shiboken6/tests/libsample: Fix warnings about unused parameters

De-inline most offending functions so that the parameter name is
preserved in the declaration.

Pick-to: 6.3 6.2
Change-Id: I4eaf9b8691502beda5addcfd7099e3a846d5c1a2
Reviewed-by: Christian Tismer <tismer@stackless.com>
Reviewed-by: Shyamnath Premnadh <Shyamnath.Premnadh@qt.io>

32 files changed, 492 insertions, 153 deletions

diff --git a/sources/shiboken6/tests/libsample/abstract.cpp b/sources/shiboken6/tests/libsample/abstract.cpp
index 65fd651ad..7d4a21ceb 100644
--- a/sources/shiboken6/tests/libsample/abstract.cpp
+++ b/sources/shiboken6/tests/libsample/abstract.cpp
@@ -66,7 +66,7 @@ void Abstract::callVirtualGettingEnum(PrintFormat p)
     virtualGettingAEnum(p);
 }
 
-void Abstract::virtualGettingAEnum(Abstract::PrintFormat p)
+void Abstract::virtualGettingAEnum(Abstract::PrintFormat)
 {
 }
 
diff --git a/sources/shiboken6/tests/libsample/derived.cpp b/sources/shiboken6/tests/libsample/derived.cpp
index ad68d2614..87a8669ff 100644
--- a/sources/shiboken6/tests/libsample/derived.cpp
+++ b/sources/shiboken6/tests/libsample/derived.cpp
@@ -49,26 +49,22 @@ Derived::defaultValue(int n)
     return ((double) n) + 0.1;
 }
 
-OverloadedFuncEnum
-Derived::overloaded(int i, int d)
+OverloadedFuncEnum Derived::overloaded(int, int)
 {
     return OverloadedFunc_ii;
 }
 
-OverloadedFuncEnum
-Derived::overloaded(double n)
+OverloadedFuncEnum Derived::overloaded(double)
 {
     return OverloadedFunc_d;
 }
 
-Derived::OtherOverloadedFuncEnum
-Derived::otherOverloaded(int a, int b, bool c, double d)
+Derived::OtherOverloadedFuncEnum Derived::otherOverloaded(int, int, bool, double)
 {
     return OtherOverloadedFunc_iibd;
 }
 
-Derived::OtherOverloadedFuncEnum
-Derived::otherOverloaded(int a, double b)
+Derived::OtherOverloadedFuncEnum Derived::otherOverloaded(int, double)
 {
     return OtherOverloadedFunc_id;
 }
diff --git a/sources/shiboken6/tests/libsample/derived.h b/sources/shiboken6/tests/libsample/derived.h
index 5d5010857..35673198b 100644
--- a/sources/shiboken6/tests/libsample/derived.h
+++ b/sources/shiboken6/tests/libsample/derived.h
@@ -24,7 +24,7 @@ public:
     public:
         void uselessMethod() {}
         SomeInnerClass operator+(const SomeInnerClass& other) { return other; }
-        bool operator==(const SomeInnerClass& other) { return true; }
+        bool operator==(const SomeInnerClass &) { return true; }
     };
 
     Derived(int id = -1);
diff --git a/sources/shiboken6/tests/libsample/echo.h b/sources/shiboken6/tests/libsample/echo.h
index 4a655fec1..54db3e9bd 100644
--- a/sources/shiboken6/tests/libsample/echo.h
+++ b/sources/shiboken6/tests/libsample/echo.h
@@ -15,16 +15,44 @@ public:
     Echo(){}
     ~Echo(){}
 
-    void doNothingWithConstBool(const bool hi) {}
-    void methodWithNamedArg(const Str& string = Str("")) {}
+    void doNothingWithConstBool(const bool hi);
+    void methodWithNamedArg(const Str& string = Str(""));
 
     Str operator()(const Str& s, const int i) { return s + i; }
 
     // These method are here just for compilation test purposes
-    Echo& operator<<(unsigned int item) { return *this; }
-    Echo& operator<<(signed int item) { return *this; }
-    Echo& operator<<(const ObjectType* item) { return *this; }
-    Echo& operator<<(Str str) { return *this; }
+    Echo& operator<<(unsigned int item);
+    Echo& operator<<(signed int item);
+    Echo& operator<<(const ObjectType *item);
+    Echo& operator<<(Str str);
 };
 
-#endif
+inline void Echo::doNothingWithConstBool(const bool)
+{
+}
+
+inline void Echo::methodWithNamedArg(const Str &)
+{
+}
+
+inline Echo &Echo::operator<<(unsigned int)
+{
+    return *this;
+}
+
+inline Echo &Echo::operator<<(signed int)
+{
+    return *this;
+}
+
+inline Echo &Echo::operator<<(const ObjectType *)
+{
+    return *this;
+}
+
+inline Echo &Echo::operator<<(Str)
+{
+    return *this;
+}
+
+#endif // ECHO_H
diff --git a/sources/shiboken6/tests/libsample/functions.cpp b/sources/shiboken6/tests/libsample/functions.cpp
index 7325aad3a..d96a58abd 100644
--- a/sources/shiboken6/tests/libsample/functions.cpp
+++ b/sources/shiboken6/tests/libsample/functions.cpp
@@ -78,14 +78,12 @@ returnCString()
     return __FUNCTION__;
 }
 
-GlobalOverloadFuncEnum
-overloadedFunc(int val)
+GlobalOverloadFuncEnum overloadedFunc(int)
 {
     return GlobalOverloadFunc_i;
 }
 
-GlobalOverloadFuncEnum
-overloadedFunc(double val)
+GlobalOverloadFuncEnum overloadedFunc(double)
 {
     return GlobalOverloadFunc_d;
 }
diff --git a/sources/shiboken6/tests/libsample/handle.h b/sources/shiboken6/tests/libsample/handle.h
index d54dd9f11..1ef80689d 100644
--- a/sources/shiboken6/tests/libsample/handle.h
+++ b/sources/shiboken6/tests/libsample/handle.h
@@ -23,7 +23,7 @@ public:
     explicit HandleHolder(HANDLE ptr = nullptr) : m_handle(ptr) {}
     explicit HandleHolder(Foo::HANDLE val): m_handle2(val) {}
 
