Changes in src/ResolvExpr/Resolver.cc [6f326b1:2efe4b8]
- File:
-
- 1 edited
-
src/ResolvExpr/Resolver.cc (modified) (21 diffs)
Legend:
- Unmodified
- Added
- Removed
-
src/ResolvExpr/Resolver.cc
r6f326b1 r2efe4b8 22 22 #include "Alternative.h" // for Alternative, AltList 23 23 #include "AlternativeFinder.h" // for AlternativeFinder, resolveIn... 24 #include "Common/GC.h" // for new_generation, collect_young 24 25 #include "Common/PassVisitor.h" // for PassVisitor 25 26 #include "Common/SemanticError.h" // for SemanticError … … 59 60 void previsit( TypeDecl *typeDecl ); 60 61 void previsit( EnumDecl * enumDecl ); 61 void previsit( StaticAssertDecl * assertDecl );62 62 63 63 void previsit( ArrayType * at ); … … 139 139 castExpr->arg = nullptr; 140 140 std::swap( expr->env, castExpr->env ); 141 delete castExpr;142 141 } 143 142 } … … 148 147 void findUnfinishedKindExpression(Expression * untyped, Alternative & alt, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, bool adjust = false, bool prune = true, bool failFast = true) { 149 148 assertf( untyped, "expected a non-null expression." ); 149 150 auto guard = new_generation(); // set up GC generation for this top-level expression 151 150 152 TypeEnvironment env; 151 153 AlternativeFinder finder( indexer, env ); … … 175 177 findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) ); 176 178 if ( winners.size() == 0 ) { 177 SemanticError( untyped, toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: ") ); 179 SemanticError( untyped, toString( 180 "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), 181 "expression: ") ); 178 182 } else if ( winners.size() != 1 ) { 179 183 std::ostringstream stream; 180 stream << "Cannot choose between " << winners.size() << " alternatives for " << kindStr << (kindStr != "" ? " " : "") << "expression\n"; 184 stream << "Cannot choose between " << winners.size() << " alternatives for " 185 << kindStr << (kindStr != "" ? " " : "") << "expression\n"; 181 186 untyped->print( stream ); 182 187 stream << " Alternatives are:\n"; 183 188 printAlts( winners, stream, 1 ); 189 184 190 SemanticError( untyped->location, stream.str() ); 185 191 } … … 188 194 Alternative & choice = winners.front(); 189 195 if ( findDeletedExpr( choice.expr ) ) { 190 SemanticError( choice.expr, "Unique best alternative includes deleted identifier in " ); 196 trace( choice.expr ); 197 SemanticError( choice.expr, 198 "Unique best alternative includes deleted identifier in " ); 191 199 } 192 200 alt = std::move( choice ); 201 trace( alt ); 193 202 } 194 203 … … 199 208 findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, adjust, prune, failFast ); 200 209 finishExpr( choice.expr, choice.env, untyped->env ); 201 delete untyped;202 210 untyped = choice.expr; 203 211 choice.expr = nullptr; … … 222 230 assertf( expr, "expected a non-null expression." ); 223 231 224 static CastExpr untyped( nullptr ); // cast to void232 auto untyped = new CastExpr{ expr }; // cast to void 225 233 226 234 // set up and resolve expression cast to void 227 untyped.arg = expr;228 235 Alternative choice; 229 findUnfinishedKindExpression( &untyped, choice, indexer, "", standardAlternativeFilter, true );236 findUnfinishedKindExpression( untyped, choice, indexer, "", standardAlternativeFilter, true ); 230 237 CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( choice.expr ); 231 238 env = std::move( choice.env ); 232 239 233 240 // clean up resolved expression 234 Expression * ret = castExpr->arg; 235 castExpr->arg = nullptr; 236 237 // unlink the arg so that it isn't deleted twice at the end of the program 238 untyped.arg = nullptr; 239 return ret; 241 return castExpr->arg; 240 242 } 241 243 … … 245 247 Expression * newExpr = resolveInVoidContext( untyped, indexer, env ); 246 248 finishExpr( newExpr, env, untyped->env ); 247 delete untyped;248 249 untyped = newExpr; 249 250 } … … 364 365 } 365 366 366 void Resolver::previsit( StaticAssertDecl * assertDecl ) {367 findIntegralExpression( assertDecl->condition, indexer );368 }369 370 367 void Resolver::previsit( ExprStmt *exprStmt ) { 371 368 visit_children = false; … … 423 420 caseStmt->condition = castExpr->arg; 424 421 castExpr->arg = nullptr; 425 delete castExpr;426 422 } 427 423 } … … 490 486 ss << "' in call to waitfor"; 491 487 SemanticError( stmt->location, ss.str() ); 492 }493 494 if(clause.target.arguments.empty()) {495 SemanticError( stmt->location, "Waitfor clause must have at least one mutex parameter");496 488 } 497 489 … … 544 536 OpenVarSet openVars; 545 537 AssertionSet resultNeed, resultHave; 546 TypeEnvironment resultEnv( func.env ); 547 makeUnifiableVars( function, openVars, resultNeed ); 548 // add all type variables as open variables now so that those not used in the parameter 549 // list are still considered open. 550 resultEnv.add( function->forall ); 538 TypeEnvironment resultEnv; 551 539 552 540 // Load type variables from arguemnts into one shared space … … 564 552 auto param_end = function->parameters.end(); 565 553 566 int n_mutex_arg = 0;567 568 554 // For every arguments of its set, check if it matches one of the parameter 569 555 // The order is important … … 574 560 // We ran out of parameters but still have arguments 575 561 // this function doesn't match 576 SemanticError( function, toString("candidate function not viable: too many mutex arguments, expected ", n_mutex_arg, "\n" ));562 SemanticError( function, "candidate function not viable: too many mutex arguments\n" ); 577 563 } 578 564 579 n_mutex_arg++;580 581 565 // Check if the argument matches the parameter type in the current scope 582 if( ! unify( arg.expr->get_result(), (*param)->get_type(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) {566 if( ! unify( (*param)->get_type(), arg.expr->get_result(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) { 583 567 // Type doesn't match 584 568 stringstream ss; 585 569 ss << "candidate function not viable: no known convertion from '"; 570 arg.expr->get_result()->print( ss ); 571 ss << "' to '"; 586 572 (*param)->get_type()->print( ss ); 587 ss << "' to '";588 arg.expr->get_result()->print( ss );589 ss << "' with env '";590 resultEnv.print(ss);591 573 ss << "'\n"; 592 574 SemanticError( function, ss.str() ); … … 602 584 // We ran out of arguments but still have parameters left 603 585 // this function doesn't match 604 SemanticError( function, toString("candidate function not viable: too few mutex arguments, expected ", n_mutex_arg, "\n" ));586 SemanticError( function, "candidate function not viable: too few mutex arguments\n" ); 605 587 } 606 588 … … 719 701 std::swap( initExpr->env, newExpr->env ); 720 702 std::swap( initExpr->inferParams, newExpr->inferParams ) ; 721 delete initExpr;722 703 723 704 // get the actual object's type (may not exactly match what comes back from the resolver due to conversions) … … 737 718 ce->set_arg( nullptr ); 738 719 std::swap( ce->env, newExpr->env ); 739 delete ce;740 720 } 741 721 } … … 788 768 // could not find valid constructor, or found an intrinsic constructor 789 769 // fall back on C-style initializer 790 delete ctorInit->get_ctor(); 791 ctorInit->set_ctor( NULL ); 792 delete ctorInit->get_dtor(); 793 ctorInit->set_dtor( NULL ); 770 ctorInit->set_ctor( nullptr ); 771 ctorInit->set_dtor( nullptr ); 794 772 maybeAccept( ctorInit->get_init(), *visitor ); 795 773 } … … 817 795 818 796 // found a constructor - can get rid of C-style initializer 819 delete ctorInit->init;820 797 ctorInit->init = nullptr; 821 798 … … 824 801 // to clean up generated code. 825 802 if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->ctor ) ) { 826 delete ctorInit->ctor;827 803 ctorInit->ctor = nullptr; 828 804 } 829 805 830 806 if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->dtor ) ) { 831 delete ctorInit->dtor;832 807 ctorInit->dtor = nullptr; 833 808 }
Note:
See TracChangeset
for help on using the changeset viewer.
