Changes in / [946bcca:615a096]

Files:

• doc/LaTeXmacros/common.tex (modified) (1 diff)
• src/InitTweak/FixInit.cc (modified) (7 diffs)
• src/Parser/ExpressionNode.cc (modified) (1 diff)
• src/Parser/ParseNode.h (modified) (1 diff)
• src/ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• src/SynTree/Declaration.cc (modified) (1 diff)
• src/SynTree/Expression.cc (modified) (1 diff)
• src/SynTree/Initializer.cc (modified) (1 diff)
• src/SynTree/Initializer.h (modified) (1 diff)
• src/SynTree/Type.cc (modified) (2 diffs)
• src/Tuples/TupleExpansion.cc (modified) (3 diffs)
• src/tests/.expect/memberCtors-ERR1.txt (modified) (1 diff)

doc/LaTeXmacros/common.tex

@@ -40 +40 @@
 \newcommand{\CC}{\rm C\kern-.1em\hbox{+\kern-.25em+}\xspace} % CC symbolic name
 \newcommand{\CCeleven}{\rm C\kern-.1em\hbox{+\kern-.25em+}11\xspace} % C++11 symbolic name
-\newcommand{\CCfourteen}{\rm C\kern-.1em\hbox{+\kern-.25em+}14\xspace} % C++14 symbolic name
 \newcommand{\CCseventeen}{\rm C\kern-.1em\hbox{+\kern-.25em+}17\xspace} % C++17 symbolic name
 \newcommand{\Celeven}{C11\xspace}               % C11 symbolic name

src/InitTweak/FixInit.cc

@@ -232 +232 @@
                         void handleFirstParam( Expression * firstParam );
                         template< typename... Params >
-                        void emit( CodeLocation, const Params &... params );
+                        void emit( const Params &... params );
 
                         FunctionDecl * function = 0;
-                        std::set< DeclarationWithType * > unhandled;
-                        std::map< DeclarationWithType *, CodeLocation > usedUninit;
+                        std::set< DeclarationWithType * > unhandled, usedUninit;
                         ObjectDecl * thisParam = 0;
                         bool isCtor = false; // true if current function is a constructor
@@ -337 +336 @@
                         GenStructMemberCalls warner;
                         acceptAll( translationUnit, warner );
+
+                        // visitor doesn't throw so that it can collect all errors
+                        if ( ! warner.errors.isEmpty() ) {
+                                throw warner.errors;
+                        }
                 }
 
@@ -936 +940 @@
                         ValueGuard< FunctionDecl * > oldFunction( funcDecl );
                         ValueGuard< std::set< DeclarationWithType * > > oldUnhandled( unhandled );
-                        ValueGuard< std::map< DeclarationWithType *, CodeLocation > > oldUsedUninit( usedUninit );
+                        ValueGuard< std::set< DeclarationWithType * > > 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
@@ -969 +972 @@
                         // remove the unhandled objects from usedUninit, because a call is inserted
                         // to handle them - only objects that are later constructed are used uninitialized.
-                        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" );
+                        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" );
                         }
 
@@ -1027 +1020 @@
                                                         }
                                                 } catch ( SemanticError & 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" );
+                                                        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" );
                                                 }
                                         }
                                 }
                                 leaveScope();
-                        }
-                        if (! errors.isEmpty()) {
-                                throw errors;
                         }
                 }
@@ -1089 +1079 @@
                                                         if ( unhandled.count( memberExpr->get_member() ) ) {
                                                                 // emit a warning because a member was used before it was constructed
-                                                                usedUninit.insert( { memberExpr->get_member(), memberExpr->location } );
+                                                                usedUninit.insert( memberExpr->get_member() );
                                                         }
                                                 }
@@ -1099 +1089 @@
 
                 template< typename Visitor, typename... Params >