-    inline void set(HANDLE ptr) { HANDLE tmp; tmp = m_handle;  m_handle = tmp; }
+    void set(HANDLE ptr);
     inline void set(const Foo::HANDLE& val) { m_handle2 = val; }
     inline HANDLE handle() { return m_handle; }
     inline Foo::HANDLE handle2() { return m_handle2; }
@@ -37,6 +37,12 @@ private:
     Foo::HANDLE m_handle2;
 };
 
+inline void HandleHolder::set(HANDLE)
+{
+    HANDLE tmp = m_handle;
+    m_handle = tmp;
+}
+
 struct LIBSAMPLE_API PrimitiveStruct {};
 using PrimitiveStructPtr = struct PrimitiveStruct *;
 struct LIBSAMPLE_API PrimitiveStructPointerHolder
diff --git a/sources/shiboken6/tests/libsample/implicitconv.cpp b/sources/shiboken6/tests/libsample/implicitconv.cpp
index 054aa4b75..fad17e879 100644
--- a/sources/shiboken6/tests/libsample/implicitconv.cpp
+++ b/sources/shiboken6/tests/libsample/implicitconv.cpp
@@ -3,6 +3,11 @@
 
 #include "implicitconv.h"
 
+ImplicitConv::ImplicitConv(const Null &) :
+    m_ctorEnum(CtorPrimitiveType)
+{
+}
+
 ImplicitConv
 ImplicitConv::implicitConvCommon(ImplicitConv implicit)
 {
@@ -16,26 +21,27 @@ ImplicitConv::implicitConvDefault(ImplicitConv implicit)
 }
 
 ImplicitConv::ICOverloadedFuncEnum
-ImplicitConv::implicitConvOverloading(ImplicitConv implicit, int dummyArg)
+ImplicitConv::implicitConvOverloading(ImplicitConv, int)
 {
     return ImplicitConv::OverFunc_Ii;
 }
 
 ImplicitConv::ICOverloadedFuncEnum
-ImplicitConv::implicitConvOverloading(ImplicitConv implicit, bool dummyArg)
+ImplicitConv::implicitConvOverloading(ImplicitConv, bool)
 {
     return ImplicitConv::OverFunc_Ib;
 }
 
 ImplicitConv::ICOverloadedFuncEnum
-ImplicitConv::implicitConvOverloading(int dummyArg)
+ImplicitConv::implicitConvOverloading(int)
 {
     return ImplicitConv::OverFunc_i;
 }
 
 ImplicitConv::ICOverloadedFuncEnum
-ImplicitConv::implicitConvOverloading(CtorEnum dummyArg)
+ImplicitConv::implicitConvOverloading(CtorEnum)
 {
     return ImplicitConv::OverFunc_C;
 }
 
+
diff --git a/sources/shiboken6/tests/libsample/implicitconv.h b/sources/shiboken6/tests/libsample/implicitconv.h
index aafd919b9..bd390b15c 100644
--- a/sources/shiboken6/tests/libsample/implicitconv.h
+++ b/sources/shiboken6/tests/libsample/implicitconv.h
@@ -33,7 +33,7 @@ public:
     ImplicitConv(CtorEnum ctorEnum) : m_ctorEnum(ctorEnum), m_objId(-1), m_value(-1.0) {}
     ImplicitConv(ObjectType&) : m_ctorEnum(CtorObjectTypeReference), m_objId(-1), m_value(-1.0) {}
     ImplicitConv(double value, bool=true) : m_ctorEnum(CtorNone), m_value(value) {}
-    ImplicitConv(const Null& null) : m_ctorEnum(CtorPrimitiveType) {}
+    ImplicitConv(const Null &null);
     ~ImplicitConv() {}
 
     inline CtorEnum ctorEnum() { return m_ctorEnum; }
diff --git a/sources/shiboken6/tests/libsample/listuser.cpp b/sources/shiboken6/tests/libsample/listuser.cpp
index 574644397..6801bfdf3 100644
--- a/sources/shiboken6/tests/libsample/listuser.cpp
+++ b/sources/shiboken6/tests/libsample/listuser.cpp
@@ -50,14 +50,12 @@ ListUser::sumList(std::list<double> vallist)
     return std::accumulate(vallist.begin(), vallist.end(), 0.0);
 }
 
-ListUser::ListOfSomething
-ListUser::listOfPoints(const std::list<Point>& pointlist)
+ListUser::ListOfSomething ListUser::listOfPoints(const std::list<Point> &)
 {
     return ListOfPoint;
 }
 
-ListUser::ListOfSomething
-ListUser::listOfPoints(const std::list<PointF>& pointlist)
+ListUser::ListOfSomething ListUser::listOfPoints(const std::list<PointF> &)
 {
     return ListOfPointF;
 }
diff --git a/sources/shiboken6/tests/libsample/mapuser.cpp b/sources/shiboken6/tests/libsample/mapuser.cpp
index de96fb40e..032d465d8 100644
--- a/sources/shiboken6/tests/libsample/mapuser.cpp
+++ b/sources/shiboken6/tests/libsample/mapuser.cpp
@@ -41,6 +41,14 @@ MapUser::showMap(std::map<std::string, int> mapping)
         cout << (*it).first << " => " << (*it).second << endl;
 }
 
+void MapUser::pointerToMap(std::map<std::string, std::string> *)
+{
+}
+
+void MapUser::referenceToMap(std::map<std::string, std::string> &)
+{
+}
+
 std::map<int, std::list<std::list<double> > > MapUser::foo() const
 {
     std::map<int, std::list<std::list<double> > > result;
diff --git a/sources/shiboken6/tests/libsample/mapuser.h b/sources/shiboken6/tests/libsample/mapuser.h
index 93cbd0f1e..49318743c 100644
--- a/sources/shiboken6/tests/libsample/mapuser.h
+++ b/sources/shiboken6/tests/libsample/mapuser.h
@@ -28,8 +28,8 @@ public:
     inline std::map<std::string, std::list<int> > getMap() { return m_map; }
 
     // Compile test
-    static void pointerToMap(std::map<std::string, std::string>* arg) {}
-    static void referenceToMap(std::map<std::string, std::string>& arg) {}
+    static void pointerToMap(std::map<std::string, std::string> *arg);
+    static void referenceToMap(std::map<std::string, std::string> &arg);
 
     inline const std::map<int, ByteArray>& passMapIntValueType(const std::map<int, ByteArray>& arg) { return arg; }
 
diff --git a/sources/shiboken6/tests/libsample/modifications.cpp b/sources/shiboken6/tests/libsample/modifications.cpp
index 69481443e..8b1ba07dc 100644
--- a/sources/shiboken6/tests/libsample/modifications.cpp
+++ b/sources/shiboken6/tests/libsample/modifications.cpp
@@ -18,6 +18,67 @@ Modifications::~Modifications()
     delete m_object;
 }
 
