Changeset a16764a6

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

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (1 diff)
• CodeGen/FixMain.cc (modified) (1 diff)
• CodeGen/FixNames.cc (modified) (1 diff)
• CodeTools/DeclStats.cc (modified) (1 diff)
• CodeTools/TrackLoc.cc (modified) (1 diff)
• Common/ErrorObjects.h (added)
• Common/PassVisitor.impl.h (modified) (10 diffs)
• Common/SemanticError.cc (modified) (1 diff)
• Common/SemanticError.h (modified) (1 diff)
• Concurrency/Keywords.cc (modified) (5 diffs)
• Concurrency/Waitfor.cc (modified) (1 diff)
• ControlStruct/ExceptTranslate.cc (modified) (1 diff)
• ControlStruct/LabelFixer.cc (modified) (2 diffs)
• ControlStruct/LabelFixer.h (modified) (1 diff)
• ControlStruct/MLEMutator.cc (modified) (3 diffs)
• ControlStruct/MLEMutator.h (modified) (1 diff)
• ControlStruct/Mutate.cc (modified) (1 diff)
• GenPoly/Box.cc (modified) (4 diffs)
• GenPoly/FindFunction.cc (modified) (1 diff)
• GenPoly/InstantiateGeneric.cc (modified) (1 diff)
• GenPoly/Lvalue.cc (modified) (1 diff)
• GenPoly/Specialize.cc (modified) (1 diff)
• InitTweak/FixGlobalInit.cc (modified) (1 diff)
• InitTweak/FixInit.cc (modified) (6 diffs)
• InitTweak/GenInit.cc (modified) (1 diff)
• InitTweak/InitTweak.cc (modified) (1 diff)
• Parser/DeclarationNode.cc (modified) (11 diffs)
• Parser/ExpressionNode.cc (modified) (2 diffs)
• Parser/LinkageSpec.cc (modified) (2 diffs)
• Parser/ParseNode.h (modified) (2 diffs)
• Parser/TypeData.cc (modified) (3 diffs)
• Parser/lex.ll (modified) (1 diff)
• Parser/parser.yy (modified) (6 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (8 diffs)
• ResolvExpr/CurrentObject.cc (modified) (4 diffs)
• ResolvExpr/Resolver.cc (modified) (11 diffs)
• SymTab/Autogen.cc (modified) (1 diff)
• SymTab/Indexer.cc (modified) (4 diffs)
• SymTab/Validate.cc (modified) (11 diffs)
• SynTree/Expression.cc (modified) (1 diff)
• SynTree/Mutator.h (modified) (2 diffs)
• SynTree/Statement.cc (modified) (2 diffs)
• SynTree/Statement.h (modified) (2 diffs)
• SynTree/TypeSubstitution.h (modified) (1 diff)
• SynTree/Visitor.h (modified) (2 diffs)
• main.cc (modified) (1 diff)

src/CodeGen/CodeGenerator.cc

@@ -18 +18 @@
 #include <list>                      // for _List_iterator, list, list<>::it...
 
-#include "Common/SemanticError.h"    // for SemanticError
 #include "Common/UniqueName.h"       // for UniqueName
 #include "Common/utility.h"          // for CodeLocation, toString

src/CodeGen/FixMain.cc

@@ -39 +39 @@
         {
                 if(main_signature) {
-                        throw SemanticError(functionDecl, "Multiple definition of main routine\n");
+                        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(functionDecl, "Main expected to have 0, 2 or 3 arguments\n");
+                                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/CodeTools/DeclStats.cc

@@ -24 +24 @@
 
 #include "Common/PassVisitor.h"
-#include "Common/SemanticError.h"  // for SemanticError
 #include "Common/VectorMap.h"      // for VectorMap
 #include "GenPoly/GenPoly.h"       // for hasPolyBase

src/CodeTools/TrackLoc.cc

@@ -24 +24 @@
 
 #include "Common/PassVisitor.h"      // for PassVisitor
-#include "Common/SemanticError.h"    // for SemanticError
 #include "Common/utility.h"          // for CodeLocation
 #include "SynTree/BaseSyntaxNode.h"  // for BaseSyntaxNode

src/Common/PassVisitor.impl.h

@@ -65 +65 @@
         DeclList_t* beforeDecls = visitor.get_beforeDecls();
         DeclList_t* afterDecls  = visitor.get_afterDecls();
-        SemanticError errors;
+        SemanticErrorException errors;
 
         for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
@@ -76 +76 @@
                         // run visitor on declaration
                         maybeAccept_impl( *i, visitor );
-                } catch( SemanticError &e ) {
+                } catch( SemanticErrorException &e ) {
                         errors.append( e );
                 }
@@ -92 +92 @@
         DeclList_t* beforeDecls = mutator.get_beforeDecls();
         DeclList_t* afterDecls  = mutator.get_afterDecls();
-        SemanticError errors;
+        SemanticErrorException errors;
 
         for ( std::list< Declaration* >::iterator i = decls.begin(); ; ++i ) {
@@ -102 +102 @@
                         // run mutator on declaration
                         maybeMutate_impl( *i, mutator );
-                } catch( SemanticError &e ) {
+                } catch( SemanticErrorException &e ) {
                         errors.append( e );
                 }
@@ -125 +125 @@
 inline void maybeAccept_impl( Container & container, PassVisitor< pass_type > & visitor ) {
         if ( ! visitor.get_visit_children() ) return;
-        SemanticError errors;
+        SemanticErrorException errors;
         for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
                 try {
@@ -131 +131 @@
                                 (*i)->accept( visitor );
                         }
-                } catch( SemanticError &e ) {
+                } catch( SemanticErrorException &e ) {
                         errors.append( e );
                 }
@@ -152 +152 @@
 inline void maybeMutate_impl( Container & container, PassVisitor< pass_type > & mutator ) {
         if ( ! mutator.get_visit_children() ) return;
-        SemanticError errors;
+        SemanticErrorException errors;
         for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
                 try {
@@ -159 +159 @@
                                 assert( *i );
                         } // if
-                } catch( SemanticError &e ) {
+                } catch( SemanticErrorException &e ) {
                         errors.append( e );
                 } // try
@@ -172 +172 @@
 void PassVisitor< pass_type >::handleStatementList( std::list< Statement * > & statements, func_t func ) {
         if ( ! get_visit_children() ) return;
-        SemanticError errors;
+        SemanticErrorException errors;
 
         // don't want statements from outer CompoundStmts to be added to this CompoundStmt
@@ -195 +195 @@
                             || ( empty( beforeDecls ) && empty( afterDecls )) );
 
-                } catch ( SemanticError &e ) {
+                } catch ( SemanticErrorException &e ) {
                         errors.append( e );
                 }

src/Common/SemanticError.cc

@@ -23 +23 @@
 #include "SemanticError.h"
 
-SemanticError::SemanticError( CodeLocation location, std::string error ) {
+SemanticErrorException::SemanticErrorException( CodeLocation location, std::string error ) {
         append( location, error );
 }
 
-void SemanticError::append( SemanticError &other ) {
+void SemanticErrorException::append( SemanticErrorException &other ) {
         errors.splice( errors.end(), other.errors );
 }
 
-void SemanticError::append( CodeLocation location, const std::string & msg ) {
+void SemanticErrorException::append( CodeLocation location, const std::string & msg ) {
         errors.emplace_back( location, msg );
 }
 
-bool SemanticError::isEmpty() const {
+bool SemanticErrorException::isEmpty() const {
         return errors.empty();
 }
 
-void SemanticError::print() {
+void SemanticErrorException::print() {
         using std::to_string;
         for( auto err : errors ) {
-                std::cerr << bold() << err.location << error_str() << reset_font() << err.description << std::endl;
+                std::cerr << ErrorHelpers::bold() << err.location << ErrorHelpers::error_str() << ErrorHelpers::reset_font() << err.description << std::endl;
         }
 }
 
-SemanticWarning::SemanticWarning( CodeLocation location, std::string msg ) {
-        std::cerr << bold() << location << warning_str() << reset_font() << msg << std::endl;
+void SemanticError( CodeLocation location, std::string error ) {
+        throw SemanticErrorException(location, error);
+}
+
+void SemanticWarningImpl( CodeLocation location, std::string msg ) {
+        std::cerr << ErrorHelpers::bold() << location << ErrorHelpers::warning_str() << ErrorHelpers::reset_font() << msg << std::endl;
+}
+
+//-----------------------------------------------------------------------------
+// Helpers
+namespace ErrorHelpers {
+        const std::string & error_str() {
+                static std::string str = isatty( STDERR_FILENO ) ? "\e[31merror:\e[39m " : "error: ";
+                return str;
+        }
+
+        const std::string & warning_str() {
+                static std::string str = isatty( STDERR_FILENO ) ? "\e[95mwarning:\e[39m " : "warning: ";
+                return str;
+        }
+
+        const std::string & bold_ttycode() {
+                static std::string str = isatty( STDERR_FILENO ) ? "\e[1m" : "";
+                return str;
+        }
+
+        const std::string & reset_font_ttycode() {
+                static std::string str = isatty( STDERR_FILENO ) ? "\e[0m" : "";
+                return str;
+        }
+
+        std::string make_bold( const std::string & str ) {
+                return bold_ttycode() + str + reset_font_ttycode();
+        }
+
+        std::ostream & operator<<(std::ostream & os, bold) {
+                os << bold_ttycode();
+                return os;
+        }
+
+        std::ostream & operator<<(std::ostream & os, reset_font) {
+                os << reset_font_ttycode();
+                return os;
+        }
 }
 

src/Common/SemanticError.h

@@ -16 +16 @@
 #pragma once
 
-#include <exception>                                                                    // for exception
-#include <iostream>                                                                             // for ostream
-#include <list>                                                                                 // for list
-#include <string>                                                                               // for string
-#include <unistd.h>                                                                             // for isatty
-
-#include "CodeLocation.h"                                                               // for CodeLocation, toString
+#include "ErrorObjects.h"
 
 //-----------------------------------------------------------------------------
 // Errors
-struct error {
-        CodeLocation location;
-        std::string description;
 
-        error() = default;
-        error( CodeLocation loc, const std::string & str ) : location( loc ), description( str ) {}
-};
-
-class SemanticError : public std::exception {
-  public:
-        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() {
-                static std::string str = isatty( STDERR_FILENO ) ? "\e[31merror:\e[39m " : "error: ";
-                return str;
-        }
-
-        void append( SemanticError & other );
-        void append( CodeLocation location, const std::string & );
-        bool isEmpty() const;
-        void print();
-  private:
-        std::list< error > errors;
-};
+__attribute__((noreturn)) void SemanticError( CodeLocation location, std::string error );
 
 template< typename T >
-SemanticError::SemanticError( const T * obj, const std::string & error )
-        : SemanticError( obj->location, toString( error, obj ) )
-{}
+__attribute__((noreturn)) static inline void 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 ) )
-{}
+__attribute__((noreturn)) static inline void 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);
+constexpr const char * const WarningFormats[] = {
 
-        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 ) )
-{}
+enum class Warning {
+        NUMBER_OF_WARNINGS, //This MUST be the last warning
+};
 
-template< typename T >
-SemanticWarning::SemanticWarning( CodeLocation location, const T * obj, const std::string & error )
-        : SemanticWarning( location, toString( error, obj ) )
-{}
+static_assert(
+        (sizeof(WarningFormats) / sizeof(WarningFormats[0])) == ((unsigned long)Warning::NUMBER_OF_WARNINGS),
+        "Each warning format should have a corresponding warning enum value"
+);
+
+#define SemanticWarning(loc, id, ...) SemanticWarningImpl(loc, id, WarningFormats[id], __VA_ARGS__)
+
+void SemanticWarningImpl (CodeLocation loc, Warning warn, const char * const fmt, ...) __attribute__((format(printf, 3, 4)));
+
 
 //-----------------------------------------------------------------------------
 // Helpers
-static inline const std::string & bold_ttycode() {
-        static std::string str = isatty( STDERR_FILENO ) ? "\e[1m" : "";
-        return str;
+namespace ErrorHelpers {
+        const std::string & error_str();
+        const std::string & warning_str();
+        const std::string & bold_ttycode();
+        const std::string & reset_font_ttycode();
+
+        std::string make_bold( const std::string & str );
+
+        struct bold {};
+        std::ostream & operator<<(std::ostream & os, bold);
+
+        struct reset_font {};
+        std::ostream & operator<<(std::ostream & os, reset_font);
 }
 
-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;
-}
 
 // Local Variables: //

src/Concurrency/Keywords.cc

@@ -280 +280 @@
                 if( ! decl->body ) return;
 
-                if( !type_decl ) throw SemanticError( decl, context_error );
+                if( !type_decl ) SemanticError( decl, context_error );
 
                 FunctionDecl * func = forwardDeclare( decl );
@@ -417 +417 @@
                 if( mutexArgs.empty() ) return;
 
-                if( CodeGen::isConstructor(decl->name) ) throw SemanticError( decl, "constructors cannot have mutex parameters" );
+                if( CodeGen::isConstructor(decl->name) ) SemanticError( decl, "constructors cannot have mutex parameters" );
 
                 bool isDtor = CodeGen::isDestructor( decl->name );
 
-                if( isDtor && mutexArgs.size() != 1 ) throw SemanticError( decl, "destructors can only have 1 mutex argument" );
+                if( isDtor && mutexArgs.size() != 1 ) SemanticError( decl, "destructors can only have 1 mutex argument" );
 
                 for(auto arg : mutexArgs) {
@@ -430 +430 @@
                 if( ! body ) return;
 
-                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( !monitor_decl || !guard_decl || !dtor_guard_decl )
+                        SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor>" );
 
                 if( isDtor ) {
@@ -478 +477 @@
                 //Makes sure it's not a copy
                 ReferenceType* rty = dynamic_cast< ReferenceType * >( ty );
-                if( ! rty ) throw SemanticError( arg, "Mutex argument must be of reference type " );
+                if( ! rty ) 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( 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 " );
+                if( dynamic_cast< ReferenceType * >( base ) ) SemanticError( arg, "Mutex argument have exactly one level of indirection " );
+                if( dynamic_cast< PointerType * >( base ) ) SemanticError( arg, "Mutex argument have exactly one level of indirection " );
 
                 //Make sure that typed isn't mutex
-                if( base->get_mutex() ) throw SemanticError( arg, "mutex keyword may only appear once per argument " );
+                if( base->get_mutex() ) SemanticError( arg, "mutex keyword may only appear once per argument " );
         }
 
@@ -624 +623 @@
                 if( type && type->get_baseStruct()->is_thread() ) {
                         if( !thread_decl || !thread_ctor_seen ) {
-                                throw SemanticError( type->get_baseStruct()->location, "thread keyword requires threads to be in scope, add #include <thread>");
+                                SemanticError( type->get_baseStruct()->location, "thread keyword requires threads to be in scope, add #include <thread>");
                         }
 

src/Concurrency/Waitfor.cc

@@ -250 +250 @@
         Statement * GenerateWaitForPass::postmutate( WaitForStmt * waitfor ) {
                 if( !decl_monitor || !decl_acceptable || !decl_mask )
-                        throw SemanticError( waitfor, "waitfor keyword requires monitors to be in scope, add #include <monitor>" );
+                        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(catchStmt->location, "catch must have exception type");
+                        SemanticError(catchStmt->location, "catch must have exception type");
                 } else {
-                        throw SemanticError(catchStmt->location, "catchResume must have exception type");
+                        SemanticError(catchStmt->location, "catchResume must have exception type");
                 }
 

src/ControlStruct/LabelFixer.cc

@@ -92 +92 @@
                         } else if ( labelTable[ l ]->defined() ) {
                                 // defined twice, error
-                                throw SemanticError( l.get_statement()->location, "Duplicate definition of label: " + l.get_name() );
+                                SemanticError( l.get_statement()->location, "Duplicate definition of label: " + l.get_name() );
                         }       else {
                                 // used previously, but undefined until now -> link with this entry
@@ -117 +117 @@
 
         // Builds a table that maps a label to its defining statement.
-        std::map<Label, Statement * > *LabelFixer::resolveJumps() throw ( SemanticError ) {
+        std::map<Label, Statement * > *LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
                 std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
                 for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
                         if ( ! i->second->defined() ) {
-                                throw SemanticError( i->first.get_statement()->location, "Use of undefined label: " + i->first.get_name() );
+                                SemanticError( i->first.get_statement()->location, "Use of undefined label: " + i->first.get_name() );
                         }
                         (*ret)[ i->first ] = i->second->get_definition();

src/ControlStruct/LabelFixer.h

@@ -33 +33 @@
                 LabelFixer( LabelGenerator *gen = 0 );
 
-                std::map < Label, Statement * > *resolveJumps() throw ( SemanticError );
+                std::map < Label, Statement * > *resolveJumps() throw ( SemanticErrorException );
 
                 // Declarations

src/ControlStruct/MLEMutator.cc

@@ -98 +98 @@
 
 
-        Statement *MLEMutator::postmutate( BranchStmt *branchStmt ) throw ( SemanticError ) {
+        Statement *MLEMutator::postmutate( BranchStmt *branchStmt ) throw ( SemanticErrorException ) {
                 std::string originalTarget = branchStmt->originalTarget;
 
@@ -115 +115 @@
                                         } else {
                                                 // break target is outmost control structure
-                                                if ( enclosingControlStructures.empty() ) throw SemanticError( branchStmt->location, "'break' outside a loop, switch, or labelled block" );
+                                                if ( enclosingControlStructures.empty() ) 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( branchStmt->location, toString( (isContinue ? "'continue'" : "'break'"), " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "), originalTarget ) );
+                                        SemanticError( branchStmt->location, toString( (isContinue ? "'continue'" : "'break'"), " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "), originalTarget ) );
                                 } // if
                                 break;

src/ControlStruct/MLEMutator.h

@@ -37 +37 @@
 
                 void premutate( CompoundStmt *cmpndStmt );
-                Statement * postmutate( BranchStmt *branchStmt ) throw ( SemanticError );
+                Statement * postmutate( BranchStmt *branchStmt ) throw ( SemanticErrorException );
                 void premutate( WhileStmt *whileStmt );
                 Statement * postmutate( WhileStmt *whileStmt );

src/ControlStruct/Mutate.cc

@@ -18 +18 @@
 
 #include "Common/PassVisitor.h"    // for mutateAll
-#include "Common/SemanticError.h"  // for SemanticError
 #include "ForExprMutator.h"        // for ForExprMutator
 #include "LabelFixer.h"            // for LabelFixer

src/GenPoly/Box.cc

@@ -215 +215 @@
         inline void mutateTranslationUnit( std::list< Declaration* > &translationUnit, MutatorType &mutator ) {
                 bool seenIntrinsic = false;
-                SemanticError errors;
+                SemanticErrorException errors;
                 for ( typename std::list< Declaration* >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
                         try {
@@ -228 +228 @@
                                         assert( *i );
                                 } // if
-                        } catch( SemanticError &e ) {
+                        } catch( SemanticErrorException &e ) {
                                 errors.append( e );
                         } // try
@@ -575 +575 @@
                                                 }
                                         } else {
-                                                throw SemanticError( argBaseType, "Cannot pass non-struct type for generic struct: " );
+                                                SemanticError( argBaseType, "Cannot pass non-struct type for generic struct: " );
                                         }
                                 }
@@ -597 +597 @@
                                         } else {
                                                 // xxx - should this be an assertion?
-                                                throw SemanticError( appExpr, toString( *env, "\nunbound type variable: ", tyParm->first, " in application " ) );
+                                                SemanticError( appExpr, toString( *env, "\nunbound type variable: ", tyParm->first, " in application " ) );
                                         } // if
                                 } // if

src/GenPoly/FindFunction.cc

@@ -19 +19 @@
 
 #include "Common/PassVisitor.h"         // for PassVisitor
-#include "Common/SemanticError.h"       // for SemanticError
 #include "GenPoly/ErasableScopedMap.h"  // for ErasableScopedMap<>::iterator
 #include "GenPoly/GenPoly.h"            // for TyVarMap

src/GenPoly/InstantiateGeneric.cc

@@ -24 +24 @@
 #include "Common/PassVisitor.h"        // for PassVisitor, WithDeclsToAdd
 #include "Common/ScopedMap.h"          // for ScopedMap
-#include "Common/SemanticError.h"      // for SemanticError
 #include "Common/UniqueName.h"         // for UniqueName
 #include "Common/utility.h"            // for deleteAll, cloneAll

src/GenPoly/Lvalue.cc

@@ -18 +18 @@
 
 #include "Common/PassVisitor.h"
-#include "Common/SemanticError.h"        // for SemanticError
 #include "GenPoly.h"                     // for isPolyType
 #include "Lvalue.h"

src/GenPoly/Specialize.cc

@@ -23 +23 @@
 
 #include "Common/PassVisitor.h"
-#include "Common/SemanticError.h"        // for SemanticError
 #include "Common/UniqueName.h"           // for UniqueName
 #include "Common/utility.h"              // for group_iterate

src/InitTweak/FixGlobalInit.cc

@@ -21 +21 @@
 
 #include "Common/PassVisitor.h"
-#include "Common/SemanticError.h"  // for SemanticError
 #include "Common/UniqueName.h"     // for UniqueName
 #include "InitTweak.h"             // for isIntrinsicSingleArgCallStmt

src/InitTweak/FixInit.cc

@@ -213 +213 @@
                         Expression * postmutate( UntypedExpr * expr );
 
-                        SemanticError errors;
+                        SemanticErrorException errors;
                   private:
                         template< typename... Params >
@@ -276 +276 @@
                         // can't use mutateAll, because need to insert declarations at top-level
                         // can't use DeclMutator, because sometimes need to insert IfStmt, etc.
-                        SemanticError errors;
+                        SemanticErrorException errors;
                         for ( std::list< Declaration * >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
                                 try {
                                         maybeMutate( *i, fixer );
                                         translationUnit.splice( i, fixer.pass.staticDtorDecls );
-                                } catch( SemanticError &e ) {
+                                } catch( SemanticErrorException &e ) {
                                         errors.append( e );
                                 } // try
@@ -894 +894 @@
                         )
                         if ( ! diff.empty() ) {
-                                throw SemanticError( stmt, std::string("jump to label '") + stmt->get_target().get_name() + "' crosses initialization of " + (*diff.begin())->get_name() + " " );
+                                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
@@ -945 +945 @@
                         GuardValue( isCtor );
                         GuardValue( structDecl );
-                        errors = SemanticError();  // clear previous errors
+                        errors = SemanticErrorException();  // clear previous errors
 
                         // need to start with fresh sets
@@ -1034 +1034 @@
                                                                 function->get_statements()->push_back( callStmt );
                                                         }
-                                                } catch ( SemanticError & error ) {
+                                                } catch ( SemanticErrorException & error ) {
                                                         emit( funcDecl->location, "in ", CodeGen::genPrettyType( function->get_functionType(), function->get_name() ), ", field ", field->get_name(), " not explicitly ", isCtor ? "constructed" : "destructed",  " and no ", isCtor ? "default constructor" : "destructor", " found" );
                                                 }
@@ -1110 +1110 @@
                 template< typename Visitor, typename... Params >
                 void error( Visitor & v, CodeLocation loc, const Params &... params ) {
-                        SemanticError err( loc, toString( params... ) );
+                        SemanticErrorException 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( objDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
+                        if ( isDesignated( objDecl->get_init() ) ) 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( objDecl, "Managed object's initializer is too deep " );
+                        if ( ! checkInitDepth( objDecl ) ) 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( init->location, "unbalanced list initializers" );
+                                        SemanticError( init->location, "unbalanced list initializers" );
                                 }
 

src/Parser/DeclarationNode.cc

@@ -576 +576 @@
                                         dst->basictype = src->basictype;
                                 } else if ( src->basictype != DeclarationNode::NoBasicType )
-                                        throw SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::basicTypeNames[ src->basictype ] + " in type: " );
+                                        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( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::complexTypeNames[ src->complextype ] + " in type: " );
+                                        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( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: " );
+                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::signednessNames[ src->signedness ] + " in type: " );
 
                                 if ( dst->length == DeclarationNode::NoLength ) {
@@ -593 +593 @@
                                         dst->length = DeclarationNode::LongLong;
                                 } else if ( src->length != DeclarationNode::NoLength )
