Handle shadowing

Author: pfultz2

lib/templatesimplifier.cpp

@@ -810,15 +810,18 @@ struct ParameterShape {
 struct DeducedType {
     std::string typeStr;                // base type, e.g. "int" or "MyClass"
     std::string qualification;          // enclosing scopes of record and enum types, "N :: A"
+    const Scope* typeScope = nullptr;   // the scope of a record or enum type
+    bool globalQualification = false;   // write the type with a leading "::"
     unsigned int constness = 0;         // bit 0 = data const, bit 1 = first '*' const, ..
     unsigned int pointer = 0;           // number of '*'
     bool isUnsigned = false;
     bool isLong = false;
 
     bool operator==(const DeducedType& other) const
     {
-        return typeStr == other.typeStr && qualification == other.qualification && constness == other.constness &&
-               pointer == other.pointer && isUnsigned == other.isUnsigned && isLong == other.isLong;
+        return typeStr == other.typeStr && qualification == other.qualification && typeScope == other.typeScope &&
+               constness == other.constness && pointer == other.pointer && isUnsigned == other.isUnsigned &&
+               isLong == other.isLong;
     }
 };
 
@@ -916,9 +919,40 @@ static DeducedType deducedScopeType(DeducedType deduced, const Scope* typeScope)
     if (deduced.qualification.empty() && enclosing && enclosing->type != ScopeType::eGlobal)
         return DeducedType(); // local types etc. cannot be named - bail out
     deduced.typeStr = typeScope->className;
+    deduced.typeScope = typeScope;
     return deduced;
 }
 
+// Does the name of the deduced type, looked up from the given scope, find another scope
+// than the one the type is in? The instantiation is declared in the scope of the
+// template, so "S" deduced from "::S" would be resolved to "X::S" when the template is
+// in namespace X and X has its own S. Such a type must be written with a leading "::".
+static bool deducedTypeIsShadowed(const Scope* from, const DeducedType& deduced)
+{
+    if (!deduced.typeScope)
+        return false;
+    // the outermost named scope of the type: "N" for "N :: A :: M", the type itself for "S"
+    const Scope* outermost = deduced.typeScope;
+    while (outermost->nestedIn && outermost->nestedIn->type != ScopeType::eGlobal)
+        outermost = outermost->nestedIn;
+    const std::string& name = outermost->className;
+    for (const Scope* scope = from; scope && scope->type != ScopeType::eGlobal; scope = scope->nestedIn) {
+        // in a class the nested types of the base classes are visible too
+        std::vector<const Scope*> lookupScopes;
+        if (scope->isClassOrStructOrUnion())
+            lookupScopes = scope->findAssociatedScopes();
+        else
+            lookupScopes.push_back(scope);
+        for (const Scope* lookupScope : lookupScopes) {
+            for (const Scope* nested : lookupScope->nestedList) {
+                if (nested->className == name)
+                    return nested != outermost;
+            }
+        }
+    }
+    return false;
+}
+
 // Convert the type of an argument expression to the type that the parameter shape
 // deduces for its template parameter. The returned type has an empty typeStr when the
 // type is not supported.
