Changeset 7c782af for src/SymTab

Timestamp:

Feb 16, 2018, 4:22:25 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

5964127

Parents:

c71b256 (diff), 62cd621 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:/u/cforall/software/cfa/cfa-cc

Location:

src/SymTab

Files:

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

src/SymTab/Indexer.cc

@@ -443 +443 @@
                         // 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 override any C declaration
                         if ( hasCompatibleCDecl( name, mangleName, scope ) ) {
-                                throw SemanticError( "Cforall declaration hides C function ", decl );
+                                throw SemanticError( decl, "Cforall declaration hides C function " );
                         }
                 }
@@ -463 +463 @@
         void Indexer::addId( DeclarationWithType * decl, Expression * baseExpr ) {
                 // default handling of conflicts is to raise an error
-                addId( decl, [decl](IdData &, const std::string & msg) { throw SemanticError( msg, decl ); return true; }, baseExpr );
+                addId( decl, [decl](IdData &, const std::string & msg) { throw SemanticError( decl, msg ); return true; }, baseExpr );
         }
 
         void Indexer::addDeletedId( DeclarationWithType * decl, BaseSyntaxNode * deleteStmt ) {
                 // default handling of conflicts is to raise an error
-                addId( decl, [decl](IdData &, const std::string & msg) { throw SemanticError( msg, decl ); return true; }, nullptr, deleteStmt );
+                addId( decl, [decl](IdData &, const std::string & msg) { throw SemanticError( decl, msg ); return true; }, nullptr, deleteStmt );
         }
 
@@ -477 +477 @@
                         return true;
                 } else {
-                        throw SemanticError( "redeclaration of ", added );
+                        throw SemanticError( added, "redeclaration of " );
                 }
         }
@@ -504 +504 @@
                         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

@@ -361 +361 @@
                         // 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 );
+                                throw SemanticError( func, "invalid type void in function type " );
                         }
 
@@ -402 +402 @@
                 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 +502 @@
                 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 +513 @@
                         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() ) ) {
@@ -619 +619 @@
                                 bool isVoid = fixFunction( assertion );
                                 if ( isVoid ) {
-                                        throw SemanticError( "invalid type void in assertion of function ", node );
+                                        throw SemanticError( node, "invalid type void in assertion of function " );
                                 } // if
                         } // for
@@ -663 +663 @@
                 // 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 +704 @@
                                 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 +742 @@
                         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 +749 @@
                         // 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 +847 @@
                                 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 +898 @@
                 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 +940 @@
 
                         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 " );
                 }
         }