-                                        throw SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: " );
+                                        SemanticError( yylloc, src, string( "conflicting type specifier " ) + DeclarationNode::lengthNames[ src->length ] + " in type: " );
                         } // if
                         break;
@@ -940 +940 @@
 
 void buildList( const DeclarationNode * firstNode, std::list< Declaration * > &outputList ) {
-        SemanticError errors;
+        SemanticErrorException errors;
         std::back_insert_iterator< std::list< Declaration * > > out( outputList );
 
@@ -960 +960 @@
                                 * out++ = decl;
                         } // if
-                } catch( SemanticError &e ) {
+                } catch( SemanticErrorException &e ) {
                         errors.append( e );
                 } // try
@@ -971 +971 @@
 
 void buildList( const DeclarationNode * firstNode, std::list< DeclarationWithType * > &outputList ) {
-        SemanticError errors;
+        SemanticErrorException errors;
         std::back_insert_iterator< std::list< DeclarationWithType * > > out( outputList );
 
@@ -994 +994 @@
                                 } // if
                         } // if
-                } catch( SemanticError &e ) {
+                } catch( SemanticErrorException &e ) {
                         errors.append( e );
                 } // try
@@ -1005 +1005 @@
 
 void buildTypeList( const DeclarationNode * firstNode, std::list< Type * > &outputList ) {
-        SemanticError errors;
+        SemanticErrorException errors;
         std::back_insert_iterator< std::list< Type * > > out( outputList );
         const DeclarationNode * cur = firstNode;
@@ -1012 +1012 @@
                 try {
                         * out++ = cur->buildType();
-                } catch( SemanticError &e ) {
+                } catch( SemanticErrorException &e ) {
                         errors.append( e );
                 } // try
@@ -1024 +1024 @@
 
 Declaration * DeclarationNode::build() const {
-        if ( ! error.empty() ) throw SemanticError( this, error + " in declaration of " );
+        if ( ! error.empty() ) SemanticError( this, error + " in declaration of " );
 
         if ( asmStmt ) {
@@ -1047 +1047 @@
                 //    inline _Noreturn int i;                   // disallowed
                 if ( type->kind != TypeData::Function && funcSpecs.any() ) {
-                        throw SemanticError( this, "invalid function specifier for " );
+                        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 );
@@ -1057 +1057 @@
         //    inlne _Noreturn enum   E { ... };         // disallowed
         if ( funcSpecs.any() ) {
-                throw SemanticError( this, "invalid function specifier for " );
+                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( yylloc, "invalid tuple index " + str );
+        if ( str.find_first_not_of( "0123456789", 1 ) != string::npos ) 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( yylloc, "invalid tuple index " + str );
+        if ( str[str.size()-1] != '.' ) SemanticError( yylloc, "invalid tuple index " + str );
         Expression * ret = build_constantInteger( *new string( str.substr( 0, str.size()-1 ) ) );
         delete &str;

src/Parser/LinkageSpec.cc

@@ -34 +34 @@
                 return BuiltinC;
         } else {
-                throw SemanticError( location, "Invalid linkage specifier " + *spec );
+                SemanticError( location, "Invalid linkage specifier " + *spec );
         } // if
 }
@@ -48 +48 @@
                 return old_spec;
         } else {
-                throw SemanticError( location, "Invalid linkage specifier " + *cmd );
+                SemanticError( location, "Invalid linkage specifier " + *cmd );
         } // if
 }

