got rid of duplicated error reporting code in CppCheck::checkInternal() / cleanups

Author: firewave

lib/cppcheck.cpp

@@ -977,30 +977,11 @@ unsigned int CppCheck::checkInternal(const FileWithDetails& file, const std::str
         std::vector<std::string> files;
         simplecpp::TokenList tokens1 = createTokenList(files, &outputList);
 
-        // If there is a syntax error, report it and stop
-        const auto output_it = std::find_if(outputList.cbegin(), outputList.cend(), [](const simplecpp::Output &output){
-            return Preprocessor::hasErrors(output);
-        });
-        if (output_it != outputList.cend()) {
-            const simplecpp::Output &output = *output_it;
-            std::string locfile = Path::fromNativeSeparators(output.location.file());
-            if (mSettings.relativePaths)
-                locfile = Path::getRelativePath(locfile, mSettings.basePaths);
-
-            ErrorMessage::FileLocation loc1(locfile, output.location.line, output.location.col);
-
-            ErrorMessage errmsg({std::move(loc1)},
-                                "", // TODO: is this correct?
-                                Severity::error,
-                                output.msg,
-                                "syntaxError",
-                                Certainty::normal);
-            mErrorLogger.reportErr(errmsg);
-            return mLogger->exitcode();
-        }
-
         Preprocessor preprocessor(tokens1, mSettings, mErrorLogger, file.lang());
 
+        if (preprocessor.reportOutput(outputList, true))
+            return mLogger->exitcode();
+
         if (!preprocessor.loadFiles(files))
             return mLogger->exitcode();
 

lib/preprocessor.h

@@ -140,12 +140,11 @@ class CPPCHECKLIB WARN_UNUSED Preprocessor {
      */
     void dump(std::ostream &out) const;
 
-    static bool hasErrors(const simplecpp::Output &output);
-
-protected:
     bool reportOutput(const simplecpp::OutputList &outputList, bool showerror);
 
 private:
+    static bool hasErrors(const simplecpp::Output &output);
+
     bool handleErrors(const simplecpp::OutputList &outputList, bool throwError);
 
     static void simplifyPragmaAsmPrivate(simplecpp::TokenList &tokenList);

test/cli/other_test.py

@@ -3888,8 +3888,9 @@ def test_simplecpp_unhandled_char(tmp_path):
     assert exitcode == 0, stdout
     assert stdout.splitlines() == []
     assert stderr.splitlines() == [
+        # TODO: lacks column information
         # TODO: should report another ID
-        '{}:2:5: error: The code contains unhandled character(s) (character code=228). Neither unicode nor extended ascii is supported. [syntaxError]'.format(test_file)
+        '{}:2:0: error: The code contains unhandled character(s) (character code=228). Neither unicode nor extended ascii is supported. [preprocessorErrorDirective]'.format(test_file)
     ]
 
 

test/cli/project_test.py

@@ -59,9 +59,12 @@ def test_json_entry_file_not_found(tmpdir):
     with open(project_file, 'w') as f:
         f.write(json.dumps(compilation_db))
 
-    ret, _, stderr = cppcheck(["--project=" + str(project_file)])
+    ret, _, stderr = cppcheck([
+        '--template=simple',
+        "--project=" + str(project_file)
+    ])
     assert 0 == ret
-    assert f"{missing_file}:1:0: error: File is missing: {missing_file_posix} [syntaxError]\n\n^\n" == stderr
+    assert stderr == f"nofile:0:0: error: File is missing: {missing_file_posix} [preprocessorErrorDirective]\n"
 
 
 def test_json_no_arguments(tmpdir):

test/testpreprocessor.cpp

@@ -49,21 +49,12 @@ class TestPreprocessor : public TestFixture {
     TestPreprocessor() : TestFixture("TestPreprocessor") {}
 
 private:
-    class PreprocessorTest : public Preprocessor
-    {
-        friend class TestPreprocessor;
-    public:
-        PreprocessorTest(simplecpp::TokenList& tokens, const Settings& settings, ErrorLogger &errorLogger, Standards::Language lang)
-            : Preprocessor(tokens, settings, errorLogger, lang)
-        {}
-    };
-
     template<size_t size>
     std::string expandMacros(const char (&code)[size], ErrorLogger &errorLogger) const {
         simplecpp::OutputList outputList;
         std::vector<std::string> files;
         simplecpp::TokenList tokens1 = simplecpp::TokenList(code, files, "file.cpp", &outputList);
-        PreprocessorTest p(tokens1, settingsDefault, errorLogger, Path::identify(tokens1.getFiles()[0], false));
+        Preprocessor p(tokens1, settingsDefault, errorLogger, Path::identify(tokens1.getFiles()[0], false));
         simplecpp::TokenList tokens2 = p.preprocess("", files, true);
         (void)p.reportOutput(outputList, true);
         return tokens2.stringify();
@@ -128,7 +119,7 @@ class TestPreprocessor : public TestFixture {
 
         simplecpp::TokenList tokens(code, size, files, Path::simplifyPath(filename), &outputList);
         // TODO: we should be using the actual Preprocessor implementation
-        PreprocessorTest preprocessor(tokens, settings, errorlogger, Path::identify(tokens.getFiles()[0], false));
+        Preprocessor preprocessor(tokens, settings, errorlogger, Path::identify(tokens.getFiles()[0], false));
 
         // TODO: should be possible without a Preprocessor instance
         if (preprocessor.reportOutput(outputList, true))

test/testsuppressions.cpp

@@ -88,8 +88,8 @@ class TestSuppressions : public TestFixture {
         TEST_CASE(suppressingSyntaxErrorsFS); // #7076
         TEST_CASE(suppressingSyntaxErrorsInlineFiles); // #5917
         TEST_CASE(suppressingSyntaxErrorsInlineFS); // #5917
-        TEST_CASE(suppressingSyntaxErrorsWhileFileReadFiles); // PR #1333
-        TEST_CASE(suppressingSyntaxErrorsWhileFileReadFS); // PR #1333
+        TEST_CASE(suppressingSimplecppErrorsWhileFileReadFiles); // PR #1333
+        TEST_CASE(suppressingSimplecppErrorsWhileFileReadFS); // PR #1333
         TEST_CASE(symbol);
 
         TEST_CASE(unusedFunctionFiles);
@@ -1341,7 +1341,7 @@ class TestSuppressions : public TestFixture {
         suppressingSyntaxErrorsInlineInternal(&TestSuppressions::checkSuppressionFS);
     }
 
-    void suppressingSyntaxErrorsWhileFileReadInternal(unsigned int (TestSuppressions::*check)(const char[], const std::string &)) { // syntaxError while file read should be suppressible (PR #1333)
+    void suppressingSimplecppErrorsWhileFileReadInternal(unsigned int (TestSuppressions::*check)(const char[], const std::string &)) { // syntaxError while file read should be suppressible (PR #1333)
         const char code[] = "CONST (genType, KS_CONST) genService[KS_CFG_NR_OF_NVM_BLOCKS] =\n"
                             "{\n"
                             "[!VAR \"BC\" = \"$BC + 1\"!][!//\n"
@@ -1355,16 +1355,16 @@ class TestSuppressions : public TestFixture {
                             "[!VAR \"BC\" = \"$BC + 1\"!][!//\n"
                             "[!ENDIF!][!//\n"
                             "};";
-        ASSERT_EQUALS(0, (this->*check)(code, "syntaxError:test.cpp:4"));
+        ASSERT_EQUALS(0, (this->*check)(code, "preprocessorErrorDirective:test.cpp:4"));
         ASSERT_EQUALS("", errout_str());
     }
 
-    void suppressingSyntaxErrorsWhileFileReadFiles() {
-        suppressingSyntaxErrorsWhileFileReadInternal(&TestSuppressions::checkSuppressionFiles);
+    void suppressingSimplecppErrorsWhileFileReadFiles() {
+        suppressingSimplecppErrorsWhileFileReadInternal(&TestSuppressions::checkSuppressionFiles);
     }
 
-    void suppressingSyntaxErrorsWhileFileReadFS() {
-        suppressingSyntaxErrorsWhileFileReadInternal(&TestSuppressions::checkSuppressionFiles);
+    void suppressingSimplecppErrorsWhileFileReadFS() {
+        suppressingSimplecppErrorsWhileFileReadInternal(&TestSuppressions::checkSuppressionFiles);
     }
 
     // TODO: this tests an internal function - should it be private?