Use OpaqueType when type is not yet defined

kornilova203 · kornilova203 · commit 786e311eebfd · 2018-07-02T17:08:10.000+04:00
diff --git a/bindgen/CMakeLists.txt b/bindgen/CMakeLists.txt
@@ -72,6 +72,8 @@ add_executable(bindgen
   ir/types/FunctionPointerType.h
   ir/types/ArrayType.cpp
   ir/types/ArrayType.h
+  ir/types/OpaqueType.cpp
+  ir/types/OpaqueType.h
 )
 
 if (STATIC_LINKING)
diff --git a/bindgen/CycleDetection.h b/bindgen/CycleDetection.h
@@ -1,6 +1,8 @@
 #pragma once
 
 #include "TypeTranslator.h"
+#include "Utils.h"
+#include "ir/types/OpaqueType.h"
 
 #include <map>
 #include <set>
@@ -35,7 +37,7 @@ class CycleDetection {
         }
 
         std::shared_ptr<Type> type = tpeTransl.translate(qtpe);
-        if (type == nullptr) {
+        if (isInstanceOf<OpaqueType>(type.get())) {
             return;
         }
 
diff --git a/bindgen/TypeTranslator.cpp b/bindgen/TypeTranslator.cpp
@@ -1,6 +1,7 @@
 #include "TypeTranslator.h"
 #include "Utils.h"
 #include "ir/types/FunctionPointerType.h"
+#include "ir/types/OpaqueType.h"
 #include "ir/types/PointerType.h"
 
 TypeTranslator::TypeTranslator(clang::ASTContext *ctx_, IR &ir)
@@ -93,8 +94,17 @@ TypeTranslator::translateStructOrUnionOrEnum(const clang::QualType &qtpe) {
          * Use type alias instead struct type */
         return (*it).second;
     }
-    /* type has typedef alias */
-    return ir.getTypeDefWithName(name);
+    std::shared_ptr<TypeDef> typeDef = ir.getTypeDefWithName(name);
+    if (typeDef) {
+        /* type has typedef alias */
+        return typeDef;
+    }
+    /* type is not yet defined.
+     * use OpaqueType that will be replaced by actual type */
+    typeDef = ir.addTypeDef(replaceChar(name, " ", "_"),
+                            std::make_shared<OpaqueType>(name));
+    addAlias(name, typeDef);
+    return typeDef;
 }
 
 std::shared_ptr<Type>
diff --git a/bindgen/Utils.h b/bindgen/Utils.h
@@ -100,4 +100,13 @@ 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,
+                                      const std::string &c2) {
+    auto f = str.find(c1);
+    if (f != std::string::npos) {
+        return str.replace(f, c1.length(), c2);
+    }
+    return str;
+}
+
 #endif // UTILS_H
diff --git a/bindgen/ir/Function.cpp b/bindgen/ir/Function.cpp
@@ -7,7 +7,7 @@ Parameter::Parameter(std::string name, std::shared_ptr<Type> type)
 Function::Function(const std::string &name, std::vector<Parameter *> parameters,
                    std::shared_ptr<Type> retType, bool isVariadic)
     : name(name), scalaName(name), parameters(std::move(parameters)),
-      retType(retType), isVariadic(isVariadic) {}
+      retType(std::move(retType)), isVariadic(isVariadic) {}
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const Function &func) {
     if (func.scalaName != func.name) {
diff --git a/bindgen/ir/IR.cpp b/bindgen/ir/IR.cpp
@@ -12,8 +12,10 @@ void IR::addFunction(std::string name, std::vector<Parameter *> parameters,
                                                    retType, isVariadic));
 }
 
