Changes in src/InitTweak/FixInit.cc [615a096:64ac636]

File:

• src/InitTweak/FixInit.cc (modified) (12 diffs)

src/InitTweak/FixInit.cc

@@ -10 +10 @@
 // Created On       : Wed Jan 13 16:29:30 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Mar 17 09:13:47 2017
-// Update Count     : 71
+// Last Modified On : Thu Mar 16 08:08:04 2017
+// Update Count     : 67
 //
 
@@ -232 +232 @@
                         void handleFirstParam( Expression * firstParam );
                         template< typename... Params >
-                        void emit( const Params &... params );
+                        void emit( CodeLocation, const Params &... params );
 
                         FunctionDecl * function = 0;
-                        std::set< DeclarationWithType * > unhandled, usedUninit;
+                        std::set< DeclarationWithType * > unhandled;
+                        std::map< DeclarationWithType *, CodeLocation > usedUninit;
                         ObjectDecl * thisParam = 0;
                         bool isCtor = false; // true if current function is a constructor
@@ -336 +337 @@
                         GenStructMemberCalls warner;
                         acceptAll( translationUnit, warner );
-
-                        // visitor doesn't throw so that it can collect all errors
-                        if ( ! warner.errors.isEmpty() ) {
-                                throw warner.errors;
-                        }
                 }
 
@@ -438 +434 @@
                         env->apply( result );
                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
-                        tmp->get_type()->set_const( false );
+                        tmp->get_type()->set_isConst( false );
 
                         // create and resolve copy constructor
@@ -484 +480 @@
                                 env->apply( result );
                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
-                                ret->get_type()->set_const( false );
+                                ret->get_type()->set_isConst( false );
                                 impCpCtorExpr->get_returnDecls().push_back( ret );
                                 CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
-                                if ( ! result->get_lvalue() ) {
+                                if ( ! result->get_isLvalue() ) {
                                         // destructing lvalue returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
                                         destructRet( ret, impCpCtorExpr );
@@ -507 +503 @@
                                 env->apply( result );
                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
-                                ret->get_type()->set_const( false );
+                                ret->get_type()->set_isConst( false );
                                 stmtExpr->get_returnDecls().push_front( ret );
 
@@ -588 +584 @@
 
                                 Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
-                                if ( callExpr->get_result()->get_lvalue() ) {
+                                if ( callExpr->get_result()->get_isLvalue() ) {
                                         // lvalue returning functions are funny. Lvalue.cc inserts a *? in front of any lvalue returning
                                         // non-intrinsic function. Add an AddressExpr to the call to negate the derefence and change the
@@ -940 +936 @@
                         ValueGuard< FunctionDecl * > oldFunction( funcDecl );
                         ValueGuard< std::set< DeclarationWithType * > > oldUnhandled( unhandled );
-                        ValueGuard< std::set< DeclarationWithType * > > oldUsedUninit( usedUninit );
+                        ValueGuard< std::map< DeclarationWithType *, CodeLocation > > oldUsedUninit( usedUninit );
                         ValueGuard< ObjectDecl * > oldThisParam( thisParam );
                         ValueGuard< bool > oldIsCtor( isCtor );
                         ValueGuard< StructDecl * > oldStructDecl( structDecl );
+                        errors = SemanticError();  // clear previous errors
 
                         // need to start with fresh sets
@@ -972 +969 @@
                         // remove the unhandled objects from usedUninit, because a call is inserted
                         // to handle them - only objects that are later constructed are used uninitialized.
-                        std::set< DeclarationWithType * > diff;
-                        std::set_difference( usedUninit.begin(), usedUninit.end(), unhandled.begin(), unhandled.end(), std::inserter( diff, diff.begin() ) );
-                        for ( DeclarationWithType * member : diff ) {
-                                emit( "in ", CodeGen::genPrettyType( function->get_functionType(), function->get_name() ), ", field ", member->get_name(), " used before being constructed" );
+                        std::map< DeclarationWithType *, CodeLocation > diff;
+                        // need the comparator since usedUninit and unhandled have different types
+                        struct comp_t {
+                                typedef decltype(usedUninit)::value_type usedUninit_t;
+                                typedef decltype(unhandled)::value_type unhandled_t;
+                                bool operator()(usedUninit_t x, unhandled_t y) { return x.first < y; }
+                                bool operator()(unhandled_t x, usedUninit_t y) { return x < y.first; }
+                        } comp;
+                        std::set_difference( usedUninit.begin(), usedUninit.end(), unhandled.begin(), unhandled.end(), std::inserter( diff, diff.begin() ), comp );
+                        for ( auto p : diff ) {
+                                DeclarationWithType * member = p.first;
+                                CodeLocation loc = p.second;
+                                // xxx - make error message better by also tracking the location that the object is constructed at?
+                                emit( loc, "in ", CodeGen::genPrettyType( function->get_functionType(), function->get_name() ), ", field ", member->get_name(), " used before being constructed" );
                         }
 
@@ -1020 +1027 @@
                                                         }
                                                 } catch ( SemanticError & error ) {
-                                                        emit( "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" );
+                                                        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" );
                                                 }
                                         }
                                 }
                                 leaveScope();
+                        }
+                        if (! errors.isEmpty()) {
+                                throw errors;
                         }
                 }
@@ -1079 +1089 @@
                                                         if ( unhandled.count( memberExpr->get_member() ) ) {
                                                                 // emit a warning because a member was used before it was constructed
-                                                                usedUninit.insert( memberExpr->get_member() );
+                                                                usedUninit.insert( { memberExpr->get_member(), memberExpr->location } );
                                                         }
                                                 }
@@ -1089 +1099 @@
 
                 template< typename Visitor, typename... Params >
-                void error( Visitor & v, const Params &... params ) {
-                        v.errors.append( toString( params... ) );
+                void error( Visitor & v, CodeLocation loc, const Params &... params ) {
+                        SemanticError err( toString( params... ) );
+                        err.set_location( loc );
+                        v.errors.append( err );
                 }
 
                 template< typename... Params >
-                void GenStructMemberCalls::emit( const Params &... params ) {
+                void GenStructMemberCalls::emit( CodeLocation loc, const Params &... params ) {
                         // toggle warnings vs. errors here.
                         // warn( params... );
-                        error( *this, params... );
+                        error( *this, loc, params... );
                 }