Handle late class members

Author: Your Name

lib/templatesimplifier.cpp

@@ -1308,7 +1308,13 @@ namespace {
         }
 
         void addFunction(const std::string &name, const ParsedType &returnType) {
-            mScopes.back().members.functions[name].push_back(returnType);
+            std::vector<ParsedType> &declarations = mScopes.back().members.functions[name];
+            // the walk can record a declaration twice (class members are
+            // recorded up front and again when the body is walked)
+            if (std::none_of(declarations.cbegin(), declarations.cend(), [&](const ParsedType &declaration) {
+                return sameDeducedType(declaration.type, returnType.type);
+            }))
+                declarations.push_back(returnType);
         }
 
         bool lookupVariable(const std::string &name, ParsedType &result) const {
@@ -1959,6 +1965,46 @@ static void deduceTemplateArgumentsAtFunctionCall(const DeductionContext &ctx, T
     insertPos->insertToken(">");
 }
 
+// Record |tok| in the symbol table when it is the name of a variable or
+// function declaration.
+static void recordDeclaration(const DeductionContext &ctx, DeductionSymbolTable &symbols, const Token *tok)
+{
+    ParsedType parsed;
+    if (parseVariableDeclaration(ctx, tok, parsed)) {
+        symbols.addVariable(tok->str(), parsed);
+    } else if (Token::simpleMatch(tok->next(), "(") && tok->next()->link() &&
+               !Token::Match(tok->previous(), ".|::|->|new")) {
+        // function declaration: record the return type
+        const Token *rpar = tok->next()->link();
+        if (Token::Match(rpar->next(), ";|{|const|noexcept")) {
+            const Token *start = findDeclarationTypeStart(ctx, tok);
+            if (start && parseType(ctx, start, tok, parsed) == tok && parsed.type.valid)
+                symbols.addFunction(tok->str(), parsed);
+        }
+    }
+}
+
+// Record the member declarations of the class body starting at |bodyStart|
+// before it is walked: in a complete-class context (member function bodies,
+// default arguments, constructor initializer lists) the members that are
+// declared later in the class are visible too. The scan is shallow - nested
+// bodies contain locals and nested class members, not members of this class.
+static void recordClassMembers(const DeductionContext &ctx, DeductionSymbolTable &symbols, const Token *bodyStart)
+{
+    const Token *const bodyEnd = bodyStart->link();
+    for (const Token *tok = bodyStart->next(); tok && tok != bodyEnd; tok = tok->next()) {
+        if (tok->link() && Token::Match(tok, "(|{|["))
+            tok = tok->link();
+        else if (Token::simpleMatch(tok, "template <")) {
+            const Token *closing = tok->next()->findClosingBracket();
+            if (!closing)
+                return;
+            tok = closing;
+        } else if (tok->isName())
+            recordDeclaration(ctx, symbols, tok);
+    }
+}
+
 void TemplateSimplifier::deduceFunctionTemplateArguments()
 {
     // map from name to the function template declarations a call could instantiate
@@ -1999,6 +2045,9 @@ void TemplateSimplifier::deduceFunctionTemplateArguments()
                     symbols.leaveScopesEndingAt(tok);
                 else if (tok == classBodyStart) {
                     symbols.enterClassScope(tok->link(), std::move(className));
+                    // members declared later in the class are visible in the
+                    // member function bodies: record them all up front
+                    recordClassMembers(ctx, symbols, tok);
                     classBodyStart = nullptr;
                 } else if (Token::Match(tok, "(|{"))
                     symbols.enterScope(tok->link());
@@ -2149,19 +2198,7 @@ void TemplateSimplifier::deduceFunctionTemplateArguments()
         }
 
         // record variable and function declarations
-        ParsedType parsed;
-        if (parseVariableDeclaration(ctx, tok, parsed)) {
-            symbols.addVariable(tok->str(), parsed);
-        } else if (Token::simpleMatch(tok->next(), "(") && tok->next()->link() &&
-                   !Token::Match(tok->previous(), ".|::|->|new")) {
-            // function declaration: record the return type
-            const Token *rpar = tok->next()->link();
-            if (Token::Match(rpar->next(), ";|{|const|noexcept")) {
-                const Token *start = findDeclarationTypeStart(ctx, tok);
-                if (start && parseType(ctx, start, tok, parsed) == tok && parsed.type.valid)
-                    symbols.addFunction(tok->str(), parsed);
-            }
-        }
+        recordDeclaration(ctx, symbols, tok);
     }
 }
 