src/Parser/ParseNode.h

@@ -419 +419 @@
 template< typename SynTreeType, typename NodeType, template< typename, typename...> class Container, typename... Args >
 void buildList( const NodeType * firstNode, Container< SynTreeType *, Args... > &outputList ) {
-        SemanticError errors;
+        SemanticErrorException errors;
         std::back_insert_iterator< Container< SynTreeType *, Args... > > out( outputList );
         const NodeType * cur = firstNode;
@@ -432 +432 @@
                                 assertf(false, "buildList unknown type");
                         } // if
-                } catch( SemanticError &e ) {
+                } catch( SemanticErrorException &e ) {
                         errors.append( e );
                 } // try

src/Parser/TypeData.cc

@@ -519 +519 @@
 
 static string genTSError( string msg, DeclarationNode::BasicType basictype ) {
-        throw SemanticError( yylloc, string( "invalid type specifier \"" ) + msg + "\" for type \"" + DeclarationNode::basicTypeNames[basictype] + "\"." );
+        SemanticError( yylloc, string( "invalid type specifier \"" ) + msg + "\" for type \"" + DeclarationNode::basicTypeNames[basictype] + "\"." );
 } // genTSError
 
@@ -919 +919 @@
                                 // 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( param->location, string( "duplicate declaration name " ) + *param->name );
