Do not generate TypeDef for enum

kornilova203 · kornilova203 · commit e2777eb95661 · 2018-08-09T11:24:19.000+03:00
diff --git a/bindgen/TypeTranslator.cpp b/bindgen/TypeTranslator.cpp
@@ -82,7 +82,7 @@ TypeTranslator::translatePointer(const clang::QualType &pte) {
 }
 
 std::shared_ptr<Type>
-TypeTranslator::translateRecordOrEnum(const clang::QualType &qtpe) {
+TypeTranslator::translateNonAnonymousRecord(const clang::QualType &qtpe) {
     std::string name = qtpe.getUnqualifiedType().getAsString();
 
     /* If the struct was already declared then there is a TypeDef instance
@@ -118,7 +118,7 @@ TypeTranslator::translateRecord(const clang::QualType &qtpe) {
         }
         return nullptr;
     }
-    return translateRecordOrEnum(qtpe);
+    return translateNonAnonymousRecord(qtpe);
 }
 
 std::shared_ptr<Type>
@@ -243,10 +243,17 @@ TypeTranslator::addStructDefinition(clang::RecordDecl *record,
 
 std::shared_ptr<Type>
 TypeTranslator::translateEnum(const clang::QualType &type) {
+    clang::EnumDecl *enumDecl = type->getAs<clang::EnumType>()->getDecl();
     if (type->hasUnnamedOrLocalType()) {
-        clang::EnumDecl *enumDecl = type->getAs<clang::EnumType>()->getDecl();
         return std::make_shared<PrimitiveType>(getTypeFromTypeMap(
             enumDecl->getIntegerType().getUnqualifiedType().getAsString()));
     }
-    return translateRecordOrEnum(type);
+    std::string name = enumDecl->getNameAsString();
+
+    if (name.empty()) {
+        name = enumDecl->getTypedefNameForAnonDecl()->getNameAsString();
+        return ir.getTypeDefWithName(name);
+    }
+    assert(!name.empty());
+    return ir.getEnumWithName(name);
 }
diff --git a/bindgen/TypeTranslator.h b/bindgen/TypeTranslator.h
@@ -35,7 +35,8 @@ class TypeTranslator {
      */
     std::map<std::string, std::string> typeMap;
 
-    std::shared_ptr<Type> translateRecordOrEnum(const clang::QualType &qtpe);
+    std::shared_ptr<Type>
+    translateNonAnonymousRecord(const clang::QualType &qtpe);
 
     std::shared_ptr<Type> translateRecord(const clang::QualType &qtpe);
 
diff --git a/bindgen/ir/Enum.cpp b/bindgen/ir/Enum.cpp
@@ -15,9 +15,8 @@ Enum::Enum(std::string name, std::string type,
 
 bool Enum::isAnonymous() const { return name.empty(); }
 
-std::shared_ptr<TypeDef> Enum::generateTypeDef() {
-    return std::make_shared<TypeDef>(getTypeName(), shared_from_this(),
-                                     nullptr);
+std::string Enum::getDefinition() {
+    return "  type " + getTypeAlias() + " = " + PrimitiveType::str() + "\n";
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const Enum &e) {
@@ -51,7 +50,14 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const Enum &e) {
 
 std::string Enum::getName() const { return name; }
 
-std::string Enum::getTypeName() const {
+std::string Enum::getTypeAlias() const {
     assert(!isAnonymous());
-    return "enum " + name;
+    return "enum_" + name;
+}
+
+std::string Enum::str(const LocationManager &locationManager) const {
+    if (locationManager.isImported(*location)) {
+        return locationManager.getImportedType(*location, getTypeAlias());
+    }
+    return getTypeAlias();
 }
diff --git a/bindgen/ir/Enum.h b/bindgen/ir/Enum.h
@@ -27,13 +27,15 @@ class Enum : public PrimitiveType, public LocatableType {
 
     bool isAnonymous() const;
 
-    std::shared_ptr<TypeDef> generateTypeDef();
+    std::string getDefinition();
 
     std::string getName() const;
 
     friend llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const Enum &e);
 
-    std::string getTypeName() const;
+    std::string getTypeAlias() const;
+
+    std::string str(const LocationManager &locationManager) const override;
 
   private:
     std::string name; // might be empty
diff --git a/bindgen/ir/IR.cpp b/bindgen/ir/IR.cpp
@@ -22,15 +22,15 @@ std::shared_ptr<TypeDef> IR::addTypeDef(std::string name,
     return typeDefs.back();
 }
 
-void IR::addEnum(std::string name, const std::string &type,
-                 std::vector<Enumerator> enumerators,
-                 std::shared_ptr<Location> location) {
+std::shared_ptr<Enum> IR::addEnum(std::string name, const std::string &type,
+                                  std::vector<Enumerator> enumerators,
+                                  std::shared_ptr<Location> location) {
     std::shared_ptr<Enum> e = std::make_shared<Enum>(
         std::move(name), type, std::move(enumerators), std::move(location));
+
     enums.push_back(e);
-    if (!e->isAnonymous()) {
-        typeDefs.push_back(e->generateTypeDef());
-    }
+
+    return e;
 }
 
 std::shared_ptr<TypeDef>
@@ -89,7 +89,7 @@ void IR::addVarDefine(std::string name, std::shared_ptr<Variable> variable) {
 bool IR::libObjEmpty() const {
     return functions.empty() && !shouldOutputType(typeDefs) &&
            !shouldOutputType(structs) && !shouldOutputType(unions) &&
-           varDefines.empty() && variables.empty();
+           varDefines.empty() && variables.empty() && enums.empty();
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
@@ -120,6 +120,13 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir) {
 
     std::vector<std::shared_ptr<const Type>> visitedTypes;
 
+    for (const auto &e : ir.enums) {
+        visitedTypes.clear();
+        if (!e->isAnonymous() && ir.shouldOutput(e, visitedTypes)) {
+            s << e->getDefinition();
+        }
+    }
+
     for (const auto &typeDef : ir.typeDefs) {
         visitedTypes.clear();
         if (ir.shouldOutputTypeDef(typeDef, visitedTypes)) {
@@ -435,6 +442,10 @@ std::shared_ptr<TypeDef> IR::getTypeDefWithName(const std::string &name) const {
     return getDeclarationWithName(typeDefs, name);
 }
 
+std::shared_ptr<Enum> IR::getEnumWithName(const std::string &name) const {
+    return getDeclarationWithName(enums, name);
+}
+
 template <typename T>
 T IR::getDeclarationWithName(const std::vector<T> &declarations,
                              const std::string &name) const {
diff --git a/bindgen/ir/IR.h b/bindgen/ir/IR.h
@@ -29,12 +29,9 @@ class IR {
                                         std::shared_ptr<Type> type,
                                         std::shared_ptr<Location> location);
 
-    /**
-     * @return type alias for the enum
-     */
-    void addEnum(std::string name, const std::string &type,
-                 std::vector<Enumerator> enumerators,
-                 std::shared_ptr<Location> location);
+    std::shared_ptr<Enum> addEnum(std::string name, const std::string &type,
+                                  std::vector<Enumerator> enumerators,
+                                  std::shared_ptr<Location> location);
 
     std::shared_ptr<TypeDef>
     addStruct(std::string name, std::vector<std::shared_ptr<Field>> fields,
@@ -76,6 +73,8 @@ class IR {
 
     std::shared_ptr<TypeDef> getTypeDefWithName(const std::string &name) const;
 
+    std::shared_ptr<Enum> getEnumWithName(const std::string &name) const;
+
   private:
     /**
      * @return true if helper methods will be generated for this library
diff --git a/bindgen/ir/TypeDef.cpp b/bindgen/ir/TypeDef.cpp
@@ -1,6 +1,5 @@
 #include "TypeDef.h"
 #include "../Utils.h"
-#include "Enum.h"
 #include "Struct.h"
 #include "Union.h"
 #include <sstream>
@@ -82,12 +81,7 @@ std::shared_ptr<Location> TypeDef::getLocation() const {
     if (recordPointer) {
         return recordPointer->getLocation();
     }
-    auto enumPointer = std::dynamic_pointer_cast<const Enum>(type);
-    if (enumPointer) {
-        return enumPointer->getLocation();
-    }
-    throw std::logic_error(
-        "Generated typedef may reference only struct, union or enum");
+    throw std::logic_error("Generated typedef may reference only records.");
 }
 
 bool TypeDef::hasLocation() const { return location || type; }
@@ -105,8 +99,7 @@ bool TypeDef::findAllCycles(
 }
 
 std::shared_ptr<const Type> TypeDef::unrollTypedefs() const {
-    if (!type || isInstanceOf<Struct>(type.get()) ||
-        isInstanceOf<Union>(type.get()) || isInstanceOf<Enum>(type.get())) {
+    if (isGenerated()) {
         return std::make_shared<TypeDef>(name, type, nullptr);
     }
     return type->unrollTypedefs();
@@ -115,9 +108,7 @@ std::shared_ptr<const Type> TypeDef::unrollTypedefs() const {
 std::shared_ptr<const Type>
 TypeDef::replaceType(const std::shared_ptr<const Type> &type,
                      const std::shared_ptr<const Type> &replacement) const {
-    if (!this->type || isInstanceOf<Struct>(this->type.get()) ||
-        isInstanceOf<Union>(this->type.get()) ||
-        isInstanceOf<Enum>(this->type.get())) {
+    if (isGenerated()) {
         return std::make_shared<TypeDef>(name, this->type, nullptr);
     }
     if (*this->type == *type) {
@@ -128,3 +119,8 @@ TypeDef::replaceType(const std::shared_ptr<const Type> &type,
 }
 
 bool TypeDef::wrapperForOpaqueType() const { return !type; }
+
+bool TypeDef::isGenerated() const {
+    return !this->type || isInstanceOf<Struct>(this->type.get()) ||
+           isInstanceOf<Union>(this->type.get());
+}
diff --git a/bindgen/ir/TypeDef.h b/bindgen/ir/TypeDef.h
@@ -47,9 +47,12 @@ class TypeDef : public TypeAndName, public LocatableType {
 
     /**
      * @return location of the typedef is it is not generated otherwise
-     *         location of referenced type (struct, union or enum).
+     *         location of referenced record.
      */
     std::shared_ptr<Location> getLocation() const override;
+
+  private:
+    bool isGenerated() const;
 };
 
 #endif // SCALA_NATIVE_BINDGEN_TYPEDEF_H
diff --git a/bindgen/ir/types/PrimitiveType.cpp b/bindgen/ir/types/PrimitiveType.cpp
@@ -4,8 +4,10 @@
 
 PrimitiveType::PrimitiveType(std::string type) : type(std::move(type)) {}
 
+std::string PrimitiveType::str() const { return handleReservedWords(type); }
+
 std::string PrimitiveType::str(const LocationManager &locationManager) const {
-    return handleReservedWords(type);
+    return str();
 }
 
 std::string PrimitiveType::getType() const { return type; }
diff --git a/bindgen/ir/types/PrimitiveType.h b/bindgen/ir/types/PrimitiveType.h
@@ -17,6 +17,8 @@ class PrimitiveType : virtual public Type {
         const std::shared_ptr<const Type> &type, bool stopOnTypeDefs,
         std::vector<std::shared_ptr<const Type>> &visitedTypes) const override;
 
+    std::string str() const;
+
     std::string str(const LocationManager &locationManager) const override;
 
     bool operator==(const Type &other) const override;
diff --git a/bindgen/visitor/TreeVisitor.cpp b/bindgen/visitor/TreeVisitor.cpp
@@ -34,6 +34,11 @@ bool TreeVisitor::VisitFunctionDecl(clang::FunctionDecl *func) {
 bool TreeVisitor::VisitTypedefDecl(clang::TypedefDecl *tpdef) {
     std::string name = tpdef->getName();
 
+    if (isAliasForAnonymousEnum(tpdef)) {
+        /* typedef was already created */
+        return true;
+    }
+
     std::shared_ptr<Type> type =
         typeTranslator.translate(tpdef->getUnderlyingType());
     if (type) {
@@ -42,25 +47,40 @@ bool TreeVisitor::VisitTypedefDecl(clang::TypedefDecl *tpdef) {
     return true;
 }
 
-bool TreeVisitor::VisitEnumDecl(clang::EnumDecl *enumdecl) {
-    std::string name = enumdecl->getNameAsString();
+bool TreeVisitor::isAliasForAnonymousEnum(clang::TypedefDecl *tpdef) const {
+    clang::QualType underlyingType = tpdef->getUnderlyingType();
+    if (!underlyingType->isEnumeralType()) {
+        return false;
+    }
+    const clang::EnumType *enumType = underlyingType->getAs<clang::EnumType>();
+    return enumType->getDecl()->getTypedefNameForAnonDecl();
+}
+
+bool TreeVisitor::VisitEnumDecl(clang::EnumDecl *enumDecl) {
+    std::string name = enumDecl->getNameAsString();
 
-    if (name.empty() && enumdecl->getTypedefNameForAnonDecl()) {
-        name = enumdecl->getTypedefNameForAnonDecl()->getNameAsString();
+    clang::TypedefNameDecl *typedefName = enumDecl->getTypedefNameForAnonDecl();
+    if (name.empty() && typedefName) {
+        name = typedefName->getNameAsString();
     }
 
     std::vector<Enumerator> enumerators;
 
-    for (const clang::EnumConstantDecl *en : enumdecl->enumerators()) {
+    for (const clang::EnumConstantDecl *en : enumDecl->enumerators()) {
         int64_t value = en->getInitVal().getSExtValue();
         enumerators.emplace_back(en->getNameAsString(), value);
     }
 
     std::string scalaType = typeTranslator.getTypeFromTypeMap(
-        enumdecl->getIntegerType().getUnqualifiedType().getAsString());
+        enumDecl->getIntegerType().getUnqualifiedType().getAsString());
 
-    ir.addEnum(name, scalaType, std::move(enumerators),
-               typeTranslator.getLocation(enumdecl));
+    std::shared_ptr<Enum> e =
+        ir.addEnum(name, scalaType, std::move(enumerators),
+                   typeTranslator.getLocation(enumDecl));
+
+    if (typedefName) {
+        ir.addTypeDef(name, e, typeTranslator.getLocation(typedefName));
+    }
 
     return true;
 }
diff --git a/bindgen/visitor/TreeVisitor.h b/bindgen/visitor/TreeVisitor.h
@@ -11,6 +11,8 @@ class TreeVisitor : public clang::RecursiveASTVisitor<TreeVisitor> {
     TypeTranslator typeTranslator;
     IR &ir;
 
+    bool isAliasForAnonymousEnum(clang::TypedefDecl *tpdef) const;
+
   public:
     TreeVisitor(clang::CompilerInstance *CI, IR &ir)
         : astContext(&(CI->getASTContext())), typeTranslator(astContext, ir),
@@ -20,7 +22,7 @@ class TreeVisitor : public clang::RecursiveASTVisitor<TreeVisitor> {
 
     virtual bool VisitFunctionDecl(clang::FunctionDecl *func);
     virtual bool VisitTypedefDecl(clang::TypedefDecl *tpdef);
-    virtual bool VisitEnumDecl(clang::EnumDecl *enumdecl);
+    virtual bool VisitEnumDecl(clang::EnumDecl *enumDecl);
     virtual bool VisitRecordDecl(clang::RecordDecl *record);
     virtual bool VisitVarDecl(clang::VarDecl *VD);
 };
diff --git a/tests/samples/IncludesHeader.scala b/tests/samples/IncludesHeader.scala
@@ -6,11 +6,11 @@ import scala.scalanative.native._
 @native.link("bindgentests")
 @native.extern
 object IncludesHeader {
+  type enum_semester = native.CUnsignedInt
   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
 }
diff --git a/tests/samples/PrivateMembers.scala b/tests/samples/PrivateMembers.scala
@@ -6,14 +6,14 @@ import scala.scalanative.native._
 @native.link("bindgentests")
 @native.extern
 object PrivateMembers {
+  type enum___privateEnum = native.CUnsignedInt
+  type enum_enumWithPrivateMembers = native.CUnsignedInt
   type pid_t = native.CInt
   type __private_type = native.CInt
   type struct_structWithPrivateType = native.CStruct2[native.CInt, __private_type]
   type union___unionWithPrivateName = native.CArray[Byte, native.Nat._4]
   type struct_structWithPrivateStruct = native.CStruct1[native.Ptr[struct_structWithPrivateType]]
   type struct_normalStruct = native.CStruct1[native.CInt]
-  type enum___privateEnum = native.CUnsignedInt
-  type enum_enumWithPrivateMembers = native.CUnsignedInt
   type struct_privateStructWithTypedef = native.CStruct1[native.Ptr[__private_type]]
   type privateStructWithTypedef = struct_privateStructWithTypedef
   type privateStructWithTypedefPtr = native.Ptr[struct_privateStructWithTypedef]
diff --git a/tests/samples/Struct.scala b/tests/samples/Struct.scala
@@ -6,18 +6,18 @@ import scala.scalanative.native._
 @native.link("bindgentests")
 @native.extern
 object Struct {
+  type enum_pointIndex = native.CUnsignedInt
+  type enum_struct_op = native.CUnsignedInt
   type struct_point = native.CStruct2[native.CInt, native.CInt]
   type point = struct_point
   type struct_points = native.CStruct2[struct_point, point]
-  type enum_pointIndex = native.CUnsignedInt
   type point_s = native.Ptr[struct_point]
   type struct_bigStruct = native.CArray[Byte, native.Nat.Digit[native.Nat._1, native.Nat.Digit[native.Nat._1, native.Nat._2]]]
   type struct_anonymous_0 = native.CStruct2[native.CChar, native.CInt]
   type struct_structWithAnonymousStruct = native.CStruct2[native.CInt, struct_anonymous_0]
   type struct_packedStruct = native.CStruct1[native.CChar]
   type struct_bitFieldStruct = native.CArray[Byte, native.Nat._2]
   type struct_bitFieldOffsetDivByEight = native.CArray[Byte, native.Nat._4]
-  type enum_struct_op = native.CUnsignedInt
   def setPoints(points: native.Ptr[struct_points], x1: native.CInt, y1: native.CInt, x2: native.CInt, y2: native.CInt): Unit = native.extern
   def getPoint(points: native.Ptr[struct_points], pointIndex: enum_pointIndex): native.CInt = native.extern
   def createPoint(): native.Ptr[struct_point] = native.extern
diff --git a/tests/samples/Union.scala b/tests/samples/Union.scala

Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ TypeTranslator::translatePointer(const clang::QualType &pte) {`
`82`	`82`	`}`
`83`	`83`
`84`	`84`	`std::shared_ptr<Type>`
`85`		`-TypeTranslator::translateRecordOrEnum(const clang::QualType &qtpe) {`
	`85`	`+TypeTranslator::translateNonAnonymousRecord(const clang::QualType &qtpe) {`
`86`	`86`	`std::string name = qtpe.getUnqualifiedType().getAsString();`
`87`	`87`
`88`	`88`	`/* If the struct was already declared then there is a TypeDef instance`
`@@ -118,7 +118,7 @@ TypeTranslator::translateRecord(const clang::QualType &qtpe) {`
`118`	`118`	`}`
`119`	`119`	`return nullptr;`
`120`	`120`	`}`
`121`		`- return translateRecordOrEnum(qtpe);`
	`121`	`+ return translateNonAnonymousRecord(qtpe);`
`122`	`122`	`}`
`123`	`123`
`124`	`124`	`std::shared_ptr<Type>`
`@@ -243,10 +243,17 @@ TypeTranslator::addStructDefinition(clang::RecordDecl *record,`
`243`	`243`
`244`	`244`	`std::shared_ptr<Type>`
`245`	`245`	`TypeTranslator::translateEnum(const clang::QualType &type) {`
	`246`	`+ clang::EnumDecl *enumDecl = type->getAs<clang::EnumType>()->getDecl();`
`246`	`247`	`if (type->hasUnnamedOrLocalType()) {`
`247`		`- clang::EnumDecl *enumDecl = type->getAs<clang::EnumType>()->getDecl();`
`248`	`248`	`return std::make_shared<PrimitiveType>(getTypeFromTypeMap(`
`249`	`249`	`enumDecl->getIntegerType().getUnqualifiedType().getAsString()));`
`250`	`250`	`}`
`251`		`- return translateRecordOrEnum(type);`
	`251`	`+ std::string name = enumDecl->getNameAsString();`
	`252`	`+`
	`253`	`+ if (name.empty()) {`
	`254`	`+ name = enumDecl->getTypedefNameForAnonDecl()->getNameAsString();`
	`255`	`+ return ir.getTypeDefWithName(name);`
	`256`	`+ }`
	`257`	`+ assert(!name.empty());`
	`258`	`+ return ir.getEnumWithName(name);`
`252`	`259`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,8 +4,10 @@`
`4`	`4`
`5`	`5`	`PrimitiveType::PrimitiveType(std::string type) : type(std::move(type)) {}`
`6`	`6`
	`7`	`+std::string PrimitiveType::str() const { return handleReservedWords(type); }`
	`8`	`+`
`7`	`9`	`std::string PrimitiveType::str(const LocationManager &locationManager) const {`
`8`		`- return handleReservedWords(type);`
	`10`	`+ return str();`
`9`	`11`	`}`
`10`	`12`
`11`	`13`	`std::string PrimitiveType::getType() const { return type; }`