Changeset d55d7a6

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

Files:

• CodeGen/FixMain.cc (modified) (1 diff)
• CodeGen/FixNames.cc (modified) (1 diff)
• Common/PassVisitor.impl.h (modified) (5 diffs)
• Common/SemanticError.cc (modified) (3 diffs)
• Common/SemanticError.h (modified) (3 diffs)
• Concurrency/Keywords.cc (modified) (6 diffs)
• Concurrency/Waitfor.cc (modified) (1 diff)
• ControlStruct/ExceptTranslate.cc (modified) (1 diff)
• ControlStruct/LabelFixer.cc (modified) (2 diffs)
• ControlStruct/MLEMutator.cc (modified) (2 diffs)
• GenPoly/Box.cc (modified) (3 diffs)
• InitTweak/FixInit.cc (modified) (3 diffs)
• InitTweak/GenInit.cc (modified) (1 diff)
• InitTweak/InitTweak.cc (modified) (1 diff)
• Parser/DeclarationNode.cc (modified) (8 diffs)
• Parser/ExpressionNode.cc (modified) (2 diffs)
• Parser/LinkageSpec.cc (modified) (3 diffs)
• Parser/LinkageSpec.h (modified) (2 diffs)
• Parser/ParseNode.h (modified) (1 diff)
• Parser/TypeData.cc (modified) (3 diffs)
• Parser/parser.yy (modified) (4 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (5 diffs)
• ResolvExpr/CurrentObject.cc (modified) (4 diffs)
• ResolvExpr/Resolver.cc (modified) (9 diffs)
• SymTab/Indexer.cc (modified) (5 diffs)
• SymTab/Validate.cc (modified) (12 diffs)
• SynTree/Expression.cc (modified) (1 diff)
• SynTree/Mutator.h (modified) (1 diff)
• SynTree/Statement.cc (modified) (3 diffs)
• SynTree/TypeSubstitution.h (modified) (1 diff)
• SynTree/Visitor.h (modified) (1 diff)
• main.cc (modified) (1 diff)

src/CodeGen/FixMain.cc

@@ -39 +39 @@
         {
                 if(main_signature) {
-                        throw SemanticError("Multiple definition of main routine\n", functionDecl);
+                        throw SemanticError(functionDecl, "Multiple definition of main routine\n");
                 }
                 main_signature.reset( functionDecl->clone() );

src/CodeGen/FixNames.cc

@@ -118 +118 @@
                         int nargs = functionDecl->get_functionType()->get_parameters().size();
                         if( !(nargs == 0 || nargs == 2 || nargs == 3) ) {
-                                throw SemanticError("Main expected to have 0, 2 or 3 arguments\n", functionDecl);
+                                throw SemanticError(functionDecl, "Main expected to have 0, 2 or 3 arguments\n");
                         }
                         functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( new ConstantExpr( Constant::from_int( 0 ) ) ) );

src/Common/PassVisitor.impl.h

@@ -77 +77 @@
                         maybeAccept_impl( *i, visitor );
                 } catch( SemanticError &e ) {
-                        e.set_location( (*i)->location );
                         errors.append( e );
                 }
@@ -104 +103 @@
                         maybeMutate_impl( *i, mutator );
                 } catch( SemanticError &e ) {
-                        e.set_location( (*i)->location );
                         errors.append( e );
                 }
@@ -134 +132 @@
                         }
                 } catch( SemanticError &e ) {
-                        e.set_location( (*i)->location );
                         errors.append( e );
                 }
@@ -163 +160 @@
                         } // if
                 } catch( SemanticError &e ) {
-                        e.set_location( (*i)->location );
                         errors.append( e );
                 } // try
@@ -200 +196 @@
 
                 } catch ( SemanticError &e ) {
-                        e.set_location( (*i)->location );
                         errors.append( e );
                 }

src/Common/SemanticError.cc

@@ -23 +23 @@
 #include "SemanticError.h"
 
-SemanticError::SemanticError() {
-}
-
-SemanticError::SemanticError( std::string error ) {
-        append( error );
+SemanticError::SemanticError( CodeLocation location, std::string error ) {
+        append( location, error );
 }
 
@@ -34 +31 @@
 }
 
