Introduced proper const-ness to the parser.

Signed-off-by: Dimitar Dobrev <dpldobrev@protonmail.com>

src/CppParser/AST.cpp

@@ -361,7 +361,7 @@ Class* DeclarationContext::FindClass(const std::string& Name, bool IsComplete,
     return _class;
 }
 
-Enumeration* DeclarationContext::FindEnum(void* OriginalPtr)
+Enumeration* DeclarationContext::FindEnum(const void* OriginalPtr)
 {
     auto foundEnum = std::find_if(Enums.begin(), Enums.end(),
         [&](Enumeration* enumeration) { return enumeration->OriginalPtr == OriginalPtr; });

src/CppParser/AST.h

@@ -431,7 +431,7 @@ public:
     CS_IGNORE ClassTemplate* FindClassTemplate(const std::string& USR);
     CS_IGNORE FunctionTemplate* FindFunctionTemplate(const std::string& USR);
 
-    CS_IGNORE Enumeration* FindEnum(void* OriginalPtr);
+    CS_IGNORE Enumeration* FindEnum(const void* OriginalPtr);
     CS_IGNORE Enumeration* FindEnum(const std::string& Name, bool Create = false);
     CS_IGNORE Enumeration* FindEnumWithItem(const std::string& Name);
 

src/CppParser/Comments.cpp

@@ -256,7 +256,7 @@ static Comment* ConvertCommentBlock(clang::comments::Comment* C)
     return _Comment;
 }
 
-void Parser::HandleComments(clang::Decl* D, Declaration* Decl)
+void Parser::HandleComments(const clang::Decl* D, Declaration* Decl)
 {
     using namespace clang;
 

src/CppParser/Parser.cpp

@@ -573,7 +573,7 @@ VTableLayout Parser::WalkVTableLayout(const clang::VTableLayout& VTLayout)
 }
 
 
-void Parser::WalkVTable(clang::CXXRecordDecl* RD, Class* C)
+void Parser::WalkVTable(const clang::CXXRecordDecl* RD, Class* C)
 {
     using namespace clang;
 
@@ -619,7 +619,7 @@ void Parser::WalkVTable(clang::CXXRecordDecl* RD, Class* C)
     }
 }
 
-Class* Parser::GetRecord(clang::RecordDecl* Record, bool& Process)
+Class* Parser::GetRecord(const clang::RecordDecl* Record, bool& Process)
 {
     using namespace clang;
     Process = false;
@@ -667,7 +667,7 @@ Class* Parser::GetRecord(clang::RecordDecl* Record, bool& Process)
     return RC;
 }
 
-Class* Parser::WalkRecord(clang::RecordDecl* Record)
+Class* Parser::WalkRecord(const clang::RecordDecl* Record)
 {
     bool Process;
     auto RC = GetRecord(Record, Process);
@@ -680,7 +680,7 @@ Class* Parser::WalkRecord(clang::RecordDecl* Record)
     return RC;
 }
 
