A7-3-1: Ignore order of using and decl

The filter on order between overriding declaration and using was
problematic because:

 1. It produced a bad join order related to start lines.
 2. It did not check if they were in the same file.
 3. It used the wrong declaration - the order of the overriding
    declaration and the using declaration doesn't matter.

I think the intention was to confirm that the hidden declaration
appeared before the using declaration (so that it was in scope), but
errors of this kind would be identified by the
DefinitionNotConsideredForUnqualifiedLookup.ql query, so there's no
need to factor that in here.

Author: lcartey

cpp/autosar/src/rules/A7-3-1/HiddenInheritedNonOverridableMemberFunction.ql

@@ -34,8 +34,7 @@ where
   // Where the hidden member function isn't explicitly brought in scope through a using declaration.
   not exists(UsingDeclarationEntry ude |
     ude.getDeclaration() = hiddenDecl and
-    ude.getEnclosingElement() = overridingDecl.getDeclaration().getDeclaringType() and
-    ude.getLocation().getStartLine() < overridingDecl.getLocation().getStartLine()
+    ude.getEnclosingElement() = overridingDecl.getDeclaration().getDeclaringType()
   ) and
   // Exclude compiler generated member functions which include things like copy constructor that hide base class
   // copy constructors.

cpp/autosar/test/rules/A7-3-1/test.cpp

@@ -47,7 +47,7 @@ void f1() {
   l1.f1(0); // calls C2::f1(double) instead of C1::f1(int)
   l1.f2(0); // calls C2::f2(double) instead of C1::f2(int)
   // S1 s1;
-  // l1.f2(s1); Won't compile because there is no suitable conversion fro S1 to
+  // l1.f2(s1); Won't compile because there is no suitable conversion from S1 to
   // double.
   C1 &l2{l1};
   l2.f1(0); // calls C1::f1(int)
@@ -60,3 +60,20 @@ void f1() {
   S1 l4;
   l3.f2(l4); // calls C1:f2(S1)
 }
+
+class C5 : public C1 {
+public:
+  void f1(double); // COMPLIANT
+  using C1::f1;    // order of using and f1 declaration is not relevant
+
+  void f2(double) override; // COMPLIANT
+  using C1::f2;             // order of using and f1 declaration is not relevant
+};
+
+void f2() {
+  C5 c5;
+  c5.f1(0);   // calls C1::f1(int)
+  c5.f1(0.0); // calls C5::f1(double)
+  c5.f2(0);   // calls C1::f2(int)
+  c5.f2(0.0); // calls C5::f2(double)
+}