-                void error( Visitor & v, CodeLocation loc, const Params &... params ) {
-                        SemanticError err( toString( params... ) );
-                        err.set_location( loc );
-                        v.errors.append( err );
+                void error( Visitor & v, const Params &... params ) {
+                        v.errors.append( toString( params... ) );
                 }
 
                 template< typename... Params >
-                void GenStructMemberCalls::emit( CodeLocation loc, const Params &... params ) {
+                void GenStructMemberCalls::emit( const Params &... params ) {
                         // toggle warnings vs. errors here.
                         // warn( params... );
-                        error( *this, loc, params... );
+                        error( *this, params... );
                 }
 

src/Parser/ExpressionNode.cc

@@ -254 +254 @@
 Expression *build_pfieldSel( ExpressionNode *expr_node, Expression *member ) {
         UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-        deref->location = expr_node->location;
         deref->get_args().push_back( maybeMoveBuild< Expression >(expr_node) );
         UntypedMemberExpr *ret = new UntypedMemberExpr( member, deref );

src/Parser/ParseNode.h

@@ -134 +134 @@
                         Expression * p = orig->build();
                         p->set_extension( orig->get_extension() );
-                        p->location = orig->location;
                         return p;
                 } else {

src/ResolvExpr/AlternativeFinder.cc

@@ -200 +200 @@
                 }
 
-                // Central location to handle gcc extension keyword, etc. for all expression types.
+                // Central location to handle gcc extension keyword for all expression types.
                 for ( Alternative &iter: alternatives ) {
                         iter.expr->set_extension( expr->get_extension() );
-                        iter.expr->location = expr->location;
                 } // for
         }

src/SynTree/Declaration.cc

@@ -32 +32 @@
 
 Declaration::Declaration( const Declaration &other )
-        : BaseSyntaxNode( other ), name( other.name ), storageClasses( other.storageClasses ), linkage( other.linkage ), uniqueId( other.uniqueId ) {
+        : name( other.name ), storageClasses( other.storageClasses ), linkage( other.linkage ), uniqueId( other.uniqueId ) {
 }
 

src/SynTree/Expression.cc

@@ -33 +33 @@
 Expression::Expression( Expression *_aname ) : result( 0 ), env( 0 ), argName( _aname ) {}
 
-Expression::Expression( const Expression &other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
+Expression::Expression( const Expression &other ) : result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
 }
 

src/SynTree/Initializer.cc

@@ -20 +20 @@
 
 Initializer::Initializer( bool maybeConstructed ) : maybeConstructed( maybeConstructed ) {}
-Initializer::Initializer( const Initializer & other ) : BaseSyntaxNode( other ), maybeConstructed( other.maybeConstructed ) {
+Initializer::Initializer( const Initializer & other ) : maybeConstructed( other.maybeConstructed ) {
 }
 

src/SynTree/Initializer.h

@@ -112 +112 @@
 // ConstructorInit represents an initializer that is either a constructor expression or
 // a C-style initializer.
-// It should not be necessary to create ConstructorInit nodes manually. Instead, set maybeConstructed
-// to true on SingleInit or ListInit constructors if object should be constructed.
 class ConstructorInit : public Initializer {
   public:

src/SynTree/Type.cc

@@ -50 +50 @@
 Type::Type( const Qualifiers &tq, const std::list< Attribute * > & attributes ) : tq( tq ), attributes( attributes ) {}
 
-Type::Type( const Type &other ) : BaseSyntaxNode( other ), tq( other.tq ) {
+Type::Type( const Type &other ) : tq( other.tq ) {
         cloneAll( other.forall, forall );
         cloneAll( other.attributes, attributes );
@@ -84 +84 @@
                 printAll( attributes, os, indent+4 );
         } // if
-
+        
         tq.print( os );
 }

src/Tuples/TupleExpansion.cc

@@ -126 +126 @@
                 /// given a expression representing the member and an expression representing the aggregate,
                 /// reconstructs a flattened UntypedMemberExpr with the right precedence
-                Expression * reconstructMemberExpr( Expression * member, Expression * aggr, CodeLocation & loc ) {
+                Expression * reconstructMemberExpr( Expression * member, Expression * aggr ) {
                         if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * >( member ) ) {
                                 // construct a new UntypedMemberExpr with the correct structure , and recursively
                                 // expand that member expression.
                                 MemberTupleExpander expander;
-                                UntypedMemberExpr * inner = new UntypedMemberExpr( memberExpr->get_aggregate(), aggr->clone() );
-                                UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->get_member(), inner );
-                                inner->location = newMemberExpr->location = loc;
+                                UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->get_member(), new UntypedMemberExpr( memberExpr->get_aggregate(), aggr->clone() ) );
+
                                 memberExpr->set_member(nullptr);
                                 memberExpr->set_aggregate(nullptr);
@@ -140 +139 @@
                         } else {
                                 // not a member expression, so there is nothing to do but attach and return
-                                UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( member, aggr->clone() );
-                                newMemberExpr->location = loc;
-                                return newMemberExpr;
+                                return new UntypedMemberExpr( member, aggr->clone() );
                         }
                 }
@@ -155 +152 @@
                         aggr = new UniqueExpr( aggr );
                         for ( Expression *& expr : tupleExpr->get_exprs() ) {
-                                expr = reconstructMemberExpr( expr, aggr, memberExpr->location );
-                                expr->location = memberExpr->location;
+                                expr = reconstructMemberExpr( expr, aggr );
                         }
                         delete aggr;
-                        tupleExpr->location = memberExpr->location;
                         return tupleExpr;
                 } else {
                         // there may be a tuple expr buried in the aggregate
                         // xxx - this is a memory leak
-                        UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->get_member()->clone(), memberExpr->get_aggregate()->acceptMutator( *this ) );
-                        newMemberExpr->location = memberExpr->location;
-                        return newMemberExpr;
+                        return new UntypedMemberExpr( memberExpr->get_member()->clone(), memberExpr->get_aggregate()->acceptMutator( *this ) );
                 }
         }

src/tests/.expect/memberCtors-ERR1.txt

@@ -1 @@
-memberCtors.c:62 error: in void ?{}(struct B *b), field a2 used before being constructed
+error: in void ?{}(struct B *b), field a2 used before being constructed
 make: *** [memberCtors-ERR1] Error 1