Changeset a16764a6 for src/SymTab/Validate.cc

Timestamp:

Feb 28, 2018, 4:48:22 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

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:

446ffa3

Parents:

6a8df56

Message:

Changed warning system to prepare for toggling warnings

File:

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

src/SymTab/Validate.cc

@@ -360 +360 @@
                         // 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( func, "invalid type void in function type " );
+                                SemanticError( func, "invalid type void in function type " );
                         }
 
@@ -401 +401 @@
                 for ( Expression * param : inst->parameters ) {
                         if ( ! dynamic_cast< TypeExpr * >( param ) ) {
-                                throw SemanticError( inst, "Expression parameters for generic types are currently unsupported: " );
+                                SemanticError( inst, "Expression parameters for generic types are currently unsupported: " );
                         }
                 }
@@ -501 +501 @@
                 TraitDecl *traitDecl = local_indexer->lookupTrait( traitInst->name );
                 if ( ! traitDecl ) {
-                        throw SemanticError( traitInst->location, "use of undeclared trait " + traitInst->name );
+                        SemanticError( traitInst->location, "use of undeclared trait " + traitInst->name );
                 } // if
                 if ( traitDecl->get_parameters().size() != traitInst->get_parameters().size() ) {
-                        throw SemanticError( traitInst, "incorrect number of trait parameters: " );
+                        SemanticError( traitInst, "incorrect number of trait parameters: " );
                 } // if
                 traitInst->baseTrait = traitDecl;
@@ -512 +512 @@
                         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: " );
+                                SemanticError( std::get<1>(p), "Expression parameters for trait instances are currently unsupported: " );
                         }
                         if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( expr->get_type() ) ) {
@@ -618 +618 @@
                                 bool isVoid = fixFunction( assertion );
                                 if ( isVoid ) {
-                                        throw SemanticError( node, "invalid type void in assertion of function " );
+                                        SemanticError( node, "invalid type void in assertion of function " );
                                 } // if
                         } // for
@@ -662 +662 @@
                 // were cast to void.
                 if ( ! returnStmt->get_expr() && returnVals.size() != 0 ) {
-                        throw SemanticError( returnStmt, "Non-void function returns no values: " );
+                        SemanticError( returnStmt, "Non-void function returns no values: " );
                 }
         }
@@ -703 +703 @@
                                 ReferenceToType *rtt = dynamic_cast<ReferenceToType*>(ret);
                                 if ( ! rtt ) {
-                                        throw SemanticError( typeInst->location, "Cannot apply type parameters to base type of " + typeInst->name );
+                                        SemanticError( typeInst->location, "Cannot apply type parameters to base type of " + typeInst->name );
                                 }
                                 rtt->get_parameters().clear();
@@ -741 +741 @@
                         Type * t2 = typedefNames[ tyDecl->get_name() ].first->get_base();
                         if ( ! ResolvExpr::typesCompatible( t1, t2, Indexer() ) ) {
-                                throw SemanticError( tyDecl->location, "Cannot redefine typedef: " + tyDecl->name );
+                                SemanticError( tyDecl->location, "Cannot redefine typedef: " + tyDecl->name );
                         }
                         // Cannot redefine VLA typedefs. Note: this is slightly incorrect, because our notion of VLAs
@@ -748 +748 @@
                         // 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 );
+                                SemanticError( tyDecl->location, "Cannot redefine typedef: " + tyDecl->name );
                         }
                 } else {
@@ -897 +897 @@
                 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 " );
+                                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( funcDecl, "First parameter of a constructor, destructor, or assignment function must be a reference " );
+                                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( funcDecl, "Constructors and destructors cannot have explicit return values " );
+                                SemanticError( funcDecl, "Constructors and destructors cannot have explicit return values " );
                         }
                 }
@@ -939 +939 @@
 
                         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() ) SemanticError( inst, "Too few type arguments in generic type " );
+                        if ( args.size() > params->size() ) SemanticError( inst, "Too many type arguments in generic type " );
                 }
         }