-void SemanticError::append( const std::string & msg ) {
-        errors.emplace_back( error_str() + msg );
+void SemanticError::append( CodeLocation location, const std::string & msg ) {
+        errors.emplace_back( location, msg );
 }
 
@@ -42 +39 @@
 }
 
-void SemanticError::print( std::ostream &os ) {
+void SemanticError::print() {
         using std::to_string;
         for( auto err : errors ) {
-                os << err.location << err.description << std::endl;
+                std::cerr << bold() << err.location << error_str() << reset_font() << err.description << std::endl;
         }
 }
 
-void SemanticError::set_location( const CodeLocation& location ) {
-        errors.begin()->maybeSet( location );
+SemanticWarning::SemanticWarning( CodeLocation location, std::string msg ) {
+        std::cerr << bold() << location << warning_str() << reset_font() << msg << std::endl;
 }
 

src/Common/SemanticError.h

@@ -24 +24 @@
 #include "CodeLocation.h"                                                               // for CodeLocation, toString
 
+//-----------------------------------------------------------------------------
+// Errors
 struct error {
+        CodeLocation location;
         std::string description;
-        CodeLocation location;
 
         error() = default;
-        error( const std::string & str ) : description( str ) {}
-
-        void maybeSet( const CodeLocation & location ) {
-                if( this->location.isUnset() ) {
-                        this->location = location;
-                }
-        }
+        error( CodeLocation loc, const std::string & str ) : location( loc ), description( str ) {}
 };
 
 class SemanticError : public std::exception {
   public:
-        SemanticError();
-        SemanticError( std::string error );
-        template< typename T > SemanticError( const std::string & error, const T * obj );
+        SemanticError() = default;
+        SemanticError( CodeLocation location, std::string error );
         ~SemanticError() throw() {}
+
+        // constructs an exception using the given message and the printed representation of the obj (T must have a print method)
+        template< typename T > SemanticError(const T * obj, const std::string & error);
+        template< typename T > SemanticError( CodeLocation location, const T * obj, const std::string & error);
 
         static inline const std::string & error_str() {
@@ -51 +50 @@
 
         void append( SemanticError & other );
-        void append( const std::string & );
+        void append( CodeLocation location, const std::string & );
         bool isEmpty() const;
-        void print( std::ostream & os );
-
-        void set_location( const CodeLocation & location );
-        // constructs an exception using the given message and the printed representation of the obj (T must have a print
-        // method)
+        void print();
   private:
         std::list< error > errors;
@@ -63 +58 @@
 
 template< typename T >
-SemanticError::SemanticError( const std::string & error, const T * obj ) {
-        append( toString( error, obj ) );
+SemanticError::SemanticError( const T * obj, const std::string & error )
+        : SemanticError( obj->location, toString( error, obj ) )
+{}
+
+template< typename T >
+SemanticError::SemanticError( CodeLocation location, const T * obj, const std::string & error )
+        : SemanticError( location, toString( error, obj ) )
+{}
+
+//-----------------------------------------------------------------------------
+// Warnings
+class SemanticWarning {
+  public:
+        SemanticWarning( CodeLocation location, std::string error );
+        ~SemanticWarning() throw() {}
+
+        // constructs an exception using the given message and the printed representation of the obj (T must have a print method)
+        template< typename T > SemanticWarning(const T * obj, const std::string & error);
+        template< typename T > SemanticWarning( CodeLocation location, const T * obj, const std::string & error);
+
+        static inline const std::string & warning_str() {
+                static std::string str = isatty( STDERR_FILENO ) ? "\e[95mwarning:\e[39m " : "warning: ";
+                return str;
+        }
+
+  private:
+};
+
+template< typename T >
+SemanticWarning::SemanticWarning( const T * obj, const std::string & error )
+        : SemanticWarning( obj->location, toString( error, obj ) )
+{}
+
+template< typename T >
+SemanticWarning::SemanticWarning( CodeLocation location, const T * obj, const std::string & error )
+        : SemanticWarning( location, toString( error, obj ) )
+{}
+
+//-----------------------------------------------------------------------------
+// Helpers
+static inline const std::string & bold_ttycode() {
+        static std::string str = isatty( STDERR_FILENO ) ? "\e[1m" : "";
+        return str;
+}
+
+static inline const std::string & reset_font_ttycode() {
+        static std::string str = isatty( STDERR_FILENO ) ? "\e[0m" : "";
+        return str;
+}
+
+static inline std::string make_bold( const std::string & str ) {
+        return bold_ttycode() + str + reset_font_ttycode();
+}
+
+struct bold {};
+static inline std::ostream & operator<<(std::ostream & os, bold) {
+        os << bold_ttycode();
+        return os;
+}
+
+struct reset_font {};
+static inline std::ostream & operator<<(std::ostream & os, reset_font) {
+        os << reset_font_ttycode();
+        return os;
 }
 

src/Concurrency/Keywords.cc

@@ -276 +276 @@
                         handle( decl );
                 }
-
         }
 
@@ -282 +281 @@
                 if( ! decl->body ) return;
 
-                if( !type_decl ) throw SemanticError( context_error, decl );
+                if( !type_decl ) throw SemanticError( decl, context_error );
 
                 FunctionDecl * func = forwardDeclare( decl );
@@ -419 +418 @@
                 if( mutexArgs.empty() ) return;
 
-                if( CodeGen::isConstructor(decl->name) ) throw SemanticError( "constructors cannot have mutex parameters", decl );
+                if( CodeGen::isConstructor(decl->name) ) throw SemanticError( decl, "constructors cannot have mutex parameters" );
 
                 bool isDtor = CodeGen::isDestructor( decl->name );
 
-                if( isDtor && mutexArgs.size() != 1 ) throw SemanticError( "destructors can only have 1 mutex argument", decl );
+                if( isDtor && mutexArgs.size() != 1 ) throw SemanticError( decl, "destructors can only have 1 mutex argument" );
 
                 for(auto arg : mutexArgs) {
@@ -432 +431 @@
                 if( ! body ) return;
 
-                if( !monitor_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
-                if( !guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
-                if( !dtor_guard_decl ) throw SemanticError( "mutex keyword requires monitors to be in scope, add #include <monitor>", decl );
+                if( !monitor_decl ) throw SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor>" );
+                if( !guard_decl ) throw SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor>" );
+                if( !dtor_guard_decl ) throw SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor>" );
 
                 if( isDtor ) {
@@ -480 +479 @@
                 //Makes sure it's not a copy
                 ReferenceType* rty = dynamic_cast< ReferenceType * >( ty );
-                if( ! rty ) throw SemanticError( "Mutex argument must be of reference type ", arg );
+                if( ! rty ) throw SemanticError( arg, "Mutex argument must be of reference type " );
 
                 //Make sure the we are pointing directly to a type
                 Type* base = rty->get_base();
-                if( dynamic_cast< ReferenceType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
-                if( dynamic_cast< PointerType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
+                if( dynamic_cast< ReferenceType * >( base ) ) throw SemanticError( arg, "Mutex argument have exactly one level of indirection " );
+                if( dynamic_cast< PointerType * >( base ) ) throw SemanticError( arg, "Mutex argument have exactly one level of indirection " );
 
                 //Make sure that typed isn't mutex
-                if( base->get_mutex() ) throw SemanticError( "mutex keyword may only appear once per argument ", arg );
+                if( base->get_mutex() ) throw SemanticError( arg, "mutex keyword may only appear once per argument " );
         }
 
@@ -626 +625 @@
                 if( type && type->get_baseStruct()->is_thread() ) {
                         if( !thread_decl || !thread_ctor_seen ) {
-                                throw SemanticError("thread keyword requires threads to be in scope, add #include <thread>");
+                                throw SemanticError( type->get_baseStruct()->location, "thread keyword requires threads to be in scope, add #include <thread>");
                         }
 

src/Concurrency/Waitfor.cc

@@ -249 +249 @@
 
         Statement * GenerateWaitForPass::postmutate( WaitForStmt * waitfor ) {
-                if( !decl_monitor || !decl_acceptable || !decl_mask ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include <monitor>", waitfor );
+                if( !decl_monitor || !decl_acceptable || !decl_mask )
+                        throw SemanticError( waitfor, "waitfor keyword requires monitors to be in scope, add #include <monitor>" );
 
                 CompoundStmt * stmt = new CompoundStmt();

src/ControlStruct/ExceptTranslate.cc

@@ -572 +572 @@
                         // Pass.
                 } else if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
-                        throw SemanticError("catch must have exception type");
+                        throw SemanticError(catchStmt->location, "catch must have exception type");
                 } else {
-                        throw SemanticError("catchResume must have exception type");
+                        throw SemanticError(catchStmt->location, "catchResume must have exception type");
                 }
 

src/ControlStruct/LabelFixer.cc

@@ -92 +92 @@
                         } else if ( labelTable[ l ]->defined() ) {
                                 // defined twice, error
-                                throw SemanticError( "Duplicate definition of label: " + l.get_name() );
+                                throw SemanticError( l.get_statement()->location, "Duplicate definition of label: " + l.get_name() );
                         }       else {
                                 // used previously, but undefined until now -> link with this entry
@@ -121 +121 @@
                 for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
                         if ( ! i->second->defined() ) {
-                                throw SemanticError( "Use of undefined label: " + i->first.get_name() );
+                                throw SemanticError( i->first.get_statement()->location, "Use of undefined label: " + i->first.get_name() );
                         }
                         (*ret)[ i->first ] = i->second->get_definition();

src/ControlStruct/MLEMutator.cc

@@ -115 +115 @@
                                         } else {
                                                 // break target is outmost control structure
-                                                if ( enclosingControlStructures.empty() ) throw SemanticError( "'break' outside a loop, switch, or labelled block" );
+                                                if ( enclosingControlStructures.empty() ) throw SemanticError( branchStmt->location, "'break' outside a loop, switch, or labelled block" );
                                                 targetEntry = enclosingControlStructures.rbegin();
                                         } // if
@@ -124 +124 @@
                                 // ensure that selected target is valid
                                 if ( targetEntry == enclosingControlStructures.rend() || (isContinue && ! isLoop( targetEntry->get_controlStructure() ) ) ) {
-                                        throw SemanticError( toString( (isContinue ? "'continue'" : "'break'"), " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "), originalTarget ) );
+                                        throw SemanticError( branchStmt->location, toString( (isContinue ? "'continue'" : "'break'"), " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "), originalTarget ) );
                                 } // if
                                 break;

src/GenPoly/Box.cc

@@ -229 +229 @@
                                 } // if
                         } catch( SemanticError &e ) {
-                                e.set_location( (*i)->location );
                                 errors.append( e );
                         } // try
@@ -576 +575 @@
                                                 }
                                         } else {
-                                                throw SemanticError( "Cannot pass non-struct type for generic struct: ", argBaseType );
+                                                throw SemanticError( argBaseType, "Cannot pass non-struct type for generic struct: " );
                                         }
                                 }
@@ -598 +597 @@
                                         } else {
                                                 // xxx - should this be an assertion?
-                                                throw SemanticError( toString( *env, "\nunbound type variable: ", tyParm->first, " in application " ), appExpr );
+                                                throw SemanticError( appExpr, toString( *env, "\nunbound type variable: ", tyParm->first, " in application " ) );
                                         } // if
                                 } // if

