Changes in src/SymTab/Validate.cc [4bda2cf:0b0f1dd]

File:

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

src/SymTab/Validate.cc

@@ -351 +351 @@
         namespace {
                 template< typename DWTList >
-                void fixFunctionList( DWTList & dwts, bool isVarArgs, FunctionType * func ) {
-                        auto nvals = dwts.size();
-                        bool containsVoid = false;
-                        for ( auto & dwt : dwts ) {
-                                // fix each DWT and record whether a void was found
-                                containsVoid |= fixFunction( dwt );
-                        }
-
-                        // the only case in which "void" is valid is where it is the only one in the list
-                        if ( containsVoid && ( nvals > 1 || isVarArgs ) ) {
-                                throw SemanticError( "invalid type void in function type ", func );
-                        }
-
-                        // one void is the only thing in the list; remove it.
-                        if ( containsVoid ) {
-                                delete dwts.front();
-                                dwts.clear();
-                        }
+                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
+                        typedef typename DWTList::iterator DWTIterator;
+                        DWTIterator begin( dwts.begin() ), end( dwts.end() );
+                        if ( begin == end ) return;
+                        PassVisitor<FixFunction> fixer;
+                        DWTIterator i = begin;
+                        *i = (*i)->acceptMutator( fixer );
+                        if ( fixer.pass.isVoid ) {
+                                DWTIterator j = i;
+                                ++i;
+                                delete *j;
+                                dwts.erase( j );
+                                if ( i != end ) {
+                                        throw SemanticError( func, "invalid type void in function type " );
+                                } // if
+                        } else {
+                                ++i;
+                                for ( ; i != end; ++i ) {
+                                        PassVisitor<FixFunction> fixer;
+                                        *i = (*i)->acceptMutator( fixer );
+                                        if ( fixer.pass.isVoid ) {
+                                                throw SemanticError( func, "invalid type void in function type " );
+                                        } // if
+                                } // for
+                        } // if
                 }
         }
@@ -374 +383 @@
         void EnumAndPointerDecay::previsit( FunctionType *func ) {
                 // Fix up parameters and return types
-                fixFunctionList( func->parameters, func->isVarArgs, func );
-                fixFunctionList( func->returnVals, false, func );
+                fixFunctionList( func->get_parameters(), func );
+                fixFunctionList( func->get_returnVals(), func );
         }
 
@@ -402 +411 @@
                 for ( Expression * param : inst->parameters ) {
                         if ( ! dynamic_cast< TypeExpr * >( param ) ) {
-                                throw SemanticError( "Expression parameters for generic types are currently unsupported: ", inst );
+                                throw SemanticError( inst, "Expression parameters for generic types are currently unsupported: " );
                         }
                 }
@@ -502 +511 @@
                 TraitDecl *traitDecl = local_indexer->lookupTrait( traitInst->name );
                 if ( ! traitDecl ) {
-                        throw SemanticError( "use of undeclared trait " + traitInst->name );
+                        throw SemanticError( traitInst->location, "use of undeclared trait " + traitInst->name );
                 } // if
                 if ( traitDecl->get_parameters().size() != traitInst->get_parameters().size() ) {
-                        throw SemanticError( "incorrect number of trait parameters: ", traitInst );
+                        throw SemanticError( traitInst, "incorrect number of trait parameters: " );
                 } // if
                 traitInst->baseTrait = traitDecl;