+Modifications::OverloadedModFunc Modifications::overloaded(int, bool, Point, Point)
+{
+    return Overloaded_ibPP;
+}
+
+Modifications::OverloadedModFunc Modifications::overloaded(int, bool, int, int)
+{
+    return Overloaded_ibii;
+}
+
+Modifications::OverloadedModFunc Modifications::overloaded(int, bool, int, Point)
+{
+    return Overloaded_ibiP;
+}
+
+Modifications::OverloadedModFunc Modifications::overloaded(int, bool, int, bool)
+{
+    return Overloaded_ibib;
+}
+
+Modifications::OverloadedModFunc Modifications::overloaded(int, bool, int, double)
+{
+    return Overloaded_ibid;
+}
+
+void Modifications::argRemoval0(int, bool, int, int)
+{
+}
+
+void Modifications::argRemoval0(int, bool, int, bool)
+{
+}
+
+void Modifications::argRemoval1(int, bool, Point, Point, int)
+{
+}
+
+void Modifications::argRemoval1(int, bool, int, bool)
+{
+}
+
+void Modifications::argRemoval2(int, bool, Point, Point, int)
+{
+}
+
+void Modifications::argRemoval3(int, Point, bool, Point, int)
+{
+}
+
+void Modifications::argRemoval4(int, Point, bool, Point, int)
+{
+}
+
+void Modifications::argRemoval5(int, bool, Point, Point, int)
+{
+}
+
+void Modifications::argRemoval5(int, bool, int, bool)
+{
+}
+
 std::pair<double, double>
 Modifications::pointToPair(Point pt, bool* ok)
 {
diff --git a/sources/shiboken6/tests/libsample/modifications.h b/sources/shiboken6/tests/libsample/modifications.h
index 5caabcd9a..d757d87b9 100644
--- a/sources/shiboken6/tests/libsample/modifications.h
+++ b/sources/shiboken6/tests/libsample/modifications.h
@@ -33,26 +33,30 @@ public:
 
     // those overloaded methods should be heavily modified
     // to push the overload decisor to its limits
-    inline OverloadedModFunc overloaded(int a0, bool b0, int c0, double d0) { return Overloaded_ibid; }
-    inline OverloadedModFunc overloaded(int a1, bool b1, int c1, bool d1) { return Overloaded_ibib; }
-    inline OverloadedModFunc overloaded(int a2, bool b2, int c2, Point d2) { return Overloaded_ibiP; }
-    inline OverloadedModFunc overloaded(int a3, bool b3, int c3 = 123, int d3 = 456) { return Overloaded_ibii; }
-    inline OverloadedModFunc overloaded(int a4, bool b4, Point c4, Point d4) { return Overloaded_ibPP; }
+    OverloadedModFunc overloaded(int a0, bool b0, int c0, double d0);
+    OverloadedModFunc overloaded(int a1, bool b1, int c1, bool d1);
+    OverloadedModFunc overloaded(int a2, bool b2, int c2, Point d2);
+    OverloadedModFunc overloaded(int a3, bool b3, int c3 = 123, int d3 = 456);
+    OverloadedModFunc overloaded(int a4, bool b4, Point c4, Point d4);
 
-    inline void argRemoval0(int a0, bool a1, int a2 = 123, int a3 = 456) {}
-    inline void argRemoval0(int a0, bool a1, int a2, bool a3) {}
+    void argRemoval0(int a0, bool a1, int a2 = 123, int a3 = 456);
+    void argRemoval0(int a0, bool a1, int a2, bool a3);
 
-    inline void argRemoval1(int a0, bool a1, Point a2 = Point(1, 2), Point a3 = Point(3, 4), int a4 = 333) {}
-    inline void argRemoval1(int a0, bool a1, int a2, bool a3) {}
+    void argRemoval1(int a0, bool a1, Point a2 = Point(1, 2), Point a3 = Point(3, 4),
+                     int a4 = 333);
+    void argRemoval1(int a0, bool a1, int a2, bool a3);
 
-    inline void argRemoval2(int a0, bool a1, Point a2 = Point(1, 2), Point a3 = Point(3, 4), int a4 = 333) {}
+    void argRemoval2(int a0, bool a1, Point a2 = Point(1, 2), Point a3 = Point(3, 4),
+                     int a4 = 333);
 
-    inline void argRemoval3(int a0, Point a1 = Point(1, 2), bool a2 = true, Point a3 = Point(3, 4), int a4 = 333) {}
+    void argRemoval3(int a0, Point a1 = Point(1, 2), bool a2 = true, Point a3 = Point(3, 4),
+                     int a4 = 333);
 
-    inline void argRemoval4(int a0, Point a1, bool a2, Point a3 = Point(3, 4), int a4 = 333) {}
+    void argRemoval4(int a0, Point a1, bool a2, Point a3 = Point(3, 4), int a4 = 333);
 
-    inline void argRemoval5(int a0, bool a1, Point a2 = Point(1, 2), Point a3 = Point(3, 4), int a4 = 333) {}
-    inline void argRemoval5(int a0, bool a1, int a2, bool a3) {}
+    void argRemoval5(int a0, bool a1, Point a2 = Point(1, 2), Point a3 = Point(3, 4),
+                     int a4 = 333);
+    void argRemoval5(int a0, bool a1, int a2, bool a3);
 
     // 'ok' must be removed and the return value will be changed
     // to a tuple (PyObject*) containing the expected result plus
diff --git a/sources/shiboken6/tests/libsample/objectmodel.cpp b/sources/shiboken6/tests/libsample/objectmodel.cpp
index 7ba762d36..a211d2969 100644
--- a/sources/shiboken6/tests/libsample/objectmodel.cpp
+++ b/sources/shiboken6/tests/libsample/objectmodel.cpp
@@ -15,3 +15,12 @@ ObjectModel::data() const
     return m_data;
 }
 