+                                if ( param->type ) 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( param->location, string( "duplicate parameter name " ) + *param->name );
+                                if ( ! decl->type ) 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
@@ -929 +929 @@
                 } // for
                 // declaration type still set => type not moved to a matching parameter so there is a missing parameter name
-                if ( decl->type ) throw SemanticError( decl->location, string( "missing name in parameter list " ) + *decl->name );
+                if ( decl->type ) SemanticError( decl->location, string( "missing name in parameter list " ) + *decl->name );
         } // for
 

src/Parser/lex.ll

@@ -453 +453 @@
 void yyerror( const char * errmsg ) {
         cout << (yyfilename ? yyfilename : "*unknown file*") << ':' << yylineno << ':' << column - yyleng + 1
-                 << ": " << SemanticError::error_str() << errmsg << " at token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << '"' << endl;
+                 << ": " << ErrorHelpers::error_str() << errmsg << " at token \"" << (yytext[0] == '\0' ? "EOF" : yytext) << '"' << endl;
 }
 

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( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; } // FIX ME
+                { SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; } // FIX ME
         | type_name '.' '[' push field_list pop ']'                     // CFA, nested type / tuple field selector
-                { throw SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; } // FIX ME
+                { SemanticError( yylloc, "Qualified names are currently unimplemented." ); $$ = nullptr; } // FIX ME
         | GENERIC '(' assignment_expression ',' generic_assoc_list ')' // C11
