Add const qualifiers to fields of type Type

kornilova203 · kornilova203 · commit e5d86c5b71da · 2018-07-23T16:35:46.000+08:00
diff --git a/bindgen/TypeTranslator.cpp b/bindgen/TypeTranslator.cpp
@@ -43,7 +43,7 @@ TypeTranslator::translateFunctionPointer(const clang::QualType &qtpe,
         const auto *fc = inner->getAs<clang::FunctionProtoType>();
         std::shared_ptr<Type> returnType =
             translate(fc->getReturnType(), avoid);
-        std::vector<std::shared_ptr<Type>> parametersTypes;
+        std::vector<std::shared_ptr<const Type>> parametersTypes;
 
         for (const clang::QualType &param : fc->param_types()) {
             parametersTypes.push_back(translate(param, avoid));
diff --git a/bindgen/Utils.h b/bindgen/Utils.h
@@ -64,7 +64,7 @@ static inline bool startsWith(const std::string &str,
 }
 
 template <typename T, typename PT> static inline bool isInstanceOf(PT *type) {
-    auto *p = dynamic_cast<T *>(type);
+    auto *p = dynamic_cast<const T *>(type);
     return p != nullptr;
 }
 
@@ -82,13 +82,13 @@ static inline std::string replaceChar(const std::string &str,
  * Types may be wrapper in a chain of typedefs.
  * @return true if given type is of type T or is an alias for type T.
  */
-template <typename T> static inline bool isAliasForType(Type *type) {
+template <typename T> static inline bool isAliasForType(const Type *type) {
     if (isInstanceOf<T>(type)) {
         return true;
     }
-    auto *typeDef = dynamic_cast<TypeDef *>(type);
+    auto *typeDef = dynamic_cast<const TypeDef *>(type);
     if (typeDef) {
-        return isAliasForType<T>(typeDef->getType().get());
+        return isAliasForType<const T>(typeDef->getType().get());
     }
     return false;
 }
diff --git a/bindgen/ir/Function.cpp b/bindgen/ir/Function.cpp
@@ -2,12 +2,12 @@
 #include "../Utils.h"
 #include "Struct.h"
 
-Parameter::Parameter(std::string name, std::shared_ptr<Type> type)
+Parameter::Parameter(std::string name, std::shared_ptr<const Type> type)
     : TypeAndName(std::move(name), type) {}
 
 Function::Function(const std::string &name,
                    std::vector<std::shared_ptr<Parameter>> parameters,
-                   std::shared_ptr<Type> retType, bool isVariadic)
+                   std::shared_ptr<const Type> retType, bool isVariadic)
     : name(name), scalaName(name), parameters(std::move(parameters)),
       retType(std::move(retType)), isVariadic(isVariadic) {}
 
diff --git a/bindgen/ir/Function.h b/bindgen/ir/Function.h
@@ -9,14 +9,14 @@
 
 class Parameter : public TypeAndName {
   public:
-    Parameter(std::string name, std::shared_ptr<Type> type);
+    Parameter(std::string name, std::shared_ptr<const Type> type);
 };
 
 class Function {
   public:
     Function(const std::string &name,
              std::vector<std::shared_ptr<Parameter>> parameters,
-             std::shared_ptr<Type> retType, bool isVariadic);
+             std::shared_ptr<const Type> retType, bool isVariadic);
 
     friend llvm::raw_ostream &operator<<(llvm::raw_ostream &s,
                                          const Function &func);
@@ -41,7 +41,7 @@ class Function {
     std::string name;      // real name of the function
     std::string scalaName; // not empty
     std::vector<std::shared_ptr<Parameter>> parameters;
-    std::shared_ptr<Type> retType;
+    std::shared_ptr<const Type> retType;
     bool isVariadic;
 };
 
diff --git a/bindgen/ir/IR.cpp b/bindgen/ir/IR.cpp
@@ -260,8 +260,8 @@ void IR::filterTypeDefs(const std::string &excludePrefix) {
     }
 }
 
-void IR::replaceTypeInTypeDefs(std::shared_ptr<Type> oldType,
-                               std::shared_ptr<Type> newType) {
+void IR::replaceTypeInTypeDefs(std::shared_ptr<const Type> oldType,
+                               std::shared_ptr<const Type> newType) {
     for (auto &typeDef : typeDefs) {
         if (typeDef->getType() == oldType) {
             typeDef->setType(newType);
@@ -443,15 +443,15 @@ template <typename T> bool IR::inMainFile(const T &type) const {
         /* generated TypeDef */
         auto *typeDef = dynamic_cast<const TypeDef *>(&type);
         assert(typeDef);
-        Type *innerType = typeDef->getType().get();
+        const Type *innerType = typeDef->getType().get();
         if (isInstanceOf<Struct>(innerType)) {
-            return inMainFile(*dynamic_cast<Struct *>(innerType));
+            return inMainFile(*dynamic_cast<const Struct *>(innerType));
         }
         if (isInstanceOf<Union>(innerType)) {
-            return inMainFile(*dynamic_cast<Union *>(innerType));
+            return inMainFile(*dynamic_cast<const Union *>(innerType));
         }
         if (isInstanceOf<Enum>(innerType)) {
-            return inMainFile(*dynamic_cast<Enum *>(innerType));
+            return inMainFile(*dynamic_cast<const Enum *>(innerType));
         }
     }
     return location && locationManager.inMainFile(*location);
diff --git a/bindgen/ir/IR.h b/bindgen/ir/IR.h
@@ -108,8 +108,8 @@ class IR {
     /**
      * Find all typedefs that use oldType and replace it with newType.
      */
-    void replaceTypeInTypeDefs(std::shared_ptr<Type> oldType,
-                               std::shared_ptr<Type> newType);
+    void replaceTypeInTypeDefs(std::shared_ptr<const Type> oldType,
+                               std::shared_ptr<const Type> newType);
 
     /**
      * @return true if given type is used only in typedefs.
diff --git a/bindgen/ir/LiteralDefine.cpp b/bindgen/ir/LiteralDefine.cpp
@@ -1,7 +1,7 @@
 #include "LiteralDefine.h"
 
 LiteralDefine::LiteralDefine(std::string name, std::string literal,
-                             std::shared_ptr<Type> type)
+                             std::shared_ptr<const Type> type)
     : Define(std::move(name)), literal(std::move(literal)), type(type) {}
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &s,
diff --git a/bindgen/ir/LiteralDefine.h b/bindgen/ir/LiteralDefine.h
@@ -8,7 +8,7 @@
 class LiteralDefine : public Define {
   public:
     LiteralDefine(std::string name, std::string literal,
-                  std::shared_ptr<Type> type);
+                  std::shared_ptr<const Type> type);
 
     friend llvm::raw_ostream &operator<<(llvm::raw_ostream &s,
                                          const LiteralDefine &literalDefine);
@@ -17,7 +17,7 @@ class LiteralDefine : public Define {
 
   private:
     std::string literal;
-    std::shared_ptr<Type> type;
+    std::shared_ptr<const Type> type;
 };
 
 #endif // SCALA_NATIVE_BINDGEN_LITERALDEFINE_H
diff --git a/bindgen/ir/Struct.cpp b/bindgen/ir/Struct.cpp
@@ -5,10 +5,10 @@
 #include "types/PrimitiveType.h"
 #include <sstream>
 
-Field::Field(std::string name, std::shared_ptr<Type> type)
+Field::Field(std::string name, std::shared_ptr<const Type> type)
     : TypeAndName(std::move(name), std::move(type)) {}
 
-Field::Field(std::string name, std::shared_ptr<Type> type,
+Field::Field(std::string name, std::shared_ptr<const Type> type,
              uint64_t offsetInBits)
     : TypeAndName(std::move(name), std::move(type)),
       offsetInBits(offsetInBits) {}
@@ -262,7 +262,7 @@ std::string Union::generateHelperClass() const {
         if (!field->getName().empty()) {
             std::string getter = handleReservedWords(field->getName());
             std::string setter = handleReservedWords(field->getName(), "_=");
-            std::shared_ptr<Type> ftype = field->getType();
+            std::shared_ptr<const Type> ftype = field->getType();
             s << "    def " << getter << ": native.Ptr[" << ftype->str()
               << "] = p.cast[native.Ptr[" << ftype->str() << "]]\n";
 
diff --git a/bindgen/ir/Struct.h b/bindgen/ir/Struct.h
@@ -11,9 +11,10 @@
 
 class Field : public TypeAndName {
   public:
-    Field(std::string name, std::shared_ptr<Type> type);
+    Field(std::string name, std::shared_ptr<const Type> type);
 
-    Field(std::string name, std::shared_ptr<Type> type, uint64_t offsetInBits);
+    Field(std::string name, std::shared_ptr<const Type> type,
+          uint64_t offsetInBits);
 
     uint64_t getOffsetInBits() const;
 
diff --git a/bindgen/ir/TypeAndName.cpp b/bindgen/ir/TypeAndName.cpp
@@ -1,14 +1,16 @@
 #include "TypeAndName.h"
 #include <clang/Tooling/Tooling.h>
 
-TypeAndName::TypeAndName(std::string name, std::shared_ptr<Type> type)
+TypeAndName::TypeAndName(std::string name, std::shared_ptr<const Type> type)
     : name(std::move(name)), type(std::move(type)) {}
 
-std::shared_ptr<Type> TypeAndName::getType() const { return type; }
+std::shared_ptr<const Type> TypeAndName::getType() const { return type; }
 
 std::string TypeAndName::getName() const { return name; }
 
-void TypeAndName::setType(std::shared_ptr<Type> type) { this->type = type; }
+void TypeAndName::setType(std::shared_ptr<const Type> type) {
+    this->type = type;
+}
 
 bool TypeAndName::operator==(const TypeAndName &other) const {
     if (this == &other) {
diff --git a/bindgen/ir/TypeAndName.h b/bindgen/ir/TypeAndName.h
@@ -11,11 +11,11 @@
  */
 class TypeAndName {
   public:
-    TypeAndName(std::string name, std::shared_ptr<Type> type);
+    TypeAndName(std::string name, std::shared_ptr<const Type> type);
 
-    std::shared_ptr<Type> getType() const;
+    std::shared_ptr<const Type> getType() const;
 
-    void setType(std::shared_ptr<Type> name);
+    void setType(std::shared_ptr<const Type> name);
 
     std::string getName() const;
 
@@ -27,7 +27,7 @@ class TypeAndName {
 
   protected:
     std::string name;
-    std::shared_ptr<Type> type;
+    std::shared_ptr<const Type> type;
 };
 
 #endif // SCALA_NATIVE_BINDGEN_TYPEANDNAME_H
diff --git a/bindgen/ir/TypeDef.cpp b/bindgen/ir/TypeDef.cpp
@@ -3,7 +3,7 @@
 #include "Enum.h"
 #include "Struct.h"
 
-TypeDef::TypeDef(std::string name, std::shared_ptr<Type> type,
+TypeDef::TypeDef(std::string name, std::shared_ptr<const Type> type,
                  std::shared_ptr<Location> location)
     : TypeAndName(std::move(name), std::move(type)),
       location(std::move(location)) {}
@@ -36,7 +36,7 @@ bool TypeDef::operator==(const Type &other) const {
     if (this == &other) {
         return true;
     }
-    if (isInstanceOf<const TypeDef>(&other)) {
+    if (isInstanceOf<TypeDef>(&other)) {
         auto *typDef = dynamic_cast<const TypeDef *>(&other);
         if (name != typDef->name) {
             return false;
diff --git a/bindgen/ir/TypeDef.h b/bindgen/ir/TypeDef.h
@@ -8,7 +8,7 @@
 
 class TypeDef : public TypeAndName, public Type {
   public:
-    TypeDef(std::string name, std::shared_ptr<Type> type,
+    TypeDef(std::string name, std::shared_ptr<const Type> type,
             std::shared_ptr<Location> location);
 
     friend llvm::raw_ostream &operator<<(llvm::raw_ostream &s,
diff --git a/bindgen/ir/Variable.cpp b/bindgen/ir/Variable.cpp
@@ -1,7 +1,7 @@
 #include "Variable.h"
 #include "../Utils.h"
 
-Variable::Variable(const std::string &name, std::shared_ptr<Type> type)
+Variable::Variable(const std::string &name, std::shared_ptr<const Type> type)
     : TypeAndName(name, type) {}
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &s, const Variable &variable) {
diff --git a/bindgen/ir/Variable.h b/bindgen/ir/Variable.h
@@ -6,7 +6,7 @@
 
 class Variable : public TypeAndName {
   public:
-    Variable(const std::string &name, std::shared_ptr<Type> type);
+    Variable(const std::string &name, std::shared_ptr<const Type> type);
 
     friend llvm::raw_ostream &operator<<(llvm::raw_ostream &s,
                                          const Variable &variable);
diff --git a/bindgen/ir/types/ArrayType.cpp b/bindgen/ir/types/ArrayType.cpp
@@ -2,7 +2,7 @@
 #include "../../Utils.h"
 #include "../Struct.h"
 
-ArrayType::ArrayType(std::shared_ptr<Type> elementsType, uint64_t size)
+ArrayType::ArrayType(std::shared_ptr<const Type> elementsType, uint64_t size)
     : size(size), elementsType(std::move(elementsType)) {}
 
 std::string ArrayType::str() const {
@@ -20,8 +20,7 @@ bool ArrayType::operator==(const Type &other) const {
     if (this == &other) {
         return true;
     }
-    if (isInstanceOf<const ArrayType>(&other) &&
-        !isInstanceOf<const Union>(&other)) {
+    if (isInstanceOf<ArrayType>(&other) && !isInstanceOf<Union>(&other)) {
         auto *arrayType = dynamic_cast<const ArrayType *>(&other);
         if (size != arrayType->size) {
             return false;
diff --git a/bindgen/ir/types/ArrayType.h b/bindgen/ir/types/ArrayType.h
@@ -5,7 +5,7 @@
 
 class ArrayType : public virtual Type {
   public:
-    ArrayType(std::shared_ptr<Type> elementsType, uint64_t size);
+    ArrayType(std::shared_ptr<const Type> elementsType, uint64_t size);
 
     bool usesType(const std::shared_ptr<Type> &type,
                   bool stopOnTypeDefs) const override;
@@ -16,7 +16,7 @@ class ArrayType : public virtual Type {
 
   private:
     const uint64_t size;
-    std::shared_ptr<Type> elementsType;
+    std::shared_ptr<const Type> elementsType;
 };
 
 #endif // SCALA_NATIVE_BINDGEN_ARRAYTYPE_H
diff --git a/bindgen/ir/types/FunctionPointerType.cpp b/bindgen/ir/types/FunctionPointerType.cpp
@@ -3,8 +3,8 @@
 #include <sstream>
 
 FunctionPointerType::FunctionPointerType(
-    std::shared_ptr<Type> returnType,
-    const std::vector<std::shared_ptr<Type>> &parametersTypes, bool isVariadic)
+    std::shared_ptr<const Type> returnType,
+    std::vector<std::shared_ptr<const Type>> &parametersTypes, bool isVariadic)
     : returnType(std::move(returnType)), parametersTypes(parametersTypes),
       isVariadic(isVariadic) {}
 
@@ -25,14 +25,13 @@ std::string FunctionPointerType::str() const {
 
 bool FunctionPointerType::usesType(const std::shared_ptr<Type> &type,
                                    bool stopOnTypeDefs) const {
-    if (*returnType == *type ||
-        returnType.get()->usesType(type, stopOnTypeDefs)) {
+    if (*returnType == *type || returnType->usesType(type, stopOnTypeDefs)) {
         return true;
     }
 
     for (const auto &parameterType : parametersTypes) {
         if (*parameterType == *type ||
-            parameterType.get()->usesType(type, stopOnTypeDefs)) {
+            parameterType->usesType(type, stopOnTypeDefs)) {
             return true;
         }
     }
@@ -43,7 +42,7 @@ bool FunctionPointerType::operator==(const Type &other) const {
     if (this == &other) {
         return true;
     }
-    if (isInstanceOf<const FunctionPointerType>(&other)) {
+    if (isInstanceOf<FunctionPointerType>(&other)) {
         auto *functionPointerType =
             dynamic_cast<const FunctionPointerType *>(&other);
         if (isVariadic != functionPointerType->isVariadic) {
diff --git a/bindgen/ir/types/FunctionPointerType.h b/bindgen/ir/types/FunctionPointerType.h
@@ -7,8 +7,8 @@
 class FunctionPointerType : public Type {
   public:
     FunctionPointerType(
-        std::shared_ptr<Type> returnType,
-        const std::vector<std::shared_ptr<Type>> &parametersTypes,
+        std::shared_ptr<const Type> returnType,
+        std::vector<std::shared_ptr<const Type>> &parametersTypes,
         bool isVariadic);
 
     bool usesType(const std::shared_ptr<Type> &type,
@@ -19,8 +19,8 @@ class FunctionPointerType : public Type {
     bool operator==(const Type &other) const override;
 
   private:
-    std::shared_ptr<Type> returnType;
-    std::vector<std::shared_ptr<Type>> parametersTypes;
+    std::shared_ptr<const Type> returnType;
+    std::vector<std::shared_ptr<const Type>> parametersTypes;
     bool isVariadic;
 };
 
diff --git a/bindgen/ir/types/PointerType.cpp b/bindgen/ir/types/PointerType.cpp
@@ -1,7 +1,8 @@
 #include "PointerType.h"
 #include "../../Utils.h"
 
-PointerType::PointerType(std::shared_ptr<Type> type) : type(std::move(type)) {}
+PointerType::PointerType(std::shared_ptr<const Type> type)
+    : type(std::move(type)) {}
 
 std::string PointerType::str() const {
     return "native.Ptr[" + type->str() + "]";
@@ -17,7 +18,7 @@ bool PointerType::operator==(const Type &other) const {
     if (this == &other) {
         return true;
     }
-    if (isInstanceOf<const PointerType>(&other)) {
+    if (isInstanceOf<PointerType>(&other)) {
         auto *pointerType = dynamic_cast<const PointerType *>(&other);
         return *type == *pointerType->type;
     }
diff --git a/bindgen/ir/types/PointerType.h b/bindgen/ir/types/PointerType.h
diff --git a/bindgen/ir/types/PrimitiveType.cpp b/bindgen/ir/types/PrimitiveType.cpp

Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ static inline bool startsWith(const std::string &str,`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`template <typename T, typename PT> static inline bool isInstanceOf(PT *type) {`
`67`		`- auto p = dynamic_cast<T >(type);`
	`67`	`+ auto p = dynamic_cast<const T >(type);`
`68`	`68`	`return p != nullptr;`
`69`	`69`	`}`
`70`	`70`
`@@ -82,13 +82,13 @@ static inline std::string replaceChar(const std::string &str,`
`82`	`82`	`* Types may be wrapper in a chain of typedefs.`
`83`	`83`	`* @return true if given type is of type T or is an alias for type T.`
`84`	`84`	`*/`
`85`		`-template <typename T> static inline bool isAliasForType(Type *type) {`
	`85`	`+template <typename T> static inline bool isAliasForType(const Type *type) {`
`86`	`86`	`if (isInstanceOf<T>(type)) {`
`87`	`87`	`return true;`
`88`	`88`	`}`
`89`		`- auto typeDef = dynamic_cast<TypeDef >(type);`
	`89`	`+ auto typeDef = dynamic_cast<const TypeDef >(type);`
`90`	`90`	`if (typeDef) {`
`91`		`- return isAliasForType<T>(typeDef->getType().get());`
	`91`	`+ return isAliasForType<const T>(typeDef->getType().get());`
`92`	`92`	`}`
`93`	`93`	`return false;`
`94`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -260,8 +260,8 @@ void IR::filterTypeDefs(const std::string &excludePrefix) {`
`260`	`260`	`}`
`261`	`261`	`}`
`262`	`262`
`263`		`-void IR::replaceTypeInTypeDefs(std::shared_ptr<Type> oldType,`
`264`		`- std::shared_ptr<Type> newType) {`
	`263`	`+void IR::replaceTypeInTypeDefs(std::shared_ptr<const Type> oldType,`
	`264`	`+ std::shared_ptr<const Type> newType) {`
`265`	`265`	`for (auto &typeDef : typeDefs) {`
`266`	`266`	`if (typeDef->getType() == oldType) {`
`267`	`267`	`typeDef->setType(newType);`
`@@ -443,15 +443,15 @@ template <typename T> bool IR::inMainFile(const T &type) const {`
`443`	`443`	`/* generated TypeDef */`
`444`	`444`	`auto typeDef = dynamic_cast<const TypeDef >(&type);`
`445`	`445`	`assert(typeDef);`
`446`		`- Type *innerType = typeDef->getType().get();`
	`446`	`+ const Type *innerType = typeDef->getType().get();`
`447`	`447`	`if (isInstanceOf<Struct>(innerType)) {`
`448`		`- return inMainFile(dynamic_cast<Struct >(innerType));`
	`448`	`+ return inMainFile(dynamic_cast<const Struct >(innerType));`
`449`	`449`	`}`
`450`	`450`	`if (isInstanceOf<Union>(innerType)) {`
`451`		`- return inMainFile(dynamic_cast<Union >(innerType));`
	`451`	`+ return inMainFile(dynamic_cast<const Union >(innerType));`
`452`	`452`	`}`
`453`	`453`	`if (isInstanceOf<Enum>(innerType)) {`
`454`		`- return inMainFile(dynamic_cast<Enum >(innerType));`
	`454`	`+ return inMainFile(dynamic_cast<const Enum >(innerType));`
`455`	`455`	`}`
`456`	`456`	`}`
`457`	`457`	`return location && locationManager.inMainFile(*location);`