+ObjectModel::MethodCalled ObjectModel::receivesObjectTypeFamily(const ObjectModel &)
+{
+    return ObjectModel::ObjectModelCalled;
+}
+
+ObjectModel::MethodCalled ObjectModel::receivesObjectTypeFamily(const ObjectType &)
+{
+    return ObjectModel::ObjectTypeCalled;
+}
diff --git a/sources/shiboken6/tests/libsample/objectmodel.h b/sources/shiboken6/tests/libsample/objectmodel.h
index 6f99c41e0..063404460 100644
--- a/sources/shiboken6/tests/libsample/objectmodel.h
+++ b/sources/shiboken6/tests/libsample/objectmodel.h
@@ -20,8 +20,8 @@ public:
     // The MethodCalled enum and related static methods were created to
     // test bug #630 [http://bugs.openbossa.org/show_bug.cgi?id=630]
     enum MethodCalled { ObjectTypeCalled, ObjectModelCalled };
-    static MethodCalled receivesObjectTypeFamily(const ObjectType& object) { return ObjectModel::ObjectTypeCalled; }
-    static MethodCalled receivesObjectTypeFamily(const ObjectModel& object) { return ObjectModel::ObjectModelCalled; }
+    static MethodCalled receivesObjectTypeFamily(const ObjectType &object);
+    static MethodCalled receivesObjectTypeFamily(const ObjectModel &object);
 
 private:
     // The model holds only one piece of data.
diff --git a/sources/shiboken6/tests/libsample/objecttype.cpp b/sources/shiboken6/tests/libsample/objecttype.cpp
index 03c677104..1e3920734 100644
--- a/sources/shiboken6/tests/libsample/objecttype.cpp
+++ b/sources/shiboken6/tests/libsample/objecttype.cpp
@@ -133,8 +133,7 @@ ObjectType::causeEvent(Event::EventType eventType)
     return event(&e);
 }
 
-bool
-ObjectType::event(Event* event)
+bool ObjectType::event(Event *)
 {
     return true;
 }
@@ -154,6 +153,10 @@ ObjectType::callInvalidateEvent(Event* event)
     invalidateEvent(event);
 }
 
+void ObjectType::invalidateEvent(Event *)
+{
+}
+
 void
 ObjectType::setLayout(ObjectTypeLayout* l)
 {
@@ -205,13 +208,13 @@ objectTypeHash(const ObjectType* objectType)
     return reinterpret_cast<std::size_t>(objectType);
 }
 