-                { throw SemanticError( yylloc, "_Generic is currently unimplemented." ); $$ = nullptr; } // FIX ME
+                { SemanticError( yylloc, "_Generic is currently unimplemented." ); $$ = nullptr; } // FIX ME
         ;
 
@@ -780 +780 @@
                 { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); }
         | unary_expression '=' '{' initializer_list comma_opt '}'
-                { throw SemanticError( yylloc, "Initializer assignment is currently unimplemented." ); $$ = nullptr; } // FIX ME
+                { SemanticError( yylloc, "Initializer assignment is currently unimplemented." ); $$ = nullptr; } // FIX ME
         ;
 
@@ -850 +850 @@
         | exception_statement
         | enable_disable_statement
-                { throw SemanticError( yylloc, "enable/disable statement is currently unimplemented." ); $$ = nullptr; } // FIX ME
+                { SemanticError( yylloc, "enable/disable statement is currently unimplemented." ); $$ = nullptr; } // FIX ME
         | asm_statement
         ;
@@ -1067 +1067 @@
                 { $$ = new StatementNode( build_return( $2 ) ); }
         | RETURN '{' initializer_list comma_opt '}'
-                { throw SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; } // FIX ME
+                { SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; } // FIX ME
         | THROW assignment_expression_opt ';'                           // handles rethrow
                 { $$ = new StatementNode( build_throw( $2 ) ); }