src/InitTweak/FixInit.cc

@@ -282 +282 @@
                                         translationUnit.splice( i, fixer.pass.staticDtorDecls );
                                 } catch( SemanticError &e ) {
-                                        e.set_location( (*i)->location );
                                         errors.append( e );
                                 } // try
@@ -895 +894 @@
                         )
                         if ( ! diff.empty() ) {
-                                throw SemanticError( std::string("jump to label '") + stmt->get_target().get_name() + "' crosses initialization of " + (*diff.begin())->get_name() + " ", stmt );
+                                throw SemanticError( stmt, std::string("jump to label '") + stmt->get_target().get_name() + "' crosses initialization of " + (*diff.begin())->get_name() + " " );
                         } // if
                         // S_G-S_L results in set of objects that must be destructed
@@ -1111 +1110 @@
                 template< typename Visitor, typename... Params >
                 void error( Visitor & v, CodeLocation loc, const Params &... params ) {
-                        SemanticError err( toString( params... ) );
-                        err.set_location( loc );
+                        SemanticError err( loc, toString( params... ) );
                         v.errors.append( err );
                 }

src/InitTweak/GenInit.cc

@@ -317 +317 @@
                 if ( tryConstruct( objDecl ) && ( managedTypes.isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) {
                         // constructed objects cannot be designated
-                        if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n", objDecl );
+                        if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( objDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
                         // constructed objects should not have initializers nested too deeply
-                        if ( ! checkInitDepth( objDecl ) ) throw SemanticError( "Managed object's initializer is too deep ", objDecl );
+                        if ( ! checkInitDepth( objDecl ) ) throw SemanticError( objDecl, "Managed object's initializer is too deep " );
 
                         objDecl->set_init( genCtorInit( objDecl ) );

src/InitTweak/InitTweak.cc

@@ -225 +225 @@
                                         // xxx - this shouldn't be an error, but need a way to
                                         // terminate without creating output, so should catch this error
-                                        throw SemanticError( "unbalanced list initializers" );
+                                        throw SemanticError( init->location, "unbalanced list initializers" );
                                 }
 

src/Parser/DeclarationNode.cc

@@ -581 +581 @@
                                         dst->basictype = src->basictype;
                                 } else if ( src->basictype != DeclarationNode::NoBasicType )
-                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: ", src );
+                                        throw SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: " );
 
                                 if ( dst->complextype == DeclarationNode::NoComplexType ) {
                                         dst->complextype = src->complextype;
                                 } else if ( src->complextype != DeclarationNode::NoComplexType )
-                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: ", src );
+                                        throw SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: " );
 
                                 if ( dst->signedness == DeclarationNode::NoSignedness ) {
                                         dst->signedness = src->signedness;
                                 } else if ( src->signedness != DeclarationNode::NoSignedness )
-                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: ", src );
+                                        throw SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: " );
 
                                 if ( dst->length == DeclarationNode::NoLength ) {
@@ -598 +598 @@
                                         dst->length = DeclarationNode::LongLong;
                                 } else if ( src->length != DeclarationNode::NoLength )
-                                        throw SemanticError( string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: ", src );
+                                        throw SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: " );
                         } // if
                         break;
@@ -966 +966 @@
                         } // if
                 } catch( SemanticError &e ) {
-                        e.set_location( cur->location );
                         errors.append( e );
                 } // try
@@ -1001 +1000 @@
                         } // if
                 } catch( SemanticError &e ) {
-                        e.set_location( cur->location );
                         errors.append( e );
                 } // try
@@ -1020 +1018 @@
                         * out++ = cur->buildType();
                 } catch( SemanticError &e ) {
-                        e.set_location( cur->location );
                         errors.append( e );
                 } // try
@@ -1032 +1029 @@
 
 Declaration * DeclarationNode::build() const {
-        if ( ! error.empty() ) throw SemanticError( error + " in declaration of ", this );
+        if ( ! error.empty() ) throw SemanticError( this, error + " in declaration of " );
 
         if ( asmStmt ) {
@@ -1055 +1052 @@
                 //    inline _Noreturn int i;                   // disallowed
                 if ( type->kind != TypeData::Function && funcSpecs.any() ) {
-                        throw SemanticError( "invalid function specifier for ", this );
+                        throw SemanticError( this, "invalid function specifier for " );
                 } // if
                 return buildDecl( type, name ? *name : string( "" ), storageClasses, maybeBuild< Expression >( bitfieldWidth ), funcSpecs, linkage, asmName, maybeBuild< Initializer >(initializer), attributes )->set_extension( extension );
@@ -1065 +1062 @@
         //    inlne _Noreturn enum   E { ... };         // disallowed
         if ( funcSpecs.any() ) {
-                throw SemanticError( "invalid function specifier for ", this );
+                throw SemanticError( this, "invalid function specifier for " );
         } // if
         assertf( name, "ObjectDecl must a have name\n" );

src/Parser/ExpressionNode.cc

@@ -356 +356 @@
 
 Expression * build_field_name_FLOATING_FRACTIONconstant( const string & str ) {
-        if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( "invalid tuple index " + str );
+        if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) throw SemanticError( yylloc, "invalid tuple index " + str );
         Expression * ret = build_constantInteger( *new string( str.substr(1) ) );
         delete &str;
@@ -363 +363 @@
 
 Expression * build_field_name_FLOATING_DECIMALconstant( const string & str ) {
-        if ( str[str.size()-1] != '.' ) throw SemanticError( "invalid tuple index " + str );
+        if ( str[str.size()-1] != '.' ) throw SemanticError( yylloc, "invalid tuple index " + str );
         Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
         delete &str;

src/Parser/LinkageSpec.cc

@@ -24 +24 @@
 namespace LinkageSpec {
 
-Spec linkageCheck( const string * spec ) {
+Spec linkageCheck( CodeLocation location, const string * spec ) {
         assert( spec );
         unique_ptr<const string> guard( spec ); // allocated by lexer
@@ -34 +34 @@
                 return BuiltinC;
         } else {
-                throw SemanticError( "Invalid linkage specifier " + *spec );
+                throw SemanticError( location, "Invalid linkage specifier " + *spec );
         } // if
 }
 
-Spec linkageUpdate( Spec old_spec, const string * cmd ) {
+Spec linkageUpdate( CodeLocation location, Spec old_spec, const string * cmd ) {
         assert( cmd );
         unique_ptr<const string> guard( cmd ); // allocated by lexer
@@ -48 +48 @@
                 return old_spec;
         } else {
-                throw SemanticError( "Invalid linkage specifier " + *cmd );
+                throw SemanticError( location, "Invalid linkage specifier " + *cmd );
         } // if
 }

src/Parser/LinkageSpec.h

@@ -17 +17 @@
 
 #include <string>
+
+#include "Common/CodeLocation.h"
 
 namespace LinkageSpec {
@@ -45 +47 @@
 
 
-        Spec linkageCheck( const std::string * );
+        Spec linkageCheck( CodeLocation location, const std::string * );
         // Returns the Spec with the given name (limited to C, Cforall & BuiltinC)
-        Spec linkageUpdate( Spec old_spec, const std::string * cmd );
+        Spec linkageUpdate( CodeLocation location, Spec old_spec, const std::string * cmd );
         /* If cmd = "C" returns a Spec that is old_spec with is_mangled = false
          * If cmd = "Cforall" returns old_spec Spec with is_mangled = true

src/Parser/ParseNode.h

@@ -434 +434 @@
                         } // if
                 } catch( SemanticError &e ) {
-                        e.set_location( cur->location );
                         errors.append( e );
                 } // try

src/Parser/TypeData.cc

@@ -521 +521 @@
 
 static string genTSError( string msg, DeclarationNode::BasicType basictype ) {
-        throw SemanticError( string( "invalid type specifier \"" ) + msg + "\" for type \"" + DeclarationNode::basicTypeNames[basictype] + "\"." );
+        throw SemanticError( yylloc, string( "invalid type specifier \"" ) + msg + "\" for type \"" + DeclarationNode::basicTypeNames[basictype] + "\"." );
 } // genTSError
 
@@ -923 +923 @@
                                 // type set => parameter name already transformed by a declaration names so there is a duplicate
                                 // declaration name attempting a second transformation
-                                if ( param->type ) throw SemanticError( string( "duplicate declaration name " ) + *param->name );
+                                if ( param->type ) throw SemanticError( param->location, string( "duplicate declaration name " ) + *param->name );
                                 // declaration type reset => declaration already transformed by a parameter name so there is a duplicate
                                 // parameter name attempting a second transformation
-                                if ( ! decl->type ) throw SemanticError( string( "duplicate parameter name " ) + *param->name );
+                                if ( ! decl->type ) throw SemanticError( param->location, string( "duplicate parameter name " ) + *param->name );
                                 param->type = decl->type;                               // set copy declaration type to parameter type
                                 decl->type = nullptr;                                   // reset declaration type
@@ -933 +933 @@
                 } // for
                 // declaration type still set => type not moved to a matching parameter so there is a missing parameter name
-                if ( decl->type ) throw SemanticError( string( "missing name in parameter list " ) + *decl->name );
+                if ( decl->type ) throw SemanticError( decl->location, string( "missing name in parameter list " ) + *decl->name );
         } // for
 

src/Parser/parser.yy

@@ -482 +482 @@
                 { $$ = new ExpressionNode( new StmtExpr( dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >($2) ) ) ); }
         | type_name '.' no_attr_identifier                                      // CFA, nested type
-                { throw SemanticError("Qualified names are currently unimplemented."); $$ = nullptr; } // FIX ME
+                { throw SemanticError(yylloc, "Qualified names are currently unimplemented."); $$ = nullptr; } // FIX ME
         | type_name '.' '[' push field_list pop ']'                     // CFA, nested type / tuple field selector
-                { throw SemanticError("Qualified names are currently unimplemented."); $$ = nullptr; } // FIX ME
+                { throw SemanticError(yylloc, "Qualified names are currently unimplemented."); $$ = nullptr; } // FIX ME
         ;
 
@@ -1072 +1072 @@
 mutex_statement:
         MUTEX '(' argument_expression_list ')' statement
-                { throw SemanticError("Mutex statement is currently unimplemented."); $$ = nullptr; } // FIX ME
+                { throw SemanticError(yylloc, "Mutex statement is currently unimplemented."); $$ = nullptr; } // FIX ME
         ;
 
@@ -1293 +1293 @@
 static_assert:
         STATICASSERT '(' constant_expression ',' string_literal ')' ';' // C11
-                { throw SemanticError("Static assert is currently unimplemented."); $$ = nullptr; }     // FIX ME
+                { throw SemanticError(yylloc, "Static assert is currently unimplemented."); $$ = nullptr; }     // FIX ME
 
 // C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and function
@@ -2381 +2381 @@
                 {
                         linkageStack.push( linkage );                           // handle nested extern "C"/"Cforall"
-                        linkage = LinkageSpec::linkageUpdate( linkage, $2 );
+                        linkage = LinkageSpec::linkageUpdate( yylloc, linkage, $2 );
                 }
           '{' external_definition_list_opt '}'

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; }
 
 

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 " );
                 }
         }

src/SynTree/Expression.cc

@@ -93 +93 @@
                 return 0;
         }
-        throw SemanticError( "Constant expression of non-integral type ", this );
+        throw SemanticError( this, "Constant expression of non-integral type " );
 }
 

src/SynTree/Mutator.h

@@ -148 +148 @@
                         } // if
                 } catch( SemanticError &e ) {
-                        e.set_location( (*i)->location );
                         errors.append( e );
                 } // try

src/SynTree/Statement.cc

@@ -100 +100 @@
         //actually this is a syntactic error signaled by the parser
         if ( type == BranchStmt::Goto && target.empty() ) {
-                throw SemanticError("goto without target");
+                throw SemanticError( target.get_statement()->location, "goto without target");
         }
 }
@@ -107 +107 @@
         Statement(), computedTarget( computedTarget ), type( type ) {
         if ( type != BranchStmt::Goto || computedTarget == nullptr ) {
-                throw SemanticError("Computed target not valid in branch statement");
+                throw SemanticError( computedTarget->location, "Computed target not valid in branch statement");
         }
 }
@@ -203 +203 @@
 CaseStmt::CaseStmt( Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
         Statement(), condition( condition ), stmts( statements ), _isDefault( deflt ) {
-        if ( isDefault() && condition != 0 ) throw SemanticError("default case with condition: ", condition);
+        if ( isDefault() && condition != 0 ) throw SemanticError( condition, "default case with condition: " );
 }
 

src/SynTree/TypeSubstitution.h

@@ -98 +98 @@
                                 } // if
                         } else {
-                                throw SemanticError( toString( "Attempt to provide non-type parameter: ", toString( *actualIt ).c_str(), " for type parameter " ), formal );
+                                throw SemanticError( formal, toString( "Attempt to provide non-type parameter: ", toString( *actualIt ).c_str(), " for type parameter " ) );
                         } // if
                 } else {

src/SynTree/Visitor.h

@@ -142 +142 @@
                         }
                 } catch( SemanticError &e ) {
-                        e.set_location( (*i)->location );
                         errors.append( e );
                 }

src/main.cc

@@ -361 +361 @@
                         cerr << endl << "---End of AST, begin error message:---\n" << endl;
                 } // if
-                e.print( cerr );
+                e.print();
                 if ( output != &cout ) {
                         delete output;