Changeset 522363e for src/SymTab

Timestamp:

Sep 14, 2017, 1:46:06 PM (7 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, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

3e3d923, bff09c8, f92c696

Parents:

c57ded70

Message:

Fix PassVisitor? Indexer calls, aggregate top-level errors in PassVisitor?, convert ForallPointerDecay? and LinkReferenceToTypes? to PassVisitor?

Location:

src/SymTab

Files:

• Indexer.cc (modified) (1 diff)
• Indexer.h (modified) (2 diffs)
• Validate.cc (modified) (14 diffs)

src/SymTab/Indexer.cc

@@ -37 +37 @@
 #include "SynTree/Type.h"          // for Type, StructInstType, UnionInstType
 
-#define debugPrint(x) if ( doDebug ) { std::cout << x; }
+#define debugPrint(x) if ( doDebug ) { std::cerr << x; }
 
 namespace SymTab {

src/SymTab/Indexer.h

@@ -104 +104 @@
 
                 void print( std::ostream &os, int indent = 0 ) const;
-          private:
+
                 /// looks up a specific mangled ID at the given scope
                 DeclarationWithType *lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
@@ -127 +127 @@
                 void addTrait( TraitDecl *decl );
 
+          private:
                 struct Impl;
 

src/SymTab/Validate.cc

@@ -123 +123 @@
 
         /// Associates forward declarations of aggregates with their definitions
-        class LinkReferenceToTypes final : public Indexer {
-                typedef Indexer Parent;
-          public:
-                LinkReferenceToTypes( bool doDebug, const Indexer *indexer );
-                using Parent::visit;
-                void visit( TypeInstType *typeInst ) final;
-
-                void visit( EnumInstType *enumInst ) final;
-                void visit( StructInstType *structInst ) final;
-                void visit( UnionInstType *unionInst ) final;
-                void visit( TraitInstType *traitInst ) final;
-
-                void visit( EnumDecl *enumDecl ) final;
-                void visit( StructDecl *structDecl ) final;
-                void visit( UnionDecl *unionDecl ) final;
-                void visit( TraitDecl * traitDecl ) final;
+        struct LinkReferenceToTypes final : public WithIndexer {
+                LinkReferenceToTypes( const Indexer *indexer );
+                void postvisit( TypeInstType *typeInst );
+
+                void postvisit( EnumInstType *enumInst );
+                void postvisit( StructInstType *structInst );
+                void postvisit( UnionInstType *unionInst );
+                void postvisit( TraitInstType *traitInst );
+
+                void postvisit( EnumDecl *enumDecl );
+                void postvisit( StructDecl *structDecl );
+                void postvisit( UnionDecl *unionDecl );
+                void postvisit( TraitDecl * traitDecl );
 
           private:
-                const Indexer *indexer;
+                const Indexer *local_indexer;
 
                 typedef std::map< std::string, std::list< EnumInstType * > > ForwardEnumsType;
@@ -152 +149 @@
 
         /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID.
-        class ForallPointerDecay final : public Indexer {
-                typedef Indexer Parent;
-          public:
-                using Parent::visit;
-                ForallPointerDecay( const Indexer *indexer );
-
-                virtual void visit( ObjectDecl *object ) override;
-                virtual void visit( FunctionDecl *func ) override;
-
-                const Indexer *indexer;
+        struct ForallPointerDecay final {
+                void previsit( ObjectDecl *object );
+                void previsit( FunctionDecl *func );
         };
 
@@ -263 +253 @@
         };
 
-        void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
+        void validate( std::list< Declaration * > &translationUnit, __attribute__((unused)) bool doDebug ) {
                 PassVisitor<EnumAndPointerDecay> epc;
-                LinkReferenceToTypes lrt( doDebug, 0 );
-                ForallPointerDecay fpd( 0 );
+                PassVisitor<LinkReferenceToTypes> lrt( nullptr );
+                PassVisitor<ForallPointerDecay> fpd;
                 PassVisitor<CompoundLiteral> compoundliteral;
                 PassVisitor<ValidateGenericParameters> genericParams;
@@ -293 +283 @@
         void validateType( Type *type, const Indexer *indexer ) {
                 PassVisitor<EnumAndPointerDecay> epc;
-                LinkReferenceToTypes lrt( false, indexer );
-                ForallPointerDecay fpd( indexer );
+                PassVisitor<LinkReferenceToTypes> lrt( indexer );
+                PassVisitor<ForallPointerDecay> fpd;
                 type->accept( epc );
                 type->accept( lrt );
@@ -408 +398 @@
         }
 
-        LinkReferenceToTypes::LinkReferenceToTypes( bool doDebug, const Indexer *other_indexer ) : Indexer( doDebug ) {
+        LinkReferenceToTypes::LinkReferenceToTypes( const Indexer *other_indexer ) {
                 if ( other_indexer ) {
-                        indexer = other_indexer;
+                        local_indexer = other_indexer;
                 } else {
-                        indexer = this;
-                } // if
-        }
-
-        void LinkReferenceToTypes::visit( EnumInstType *enumInst ) {
-                Parent::visit( enumInst );
-                EnumDecl *st = indexer->lookupEnum( enumInst->get_name() );
+                        local_indexer = &indexer;
+                } // if
+        }
+
+        void LinkReferenceToTypes::postvisit( EnumInstType *enumInst ) {
+                EnumDecl *st = local_indexer->lookupEnum( enumInst->get_name() );
                 // it's not a semantic error if the enum is not found, just an implicit forward declaration
                 if ( st ) {
@@ -430 +419 @@
         }
 
-        void LinkReferenceToTypes::visit( StructInstType *structInst ) {
-                Parent::visit( structInst );
-                StructDecl *st = indexer->lookupStruct( structInst->get_name() );
+        void LinkReferenceToTypes::postvisit( StructInstType *structInst ) {
+                StructDecl *st = local_indexer->lookupStruct( structInst->get_name() );
                 // it's not a semantic error if the struct is not found, just an implicit forward declaration
                 if ( st ) {
@@ -444 +432 @@
         }
 
-        void LinkReferenceToTypes::visit( UnionInstType *unionInst ) {
-                Parent::visit( unionInst );
-                UnionDecl *un = indexer->lookupUnion( unionInst->get_name() );
+        void LinkReferenceToTypes::postvisit( UnionInstType *unionInst ) {
+                UnionDecl *un = local_indexer->lookupUnion( unionInst->get_name() );
                 // it's not a semantic error if the union is not found, just an implicit forward declaration
                 if ( un ) {
@@ -499 +486 @@
         }
 
-        void LinkReferenceToTypes::visit( TraitDecl * traitDecl ) {
-                Parent::visit( traitDecl );
-
+        void LinkReferenceToTypes::postvisit( TraitDecl * traitDecl ) {
                 if ( traitDecl->name == "sized" ) {
                         // "sized" is a special trait - flick the sized status on for the type variable
@@ -523 +508 @@
         }
 
-        void LinkReferenceToTypes::visit( TraitInstType * traitInst ) {
-                Parent::visit( traitInst );
+        void LinkReferenceToTypes::postvisit( TraitInstType * traitInst ) {
                 // handle other traits
-                TraitDecl *traitDecl = indexer->lookupTrait( traitInst->name );
+                TraitDecl *traitDecl = local_indexer->lookupTrait( traitInst->name );
                 if ( ! traitDecl ) {
                         throw SemanticError( "use of undeclared trait " + traitInst->name );
@@ -547 +531 @@
         }
 
-        void LinkReferenceToTypes::visit( EnumDecl *enumDecl ) {
+        void LinkReferenceToTypes::postvisit( EnumDecl *enumDecl ) {
                 // visit enum members first so that the types of self-referencing members are updated properly
-                Parent::visit( enumDecl );
                 if ( ! enumDecl->get_members().empty() ) {
                         ForwardEnumsType::iterator fwds = forwardEnums.find( enumDecl->get_name() );
@@ -561 +544 @@
         }
 
-        void LinkReferenceToTypes::visit( StructDecl *structDecl ) {
+        void LinkReferenceToTypes::postvisit( StructDecl *structDecl ) {
                 // 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 and their defaults)
-                Parent::visit( structDecl );
+                // 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() );
@@ -576 +558 @@
         }
 
-        void LinkReferenceToTypes::visit( UnionDecl *unionDecl ) {
-                Parent::visit( unionDecl );
+        void LinkReferenceToTypes::postvisit( UnionDecl *unionDecl ) {
                 if ( ! unionDecl->get_members().empty() ) {
                         ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->get_name() );
@@ -589 +570 @@
         }
 
-        void LinkReferenceToTypes::visit( TypeInstType *typeInst ) {
-                if ( NamedTypeDecl *namedTypeDecl = lookupType( typeInst->get_name() ) ) {
+        void LinkReferenceToTypes::postvisit( TypeInstType *typeInst ) {
+                if ( NamedTypeDecl *namedTypeDecl = local_indexer->lookupType( typeInst->get_name() ) ) {
                         if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
                                 typeInst->set_isFtype( typeDecl->get_kind() == TypeDecl::Ftype );
                         } // if
-                } // if
-        }
-
-        ForallPointerDecay::ForallPointerDecay( const Indexer *other_indexer ) :  Indexer( false ) {
-                if ( other_indexer ) {
-                        indexer = other_indexer;
-                } else {
-                        indexer = this;
                 } // if
         }
@@ -633 +606 @@
         }
 
-        void ForallPointerDecay::visit( ObjectDecl *object ) {
+        void ForallPointerDecay::previsit( ObjectDecl *object ) {
                 forallFixer( object->get_type() );
                 if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) {
                         forallFixer( pointer->get_base() );
                 } // if
-                Parent::visit( object );
                 object->fixUniqueId();
         }
 
-        void ForallPointerDecay::visit( FunctionDecl *func ) {
+        void ForallPointerDecay::previsit( FunctionDecl *func ) {
                 forallFixer( func->get_type() );
-                Parent::visit( func );
                 func->fixUniqueId();
         }