Rename SimpleType and remove unused imports

Author: kornilova203

bindgen/CMakeLists.txt

@@ -56,8 +56,8 @@ add_executable(bindgen
   ir/PossibleVarDefine.h
   ir/types/Type.cpp
   ir/types/Type.h
-  ir/types/SimpleType.cpp
-  ir/types/SimpleType.h
+  ir/types/PrimitiveType.cpp
+  ir/types/PrimitiveType.h
   ir/types/PointerType.cpp
   ir/types/PointerType.h
   ir/types/FunctionPointerType.cpp

bindgen/TypeTranslator.cpp

@@ -1,9 +1,7 @@
 #include "TypeTranslator.h"
 #include "Utils.h"
-#include "ir/types/ArrayType.h"
 #include "ir/types/FunctionPointerType.h"
 #include "ir/types/PointerType.h"
-#include "ir/types/SimpleType.h"
 
 TypeTranslator::TypeTranslator(clang::ASTContext *ctx_, IR &ir)
     : ctx(ctx_), ir(ir), typeMap() {
@@ -67,13 +65,13 @@ Type *TypeTranslator::TranslatePointer(const clang::QualType &pte,
 
         // Take care of void*
         if (as->getKind() == clang::BuiltinType::Void) {
-            return new PointerType(new SimpleType("Byte"));
+            return new PointerType(new PrimitiveType("Byte"));
         }
 
         // Take care of char*
         if (as->getKind() == clang::BuiltinType::Char_S ||
             as->getKind() == clang::BuiltinType::SChar) {
-            return new SimpleType("native.CString");
+            return new PrimitiveType("native.CString");
         }
     }
 
@@ -84,15 +82,15 @@ Type *TypeTranslator::translateStruct(const clang::QualType &qtpe) {
     if (qtpe->hasUnnamedOrLocalType()) {
         // TODO: Verify that the local part is not a problem
         uint64_t size = ctx->getTypeSize(qtpe);
-        return new ArrayType(new SimpleType("Byte"), size);
+        return new ArrayType(new PrimitiveType("Byte"), size);
     }
 
     std::string name = qtpe.getUnqualifiedType().getAsString();
 
     // TODO: do it properly
     size_t f = name.find(std::string("struct __dirstream"));
     if (f != std::string::npos) {
-        return new ArrayType(new SimpleType("Byte"), 320);
+        return new ArrayType(new PrimitiveType("Byte"), 320);
     }
 
     auto it = aliasesMap.find(name);
@@ -109,7 +107,7 @@ Type *TypeTranslator::translateUnion(const clang::QualType &qtpe) {
     if (qtpe->hasUnnamedOrLocalType()) {
         // TODO: Verify that the local part is not a problem
         uint64_t size = ctx->getTypeSize(qtpe);
-        return new ArrayType(new SimpleType("Byte"), size);
+        return new ArrayType(new PrimitiveType("Byte"), size);
     }
 
     std::string name = qtpe.getUnqualifiedType().getAsString();
@@ -152,7 +150,7 @@ Type *TypeTranslator::translate(const clang::QualType &qtpe,
         // This is a type that we want to avoid the usage.
         // Êxample: A struct that has a pointer to itself
         uint64_t size = ctx->getTypeSize(tpe);
-        return new ArrayType(new SimpleType("Byte"), size);
+        return new ArrayType(new PrimitiveType("Byte"), size);
     }
 
     if (tpe->isFunctionPointerType()) {
@@ -180,7 +178,7 @@ Type *TypeTranslator::translate(const clang::QualType &qtpe,
 
         auto found = typeMap.find(qtpe.getUnqualifiedType().getAsString());
         if (found != typeMap.end()) {
-            return new SimpleType(found->second);
+            return new PrimitiveType(found->second);
         } else {
             return ir.getTypeDefWithName(
                 qtpe.getUnqualifiedType().getAsString());

bindgen/TypeTranslator.h

@@ -1,9 +1,6 @@
 #pragma once
 
 #include "ir/IR.h"
-#include "ir/types/Type.h"
-#include <clang/AST/AST.h>
-#include <clang/AST/ASTContext.h>
 #include <clang/Tooling/Tooling.h>
 
 class TypeTranslator {
@@ -26,8 +23,15 @@ class TypeTranslator {
   private:
     clang::ASTContext *ctx;
     IR &ir;
+
+    /**
+     * Primitive types
+     */
     std::map<std::string, std::string> typeMap;
 
+    /**
+     * Maps C struct, union or enum name to Type alias
+     */
     std::map<std::string, Type *> aliasesMap;
 
     Type *translateEnum(const clang::QualType &qtpe);

bindgen/defines/DefineFinder.cpp

@@ -1,5 +1,5 @@
 #include "DefineFinder.h"
-#include "../ir/types/SimpleType.h"
+#include "../ir/types/PrimitiveType.h"
 
 #include <llvm/ADT/APInt.h>
 #include <sstream>
@@ -42,7 +42,8 @@ void DefineFinder::MacroDefined(const clang::Token &macroNameTok,
             clang::Token stringToken = (*tokens)[0];
             std::string literal(stringToken.getLiteralData(),
                                 stringToken.getLength());
-            ir.addLiteralDefine(macroName, "c" + literal, new SimpleType("native.CString"));
+            ir.addLiteralDefine(macroName, "c" + literal,
+                                new PrimitiveType("native.CString"));
         } else if (tokens->size() == 1 &&
                    (*tokens)[0].getKind() == clang::tok::identifier) {
             // token might be a variable
@@ -116,19 +117,19 @@ void DefineFinder::addNumericConstantDefine(const std::string &macroName,
         if (parser.isLongLong) {
             /* literal has `LL` ending. `long long` is represented as `Long`
              * in Scala Native */
-            type = new SimpleType("native.CLongLong");
+            type = new PrimitiveType("native.CLongLong");
 
             /* must fit into Scala integer type */
-            if (!integerFitsIntoType<long, ulong>(parser, positive)) {
+            if (!integerFitsIntoType<long, unsigned long>(parser, positive)) {
                 std::free(type);
                 type = nullptr;
             }
         } else if (parser.isLong) {
             /* literal has `L` ending */
-            type = new SimpleType("native.CLong");
+            type = new PrimitiveType("native.CLong");
 
             /* must fit into Scala integer type */
-            if (!integerFitsIntoType<long, ulong>(parser, positive)) {
+            if (!integerFitsIntoType<long, unsigned long>(parser, positive)) {
                 std::free(type);
                 type = nullptr;
             }
@@ -145,7 +146,7 @@ void DefineFinder::addNumericConstantDefine(const std::string &macroName,
         }
     } else if (parser.isFloatingLiteral()) {
         if (fitsIntoDouble(parser)) {
-            type = new SimpleType("native.CDouble");
+            type = new PrimitiveType("native.CDouble");
             scalaLiteral = getDoubleLiteral(parser);
         }
     }
@@ -164,9 +165,9 @@ DefineFinder::getTypeOfIntegerLiteral(const clang::NumericLiteralParser &parser,
                                       bool positive) {
 
     if (integerFitsIntoType<int, uint>(parser, positive)) {
-        return new SimpleType("native.CInt");
+        return new PrimitiveType("native.CInt");
     } else if (integerFitsIntoType<long, unsigned long>(parser, positive)) {
-        return new SimpleType("native.CLong");
+        return new PrimitiveType("native.CLong");
     } else {
         llvm::errs() << "Warning: integer value does not fit into 8 bytes: "
                      << literal << "\n";

bindgen/ir/Enum.cpp

@@ -1,6 +1,4 @@
 #include "Enum.h"
-#include <sstream>
-#include <utility>
 
 Enumerator::Enumerator(std::string name, int64_t value)
     : name(std::move(name)), value(value) {}
@@ -11,7 +9,7 @@ int64_t Enumerator::getValue() { return value; }
 
 Enum::Enum(std::string name, std::string type,
            std::vector<Enumerator> enumerators)
-    : SimpleType(std::move(type)), name(std::move(name)),
+    : PrimitiveType(std::move(type)), name(std::move(name)),
       enumerators(std::move(enumerators)) {}
 
 bool Enum::isAnonymous() const { return name.empty(); }

bindgen/ir/Enum.h

@@ -2,9 +2,7 @@
 #define SCALA_NATIVE_BINDGEN_ENUM_H
 
 #include "TypeDef.h"
-#include "types/SimpleType.h"
-#include <llvm/Support/raw_ostream.h>
-#include <string>
+#include "types/PrimitiveType.h"
 #include <vector>
 
 class Enumerator {
@@ -20,7 +18,7 @@ class Enumerator {
     int64_t value;
 };
 
-class Enum : public SimpleType {
+class Enum : public PrimitiveType {
   public:
     Enum(std::string name, std::string type,
          std::vector<Enumerator> enumerators);

bindgen/ir/IR.cpp

@@ -8,8 +8,8 @@ IR::IR(std::string libName, std::string linkName, std::string objectName,
 
 void IR::addFunction(std::string name, std::vector<Parameter> parameters,
                      Type *retType, bool isVariadic) {
-    functions.push_back(new Function(name, std::move(parameters),
-                                     retType, isVariadic));
+    functions.push_back(
+        new Function(name, std::move(parameters), retType, isVariadic));
 }
 
 void IR::addTypeDef(std::string name, Type *type) {
@@ -50,7 +50,7 @@ void IR::addLiteralDefine(std::string name, std::string literal, Type *type) {
 
 void IR::addPossibleVarDefine(const std::string &macroName,
                               const std::string &varName) {
-    possibleVarDefines.emplace_back(macroName, varName);
+    possibleVarDefines.push_back(new PossibleVarDefine(macroName, varName));
 }
 
 void IR::addVarDefine(std::string name, Variable *variable) {
@@ -165,8 +165,6 @@ bool IR::hasHelperMethods() const {
     return false;
 }
 
-bool IR::hasEnums() const { return !enums.empty(); }
-
 void IR::filterDeclarations(const std::string &excludePrefix) {
     if (excludePrefix.empty()) {
         return;
@@ -283,30 +281,12 @@ std::string IR::getDefineForVar(const std::string &varName) const {
     return "";
 }
 
-Variable *IR::addVariable(const std::string &name, const std::string &type) {
+Variable *IR::addVariable(const std::string &name, Type *type) {
     Variable *variable = new Variable(name, type);
     variables.push_back(variable);
     return variable;
 }
 
-IR::~IR() {
-    for (auto variable : variables) {
-        std::free(variable);
-    }
-}
-
-Enum *IR::getEnumWithName(const std::string &name) {
-    return getDeclarationWithName(enums, name);
-}
-
-Struct *IR::getStructWithName(const std::string &name) {
-    return getDeclarationWithName(structs, name);
-}
-
-Union *IR::getUnionWithName(const std::string &name) {
-    return getDeclarationWithName(unions, name);
-}
-
 TypeDef *IR::getTypeDefWithName(const std::string &name) {
     return getDeclarationWithName(typeDefs, name);
 }
@@ -323,3 +303,21 @@ T IR::getDeclarationWithName(std::vector<T> &declarations,
     }
     return nullptr;
 }
+
+IR::~IR() {
+    clearVector(functions);
+    clearVector(typeDefs);
+    clearVector(structs);
+    clearVector(unions);
+    clearVector(enums);
+    clearVector(literalDefines);
+    clearVector(possibleVarDefines);
+    clearVector(variables);
+    clearVector(varDefines);
+}
+
+template <typename T> void IR::clearVector(std::vector<T> v) {
+    for (auto e : v) {
+        std::free(e);
+    }
+}

bindgen/ir/IR.h

@@ -14,8 +14,8 @@
  */
 class IR {
   public:
-    explicit IR(std::string libName, std::string linkName,
-                std::string objectName, std::string packageName);
+    IR(std::string libName, std::string linkName, std::string objectName,
+       std::string packageName);
 
     ~IR();
 
@@ -49,16 +49,14 @@ class IR {
 
     void addVarDefine(std::string name, Variable *variable);
 
-    Variable *addVariable(const std::string &name, const std::string &type);
+    Variable *addVariable(const std::string &name, Type *type);
 
     /**
      * @return true if there are no functions, types,
      *         structs and unions
      */
     bool libObjEmpty() const;
 
-    bool hasEnums() const;
-
     friend llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const IR &ir);
 
     void generate(const std::string &excludePrefix);
@@ -71,20 +69,9 @@ class IR {
      */
     std::string getDefineForVar(const std::string &varName) const;
 
-    Enum *getEnumWithName(const std::string &name);
-
-    Struct *getStructWithName(const std::string &name);
-
-    Union *getUnionWithName(const std::string &name);
-
     TypeDef *getTypeDefWithName(const std::string &name);
 
   private:
-    /**
-     * Generates type defs for enums, structs and unions
-     */
-    void generateTypeDefs();
-
     /**
      * @return true if helper methods will be generated for this library
      */
@@ -147,10 +134,11 @@ 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
-    // TODO: free memory
     std::vector<Function *> functions;
     std::vector<TypeDef *> typeDefs;
     std::vector<Struct *> structs;

bindgen/ir/LiteralDefine.cpp

@@ -1,5 +1,4 @@
 #include "LiteralDefine.h"
-#include "types/Type.h"
 
 LiteralDefine::LiteralDefine(std::string name, std::string literal, Type *type)
     : Define(std::move(name)), literal(std::move(literal)), type(type) {}

bindgen/ir/Struct.cpp

@@ -1,7 +1,7 @@
 #include "Struct.h"
 #include "../Utils.h"
 #include "types/ArrayType.h"
-#include "types/SimpleType.h"
+#include "types/PrimitiveType.h"
 #include <sstream>
 #include <utility>
 
@@ -24,7 +24,7 @@ TypeDef *Struct::generateTypeDef() {
         // have to represent it as an array and then Add helpers to help with
         // its manipulation
         return new TypeDef(getAliasType(),
-                           new ArrayType(new SimpleType("Byte"), typeSize));
+                           new ArrayType(new PrimitiveType("Byte"), typeSize));
     }
 }
 
@@ -96,7 +96,7 @@ bool Struct::usesType(Type *type) const {
 
 Union::Union(std::string name, std::vector<Field> fields, uint64_t maxSize)
     : StructOrUnion(std::move(name), std::move(fields)),
-      ArrayType(new SimpleType("Byte"), maxSize) {}
+      ArrayType(new PrimitiveType("Byte"), maxSize) {}
 
 TypeDef *Union::generateTypeDef() { return new TypeDef(getTypeAlias(), this); }