Functions declared in a scope should not hide previous declaration in earlier scopes

[ogoffart]

Summary

This code should be an error:

void foo(int); 
void f3() {
  int foo(float);
  {
    float foo(int); // expected-error {{functions that differ only in their return type cannot be overloaded}}
  }
}

the foo(float) function declared at function scope should not hide the float(int) while trying to redeclare functions.

[ogoffart]

Ping.
This would be required for http://reviews.llvm.org/D19764

[rsmith]

lib/Sema/SemaLookup.cpp

1091 ↗

(On Diff #55712)

Please rename this to something like SearchNamespaceScope (and invert the sense of it) to reflect what it now means.

cfe/trunk/lib/Sema/SemaLookup.cpp

bool Sema::CppLookupName(LookupResult &R, Scope *S) {
   bool LeftStartingScope = false;
   DeclContext *OutsideOfTemplateParamDC = nullptr;
 
   // When performing a scope lookup, we want to find local extern decls.
   FindLocalExternScope FindLocals(R);
 
   for (; S && !isNamespaceOrTranslationUnitScope(S); S = S->getParent()) {
     DeclContext *Ctx = S->getEntity();
-
+    bool SearchNamespaceScope = true;
     // Check whether the IdResolver has anything in this scope.
-    bool Found = false;
     for (; I != IEnd && S->isDeclScope(*I); ++I) {
       if (NamedDecl *ND = R.getAcceptableDecl(*I)) {
-        if (NameKind == LookupRedeclarationWithLinkage) {
+        if (NameKind == LookupRedeclarationWithLinkage &&
+            !(*I)->isTemplateParameter()) {
+          // If it's a template parameter, we still find it, so we can diagnose
+          // the invalid redeclaration.
+
           // Determine whether this (or a previous) declaration is
           // out-of-scope.
           if (!LeftStartingScope && !Initial->isDeclScope(*I))
             LeftStartingScope = true;
 
           // If we found something outside of our starting scope that
-          // does not have linkage, skip it. If it's a template parameter,
-          // we still find it, so we can diagnose the invalid redeclaration.
-          if (LeftStartingScope && !((*I)->hasLinkage()) &&
-              !(*I)->isTemplateParameter()) {
+          // does not have linkage, skip it.
+          if (LeftStartingScope && !((*I)->hasLinkage())) {
             R.setShadowed();
             continue;
           }
+        } else {
+          // We found something in this scope, we should not look at the
+          // namespace scope
+          SearchNamespaceScope = false;
         }
-
-        Found = true;
         R.addDecl(ND);
       }
     }
-    if (Found) {
+    if (!SearchNamespaceScope) {
       R.resolveKind();
       if (S->isClassScope())
         if (CXXRecordDecl *Record = dyn_cast_or_null<CXXRecordDecl>(Ctx))
           R.setNamingClass(Record);
       return true;
     }
 
     if (NameKind == LookupLocalFriendName && !S->isClassScope()) {

cfe/trunk/test/SemaCXX/function-redecl.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 int foo(int);
 
 namespace N {
   void f1() {
     void foo(int); // okay
     void bar(int); // expected-note 2{{previous declaration is here}}
   }
 
-  void foo(int); // expected-note 2{{previous declaration is here}}
+  void foo(int); // expected-note 3{{previous declaration is here}}
 
   void f2() {
     int foo(int); // expected-error {{functions that differ only in their return type cannot be overloaded}}
     int bar(int); // expected-error {{functions that differ only in their return type cannot be overloaded}}
     int baz(int); // expected-note {{previous declaration is here}}
 
     {
       int foo;
       int bar;
       int baz;
       {
         float foo(int); // expected-error {{functions that differ only in their return type cannot be overloaded}}
         float bar(int); // expected-error {{functions that differ only in their return type cannot be overloaded}}
         float baz(int); // expected-error {{functions that differ only in their return type cannot be overloaded}}
       }
     }
   }
+
+  void f3() {
+    int foo(float);
+    {
+      float foo(int); // expected-error {{functions that differ only in their return type cannot be overloaded}}
+    }
+  }
 }
 
 class A {
  void typocorrection(); // expected-note {{'typocorrection' declared here}}
 };
 
 void A::Notypocorrection() { // expected-error {{out-of-line definition of 'Notypocorrection' does not match any declaration in 'A'; did you mean 'typocorrection'}}
 }