Use settings flag

Author: Your Name

cli/cmdlineparser.cpp

@@ -1548,6 +1548,11 @@ CmdLineParser::Result CmdLineParser::parseFromArgs(int argc, const char* const a
             // TODO: bail out when no placeholders are found?
         }
 
+        // Recreate the symbol database etc. after each template type deduction round
+        // instead of updating them incrementally - for testing and debugging
+        else if (std::strcmp(argv[i], "--template-full-rebuild") == 0)
+            mSettings.templateFullRebuild = true;
+
         else if (std::strncmp(argv[i], "--template-location=", 20) == 0) {
             mSettings.templateLocation = argv[i] + 20;
             // TODO: bail out when no template is provided?

lib/settings.h

@@ -466,6 +466,11 @@ class CPPCHECKLIB WARN_UNUSED Settings {
         e.g. "{severity} {file}:{line} {message} {id}" */
     std::string templateFormat;
 
+    /** @brief Is --template-full-rebuild given? Recreate the symbol database etc. from
+     * scratch after each template type deduction round instead of updating them
+     * incrementally. For testing and debugging. */
+    bool templateFullRebuild{};
+
     /** @brief The output format in which the error locations are printed in
      *  text mode, e.g. "{file}:{line} {info}" */
     std::string templateLocation;

lib/tokenize.cpp

@@ -4287,8 +4287,7 @@ void Tokenizer::simplifyTemplatesUsingTypeInformation()
 
     // for testing and debugging: recreate the symbol database etc. from scratch after
     // each deduction round instead of updating them incrementally
-    const char* fullRebuildEnv = std::getenv("CPPCHECK_TEMPLATE_FULL_REBUILD");
-    const bool allowIncremental = !fullRebuildEnv || (std::strcmp(fullRebuildEnv, "1") != 0);
+    const bool allowIncremental = !mSettings.templateFullRebuild;
 
     bool finalized = false;
 

test/testcmdlineparser.cpp

@@ -383,6 +383,7 @@ class TestCmdlineParser : public TestFixture {
         TEST_CASE(performanceValueflowMaxTimeInvalid);
         TEST_CASE(performanceValueFlowMaxIfCount);
         TEST_CASE(performanceValueFlowMaxIfCountInvalid);
+        TEST_CASE(templateFullRebuild);
         TEST_CASE(templateMaxTime);
         TEST_CASE(templateMaxTimeInvalid);
         TEST_CASE(templateMaxTimeInvalid2);
@@ -2535,6 +2536,13 @@ class TestCmdlineParser : public TestFixture {
         ASSERT_EQUALS("cppcheck: error: argument to '--performance-valueflow-max-if-count=' is not valid - not an integer (invalid_argument).\n", logger->str());
     }
 
+    void templateFullRebuild() {
+        REDIRECT;
+        const char * const argv[] = {"cppcheck", "--template-full-rebuild", "file.cpp"};
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
+        ASSERT_EQUALS(true, settings->templateFullRebuild);
+    }
+
     void templateMaxTime() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--template-max-time=12", "file.cpp"};

test/testsimplifytemplate.cpp

@@ -42,6 +42,13 @@ class TestSimplifyTemplate : public TestFixture {
     const Settings settings = settingsBuilder().severity(Severity::portability).build();
     const Settings settings1 = settingsBuilder(settings).library("std.cfg").build();
     const Settings settings1_d = settingsBuilder(settings1).debugwarnings().build();
+    const Settings settings1_fr = makeFullRebuildSettings(settings1);
+
+    static Settings makeFullRebuildSettings(const Settings& base) {
+        Settings s = base;
+        s.templateFullRebuild = true;
+        return s;
+    }
 
     void run() override {
         TEST_CASE(template1);
@@ -294,6 +301,7 @@ class TestSimplifyTemplate : public TestFixture {
         TEST_CASE(templateTypeDeduction13); // members declared after the member function are visible
         TEST_CASE(templateTypeDeduction14); // a non template overload might be a better match
         TEST_CASE(templateTypeDeduction15); // final classes
+        TEST_CASE(templateTypeDeductionFullRebuild); // --template-full-rebuild gives the same result
 
         TEST_CASE(simplifyTemplateArgs1);
         TEST_CASE(simplifyTemplateArgs2);
@@ -352,12 +360,19 @@ class TestSimplifyTemplate : public TestFixture {
     struct CheckOptions
     {
         bool debugwarnings = false;
+        bool templateFullRebuild = false;
     };
 
+    const Settings& checkOptionsSettings(const CheckOptions& options) const {
+        if (options.templateFullRebuild)
+            return settings1_fr;
+        return options.debugwarnings ? settings1_d : settings1;
+    }
+
 #define tok(...) tok_(__FILE__, __LINE__, __VA_ARGS__)
     template<size_t size>
     std::string tok_(const char* file, int line, const char (&code)[size], const CheckOptions& options = make_default_obj()) {
-        const Settings& s = options.debugwarnings ? settings1_d : settings1;
+        const Settings& s = checkOptionsSettings(options);
         SimpleTokenizer tokenizer(s, *this);
 
         ASSERT_LOC(tokenizer.tokenize(code), file, line);
@@ -6871,6 +6886,48 @@ class TestSimplifyTemplate : public TestFixture {
         }
     }
 
+    void templateTypeDeductionFullRebuild()
+    { // --template-full-rebuild recreates the symbol database etc. after each type
+      // deduction round instead of updating them incrementally - the result must be
+      // the same
+        {
+            // deduction from variables and expressions
+            const char code[] = "template <typename T> void f(T n) { (void)n; }\n"
+                                "struct MyClass { int m; };\n"
+                                "void func(MyClass mc, unsigned long long ull, double d) {\n"
+                                "    f(mc);\n"
+                                "    f(ull);\n"
+                                "    f(d + 1.5);\n"
+                                "}";
+            const std::string expected = tok(code);
+            ASSERT(expected.find("f<MyClass>") != std::string::npos);
+            ASSERT_EQUALS(expected, tok(code, dinit(CheckOptions, $.templateFullRebuild = true)));
+        }
+        {
+            // base class member template: the instantiated declaration is removed in a
+            // finalize step
+            const char code[] = "struct Base {\n"
+                                "    template<class T> void btf(T t) { (void)t; }\n"
+                                "    int bm;\n"
+                                "};\n"
+                                "struct Derived : public Base {\n"
+                                "    void use() { btf(bm); }\n"
+                                "};";
+            const std::string expected = tok(code);
+            ASSERT(expected.find("Base :: btf<int>") != std::string::npos);
+            ASSERT_EQUALS(expected, tok(code, dinit(CheckOptions, $.templateFullRebuild = true)));
+        }
+        {
+            // nested calls need multiple deduction rounds
+            const char code[] = "template<class T> T pass(T x) { return x; }\n"
+                                "template<class T> void sink(T x) { (void)x; }\n"
+                                "void use(long v) { sink(pass(v)); }";
+            const std::string expected = tok(code);
+            ASSERT(expected.find("sink<long>") != std::string::npos);
+            ASSERT_EQUALS(expected, tok(code, dinit(CheckOptions, $.templateFullRebuild = true)));
+        }
+    }
+
     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 >;"));