Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 196 insertions, 0 deletions

diff --git a/compilerplugins/clang/test/unnecessaryoverride.cxx b/compilerplugins/clang/test/unnecessaryoverride.cxx
new file mode 100644
index 000000000..bf1e61352
--- /dev/null
+++ b/compilerplugins/clang/test/unnecessaryoverride.cxx
@@ -0,0 +1,196 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <sal/config.h>
+
+#include <config_clang.h>
+#include <o3tl/typed_flags_set.hxx>
+
+struct Base
+{
+    Base();
+    Base(Base const&);
+    virtual ~Base();
+    Base& operator=(Base const&);
+    virtual void f();
+    void variadic(int, ...);
+    void cv() const volatile;
+    void ref();
+    static void staticFn();
+    void defaults(void* = nullptr, int = 0, double = 1, Base const& = {}, char const* = "foo");
+};
+
+struct SimpleDerived : Base
+{
+    void
+    f() override // expected-error {{public virtual function just calls public parent [loplugin:unnecessaryoverride]}}
+    {
+        Base::f();
+    }
+};
+
+struct Intermediate1 : Base
+{
+};
+
+struct MultiFunctionIntermediate2 : Base
+{
+    void f() override;
+};
+
+struct MultiFunctionDerived : Intermediate1, MultiFunctionIntermediate2
+{
+    void f() override { Intermediate1::f(); } // no warning
+};
+
+struct MultiClassIntermediate2 : Base
+{
+};
+
+struct MultiClassDerived : Intermediate1, MultiClassIntermediate2
+{
+    void f() override { Intermediate1::f(); } // no warning
+};
+
+struct DerivedDifferent : Base
+{
+    void variadic(int x) { Base::variadic(x); } // no warning
+    void cv() { Base::cv(); } // no warning
+    void ref() && { Base::ref(); } // no warning
+    void staticFn() { Base::staticFn(); } // no warning
+    void defaults(void* x1, int x2, double x3, Base const& x4, char const* x5)
+    {
+        Base::defaults(x1, x2, x3, x4, x5); // no warning
+    }
+};
+
+struct DerivedSame : Base
+{
+    void
+    defaults( // expected-error {{public function just calls public parent [loplugin:unnecessaryoverride]}}
+        void* x1 = 0, int x2 = (1 - 1), double x3 = 1.0, Base const& x4 = (Base()),
+        char const* x5 = "f"
+                         "oo")
+    {
+        Base::defaults(x1, x2, x3, x4, x5);
+    }
+};
+
+struct DerivedSlightlyDifferent : Base
+{
+    void defaults( // no warning
+        void* x1 = nullptr, int x2 = 0, double x3 = 1, Base const& x4 = DerivedSlightlyDifferent(),
+        char const* x5 = "foo")
+    {
+        Base::defaults(x1, x2, x3, x4, x5);
+    }
+};
+
+enum class E
+{
+    E1 = 1,
+    E2 = 2,
+    E3 = 4
+};
+namespace o3tl
+{
+template <> struct typed_flags<E> : is_typed_flags<E, 7>
+{
+};
+}
+
+struct Base2
+{
+    void default1(Base const& = SimpleDerived());
+    void default2(Base const& = SimpleDerived());
+    void default3(Base = Base());
+    void default4(E = (E::E1 | E::E2 | E::E3));
+};
+
+struct Derived2 : Base2
+{
+    void default1(Base const& x = Intermediate1()) { Base2::default1(x); } // no warning
+    void
+    default2( // expected-error {{public function just calls public parent [loplugin:unnecessaryoverride]}}
+        Base const& x = SimpleDerived())
+    {
+        Base2::default2(x);
+    }
+    void
+    default3( // expected-error {{public function just calls public parent [loplugin:unnecessaryoverride]}}
+        Base x = Base())
+    {
+        (Base2::default3(x));
+    }
+    void
+    default4( // expected-error {{public function just calls public parent [loplugin:unnecessaryoverride]}}
+        E x = (E::E1 | E::E2 | E::E3))
+    {
+        Base2::default4(x);
+    }
+};
+
+class Base3
+{
+public:
+    void f1();
+};
+
+class Derived3 : protected Base3
+{
+public:
+    // effectively changing access from protected to public
+    void f1() { Base3::f1(); }
+};
+
+// check the case where the method occurs more than once in a direct path up the class hierarchy
+struct Base4
+{
+    void f1();
+};
+struct Derived4_1 : public Base4
+{
+    void f1();
+};
+struct Derived4_2 : public Derived4_1
+{
+    void
+    f1() // expected-error {{public function just calls public parent [loplugin:unnecessaryoverride]}}
+    {
+        Derived4_1::f1();
+    }
+};
+
+struct Base5_1
+{
+    void f1();
+};
+struct Base5_2
+{
+    void f1();
+};
+struct Derived5 : public Base5_1, public Base5_2
+{
+    void f1() { Base5_1::f1(); } // no warning expected
+};
+
+struct Base6_1
+{
+    bool f1();
+};
+struct Derived6 : public Base6_1
+{
+    bool
+    f1() // expected-error {{public function just calls public parent [loplugin:unnecessaryoverride]}}
+    {
+        bool ret = Base6_1::f1();
+        return ret;
+    }
+};
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */