Changeset d55d7a6 for src/ResolvExpr

Timestamp:

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

Files:

• AlternativeFinder.cc (modified) (5 diffs)
• CurrentObject.cc (modified) (4 diffs)
• Resolver.cc (modified) (9 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -252 +252 @@
                                 std::cerr << "No reasonable alternatives for expression " << expr << std::endl;
                         )
-                        throw SemanticError( "No reasonable alternatives for expression ", expr );
+                        throw SemanticError( expr, "No reasonable alternatives for expression " );
                 }
                 if ( prune ) {
@@ -270 +270 @@
                                 stream << "Alternatives are:\n";
                                 printAlts( winners, stream, 1 );
-                                throw SemanticError( stream.str() );
+                                throw SemanticError( expr->location, stream.str() );
                         }
                         alternatives = move(pruned);
@@ -507 +507 @@
                                 return;
                         } else if ( level >= recursionLimit ) {
-                                throw SemanticError( "Too many recursive assertions" );
+                                throw SemanticError( newAlt.expr->location, "Too many recursive assertions" );
                         } else {
                                 AssertionSet newerNeed;
@@ -1421 +1421 @@
                         findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) );
                         if ( winners.size() != 1 ) {
-                                throw SemanticError( "Ambiguous expression in sizeof operand: ", sizeofExpr->get_expr() );
+                                throw SemanticError( sizeofExpr->get_expr(), "Ambiguous expression in sizeof operand: " );
                         } // if
                         // return the lowest cost alternative for the argument
@@ -1442 +1442 @@
                         findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) );
                         if ( winners.size() != 1 ) {
-                                throw SemanticError( "Ambiguous expression in alignof operand: ", alignofExpr->get_expr() );
+                                throw SemanticError( alignofExpr->get_expr(), "Ambiguous expression in alignof operand: " );
                         } // if
                         // return the lowest cost alternative for the argument

src/ResolvExpr/CurrentObject.cc

@@ -141 +141 @@
                         base = at->get_base();
                         memberIter = createMemberIterator( base );
-                        if ( at->isVarLen ) throw SemanticError( "VLA initialization does not support @=", at );
+                        if ( at->isVarLen ) throw SemanticError( at, "VLA initialization does not support @=" );
                         setSize( at->get_dimension() );
                 }
@@ -156 +156 @@
                                         PRINT( std::cerr << "array type with size: " << size << std::endl; )
                                 } catch ( SemanticError & ) {
-                                        throw SemanticError( "Constant expression of non-integral type in array dimension: ", expr );
+                                        throw SemanticError( expr, "Constant expression of non-integral type in array dimension: " );
                                 }
                         }       else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
@@ -179 +179 @@
                                         index = constExpr->intValue();
                                 } catch( SemanticError & ) {
-                                        throw SemanticError( "Constant expression of non-integral type in array designator: ", expr );
+                                        throw SemanticError( expr, "Constant expression of non-integral type in array designator: " );
                                 }
                         } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
@@ -532 +532 @@
                 } // for
                 if ( desigAlts.size() > 1 ) {
-                        throw SemanticError( toString("Too many alternatives (", desigAlts.size(), ") for designation: "), designation );
+                        throw SemanticError( designation, toString("Too many alternatives (", desigAlts.size(), ") for designation: ") );
                 } else if ( desigAlts.size() == 0 ) {
-                        throw SemanticError( "No reasonable alternatives for designation: ", designation );
+                        throw SemanticError( designation, "No reasonable alternatives for designation: " );
                 }
                 DesignatorChain & d = desigAlts.back();

src/ResolvExpr/Resolver.cc

@@ -188 +188 @@
                         findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
                         if ( winners.size() == 0 ) {
-                                throw SemanticError( "No reasonable alternatives for " + kindStr + " expression: ", untyped );
+                                throw SemanticError( untyped, "No reasonable alternatives for " + kindStr + " expression: " );
                         } else if ( winners.size() != 1 ) {
                                 std::ostringstream stream;
@@ -195 +195 @@
                                 stream << "Alternatives are:\n";
                                 printAlts( winners, stream, 1 );
-                                throw SemanticError( stream.str() );
+                                throw SemanticError( untyped->location, stream.str() );
                         }
 
@@ -429 +429 @@
                                 ss << strict_dynamic_cast<NameExpr*>( clause.target.function )->name;
                                 ss << "' in call to waitfor";
-                                throw SemanticError( ss.str() );
+                                throw SemanticError( stmt->location, ss.str() );
                         }
 
@@ -451 +451 @@
                                         PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() );
                                         if( !pointer ) {
-                                                throw SemanticError( "candidate not viable: not a pointer type\n", func.expr->get_result() );
+                                                throw SemanticError( func.expr->get_result(), "candidate not viable: not a pointer type\n" );
                                         }
 
                                         FunctionType * function = dynamic_cast< FunctionType* >( pointer->get_base() );
                                         if( !function ) {
-                                                throw SemanticError( "candidate not viable: not a function type\n", pointer->get_base() );
+                                                throw SemanticError( pointer->get_base(), "candidate not viable: not a function type\n" );
                                         }
 
@@ -465 +465 @@
 
                                                 if( !advance_to_mutex( param, param_end ) ) {
-                                                        throw SemanticError("candidate function not viable: no mutex parameters\n", function);
+                                                        throw SemanticError(function, "candidate function not viable: no mutex parameters\n");
                                                 }
                                         }
@@ -504 +504 @@
                                                                         // We ran out of parameters but still have arguments
                                                                         // this function doesn't match
-                                                                        throw SemanticError("candidate function not viable: too many mutex arguments\n", function);
+                                                                        throw SemanticError( function, "candidate function not viable: too many mutex arguments\n" );
                                                                 }
 
@@ -516 +516 @@
                                                                         (*param)->get_type()->print( ss );
                                                                         ss << "'\n";
-                                                                        throw SemanticError(ss.str(), function);
+                                                                        throw SemanticError( function, ss.str() );
                                                                 }
 
@@ -528 +528 @@
                                                                 // We ran out of arguments but still have parameters left
                                                                 // this function doesn't match
-                                                                throw SemanticError("candidate function not viable: too few mutex arguments\n", function);
+                                                                throw SemanticError( function, "candidate function not viable: too few mutex arguments\n" );
                                                         }
 
@@ -555 +555 @@
 
                         // Make sure we got the right number of arguments
-                        if( func_candidates.empty() )    { SemanticError top( "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
-                        if( args_candidates.empty() )    { SemanticError top( "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
-                        if( func_candidates.size() > 1 ) { SemanticError top( "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
-                        if( args_candidates.size() > 1 ) { SemanticError top( "Ambiguous arguments in call to waitfor"           ); top.append( errors ); throw top; }
+                        if( func_candidates.empty() )    { SemanticError top( stmt->location, "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
+                        if( args_candidates.empty() )    { SemanticError top( stmt->location, "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
+                        if( func_candidates.size() > 1 ) { SemanticError top( stmt->location, "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
+                        if( args_candidates.size() > 1 ) { SemanticError top( stmt->location, "Ambiguous arguments in call to waitfor"           ); top.append( errors ); throw top; }