source: src/ResolvExpr/Resolver.cc@ 5684736

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since 5684736 was 2b59f55, checked in by Aaron Moss <a3moss@…>, 6 years ago

More resolver porting
  • Property mode set to 100644
File size: 53.2 KB
RevLine 
[a32b204]1//
2// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
[71f4e4f]7// Resolver.cc --
[a32b204]8//
[d76c588]9// Author : Aaron B. Moss
[a32b204]10// Created On : Sun May 17 12:17:01 2015
[d76c588]11// Last Modified By : Aaron B. Moss
12// Last Modified On : Wed May 29 11:00:00 2019
13// Update Count : 241
[a32b204]14//
15
[e3e16bc]16#include <cassert> // for strict_dynamic_cast, assert
[ea6332d]17#include <memory> // for allocator, allocator_traits<...
18#include <tuple> // for get
[6d6e829]19#include <vector> // for vector
[ea6332d]20
21#include "Alternative.h" // for Alternative, AltList
22#include "AlternativeFinder.h" // for AlternativeFinder, resolveIn...
[99d4584]23#include "Candidate.hpp"
24#include "CandidateFinder.hpp"
[d76c588]25#include "CurrentObject.h" // for CurrentObject
26#include "RenameVars.h" // for RenameVars, global_renamer
27#include "Resolver.h"
28#include "ResolvMode.h" // for ResolvMode
29#include "typeops.h" // for extractResultType
30#include "Unify.h" // for unify
[4864a73]31#include "AST/Chain.hpp"
[2a8f0c1]32#include "AST/Decl.hpp"
33#include "AST/Init.hpp"
[d76c588]34#include "AST/Pass.hpp"
[99d4584]35#include "AST/Print.hpp"
[d76c588]36#include "AST/SymbolTable.hpp"
[a4ca48c]37#include "Common/PassVisitor.h" // for PassVisitor
[ea6332d]38#include "Common/SemanticError.h" // for SemanticError
39#include "Common/utility.h" // for ValueGuard, group_iterate
[0a60c04]40#include "InitTweak/GenInit.h"
[ea6332d]41#include "InitTweak/InitTweak.h" // for isIntrinsicSingleArgCallStmt
42#include "ResolvExpr/TypeEnvironment.h" // for TypeEnvironment
43#include "SymTab/Autogen.h" // for SizeType
44#include "SymTab/Indexer.h" // for Indexer
45#include "SynTree/Declaration.h" // for ObjectDecl, TypeDecl, Declar...
46#include "SynTree/Expression.h" // for Expression, CastExpr, InitExpr
47#include "SynTree/Initializer.h" // for ConstructorInit, SingleInit
48#include "SynTree/Statement.h" // for ForStmt, Statement, BranchStmt
49#include "SynTree/Type.h" // for Type, BasicType, PointerType
50#include "SynTree/TypeSubstitution.h" // for TypeSubstitution
51#include "SynTree/Visitor.h" // for acceptAll, maybeAccept
[0a60c04]52#include "Tuples/Tuples.h"
[2bfc6b2]53#include "Validate/FindSpecialDecls.h" // for SizeType
[51b73452]54
[d9a0e76]55using namespace std;
[51b73452]56
[d9a0e76]57namespace ResolvExpr {
[d76c588]58 struct Resolver_old final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver_old>, public WithShortCircuiting, public WithStmtsToAdd {
59 Resolver_old() {}
60 Resolver_old( const SymTab::Indexer & other ) {
[a4ca48c]61 indexer = other;
[1d2b64f]62 }
[71f4e4f]63
[5170d95]64 void previsit( FunctionDecl * functionDecl );
65 void postvisit( FunctionDecl * functionDecl );
66 void previsit( ObjectDecl * objectDecll );
[a4ca48c]67 void previsit( EnumDecl * enumDecl );
[bd87b138]68 void previsit( StaticAssertDecl * assertDecl );
[a4ca48c]69
70 void previsit( ArrayType * at );
71 void previsit( PointerType * at );
72
[5170d95]73 void previsit( ExprStmt * exprStmt );
74 void previsit( AsmExpr * asmExpr );
75 void previsit( AsmStmt * asmStmt );
76 void previsit( IfStmt * ifStmt );
77 void previsit( WhileStmt * whileStmt );
78 void previsit( ForStmt * forStmt );
79 void previsit( SwitchStmt * switchStmt );
80 void previsit( CaseStmt * caseStmt );
81 void previsit( BranchStmt * branchStmt );
82 void previsit( ReturnStmt * returnStmt );
83 void previsit( ThrowStmt * throwStmt );
84 void previsit( CatchStmt * catchStmt );
[695e00d]85 void previsit( WaitForStmt * stmt );
[a4ca48c]86
[5170d95]87 void previsit( SingleInit * singleInit );
88 void previsit( ListInit * listInit );
89 void previsit( ConstructorInit * ctorInit );
[a32b204]90 private:
[c28a038d]91 typedef std::list< Initializer * >::iterator InitIterator;
[94b4364]92
[40e636a]93 template< typename PtrType >
94 void handlePtrType( PtrType * type );
95
[c28a038d]96 void fallbackInit( ConstructorInit * ctorInit );
[b726084]97
[77971f6]98 Type * functionReturn = nullptr;
[e4d829b]99 CurrentObject currentObject = nullptr;
[a436947]100 bool inEnumDecl = false;
[a32b204]101 };
[d9a0e76]102
[2a6292d]103 struct ResolveWithExprs : public WithIndexer, public WithGuards, public WithVisitorRef<ResolveWithExprs>, public WithShortCircuiting, public WithStmtsToAdd {
104 void previsit( FunctionDecl * );
105 void previsit( WithStmt * );
106
107 void resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts );
108 };
109
[a32b204]110 void resolve( std::list< Declaration * > translationUnit ) {
[d76c588]111 PassVisitor<Resolver_old> resolver;
[a32b204]112 acceptAll( translationUnit, resolver );
[d9a0e76]113 }
114
[5170d95]115 void resolveDecl( Declaration * decl, const SymTab::Indexer & indexer ) {
[d76c588]116 PassVisitor<Resolver_old> resolver( indexer );
[8b11840]117 maybeAccept( decl, resolver );
118 }
119
[c71b256]120 namespace {
[99d4584]121 struct DeleteFinder_old : public WithShortCircuiting {
[c71b256]122 DeletedExpr * delExpr = nullptr;
123 void previsit( DeletedExpr * expr ) {
124 if ( delExpr ) visit_children = false;
125 else delExpr = expr;
126 }
127
128 void previsit( Expression * ) {
129 if ( delExpr ) visit_children = false;
130 }
131 };
132 }
133
134 DeletedExpr * findDeletedExpr( Expression * expr ) {
[99d4584]135 PassVisitor<DeleteFinder_old> finder;
[c71b256]136 expr->accept( finder );
137 return finder.pass.delExpr;
[d9a0e76]138 }
[a32b204]139
140 namespace {
[99d4584]141 struct StripCasts_old {
[cdb990a]142 Expression * postmutate( CastExpr * castExpr ) {
143 if ( castExpr->isGenerated && ResolvExpr::typesCompatible( castExpr->arg->result, castExpr->result, SymTab::Indexer() ) ) {
144 // generated cast is to the same type as its argument, so it's unnecessary -- remove it
145 Expression * expr = castExpr->arg;
146 castExpr->arg = nullptr;
147 std::swap( expr->env, castExpr->env );
148 return expr;
149 }
150 return castExpr;
151 }
152
153 static void strip( Expression *& expr ) {
[99d4584]154 PassVisitor<StripCasts_old> stripper;
[cdb990a]155 expr = expr->acceptMutator( stripper );
156 }
157 };
158
[5170d95]159 void finishExpr( Expression *& expr, const TypeEnvironment & env, TypeSubstitution * oldenv = nullptr ) {
[7664fad]160 expr->env = oldenv ? oldenv->clone() : new TypeSubstitution;
[cdb990a]161 env.makeSubstitution( *expr->env );
[99d4584]162 StripCasts_old::strip( expr ); // remove unnecessary casts that may be buried in an expression
[a32b204]163 }
[0a22cda]164
165 void removeExtraneousCast( Expression *& expr, const SymTab::Indexer & indexer ) {
166 if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
[b7d92b96]167 if ( typesCompatible( castExpr->arg->result, castExpr->result, indexer ) ) {
[0a22cda]168 // cast is to the same type as its argument, so it's unnecessary -- remove it
169 expr = castExpr->arg;
170 castExpr->arg = nullptr;
171 std::swap( expr->env, castExpr->env );
172 delete castExpr;
173 }
174 }
175 }
[db4ecc5]176 } // namespace
[a32b204]177
[8f98b78]178 namespace {
[59cf83b]179 void findUnfinishedKindExpression(Expression * untyped, Alternative & alt, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, ResolvMode mode = ResolvMode{} ) {
[c71b256]180 assertf( untyped, "expected a non-null expression." );
[6d6e829]181
182 // xxx - this isn't thread-safe, but should work until we parallelize the resolver
183 static unsigned recursion_level = 0;
184
185 ++recursion_level;
[8587878e]186 TypeEnvironment env;
187 AlternativeFinder finder( indexer, env );
[6d6e829]188 finder.find( untyped, recursion_level == 1 ? mode.atTopLevel() : mode );
189 --recursion_level;
[c71b256]190
191 #if 0
192 if ( finder.get_alternatives().size() != 1 ) {
193 std::cerr << "untyped expr is ";
194 untyped->print( std::cerr );
195 std::cerr << std::endl << "alternatives are:";
196 for ( const Alternative & alt : finder.get_alternatives() ) {
197 alt.print( std::cerr );
198 } // for
199 } // if
200 #endif
[8587878e]201
[6d6e829]202 // produce filtered list of alternatives
[8587878e]203 AltList candidates;
204 for ( Alternative & alt : finder.get_alternatives() ) {
[c71b256]205 if ( pred( alt ) ) {
[8587878e]206 candidates.push_back( std::move( alt ) );
207 }
208 }
209
[6d6e829]210 // produce invalid error if no candidates
211 if ( candidates.empty() ) {
[a16764a6]212 SemanticError( untyped, toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: ") );
[6d6e829]213 }
214
215 // search for cheapest candidate
216 AltList winners;
217 bool seen_undeleted = false;
218 for ( unsigned i = 0; i < candidates.size(); ++i ) {
219 int c = winners.empty() ? -1 : candidates[i].cost.compare( winners.front().cost );
220
221 if ( c > 0 ) continue; // skip more expensive than winner
222
223 if ( c < 0 ) {
224 // reset on new cheapest
225 seen_undeleted = ! findDeletedExpr( candidates[i].expr );
226 winners.clear();
227 } else /* if ( c == 0 ) */ {
228 if ( findDeletedExpr( candidates[i].expr ) ) {
229 // skip deleted expression if already seen one equivalent-cost not
230 if ( seen_undeleted ) continue;
231 } else if ( ! seen_undeleted ) {
232 // replace list of equivalent-cost deleted expressions with one non-deleted
233 winners.clear();
234 seen_undeleted = true;
235 }
236 }
237
[2fd9f24]238 winners.emplace_back( std::move( candidates[i] ) );
[6d6e829]239 }
240
241 // promote alternative.cvtCost to .cost
242 // xxx - I don't know why this is done, but I'm keeping the behaviour from findMinCost
243 for ( Alternative& winner : winners ) {
244 winner.cost = winner.cvtCost;
245 }
[cde3891]246
[6d6e829]247 // produce ambiguous errors, if applicable
248 if ( winners.size() != 1 ) {
[8587878e]249 std::ostringstream stream;
[c71b256]250 stream << "Cannot choose between " << winners.size() << " alternatives for " << kindStr << (kindStr != "" ? " " : "") << "expression\n";
[8587878e]251 untyped->print( stream );
[93401f8]252 stream << " Alternatives are:\n";
[8587878e]253 printAlts( winners, stream, 1 );
[a16764a6]254 SemanticError( untyped->location, stream.str() );
[8587878e]255 }
256
[6d6e829]257 // single selected choice
258 Alternative& choice = winners.front();
259
260 // fail on only expression deleted
261 if ( ! seen_undeleted ) {
[2a08c25]262 SemanticError( untyped->location, choice.expr, "Unique best alternative includes deleted identifier in " );
[c71b256]263 }
[6d6e829]264
265 // xxx - check for ambiguous expressions
[cde3891]266
[6d6e829]267 // output selected choice
[c71b256]268 alt = std::move( choice );
269 }
270
271 /// resolve `untyped` to the expression whose alternative satisfies `pred` with the lowest cost; kindStr is used for providing better error messages
[59cf83b]272 void findKindExpression(Expression *& untyped, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, ResolvMode mode = ResolvMode{}) {
[c71b256]273 if ( ! untyped ) return;
274 Alternative choice;
[59cf83b]275 findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, mode );
[c71b256]276 finishExpr( choice.expr, choice.env, untyped->env );
[8587878e]277 delete untyped;
[c71b256]278 untyped = choice.expr;
279 choice.expr = nullptr;
[8587878e]280 }
281
[c71b256]282 bool standardAlternativeFilter( const Alternative & ) {
283 // currently don't need to filter, under normal circumstances.
284 // in the future, this may be useful for removing deleted expressions
285 return true;
286 }
287 } // namespace
288
289 // used in resolveTypeof
[5170d95]290 Expression * resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer ) {
[c71b256]291 TypeEnvironment env;
292 return resolveInVoidContext( expr, indexer, env );
293 }
294
[5170d95]295 Expression * resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer, TypeEnvironment & env ) {
[c71b256]296 // it's a property of the language that a cast expression has either 1 or 0 interpretations; if it has 0
297 // interpretations, an exception has already been thrown.
298 assertf( expr, "expected a non-null expression." );
299
[5170d95]300 CastExpr * untyped = new CastExpr( expr ); // cast to void
301 untyped->location = expr->location;
[c71b256]302
303 // set up and resolve expression cast to void
304 Alternative choice;
[5170d95]305 findUnfinishedKindExpression( untyped, choice, indexer, "", standardAlternativeFilter, ResolvMode::withAdjustment() );
[c71b256]306 CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( choice.expr );
[5170d95]307 assert( castExpr );
[c71b256]308 env = std::move( choice.env );
309
310 // clean up resolved expression
311 Expression * ret = castExpr->arg;
312 castExpr->arg = nullptr;
313
314 // unlink the arg so that it isn't deleted twice at the end of the program
[5170d95]315 untyped->arg = nullptr;
[c71b256]316 return ret;
317 }
318
[5170d95]319 void findVoidExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
[c71b256]320 resetTyVarRenaming();
321 TypeEnvironment env;
322 Expression * newExpr = resolveInVoidContext( untyped, indexer, env );
323 finishExpr( newExpr, env, untyped->env );
324 delete untyped;
325 untyped = newExpr;
326 }
327
[5170d95]328 void findSingleExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
[c71b256]329 findKindExpression( untyped, indexer, "", standardAlternativeFilter );
330 }
331
332 void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer & indexer ) {
333 assert( untyped && type );
[2a08c25]334 // transfer location to generated cast for error purposes
335 CodeLocation location = untyped->location;
[c71b256]336 untyped = new CastExpr( untyped, type );
[2a08c25]337 untyped->location = location;
[c71b256]338 findSingleExpression( untyped, indexer );
339 removeExtraneousCast( untyped, indexer );
340 }
341
342 namespace {
343 bool isIntegralType( const Alternative & alt ) {
344 Type * type = alt.expr->result;
[a32b204]345 if ( dynamic_cast< EnumInstType * >( type ) ) {
346 return true;
[5170d95]347 } else if ( BasicType * bt = dynamic_cast< BasicType * >( type ) ) {
[a32b204]348 return bt->isInteger();
[89e6ffc]349 } else if ( dynamic_cast< ZeroType* >( type ) != nullptr || dynamic_cast< OneType* >( type ) != nullptr ) {
350 return true;
[a32b204]351 } else {
352 return false;
353 } // if
354 }
[71f4e4f]355
[5170d95]356 void findIntegralExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
[8587878e]357 findKindExpression( untyped, indexer, "condition", isIntegralType );
[a32b204]358 }
359 }
[71f4e4f]360
[2a6292d]361
362 bool isStructOrUnion( const Alternative & alt ) {
363 Type * t = alt.expr->result->stripReferences();
364 return dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t );
365 }
366
367 void resolveWithExprs( std::list< Declaration * > & translationUnit ) {
368 PassVisitor<ResolveWithExprs> resolver;
369 acceptAll( translationUnit, resolver );
370 }
371
372 void ResolveWithExprs::resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts ) {
373 for ( Expression *& expr : withExprs ) {
374 // only struct- and union-typed expressions are viable candidates
375 findKindExpression( expr, indexer, "with statement", isStructOrUnion );
376
377 // if with expression might be impure, create a temporary so that it is evaluated once
378 if ( Tuples::maybeImpure( expr ) ) {
379 static UniqueName tmpNamer( "_with_tmp_" );
380 ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), expr->result->clone(), new SingleInit( expr ) );
381 expr = new VariableExpr( tmp );
382 newStmts.push_back( new DeclStmt( tmp ) );
383 if ( InitTweak::isConstructable( tmp->type ) ) {
384 // generate ctor/dtor and resolve them
385 tmp->init = InitTweak::genCtorInit( tmp );
386 tmp->accept( *visitor );
387 }
388 }
389 }
390 }
391
392 void ResolveWithExprs::previsit( WithStmt * withStmt ) {
393 resolveWithExprs( withStmt->exprs, stmtsToAddBefore );
394 }
395
396 void ResolveWithExprs::previsit( FunctionDecl * functionDecl ) {
397 {
398 // resolve with-exprs with parameters in scope and add any newly generated declarations to the
399 // front of the function body.
400 auto guard = makeFuncGuard( [this]() { indexer.enterScope(); }, [this](){ indexer.leaveScope(); } );
401 indexer.addFunctionType( functionDecl->type );
402 std::list< Statement * > newStmts;
403 resolveWithExprs( functionDecl->withExprs, newStmts );
404 if ( functionDecl->statements ) {
405 functionDecl->statements->kids.splice( functionDecl->statements->kids.begin(), newStmts );
406 } else {
407 assertf( functionDecl->withExprs.empty() && newStmts.empty(), "Function %s without a body has with-clause and/or generated with declarations.", functionDecl->name.c_str() );
408 }
409 }
410 }
411
[d76c588]412 void Resolver_old::previsit( ObjectDecl * objectDecl ) {
[4864a73]413 // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that
414 // class-variable initContext is changed multiple time because the LHS is analysed twice.
415 // The second analysis changes initContext because of a function type can contain object
416 // declarations in the return and parameter types. So each value of initContext is
[6d6e829]417 // retained, so the type on the first analysis is preserved and used for selecting the RHS.
[a4ca48c]418 GuardValue( currentObject );
[e4d829b]419 currentObject = CurrentObject( objectDecl->get_type() );
420 if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
[a436947]421 // enumerator initializers should not use the enum type to initialize, since
422 // the enum type is still incomplete at this point. Use signed int instead.
[e4d829b]423 currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
[a436947]424 }
[bfbf97f]425 }
426
[40e636a]427 template< typename PtrType >
[d76c588]428 void Resolver_old::handlePtrType( PtrType * type ) {
[40e636a]429 if ( type->get_dimension() ) {
[2bfc6b2]430 findSingleExpression( type->dimension, Validate::SizeType->clone(), indexer );
[d1d17f5]431 }
[40e636a]432 }
433
[d76c588]434 void Resolver_old::previsit( ArrayType * at ) {
[40e636a]435 handlePtrType( at );
[a32b204]436 }
[94b4364]437
[d76c588]438 void Resolver_old::previsit( PointerType * pt ) {
[40e636a]439 handlePtrType( pt );
440 }
441
[d76c588]442 void Resolver_old::previsit( FunctionDecl * functionDecl ) {
[d9a0e76]443#if 0
[a4ca48c]444 std::cerr << "resolver visiting functiondecl ";
445 functionDecl->print( std::cerr );
446 std::cerr << std::endl;
[d9a0e76]447#endif
[a4ca48c]448 GuardValue( functionReturn );
[60914351]449 functionReturn = ResolvExpr::extractResultType( functionDecl->type );
[a4ca48c]450 }
[88d1066]451
[d76c588]452 void Resolver_old::postvisit( FunctionDecl * functionDecl ) {
[4864a73]453 // default value expressions have an environment which shouldn't be there and trips up
[6d6e829]454 // later passes.
[cde3891]455 // xxx - it might be necessary to somehow keep the information from this environment, but I
[6d6e829]456 // can't currently see how it's useful.
[c28a038d]457 for ( Declaration * d : functionDecl->type->parameters ) {
[88d1066]458 if ( ObjectDecl * obj = dynamic_cast< ObjectDecl * >( d ) ) {
[c28a038d]459 if ( SingleInit * init = dynamic_cast< SingleInit * >( obj->init ) ) {
460 delete init->value->env;
461 init->value->env = nullptr;
[88d1066]462 }
463 }
464 }
[a32b204]465 }
[51b73452]466
[d76c588]467 void Resolver_old::previsit( EnumDecl * ) {
[a436947]468 // in case we decide to allow nested enums
[a4ca48c]469 GuardValue( inEnumDecl );
[a436947]470 inEnumDecl = true;
471 }
472
[d76c588]473 void Resolver_old::previsit( StaticAssertDecl * assertDecl ) {
[bd87b138]474 findIntegralExpression( assertDecl->condition, indexer );
475 }
476
[d76c588]477 void Resolver_old::previsit( ExprStmt * exprStmt ) {
[a4ca48c]478 visit_children = false;
[08da53d]479 assertf( exprStmt->expr, "ExprStmt has null Expression in resolver" );
480 findVoidExpression( exprStmt->expr, indexer );
[a32b204]481 }
[51b73452]482
[d76c588]483 void Resolver_old::previsit( AsmExpr * asmExpr ) {
[a4ca48c]484 visit_children = false;
[08da53d]485 findVoidExpression( asmExpr->operand, indexer );
[7f5566b]486 if ( asmExpr->get_inout() ) {
[08da53d]487 findVoidExpression( asmExpr->inout, indexer );
[7f5566b]488 } // if
489 }
490
[d76c588]491 void Resolver_old::previsit( AsmStmt * asmStmt ) {
[a4ca48c]492 visit_children = false;
493 acceptAll( asmStmt->get_input(), *visitor );
494 acceptAll( asmStmt->get_output(), *visitor );
[7f5566b]495 }
496
[d76c588]497 void Resolver_old::previsit( IfStmt * ifStmt ) {
[8587878e]498 findIntegralExpression( ifStmt->condition, indexer );
[a32b204]499 }
[51b73452]500
[d76c588]501 void Resolver_old::previsit( WhileStmt * whileStmt ) {
[8587878e]502 findIntegralExpression( whileStmt->condition, indexer );
[a32b204]503 }
[51b73452]504
[d76c588]505 void Resolver_old::previsit( ForStmt * forStmt ) {
[08da53d]506 if ( forStmt->condition ) {
[8587878e]507 findIntegralExpression( forStmt->condition, indexer );
[a32b204]508 } // if
[71f4e4f]509
[08da53d]510 if ( forStmt->increment ) {
511 findVoidExpression( forStmt->increment, indexer );
[a32b204]512 } // if
513 }
[51b73452]514
[d76c588]515 void Resolver_old::previsit( SwitchStmt * switchStmt ) {
[a4ca48c]516 GuardValue( currentObject );
[08da53d]517 findIntegralExpression( switchStmt->condition, indexer );
[71f4e4f]518
[08da53d]519 currentObject = CurrentObject( switchStmt->condition->result );
[a32b204]520 }
[51b73452]521
[d76c588]522 void Resolver_old::previsit( CaseStmt * caseStmt ) {
[cdb990a]523 if ( caseStmt->condition ) {
[e4d829b]524 std::list< InitAlternative > initAlts = currentObject.getOptions();
525 assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
[08da53d]526 // must remove cast from case statement because RangeExpr cannot be cast.
527 Expression * newExpr = new CastExpr( caseStmt->condition, initAlts.front().type->clone() );
528 findSingleExpression( newExpr, indexer );
[cdb990a]529 // case condition cannot have a cast in C, so it must be removed, regardless of whether it performs a conversion.
530 // Ideally we would perform the conversion internally here.
531 if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( newExpr ) ) {
532 newExpr = castExpr->arg;
533 castExpr->arg = nullptr;
534 std::swap( newExpr->env, castExpr->env );
535 delete castExpr;
536 }
537 caseStmt->condition = newExpr;
[32b8144]538 }
[a32b204]539 }
[51b73452]540
[d76c588]541 void Resolver_old::previsit( BranchStmt * branchStmt ) {
[a4ca48c]542 visit_children = false;
[de62360d]543 // must resolve the argument for a computed goto
544 if ( branchStmt->get_type() == BranchStmt::Goto ) { // check for computed goto statement
[08da53d]545 if ( branchStmt->computedTarget ) {
546 // computed goto argument is void *
547 findSingleExpression( branchStmt->computedTarget, new PointerType( Type::Qualifiers(), new VoidType( Type::Qualifiers() ) ), indexer );
[de62360d]548 } // if
549 } // if
550 }
551
[d76c588]552 void Resolver_old::previsit( ReturnStmt * returnStmt ) {
[a4ca48c]553 visit_children = false;
[08da53d]554 if ( returnStmt->expr ) {
555 findSingleExpression( returnStmt->expr, functionReturn->clone(), indexer );
[a32b204]556 } // if
557 }
[51b73452]558
[d76c588]559 void Resolver_old::previsit( ThrowStmt * throwStmt ) {
[a4ca48c]560 visit_children = false;
[cbce272]561 // TODO: Replace *exception type with &exception type.
[307a732]562 if ( throwStmt->get_expr() ) {
[cbce272]563 StructDecl * exception_decl =
[36982fc]564 indexer.lookupStruct( "__cfaabi_ehm__base_exception_t" );
[cbce272]565 assert( exception_decl );
[08da53d]566 Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, exception_decl ) );
567 findSingleExpression( throwStmt->expr, exceptType, indexer );
[307a732]568 }
569 }
570
[d76c588]571 void Resolver_old::previsit( CatchStmt * catchStmt ) {
[08da53d]572 if ( catchStmt->cond ) {
[e15853c]573 findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer );
[cbce272]574 }
575 }
576
[1dcd9554]577 template< typename iterator_t >
578 inline bool advance_to_mutex( iterator_t & it, const iterator_t & end ) {
579 while( it != end && !(*it)->get_type()->get_mutex() ) {
580 it++;
581 }
582
583 return it != end;
584 }
585
[d76c588]586 void Resolver_old::previsit( WaitForStmt * stmt ) {
[8f98b78]587 visit_children = false;
[1dcd9554]588
589 // Resolve all clauses first
590 for( auto& clause : stmt->clauses ) {
591
592 TypeEnvironment env;
[8f98b78]593 AlternativeFinder funcFinder( indexer, env );
[1dcd9554]594
595 // Find all alternatives for a function in canonical form
596 funcFinder.findWithAdjustment( clause.target.function );
597
598 if ( funcFinder.get_alternatives().empty() ) {
599 stringstream ss;
600 ss << "Use of undeclared indentifier '";
601 ss << strict_dynamic_cast<NameExpr*>( clause.target.function )->name;
602 ss << "' in call to waitfor";
[a16764a6]603 SemanticError( stmt->location, ss.str() );
[1dcd9554]604 }
605
[b9f383f]606 if(clause.target.arguments.empty()) {
607 SemanticError( stmt->location, "Waitfor clause must have at least one mutex parameter");
608 }
609
[1dcd9554]610 // Find all alternatives for all arguments in canonical form
[bd4f2e9]611 std::vector< AlternativeFinder > argAlternatives;
[1dcd9554]612 funcFinder.findSubExprs( clause.target.arguments.begin(), clause.target.arguments.end(), back_inserter( argAlternatives ) );
613
614 // List all combinations of arguments
[bd4f2e9]615 std::vector< AltList > possibilities;
[1dcd9554]616 combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
617
618 AltList func_candidates;
619 std::vector< AltList > args_candidates;
620
621 // For every possible function :
622 // try matching the arguments to the parameters
623 // not the other way around because we have more arguments than parameters
[a16764a6]624 SemanticErrorException errors;
[1dcd9554]625 for ( Alternative & func : funcFinder.get_alternatives() ) {
626 try {
627 PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() );
628 if( !pointer ) {
[a16764a6]629 SemanticError( func.expr->get_result(), "candidate not viable: not a pointer type\n" );
[1dcd9554]630 }
631
632 FunctionType * function = dynamic_cast< FunctionType* >( pointer->get_base() );
633 if( !function ) {
[a16764a6]634 SemanticError( pointer->get_base(), "candidate not viable: not a function type\n" );
[1dcd9554]635 }
636
637
638 {
639 auto param = function->parameters.begin();
640 auto param_end = function->parameters.end();
641
642 if( !advance_to_mutex( param, param_end ) ) {
[a16764a6]643 SemanticError(function, "candidate function not viable: no mutex parameters\n");
[1dcd9554]644 }
645 }
646
647 Alternative newFunc( func );
648 // Strip reference from function
[a181494]649 referenceToRvalueConversion( newFunc.expr, newFunc.cost );
[1dcd9554]650
651 // For all the set of arguments we have try to match it with the parameter of the current function alternative
652 for ( auto & argsList : possibilities ) {
653
654 try {
655 // Declare data structures need for resolution
656 OpenVarSet openVars;
657 AssertionSet resultNeed, resultHave;
[6f326b1]658 TypeEnvironment resultEnv( func.env );
659 makeUnifiableVars( function, openVars, resultNeed );
660 // add all type variables as open variables now so that those not used in the parameter
661 // list are still considered open.
662 resultEnv.add( function->forall );
[1dcd9554]663
664 // Load type variables from arguemnts into one shared space
665 simpleCombineEnvironments( argsList.begin(), argsList.end(), resultEnv );
666
667 // Make sure we don't widen any existing bindings
[d286cf68]668 resultEnv.forbidWidening();
[c5283ba]669
[1dcd9554]670 // Find any unbound type variables
671 resultEnv.extractOpenVars( openVars );
672
673 auto param = function->parameters.begin();
674 auto param_end = function->parameters.end();
675
[c5283ba]676 int n_mutex_param = 0;
[b9f383f]677
[1dcd9554]678 // For every arguments of its set, check if it matches one of the parameter
679 // The order is important
680 for( auto & arg : argsList ) {
681
682 // Ignore non-mutex arguments
683 if( !advance_to_mutex( param, param_end ) ) {
684 // We ran out of parameters but still have arguments
685 // this function doesn't match
[c5283ba]686 SemanticError( function, toString("candidate function not viable: too many mutex arguments, expected ", n_mutex_param, "\n" ));
[1dcd9554]687 }
688
[c5283ba]689 n_mutex_param++;
[b9f383f]690
[1dcd9554]691 // Check if the argument matches the parameter type in the current scope
[b9f383f]692 if( ! unify( arg.expr->get_result(), (*param)->get_type(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) {
[1dcd9554]693 // Type doesn't match
694 stringstream ss;
695 ss << "candidate function not viable: no known convertion from '";
696 (*param)->get_type()->print( ss );
[b9f383f]697 ss << "' to '";
698 arg.expr->get_result()->print( ss );
[5248789]699 ss << "' with env '";
700 resultEnv.print(ss);
[1dcd9554]701 ss << "'\n";
[a16764a6]702 SemanticError( function, ss.str() );
[1dcd9554]703 }
704
705 param++;
706 }
707
708 // All arguments match !
709
710 // Check if parameters are missing
711 if( advance_to_mutex( param, param_end ) ) {
[c5283ba]712 do {
713 n_mutex_param++;
714 param++;
715 } while( advance_to_mutex( param, param_end ) );
716
[1dcd9554]717 // We ran out of arguments but still have parameters left
718 // this function doesn't match
[c5283ba]719 SemanticError( function, toString("candidate function not viable: too few mutex arguments, expected ", n_mutex_param, "\n" ));
[1dcd9554]720 }
721
722 // All parameters match !
723
724 // Finish the expressions to tie in the proper environments
725 finishExpr( newFunc.expr, resultEnv );
726 for( Alternative & alt : argsList ) {
727 finishExpr( alt.expr, resultEnv );
728 }
729
730 // This is a match store it and save it for later
731 func_candidates.push_back( newFunc );
732 args_candidates.push_back( argsList );
733
734 }
[5170d95]735 catch( SemanticErrorException & e ) {
[1dcd9554]736 errors.append( e );
737 }
738 }
739 }
[5170d95]740 catch( SemanticErrorException & e ) {
[1dcd9554]741 errors.append( e );
742 }
743 }
744
745 // Make sure we got the right number of arguments
[a16764a6]746 if( func_candidates.empty() ) { SemanticErrorException top( stmt->location, "No alternatives for function in call to waitfor" ); top.append( errors ); throw top; }
747 if( args_candidates.empty() ) { SemanticErrorException top( stmt->location, "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
748 if( func_candidates.size() > 1 ) { SemanticErrorException top( stmt->location, "Ambiguous function in call to waitfor" ); top.append( errors ); throw top; }
749 if( args_candidates.size() > 1 ) { SemanticErrorException top( stmt->location, "Ambiguous arguments in call to waitfor" ); top.append( errors ); throw top; }
[c71b256]750 // TODO: need to use findDeletedExpr to ensure no deleted identifiers are used.
[1dcd9554]751
752 // Swap the results from the alternative with the unresolved values.
753 // Alternatives will handle deletion on destruction
754 std::swap( clause.target.function, func_candidates.front().expr );
755 for( auto arg_pair : group_iterate( clause.target.arguments, args_candidates.front() ) ) {
756 std::swap ( std::get<0>( arg_pair), std::get<1>( arg_pair).expr );
757 }
758
759 // Resolve the conditions as if it were an IfStmt
760 // Resolve the statments normally
[08da53d]761 findSingleExpression( clause.condition, this->indexer );
[8f98b78]762 clause.statement->accept( *visitor );
[1dcd9554]763 }
764
765
766 if( stmt->timeout.statement ) {
767 // Resolve the timeout as an size_t for now
768 // Resolve the conditions as if it were an IfStmt
769 // Resolve the statments normally
[08da53d]770 findSingleExpression( stmt->timeout.time, new BasicType( noQualifiers, BasicType::LongLongUnsignedInt ), this->indexer );
771 findSingleExpression( stmt->timeout.condition, this->indexer );
[8f98b78]772 stmt->timeout.statement->accept( *visitor );
[1dcd9554]773 }
774
775 if( stmt->orelse.statement ) {
776 // Resolve the conditions as if it were an IfStmt
777 // Resolve the statments normally
[08da53d]778 findSingleExpression( stmt->orelse.condition, this->indexer );
[8f98b78]779 stmt->orelse.statement->accept( *visitor );
[1dcd9554]780 }
781 }
782
[b5c5684]783 template< typename T >
784 bool isCharType( T t ) {
785 if ( BasicType * bt = dynamic_cast< BasicType * >( t ) ) {
[71f4e4f]786 return bt->get_kind() == BasicType::Char || bt->get_kind() == BasicType::SignedChar ||
[b5c5684]787 bt->get_kind() == BasicType::UnsignedChar;
788 }
789 return false;
790 }
791
[d76c588]792 void Resolver_old::previsit( SingleInit * singleInit ) {
[a4ca48c]793 visit_children = false;
[62423350]794 // resolve initialization using the possibilities as determined by the currentObject cursor
[0a22cda]795 Expression * newExpr = new UntypedInitExpr( singleInit->value, currentObject.getOptions() );
[08da53d]796 findSingleExpression( newExpr, indexer );
[e3e16bc]797 InitExpr * initExpr = strict_dynamic_cast< InitExpr * >( newExpr );
[62423350]798
799 // move cursor to the object that is actually initialized
[e4d829b]800 currentObject.setNext( initExpr->get_designation() );
[62423350]801
802 // discard InitExpr wrapper and retain relevant pieces
[08da53d]803 newExpr = initExpr->expr;
804 initExpr->expr = nullptr;
805 std::swap( initExpr->env, newExpr->env );
[cde3891]806 // InitExpr may have inferParams in the case where the expression specializes a function
807 // pointer, and newExpr may already have inferParams of its own, so a simple swap is not
[6d6e829]808 // sufficient.
[cdb990a]809 newExpr->spliceInferParams( initExpr );
[e4d829b]810 delete initExpr;
811
[cde3891]812 // get the actual object's type (may not exactly match what comes back from the resolver
[6d6e829]813 // due to conversions)
[62423350]814 Type * initContext = currentObject.getCurrentType();
815
[0a22cda]816 removeExtraneousCast( newExpr, indexer );
817
[62423350]818 // check if actual object's type is char[]
819 if ( ArrayType * at = dynamic_cast< ArrayType * >( initContext ) ) {
820 if ( isCharType( at->get_base() ) ) {
821 // check if the resolved type is char *
822 if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
823 if ( isCharType( pt->get_base() ) ) {
[5170d95]824 if ( CastExpr * ce = dynamic_cast< CastExpr * >( newExpr ) ) {
[cde3891]825 // strip cast if we're initializing a char[] with a char *,
[6d6e829]826 // e.g. char x[] = "hello";
[0a22cda]827 newExpr = ce->get_arg();
828 ce->set_arg( nullptr );
829 std::swap( ce->env, newExpr->env );
830 delete ce;
831 }
[62423350]832 }
833 }
834 }
835 }
[94b4364]836
[62423350]837 // set initializer expr to resolved express
[0a22cda]838 singleInit->value = newExpr;
[62423350]839
840 // move cursor to next object in preparation for next initializer
841 currentObject.increment();
842 }
[94b4364]843
[d76c588]844 void Resolver_old::previsit( ListInit * listInit ) {
[a4ca48c]845 visit_children = false;
[62423350]846 // move cursor into brace-enclosed initializer-list
[e4d829b]847 currentObject.enterListInit();
[cde3891]848 // xxx - fix this so that the list isn't copied, iterator should be used to change current
[6d6e829]849 // element
[e4d829b]850 std::list<Designation *> newDesignations;
851 for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) {
[cde3891]852 // iterate designations and initializers in pairs, moving the cursor to the current
[6d6e829]853 // designated object and resolving the initializer against that object.
[e4d829b]854 Designation * des = std::get<0>(p);
855 Initializer * init = std::get<1>(p);
856 newDesignations.push_back( currentObject.findNext( des ) );
[a4ca48c]857 init->accept( *visitor );
[b5c5684]858 }
[62423350]859 // set the set of 'resolved' designations and leave the brace-enclosed initializer-list
[e4d829b]860 listInit->get_designations() = newDesignations; // xxx - memory management
861 currentObject.exitListInit();
862
[62423350]863 // xxx - this part has not be folded into CurrentObject yet
[e4d829b]864 // } else if ( TypeInstType * tt = dynamic_cast< TypeInstType * >( initContext ) ) {
865 // Type * base = tt->get_baseType()->get_base();
866 // if ( base ) {
867 // // know the implementation type, so try using that as the initContext
868 // ObjectDecl tmpObj( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, base->clone(), nullptr );
869 // currentObject = &tmpObj;
870 // visit( listInit );
871 // } else {
872 // // missing implementation type -- might be an unknown type variable, so try proceeding with the current init context
873 // Parent::visit( listInit );
874 // }
875 // } else {
[a32b204]876 }
[71f4e4f]877
[f1e012b]878 // ConstructorInit - fall back on C-style initializer
[d76c588]879 void Resolver_old::fallbackInit( ConstructorInit * ctorInit ) {
[f1e012b]880 // could not find valid constructor, or found an intrinsic constructor
881 // fall back on C-style initializer
882 delete ctorInit->get_ctor();
[6d6e829]883 ctorInit->set_ctor( nullptr );
[71a145de]884 delete ctorInit->get_dtor();
[6d6e829]885 ctorInit->set_dtor( nullptr );
[a4ca48c]886 maybeAccept( ctorInit->get_init(), *visitor );
[f1e012b]887 }
888
[1d2b64f]889 // needs to be callable from outside the resolver, so this is a standalone function
890 void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ) {
891 assert( ctorInit );
[d76c588]892 PassVisitor<Resolver_old> resolver( indexer );
[1d2b64f]893 ctorInit->accept( resolver );
894 }
895
896 void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ) {
897 assert( stmtExpr );
[d76c588]898 PassVisitor<Resolver_old> resolver( indexer );
[1d2b64f]899 stmtExpr->accept( resolver );
[5e2c348]900 stmtExpr->computeResult();
[dd05e12]901 // xxx - aggregate the environments from all statements? Possibly in AlternativeFinder instead?
[1d2b64f]902 }
903
[d76c588]904 void Resolver_old::previsit( ConstructorInit * ctorInit ) {
[a4ca48c]905 visit_children = false;
[1ba88a0]906 // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit
[dd05e12]907 maybeAccept( ctorInit->ctor, *visitor );
908 maybeAccept( ctorInit->dtor, *visitor );
[071a31a]909
[5b2f5bb]910 // found a constructor - can get rid of C-style initializer
[dd05e12]911 delete ctorInit->init;
912 ctorInit->init = nullptr;
[ec79847]913
914 // intrinsic single parameter constructors and destructors do nothing. Since this was
915 // implicitly generated, there's no way for it to have side effects, so get rid of it
916 // to clean up generated code.
[dd05e12]917 if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->ctor ) ) {
918 delete ctorInit->ctor;
919 ctorInit->ctor = nullptr;
[ec79847]920 }
[f9cebb5]921
[dd05e12]922 if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->dtor ) ) {
923 delete ctorInit->dtor;
924 ctorInit->dtor = nullptr;
[ec79847]925 }
[a465caff]926
927 // xxx - todo -- what about arrays?
[6d6e829]928 // if ( dtor == nullptr && InitTweak::isIntrinsicCallStmt( ctorInit->get_ctor() ) ) {
[a465caff]929 // // can reduce the constructor down to a SingleInit using the
930 // // second argument from the ctor call, since
931 // delete ctorInit->get_ctor();
[6d6e829]932 // ctorInit->set_ctor( nullptr );
[a465caff]933
934 // Expression * arg =
935 // ctorInit->set_init( new SingleInit( arg ) );
936 // }
[71f4e4f]937 }
[d76c588]938
939 ///////////////////////////////////////////////////////////////////////////
940 //
941 // *** NEW RESOLVER ***
942 //
943 ///////////////////////////////////////////////////////////////////////////
944
[99d4584]945 namespace {
946 /// Finds deleted expressions in an expression tree
947 struct DeleteFinder_new final : public ast::WithShortCircuiting {
948 const ast::DeletedExpr * delExpr = nullptr;
949
950 void previsit( const ast::DeletedExpr * expr ) {
951 if ( delExpr ) { visit_children = false; }
952 else { delExpr = expr; }
953 }
954
955 void previsit( const ast::Expr * ) {
956 if ( delExpr ) { visit_children = false; }
957 }
958 };
959
960 /// Check if this expression is or includes a deleted expression
961 const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr ) {
962 ast::Pass<DeleteFinder_new> finder;
963 expr->accept( finder );
964 return finder.pass.delExpr;
965 }
966
[b7d92b96]967 /// always-accept candidate filter
968 bool anyCandidate( const Candidate & ) { return true; }
969
[99d4584]970 /// Calls the CandidateFinder and finds the single best candidate
971 CandidateRef findUnfinishedKindExpression(
972 const ast::Expr * untyped, const ast::SymbolTable & symtab, const std::string & kind,
[b7d92b96]973 std::function<bool(const Candidate &)> pred = anyCandidate, ResolvMode mode = {}
[99d4584]974 ) {
975 if ( ! untyped ) return nullptr;
976
977 // xxx - this isn't thread-safe, but should work until we parallelize the resolver
978 static unsigned recursion_level = 0;
979
980 ++recursion_level;
981 ast::TypeEnvironment env;
982 CandidateFinder finder{ symtab, env };
983 finder.find( untyped, recursion_level == 1 ? mode.atTopLevel() : mode );
984 --recursion_level;
985
986 // produce a filtered list of candidates
987 CandidateList candidates;
988 for ( auto & cand : finder.candidates ) {
989 if ( pred( *cand ) ) { candidates.emplace_back( cand ); }
990 }
991
992 // produce invalid error if no candidates
993 if ( candidates.empty() ) {
994 SemanticError( untyped,
995 toString( "No reasonable alternatives for ", kind, (kind != "" ? " " : ""),
996 "expression: ") );
997 }
998
999 // search for cheapest candidate
1000 CandidateList winners;
1001 bool seen_undeleted = false;
1002 for ( CandidateRef & cand : candidates ) {
1003 int c = winners.empty() ? -1 : cand->cost.compare( winners.front()->cost );
1004
1005 if ( c > 0 ) continue; // skip more expensive than winner
1006
1007 if ( c < 0 ) {
1008 // reset on new cheapest
1009 seen_undeleted = ! findDeletedExpr( cand->expr );
1010 winners.clear();
1011 } else /* if ( c == 0 ) */ {
1012 if ( findDeletedExpr( cand->expr ) ) {
1013 // skip deleted expression if already seen one equivalent-cost not
1014 if ( seen_undeleted ) continue;
1015 } else if ( ! seen_undeleted ) {
1016 // replace list of equivalent-cost deleted expressions with one non-deleted
1017 winners.clear();
1018 seen_undeleted = true;
1019 }
1020 }
1021
1022 winners.emplace_back( std::move( cand ) );
1023 }
1024
1025 // promote candidate.cvtCost to .cost
1026 for ( CandidateRef & cand : winners ) {
1027 cand->cost = cand->cvtCost;
1028 }
1029
1030 // produce ambiguous errors, if applicable
1031 if ( winners.size() != 1 ) {
1032 std::ostringstream stream;
1033 stream << "Cannot choose between " << winners.size() << " alternatives for "
1034 << kind << (kind != "" ? " " : "") << "expression\n";
1035 ast::print( stream, untyped );
1036 stream << " Alternatives are:\n";
1037 print( stream, winners, 1 );
1038 SemanticError( untyped->location, stream.str() );
1039 }
1040
1041 // single selected choice
1042 CandidateRef & choice = winners.front();
1043
1044 // fail on only expression deleted
1045 if ( ! seen_undeleted ) {
1046 SemanticError( untyped->location, choice->expr.get(), "Unique best alternative "
1047 "includes deleted identifier in " );
1048 }
1049
1050 return std::move( choice );
1051 }
1052
1053 /// Strips extraneous casts out of an expression
1054 struct StripCasts_new final {
1055 const ast::Expr * postmutate( const ast::CastExpr * castExpr ) {
1056 if (
1057 castExpr->isGenerated
1058 && typesCompatible( castExpr->arg->result, castExpr->result )
1059 ) {
1060 // generated cast is the same type as its argument, remove it after keeping env
[b7d92b96]1061 return ast::mutate_field(
1062 castExpr->arg.get(), &ast::Expr::env, castExpr->env );
[99d4584]1063 }
1064 return castExpr;
1065 }
1066
1067 static void strip( ast::ptr< ast::Expr > & expr ) {
1068 ast::Pass< StripCasts_new > stripper;
1069 expr = expr->accept( stripper );
1070 }
1071 };
1072
[b7d92b96]1073 /// Removes cast to type of argument (unlike StripCasts, also handles non-generated casts)
1074 void removeExtraneousCast( ast::ptr<ast::Expr> & expr, const ast::SymbolTable & symtab ) {
1075 if ( const ast::CastExpr * castExpr = expr.as< ast::CastExpr >() ) {
1076 if ( typesCompatible( castExpr->arg->result, castExpr->result, symtab ) ) {
1077 // cast is to the same type as its argument, remove it
1078 ast::ptr< ast::TypeSubstitution > env = castExpr->env;
1079 expr.set_and_mutate( castExpr->arg )->env = env;
1080 }
1081 }
1082 }
1083
[99d4584]1084 /// Establish post-resolver invariants for expressions
1085 void finishExpr(
1086 ast::ptr< ast::Expr > & expr, const ast::TypeEnvironment & env,
1087 const ast::TypeSubstitution * oldenv = nullptr
1088 ) {
1089 // set up new type substitution for expression
1090 ast::ptr< ast::TypeSubstitution > newenv =
1091 oldenv ? oldenv : new ast::TypeSubstitution{};
1092 env.writeToSubstitution( *newenv.get_and_mutate() );
1093 expr.get_and_mutate()->env = std::move( newenv );
1094 // remove unncecessary casts
1095 StripCasts_new::strip( expr );
1096 }
[b7d92b96]1097
1098 /// Find the expression candidate that is the unique best match for `untyped` in a `void`
1099 /// context.
1100 ast::ptr< ast::Expr > resolveInVoidContext(
1101 const ast::Expr * expr, const ast::SymbolTable & symtab, ast::TypeEnvironment & env
1102 ) {
1103 assertf( expr, "expected a non-null expression" );
1104
1105 // set up and resolve expression cast to void
1106 ast::CastExpr * untyped = new ast::CastExpr{ expr->location, expr };
1107 CandidateRef choice = findUnfinishedKindExpression(
1108 untyped, symtab, "", anyCandidate, ResolvMode::withAdjustment() );
1109
1110 // a cast expression has either 0 or 1 interpretations (by language rules);
1111 // if 0, an exception has already been thrown, and this code will not run
1112 const ast::CastExpr * castExpr = choice->expr.strict_as< ast::CastExpr >();
1113 env = std::move( choice->env );
1114
1115 return castExpr->arg;
1116 }
1117
1118 /// Resolve `untyped` to the expression whose candidate is the best match for a `void`
1119 /// context.
1120 ast::ptr< ast::Expr > findVoidExpression(
1121 const ast::Expr * untyped, const ast::SymbolTable & symtab
1122 ) {
1123 resetTyVarRenaming();
1124 ast::TypeEnvironment env;
1125 ast::ptr< ast::Expr > newExpr = resolveInVoidContext( untyped, symtab, env );
1126 finishExpr( newExpr, env, untyped->env );
1127 return newExpr;
1128 }
1129
[99d4584]1130 /// resolve `untyped` to the expression whose candidate satisfies `pred` with the
1131 /// lowest cost, returning the resolved version
1132 ast::ptr< ast::Expr > findKindExpression(
[2b59f55]1133 const ast::Expr * untyped, const ast::SymbolTable & symtab,
1134 std::function<bool(const Candidate &)> pred = anyCandidate,
1135 const std::string & kind = "", ResolvMode mode = {}
[99d4584]1136 ) {
1137 if ( ! untyped ) return {};
1138 CandidateRef choice =
1139 findUnfinishedKindExpression( untyped, symtab, kind, pred, mode );
1140 finishExpr( choice->expr, choice->env, untyped->env );
1141 return std::move( choice->expr );
1142 }
1143
[b7d92b96]1144 /// Resolve `untyped` to the single expression whose candidate is the best match for the
1145 /// given type.
1146 ast::ptr< ast::Expr > findSingleExpression(
1147 const ast::Expr * untyped, const ast::Type * type, const ast::SymbolTable & symtab
1148 ) {
1149 assert( untyped && type );
1150 const ast::Expr * castExpr = new ast::CastExpr{ untyped->location, untyped, type };
[2b59f55]1151 ast::ptr< ast::Expr > newExpr = findKindExpression( castExpr, symtab );
[b7d92b96]1152 removeExtraneousCast( newExpr, symtab );
1153 return newExpr;
1154 }
1155
[99d4584]1156 /// Predicate for "Candidate has integral type"
1157 bool hasIntegralType( const Candidate & i ) {
1158 const ast::Type * type = i.expr->result;
1159
1160 if ( auto bt = dynamic_cast< const ast::BasicType * >( type ) ) {
1161 return bt->isInteger();
1162 } else if (
1163 dynamic_cast< const ast::EnumInstType * >( type )
1164 || dynamic_cast< const ast::ZeroType * >( type )
1165 || dynamic_cast< const ast::OneType * >( type )
1166 ) {
1167 return true;
1168 } else return false;
1169 }
1170
1171 /// Resolve `untyped` as an integral expression, returning the resolved version
1172 ast::ptr< ast::Expr > findIntegralExpression(
1173 const ast::Expr * untyped, const ast::SymbolTable & symtab
1174 ) {
[2b59f55]1175 return findKindExpression( untyped, symtab, hasIntegralType, "condition" );
[99d4584]1176 }
1177 }
1178
[4864a73]1179 class Resolver_new final
1180 : public ast::WithSymbolTable, public ast::WithGuards,
1181 public ast::WithVisitorRef<Resolver_new>, public ast::WithShortCircuiting,
[0e42794]1182 public ast::WithStmtsToAdd<> {
[4864a73]1183
[2a8f0c1]1184 ast::ptr< ast::Type > functionReturn = nullptr;
[2b59f55]1185 ast::CurrentObject currentObject;
[99d4584]1186 bool inEnumDecl = false;
[2a8f0c1]1187
[4864a73]1188 public:
[d76c588]1189 Resolver_new() = default;
[0e42794]1190 Resolver_new( const ast::SymbolTable & syms ) { symtab = syms; }
[d76c588]1191
[99d4584]1192 void previsit( const ast::FunctionDecl * );
1193 const ast::FunctionDecl * postvisit( const ast::FunctionDecl * );
1194 void previsit( const ast::ObjectDecl * );
1195 void previsit( const ast::EnumDecl * );
1196 const ast::StaticAssertDecl * previsit( const ast::StaticAssertDecl * );
1197
1198 void previsit( const ast::ArrayType * );
1199 void previsit( const ast::PointerType * );
1200
[2b59f55]1201 const ast::ExprStmt * previsit( const ast::ExprStmt * );
1202 const ast::AsmExpr * previsit( const ast::AsmExpr * );
1203 const ast::AsmStmt * previsit( const ast::AsmStmt * );
1204 const ast::IfStmt * previsit( const ast::IfStmt * );
1205 const ast::WhileStmt * previsit( const ast::WhileStmt * );
1206 const ast::ForStmt * previsit( const ast::ForStmt * );
[b7d92b96]1207 const ast::SwitchStmt * previsit( const ast::SwitchStmt * );
[2b59f55]1208 const ast::CaseStmt * previsit( const ast::CaseStmt * );
[b7d92b96]1209 const ast::BranchStmt * previsit( const ast::BranchStmt * );
[2b59f55]1210 const ast::ReturnStmt * previsit( const ast::ReturnStmt * );
1211 const ast::ThrowStmt * previsit( const ast::ThrowStmt * );
1212 const ast::CatchStmt * previsit( const ast::CatchStmt * );
[99d4584]1213 void previsit( const ast::WaitForStmt * );
1214
1215 void previsit( const ast::SingleInit * );
1216 void previsit( const ast::ListInit * );
1217 void previsit( const ast::ConstructorInit * );
[d76c588]1218 };
1219
1220 void resolve( std::list< ast::ptr<ast::Decl> >& translationUnit ) {
1221 ast::Pass<Resolver_new> resolver;
1222 accept_all( translationUnit, resolver );
1223 }
1224
[2a8f0c1]1225 void Resolver_new::previsit( const ast::FunctionDecl * functionDecl ) {
1226 GuardValue( functionReturn );
1227 functionReturn = extractResultType( functionDecl->type );
[d76c588]1228 }
1229
[2a8f0c1]1230 const ast::FunctionDecl * Resolver_new::postvisit( const ast::FunctionDecl * functionDecl ) {
[4864a73]1231 // default value expressions have an environment which shouldn't be there and trips up
[2a8f0c1]1232 // later passes.
1233 ast::ptr< ast::FunctionDecl > ret = functionDecl;
1234 for ( unsigned i = 0; i < functionDecl->type->params.size(); ++i ) {
1235 const ast::ptr<ast::DeclWithType> & d = functionDecl->type->params[i];
[4864a73]1236
[2a8f0c1]1237 if ( const ast::ObjectDecl * obj = d.as< ast::ObjectDecl >() ) {
1238 if ( const ast::SingleInit * init = obj->init.as< ast::SingleInit >() ) {
1239 if ( init->value->env == nullptr ) continue;
1240 // clone initializer minus the initializer environment
[4864a73]1241 ast::chain_mutate( ret )
1242 ( &ast::FunctionDecl::type )
[3cd5fdd]1243 ( &ast::FunctionType::params )[i]
[4864a73]1244 ( &ast::ObjectDecl::init )
1245 ( &ast::SingleInit::value )->env = nullptr;
1246
1247 assert( functionDecl != ret.get() || functionDecl->unique() );
1248 assert( ! ret->type->params[i].strict_as< ast::ObjectDecl >()->init.strict_as< ast::SingleInit >()->value->env );
[2a8f0c1]1249 }
1250 }
1251 }
1252 return ret.get();
[d76c588]1253 }
1254
[2a8f0c1]1255 void Resolver_new::previsit( const ast::ObjectDecl * objectDecl ) {
[b7d92b96]1256 // To handle initialization of routine pointers [e.g. int (*fp)(int) = foo()],
1257 // class-variable `initContext` is changed multiple times because the LHS is analyzed
1258 // twice. The second analysis changes `initContext` because a function type can contain
1259 // object declarations in the return and parameter types. Therefore each value of
1260 // `initContext` is retained so the type on the first analysis is preserved and used for
1261 // selecting the RHS.
1262 GuardValue( currentObject );
[2b59f55]1263 currentObject = ast::CurrentObject{ objectDecl->location, objectDecl->get_type() };
[b7d92b96]1264 if ( inEnumDecl && dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() ) ) {
1265 // enumerator initializers should not use the enum type to initialize, since the
1266 // enum type is still incomplete at this point. Use `int` instead.
[2b59f55]1267 currentObject = ast::CurrentObject{
1268 objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
[b7d92b96]1269 }
[d76c588]1270 }
1271
[99d4584]1272 void Resolver_new::previsit( const ast::EnumDecl * ) {
1273 // in case we decide to allow nested enums
1274 GuardValue( inEnumDecl );
1275 inEnumDecl = false;
[d76c588]1276 }
1277
[99d4584]1278 const ast::StaticAssertDecl * Resolver_new::previsit(
1279 const ast::StaticAssertDecl * assertDecl
1280 ) {
[b7d92b96]1281 return ast::mutate_field(
1282 assertDecl, &ast::StaticAssertDecl::cond,
1283 findIntegralExpression( assertDecl->cond, symtab ) );
1284 }
1285
1286 template< typename PtrType >
1287 void handlePtrType( const PtrType * type, const ast::SymbolTable & symtab ) {
1288 #warning unimplemented; needs support for new Validate::SizeType global
1289 (void)type; (void)symtab;
1290 assert( false );
[d76c588]1291 }
1292
[2a8f0c1]1293 void Resolver_new::previsit( const ast::ArrayType * at ) {
[b7d92b96]1294 handlePtrType( at, symtab );
[d76c588]1295 }
1296
[2a8f0c1]1297 void Resolver_new::previsit( const ast::PointerType * pt ) {
[b7d92b96]1298 handlePtrType( pt, symtab );
[d76c588]1299 }
1300
[b7d92b96]1301 const ast::ExprStmt * Resolver_new::previsit( const ast::ExprStmt * exprStmt ) {
1302 visit_children = false;
1303 assertf( exprStmt->expr, "ExprStmt has null expression in resolver" );
1304
1305 return ast::mutate_field(
1306 exprStmt, &ast::ExprStmt::expr, findVoidExpression( exprStmt->expr, symtab ) );
[d76c588]1307 }
1308
[b7d92b96]1309 const ast::AsmExpr * Resolver_new::previsit( const ast::AsmExpr * asmExpr ) {
1310 visit_children = false;
1311
1312 asmExpr = ast::mutate_field(
1313 asmExpr, &ast::AsmExpr::operand, findVoidExpression( asmExpr->operand, symtab ) );
1314
1315 if ( asmExpr->inout ) {
1316 asmExpr = ast::mutate_field(
1317 asmExpr, &ast::AsmExpr::inout, findVoidExpression( asmExpr->inout, symtab ) );
1318 }
1319
1320 return asmExpr;
[d76c588]1321 }
1322
[2b59f55]1323 const ast::AsmStmt * Resolver_new::previsit( const ast::AsmStmt * asmStmt ) {
1324 visitor->maybe_accept( asmStmt, &ast::AsmStmt::input );
1325 visitor->maybe_accept( asmStmt, &ast::AsmStmt::output );
1326 visit_children = false;
1327 return asmStmt;
[d76c588]1328 }
1329
[b7d92b96]1330 const ast::IfStmt * Resolver_new::previsit( const ast::IfStmt * ifStmt ) {
1331 return ast::mutate_field(
1332 ifStmt, &ast::IfStmt::cond, findIntegralExpression( ifStmt->cond, symtab ) );
[d76c588]1333 }
1334
[b7d92b96]1335 const ast::WhileStmt * Resolver_new::previsit( const ast::WhileStmt * whileStmt ) {
1336 return ast::mutate_field(
1337 whileStmt, &ast::WhileStmt::cond, findIntegralExpression( whileStmt->cond, symtab ) );
[d76c588]1338 }
1339
[b7d92b96]1340 const ast::ForStmt * Resolver_new::previsit( const ast::ForStmt * forStmt ) {
1341 if ( forStmt->cond ) {
1342 forStmt = ast::mutate_field(
1343 forStmt, &ast::ForStmt::cond, findIntegralExpression( forStmt->cond, symtab ) );
1344 }
1345
1346 if ( forStmt->inc ) {
1347 forStmt = ast::mutate_field(
1348 forStmt, &ast::ForStmt::inc, findVoidExpression( forStmt->inc, symtab ) );
1349 }
1350
1351 return forStmt;
[d76c588]1352 }
1353
[b7d92b96]1354 const ast::SwitchStmt * Resolver_new::previsit( const ast::SwitchStmt * switchStmt ) {
1355 GuardValue( currentObject );
1356 switchStmt = ast::mutate_field(
1357 switchStmt, &ast::SwitchStmt::cond,
1358 findIntegralExpression( switchStmt->cond, symtab ) );
[2b59f55]1359 currentObject = ast::CurrentObject{ switchStmt->location, switchStmt->cond->result };
[b7d92b96]1360 return switchStmt;
[d76c588]1361 }
1362
[b7d92b96]1363 const ast::CaseStmt * Resolver_new::previsit( const ast::CaseStmt * caseStmt ) {
1364 if ( caseStmt->cond ) {
[2b59f55]1365 std::vector< ast::InitAlternative > initAlts = currentObject.getOptions();
1366 assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral "
1367 "expression." );
1368
1369 const ast::Expr * untyped =
1370 new ast::CastExpr{ caseStmt->location, caseStmt->cond, initAlts.front().type };
1371 ast::ptr< ast::Expr > newExpr = findKindExpression( untyped, symtab );
1372
1373 // case condition cannot have a cast in C, so it must be removed here, regardless of
1374 // whether it would perform a conversion.
1375 if ( const ast::CastExpr * castExpr = newExpr.as< ast::CastExpr >() ) {
1376 ast::ptr< ast::TypeSubstitution > env = castExpr->env;
1377 newExpr.set_and_mutate( castExpr->arg )->env = env;
1378 }
1379
1380 caseStmt = ast::mutate_field( caseStmt, &ast::CaseStmt::cond, newExpr );
[b7d92b96]1381 }
1382 return caseStmt;
[d76c588]1383 }
1384
[b7d92b96]1385 const ast::BranchStmt * Resolver_new::previsit( const ast::BranchStmt * branchStmt ) {
1386 visit_children = false;
1387 // must resolve the argument of a computed goto
1388 if ( branchStmt->kind == ast::BranchStmt::Goto && branchStmt->computedTarget ) {
1389 // computed goto argument is void*
1390 branchStmt = ast::mutate_field(
1391 branchStmt, &ast::BranchStmt::computedTarget,
1392 findSingleExpression(
1393 branchStmt->computedTarget, new ast::PointerType{ new ast::VoidType{} },
1394 symtab ) );
1395 }
1396 return branchStmt;
[d76c588]1397 }
1398
[2b59f55]1399 const ast::ReturnStmt * Resolver_new::previsit( const ast::ReturnStmt * returnStmt ) {
1400 visit_children = false;
1401 if ( returnStmt->expr ) {
1402 returnStmt = ast::mutate_field(
1403 returnStmt, &ast::ReturnStmt::expr,
1404 findSingleExpression( returnStmt->expr, functionReturn, symtab ) );
1405 }
1406 return returnStmt;
[d76c588]1407 }
1408
[2b59f55]1409 const ast::ThrowStmt * Resolver_new::previsit( const ast::ThrowStmt * throwStmt ) {
1410 visit_children = false;
1411 if ( throwStmt->expr ) {
1412 const ast::StructDecl * exceptionDecl =
1413 symtab.lookupStruct( "__cfaabi_ehm__base_exception_t" );
1414 assert( exceptionDecl );
1415 ast::ptr< ast::Type > exceptType =
1416 new ast::PointerType{ new ast::StructInstType{ exceptionDecl } };
1417 throwStmt = ast::mutate_field(
1418 throwStmt, &ast::ThrowStmt::expr,
1419 findSingleExpression( throwStmt->expr, exceptType, symtab ) );
1420 }
1421 return throwStmt;
[d76c588]1422 }
1423
[2b59f55]1424 const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
1425 if ( catchStmt->cond ) {
1426 ast::ptr< ast::Type > boolType = new ast::BasicType{ ast::BasicType::Bool };
1427 catchStmt = ast::mutate_field(
1428 catchStmt, &ast::CatchStmt::cond,
1429 findSingleExpression( catchStmt->cond, boolType, symtab ) );
1430 }
1431 return catchStmt;
[d76c588]1432 }
1433
[2a8f0c1]1434 void Resolver_new::previsit( const ast::WaitForStmt * stmt ) {
[d76c588]1435 #warning unimplemented; Resolver port in progress
1436 (void)stmt;
1437 assert(false);
1438 }
1439
[2a8f0c1]1440 void Resolver_new::previsit( const ast::SingleInit * singleInit ) {
[d76c588]1441 #warning unimplemented; Resolver port in progress
1442 (void)singleInit;
1443 assert(false);
1444 }
1445
[2a8f0c1]1446 void Resolver_new::previsit( const ast::ListInit * listInit ) {
[d76c588]1447 #warning unimplemented; Resolver port in progress
1448 (void)listInit;
1449 assert(false);
1450 }
1451
[2a8f0c1]1452 void Resolver_new::previsit( const ast::ConstructorInit * ctorInit ) {
[d76c588]1453 #warning unimplemented; Resolver port in progress
1454 (void)ctorInit;
1455 assert(false);
1456 }
1457
[51b73452]1458} // namespace ResolvExpr
[a32b204]1459
1460// Local Variables: //
1461// tab-width: 4 //
1462// mode: c++ //
1463// compile-command: "make install" //
1464// End: //
Note: See TracBrowser for help on using the repository browser.