Changeset eaa6430

Timestamp:

Jun 12, 2018, 11:26:23 AM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

589a70b

Parents:

d16cf16

git-author:

Rob Schluntz <rschlunt@…> (06/12/18 11:21:45)

git-committer:

Rob Schluntz <rschlunt@…> (06/12/18 11:26:23)

Message:

Minor cleanup

File:

• src/SymTab/Validate.cc (modified) (11 diffs)

src/SymTab/Validate.cc

@@ -395 +395 @@
 
         void LinkReferenceToTypes::postvisit( EnumInstType *enumInst ) {
-                EnumDecl *st = local_indexer->lookupEnum( enumInst->get_name() );
+                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 ) {
                         //assert( ! enumInst->get_baseEnum() || enumInst->get_baseEnum()->get_members().empty() || ! st->get_members().empty() );
-                        enumInst->set_baseEnum( st );
-                } // if
-                if ( ! st || st->get_members().empty() ) {
+                        enumInst->baseEnum = st;
+                } // if
+                if ( ! st || st->members.empty() ) {
                         // use of forward declaration
-                        forwardEnums[ enumInst->get_name() ].push_back( enumInst );
+                        forwardEnums[ enumInst->name ].push_back( enumInst );
                 } // if
         }
@@ -416 +416 @@
 
         void LinkReferenceToTypes::postvisit( StructInstType *structInst ) {
-                StructDecl *st = local_indexer->lookupStruct( structInst->get_name() );
+                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 ) {
                         //assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );
-                        structInst->set_baseStruct( st );
-                } // if
-                if ( ! st || st->get_members().empty() ) {
+                        structInst->baseStruct = st;
+                } // if
+                if ( ! st || st->members.empty() ) {
                         // use of forward declaration
-                        forwardStructs[ structInst->get_name() ].push_back( structInst );
+                        forwardStructs[ structInst->name ].push_back( structInst );
                 } // if
                 checkGenericParameters( structInst );
@@ -430 +430 @@
 
         void LinkReferenceToTypes::postvisit( UnionInstType *unionInst ) {
-                UnionDecl *un = local_indexer->lookupUnion( unionInst->get_name() );
+                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->set_baseUnion( un );
-                } // if
-                if ( ! un || un->get_members().empty() ) {
+                        unionInst->baseUnion = un;
+                } // if
+                if ( ! un || un->members.empty() ) {
                         // use of forward declaration
-                        forwardUnions[ unionInst->get_name() ].push_back( unionInst );
+                        forwardUnions[ unionInst->name ].push_back( unionInst );
                 } // if
                 checkGenericParameters( unionInst );
@@ -450 +450 @@
                         DeclarationWithType * dwt2 = dynamic_cast<DeclarationWithType *>( d2 );
                         if ( dwt1 && dwt2 ) {
-                                if ( dwt1->get_name() == dwt2->get_name() && ResolvExpr::typesCompatible( dwt1->get_type(), dwt2->get_type(), SymTab::Indexer() ) ) {
+                                if ( dwt1->name == dwt2->name && ResolvExpr::typesCompatible( dwt1->get_type(), dwt2->get_type(), SymTab::Indexer() ) ) {
                                         // std::cerr << "=========== equal:" << std::endl;
                                         // std::cerr << "d1: " << d1 << std::endl;
@@ -475 +475 @@
         template< typename Iterator >
         void expandAssertions( TraitInstType * inst, Iterator out ) {
-                assertf( inst->baseTrait, "Trait instance not linked to base trait: %s", toString( inst ).c_str() );
+                assertf( inst->baseTrait, "Trait instance not linked to base trait: %s", toCString( inst ) );
                 std::list< DeclarationWithType * > asserts;
                 for ( Declaration * decl : inst->baseTrait->members ) {
@@ -518 +518 @@
 
                 // need to carry over the 'sized' status of each decl in the instance
-                for ( auto p : group_iterate( traitDecl->get_parameters(), traitInst->get_parameters() ) ) {
+                for ( auto p : group_iterate( traitDecl->parameters, traitInst->parameters ) ) {
                         TypeExpr * expr = dynamic_cast< TypeExpr * >( std::get<1>(p) );
                         if ( ! expr ) {
@@ -525 +525 @@
                         if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( expr->get_type() ) ) {
                                 TypeDecl * formalDecl = std::get<0>(p);
-                                TypeDecl * instDecl = inst->get_baseType();
+                                TypeDecl * instDecl = inst->baseType;
                                 if ( formalDecl->get_sized() ) instDecl->set_sized( true );
                         }
@@ -534 +534 @@
         void LinkReferenceToTypes::postvisit( EnumDecl *enumDecl ) {
                 // visit enum members first so that the types of self-referencing members are updated properly
-                if ( ! enumDecl->get_members().empty() ) {
-                        ForwardEnumsType::iterator fwds = forwardEnums.find( enumDecl->get_name() );
+                if ( ! enumDecl->members.empty() ) {
+                        ForwardEnumsType::iterator fwds = forwardEnums.find( enumDecl->name );
                         if ( fwds != forwardEnums.end() ) {
                                 for ( std::list< EnumInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
-                                        (*inst )->set_baseEnum( enumDecl );
+                                        (*inst)->baseEnum = enumDecl;
                                 } // for
                                 forwardEnums.erase( fwds );
@@ -574 +574 @@
                 // visit struct members first so that the types of self-referencing members are updated properly
                 // xxx - need to ensure that type parameters match up between forward declarations and definition (most importantly, number of type parameters and their defaults)
-                if ( ! structDecl->get_members().empty() ) {
-                        ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->get_name() );
+                if ( ! structDecl->members.empty() ) {
+                        ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->name );
                         if ( fwds != forwardStructs.end() ) {
                                 for ( std::list< StructInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
-                                        (*inst )->set_baseStruct( structDecl );
+                                        (*inst)->baseStruct = structDecl;
                                 } // for
                                 forwardStructs.erase( fwds );
@@ -586 +586 @@
 
         void LinkReferenceToTypes::postvisit( UnionDecl *unionDecl ) {
-                if ( ! unionDecl->get_members().empty() ) {
-                        ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->get_name() );
+                if ( ! unionDecl->members.empty() ) {
+                        ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->name );
                         if ( fwds != forwardUnions.end() ) {
                                 for ( std::list< UnionInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
-                                        (*inst )->set_baseUnion( unionDecl );
+                                        (*inst)->baseUnion = unionDecl;
                                 } // for
                                 forwardUnions.erase( fwds );
@@ -600 +600 @@
                 // ensure generic parameter instances are renamed like the base type
                 if ( inGeneric && typeInst->baseType ) typeInst->name = typeInst->baseType->name;
-                if ( NamedTypeDecl *namedTypeDecl = local_indexer->lookupType( typeInst->get_name() ) ) {
+                if ( NamedTypeDecl *namedTypeDecl = local_indexer->lookupType( typeInst->name ) ) {
                         if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
                                 typeInst->set_isFtype( typeDecl->get_kind() == TypeDecl::Ftype );