-unsigned char
-ObjectType::callWithEnum(const Str& prefix, Event::EventType type, unsigned char value){
+unsigned char ObjectType::callWithEnum(const Str &, Event::EventType, unsigned char value)
+{
     return value*value;
 }
 
-unsigned char
-ObjectType::callWithEnum(const Str& prefix, unsigned char value) {
+unsigned char ObjectType::callWithEnum(const Str &, unsigned char value)
+{
     return value;
 }
 
@@ -280,8 +283,7 @@ ObjectTypeDerived::~ObjectTypeDerived()
 {
 }
 
-bool
-ObjectTypeDerived::event(Event* event)
+bool ObjectTypeDerived::event(Event *)
 {
     return true;
 }
diff --git a/sources/shiboken6/tests/libsample/objecttype.h b/sources/shiboken6/tests/libsample/objecttype.h
index 798b932f9..0f732a60a 100644
--- a/sources/shiboken6/tests/libsample/objecttype.h
+++ b/sources/shiboken6/tests/libsample/objecttype.h
@@ -76,7 +76,7 @@ public:
     static int processEvent(ObjectTypeList objects, Event *event);
 
     void callInvalidateEvent(Event* event);
-    virtual void invalidateEvent(Event* event) {}
+    virtual void invalidateEvent(Event *event);
 
     // This nonsense method emulate QWidget.setLayout method
     // All layout objects will became children of this object.
diff --git a/sources/shiboken6/tests/libsample/objecttypebyvalue.h b/sources/shiboken6/tests/libsample/objecttypebyvalue.h
index ff981b517..0d7ac0160 100644
--- a/sources/shiboken6/tests/libsample/objecttypebyvalue.h
+++ b/sources/shiboken6/tests/libsample/objecttypebyvalue.h
@@ -10,12 +10,20 @@ class ObjectTypeByValue
 {
 public:
     ObjectTypeByValue returnSomeKindOfMe() { return ObjectTypeByValue(); }
-    void acceptKindOfMeAsValue(ObjectTypeByValue kindOfMe) {}
+    void acceptKindOfMeAsValue(ObjectTypeByValue kindOfMe);
 
-    void acceptListOfObjectTypeByValue(std::list<ObjectTypeByValue> listOfMe) {}
+    void acceptListOfObjectTypeByValue(std::list<ObjectTypeByValue> listOfMe);
 
     // prop used to check for segfaults
     ProtectedProperty prop;
 };
 
-#endif
+inline void ObjectTypeByValue::acceptKindOfMeAsValue(ObjectTypeByValue)
+{
+}
+
+inline void ObjectTypeByValue::acceptListOfObjectTypeByValue(std::list<ObjectTypeByValue>)
+{
+}
+
+#endif // OBJECTTYPEBYVALUE_H
diff --git a/sources/shiboken6/tests/libsample/overload.cpp b/sources/shiboken6/tests/libsample/overload.cpp
index c0dfd820a..d533b4014 100644
--- a/sources/shiboken6/tests/libsample/overload.cpp
+++ b/sources/shiboken6/tests/libsample/overload.cpp
@@ -8,18 +8,194 @@ Overload::FunctionEnum Overload::overloaded()
     return Function0;
 }
 
-Overload::FunctionEnum Overload::overloaded(Size* size)
+Overload::FunctionEnum Overload::overloaded(Size *)
 {
     return Function1;
 }
 
-Overload::FunctionEnum Overload::overloaded(Point* point, ParamEnum param)
+Overload::FunctionEnum Overload::overloaded(Point *, ParamEnum)
 {
     return Function2;
 }
 
-Overload::FunctionEnum Overload::overloaded(const Point& point)
+Overload::FunctionEnum Overload::overloaded(const Point &)
 {
     return Function3;
 }
 
+void Overload::differentReturnTypes(ParamEnum)
+{
+
+}
+
+int Overload::differentReturnTypes(ParamEnum, int val)
+{
+    return val;
+}
+
+int Overload::intOverloads(const Point &, double)
+{
+    return 1; }
+
+int Overload::intOverloads(int, int)
+{
+    return 2; }
+
+int Overload::intOverloads(int, int, double)
+{
+    return 3;
+}
+
+Overload::FunctionEnum Overload::intDoubleOverloads(double, double) const
+{
+    return Function1;
+}
+
+Overload::FunctionEnum Overload::intDoubleOverloads(int, int) const
+{
+    return Function0;
+}
+
+void Overload::singleOverload(Point *)
+{
+}
+
+Overload::FunctionEnum Overload::wrapperIntIntOverloads(const Polygon &, int, int)
+{
+    return Function1;
+}
+
+Overload::FunctionEnum Overload::wrapperIntIntOverloads(const Point &, int, int)
+{
+    return Function0;
+}
+
+Overload::FunctionEnum Overload::strBufferOverloads(const Str &, const char *, bool)
+{
+    return Function0;
+}
+
+Overload::FunctionEnum Overload::strBufferOverloads(unsigned char *, int)
+{
+    return Function1;
+}
+
+Overload::FunctionEnum Overload::drawText(const PointF &, const Str &)
+{
+    return Function1;
+}
+
+Overload::FunctionEnum Overload::drawText(const Point &, const Str &)
+{
+    return Function0;
+}
+
+Overload::FunctionEnum Overload::drawText(const RectF &, const Str &, const Echo &)
+{
+    return Function4;
+}
+
+Overload::FunctionEnum Overload::drawText(const RectF &, int, const Str &)
+{
+    return Function3;
+}
+
+Overload::FunctionEnum Overload::drawText(const Rect &, int, const Str &)
+{
+    return Function2;
+}
+
+Overload::FunctionEnum Overload::drawText(int, int, const Str &)
+{
+    return Function5;
+}
+
+Overload::FunctionEnum Overload::drawText(int, int, int, int, int, const Str &)
+{
+    return Function6;
+}
+
+Overload::FunctionEnum Overload::drawText2(const PointF &, const Str &)
+{
+    return Function1;
+}
+
+Overload::FunctionEnum Overload::drawText2(const Point &, const Str &)
+{
+    return Function0;
+}
+
+Overload::FunctionEnum Overload::drawText2(int, int, const Str &)
+{
+    return Function5;
+}
+
+Overload::FunctionEnum Overload::drawText2(const RectF &, const Str &, const Echo &)
+{
+    return Function4;
+}
+
+Overload::FunctionEnum Overload::drawText2(const RectF &, int, const Str &)
+{
+    return Function3;
+}
+
+Overload::FunctionEnum Overload::drawText2(const Rect &, int, const Str &)
+{
+    return Function2;
+}
+
+Overload::FunctionEnum Overload::drawText2(int, int, int, int, int, const Str &)
+{
+    return Function6;
+}
+
+Overload::FunctionEnum Overload::drawText3(const Str &, const Str &, const Str &)
+{
+    return Function0;
+}
+
+Overload::FunctionEnum Overload::drawText3(int, int, int, int, int)
+{
+    return Function1;
+}
+
+Overload::FunctionEnum Overload::drawText4(int, int, int)
+{
+    return Function0;
+}
+
+Overload::FunctionEnum Overload::drawText4(int, int, int, int, int)
+{
+    return Function1;
+}
+
+Overload::FunctionEnum Overload::acceptSequence()
+{
+    return Function0;
+}
+
+Overload::FunctionEnum Overload::acceptSequence(const Str &, ParamEnum)
+{
+    return Function2;
+}
+
+Overload::FunctionEnum Overload::acceptSequence(int, int)
+{
+    return Function1;
+}
+
+Overload::FunctionEnum Overload::acceptSequence(void *)
+{
+    return Function5;
+}
+
+Overload::FunctionEnum Overload::acceptSequence(const char *const[])
+{
+    return Function4;
+}
+
+Overload::FunctionEnum Overload::acceptSequence(const Size &)
+{
+    return Function3;
+}
diff --git a/sources/shiboken6/tests/libsample/overload.h b/sources/shiboken6/tests/libsample/overload.h
index 29a6c575f..91de8a963 100644
--- a/sources/shiboken6/tests/libsample/overload.h
+++ b/sources/shiboken6/tests/libsample/overload.h
@@ -40,61 +40,63 @@ public:
     FunctionEnum overloaded(Point* point, ParamEnum param);
     FunctionEnum overloaded(const Point& point);
 
-    inline void differentReturnTypes(ParamEnum param = Param0) {}
-    inline int differentReturnTypes(ParamEnum param, int val) { return val; }
+    void differentReturnTypes(ParamEnum param = Param0);
+    int differentReturnTypes(ParamEnum param, int val);
 
-    inline int intOverloads(const Point& p, double d) { return 1; }
-    inline int intOverloads(int i, int i2) { return 2; }
-    inline int intOverloads(int i, int removedArg, double d) { return 3; }
+    int intOverloads(const Point &p, double d);
+    int intOverloads(int i, int i2);
+    int intOverloads(int i, int removedArg, double d);
 
-    inline FunctionEnum intDoubleOverloads(int a0, int a1) const { return Function0; }
-    inline FunctionEnum intDoubleOverloads(double a0, double a1) const { return Function1; }
+    FunctionEnum intDoubleOverloads(int a0, int a1) const;
+    FunctionEnum intDoubleOverloads(double a0, double a1) const;
 
-    void singleOverload(Point* x) {}
+    void singleOverload(Point *x);
     Point* singleOverload() {return new Point();}
 
     // Similar to QImage::trueMatrix(QMatrix,int,int) and QImage::trueMatrix(QTransform,int,int)
-    FunctionEnum wrapperIntIntOverloads(const Point& arg0, int arg1, int arg2) { return Function0; }
-    FunctionEnum wrapperIntIntOverloads(const Polygon& arg0, int arg1, int arg2) { return Function1; }
+    FunctionEnum wrapperIntIntOverloads(const Point &arg0, int arg1, int arg2);
+    FunctionEnum wrapperIntIntOverloads(const Polygon &arg0, int arg1, int arg2);
 
     // Similar to QImage constructor
-    FunctionEnum strBufferOverloads(const Str &arg0, const char *arg1 = nullptr, bool arg2 = true) { return Function0; }
-    FunctionEnum strBufferOverloads(unsigned char* arg0, int arg1) { return Function1; }
+    FunctionEnum strBufferOverloads(const Str &arg0, const char *arg1 = nullptr,
+                                    bool arg2 = true);
+    FunctionEnum strBufferOverloads(unsigned char* arg0, int arg1);
     FunctionEnum strBufferOverloads() { return Function2; }
 
     // Similar to QPainter::drawText(...)
-    FunctionEnum drawText(const Point& a0, const Str& a1) { return Function0; }
-    FunctionEnum drawText(const PointF& a0, const Str& a1) { return Function1; }
-    FunctionEnum drawText(const Rect& a0, int a1, const Str& a2) { return Function2; }
-    FunctionEnum drawText(const RectF& a0, int a1, const Str& a2) { return Function3; }
-    FunctionEnum drawText(const RectF& a0, const Str& a1, const Echo& a2 = Echo()) { return Function4; }
-    FunctionEnum drawText(int a0, int a1, const Str& a2) { return Function5; }
-    FunctionEnum drawText(int a0, int a1, int a2, int a3, int a4, const Str& a5) { return Function6; }
+    FunctionEnum drawText(const Point &a0, const Str &a1);
+    FunctionEnum drawText(const PointF &a0, const Str &a1);
+    FunctionEnum drawText(const Rect &a0, int a1, const Str &a2);
+    FunctionEnum drawText(const RectF &a0, int a1, const Str &a2);
+    FunctionEnum drawText(const RectF &a0, const Str &a1, const Echo &a2 = Echo());
+    FunctionEnum drawText(int a0, int a1, const Str &a2);
+    FunctionEnum drawText(int a0, int a1, int a2, int a3, int a4, const Str &a5);
 
     // A variant of the one similar to QPainter::drawText(...)
-    FunctionEnum drawText2(const Point& a0, const Str& a1) { return Function0; }
-    FunctionEnum drawText2(const PointF& a0, const Str& a1) { return Function1; }
-    FunctionEnum drawText2(const Rect& a0, int a1, const Str& a2) { return Function2; }
-    FunctionEnum drawText2(const RectF& a0, int a1, const Str& a2) { return Function3; }
-    FunctionEnum drawText2(const RectF& a0, const Str& a1, const Echo& a2 = Echo()) { return Function4; }
-    FunctionEnum drawText2(int a0, int a1, const Str& a2) { return Function5; }
-    FunctionEnum drawText2(int a0, int a1, int a2, int a3 = 0, int a4 = 0, const Str& a5 = Str()) { return Function6; }
+    FunctionEnum drawText2(const Point &a0, const Str &a1);
+    FunctionEnum drawText2(const PointF &a0, const Str &a1);
+    FunctionEnum drawText2(const Rect &a0, int a1, const Str &a2);
+    FunctionEnum drawText2(const RectF &a0, int a1, const Str &a2);
+    FunctionEnum drawText2(const RectF &a0, const Str &a1, const Echo &a2 = Echo());
+    FunctionEnum drawText2(int a0, int a1, const Str &a2);
+    FunctionEnum drawText2(int a0, int a1, int a2, int a3 = 0, int a4 = 0,
+                           const Str &a5 = Str());
 
     // A simpler variant of the one similar to QPainter::drawText(...)
-    FunctionEnum drawText3(const Str& a0, const Str& a1, const Str& a2) { return Function0; }
-    FunctionEnum drawText3(int a0, int a1, int a2, int a3, int a4) { return Function1; }
+    FunctionEnum drawText3(const Str &a0, const Str &a1, const Str &a2);
+    FunctionEnum drawText3(int a0, int a1, int a2, int a3, int a4);
 
     // Another simpler variant of the one similar to QPainter::drawText(...)
-    FunctionEnum drawText4(int a0, int a1, int a2) { return Function0; }
-    FunctionEnum drawText4(int a0, int a1, int a2, int a3, int a4) { return Function1; }
+    FunctionEnum drawText4(int a0, int a1, int a2);
+    FunctionEnum drawText4(int a0, int a1, int a2, int a3, int a4);
 
-    FunctionEnum acceptSequence() { return Function0; }
-    FunctionEnum acceptSequence(int a0, int a1) { return Function1; }
-    FunctionEnum acceptSequence(const Str& a0, ParamEnum a1 = Param0) { return Function2; }
-    FunctionEnum acceptSequence(const Size& a0) { return Function3; }
+    FunctionEnum acceptSequence();
+    FunctionEnum acceptSequence(int a0, int a1);
+    FunctionEnum acceptSequence(const Str &a0, ParamEnum a1 = Param0);
+    FunctionEnum acceptSequence(const Size &a0);
     // The type must be changed to PySequence.
-    FunctionEnum acceptSequence(const char* const a0[]) { return Function4; }
-    FunctionEnum acceptSequence(void* a0) { return Function5; }
+    FunctionEnum acceptSequence(const char* const a0[]);
+    FunctionEnum acceptSequence(void *a0);
 };
 
 class LIBSAMPLE_API Overload2 : public Overload