@@ -1070,6 +1104,8 @@ static void insertDeducedType(Token* tok, const DeducedType& deduced)
 {
     if (deduced.constness & 1U)
         tok = tok->insertToken("const");
+    if (deduced.globalQualification)
+        tok = tok->insertToken("::");
     const std::string& qualification = deduced.qualification;
     for (std::string::size_type pos = 0; pos < qualification.size();) {
         std::string::size_type end = qualification.find(' ', pos);
@@ -1335,6 +1371,8 @@ std::string TemplateSimplifier::deduceFunctionTemplateArguments(
     // find the function template declarations this call could instantiate
     std::vector<const TokenAndName*> candidates;
     std::string baseClassQualification;
+    // the scope the template is declared in - the instantiation is declared there too
+    const Scope* declarationScope = nullptr;
     for (const LookupLevel& level : lookup.levels) {
         // a non template function with the same name might be a better overload match
         if (level.scope && scopeHasNonTemplateFunction(level.scope, tok->str()))
@@ -1347,6 +1385,7 @@ std::string TemplateSimplifier::deduceFunctionTemplateArguments(
         if (!candidates.empty()) {
             if (level.isBaseClass)
                 baseClassQualification = level.scopeName;
+            declarationScope = level.scope;
             break;
         }
     }
@@ -1398,6 +1437,19 @@ std::string TemplateSimplifier::deduceFunctionTemplateArguments(
             stored = std::move(deduced);
     }
 
+    // a deduced type whose name is shadowed in the scope of the template must be written
+    // with a leading "::" so the instantiation does not use the wrong type
+    if (!declarationScope)
+        declarationScope = declaration->nameToken()->scope(); // explicitly qualified call
+    for (DeducedType& deduced : deducedTypes) {
+        if (!deduced.typeScope)
+            continue;
+        if (!declarationScope)
+            return qualification; // cannot tell which type the name would resolve to
+        if (deducedTypeIsShadowed(declarationScope, deduced))
+            deduced.globalQualification = true;
+    }
+
     // when the declaration is in a base class, qualify the call site explicitly so the
     // instantiation is matched with that declaration: "btf ( x )" => "Base :: btf ( x )"
     if (!baseClassQualification.empty()) {

test/testsimplifytemplate.cpp

@@ -317,6 +317,7 @@ class TestSimplifyTemplate : public TestFixture {
         TEST_CASE(templateTypeDeductionMultiPass);   // a pending deduction survives later simplifier passes
         TEST_CASE(templateTypeDeductionNested);      // calls inside a body created by deduction are deduced too
         TEST_CASE(templateTypeDeductionOutOfLine);   // member template defined out of line, class in a namespace
+        TEST_CASE(templateTypeDeductionShadowedType); // the deduced type name means another type in the template's scope
         TEST_CASE(templateTypeDeductionEnum);        // enum arguments deduce the enum, not its underlying type
         TEST_CASE(templateTypeDeductionArray);       // array arguments: only the decayed dimension is a pointer
         TEST_CASE(templateTypeDeductionConstPointer); // "const T *": the parameter provides the pointee const
@@ -7421,6 +7422,91 @@ class TestSimplifyTemplate : public TestFixture {
         }
     }
 
+    void templateTypeDeductionShadowedType()
+    { // the instantiation is declared in the scope of the template: when the name of
+      // the deduced type means another type there, the type must be written with a
+      // leading "::", otherwise the instantiation uses the wrong type
+        { // a global type shadowed by a type in the namespace of the template
+            const char code[] = "struct S { int a[10]; };\n"
+                                "namespace X {\n"
+                                "struct S { int a[2]; };\n"
+                                "template<class T> int f(const T& t) { return t.a[5]; }\n"
+                                "int g(const ::S& s) { return f(s); }\n"
+                                "}";
+            const char exp[] = "struct S { int a [ 10 ] ; } ; "
+                               "namespace X { "
+                               "struct S { int a [ 2 ] ; } ; "
+                               "int f<::S> ( const :: S & t ) ; "
+                               "int g ( const :: S & s ) { return f<::S> ( s ) ; } "
+                               "} "
+                               "int X :: f<::S> ( const :: S & t ) { return t . a [ 5 ] ; }";
+            ASSERT_EQUALS(exp, tok(code));
+            ASSERT_EQUALS(exp, tok(code, dinit(CheckOptions, $.templateFullRebuild = true)));
+        }
+        { // a partly qualified name: the first scope name is shadowed
+            const char code[] = "namespace N { struct S { int a[10]; }; }\n"
+                                "namespace X {\n"
+                                "namespace N { struct S { int a[2]; }; }\n"
+                                "template<class T> int f(const T& t) { return t.a[5]; }\n"
+                                "int g(const ::N::S& s) { return f(s); }\n"
+                                "}";
+            const char exp[] = "namespace N { struct S { int a [ 10 ] ; } ; } "
+                               "namespace X { "
+                               "namespace N { struct S { int a [ 2 ] ; } ; } "
+                               "int f<::N::S> ( const :: N :: S & t ) ; "
+                               "int g ( const :: N :: S & s ) { return f<::N::S> ( s ) ; } "
+                               "} "
+                               "int X :: f<::N::S> ( const :: N :: S & t ) { return t . a [ 5 ] ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        { // an explicitly qualified call from outside the namespace
+            const char code[] = "struct S { int a[10]; };\n"
+                                "namespace X {\n"
+                                "struct S { int a[2]; };\n"
+                                "template<class T> int f(const T& t) { return t.a[5]; }\n"
+                                "}\n"
+                                "int g(const S& s) { return X::f(s); }";
+            const char exp[] = "struct S { int a [ 10 ] ; } ; "
+                               "namespace X { "
+                               "struct S { int a [ 2 ] ; } ; "
+                               "int f<::S> ( const :: S & t ) ; "
+                               "} "
+                               "int g ( const S & s ) { return X :: f<::S> ( s ) ; } "
+                               "int X :: f<::S> ( const :: S & t ) { return t . a [ 5 ] ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        { // the type in the namespace itself is not shadowed: no leading "::"
+            const char code[] = "namespace X {\n"
+                                "struct S { int a[10]; };\n"
+                                "template<class T> int f(const T& t) { return t.a[5]; }\n"
+                                "int g(const S& s) { return f(s); }\n"
+                                "}";
+            const char exp[] = "namespace X { "
+                               "struct S { int a [ 10 ] ; } ; "
+                               "int f<X::S> ( const X :: S & t ) ; "
+                               "int g ( const S & s ) { return f<X::S> ( s ) ; } "
+                               "} "
+                               "int X :: f<X::S> ( const X :: S & t ) { return t . a [ 5 ] ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        { // a member template: nested types of the class and of its base classes shadow
+            const char code[] = "struct S { int a[10]; };\n"
+                                "struct Base { struct S { int a[2]; }; };\n"
+                                "struct C : Base {\n"
+                                "    template<class T> int f(const T& t) { return t.a[5]; }\n"
+                                "    int g(const ::S& s) { return f(s); }\n"
+                                "};";
+            const char exp[] = "struct S { int a [ 10 ] ; } ; "
+                               "struct Base { struct S { int a [ 2 ] ; } ; } ; "
+                               "struct C : Base { "
+                               "int f<::S> ( const :: S & t ) ; "
+                               "int g ( const :: S & s ) { return f<::S> ( s ) ; } "
+                               "} ; "
+                               "int C :: f<::S> ( const :: S & t ) { return t . a [ 5 ] ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+    }
+
     void templateTypeDeductionEnum()
     {
         { // an enum variable has the ValueType of the underlying integer type - the enum