Changes in src/SymTab/Validate.cc [d24d4e1:ce8c12f]

File:

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

src/SymTab/Validate.cc

@@ -38 +38 @@
 //   definition occurs later in the input.
 
-#include <algorithm>
+#include <list>
 #include <iterator>
-#include <list>
-
-#include "CodeGen/CodeGenerator.h"
-
-#include "Common/PassVisitor.h"
 #include "Common/ScopedMap.h"
+#include "Common/utility.h"
 #include "Common/UniqueName.h"
-#include "Common/utility.h"
-
 #include "Concurrency/Keywords.h"
-
-#include "GenPoly/DeclMutator.h"
-
-#include "InitTweak/InitTweak.h"
-
-#include "AddVisit.h"
-#include "Autogen.h"
+#include "Validate.h"
+#include "SynTree/Visitor.h"
+#include "SynTree/Mutator.h"
+#include "SynTree/Type.h"
+#include "SynTree/Expression.h"
+#include "SynTree/Statement.h"
+#include "SynTree/TypeSubstitution.h"
+#include "Indexer.h"
 #include "FixFunction.h"
 // #include "ImplementationType.h"
-#include "Indexer.h"
+#include "GenPoly/DeclMutator.h"
+#include "AddVisit.h"
 #include "MakeLibCfa.h"
 #include "TypeEquality.h"
-#include "Validate.h"
-
+#include "Autogen.h"
 #include "ResolvExpr/typeops.h"
-
-#include "SynTree/Attribute.h"
-#include "SynTree/Expression.h"
-#include "SynTree/Mutator.h"
-#include "SynTree/Statement.h"
-#include "SynTree/Type.h"
-#include "SynTree/TypeSubstitution.h"
-#include "SynTree/Visitor.h"
+#include <algorithm>
+#include "InitTweak/InitTweak.h"
+#include "CodeGen/CodeGenerator.h"
 
 #define debugPrint( x ) if ( doDebug ) { std::cout << x; }
@@ -106 +96 @@
 
         /// Fix return types so that every function returns exactly one value
