Changeset 64ac636


Ignore:
Timestamp:
Mar 17, 2017, 1:14:07 PM (5 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, deferred_resn, demangler, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
b2f5082
Parents:
1fbab5a
Message:

fix missing line numbers in some places, including member constructor generation

Location:
src
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • src/InitTweak/FixInit.cc

    r1fbab5a r64ac636  
    232232                        void handleFirstParam( Expression * firstParam );
    233233                        template< typename... Params >
    234                         void emit( const Params &... params );
     234                        void emit( CodeLocation, const Params &... params );
    235235
    236236                        FunctionDecl * function = 0;
    237                         std::set< DeclarationWithType * > unhandled, usedUninit;
     237                        std::set< DeclarationWithType * > unhandled;
     238                        std::map< DeclarationWithType *, CodeLocation > usedUninit;
    238239                        ObjectDecl * thisParam = 0;
    239240                        bool isCtor = false; // true if current function is a constructor
     
    336337                        GenStructMemberCalls warner;
    337338                        acceptAll( translationUnit, warner );
    338 
    339                         // visitor doesn't throw so that it can collect all errors
    340                         if ( ! warner.errors.isEmpty() ) {
    341                                 throw warner.errors;
    342                         }
    343339                }
    344340
     
    940936                        ValueGuard< FunctionDecl * > oldFunction( funcDecl );
    941937                        ValueGuard< std::set< DeclarationWithType * > > oldUnhandled( unhandled );
    942                         ValueGuard< std::set< DeclarationWithType * > > oldUsedUninit( usedUninit );
     938                        ValueGuard< std::map< DeclarationWithType *, CodeLocation > > oldUsedUninit( usedUninit );
    943939                        ValueGuard< ObjectDecl * > oldThisParam( thisParam );
    944940                        ValueGuard< bool > oldIsCtor( isCtor );
    945941                        ValueGuard< StructDecl * > oldStructDecl( structDecl );
     942                        errors = SemanticError();  // clear previous errors
    946943
    947944                        // need to start with fresh sets
     
    972969                        // remove the unhandled objects from usedUninit, because a call is inserted
    973970                        // to handle them - only objects that are later constructed are used uninitialized.
    974                         std::set< DeclarationWithType * > diff;
    975                         std::set_difference( usedUninit.begin(), usedUninit.end(), unhandled.begin(), unhandled.end(), std::inserter( diff, diff.begin() ) );
    976                         for ( DeclarationWithType * member : diff ) {
    977                                 emit( "in ", CodeGen::genPrettyType( function->get_functionType(), function->get_name() ), ", field ", member->get_name(), " used before being constructed" );
     971                        std::map< DeclarationWithType *, CodeLocation > diff;
     972                        // need the comparator since usedUninit and unhandled have different types
     973                        struct comp_t {
     974                                typedef decltype(usedUninit)::value_type usedUninit_t;
     975                                typedef decltype(unhandled)::value_type unhandled_t;
     976                                bool operator()(usedUninit_t x, unhandled_t y) { return x.first < y; }
     977                                bool operator()(unhandled_t x, usedUninit_t y) { return x < y.first; }
     978                        } comp;
     979                        std::set_difference( usedUninit.begin(), usedUninit.end(), unhandled.begin(), unhandled.end(), std::inserter( diff, diff.begin() ), comp );
     980                        for ( auto p : diff ) {
     981                                DeclarationWithType * member = p.first;
     982                                CodeLocation loc = p.second;
     983                                // xxx - make error message better by also tracking the location that the object is constructed at?
     984                                emit( loc, "in ", CodeGen::genPrettyType( function->get_functionType(), function->get_name() ), ", field ", member->get_name(), " used before being constructed" );
    978985                        }
    979986
     
    10201027                                                        }
    10211028                                                } catch ( SemanticError & error ) {
    1022                                                         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" );
     1029                                                        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" );
    10231030                                                }
    10241031                                        }
    10251032                                }
    10261033                                leaveScope();
     1034                        }
     1035                        if (! errors.isEmpty()) {
     1036                                throw errors;
    10271037                        }
    10281038                }
     
    10791089                                                        if ( unhandled.count( memberExpr->get_member() ) ) {
    10801090                                                                // emit a warning because a member was used before it was constructed
    1081                                                                 usedUninit.insert( memberExpr->get_member() );
     1091                                                                usedUninit.insert( { memberExpr->get_member(), memberExpr->location } );
    10821092                                                        }
    10831093                                                }
     
    10891099
    10901100                template< typename Visitor, typename... Params >
    1091                 void error( Visitor & v, const Params &... params ) {
    1092                         v.errors.append( toString( params... ) );
     1101                void error( Visitor & v, CodeLocation loc, const Params &... params ) {
     1102                        SemanticError err( toString( params... ) );
     1103                        err.set_location( loc );
     1104                        v.errors.append( err );
    10931105                }
    10941106
    10951107                template< typename... Params >
    1096                 void GenStructMemberCalls::emit( const Params &... params ) {
     1108                void GenStructMemberCalls::emit( CodeLocation loc, const Params &... params ) {
    10971109                        // toggle warnings vs. errors here.
    10981110                        // warn( params... );
    1099                         error( *this, params... );
     1111                        error( *this, loc, params... );
    11001112                }
    11011113
  • src/Parser/ExpressionNode.cc

    r1fbab5a r64ac636  
    254254Expression *build_pfieldSel( ExpressionNode *expr_node, Expression *member ) {
    255255        UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
     256        deref->location = expr_node->location;
    256257        deref->get_args().push_back( maybeMoveBuild< Expression >(expr_node) );
    257258        UntypedMemberExpr *ret = new UntypedMemberExpr( member, deref );
  • src/Parser/ParseNode.h

    r1fbab5a r64ac636  
    134134                        Expression * p = orig->build();
    135135                        p->set_extension( orig->get_extension() );
     136                        p->location = orig->location;
    136137                        return p;
    137138                } else {
  • src/ResolvExpr/AlternativeFinder.cc

    r1fbab5a r64ac636  
    200200                }
    201201
    202                 // Central location to handle gcc extension keyword for all expression types.
     202                // Central location to handle gcc extension keyword, etc. for all expression types.
    203203                for ( Alternative &iter: alternatives ) {
    204204                        iter.expr->set_extension( expr->get_extension() );
     205                        iter.expr->location = expr->location;
    205206                } // for
    206207        }
  • src/SynTree/Declaration.cc

    r1fbab5a r64ac636  
    3232
    3333Declaration::Declaration( const Declaration &other )
    34         : name( other.name ), storageClasses( other.storageClasses ), linkage( other.linkage ), uniqueId( other.uniqueId ) {
     34        : BaseSyntaxNode( other ), name( other.name ), storageClasses( other.storageClasses ), linkage( other.linkage ), uniqueId( other.uniqueId ) {
    3535}
    3636
  • src/SynTree/Expression.cc

    r1fbab5a r64ac636  
    3333Expression::Expression( Expression *_aname ) : result( 0 ), env( 0 ), argName( _aname ) {}
    3434
    35 Expression::Expression( const Expression &other ) : result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
     35Expression::Expression( const Expression &other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), argName( maybeClone( other.get_argName() ) ), extension( other.extension ) {
    3636}
    3737
  • src/SynTree/Initializer.cc

    r1fbab5a r64ac636  
    2020
    2121Initializer::Initializer( bool maybeConstructed ) : maybeConstructed( maybeConstructed ) {}
    22 Initializer::Initializer( const Initializer & other ) : maybeConstructed( other.maybeConstructed ) {
     22Initializer::Initializer( const Initializer & other ) : BaseSyntaxNode( other ), maybeConstructed( other.maybeConstructed ) {
    2323}
    2424
  • src/SynTree/Initializer.h

    r1fbab5a r64ac636  
    112112// ConstructorInit represents an initializer that is either a constructor expression or
    113113// a C-style initializer.
     114// It should not be necessary to create ConstructorInit nodes manually. Instead, set maybeConstructed
     115// to true on SingleInit or ListInit constructors if object should be constructed.
    114116class ConstructorInit : public Initializer {
    115117  public:
  • src/SynTree/Type.cc

    r1fbab5a r64ac636  
    4949Type::Type( const Qualifiers &tq, const std::list< Attribute * > & attributes ) : tq( tq ), attributes( attributes ) {}
    5050
    51 Type::Type( const Type &other ) : tq( other.tq ) {
     51Type::Type( const Type &other ) : BaseSyntaxNode( other ), tq( other.tq ) {
    5252        cloneAll( other.forall, forall );
    5353        cloneAll( other.attributes, attributes );
     
    7575                printAll( attributes, os, indent+4 );
    7676        } // if
    77        
     77
    7878        tq.print( os );
    7979}
  • src/Tuples/TupleExpansion.cc

    r1fbab5a r64ac636  
    126126                /// given a expression representing the member and an expression representing the aggregate,
    127127                /// reconstructs a flattened UntypedMemberExpr with the right precedence
    128                 Expression * reconstructMemberExpr( Expression * member, Expression * aggr ) {
     128                Expression * reconstructMemberExpr( Expression * member, Expression * aggr, CodeLocation & loc ) {
    129129                        if ( UntypedMemberExpr * memberExpr = dynamic_cast< UntypedMemberExpr * >( member ) ) {
    130130                                // construct a new UntypedMemberExpr with the correct structure , and recursively
    131131                                // expand that member expression.
    132132                                MemberTupleExpander expander;
    133                                 UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->get_member(), new UntypedMemberExpr( memberExpr->get_aggregate(), aggr->clone() ) );
    134 
     133                                UntypedMemberExpr * inner = new UntypedMemberExpr( memberExpr->get_aggregate(), aggr->clone() );
     134                                UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->get_member(), inner );
     135                                inner->location = newMemberExpr->location = loc;
    135136                                memberExpr->set_member(nullptr);
    136137                                memberExpr->set_aggregate(nullptr);
     
    139140                        } else {
    140141                                // not a member expression, so there is nothing to do but attach and return
    141                                 return new UntypedMemberExpr( member, aggr->clone() );
     142                                UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( member, aggr->clone() );
     143                                newMemberExpr->location = loc;
     144                                return newMemberExpr;
    142145                        }
    143146                }
     
    152155                        aggr = new UniqueExpr( aggr );
    153156                        for ( Expression *& expr : tupleExpr->get_exprs() ) {
    154                                 expr = reconstructMemberExpr( expr, aggr );
     157                                expr = reconstructMemberExpr( expr, aggr, memberExpr->location );
     158                                expr->location = memberExpr->location;
    155159                        }
    156160                        delete aggr;
     161                        tupleExpr->location = memberExpr->location;
    157162                        return tupleExpr;
    158163                } else {
    159164                        // there may be a tuple expr buried in the aggregate
    160165                        // xxx - this is a memory leak
    161                         return new UntypedMemberExpr( memberExpr->get_member()->clone(), memberExpr->get_aggregate()->acceptMutator( *this ) );
     166                        UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->get_member()->clone(), memberExpr->get_aggregate()->acceptMutator( *this ) );
     167                        newMemberExpr->location = memberExpr->location;
     168                        return newMemberExpr;
    162169                }
    163170        }
  • src/tests/.expect/memberCtors-ERR1.txt

    r1fbab5a r64ac636  
    1 error: in void ?{}(struct B *b), field a2 used before being constructed
     1memberCtors.c:62 error: in void ?{}(struct B *b), field a2 used before being constructed
    22make: *** [memberCtors-ERR1] Error 1
Note: See TracChangeset for help on using the changeset viewer.