@@ -513 +522 @@
                         TypeExpr * expr = dynamic_cast< TypeExpr * >( std::get<1>(p) );
                         if ( ! expr ) {
-                                throw SemanticError( "Expression parameters for trait instances are currently unsupported: ", std::get<1>(p) );
+                                throw SemanticError( std::get<1>(p), "Expression parameters for trait instances are currently unsupported: " );
                         }
                         if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( expr->get_type() ) ) {
@@ -617 +626 @@
                         // apply FixFunction to every assertion to check for invalid void type
                         for ( DeclarationWithType *& assertion : type->assertions ) {
-                                bool isVoid = fixFunction( assertion );
-                                if ( isVoid ) {
-                                        throw SemanticError( "invalid type void in assertion of function ", node );
+                                PassVisitor<FixFunction> fixer;
+                                assertion = assertion->acceptMutator( fixer );
+                                if ( fixer.pass.isVoid ) {
+                                        throw SemanticError( node, "invalid type void in assertion of function " );
                                 } // if
                         } // for
@@ -663 +673 @@
                 // were cast to void.
                 if ( ! returnStmt->get_expr() && returnVals.size() != 0 ) {
-                        throw SemanticError( "Non-void function returns no values: " , returnStmt );
+                        throw SemanticError( returnStmt, "Non-void function returns no values: " );
                 }
         }
@@ -704 +714 @@
                                 ReferenceToType *rtt = dynamic_cast<ReferenceToType*>(ret);
                                 if ( ! rtt ) {
-                                        throw SemanticError("Cannot apply type parameters to base type of " + typeInst->name);
+                                        throw SemanticError( typeInst->location, "Cannot apply type parameters to base type of " + typeInst->name );
                                 }
                                 rtt->get_parameters().clear();
@@ -742 +752 @@
                         Type * t2 = typedefNames[ tyDecl->get_name() ].first->get_base();
                         if ( ! ResolvExpr::typesCompatible( t1, t2, Indexer() ) ) {
-                                throw SemanticError( "Cannot redefine typedef: " + tyDecl->name );
+                                throw SemanticError( tyDecl->location, "Cannot redefine typedef: " + tyDecl->name );
                         }
                         // Cannot redefine VLA typedefs. Note: this is slightly incorrect, because our notion of VLAs
@@ -749 +759 @@
                         // to fix this corner case likely outweighs the utility of allowing it.
                         if ( isVariableLength( t1 ) || isVariableLength( t2 ) ) {
-                                throw SemanticError( "Cannot redefine typedef: " + tyDecl->name );
+                                throw SemanticError( tyDecl->location, "Cannot redefine typedef: " + tyDecl->name );
                         }
                 } else {
@@ -847 +857 @@
                                 type = new EnumInstType( Type::Qualifiers(), newDeclEnumDecl->get_name() );
                         } // if
-                        TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), Type::StorageClasses(), type, aggDecl->get_linkage() ) );
+                        TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), aggDecl->location, Type::StorageClasses(), type, aggDecl->get_linkage() ) );
                         typedefNames[ aggDecl->get_name() ] = std::make_pair( std::move( tyDecl ), scopeLevel );
                 } // if
@@ -898 +908 @@
                 if ( CodeGen::isCtorDtorAssign( funcDecl->get_name() ) ) { // TODO: also check /=, etc.
                         if ( params.size() == 0 ) {
-                                throw SemanticError( "Constructors, destructors, and assignment functions require at least one parameter ", funcDecl );
+                                throw SemanticError( funcDecl, "Constructors, destructors, and assignment functions require at least one parameter " );
                         }
                         ReferenceType * refType = dynamic_cast< ReferenceType * >( params.front()->get_type() );
                         if ( ! refType ) {
-                                throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a reference ", funcDecl );
+                                throw SemanticError( funcDecl, "First parameter of a constructor, destructor, or assignment function must be a reference " );
                         }
                         if ( CodeGen::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) {
-                                throw SemanticError( "Constructors and destructors cannot have explicit return values ", funcDecl );
+                                throw SemanticError( funcDecl, "Constructors and destructors cannot have explicit return values " );
                         }
                 }
@@ -940 +950 @@
 
                         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 );
+                        if ( args.size() < params->size() ) throw SemanticError( inst, "Too few type arguments in generic type " );
+                        if ( args.size() > params->size() ) throw SemanticError( inst, "Too many type arguments in generic type " );
                 }
         }