Fix issue with anonymous enums (#599)

IDKWNTCMF · web-flow · commit e05232120637 · 2023-07-12T16:46:04.000+03:00
* Fix issue with anonymous enums
diff --git a/server/src/clang-utils/SourceToHeaderMatchCallback.cpp b/server/src/clang-utils/SourceToHeaderMatchCallback.cpp
@@ -196,6 +196,7 @@ void SourceToHeaderMatchCallback::generateInternal(const FunctionDecl *decl) con
     auto policy = getDefaultPrintingPolicy(decl, true);
     policy.TerseOutput = 1;
     policy.PolishForDeclaration = 1;
+    policy.AnonymousTagLocations = 0;
 
     std::string name = decl->getNameAsString();
     std::string decoratedName = decorate(name);
@@ -208,6 +209,13 @@ void SourceToHeaderMatchCallback::generateInternal(const FunctionDecl *decl) con
         curDecl = getOldStyleDeclarationAsString(decl, decoratedName);
         wrapperDecl = getOldStyleDeclarationAsString(decl, wrapperName);
     }
+    TagDecl *tagDecl = decl->getReturnType()->getAsTagDecl();
+    if (isAnonymousEnumDecl(tagDecl)) {
+        std::string enumReturnTypeName = PrinterUtils::getEnumReturnMangledTypeName(name);
+        replaceAnonymousEnumTypeName(wrapperDecl, enumReturnTypeName);
+        replaceAnonymousEnumTypeName(curDecl, enumReturnTypeName);
+        renameAnonymousReturnTypeDecl(tagDecl, name);
+    }
 
     *internalStream << "extern \"C\" " << wrapperDecl << ";\n";
     *internalStream << "static " << curDecl << " {\n";
@@ -251,6 +259,7 @@ void SourceToHeaderMatchCallback::generateWrapper(const FunctionDecl *decl) cons
     auto policy = getDefaultPrintingPolicy(decl, false);
     policy.TerseOutput = 1;
     policy.PolishForDeclaration = 1;
