Changeset 8fd52e90

Timestamp:

Jul 12, 2019, 1:51:32 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

6f096d2, c6dc7f2

Parents:

fce4e31

Message:

Removed uses of lookupMutableXXX

Location:

src

Files:

• ResolvExpr/Resolver.cc (modified) (1 diff)
• SymTab/Indexer.cc (modified) (5 diffs)
• SymTab/Indexer.h (modified) (1 diff)
• SymTab/Validate.cc (modified) (5 diffs)

src/ResolvExpr/Resolver.cc

@@ -562 +562 @@
                 // TODO: Replace *exception type with &exception type.
                 if ( throwStmt->get_expr() ) {
-                        StructDecl * exception_decl = indexer.lookupMutableStruct( "__cfaabi_ehm__base_exception_t" );
+                        const StructDecl * exception_decl = indexer.lookupStruct( "__cfaabi_ehm__base_exception_t" );
                         assert( exception_decl );
-                        Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, exception_decl ) );
+                        Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, const_cast<StructDecl *>(exception_decl) ) );
                         findSingleExpression( throwStmt->expr, exceptType, indexer );
                 }

src/SymTab/Indexer.cc

@@ -122 +122 @@
         }
 
-        const NamedTypeDecl * Indexer::lookupType( const std::string & id ) const { return lookupMutableType(id); }
-        NamedTypeDecl * Indexer::lookupMutableType( const std::string & id ) const {
+        const NamedTypeDecl * Indexer::lookupType( const std::string & id ) const {
                 ++* stats().lookup_calls;
                 if ( ! typeTable ) return nullptr;
@@ -131 +130 @@
         }
 
-        const StructDecl * Indexer::lookupStruct( const std::string & id ) const { return lookupMutableStruct(id); }
-        StructDecl * Indexer::lookupMutableStruct( const std::string & id ) const {
+        const StructDecl * Indexer::lookupStruct( const std::string & id ) const {
                 ++* stats().lookup_calls;
                 if ( ! structTable ) return nullptr;
@@ -140 +138 @@
         }
 
-        const EnumDecl * Indexer::lookupEnum( const std::string & id ) const { return lookupMutableEnum(id); }
-        EnumDecl * Indexer::lookupMutableEnum( const std::string & id ) const {
+        const EnumDecl * Indexer::lookupEnum( const std::string & id ) const {
                 ++* stats().lookup_calls;
                 if ( ! enumTable ) return nullptr;
@@ -149 +146 @@
         }
 
-        const UnionDecl * Indexer::lookupUnion( const std::string & id ) const { return lookupMutableUnion(id); }
-        UnionDecl * Indexer::lookupMutableUnion( const std::string & id ) const {
+        const UnionDecl * Indexer::lookupUnion( const std::string & id ) const {
                 ++* stats().lookup_calls;
                 if ( ! unionTable ) return nullptr;
@@ -158 +154 @@
         }
 
-        const TraitDecl * Indexer::lookupTrait( const std::string & id ) const { return lookupMutableTrait(id); }
-        TraitDecl * Indexer::lookupMutableTrait( const std::string & id ) const {
+        const TraitDecl * Indexer::lookupTrait( const std::string & id ) const {
                 ++* stats().lookup_calls;
                 if ( ! traitTable ) return nullptr;

src/SymTab/Indexer.h

@@ -64 +64 @@
                 /// Gets the top-most type declaration with the given ID
                 const NamedTypeDecl * lookupType( const std::string & id ) const;
-                NamedTypeDecl * lookupMutableType( const std::string & id ) const;
                 /// Gets the top-most struct declaration with the given ID
                 const StructDecl * lookupStruct( const std::string & id ) const;
-                StructDecl * lookupMutableStruct( const std::string & id ) const;
                 /// Gets the top-most enum declaration with the given ID
                 const EnumDecl * lookupEnum( const std::string & id ) const;
-                EnumDecl * lookupMutableEnum( const std::string & id ) const;
                 /// Gets the top-most union declaration with the given ID
                 const UnionDecl * lookupUnion( const std::string & id ) const;
-                UnionDecl * lookupMutableUnion( const std::string & id ) const;
                 /// Gets the top-most trait declaration with the given ID
                 const TraitDecl * lookupTrait( const std::string & id ) const;
-                TraitDecl * lookupMutableTrait( const std::string & id ) const;
 
                 /// Gets the type declaration with the given ID at global scope

src/SymTab/Validate.cc

@@ -642 +642 @@
 
         void LinkReferenceToTypes_old::postvisit( EnumInstType * enumInst ) {
-                EnumDecl * st = local_indexer->lookupMutableEnum( enumInst->name );
+                const EnumDecl * st = local_indexer->lookupEnum( enumInst->name );
                 // it's not a semantic error if the enum is not found, just an implicit forward declaration
                 if ( st ) {
-                        enumInst->baseEnum = st;
+                        enumInst->baseEnum = const_cast<EnumDecl *>(st); // Just linking in the node
                 } // if
                 if ( ! st || ! st->body ) {
@@ -662 +662 @@
 
         void LinkReferenceToTypes_old::postvisit( StructInstType * structInst ) {
-                StructDecl * st = local_indexer->lookupMutableStruct( structInst->name );
+                const StructDecl * st = local_indexer->lookupStruct( structInst->name );
                 // it's not a semantic error if the struct is not found, just an implicit forward declaration
                 if ( st ) {
-                        structInst->baseStruct = st;
+                        structInst->baseStruct = const_cast<StructDecl *>(st); // Just linking in the node
                 } // if
                 if ( ! st || ! st->body ) {
@@ -675 +675 @@
 
         void LinkReferenceToTypes_old::postvisit( UnionInstType * unionInst ) {
-                UnionDecl * un = local_indexer->lookupMutableUnion( unionInst->name );
+                const UnionDecl * un = local_indexer->lookupUnion( unionInst->name );
                 // it's not a semantic error if the union is not found, just an implicit forward declaration
                 if ( un ) {
-                        unionInst->baseUnion = un;
+                        unionInst->baseUnion = const_cast<UnionDecl *>(un); // Just linking in the node
                 } // if
                 if ( ! un || ! un->body ) {
@@ -762 +762 @@
         void LinkReferenceToTypes_old::postvisit( TraitInstType * traitInst ) {
                 // handle other traits
-                TraitDecl * traitDecl = local_indexer->lookupMutableTrait( traitInst->name );
+                const TraitDecl * traitDecl = local_indexer->lookupTrait( traitInst->name );
                 if ( ! traitDecl ) {
                         SemanticError( traitInst->location, "use of undeclared trait " + traitInst->name );
@@ -769 +769 @@
                         SemanticError( traitInst, "incorrect number of trait parameters: " );
                 } // if
-                traitInst->baseTrait = traitDecl;
+                traitInst->baseTrait = const_cast<TraitDecl *>(traitDecl); // Just linking in the node
 
                 // need to carry over the 'sized' status of each decl in the instance