Remove redundant aliasesMap

Author: kornilova203

bindgen/TypeTranslator.cpp

@@ -87,22 +87,22 @@ TypeTranslator::translatePointer(const clang::QualType &pte,
 std::shared_ptr<Type>
 TypeTranslator::translateStructOrUnionOrEnum(const clang::QualType &qtpe) {
     std::string name = qtpe.getUnqualifiedType().getAsString();
+    std::string nameWithoutSpace = replaceChar(name, " ", "_");
 
-    auto it = aliasesMap.find(name);
-    if (it != aliasesMap.end()) {
-        /* name contains space: struct <name>.
-         * Use type alias instead struct type */
-        return (*it).second;
-    }
-    std::shared_ptr<TypeDef> typeDef = ir.getTypeDefWithName(name);
+    /* If the struct was already declared then there is a TypeDef instance
+     * with appropriate name.
+     *
+     * If there is no such TypeDef then the type is opaque and TypeDef with
+     * nullptr will be generated for the type. */
+
+    std::shared_ptr<TypeDef> typeDef = ir.getTypeDefWithName(nameWithoutSpace);
     if (typeDef) {
-        /* type has typedef alias */
         return typeDef;
     }
     /* type is not yet defined.
-     * nullptr will be replaced by actual type */
-    typeDef = ir.addTypeDef(replaceChar(name, " ", "_"), nullptr);
-    addAlias(name, typeDef);
+     * TypeDef with nullptr will be created.
+     * nullptr will be replaced by actual type when the type is declared. */
+    typeDef = ir.addTypeDef(nameWithoutSpace, nullptr);
     return typeDef;
 }
 
@@ -184,10 +184,6 @@ std::shared_ptr<Type> TypeTranslator::translate(const clang::QualType &qtpe,
     }
 }
 
-void TypeTranslator::addAlias(std::string cName, std::shared_ptr<Type> type) {
-    aliasesMap[cName] = type;
-}
-
 std::string TypeTranslator::getTypeFromTypeMap(std::string cType) {
     auto it = typeMap.find(cType);
     if (it != typeMap.end()) {

bindgen/TypeTranslator.h

@@ -17,8 +17,6 @@ class TypeTranslator {
     std::shared_ptr<Type> translate(const clang::QualType &tpe,
                                     const std::string * = nullptr);
 
-    void addAlias(std::string cName, std::shared_ptr<Type> type);
-
     std::string getTypeFromTypeMap(std::string cType);
 
   private:
@@ -30,11 +28,6 @@ class TypeTranslator {
      */
     std::map<std::string, std::string> typeMap;
 
-    /**
-     * Maps C struct, union or enum name to Type alias
-     */
-    std::map<std::string, std::shared_ptr<Type>> aliasesMap;
-
     std::shared_ptr<Type>
     translateStructOrUnionOrEnum(const clang::QualType &qtpe);
 

bindgen/Utils.h

@@ -100,13 +100,14 @@ template <typename T, typename PT> static inline bool isInstanceOf(PT *type) {
     return p != nullptr;
 }
 
-static inline std::string replaceChar(std::string str, const std::string &c1,
+static inline std::string replaceChar(const std::string &str,
+                                      const std::string &c1,
                                       const std::string &c2) {
     auto f = str.find(c1);
     if (f != std::string::npos) {
-        return str.replace(f, c1.length(), c2);
+        return std::string(str).replace(f, c1.length(), c2);
     }
-    return str;
+    return std::string(str);
 }
 
 #endif // UTILS_H

bindgen/ir/IR.cpp

@@ -322,6 +322,11 @@ std::shared_ptr<Variable> IR::addVariable(const std::string &name,
 }
 
 std::shared_ptr<TypeDef> IR::getTypeDefWithName(const std::string &name) {
+    /* nullptr is returned in 2 cases:
+     * 1. TypeTranslator translates opaque struct/union type for which TypeDef
+     *    was not created.
+     * 2. TreeVisitor visits struct/union declaration and it checks whether a
+     *    TypeDef already exists for it.*/
     return getDeclarationWithName(typeDefs, name);
 }
 

bindgen/visitor/TreeVisitor.cpp

@@ -71,9 +71,6 @@ bool TreeVisitor::VisitEnumDecl(clang::EnumDecl *enumdecl) {
 
     std::shared_ptr<Type> alias =
         ir.addEnum(name, scalaType, std::move(enumerators));
-    if (alias != nullptr) {
-        typeTranslator.addAlias("enum " + name, alias);
-    }
 
     return true;
 }
@@ -127,8 +124,6 @@ void TreeVisitor::handleUnion(clang::RecordDecl *record, std::string name) {
     } else {
         alias = ir.addUnion(name, std::move(fields), maxSize);
     }
-
-    typeTranslator.addAlias("union " + name, alias);
 }
 
 void TreeVisitor::handleStruct(clang::RecordDecl *record, std::string name) {
@@ -176,8 +171,6 @@ void TreeVisitor::handleStruct(clang::RecordDecl *record, std::string name) {
     } else {
         alias = ir.addStruct(name, std::move(fields), sizeInBits / 8);
     }
-
-    typeTranslator.addAlias("struct " + name, alias);
 }
 
 bool TreeVisitor::VisitVarDecl(clang::VarDecl *varDecl) {