Changeset d55d7a6 for src/SymTab

Timestamp:

Feb 15, 2018, 3:58:56 PM (7 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:

75e3cb2

Parents:

d27e340

Message:

Massive change to errors to enable warnings

Location:

src/SymTab

Files:

• Indexer.cc (modified) (5 diffs)
• Validate.cc (modified) (12 diffs)

src/SymTab/Indexer.cc

@@ -388 +388 @@
                         if ( newentry && oldentry ) {
                                 if ( newentry->get_statements() && oldentry->get_statements() ) {
-                                        throw SemanticError( "duplicate function definition for ", added );
+                                        throw SemanticError( added, "duplicate function definition for " );
                                 } // if
                         } else {
@@ -398 +398 @@
                                 ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( existing );
                                 if ( ! newobj->get_storageClasses().is_extern && ! oldobj->get_storageClasses().is_extern ) {
-                                        throw SemanticError( "duplicate object definition for ", added );
+                                        throw SemanticError( added, "duplicate object definition for " );
                                 } // if
                         } // if
                 } else {
-                        throw SemanticError( "duplicate definition for ", added );
+                        throw SemanticError( added, "duplicate definition for " );
                 } // if
 
@@ -431 +431 @@
                         // isomorphic to C type-compatibility, which it may not be.
                         if ( hasIncompatibleCDecl( name, mangleName, scope ) ) {
-                                throw SemanticError( "conflicting overload of C function ", decl );
+                                throw SemanticError( decl, "conflicting overload of C function " );
                         }
                 } else {
                         // Check that a Cforall declaration doesn't overload any C declaration
                         if ( hasCompatibleCDecl( name, mangleName, scope ) ) {
-                                throw SemanticError( "Cforall declaration hides C function ", decl );
+                                throw SemanticError( decl, "Cforall declaration hides C function " );
                         }
                 }
@@ -455 +455 @@
                         return true;
                 } else {
-                        throw SemanticError( "redeclaration of ", added );
+                        throw SemanticError( added, "redeclaration of " );
                 }
         }
@@ -482 +482 @@
                         return false;
                 } else if ( ! added->get_members().empty() ) {
-                        throw SemanticError( "redeclaration of ", added );
+                        throw SemanticError( added, "redeclaration of " );
                 } // if
                 return true;

src/SymTab/Validate.cc

@@ -366 +366 @@
                                 dwts.erase( j );
                                 if ( i != end ) {
-                                        throw SemanticError( "invalid type void in function type ", func );
+                                        throw SemanticError( func, "invalid type void in function type " );
                                 } // if
                         } else {
@@ -374 +374 @@
                                         *i = (*i)->acceptMutator( fixer );
                                         if ( fixer.pass.isVoid ) {
-                                                throw SemanticError( "invalid type void in function type ", func );
+                                                throw SemanticError( func, "invalid type void in function type " );
                                         } // if
                                 } // for
@@ -411 +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: " );
                         }
                 }
@@ -511 +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;
@@ -522 +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() ) ) {
@@ -629 +629 @@
                                 assertion = assertion->acceptMutator( fixer );
                                 if ( fixer.pass.isVoid ) {
-                                        throw SemanticError( "invalid type void in assertion of function ", node );
+                                        throw SemanticError( node, "invalid type void in assertion of function " );
                                 } // if
                         } // for
@@ -673 +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: " );
                 }
         }
@@ -714 +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();
@@ -752 +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
@@ -759 +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 {
@@ -908 +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 " );
                         }
                 }
@@ -950 +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 " );
                 }
         }