-        struct ReturnTypeFixer {
+        class ReturnTypeFixer final : public Visitor {
+          public:
+                typedef Visitor Parent;
+                using Parent::visit;
+
                 static void fix( std::list< Declaration * > &translationUnit );
 
-                void postvisit( FunctionDecl * functionDecl );
-                void postvisit( FunctionType * ftype );
+                virtual void visit( FunctionDecl * functionDecl );
+                virtual void visit( FunctionType * ftype );
         };
 
         /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers.
-        struct EnumAndPointerDecay {
-                void previsit( EnumDecl *aggregateDecl );
-                void previsit( FunctionType *func );
+        class EnumAndPointerDecayPass final : public Visitor {
+                typedef Visitor Parent;
+                virtual void visit( EnumDecl *aggregateDecl );
+                virtual void visit( FunctionType *func );
         };
 
@@ -124 +119 @@
           public:
                 LinkReferenceToTypes( bool doDebug, const Indexer *indexer );
+          private:
                 using Parent::visit;
                 void visit( EnumInstType *enumInst ) final;
@@ -133 +129 @@
                 void visit( UnionDecl *unionDecl ) final;
                 void visit( TypeInstType *typeInst ) final;
-          private:
+
                 const Indexer *indexer;
 
@@ -144 +140 @@
         };
 
-        /// 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 {
+        /// Replaces array and function types in forall lists by appropriate pointer type
+        class Pass3 final : public Indexer {
                 typedef Indexer Parent;
           public:
                 using Parent::visit;
-                ForallPointerDecay( const Indexer *indexer );
-
+                Pass3( const Indexer *indexer );
+          private:
                 virtual void visit( ObjectDecl *object ) override;
                 virtual void visit( FunctionDecl *func ) override;
@@ -157 +153 @@
         };
 
-        struct ReturnChecker : public WithGuards {
+        class ReturnChecker : public Visitor {
+          public:
                 /// Checks that return statements return nothing if their return type is void
                 /// and return something if the return type is non-void.
                 static void checkFunctionReturns( std::list< Declaration * > & translationUnit );
-
-                void previsit( FunctionDecl * functionDecl );
-                void previsit( ReturnStmt * returnStmt );
-
-                typedef std::list< DeclarationWithType * > ReturnVals;
-                ReturnVals returnVals;
+          private:
+                virtual void visit( FunctionDecl * functionDecl );
+                virtual void visit( ReturnStmt * returnStmt );
+
+                std::list< DeclarationWithType * > returnVals;
         };
 
@@ -202 +198 @@
         };
 
-        struct VerifyCtorDtorAssign {
+        class VerifyCtorDtorAssign : public Visitor {
+        public:
                 /// ensure that constructors, destructors, and assignment have at least one
                 /// parameter, the first of which must be a pointer, and that ctor/dtors have no
@@ -208 +205 @@
                 static void verify( std::list< Declaration * > &translationUnit );
 
-                void previsit( FunctionDecl *funcDecl );
+                virtual void visit( FunctionDecl *funcDecl );
         };
 
-        /// ensure that generic types have the correct number of type arguments
-        struct ValidateGenericParameters {
-                void previsit( StructInstType * inst );
-                void previsit( UnionInstType * inst );
-        };
-
-        struct ArrayLength {
+        class ArrayLength : public Visitor {
+        public:
                 /// for array types without an explicit length, compute the length and store it so that it
                 /// is known to the rest of the phases. For example,
@@ -227 +219 @@
                 static void computeLength( std::list< Declaration * > & translationUnit );
 
-                void previsit( ObjectDecl * objDecl );
+                virtual void visit( ObjectDecl * objDecl );
         };
 
-        struct CompoundLiteral final : public WithDeclsToAdd, public WithVisitorRef<CompoundLiteral> {
+        class CompoundLiteral final : public GenPoly::DeclMutator {
                 Type::StorageClasses storageClasses;
 
-                void premutate( ObjectDecl *objectDecl );
-                Expression * postmutate( CompoundLiteralExpr *compLitExpr );
+                using GenPoly::DeclMutator::mutate;
+                DeclarationWithType * mutate( ObjectDecl *objectDecl ) final;
+                Expression *mutate( CompoundLiteralExpr *compLitExpr ) final;
         };
 
         void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
-                PassVisitor<EnumAndPointerDecay> epc;
+                EnumAndPointerDecayPass epc;
                 LinkReferenceToTypes lrt( doDebug, 0 );
-                ForallPointerDecay fpd( 0 );
-                PassVisitor<CompoundLiteral> compoundliteral;
-                PassVisitor<ValidateGenericParameters> genericParams;
-
+                Pass3 pass3( 0 );
+                CompoundLiteral compoundliteral;
+
+                HoistStruct::hoistStruct( translationUnit );
                 EliminateTypedef::eliminateTypedef( translationUnit );
-                HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
                 ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
                 acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
-                acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes
                 acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist
                 VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
                 Concurrency::applyKeywords( translationUnit );
-                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay
+                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecayPass
                 Concurrency::implementMutexFuncs( translationUnit );
                 Concurrency::implementThreadStarter( translationUnit );
                 ReturnChecker::checkFunctionReturns( translationUnit );
-                mutateAll( translationUnit, compoundliteral );
-                acceptAll( translationUnit, fpd );
+                compoundliteral.mutateDeclarationList( translationUnit );
+                acceptAll( translationUnit, pass3 );
                 ArrayLength::computeLength( translationUnit );
         }
 
         void validateType( Type *type, const Indexer *indexer ) {
-                PassVisitor<EnumAndPointerDecay> epc;
+                EnumAndPointerDecayPass epc;
                 LinkReferenceToTypes lrt( false, indexer );
-                ForallPointerDecay fpd( indexer );
+                Pass3 pass3( indexer );
                 type->accept( epc );
                 type->accept( lrt );
-                type->accept( fpd );
+                type->accept( pass3 );
         }
 
@@ -346 +337 @@
         }
 
-        void EnumAndPointerDecay::previsit( EnumDecl *enumDecl ) {
+        void EnumAndPointerDecayPass::visit( EnumDecl *enumDecl ) {
                 // Set the type of each member of the enumeration to be EnumConstant
                 for ( std::list< Declaration * >::iterator i = enumDecl->get_members().begin(); i != enumDecl->get_members().end(); ++i ) {
@@ -353 +344 @@
                         obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->get_name() ) );
                 } // for
+                Parent::visit( enumDecl );
         }
 
@@ -359 +351 @@
                 void fixFunctionList( DWTList & dwts, FunctionType * func ) {
                         // the only case in which "void" is valid is where it is the only one in the list; then it should be removed
-                        // entirely. other fix ups are handled by the FixFunction class
+                        // entirely other fix ups are handled by the FixFunction class
                         typedef typename DWTList::iterator DWTIterator;
                         DWTIterator begin( dwts.begin() ), end( dwts.end() );
@@ -378 +370 @@
                                 for ( ; i != end; ++i ) {
                                         FixFunction fixer;
-                                        *i = (*i)->acceptMutator( fixer );
+                                        *i = (*i )->acceptMutator( fixer );
                                         if ( fixer.get_isVoid() ) {
                                                 throw SemanticError( "invalid type void in function type ", func );
@@ -387 +379 @@
         }
 
-        void EnumAndPointerDecay::previsit( FunctionType *func ) {
+        void EnumAndPointerDecayPass::visit( FunctionType *func ) {
                 // Fix up parameters and return types
                 fixFunctionList( func->get_parameters(), func );
                 fixFunctionList( func->get_returnVals(), func );
+                Visitor::visit( func );
         }
 
@@ -503 +496 @@
         void LinkReferenceToTypes::visit( 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 );
                 if ( ! structDecl->get_members().empty() ) {
@@ -537 +529 @@
         }
 
-        ForallPointerDecay::ForallPointerDecay( const Indexer *other_indexer ) :  Indexer( false ) {
+        Pass3::Pass3( const Indexer *other_indexer ) :  Indexer( false ) {
                 if ( other_indexer ) {
                         indexer = other_indexer;
@@ -575 +567 @@
         }
 
-        void ForallPointerDecay::visit( ObjectDecl *object ) {
+        void Pass3::visit( ObjectDecl *object ) {
                 forallFixer( object->get_type() );
                 if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) {
@@ -584 +576 @@
         }
 
-        void ForallPointerDecay::visit( FunctionDecl *func ) {
+        void Pass3::visit( FunctionDecl *func ) {
                 forallFixer( func->get_type() );
                 Parent::visit( func );
@@ -591 +583 @@
 
         void ReturnChecker::checkFunctionReturns( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<ReturnChecker> checker;
+                ReturnChecker checker;
                 acceptAll( translationUnit, checker );
         }
 
-        void ReturnChecker::previsit( FunctionDecl * functionDecl ) {
-                GuardValue( returnVals );
+        void ReturnChecker::visit( FunctionDecl * functionDecl ) {
+                std::list< DeclarationWithType * > oldReturnVals = returnVals;
                 returnVals = functionDecl->get_functionType()->get_returnVals();
-        }
-
-        void ReturnChecker::previsit( ReturnStmt * returnStmt ) {
+                Visitor::visit( functionDecl );
+                returnVals = oldReturnVals;
+        }
+
+        void ReturnChecker::visit( ReturnStmt * returnStmt ) {
                 // Previously this also checked for the existence of an expr paired with no return values on
                 // the  function return type. This is incorrect, since you can have an expression attached to
@@ -810 +804 @@
 
         void VerifyCtorDtorAssign::verify( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<VerifyCtorDtorAssign> verifier;
+                VerifyCtorDtorAssign verifier;
                 acceptAll( translationUnit, verifier );
         }
 
-        void VerifyCtorDtorAssign::previsit( FunctionDecl * funcDecl ) {
+        void VerifyCtorDtorAssign::visit( FunctionDecl * funcDecl ) {
                 FunctionType * funcType = funcDecl->get_functionType();
                 std::list< DeclarationWithType * > &returnVals = funcType->get_returnVals();
@@ -824 +818 @@
                         }
                         PointerType * ptrType = dynamic_cast< PointerType * >( params.front()->get_type() );
-                        if ( ! ptrType || ptrType->is_array() ) {
+                        ReferenceType * refType = dynamic_cast< ReferenceType * >( params.front()->get_type() );
+                        if ( ( ! ptrType && ! refType ) || ( ptrType && ptrType->is_array() ) ) {
                                 throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a pointer ", funcDecl );
                         }
@@ -831 +826 @@
                         }
                 }
-        }
-
-        template< typename Aggr >
-        void validateGeneric( Aggr * inst ) {
-                std::list< TypeDecl * > * params = inst->get_baseParameters();
-                if ( params != NULL ) {
-                        std::list< Expression * > & args = inst->get_parameters();
-
-                        // insert defaults arguments when a type argument is missing (currently only supports missing arguments at the end of the list).
-                        // A substitution is used to ensure that defaults are replaced correctly, e.g.,
-                        //   forall(otype T, otype alloc = heap_allocator(T)) struct vector;
-                        //   vector(int) v;
-                        // after insertion of default values becomes
-                        //   vector(int, heap_allocator(T))
-                        // and the substitution is built with T=int so that after substitution, the result is
-                        //   vector(int, heap_allocator(int))
-                        TypeSubstitution sub;
-                        auto paramIter = params->begin();
-                        for ( size_t i = 0; paramIter != params->end(); ++paramIter, ++i ) {
-                                if ( i < args.size() ) {
-                                        TypeExpr * expr = safe_dynamic_cast< TypeExpr * >( *std::next( args.begin(), i ) );
-                                        sub.add( (*paramIter)->get_name(), expr->get_type()->clone() );
-                                } else if ( i == args.size() ) {
-                                        Type * defaultType = (*paramIter)->get_init();
-                                        if ( defaultType ) {
-                                                args.push_back( new TypeExpr( defaultType->clone() ) );
-                                                sub.add( (*paramIter)->get_name(), defaultType->clone() );
-                                        }
-                                }
-                        }
-
-                        sub.apply( inst );
-                        if ( args.size() < params->size() ) throw SemanticError( "Too few type arguments in generic type ", inst );
-                        if ( args.size() > params->size() ) throw SemanticError( "Too many type arguments in generic type ", inst );
-                }
-        }
-
-        void ValidateGenericParameters::previsit( StructInstType * inst ) {
-                validateGeneric( inst );
-        }
-
-        void ValidateGenericParameters::previsit( UnionInstType * inst ) {
-                validateGeneric( inst );
-        }
-
-        void CompoundLiteral::premutate( ObjectDecl *objectDecl ) {
+
+                Visitor::visit( funcDecl );
+        }
+
+        DeclarationWithType * CompoundLiteral::mutate( ObjectDecl *objectDecl ) {
                 storageClasses = objectDecl->get_storageClasses();
-        }
-
-        Expression *CompoundLiteral::postmutate( CompoundLiteralExpr *compLitExpr ) {
+                DeclarationWithType * temp = Mutator::mutate( objectDecl );
+                return temp;
+        }
+
+        Expression *CompoundLiteral::mutate( CompoundLiteralExpr *compLitExpr ) {
                 // transform [storage_class] ... (struct S){ 3, ... };
                 // into [storage_class] struct S temp =  { 3, ... };
                 static UniqueName indexName( "_compLit" );
 
-                ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, nullptr, compLitExpr->get_result(), compLitExpr->get_initializer() );
-                compLitExpr->set_result( nullptr );
-                compLitExpr->set_initializer( nullptr );
+                ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, 0, compLitExpr->get_result(), compLitExpr->get_initializer() );
+                compLitExpr->set_result( 0 );
+                compLitExpr->set_initializer( 0 );
                 delete compLitExpr;
-                declsToAddBefore.push_back( tempvar );                                  // add modified temporary to current block
-                return new VariableExpr( tempvar );
+                DeclarationWithType * newtempvar = mutate( tempvar );
+                addDeclaration( newtempvar );                                   // add modified temporary to current block
+                return new VariableExpr( newtempvar );
         }
 
         void ReturnTypeFixer::fix( std::list< Declaration * > &translationUnit ) {
-                PassVisitor<ReturnTypeFixer> fixer;
+                ReturnTypeFixer fixer;
                 acceptAll( translationUnit, fixer );
         }
 
-        void ReturnTypeFixer::postvisit( FunctionDecl * functionDecl ) {
+        void ReturnTypeFixer::visit( FunctionDecl * functionDecl ) {
+                Parent::visit( functionDecl );
                 FunctionType * ftype = functionDecl->get_functionType();
                 std::list< DeclarationWithType * > & retVals = ftype->get_returnVals();
@@ -909 +867 @@
                                 ret->set_name( toString( "_retval_", CodeGen::genName( functionDecl ) ) );
                         }
-                        ret->get_attributes().push_back( new Attribute( "unused" ) );
-                }
-        }
-
-        void ReturnTypeFixer::postvisit( FunctionType * ftype ) {
+                }
+        }
+
+        void ReturnTypeFixer::visit( FunctionType * ftype ) {
                 // xxx - need to handle named return values - this information needs to be saved somehow
                 // so that resolution has access to the names.
@@ -931 +888 @@
 
         void ArrayLength::computeLength( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<ArrayLength> len;
+                ArrayLength len;
                 acceptAll( translationUnit, len );
         }
 
-        void ArrayLength::previsit( ObjectDecl * objDecl ) {
+        void ArrayLength::visit( ObjectDecl * objDecl ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->get_type() ) ) {
                         if ( at->get_dimension() != nullptr ) return;