+    policy.AnonymousTagLocations = 0;
 
     /*
      * fun_wrapper {
@@ -263,6 +272,10 @@ void SourceToHeaderMatchCallback::generateWrapper(const FunctionDecl *decl) cons
     if (IsOldStyleDefinition(wrapperDecl)){
         wrapperDecl = getOldStyleDeclarationAsString(decl, wrapperName);
     }
+    TagDecl *tagDecl = decl->getReturnType()->getAsTagDecl();
+    if (isAnonymousEnumDecl(tagDecl)) {
+        replaceAnonymousEnumTypeName(wrapperDecl, "int");
+    }
 
     *wrapperStream << wrapperDecl << " {\n";
     printReturn(decl, name, wrapperStream);
@@ -373,6 +386,23 @@ void SourceToHeaderMatchCallback::renameDecl(const NamedDecl *decl, const std::s
     const_cast<NamedDecl *>(decl)->setDeclName(wrapperDeclarationName);
 }
 
+void SourceToHeaderMatchCallback::renameAnonymousReturnTypeDecl(const TagDecl *tagDecl,
+                                                                const std::string &methodName) const {
+    auto enumDecl = llvm::dyn_cast<clang::EnumDecl>(tagDecl);
+    std::string declTypeName = PrinterUtils::getReturnMangledTypeName(methodName);
+    renameDecl(enumDecl, declTypeName);
+    print(enumDecl);
+}
+
+void SourceToHeaderMatchCallback::replaceAnonymousEnumTypeName(std::string &strDecl,
+                                                               const std::string &typeName) const {
+    StringUtils::replaceFirst(strDecl, "enum (anonymous)", typeName);
+}
+
+bool SourceToHeaderMatchCallback::isAnonymousEnumDecl(const clang::TagDecl *tagDecl) const {
+    return tagDecl && tagDecl->isEnum() && !tagDecl->hasNameForLinkage();
+}
+
 std::string SourceToHeaderMatchCallback::getOldStyleDeclarationAsString(const FunctionDecl *decl, std::string const &name) const{
     std::string result;
     llvm::raw_string_ostream resultStream{ result };
diff --git a/server/src/clang-utils/SourceToHeaderMatchCallback.h b/server/src/clang-utils/SourceToHeaderMatchCallback.h
@@ -86,8 +86,15 @@ class SourceToHeaderMatchCallback : public clang::ast_matchers::MatchFinder::Mat
 
     void renameDecl(const clang::NamedDecl *decl, const std::string &name) const;
 
+    void renameAnonymousReturnTypeDecl(const clang::TagDecl *tagDecl, const std::string &methodName) const;
+
     std::string decorate(std::string_view name) const;
 
+    void replaceAnonymousEnumTypeName(std::string &strDecl,
+                                      const std::string &typeName) const;
+
+    bool isAnonymousEnumDecl(const clang::TagDecl *tagDecl) const;
+
     std::string getOldStyleDeclarationAsString(const clang::FunctionDecl *decl, std::string const &name) const;
 
     bool IsOldStyleDefinition(std::string const &definition) const;
diff --git a/server/src/fetchers/FunctionDeclsMatchCallback.cpp b/server/src/fetchers/FunctionDeclsMatchCallback.cpp
@@ -33,6 +33,7 @@ void FunctionDeclsMatchCallback::run(const MatchFinder::MatchResult &Result) {
         }
 
         std::string methodName = FS->getQualifiedNameAsString();
+        std::string enumReturnTypeName = PrinterUtils::getEnumReturnMangledTypeName(methodName);
         methodDescription.name = methodName;
         methodDescription.callName = ClangUtils::getCallName(FS);
         methodDescription.sourceFilePath = sourceFilePath;
@@ -42,6 +43,7 @@ void FunctionDeclsMatchCallback::run(const MatchFinder::MatchResult &Result) {
         }
         clang::QualType realReturnType = ClangUtils::getReturnType(FS, Result);
         methodDescription.returnType = ParamsHandler::getType(realReturnType, realReturnType, sourceManager);
+        methodDescription.returnType.replaceTypeNameIfUnnamed(enumReturnTypeName);
         methodDescription.accessSpecifier = types::AS_pubic;
         if (onlyReturnTypes) {
             addMethod(sourceFilePath, methodDescription);
@@ -72,6 +74,7 @@ void FunctionDeclsMatchCallback::run(const MatchFinder::MatchResult &Result) {
             methodDescription.accessSpecifier = getAcessSpecifier(FS);
         }
         methodDescription.returnType = ParamsHandler::getType(realReturnType, realReturnType, sourceManager);
+        methodDescription.returnType.replaceTypeNameIfUnnamed(enumReturnTypeName);
         methodDescription.hasIncompleteReturnType = ClangUtils::isIncomplete(realReturnType);
         if (toResolveReturnTypes) {
             typesResolver.resolve(realReturnType);
diff --git a/server/src/printers/KleePrinter.cpp b/server/src/printers/KleePrinter.cpp
@@ -471,7 +471,10 @@ void KleePrinter::genReturnDeclaration(const Tests::MethodDescription &testMetho
                           : testMethod.returnType;
     bool maybeArray = returnType.maybeReturnArray();
     bool isPointer = testMethod.returnType.isObjectPointer();
-    strDeclareVar(returnType.baseType(), KleeUtils::RESULT_VARIABLE_NAME, std::nullopt, std::nullopt, false);
+    std::string type = typesHandler->isAnonymousEnum(returnType)
+                           ? "int"
+                           : returnType.baseType();
+    strDeclareVar(type, KleeUtils::RESULT_VARIABLE_NAME, std::nullopt, std::nullopt, false);
     makeBracketsForStrPredicate(predicateInfo);
     if (maybeArray) {
         size_t size = types::TypesHandler::getElementsNumberInPointerOneDim(PointerUsage::RETURN);
diff --git a/server/src/types/Types.cpp b/server/src/types/Types.cpp
@@ -390,6 +390,13 @@ void types::Type::replaceUsedType(const types::TypeName &newUsedType) {
     mUsedType = newUsedType;
 }
 
+void types::Type::replaceTypeNameIfUnnamed(const TypeName &newTypeName) {
+    if (isUnnamed()) {
+        mBaseType = newTypeName;
+        mUsedType = newTypeName;
+    }
+}
+
 /*
  * Integer types
  */
@@ -504,6 +511,10 @@ bool types::TypesHandler::isEnum(const types::Type &type) const {
     return type.isSimple() && isEnum(type.getId());
 }
 
+bool types::TypesHandler::isAnonymousEnum(const types::Type& type) const {
+    return type.isUnnamed() && isEnum(type);
+}
+
 bool types::TypesHandler::isEnum(uint64_t id) const {
     return typeIsInMap(id, typeMaps.enums);
 }