@@ -1086 +1086 @@
 mutex_statement:
         MUTEX '(' argument_expression_list ')' statement
-                { throw SemanticError( yylloc, "Mutex statement is currently unimplemented." ); $$ = nullptr; } // FIX ME
+                { SemanticError( yylloc, "Mutex statement is currently unimplemented." ); $$ = nullptr; } // FIX ME
         ;
 
@@ -1316 +1316 @@
 static_assert:
         STATICASSERT '(' constant_expression ',' string_literal ')' ';' // C11
-                { throw SemanticError( yylloc, "Static assert is currently unimplemented." ); $$ = nullptr; }   // FIX ME
+                { 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

src/ResolvExpr/AlternativeFinder.cc

@@ -240 +240 @@
                                 std::cerr << "No reasonable alternatives for expression " << expr << std::endl;
                         )
-                        throw SemanticError( expr, "No reasonable alternatives for expression " );
+                        SemanticError( expr, "No reasonable alternatives for expression " );
                 }
                 if ( prune ) {
@@ -258 +258 @@
                                 stream << " Alternatives are:\n";
                                 printAlts( winners, stream, 1 );
-                                throw SemanticError( expr->location, stream.str() );
+                                SemanticError( expr->location, stream.str() );
                         }
                         alternatives = move(pruned);