@@ -115,4 +117,3 @@ private:
 };
 
 #endif // OVERLOAD_H
-
diff --git a/sources/shiboken6/tests/libsample/overloadsort.cpp b/sources/shiboken6/tests/libsample/overloadsort.cpp
index 9857f6e86..a9b4b0972 100644
--- a/sources/shiboken6/tests/libsample/overloadsort.cpp
+++ b/sources/shiboken6/tests/libsample/overloadsort.cpp
@@ -3,6 +3,41 @@
 
 #include "overloadsort.h"
 
+const char *SortedOverload::overload(int)
+{
+    return "int";
+}
+
+const char *SortedOverload::overload(double)
+{
+    return "double";
+}
+
+const char *SortedOverload::overload(ImplicitBase)
+{
+    return "ImplicitBase";
+}
+
+const char *SortedOverload::overload(ImplicitTarget)
+{
+    return "ImplicitTarget";
+}
+
+const char *SortedOverload::overload(const std::list<ImplicitBase> &)
+{
+    return "list(ImplicitBase)";
+}
+
+int SortedOverload::implicit_overload(const ImplicitBase &)
+{
+    return 1;
+}
+
+const char *SortedOverload::overloadDeep(int, ImplicitBase &)
+{
+    return "ImplicitBase";
+}
+
 int CustomOverloadSequence::overload(short v) const
 {
     return v + int(sizeof(v));
diff --git a/sources/shiboken6/tests/libsample/overloadsort.h b/sources/shiboken6/tests/libsample/overloadsort.h
index d0d70b8f3..473828da9 100644
--- a/sources/shiboken6/tests/libsample/overloadsort.h
+++ b/sources/shiboken6/tests/libsample/overloadsort.h
@@ -18,41 +18,26 @@ class ImplicitBase
 {
 public:
     ImplicitBase(){}
-    ImplicitBase(const ImplicitTarget &b){}
+    ImplicitBase(const ImplicitTarget &b);
 };
 
-class SortedOverload
+inline ImplicitBase::ImplicitBase(const ImplicitTarget &)
 {
-public:
-
-    inline const char *overload(int x) {
-        return "int";
-    }
-
-    inline const char *overload(double x) {
-        return "double";
-    }
-
-    inline const char *overload(ImplicitBase x) {
-        return "ImplicitBase";
-    }
+}
 
-    inline const char *overload(ImplicitTarget x) {
-        return "ImplicitTarget";
-    }
-
-    inline const char *overload(const std::list<ImplicitBase> &x) {
-        return "list(ImplicitBase)";
-    }
+class LIBSAMPLE_API SortedOverload
+{
+public:
 
-    inline int implicit_overload(const ImplicitBase &x) {
-        return 1;
-    }
+    const char *overload(int x);
+    const char *overload(double x);
+    const char *overload(ImplicitBase x);
+    const char *overload(ImplicitTarget x);
+    const char *overload(const std::list<ImplicitBase> &x);
 
-    inline const char *overloadDeep(int x, ImplicitBase &y) {
-        return "ImplicitBase";
-    }
+    int implicit_overload(const ImplicitBase &x);
 
+    const char *overloadDeep(int x, ImplicitBase &y);
 
     inline const char* pyObjOverload(int, int) { return "int,int"; }
     inline const char* pyObjOverload(unsigned char*, int) { return "PyObject,int"; }
diff --git a/sources/shiboken6/tests/libsample/pen.cpp b/sources/shiboken6/tests/libsample/pen.cpp
index fd1fee877..8e216323f 100644
--- a/sources/shiboken6/tests/libsample/pen.cpp
+++ b/sources/shiboken6/tests/libsample/pen.cpp
@@ -3,11 +3,11 @@
 
 #include "pen.h"
 
-Color::Color(SampleNamespace::InValue arg) : m_null(false)
+Color::Color(SampleNamespace::InValue) : m_null(false)
 {
 }
 
-Color::Color(unsigned int arg) : m_null(false)
+Color::Color(unsigned int) : m_null(false)
 {
 }
 
@@ -49,15 +49,15 @@ Pen::Pen() : m_ctor(EmptyCtor)
 {
 }
 
-Pen::Pen(SampleNamespace::Option option) : m_ctor(EnumCtor)
+Pen::Pen(SampleNamespace::Option) : m_ctor(EnumCtor)
 {
 }
 
-Pen::Pen(const Color& color) : m_ctor(ColorCtor)
+Pen::Pen(const Color &) : m_ctor(ColorCtor)
 {
 }
 
-Pen::Pen(const Pen& pen) : m_ctor(CopyCtor)
+Pen::Pen(const Pen &) : m_ctor(CopyCtor)
 {
 }
 
@@ -70,7 +70,7 @@ int Pen::ctorType()
     return m_ctor;
 }
 
-void Pen::drawLine(int x1, int y1, int x2, int y2, RenderHints renderHints)
+void Pen::drawLine(int, int, int, int, RenderHints)
 {
 }
 
diff --git a/sources/shiboken6/tests/libsample/protected.cpp b/sources/shiboken6/tests/libsample/protected.cpp
index f6cdb3db1..7ab52d22b 100644
--- a/sources/shiboken6/tests/libsample/protected.cpp
+++ b/sources/shiboken6/tests/libsample/protected.cpp
@@ -5,3 +5,12 @@
 
 int ProtectedVirtualDestructor::dtor_called = 0;
 
+const char *ProtectedNonPolymorphic::dataTypeName(void *) const
+{
+    return "pointer";
+}
+
+const char *ProtectedNonPolymorphic::dataTypeName(int) const
+{
+    return "integer";
+}
diff --git a/sources/shiboken6/tests/libsample/protected.h b/sources/shiboken6/tests/libsample/protected.h
index 1efad9044..5f2c788fb 100644
--- a/sources/shiboken6/tests/libsample/protected.h
+++ b/sources/shiboken6/tests/libsample/protected.h
@@ -25,8 +25,8 @@ protected:
     inline int protectedSum(int a0, int a1) { return a0 + a1; }
     inline int modifiedProtectedSum(int a0, int a1) { return a0 + a1; }
     inline static const char* protectedStatic() { return "protectedStatic"; }
-    inline const char* dataTypeName(void *data = nullptr) const { return "pointer"; }
-    inline const char* dataTypeName(int data) const { return "integer"; }
+    const char *dataTypeName(void *data = nullptr) const;
+    const char *dataTypeName(int data) const;
 
 private:
     std::string m_name;
diff --git a/sources/shiboken6/tests/libsample/reference.cpp b/sources/shiboken6/tests/libsample/reference.cpp
index d3c1f882c..25db84bfd 100644
--- a/sources/shiboken6/tests/libsample/reference.cpp
+++ b/sources/shiboken6/tests/libsample/reference.cpp
@@ -12,6 +12,11 @@ Reference::show() const
     cout << "Reference.objId: " << m_objId << ", address: " << this;
 }
 
