Check number of headers before running bindgen

kornilova203 · kornilova203 · commit 7e453896559f · 2018-07-10T20:46:01.000+03:00
Cast type to Union/Struct in operator== of Union/Struct class
Fix error message when definition of opaque type was not found
diff --git a/bindgen/Main.cpp b/bindgen/Main.cpp
@@ -30,6 +30,12 @@ int main(int argc, const char *argv[]) {
     clang::tooling::ClangTool Tool(op.getCompilations(),
                                    op.getSourcePathList());
 
+    if (op.getSourcePathList().size() != 1) {
+        llvm::errs() << "Error: Only one file may be processed at a time.\n";
+        llvm::errs().flush();
+        return -1;
+    }
+
     auto libName = LibName.getValue();
     if (libName.empty()) {
         llvm::errs()
@@ -53,7 +59,6 @@ int main(int argc, const char *argv[]) {
         objectName = "nativeLib";
     }
 
-    assert(op.getSourcePathList().size() == 1);
     char *resolved = realpath(op.getSourcePathList()[0].c_str(), nullptr);
     LocationManager locationManager(resolved);
 
diff --git a/bindgen/ir/Enum.h b/bindgen/ir/Enum.h
@@ -39,9 +39,6 @@ class Enum : public PrimitiveType, public std::enable_shared_from_this<Enum> {
   private:
     std::string name; // might be empty
     std::vector<Enumerator> enumerators;
-    /**
-     * nullptr if type is generated.
-     */
     std::shared_ptr<Location> location;
 };
 
diff --git a/bindgen/ir/IR.cpp b/bindgen/ir/IR.cpp
@@ -108,7 +108,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
           << "object " << objectName << " {\n";
 
         for (const auto &typeDef : ir.typeDefs) {
-            if (ir.isOutputted(typeDef)) {
+            if (ir.shouldOutput(typeDef)) {
                 s << *typeDef;
             }
         }
@@ -145,7 +145,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
 
         std::string sep = "";
         for (const auto &e : ir.enums) {
-            if (ir.isOutputted(e)) {
+            if (ir.shouldOutput(e)) {
                 s << sep << *e;
                 sep = "\n";
             }
@@ -158,13 +158,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) && st->hasHelperMethods()) {
+            if (ir.shouldOutput(st) && st->hasHelperMethods()) {
                 s << "\n" << st->generateHelperClass();
             }
         }
 
         for (const auto &u : ir.unions) {
-            if (ir.isOutputted(u)) {
+            if (ir.shouldOutput(u)) {
                 s << "\n" << u->generateHelperClass();
             }
         }
@@ -179,7 +179,6 @@ void IR::generate(const std::string &excludePrefix) {
     if (!generated) {
         setScalaNames();
         filterDeclarations(excludePrefix);
-        //        removeUnusedExternalTypedefs();
         generated = true;
     }
 }
@@ -191,7 +190,7 @@ bool IR::hasHelperMethods() const {
     }
 
     for (const auto &s : structs) {
-        if (isOutputted(s) && s->hasHelperMethods()) {
+        if (shouldOutput(s) && s->hasHelperMethods()) {
             return true;
         }
     }
@@ -269,7 +268,7 @@ bool IR::isTypeUsed(const std::shared_ptr<Type> &type,
          * references this type */
         for (const auto &typeDef : typeDefs) {
             if (typeDef->usesType(type, false)) {
-                if (isOutputted(typeDef)) {
+                if (shouldOutput(typeDef)) {
                     return true;
                 }
             }
@@ -278,7 +277,7 @@ bool IR::isTypeUsed(const std::shared_ptr<Type> &type,
             /* stopOnTypeDefs parameter is true because because typedefs were
              * checked */
             if (s->usesType(type, true)) {
-                if (isOutputted(s)) {
+                if (shouldOutput(s)) {
                     return true;
                 }
             }
@@ -287,7 +286,7 @@ bool IR::isTypeUsed(const std::shared_ptr<Type> &type,
             /* stopOnTypeDefs parameter is true because because typedefs were
              * checked */
             if (u->usesType(type, true)) {
-                if (isOutputted(u)) {
+                if (shouldOutput(u)) {
                     return true;
                 }
             }
@@ -429,14 +428,14 @@ template <typename T>
 bool IR::hasOutputtedDeclaration(
     const std::vector<std::shared_ptr<T>> &declarations) const {
     for (const auto &declaration : declarations) {
-        if (isOutputted(declaration)) {
+        if (shouldOutput(declaration)) {
             return true;
         }
     }
     return false;
 }
 
 template <typename T>
-bool IR::isOutputted(const std::shared_ptr<T> &type) const {
+bool IR::shouldOutput(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
@@ -152,7 +152,7 @@ class IR {
      *         main file.
      */
     template <typename T>
-    bool isOutputted(const std::shared_ptr<T> &type) const;
+    bool shouldOutput(const std::shared_ptr<T> &type) const;
 
     /**
      * @tparam T Struct or Union
diff --git a/bindgen/ir/Struct.cpp b/bindgen/ir/Struct.cpp
@@ -156,9 +156,9 @@ bool Struct::usesType(const std::shared_ptr<Type> &type,
 }
 
 bool Struct::operator==(const Type &other) const {
-    auto *structOrUnion = dynamic_cast<const StructOrUnion *>(&other);
-    if (structOrUnion) {
-        return this->equals(*structOrUnion);
+    auto *s = dynamic_cast<const Struct *>(&other);
+    if (s) {
+        return this->equals(*s);
     }
     return false;
 }
@@ -198,9 +198,9 @@ 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);
+    auto *u = dynamic_cast<const Union *>(&other);
+    if (u) {
+        return this->equals(*u);
     }
     return false;
 }
diff --git a/bindgen/ir/Struct.h b/bindgen/ir/Struct.h
@@ -40,9 +40,6 @@ class StructOrUnion {
   protected:
     std::string name;
     std::vector<Field *> fields;
-    /**
-     * nullptr if type is generated.
-     */
     std::shared_ptr<Location> location;
 };
 
diff --git a/bindgen/ir/TypeDef.cpp b/bindgen/ir/TypeDef.cpp
@@ -10,7 +10,7 @@ TypeDef::TypeDef(std::string name, std::shared_ptr<Type> type,
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const TypeDef &typeDef) {
     if (!typeDef.getType()) {
-        llvm::errs() << "Error: type declaration for " << typeDef.getName()
+        llvm::errs() << "Error: type definition for " << typeDef.getName()
                      << " was not found.\n";
         llvm::errs().flush();
         return s;
@@ -25,8 +25,10 @@ bool TypeDef::usesType(const std::shared_ptr<Type> &type,
     if (stopOnTypeDefs) {
         return false;
     }
-    return *this->type == *type ||
-           this->type.get()->usesType(type, stopOnTypeDefs);
+    if (!this->type) {
+        return false;
+    }
+    return *this->type == *type || this->type->usesType(type, stopOnTypeDefs);
 }
 
 std::string TypeDef::str() const { return handleReservedWords(name); }
diff --git a/tests/samples/include/included.h b/tests/samples/include/included.h
@@ -31,7 +31,7 @@ enum unusedEnum { UNUSED }; // removed
 typedef enum unusedEnum unusedEnum; // removed
 
 struct unusedStruct {
-    enum unusedEnum e; // removed
-};
+    enum unusedEnum e;
+}; // removed
 
 enum semester { AUTUMN, SPRING };

Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {`
`108`	`108`	`<< "object " << objectName << " {\n";`
`109`	`109`
`110`	`110`	`for (const auto &typeDef : ir.typeDefs) {`
`111`		`- if (ir.isOutputted(typeDef)) {`
	`111`	`+ if (ir.shouldOutput(typeDef)) {`
`112`	`112`	`s << *typeDef;`
`113`	`113`	`}`
`114`	`114`	`}`
`@@ -145,7 +145,7 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {`
`145`	`145`
`146`	`146`	`std::string sep = "";`
`147`	`147`	`for (const auto &e : ir.enums) {`
`148`		`- if (ir.isOutputted(e)) {`
	`148`	`+ if (ir.shouldOutput(e)) {`
`149`	`149`	`s << sep << *e;`
`150`	`150`	`sep = "\n";`
`151`	`151`	`}`
`@@ -158,13 +158,13 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {`
`158`	`158`	`s << "object " << ir.libName << "Helpers {\n";`
`159`	`159`
`160`	`160`	`for (const auto &st : ir.structs) {`
`161`		`- if (ir.isOutputted(st) && st->hasHelperMethods()) {`
	`161`	`+ if (ir.shouldOutput(st) && st->hasHelperMethods()) {`
`162`	`162`	`s << "\n" << st->generateHelperClass();`
`163`	`163`	`}`
`164`	`164`	`}`
`165`	`165`
`166`	`166`	`for (const auto &u : ir.unions) {`
`167`		`- if (ir.isOutputted(u)) {`
	`167`	`+ if (ir.shouldOutput(u)) {`
`168`	`168`	`s << "\n" << u->generateHelperClass();`
`169`	`169`	`}`
`170`	`170`	`}`
`@@ -179,7 +179,6 @@ void IR::generate(const std::string &excludePrefix) {`
`179`	`179`	`if (!generated) {`
`180`	`180`	`setScalaNames();`
`181`	`181`	`filterDeclarations(excludePrefix);`
`182`		`- // removeUnusedExternalTypedefs();`
`183`	`182`	`generated = true;`
`184`	`183`	`}`
`185`	`184`	`}`
`@@ -191,7 +190,7 @@ bool IR::hasHelperMethods() const {`
`191`	`190`	`}`
`192`	`191`
`193`	`192`	`for (const auto &s : structs) {`
`194`		`- if (isOutputted(s) && s->hasHelperMethods()) {`
	`193`	`+ if (shouldOutput(s) && s->hasHelperMethods()) {`
`195`	`194`	`return true;`
`196`	`195`	`}`
`197`	`196`	`}`
`@@ -269,7 +268,7 @@ bool IR::isTypeUsed(const std::shared_ptr<Type> &type,`
`269`	`268`	`* references this type */`
`270`	`269`	`for (const auto &typeDef : typeDefs) {`
`271`	`270`	`if (typeDef->usesType(type, false)) {`
`272`		`- if (isOutputted(typeDef)) {`
	`271`	`+ if (shouldOutput(typeDef)) {`
`273`	`272`	`return true;`
`274`	`273`	`}`
`275`	`274`	`}`
`@@ -278,7 +277,7 @@ bool IR::isTypeUsed(const std::shared_ptr<Type> &type,`
`278`	`277`	`/* stopOnTypeDefs parameter is true because because typedefs were`
`279`	`278`	`* checked */`
`280`	`279`	`if (s->usesType(type, true)) {`
`281`		`- if (isOutputted(s)) {`
	`280`	`+ if (shouldOutput(s)) {`
`282`	`281`	`return true;`
`283`	`282`	`}`
`284`	`283`	`}`
`@@ -287,7 +286,7 @@ bool IR::isTypeUsed(const std::shared_ptr<Type> &type,`
`287`	`286`	`/* stopOnTypeDefs parameter is true because because typedefs were`
`288`	`287`	`* checked */`
`289`	`288`	`if (u->usesType(type, true)) {`
`290`		`- if (isOutputted(u)) {`
	`289`	`+ if (shouldOutput(u)) {`
`291`	`290`	`return true;`
`292`	`291`	`}`
`293`	`292`	`}`
`@@ -429,14 +428,14 @@ template <typename T>`
`429`	`428`	`bool IR::hasOutputtedDeclaration(`
`430`	`429`	`const std::vector<std::shared_ptr<T>> &declarations) const {`
`431`	`430`	`for (const auto &declaration : declarations) {`
`432`		`- if (isOutputted(declaration)) {`
	`431`	`+ if (shouldOutput(declaration)) {`
`433`	`432`	`return true;`
`434`	`433`	`}`
`435`	`434`	`}`
`436`	`435`	`return false;`
`437`	`436`	`}`
`438`	`437`
`439`	`438`	`template <typename T>`
`440`		`-bool IR::isOutputted(const std::shared_ptr<T> &type) const {`
	`439`	`+bool IR::shouldOutput(const std::shared_ptr<T> &type) const {`
`441`	`440`	`return inMainFile(*type) \|\| isTypeUsed(type, true);`
`442`	`441`	`}`
Original file line number	Diff line number	Diff line change
`@@ -156,9 +156,9 @@ bool Struct::usesType(const std::shared_ptr<Type> &type,`
`156`	`156`	`}`
`157`	`157`
`158`	`158`	`bool Struct::operator==(const Type &other) const {`
`159`		`- auto structOrUnion = dynamic_cast<const StructOrUnion >(&other);`
`160`		`- if (structOrUnion) {`
`161`		`- return this->equals(*structOrUnion);`
	`159`	`+ auto s = dynamic_cast<const Struct >(&other);`
	`160`	`+ if (s) {`
	`161`	`+ return this->equals(*s);`
`162`	`162`	`}`
`163`	`163`	`return false;`
`164`	`164`	`}`
`@@ -198,9 +198,9 @@ std::string Union::generateHelperClass() const {`
`198`	`198`	`std::string Union::getTypeAlias() const { return "union_" + name; }`
`199`	`199`
`200`	`200`	`bool Union::operator==(const Type &other) const {`
`201`		`- auto structOrUnion = dynamic_cast<const StructOrUnion >(&other);`
`202`		`- if (structOrUnion) {`
`203`		`- return this->equals(*structOrUnion);`
	`201`	`+ auto u = dynamic_cast<const Union >(&other);`
	`202`	`+ if (u) {`
	`203`	`+ return this->equals(*u);`
`204`	`204`	`}`
`205`	`205`	`return false;`
`206`	`206`	`}`