test/testsimplifytemplate.cpp

@@ -291,6 +291,7 @@ class TestSimplifyTemplate : public TestFixture {
         TEST_CASE(templateTypeDeduction10); // parameter visibility: init list, const method
         TEST_CASE(templateTypeDeduction11); // unqualified lookup: enclosing scopes, shadowing
         TEST_CASE(templateTypeDeduction12); // base class member templates, out of class method bodies
+        TEST_CASE(templateTypeDeduction13); // members declared after the member function are visible
 
         TEST_CASE(simplifyTemplateArgs1);
         TEST_CASE(simplifyTemplateArgs2);
@@ -6698,6 +6699,63 @@ class TestSimplifyTemplate : public TestFixture {
         }
     }
 
+    void templateTypeDeduction13() { // members declared after the member function are visible
+        {
+            const char code[] = "struct A {\n"
+                                "    template<class T> void tf(T t) { (void)t; }\n"
+                                "    void m() { tf(later); tf(getl()); }\n"
+                                "    int later;\n"
+                                "    long getl();\n"
+                                "};";
+            const char exp[]  = "struct A { "
+                                "void tf<int> ( int t ) ; "
+                                "void tf<long> ( long t ) ; "
+                                "void m ( ) { tf<int> ( later ) ; tf<long> ( getl ( ) ) ; } "
+                                "int later ; "
+                                "long getl ( ) ; "
+                                "} ; "
+                                "void A :: tf<int> ( int t ) { ( void ) t ; } "
+                                "void A :: tf<long> ( long t ) { ( void ) t ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        {
+            // constructor body; the member template is also declared later
+            const char code[] = "struct B {\n"
+                                "    B() : v(1.0f) { tf(later); }\n"
+                                "    template<class T> void tf(T t) { (void)t; }\n"
+                                "    float v;\n"
+                                "    double later;\n"
+                                "};";
+            const char exp[]  = "struct B { "
+                                "B ( ) : v ( 1.0f ) { tf<double> ( later ) ; } "
+                                "void tf<double> ( double t ) ; "
+                                "float v ; "
+                                "double later ; "
+                                "} ; "
+                                "void B :: tf<double> ( double t ) { ( void ) t ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+        {
+            // a parameter shadows a member that is declared later
+            const char code[] = "struct C {\n"
+                                "    template<class T> void tf(T t) { (void)t; }\n"
+                                "    void n(short x) { tf(x); }\n"
+                                "    void o() { tf(x); }\n"
+                                "    long x;\n"
+                                "};";
+            const char exp[]  = "struct C { "
+                                "void tf<short> ( short t ) ; "
+                                "void tf<long> ( long t ) ; "
+                                "void n ( short x ) { tf<short> ( x ) ; } "
+                                "void o ( ) { tf<long> ( x ) ; } "
+                                "long x ; "
+                                "} ; "
+                                "void C :: tf<short> ( short t ) { ( void ) t ; } "
+                                "void C :: tf<long> ( long t ) { ( void ) t ; }";
+            ASSERT_EQUALS(exp, tok(code));
+        }
+    }
+
     void simplifyTemplateArgs1() {
         ASSERT_EQUALS("foo<2> = 2 ; foo<2> ;", tok("template<int N> foo = N; foo < ( 2 ) >;"));
         ASSERT_EQUALS("foo<2> = 2 ; foo<2> ;", tok("template<int N> foo = N; foo < 1 + 1 >;"));