+Reference &Reference::returnMySecondArg(int, Reference &ref)
+{
+    return ref;
+}
+
 int
 Reference::usesReferenceVirtual(Reference& r, int inc)
 {
@@ -51,3 +56,8 @@ Reference::callAlterReferenceIdVirtual(Reference& r)
 ObjTypeReference::~ObjTypeReference()
 {
 }
+
+ObjTypeReference &ObjTypeReference::returnMySecondArg(int, ObjTypeReference &ref)
+{
+    return ref;
+}
diff --git a/sources/shiboken6/tests/libsample/reference.h b/sources/shiboken6/tests/libsample/reference.h
index d4b7ce2cf..1dc7aaf7c 100644
--- a/sources/shiboken6/tests/libsample/reference.h
+++ b/sources/shiboken6/tests/libsample/reference.h
@@ -33,7 +33,7 @@ public:
     inline static int multiplier() { return 10; }
 
     virtual Reference& returnMyFirstArg(Reference& ref) { return ref; }
-    virtual Reference& returnMySecondArg(int a, Reference& ref) { return ref; }
+    virtual Reference& returnMySecondArg(int a, Reference &ref);
 
     // nonsense operator to test if Shiboken is ignoring dereference operators.
     int operator*() { return m_objId; }
@@ -48,7 +48,7 @@ public:
     ObjTypeReference(const ObjTypeReference&) {}
     virtual ~ObjTypeReference();
     virtual ObjTypeReference& returnMyFirstArg(ObjTypeReference& ref) { return ref; }
-    virtual ObjTypeReference& returnMySecondArg(int a, ObjTypeReference& ref) { return ref; }
+    virtual ObjTypeReference &returnMySecondArg(int a, ObjTypeReference &ref);
     virtual ObjTypeReference& justAPureVirtualFunc(ObjTypeReference& ref) = 0;
 };
 
