Check if TypeDef already exists in addStruct and addUnion methods

Author: kornilova203

bindgen/ir/IR.cpp

@@ -30,39 +30,32 @@ std::shared_ptr<Type> IR::addEnum(std::string name, const std::string &type,
     return nullptr;
 }
 
-std::shared_ptr<Type> IR::addStruct(std::string name,
-                                    std::vector<Field *> fields,
-                                    uint64_t typeSize) {
-    std::shared_ptr<Struct> s =
-        std::make_shared<Struct>(std::move(name), std::move(fields), typeSize);
-    structs.push_back(s);
-    typeDefs.push_back(s->generateTypeDef());
-    return typeDefs.back();
-}
-
 void IR::addStruct(std::string name, std::vector<Field *> fields,
-                   uint64_t typeSize, const std::shared_ptr<TypeDef> &typeDef) {
+                   uint64_t typeSize) {
     std::shared_ptr<Struct> s =
-        std::make_shared<Struct>(std::move(name), std::move(fields), typeSize);
+        std::make_shared<Struct>(name, std::move(fields), typeSize);
     structs.push_back(s);
-    typeDef.get()->setType(s);
-}
-
-std::shared_ptr<Type>
-IR::addUnion(std::string name, std::vector<Field *> fields, uint64_t maxSize) {
-    std::shared_ptr<Union> u =
-        std::make_shared<Union>(std::move(name), std::move(fields), maxSize);
-    unions.push_back(u);
-    typeDefs.push_back(u->generateTypeDef());
-    return typeDefs.back();
+    std::shared_ptr<TypeDef> typeDef = getTypeDefWithName("struct_" + name);
+    if (typeDef) {
+        /* the struct type used to be opaque type, typeDef contains nullptr */
+        typeDef.get()->setType(s);
+    } else {
+        typeDefs.push_back(s->generateTypeDef());
+    }
 }
 
 void IR::addUnion(std::string name, std::vector<Field *> fields,
-                  uint64_t maxSize, const std::shared_ptr<TypeDef> &typeDef) {
+                  uint64_t maxSize) {
     std::shared_ptr<Union> u =
-        std::make_shared<Union>(std::move(name), std::move(fields), maxSize);
+        std::make_shared<Union>(name, std::move(fields), maxSize);
     unions.push_back(u);
-    typeDef.get()->setType(u);
+    std::shared_ptr<TypeDef> typeDef = getTypeDefWithName("union_" + name);
+    if (typeDef) {
+        /* the union type used to be opaque type, typeDef contains nullptr */
+        typeDef.get()->setType(u);
+    } else {
+        typeDefs.push_back(u->generateTypeDef());
+    }
 }
 
 void IR::addLiteralDefine(std::string name, std::string literal,

bindgen/ir/IR.h

@@ -31,29 +31,11 @@ class IR {
     std::shared_ptr<Type> addEnum(std::string name, const std::string &type,
                                   std::vector<Enumerator> enumerators);
 
-    /**
-     * @return type alias for the struct
-     */
-    std::shared_ptr<Type>
-    addStruct(std::string name, std::vector<Field *> fields, uint64_t typeSize);
-
-    /**
-     * Add struct for which TypeDef already exists
-     */
     void addStruct(std::string name, std::vector<Field *> fields,
-                   uint64_t typeSize, const std::shared_ptr<TypeDef> &typeDef);
+                   uint64_t typeSize);
 
-    /**
-     * @return type alias for the union
-     */
-    std::shared_ptr<Type>
-    addUnion(std::string name, std::vector<Field *> fields, uint64_t maxSize);
-
-    /**
-     * Add union for which TypeDef already exists
-     */
     void addUnion(std::string name, std::vector<Field *> fields,
-                  uint64_t maxSize, const std::shared_ptr<TypeDef> &typeDef);
+                  uint64_t maxSize);
 
     void addLiteralDefine(std::string name, std::string literal,
                           std::shared_ptr<Type> type);

bindgen/visitor/TreeVisitor.cpp

@@ -114,16 +114,7 @@ void TreeVisitor::handleUnion(clang::RecordDecl *record, std::string name) {
         fields.push_back(new Field(fname, ftype));
     }
 
-    std::shared_ptr<Type> alias = nullptr;
-
-    std::shared_ptr<TypeDef> typeDef = ir.getTypeDefWithName("union_" + name);
-    if (typeDef) {
-        /* typedef for this union already exists */
-        ir.addUnion(name, std::move(fields), maxSize, typeDef);
-        alias = typeDef;
-    } else {
-        alias = ir.addUnion(name, std::move(fields), maxSize);
-    }
+    ir.addUnion(name, std::move(fields), maxSize);
 }
 
 void TreeVisitor::handleStruct(clang::RecordDecl *record, std::string name) {
@@ -161,16 +152,8 @@ void TreeVisitor::handleStruct(clang::RecordDecl *record, std::string name) {
 
     uint64_t sizeInBits = astContext->getTypeSize(record->getTypeForDecl());
     assert(sizeInBits % 8 == 0);
-    std::shared_ptr<Type> alias = nullptr;
-
-    std::shared_ptr<TypeDef> typeDef = ir.getTypeDefWithName(newName);
-    if (typeDef) {
-        /* typedef for this struct already exists */
-        alias = typeDef;
-        ir.addStruct(name, std::move(fields), sizeInBits / 8, typeDef);
-    } else {
-        alias = ir.addStruct(name, std::move(fields), sizeInBits / 8);
-    }
+
+    ir.addStruct(name, std::move(fields), sizeInBits / 8);
 }
 
 bool TreeVisitor::VisitVarDecl(clang::VarDecl *varDecl) {

tests/samples/OpaqueTypes.h

@@ -1,7 +1,8 @@
+typedef struct points points;
+
 struct point;
 struct point *move(struct point *point, int x, int y);
 
-typedef struct points points;
 typedef union u u;
 
 union u *processPoints(points *p);

tests/samples/OpaqueTypes.scala

@@ -6,9 +6,9 @@ import scala.scalanative.native._
 @native.link("bindgentests")
 @native.extern
 object OpaqueTypes {
-  type struct_point = native.CStruct2[native.CInt, native.CInt]
   type struct_points = native.CStruct2[native.Ptr[struct_point], native.Ptr[struct_point]]
   type points = struct_points
+  type struct_point = native.CStruct2[native.CInt, native.CInt]
   type union_u = native.CArray[Byte, native.Nat._4]
   type u = union_u
   def move(point: native.Ptr[struct_point], x: native.CInt, y: native.CInt): native.Ptr[struct_point] = native.extern