diff --git a/server/src/types/Types.h b/server/src/types/Types.h
@@ -217,6 +217,13 @@ namespace types {
          */
         void replaceUsedType(const TypeName &newUsedType);
 
+        /**
+         * Replace current baseType and usedType with a new one if unnamed.
+         * @param newTypeName - name of type
+         * @return
+         */
+        void replaceTypeNameIfUnnamed(const TypeName &newTypeName);
+
         /**
          * Creates type from its name. Created type satisfies following:
          * typeName() == "const " + type && baseType() == type && usedType() == typeName();
@@ -462,6 +469,12 @@ namespace types {
          */
         bool isEnum(const Type&) const;
 
+        /**
+         * Returns true if given type is an anonymous enum, otherwise false.
+         * @return whether given type is an anonymous enum
+         */
+         bool isAnonymousEnum(const Type&) const;
+
 
         /**
          * Returns true if given type is void, otherwise false.
diff --git a/server/src/utils/PrinterUtils.cpp b/server/src/utils/PrinterUtils.cpp
@@ -97,6 +97,14 @@ namespace PrinterUtils {
         return methodName + "_return";
     }
 
+    std::string getReturnMangledTypeName(const std::string& methodName) {
+        return methodName + "_return_type";
+    }
+
+    std::string getEnumReturnMangledTypeName(const std::string& methodName) {
+        return "enum " + getReturnMangledTypeName(methodName);
+    }
+
     std::string getEqualString(const std::string& lhs, const std::string& rhs) {
         return StringUtils::stringFormat("%s == %s", lhs, rhs);
     }
diff --git a/server/src/utils/PrinterUtils.h b/server/src/utils/PrinterUtils.h
@@ -78,6 +78,8 @@ namespace PrinterUtils {
 
     std::string getParamMangledName(const std::string &paramName, const std::string &methodName);
     std::string getReturnMangledName(const std::string &methodName);
+    std::string getReturnMangledTypeName(const std::string& methodName);
+    std::string getEnumReturnMangledTypeName(const std::string& methodName);
 
     std::string getEqualString(const std::string &lhs, const std::string &rhs);
     std::string getDereferencePointer(const std::string &name, const size_t depth);
diff --git a/server/src/visitors/KleeAssumeReturnValueVisitor.cpp b/server/src/visitors/KleeAssumeReturnValueVisitor.cpp
@@ -17,7 +17,10 @@ namespace visitor {
         functionCall = printer->constrFunctionCall(methodDescription, 0, "", false);
         additionalPointersCount = methodDescription.returnType.countReturnPointers();
         auto returnType = methodDescription.returnType.baseTypeObj();
-        printer->strDeclareVar(getActualTmpVarType(returnType).baseType(),
+        std::string type = typesHandler->isAnonymousEnum(returnType)
+                               ? "int"
+                               : getActualTmpVarType(returnType).baseType();
+        printer->strDeclareVar(type,
                                KleeUtils::TEMP_VARIABLE_NAME, functionCall,
                                std::nullopt, true, additionalPointersCount);
         checkNotNullBefore();
diff --git a/server/test/framework/Syntax_Tests.cpp b/server/test/framework/Syntax_Tests.cpp
@@ -722,6 +722,26 @@ namespace {
         );
     }
 
+    TEST_F(Syntax_Test, Anonymous_Enum_As_Return_Test) {
+        auto [testGen, status] = createTestForFunction(enums_c, 79);
+
+        ASSERT_TRUE(status.ok()) << status.error_message();
+
+        checkTestCasePredicates(
+            testGen.tests.at(enums_c).methods.begin().value().testCases,
+            std::vector<TestCasePredicate>(
+                {[](const tests::Tests::MethodTestCase& testCase) {
+                      return testCase.returnValue.view->getEntryValue(nullptr) == "EVEN" && stoi(testCase.paramValues[0].view->getEntryValue(nullptr)) % 2 == 0;
+                  },
+                 [](const tests::Tests::MethodTestCase& testCase) {
+                      return testCase.returnValue.view->getEntryValue(nullptr) == "ODD"  && stoi(testCase.paramValues[0].view->getEntryValue(nullptr)) % 2 == 1;
+                  }
+                }
+            ),
+            "intToParity"
+        );
+    }
+
     TEST_F(Syntax_Test, Typedef_Struct_Test) {
         auto [testGen, status] = createTestForFunction(typedefs_1_c, 15);
 
diff --git a/server/test/suites/syntax/enums.c b/server/test/suites/syntax/enums.c
@@ -73,3 +73,10 @@ static int enumWithinRecord(struct EnumWithinRecord record) {
         return 0;
     }
 }
+
+enum {EVEN, ODD} intToParity(int a) {
+    if (a % 2 == 0) {
+        return EVEN;
+    }
+    return ODD;
+}

Original file line number	Diff line number	Diff line change
`@@ -97,6 +97,14 @@ namespace PrinterUtils {`
`97`	`97`	`return methodName + "_return";`
`98`	`98`	`}`
`99`	`99`
	`100`	`+ std::string getReturnMangledTypeName(const std::string& methodName) {`
	`101`	`+ return methodName + "_return_type";`
	`102`	`+ }`
	`103`	`+`
	`104`	`+ std::string getEnumReturnMangledTypeName(const std::string& methodName) {`
	`105`	`+ return "enum " + getReturnMangledTypeName(methodName);`
	`106`	`+ }`
	`107`	`+`
`100`	`108`	`std::string getEqualString(const std::string& lhs, const std::string& rhs) {`
`101`	`109`	`return StringUtils::stringFormat("%s == %s", lhs, rhs);`
`102`	`110`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,3 +73,10 @@ static int enumWithinRecord(struct EnumWithinRecord record) {`
`73`	`73`	`return 0;`
`74`	`74`	`}`
`75`	`75`	`}`
	`76`	`+`
	`77`	`+enum {EVEN, ODD} intToParity(int a) {`
	`78`	`+ if (a % 2 == 0) {`
	`79`	`+ return EVEN;`
	`80`	`+ }`
	`81`	`+ return ODD;`
	`82`	`+}`