diff --git a/sources/shiboken6/tests/libsample/samplenamespace.cpp b/sources/shiboken6/tests/libsample/samplenamespace.cpp
index bb38e66c9..8d1fa888f 100644
--- a/sources/shiboken6/tests/libsample/samplenamespace.cpp
+++ b/sources/shiboken6/tests/libsample/samplenamespace.cpp
@@ -61,8 +61,7 @@ getNumber(Option opt)
     return retval;
 }
 
-void
-doSomethingWithArray(const unsigned char* data, unsigned int size, const char* format)
+void doSomethingWithArray(const unsigned char *, unsigned int, const char *)
 {
     // This function does nothing in fact.
     // It is here as a dummy copy of QPixmap.loadFromData method
@@ -75,23 +74,19 @@ enumItemAsDefaultValueToIntArgument(int value)
     return value;
 }
 
-void
-forceDecisorSideA(ObjectType* object)
+void forceDecisorSideA(ObjectType *)
 {
 }
 
-void
-forceDecisorSideA(const Point& pt, const Str& text, ObjectType* object)
+void forceDecisorSideA(const Point &, const Str &, ObjectType *)
 {
 }
 
-void
-forceDecisorSideB(int a, ObjectType* object)
+void forceDecisorSideB(int, ObjectType *)
 {
 }
 
-void
-forceDecisorSideB(int a, const Point& pt, const Str& text, ObjectType* object)
+void forceDecisorSideB(int, const Point &, const Str &, ObjectType *)
 {
 }
 
diff --git a/sources/shiboken6/tests/libsample/sometime.cpp b/sources/shiboken6/tests/libsample/sometime.cpp
index 7f9bc24c3..22c894c9a 100644
--- a/sources/shiboken6/tests/libsample/sometime.cpp
+++ b/sources/shiboken6/tests/libsample/sometime.cpp
@@ -31,8 +31,7 @@ Time::somethingCompletelyDifferent()
     return ZeroArgs;
 }
 
-Time::NumArgs
-Time::somethingCompletelyDifferent(int h, int m, ImplicitConv ic, ObjectType* type)
+Time::NumArgs Time::somethingCompletelyDifferent(int, int, ImplicitConv ic, ObjectType *type)
 {
     if (type)
         return FourArgs;
diff --git a/sources/shiboken6/tests/libsample/templateptr.cpp b/sources/shiboken6/tests/libsample/templateptr.cpp
index 44be79cfc..a73f78417 100644
--- a/sources/shiboken6/tests/libsample/templateptr.cpp
+++ b/sources/shiboken6/tests/libsample/templateptr.cpp
@@ -3,6 +3,6 @@
 
 #include "templateptr.h"
 
-void TemplatePtr::dummy(std::list<std::pair<BlackBox *, BlackBox *> > & items)
+void TemplatePtr::dummy(std::list<std::pair<BlackBox *, BlackBox *> > &)
 {
 }
diff --git a/sources/shiboken6/tests/libsample/virtualmethods.cpp b/sources/shiboken6/tests/libsample/virtualmethods.cpp
index 6c7b4a004..fa2247a69 100644
--- a/sources/shiboken6/tests/libsample/virtualmethods.cpp
+++ b/sources/shiboken6/tests/libsample/virtualmethods.cpp
@@ -32,6 +32,11 @@ VirtualMethods::getMargins(int* left, int* top, int* right, int* bottom) const
     *bottom = m_bottom;
 }
 
+int VirtualMethods::recursionOnModifiedVirtual(Str) const
+{
+    return 0;
+}
+
 const Str & VirtualMethods::returnConstRef() const
 {
     static const Str result;
diff --git a/sources/shiboken6/tests/libsample/virtualmethods.h b/sources/shiboken6/tests/libsample/virtualmethods.h
index c6ff560fc..5a1438a4a 100644
--- a/sources/shiboken6/tests/libsample/virtualmethods.h
+++ b/sources/shiboken6/tests/libsample/virtualmethods.h
@@ -81,7 +81,7 @@ public:
         getMargins(left, top, right, bottom);
     }
 
-    virtual int recursionOnModifiedVirtual(Str arg) const { return 0; }
+    virtual int recursionOnModifiedVirtual(Str arg) const;
     int callRecursionOnModifiedVirtual(Str arg) const { return recursionOnModifiedVirtual(arg); }
 
     virtual const Str & returnConstRef() const;