Add tests. Search for type usages recursively

kornilova203 · kornilova203 · commit f2e29e60f5d7 · 2018-07-10T01:01:02.000+03:00
diff --git a/bindgen/ir/IR.cpp b/bindgen/ir/IR.cpp
@@ -78,7 +78,7 @@ void IR::addVarDefine(std::string name, std::shared_ptr<Variable> variable) {
 }
 
 bool IR::libObjEmpty() const {
-    return functions.empty() && !hasOutputtedTypeDefs() &&
+    return functions.empty() && !hasOutputtedDeclaration(typeDefs) &&
            !hasOutputtedDeclaration(structs) &&
            !hasOutputtedDeclaration(unions) && varDefines.empty() &&
            variables.empty();
@@ -91,7 +91,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
         s << "package " << ir.packageName << "\n\n";
     }
 
-    if (!ir.libObjEmpty() || ir.hasOutputtedEnums() ||
+    if (!ir.libObjEmpty() || ir.hasOutputtedDeclaration(ir.enums) ||
         !ir.literalDefines.empty()) {
         s << "import scala.scalanative._\n"
           << "import scala.scalanative.native._\n\n";
@@ -108,7 +108,8 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
           << "object " << objectName << " {\n";
 
         for (const auto &typeDef : ir.typeDefs) {
-            if (ir.typeDefInMainFile(*typeDef) || ir.isTypeUsed(typeDef)) {
+            if (ir.typeDefInMainFile(*typeDef) ||
+                ir.isTypeUsed(typeDef, true)) {
                 s << *typeDef;
             }
         }
@@ -136,18 +137,16 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
         s << "}\n\n";
     }
 
-    if (ir.hasOutputtedEnums() || ir.hasHelperMethods()) {
+    if (ir.hasOutputtedDeclaration(ir.enums) || ir.hasHelperMethods()) {
         s << "import " << objectName << "._\n\n";
     }
 
-    if (ir.hasOutputtedEnums()) {
+    if (ir.hasOutputtedDeclaration(ir.enums)) {
         s << "object " << ir.libName << "Enums {\n";
 
         std::string sep = "";
         for (const auto &e : ir.enums) {
-            if (ir.inMainFile(*e) ||
-                (!e->isAnonymous() &&
-                 ir.isTypeUsed(ir.getTypeDefWithName(e->getTypeAlias())))) {
+            if (ir.isOutputted(e)) {
                 s << sep << *e;
                 sep = "\n";
             }
@@ -160,13 +159,13 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
         s << "object " << ir.libName << "Helpers {\n";
 
         for (const auto &st : ir.structs) {
-            if (ir.isOutputted(st.get()) && st->hasHelperMethods()) {
+            if (ir.isOutputted(st) && st->hasHelperMethods()) {
                 s << "\n" << st->generateHelperClass();
             }
         }
 
         for (const auto &u : ir.unions) {
-            if (ir.isOutputted(u.get())) {
+            if (ir.isOutputted(u)) {
                 s << "\n" << u->generateHelperClass();
             }
         }
@@ -193,7 +192,7 @@ bool IR::hasHelperMethods() const {
     }
 
     for (const auto &s : structs) {
-        if (isOutputted(s.get()) && s->hasHelperMethods()) {
+        if (isOutputted(s) && s->hasHelperMethods()) {
             return true;
         }
     }
@@ -259,9 +258,46 @@ bool IR::typeIsUsedOnlyInTypeDefs(const std::shared_ptr<Type> &type) const {
         isTypeUsed(literalDefines, type, true));
 }
 
-bool IR::isTypeUsed(const std::shared_ptr<Type> &type) const {
-    return !(typeIsUsedOnlyInTypeDefs(type) &&
-             !isTypeUsed(typeDefs, type, false));
+bool IR::isTypeUsed(const std::shared_ptr<Type> &type,
+                    bool checkRecursively) const {
+    if (checkRecursively) {
+        if (isTypeUsed(functions, type, true) ||
+            isTypeUsed(variables, type, true) ||
+            isTypeUsed(literalDefines, type, true)) {
+            return true;
+        }
+        /* type is used if there exists another type that is used and that
+         * references this type */
+        for (const auto &typeDef : typeDefs) {
+            if (typeDef->usesType(type, false)) {
+                if (isOutputted(typeDef)) {
+                    return true;
+                }
+            }
+        }
+        for (const auto &s : structs) {
+            /* stopOnTypeDefs parameter is true because because typedefs were
+             * checked */
+            if (s->usesType(type, true)) {
+                if (isOutputted(s)) {
+                    return true;
+                }
+            }
+        }
+        for (const auto &u : unions) {
+            /* stopOnTypeDefs parameter is true because because typedefs were
+             * checked */
+            if (u->usesType(type, true)) {
+                if (isOutputted(u)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    } else {
+        return !(typeIsUsedOnlyInTypeDefs(type) &&
+                 !isTypeUsed(typeDefs, type, false));
+    }
 }
 
 void IR::setScalaNames() {
@@ -392,38 +428,18 @@ template <typename T> bool IR::inMainFile(const T &type) const {
     return location && locationManager.inMainFile(*location);
 }
 
-bool IR::hasOutputtedEnums() const {
-    for (const auto &e : enums) {
-        if (inMainFile(*e) ||
-            (!e->isAnonymous() &&
-             isTypeUsed(getTypeDefWithName(e->getTypeAlias())))) {
-            return true;
-        }
-    }
-    return false;
-}
-
-bool IR::hasOutputtedTypeDefs() const {
-    for (const auto &typeDef : typeDefs) {
-        if (inMainFile(*typeDef) || isTypeUsed(typeDef)) {
-            return true;
-        }
-    }
-    return false;
-}
-
 template <typename T>
 bool IR::hasOutputtedDeclaration(
     const std::vector<std::shared_ptr<T>> &declarations) const {
     for (const auto &declaration : declarations) {
-        if (isOutputted(declaration.get())) {
+        if (isOutputted(declaration)) {
             return true;
         }
     }
     return false;
 }
 
-bool IR::isOutputted(const StructOrUnion *structOrUnion) const {
-    return inMainFile(*structOrUnion) ||
-           isTypeUsed(getTypeDefWithName(structOrUnion->getTypeAlias()));
+template <typename T>
+bool IR::isOutputted(const std::shared_ptr<T> &type) const {
+    return inMainFile(*type) || isTypeUsed(type, true);
 }
diff --git a/bindgen/ir/IR.h b/bindgen/ir/IR.h
@@ -115,9 +115,12 @@ class IR {
     bool typeIsUsedOnlyInTypeDefs(const std::shared_ptr<Type> &type) const;
 
     /**
+     * @param checkRecursively if this parameter is true then the method will
+     * output false if the type is used only in unused types
      * @return true if type is used in one of declarations
      */
-    bool isTypeUsed(const std::shared_ptr<Type> &type) const;
+    bool isTypeUsed(const std::shared_ptr<Type> &type,
+                    bool checkRecursively = false) const;
 
     /**
      * @return true if type is used in one of given declarations.
@@ -145,11 +148,13 @@ class IR {
 
     template <typename T> bool inMainFile(const T &type) const;
 
-    bool hasOutputtedEnums() const;
-
-    bool hasOutputtedTypeDefs() const;
-
-    bool isOutputted(const StructOrUnion *structOrUnion) const;
+    /**
+     * @tparam T Type subclass
+     * @return true if type is in main file or it is used by declaration from
+     *         main file.
+     */
+    template <typename T>
+    bool isOutputted(const std::shared_ptr<T> &type) const;
 
     /**
      * @tparam T Struct or Union
diff --git a/bindgen/ir/Location.cpp b/bindgen/ir/Location.cpp
@@ -4,3 +4,5 @@ Location::Location(std::string path, int lineNumber)
     : path(std::move(path)), lineNumber(lineNumber) {}
 
 std::string Location::getPath() const { return path; }
+
+int Location::getLineNumber() const { return lineNumber; }
diff --git a/bindgen/ir/Location.h b/bindgen/ir/Location.h
@@ -9,6 +9,8 @@ class Location {
 
     std::string getPath() const;
 
+    int getLineNumber() const;
+
   private:
     std::string path;
     int lineNumber;
diff --git a/bindgen/ir/Struct.cpp b/bindgen/ir/Struct.cpp
@@ -51,7 +51,7 @@ StructOrUnion::~StructOrUnion() {
     }
 }
 
-bool StructOrUnion::operator==(const StructOrUnion &other) const {
+bool StructOrUnion::equals(const StructOrUnion &other) const {
     if (this == &other) {
         return true;
     }
@@ -155,6 +155,14 @@ bool Struct::usesType(const std::shared_ptr<Type> &type,
     return false;
 }
 
+bool Struct::operator==(const Type &other) const {
+    auto *structOrUnion = dynamic_cast<const StructOrUnion *>(&other);
+    if (structOrUnion) {
+        return this->equals(*structOrUnion);
+    }
+    return false;
+}
+
 Union::Union(std::string name, std::vector<Field *> fields, uint64_t maxSize,
              std::shared_ptr<Location> location)
     : StructOrUnion(std::move(name), std::move(fields), std::move(location)),
@@ -188,3 +196,11 @@ std::string Union::generateHelperClass() const {
 }
 
 std::string Union::getTypeAlias() const { return "union_" + name; }
+
+bool Union::operator==(const Type &other) const {
+    auto *structOrUnion = dynamic_cast<const StructOrUnion *>(&other);
+    if (structOrUnion) {
+        return this->equals(*structOrUnion);
+    }
+    return false;
+}
diff --git a/bindgen/ir/Struct.h b/bindgen/ir/Struct.h
@@ -31,7 +31,7 @@ class StructOrUnion {
 
     std::string getName() const;
 
-    bool operator==(const StructOrUnion &other) const;
+    bool equals(const StructOrUnion &other) const;
 
     std::shared_ptr<Location> getLocation() const;
 
@@ -69,7 +69,7 @@ class Struct : public StructOrUnion,
 
     std::string str() const override;
 
-    using StructOrUnion::operator==;
+    bool operator==(const Type &other) const override;
 
   private:
     /* type size is needed if number of fields is bigger than 22 */
@@ -87,7 +87,7 @@ class Union : public StructOrUnion,
 
     std::string generateHelperClass() const override;
 
-    using StructOrUnion::operator==;
+    bool operator==(const Type &other) const override;
 
     std::string getTypeAlias() const override;
 };
diff --git a/bindgen/ir/TypeAndName.cpp b/bindgen/ir/TypeAndName.cpp
@@ -11,6 +11,9 @@ std::string TypeAndName::getName() const { return name; }
 void TypeAndName::setType(std::shared_ptr<Type> type) { this->type = type; }
 
 bool TypeAndName::operator==(const TypeAndName &other) const {
+    if (this == &other) {
+        return true;
+    }
     return name == other.name && *type == *other.type;
 }
 
diff --git a/bindgen/ir/types/ArrayType.cpp b/bindgen/ir/types/ArrayType.cpp
@@ -1,5 +1,6 @@
 #include "ArrayType.h"
 #include "../../Utils.h"
+#include "../Struct.h"
 
 ArrayType::ArrayType(std::shared_ptr<Type> elementsType, uint64_t size)
     : size(size), elementsType(std::move(elementsType)) {}
@@ -12,19 +13,20 @@ std::string ArrayType::str() const {
 bool ArrayType::usesType(const std::shared_ptr<Type> &type,
                          bool stopOnTypeDefs) const {
     return *elementsType == *type ||
-           elementsType.get()->usesType(type, stopOnTypeDefs);
+           elementsType->usesType(type, stopOnTypeDefs);
 }
 
 bool ArrayType::operator==(const Type &other) const {
     if (this == &other) {
         return true;
     }
-    if (isInstanceOf<const ArrayType>(&other)) {
+    if (isInstanceOf<const ArrayType>(&other) &&
+        !isInstanceOf<const Union>(&other)) {
         auto *arrayType = dynamic_cast<const ArrayType *>(&other);
         if (size != arrayType->size) {
             return false;
         }
-        return *elementsType == *arrayType->elementsType.get();
+        return *elementsType == *arrayType->elementsType;
     }
     return false;
 }
diff --git a/bindgen/ir/types/PrimitiveType.cpp b/bindgen/ir/types/PrimitiveType.cpp
@@ -1,5 +1,6 @@
 #include "PrimitiveType.h"
 #include "../../Utils.h"
+#include "../Enum.h"
 
 PrimitiveType::PrimitiveType(std::string type) : type(std::move(type)) {}
 
@@ -16,7 +17,8 @@ bool PrimitiveType::operator==(const Type &other) const {
     if (this == &other) {
         return true;
     }
-    if (isInstanceOf<const PrimitiveType>(&other)) {
+    if (isInstanceOf<const PrimitiveType>(&other) &&
+        !isInstanceOf<const Enum>(&other)) {
         auto *primitiveType = dynamic_cast<const PrimitiveType *>(&other);
         return type == primitiveType->type;
     }
diff --git a/tests/samples/IncludesHeader.h b/tests/samples/IncludesHeader.h
@@ -0,0 +1,8 @@
+#include "include/included.h"
+
+size getSize(struct document *d);
+
+struct courseInfo {
+    char *name;
+    enum semester s;
+};
diff --git a/tests/samples/IncludesHeader.scala b/tests/samples/IncludesHeader.scala
@@ -0,0 +1,51 @@
+package org.scalanative.bindgen.samples
+
+import scala.scalanative._
+import scala.scalanative.native._
+
+@native.link("bindgentests")
+@native.extern
+object IncludesHeader {
+  type size = native.CInt
+  type struct_metadata = native.CStruct2[native.CUnsignedInt, native.CString]
+  type metadata = struct_metadata
+  type struct_document = native.CStruct1[metadata]
+  type enum_semester = native.CUnsignedInt
+  type struct_courseInfo = native.CStruct2[native.CString, enum_semester]
+  def getSize(d: native.Ptr[struct_document]): size = native.extern
+}
+
+import IncludesHeader._
+
+object IncludesHeaderEnums {
+  final val enum_semester_AUTUMN: enum_semester = 0.toUInt
+  final val enum_semester_SPRING: enum_semester = 1.toUInt
+}
+
+object IncludesHeaderHelpers {
+
+  implicit class struct_metadata_ops(val p: native.Ptr[struct_metadata]) extends AnyVal {
+    def year: native.CUnsignedInt = !p._1
+    def year_=(value: native.CUnsignedInt): Unit = !p._1 = value
+    def publisher: native.CString = !p._2
+    def publisher_=(value: native.CString): Unit = !p._2 = value
+  }
+
+  def struct_metadata()(implicit z: native.Zone): native.Ptr[struct_metadata] = native.alloc[struct_metadata]
+
+  implicit class struct_document_ops(val p: native.Ptr[struct_document]) extends AnyVal {
+    def m: native.Ptr[metadata] = p._1
+    def m_=(value: native.Ptr[metadata]): Unit = !p._1 = !value
+  }
+
+  def struct_document()(implicit z: native.Zone): native.Ptr[struct_document] = native.alloc[struct_document]
+
+  implicit class struct_courseInfo_ops(val p: native.Ptr[struct_courseInfo]) extends AnyVal {
+    def name: native.CString = !p._1
+    def name_=(value: native.CString): Unit = !p._1 = value
+    def s: enum_semester = !p._2
+    def s_=(value: enum_semester): Unit = !p._2 = value
+  }
+
+  def struct_courseInfo()(implicit z: native.Zone): native.Ptr[struct_courseInfo] = native.alloc[struct_courseInfo]
+}
diff --git a/tests/samples/include/included.h b/tests/samples/include/included.h

Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,9 @@ std::string TypeAndName::getName() const { return name; }`
`11`	`11`	`void TypeAndName::setType(std::shared_ptr<Type> type) { this->type = type; }`
`12`	`12`
`13`	`13`	`bool TypeAndName::operator==(const TypeAndName &other) const {`
	`14`	`+ if (this == &other) {`
	`15`	`+ return true;`
	`16`	`+ }`
`14`	`17`	`return name == other.name && type == other.type;`
`15`	`18`	`}`
`16`	`19`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`#include "ArrayType.h"`
`2`	`2`	`#include "../../Utils.h"`
	`3`	`+#include "../Struct.h"`
`3`	`4`
`4`	`5`	`ArrayType::ArrayType(std::shared_ptr<Type> elementsType, uint64_t size)`
`5`	`6`	`: size(size), elementsType(std::move(elementsType)) {}`
`@@ -12,19 +13,20 @@ std::string ArrayType::str() const {`
`12`	`13`	`bool ArrayType::usesType(const std::shared_ptr<Type> &type,`
`13`	`14`	`bool stopOnTypeDefs) const {`
`14`	`15`	`return elementsType == type \|\|`
`15`		`- elementsType.get()->usesType(type, stopOnTypeDefs);`
	`16`	`+ elementsType->usesType(type, stopOnTypeDefs);`
`16`	`17`	`}`
`17`	`18`
`18`	`19`	`bool ArrayType::operator==(const Type &other) const {`
`19`	`20`	`if (this == &other) {`
`20`	`21`	`return true;`
`21`	`22`	`}`
`22`		`- if (isInstanceOf<const ArrayType>(&other)) {`
	`23`	`+ if (isInstanceOf<const ArrayType>(&other) &&`
	`24`	`+ !isInstanceOf<const Union>(&other)) {`
`23`	`25`	`auto arrayType = dynamic_cast<const ArrayType >(&other);`
`24`	`26`	`if (size != arrayType->size) {`
`25`	`27`	`return false;`
`26`	`28`	`}`
`27`		`- return elementsType == arrayType->elementsType.get();`
	`29`	`+ return elementsType == arrayType->elementsType;`
`28`	`30`	`}`
`29`	`31`	`return false;`
`30`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`#include "PrimitiveType.h"`
`2`	`2`	`#include "../../Utils.h"`
	`3`	`+#include "../Enum.h"`
`3`	`4`
`4`	`5`	`PrimitiveType::PrimitiveType(std::string type) : type(std::move(type)) {}`
`5`	`6`
`@@ -16,7 +17,8 @@ bool PrimitiveType::operator==(const Type &other) const {`
`16`	`17`	`if (this == &other) {`
`17`	`18`	`return true;`
`18`	`19`	`}`
`19`		`- if (isInstanceOf<const PrimitiveType>(&other)) {`
	`20`	`+ if (isInstanceOf<const PrimitiveType>(&other) &&`
	`21`	`+ !isInstanceOf<const Enum>(&other)) {`
`20`	`22`	`auto primitiveType = dynamic_cast<const PrimitiveType >(&other);`
`21`	`23`	`return type == primitiveType->type;`
`22`	`24`	`}`