@@ -495 +495 @@
                                 return;
                         } else if ( level >= recursionLimit ) {
-                                throw SemanticError( newAlt.expr->location, "Too many recursive assertions" );
+                                SemanticError( newAlt.expr->location, "Too many recursive assertions" );
                         } else {
                                 AssertionSet newerNeed;
@@ -1112 +1112 @@
 
                 AltList candidates;
-                SemanticError errors;
+                SemanticErrorException errors;
                 for ( AltList::iterator func = funcFinder.alternatives.begin(); func != funcFinder.alternatives.end(); ++func ) {
                         try {
@@ -1138 +1138 @@
                                         } // if
                                 }
-                        } catch ( SemanticError &e ) {
+                        } catch ( SemanticErrorException &e ) {
                                 errors.append( e );
                         }
@@ -1167 +1167 @@
                                                 }
                                         }
-                                } catch ( SemanticError &e ) {
+                                } catch ( SemanticErrorException &e ) {
                                         errors.append( e );
                                 }
@@ -1409 +1409 @@
                         findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) );
                         if ( winners.size() != 1 ) {
-                                throw SemanticError( sizeofExpr->get_expr(), "Ambiguous expression in sizeof operand: " );
+                                SemanticError( sizeofExpr->get_expr(), "Ambiguous expression in sizeof operand: " );
                         } // if
                         // return the lowest cost alternative for the argument
@@ -1430 +1430 @@
                         findMinCost( finder.alternatives.begin(), finder.alternatives.end(), back_inserter( winners ) );
                         if ( winners.size() != 1 ) {
-                                throw SemanticError( alignofExpr->get_expr(), "Ambiguous expression in alignof operand: " );
+                                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( at, "VLA initialization does not support @=" );
+                        if ( at->isVarLen ) SemanticError( at, "VLA initialization does not support @=" );
                         setSize( at->get_dimension() );
                 }
@@ -155 +155 @@
                                         size = constExpr->intValue();
                                         PRINT( std::cerr << "array type with size: " << size << std::endl; )
-                                } catch ( SemanticError & ) {
-                                        throw SemanticError( expr, "Constant expression of non-integral type in array dimension: " );
+                                } catch ( SemanticErrorException & ) {
+                                        SemanticError( expr, "Constant expression of non-integral type in array dimension: " );
                                 }
                         }       else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
@@ -178 +178 @@
                                 try {
                                         index = constExpr->intValue();
-                                } catch( SemanticError & ) {
-                                        throw SemanticError( expr, "Constant expression of non-integral type in array designator: " );
+                                } catch( SemanticErrorException & ) {
+                                        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( designation, toString("Too many alternatives (", desigAlts.size(), ") for designation: ") );
+                        SemanticError( designation, toString("Too many alternatives (", desigAlts.size(), ") for designation: ") );
                 } else if ( desigAlts.size() == 0 ) {
-                        throw SemanticError( designation, "No reasonable alternatives for designation: " );
+                        SemanticError( designation, "No reasonable alternatives for designation: " );
                 }
                 DesignatorChain & d = desigAlts.back();

src/ResolvExpr/Resolver.cc

@@ -174 +174 @@
                         findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
                         if ( winners.size() == 0 ) {
-                                throw SemanticError( untyped, toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: ") );
+                                SemanticError( untyped, toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: ") );
                         } else if ( winners.size() != 1 ) {
                                 std::ostringstream stream;
@@ -181 +181 @@
                                 stream << " Alternatives are:\n";
                                 printAlts( winners, stream, 1 );
-                                throw SemanticError( untyped->location, stream.str() );
+                                SemanticError( untyped->location, stream.str() );
                         }
 
@@ -187 +187 @@
                         Alternative & choice = winners.front();
                         if ( findDeletedExpr( choice.expr ) ) {
-                                throw SemanticError( choice.expr, "Unique best alternative includes deleted identifier in " );
+                                SemanticError( choice.expr, "Unique best alternative includes deleted identifier in " );
                         }
                         alt = std::move( choice );
@@ -484 +484 @@
                                 ss << strict_dynamic_cast<NameExpr*>( clause.target.function )->name;
                                 ss << "' in call to waitfor";
-                                throw SemanticError( stmt->location, ss.str() );
+                                SemanticError( stmt->location, ss.str() );
                         }
 
@@ -501 +501 @@
                         //      try matching the arguments to the parameters
                         //      not the other way around because we have more arguments than parameters
-                        SemanticError errors;
+                        SemanticErrorException errors;
                         for ( Alternative & func : funcFinder.get_alternatives() ) {
                                 try {
                                         PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() );
                                         if( !pointer ) {
-                                                throw SemanticError( func.expr->get_result(), "candidate not viable: not a pointer type\n" );
+                                                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( pointer->get_base(), "candidate not viable: not a function type\n" );
+                                                SemanticError( pointer->get_base(), "candidate not viable: not a function type\n" );
                                         }
 
@@ -520 +520 @@
 
                                                 if( !advance_to_mutex( param, param_end ) ) {
-                                                        throw SemanticError(function, "candidate function not viable: no mutex parameters\n");
+                                                        SemanticError(function, "candidate function not viable: no mutex parameters\n");
                                                 }
                                         }
@@ -559 +559 @@
                                                                         // We ran out of parameters but still have arguments
                                                                         // this function doesn't match
-                                                                        throw SemanticError( function, "candidate function not viable: too many mutex arguments\n" );
+                                                                        SemanticError( function, "candidate function not viable: too many mutex arguments\n" );
                                                                 }
 