-Class* Parser::WalkRecordCXX(clang::CXXRecordDecl* Record)
+Class* Parser::WalkRecordCXX(const clang::CXXRecordDecl* Record)
 {
     bool Process;
     auto RC = GetRecord(Record, Process);
@@ -695,7 +695,7 @@ Class* Parser::WalkRecordCXX(clang::CXXRecordDecl* Record)
 
 static int I = 0;
 
-void Parser::WalkRecord(clang::RecordDecl* Record, Class* RC)
+void Parser::WalkRecord(const clang::RecordDecl* Record, Class* RC)
 {
     using namespace clang;
 
@@ -795,12 +795,12 @@ static clang::CXXRecordDecl* GetCXXRecordDeclFromBaseType(const clang::Type* Ty)
     return nullptr;
 }
 
-void Parser::WalkRecordCXX(clang::CXXRecordDecl* Record, Class* RC)
+void Parser::WalkRecordCXX(const clang::CXXRecordDecl* Record, Class* RC)
 {
     using namespace clang;
 
     auto& Sema = C->getSema();
-    Sema.ForceDeclarationOfImplicitMembers(Record);
+    Sema.ForceDeclarationOfImplicitMembers(const_cast<clang::CXXRecordDecl*>(Record));
 
     WalkRecord(Record, RC);
 
@@ -876,7 +876,7 @@ WalkTemplateSpecializationKind(clang::TemplateSpecializationKind Kind)
 }
 
 ClassTemplateSpecialization*
-Parser::WalkClassTemplateSpecialization(clang::ClassTemplateSpecializationDecl* CTS)
+Parser::WalkClassTemplateSpecialization(const clang::ClassTemplateSpecializationDecl* CTS)
 {
     using namespace clang;
 
@@ -919,7 +919,7 @@ Parser::WalkClassTemplateSpecialization(clang::ClassTemplateSpecializationDecl*
 //-----------------------------------//
 
 ClassTemplatePartialSpecialization*
-Parser::WalkClassTemplatePartialSpecialization(clang::ClassTemplatePartialSpecializationDecl* CTS)
+Parser::WalkClassTemplatePartialSpecialization(const clang::ClassTemplatePartialSpecializationDecl* CTS)
 {
     using namespace clang;
 
@@ -1340,11 +1340,19 @@ Method* Parser::WalkMethodCXX(clang::CXXMethodDecl* MD)
 
 //-----------------------------------//
 
-Field* Parser::WalkFieldCXX(clang::FieldDecl* FD, Class* Class)
+Field* Parser::WalkFieldCXX(const clang::FieldDecl* FD, Class* Class)
 {
     using namespace clang;
 
-    Field* F = new Field();
+    const auto& USR = GetDeclUSR(FD);
+
+    auto FoundField = std::find_if(Class->Fields.begin(), Class->Fields.end(),
+        [&](Field* Field) { return Field->USR == USR; });
+
+    if (FoundField != Class->Fields.end())
+        return *FoundField;
+
+    auto F = new Field();
     HandleDeclaration(FD, F);
 
     F->_Namespace = Class;
@@ -1420,24 +1428,26 @@ TranslationUnit* Parser::GetTranslationUnit(const clang::Decl* D)
     return Unit;
 }
 
-DeclarationContext* Parser::GetNamespace(clang::Decl* D,
-                                                   clang::DeclContext *Ctx)
+DeclarationContext* Parser::GetNamespace(const clang::Decl* D,
+    const clang::DeclContext *Ctx)
 {
     using namespace clang;
 
+    auto Context = Ctx;
+
     // If the declaration is at global scope, just early exit.
-    if (Ctx->isTranslationUnit())
+    if (Context->isTranslationUnit())
         return GetTranslationUnit(D);
 
-    TranslationUnit* Unit = GetTranslationUnit(cast<Decl>(Ctx));
+    TranslationUnit* Unit = GetTranslationUnit(cast<Decl>(Context));
 
     // Else we need to do a more expensive check to get all the namespaces,
     // and then perform a reverse iteration to get the namespaces in order.
-    typedef SmallVector<DeclContext *, 8> ContextsTy;
+    typedef SmallVector<const DeclContext *, 8> ContextsTy;
     ContextsTy Contexts;
 
-    for(; Ctx != nullptr; Ctx = Ctx->getParent())
-        Contexts.push_back(Ctx);
+    for(; Context != nullptr; Context = Context->getParent())
+        Contexts.push_back(Context);
 
     assert(Contexts.back()->isTranslationUnit());
     Contexts.pop_back();
@@ -1446,13 +1456,13 @@ DeclarationContext* Parser::GetNamespace(clang::Decl* D,
 
     for (auto I = Contexts.rbegin(), E = Contexts.rend(); I != E; ++I)
     {
-        DeclContext* Ctx = *I;
+        const auto* Ctx = *I;
 
         switch(Ctx->getDeclKind())
         {
         case Decl::Namespace:
         {
-            NamespaceDecl* ND = cast<NamespaceDecl>(Ctx);
+            auto ND = cast<NamespaceDecl>(Ctx);
             if (ND->isAnonymousNamespace())
                 continue;
             auto Name = ND->getName();
@@ -1508,7 +1518,7 @@ DeclarationContext* Parser::GetNamespace(clang::Decl* D,
     return DC;
 }
 
-DeclarationContext* Parser::GetNamespace(clang::Decl *D)
+DeclarationContext* Parser::GetNamespace(const clang::Decl *D)
 {
     return GetNamespace(D, D->getDeclContext());
 }
@@ -2195,7 +2205,7 @@ Type* Parser::WalkType(clang::QualType QualType, clang::TypeLoc* TL,
 
 //-----------------------------------//
 
-Enumeration* Parser::WalkEnum(clang::EnumDecl* ED)
+Enumeration* Parser::WalkEnum(const clang::EnumDecl* ED)
 {
     using namespace clang;
 
@@ -2855,7 +2865,7 @@ void Parser::HandlePreprocessedEntities(Declaration* Decl,
     }
 }
 
-void Parser::HandleOriginalText(clang::Decl* D, Declaration* Decl)
+void Parser::HandleOriginalText(const clang::Decl* D, Declaration* Decl)
 {
     auto& SM = C->getSourceManager();
     auto& LangOpts = C->getLangOpts();
@@ -2869,7 +2879,7 @@ void Parser::HandleOriginalText(clang::Decl* D, Declaration* Decl)
         Decl->DebugText = DeclText;
 }
 
-void Parser::HandleDeclaration(clang::Decl* D, Declaration* Decl)
+void Parser::HandleDeclaration(const clang::Decl* D, Declaration* Decl)
 {
     if (Decl->OriginalPtr != nullptr)
         return;

src/CppParser/Parser.h

@@ -58,28 +58,28 @@ public:
                                     CppSharp::CppParser::NativeLibrary*& NativeLib);
     ParserTargetInfo*  GetTargetInfo();
 
-protected:
+private:
 
     // AST traversers
     void WalkAST();
     Declaration* WalkDeclaration(clang::Decl* D,
         bool IgnoreSystemDecls = true, bool CanBeDefinition = false);
     Declaration* WalkDeclarationDef(clang::Decl* D);
-    Enumeration* WalkEnum(clang::EnumDecl* ED);
+    Enumeration* WalkEnum(const clang::EnumDecl* ED);
 	Enumeration::Item* WalkEnumItem(clang::EnumConstantDecl* ECD);
     Function* WalkFunction(clang::FunctionDecl* FD, bool IsDependent = false,
         bool AddToNamespace = true);
-    Class* GetRecord(clang::RecordDecl* Record, bool& IsComplete);
-    Class* WalkRecord(clang::RecordDecl* Record);
-    void WalkRecord(clang::RecordDecl* Record, Class* RC);
-    Class* WalkRecordCXX(clang::CXXRecordDecl* Record);
-    void WalkRecordCXX(clang::CXXRecordDecl* Record, Class* RC);
+    Class* GetRecord(const clang::RecordDecl* Record, bool& IsComplete);
+    Class* WalkRecord(const clang::RecordDecl* Record);
+    void WalkRecord(const clang::RecordDecl* Record, Class* RC);
+    Class* WalkRecordCXX(const clang::CXXRecordDecl* Record);
+    void WalkRecordCXX(const clang::CXXRecordDecl* Record, Class* RC);
     ClassTemplateSpecialization*
-    WalkClassTemplateSpecialization(clang::ClassTemplateSpecializationDecl* CTS);
+    WalkClassTemplateSpecialization(const clang::ClassTemplateSpecializationDecl* CTS);
     ClassTemplatePartialSpecialization*
-    WalkClassTemplatePartialSpecialization(clang::ClassTemplatePartialSpecializationDecl* CTS);
+    WalkClassTemplatePartialSpecialization(const clang::ClassTemplatePartialSpecializationDecl* CTS);
     Method* WalkMethodCXX(clang::CXXMethodDecl* MD);
-    Field* WalkFieldCXX(clang::FieldDecl* FD, Class* Class);
+    Field* WalkFieldCXX(const clang::FieldDecl* FD, Class* Class);
     FunctionTemplateSpecialization* WalkFunctionTemplateSpec(clang::FunctionTemplateSpecializationInfo* FTS, Function* Function);
     Variable* WalkVariable(clang::VarDecl* VD);
     Friend* WalkFriend(clang::FriendDecl* FD);
@@ -96,7 +96,9 @@ protected:
     FunctionTemplate* WalkFunctionTemplate(clang::FunctionTemplateDecl* TD);
     std::vector<TemplateArgument> WalkTemplateArgumentList(const clang::TemplateArgumentList* TAL, clang::TemplateSpecializationTypeLoc* TSTL);
     std::vector<TemplateArgument> WalkTemplateArgumentList(const clang::TemplateArgumentList* TAL, const clang::ASTTemplateArgumentListInfo* TSTL);
-    void WalkVTable(clang::CXXRecordDecl* RD, Class* C);
+    void WalkVTable(const clang::CXXRecordDecl* RD, Class* C);
+    Field* WalkVTablePointer(const std::string& prefix, Class* Class,
+        const clang::RecordDecl * RD, const clang::CharUnits& Offset);
     VTableLayout WalkVTableLayout(const clang::VTableLayout& VTLayout);
     VTableComponent WalkVTableComponent(const clang::VTableComponent& Component);
     PreprocessedEntity* WalkPreprocessedEntity(Declaration* Decl,
@@ -120,12 +122,12 @@ protected:
         SourceLocationKind *Kind = 0);
     TranslationUnit* GetTranslationUnit(const clang::Decl* D);
 
-    DeclarationContext* GetNamespace(clang::Decl* D, clang::DeclContext* Ctx);
-    DeclarationContext* GetNamespace(clang::Decl* D);
+    DeclarationContext* GetNamespace(const clang::Decl* D, const clang::DeclContext* Ctx);
+    DeclarationContext* GetNamespace(const clang::Decl* D);
 
-    void HandleDeclaration(clang::Decl* D, Declaration* Decl);
-    void HandleOriginalText(clang::Decl* D, Declaration* Decl);
-    void HandleComments(clang::Decl* D, Declaration* Decl);
+    void HandleDeclaration(const clang::Decl* D, Declaration* Decl);
+    void HandleOriginalText(const clang::Decl* D, Declaration* Decl);
+    void HandleComments(const clang::Decl* D, Declaration* Decl);
     void HandleDiagnostics(ParserResult* res);
 
     int Index;
@@ -136,7 +138,6 @@ protected:
     clang::TargetCXXABI::Kind TargetABI;
     clang::CodeGen::CodeGenTypes* CodeGenTypes;
 
-private:
     ParserResultKind ReadSymbols(llvm::StringRef File,
                                  llvm::object::basic_symbol_iterator Begin,
                                  llvm::object::basic_symbol_iterator End,