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

File:

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

src/SymTab/Validate.cc

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