@@ -571 +571 @@
                                                                         (*param)->get_type()->print( ss );
                                                                         ss << "'\n";
-                                                                        throw SemanticError( function, ss.str() );
+                                                                        SemanticError( function, ss.str() );
                                                                 }
 
@@ -583 +583 @@
                                                                 // We ran out of arguments but still have parameters left
                                                                 // this function doesn't match
-                                                                throw SemanticError( function, "candidate function not viable: too few mutex arguments\n" );
+                                                                SemanticError( function, "candidate function not viable: too few mutex arguments\n" );
                                                         }
 
@@ -599 +599 @@
 
                                                 }
-                                                catch( SemanticError &e ) {
+                                                catch( SemanticErrorException &e ) {
                                                         errors.append( e );
                                                 }
                                         }
                                 }
-                                catch( SemanticError &e ) {
+                                catch( SemanticErrorException &e ) {
                                         errors.append( e );
                                 }
@@ -610 +610 @@
 
                         // Make sure we got the right number of arguments
-                        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; }
+                        if( func_candidates.empty() )    { SemanticErrorException top( stmt->location, "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
+                        if( args_candidates.empty() )    { SemanticErrorException top( stmt->location, "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
+                        if( func_candidates.size() > 1 ) { SemanticErrorException top( stmt->location, "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
+                        if( args_candidates.size() > 1 ) { SemanticErrorException top( stmt->location, "Ambiguous arguments in call to waitfor"           ); top.append( errors ); throw top; }
                         // TODO: need to use findDeletedExpr to ensure no deleted identifiers are used.
 

src/SymTab/Autogen.cc

@@ -331 +331 @@
                         definitions.push_back( dcl );
                         indexer.addId( dcl );
-                } catch ( SemanticError err ) {
+                } catch ( SemanticErrorException err ) {
                         // okay if decl does not resolve - that means the function should not be generated
                         delete dcl;

src/SymTab/Indexer.cc

@@ -443 +443 @@
                         // isomorphic to C type-compatibility, which it may not be.
                         if ( hasIncompatibleCDecl( name, mangleName, scope ) ) {
-                                throw SemanticError( decl, "conflicting overload of C function " );
+                                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( decl, "Cforall declaration hides C function " );
+                                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( decl, msg ); return true; }, baseExpr );
+                addId( decl, [decl](IdData &, const std::string & msg) { 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( decl, msg ); return true; }, nullptr, deleteStmt );
+                addId( decl, [decl](IdData &, const std::string & msg) { SemanticError( decl, msg ); return true; }, nullptr, deleteStmt );
         }
 
@@ -477 +477 @@
                         return true;
                 } else {
-                        throw SemanticError( added, "redeclaration of " );
+                        SemanticError( added, "redeclaration of " );
                 }
         }
@@ -504 +504 @@
                         return false;
                 } else if ( ! added->get_members().empty() ) {
-                        throw SemanticError( added, "redeclaration of " );
+                        SemanticError( added, "redeclaration of " );
                 } // if
                 return true;

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

src/SynTree/Expression.cc

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

src/SynTree/Mutator.h

@@ -136 +136 @@
 template< typename Container, typename MutatorType >
 inline void mutateAll( Container &container, MutatorType &mutator ) {
-        SemanticError errors;
+        SemanticErrorException errors;
         for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
                 try {
@@ -144 +144 @@
                                 assert( *i );
                         } // if
-                } catch( SemanticError &e ) {
+                } catch( SemanticErrorException &e ) {
                         errors.append( e );
                 } // try

src/SynTree/Statement.cc

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

src/SynTree/Statement.h

@@ -179 +179 @@
         std::list<Statement *> stmts;
 
-        CaseStmt( Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
+        CaseStmt( Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw (SemanticErrorException);
         CaseStmt( const CaseStmt &other );
         virtual ~CaseStmt();
@@ -263 +263 @@
         Type type;
 
-        BranchStmt( Label target, Type ) throw (SemanticError);
-        BranchStmt( Expression *computedTarget, Type ) throw (SemanticError);
+        BranchStmt( Label target, Type ) throw (SemanticErrorException);
+        BranchStmt( Expression *computedTarget, Type ) throw (SemanticErrorException);
 
         Label get_originalTarget() { return originalTarget; }

src/SynTree/TypeSubstitution.h

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

src/SynTree/Visitor.h

@@ -132 +132 @@
 template< typename Container, typename VisitorType >
 inline void acceptAll( Container &container, VisitorType &visitor ) {
-        SemanticError errors;
+        SemanticErrorException errors;
         for ( typename Container::iterator i = container.begin(); i != container.end(); ++i ) {
                 try {
@@ -138 +138 @@
                                 (*i)->accept( visitor );
                         }
-                } catch( SemanticError &e ) {
+                } catch( SemanticErrorException &e ) {
                         errors.append( e );
                 }

src/main.cc

@@ -357 +357 @@
                         delete output;
                 } // if
-        } catch ( SemanticError &e ) {
+        } catch ( SemanticErrorException &e ) {
                 if ( errorp ) {
                         cerr << "---AST at error:---" << endl;