-void IR::addTypeDef(std::string name, std::shared_ptr<Type> type) {
+std::shared_ptr<TypeDef> IR::addTypeDef(std::string name,
+                                        std::shared_ptr<Type> type) {
     typeDefs.push_back(std::make_shared<TypeDef>(std::move(name), type));
+    return typeDefs.back();
 }
 
 std::shared_ptr<Type> IR::addEnum(std::string name, const std::string &type,
@@ -38,6 +40,14 @@ std::shared_ptr<Type> IR::addStruct(std::string name,
     return typeDefs.back();
 }
 
+void IR::addStruct(std::string name, std::vector<Field *> fields,
+                   uint64_t typeSize, const std::shared_ptr<TypeDef> &typeDef) {
+    std::shared_ptr<Struct> s =
+        std::make_shared<Struct>(std::move(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 =
@@ -47,6 +57,14 @@ IR::addUnion(std::string name, std::vector<Field *> fields, uint64_t maxSize) {
     return typeDefs.back();
 }
 
+void IR::addUnion(std::string name, std::vector<Field *> fields,
+                  uint64_t maxSize, const std::shared_ptr<TypeDef> &typeDef) {
+    std::shared_ptr<Union> u =
+        std::make_shared<Union>(std::move(name), std::move(fields), maxSize);
+    unions.push_back(u);
+    typeDef.get()->setType(u);
+}
+
 void IR::addLiteralDefine(std::string name, std::string literal,
                           std::shared_ptr<Type> type) {
     literalDefines.push_back(std::make_shared<LiteralDefine>(
@@ -317,7 +335,6 @@ T IR::getDeclarationWithName(std::vector<T> &declarations,
             return declaration;
         }
     }
-    llvm::errs() << "Failed to get declaration for " << name << "\n";
     return nullptr;
 }
 
@@ -331,4 +348,4 @@ IR::~IR() {
     possibleVarDefines.clear();
     variables.clear();
     varDefines.clear();
-}
+}
diff --git a/bindgen/ir/IR.h b/bindgen/ir/IR.h
@@ -22,7 +22,8 @@ class IR {
     void addFunction(std::string name, std::vector<Parameter *> parameters,
                      std::shared_ptr<Type> retType, bool isVariadic);
 
-    void addTypeDef(std::string name, std::shared_ptr<Type> type);
+    std::shared_ptr<TypeDef> addTypeDef(std::string name,
+                                        std::shared_ptr<Type> type);
 
     /**
      * @return type alias for the enum
@@ -36,12 +37,24 @@ class IR {
     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);
+
     /**
      * @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);
+
     void addLiteralDefine(std::string name, std::string literal,
                           std::shared_ptr<Type> type);
 
@@ -138,8 +151,6 @@ class IR {
     T getDeclarationWithName(std::vector<T> &declarations,
                              const std::string &name);
 
-    template <typename T> void clearVector(std::vector<T> v);
-
     std::string libName;    // name of the library
     std::string linkName;   // name of the library to link with
     std::string objectName; // name of Scala object
diff --git a/bindgen/ir/Struct.cpp b/bindgen/ir/Struct.cpp
@@ -3,7 +3,6 @@
 #include "types/ArrayType.h"
 #include "types/PrimitiveType.h"
 #include <sstream>
-#include <utility>
 
 Field::Field(std::string name, std::shared_ptr<Type> type)
     : TypeAndName(std::move(name), std::move(type)) {}
diff --git a/bindgen/ir/TypeAndName.cpp b/bindgen/ir/TypeAndName.cpp
@@ -2,7 +2,7 @@
 #include <clang/Tooling/Tooling.h>
 
 TypeAndName::TypeAndName(std::string name, std::shared_ptr<Type> type)
-    : name(std::move(name)), type(type) {}
+    : name(std::move(name)), type(std::move(type)) {}
 
 std::shared_ptr<Type> TypeAndName::getType() const { return type; }
 
diff --git a/bindgen/ir/types/ArrayType.cpp b/bindgen/ir/types/ArrayType.cpp
@@ -2,7 +2,7 @@
 #include "../../Utils.h"
 
 ArrayType::ArrayType(std::shared_ptr<Type> elementsType, uint64_t size)
-    : size(size), elementsType(elementsType) {}
+    : size(size), elementsType(std::move(elementsType)) {}
 
 std::string ArrayType::str() const {
     return "native.CArray[" + elementsType->str() + ", " +
@@ -12,5 +12,3 @@ std::string ArrayType::str() const {
 bool ArrayType::usesType(std::shared_ptr<Type> type) const {
     return this == type.get() || elementsType == type;
 }
-
-ArrayType::~ArrayType() {}
diff --git a/bindgen/ir/types/ArrayType.h b/bindgen/ir/types/ArrayType.h
@@ -7,7 +7,7 @@ class ArrayType : public Type {
   public:
     ArrayType(std::shared_ptr<Type> elementsType, uint64_t size);
 
-    ~ArrayType() override;
+    ~ArrayType() override = default;
 
     bool usesType(std::shared_ptr<Type> type) const override;
 
diff --git a/bindgen/ir/types/FunctionPointerType.cpp b/bindgen/ir/types/FunctionPointerType.cpp
@@ -4,7 +4,7 @@
 FunctionPointerType::FunctionPointerType(
     std::shared_ptr<Type> returnType,
     const std::vector<std::shared_ptr<Type>> &parametersTypes, bool isVariadic)
-    : returnType(returnType), parametersTypes(parametersTypes),
+    : returnType(std::move(returnType)), parametersTypes(parametersTypes),
       isVariadic(isVariadic) {}
 
 std::string FunctionPointerType::str() const {
@@ -30,12 +30,10 @@ bool FunctionPointerType::usesType(std::shared_ptr<Type> type) const {
         return true;
     }
 
-    for (auto parameterType : parametersTypes) {
+    for (const auto &parameterType : parametersTypes) {
         if (parameterType == type) {
             return true;
         }
     }
     return false;
 }
-
-FunctionPointerType::~FunctionPointerType() {}
diff --git a/bindgen/ir/types/FunctionPointerType.h b/bindgen/ir/types/FunctionPointerType.h
@@ -11,7 +11,7 @@ class FunctionPointerType : public Type {
         const std::vector<std::shared_ptr<Type>> &parametersTypes,
         bool isVariadic);
 
-    ~FunctionPointerType() override;
+    ~FunctionPointerType() override = default;
 
     bool usesType(std::shared_ptr<Type> type) const override;
 
diff --git a/bindgen/ir/types/OpaqueType.cpp b/bindgen/ir/types/OpaqueType.cpp
@@ -0,0 +1,8 @@
+#include "OpaqueType.h"
+#include <cassert>
+
+OpaqueType::OpaqueType(std::string type) : type(std::move(type)) {}
+
+std::string OpaqueType::getType() const { return type; }
+
+std::string OpaqueType::str() const { assert(false && "Type is opaque"); }
diff --git a/bindgen/ir/types/OpaqueType.h b/bindgen/ir/types/OpaqueType.h
@@ -0,0 +1,18 @@
+#ifndef SCALA_NATIVE_BINDGEN_OPAQUETYPE_H
+#define SCALA_NATIVE_BINDGEN_OPAQUETYPE_H
+
+#include "Type.h"
+
+class OpaqueType : public Type {
+  public:
+    explicit OpaqueType(std::string type);
+
+    std::string getType() const;
+
+    std::string str() const override;
+
+  private:
+    std::string type;
+};
+
+#endif // SCALA_NATIVE_BINDGEN_OPAQUETYPE_H
diff --git a/bindgen/ir/types/PointerType.cpp b/bindgen/ir/types/PointerType.cpp
@@ -1,6 +1,6 @@
 #include "PointerType.h"
 
-PointerType::PointerType(std::shared_ptr<Type> type) : type(type) {}
+PointerType::PointerType(std::shared_ptr<Type> type) : type(std::move(type)) {}
 
 std::string PointerType::str() const {
     return "native.Ptr[" + type->str() + "]";
@@ -12,5 +12,3 @@ bool PointerType::usesType(std::shared_ptr<Type> type) const {
     }
     return this->type == type;
 }
-
-PointerType::~PointerType() {}
diff --git a/bindgen/ir/types/PointerType.h b/bindgen/ir/types/PointerType.h
@@ -7,7 +7,7 @@ class PointerType : public Type {
   public:
     explicit PointerType(std::shared_ptr<Type> type);
 
-    ~PointerType() override;
+    ~PointerType() override = default;
 
     bool usesType(std::shared_ptr<Type> type) const override;
 
diff --git a/bindgen/ir/types/Type.cpp b/bindgen/ir/types/Type.cpp
@@ -3,5 +3,3 @@
 std::string Type::str() const { return ""; }
 
 bool Type::usesType(std::shared_ptr<Type> type) const { return false; }
-
-Type::~Type() = default;
diff --git a/bindgen/ir/types/Type.h b/bindgen/ir/types/Type.h
@@ -9,7 +9,7 @@
  */
 class Type {
   public:
-    virtual ~Type();
+    virtual ~Type() = default;
 
     virtual std::string str() const;
 
diff --git a/bindgen/visitor/TreeVisitor.cpp b/bindgen/visitor/TreeVisitor.cpp
@@ -86,8 +86,8 @@ bool TreeVisitor::VisitRecordDecl(clang::RecordDecl *record) {
         name = record->getTypedefNameForAnonDecl()->getNameAsString();
     }
 
-    if (record->isUnion() && !record->isAnonymousStructOrUnion() &&
-        !name.empty()) {
+    if (record->isUnion() && record->isThisDeclarationADefinition() &&
+        !record->isAnonymousStructOrUnion() && !name.empty()) {
         handleUnion(record, name);
         return true;
 
@@ -115,7 +115,16 @@ void TreeVisitor::handleUnion(clang::RecordDecl *record, std::string name) {
         fields.push_back(new Field(fname, ftype));
     }
 
-    std::shared_ptr<Type> alias = ir.addUnion(name, std::move(fields), maxSize);
+    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);
+    }
 
     typeTranslator.addAlias("union " + name, alias);
 }
@@ -155,8 +164,16 @@ 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 =
-        ir.addStruct(name, std::move(fields), sizeInBits / 8);
+    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);
+    }
 
     typeTranslator.addAlias("struct " + name, alias);
 }
diff --git a/tests/samples/OpaqueTypes.h b/tests/samples/OpaqueTypes.h
@@ -0,0 +1,22 @@
+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);
+
+union u {
+    int i;
+    float f;
+};
+
+struct points {
+    struct point *point1;
+    struct point *point2;
+};
+
+struct point {
+    int x;
+    int y;
+};
diff --git a/tests/samples/OpaqueTypes.scala b/tests/samples/OpaqueTypes.scala

Original file line number	Diff line number	Diff line change
`@@ -72,6 +72,8 @@ add_executable(bindgen`
`72`	`72`	`ir/types/FunctionPointerType.h`
`73`	`73`	`ir/types/ArrayType.cpp`
`74`	`74`	`ir/types/ArrayType.h`
	`75`	`+ ir/types/OpaqueType.cpp`
	`76`	`+ ir/types/OpaqueType.h`
`75`	`77`	`)`
`76`	`78`
`77`	`79`	`if (STATIC_LINKING)`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,8 @@`
`1`	`1`	`#pragma once`
`2`	`2`
`3`	`3`	`#include "TypeTranslator.h"`
	`4`	`+#include "Utils.h"`
	`5`	`+#include "ir/types/OpaqueType.h"`
`4`	`6`
`5`	`7`	`#include <map>`
`6`	`8`	`#include <set>`
`@@ -35,7 +37,7 @@ class CycleDetection {`
`35`	`37`	`}`
`36`	`38`
`37`	`39`	`std::shared_ptr<Type> type = tpeTransl.translate(qtpe);`
`38`		`- if (type == nullptr) {`
	`40`	`+ if (isInstanceOf<OpaqueType>(type.get())) {`
`39`	`41`	`return;`
`40`	`42`	`}`
`41`	`43`