source: src/GenPoly/GenPoly.cc@ 19de7864

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since 19de7864 was 3e5dd913, checked in by Fangren Yu <f37yu@…>, 5 years ago

reimplement function type and eliminate deep copy
  • Property mode set to 100644
File size: 23.5 KB
Line 
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//
7// GenPoly.cc --
8//
9// Author : Richard C. Bilson
10// Created On : Mon May 18 07:44:20 2015
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Wed Jun 29 21:45:53 2016
13// Update Count : 14
14//
15
16#include "GenPoly.h"
17
18#include <cassert> // for assertf, assert
19#include <iostream> // for operator<<, ostream, basic_os...
20#include <iterator> // for back_insert_iterator, back_in...
21#include <list> // for list, _List_iterator, list<>:...
22#include <typeindex> // for type_index
23#include <utility> // for pair
24#include <vector> // for vector
25
26#include "AST/Type.hpp"
27#include "GenPoly/ErasableScopedMap.h" // for ErasableScopedMap<>::const_it...
28#include "ResolvExpr/typeops.h" // for flatten
29#include "SynTree/Constant.h" // for Constant
30#include "SynTree/Expression.h" // for Expression, TypeExpr, Constan...
31#include "SynTree/Type.h" // for Type, StructInstType, UnionIn...
32#include "SynTree/TypeSubstitution.h" // for TypeSubstitution
33
34using namespace std;
35
36namespace GenPoly {
37 namespace {
38 /// Checks a parameter list for polymorphic parameters; will substitute according to env if present
39 bool hasPolyParams( std::list< Expression* >& params, const TypeSubstitution *env ) {
40 for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
41 TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
42 assertf(paramType, "Aggregate parameters should be type expressions");
43 if ( isPolyType( paramType->get_type(), env ) ) return true;
44 }
45 return false;
46 }
47
48 bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const ast::TypeSubstitution * env) {
49 for (auto &param : params) {
50 auto paramType = param.strict_as<ast::TypeExpr>();
51 if (isPolyType(paramType->type, env)) return true;
52 }
53 return false;
54 }
55
56 /// Checks a parameter list for polymorphic parameters from tyVars; will substitute according to env if present
57 bool hasPolyParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
58 for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
59 TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
60 assertf(paramType, "Aggregate parameters should be type expressions");
61 if ( isPolyType( paramType->get_type(), tyVars, env ) ) return true;
62 }
63 return false;
64 }
65
66 bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const TyVarMap & tyVars, const ast::TypeSubstitution * env) {
67 for (auto &param : params) {
68 auto paramType = param.strict_as<ast::TypeExpr>();
69 if (isPolyType(paramType->type, tyVars, env)) return true;
70 }
71 return false;
72 }
73
74 /// Checks a parameter list for dynamic-layout parameters from tyVars; will substitute according to env if present
75 bool hasDynParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
76 for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
77 TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
78 assertf(paramType, "Aggregate parameters should be type expressions");
79 if ( isDynType( paramType->get_type(), tyVars, env ) ) return true;
80 }
81 return false;
82 }
83
84 /// Checks a parameter list for inclusion of polymorphic parameters; will substitute according to env if present
85 bool includesPolyParams( std::list< Expression* >& params, const TypeSubstitution *env ) {
86 for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
87 TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
88 assertf(paramType, "Aggregate parameters should be type expressions");
89 if ( includesPolyType( paramType->get_type(), env ) ) return true;
90 }
91 return false;
92 }
93
94 /// Checks a parameter list for inclusion of polymorphic parameters from tyVars; will substitute according to env if present
95 bool includesPolyParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
96 for ( std::list< Expression* >::iterator param = params.begin(); param != params.end(); ++param ) {
97 TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
98 assertf(paramType, "Aggregate parameters should be type expressions");
99 if ( includesPolyType( paramType->get_type(), tyVars, env ) ) return true;
100 }
101 return false;
102 }
103 }
104
105 Type* replaceTypeInst( Type* type, const TypeSubstitution* env ) {
106 if ( ! env ) return type;
107 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( type ) ) {
108 Type *newType = env->lookup( typeInst->get_name() );
109 if ( newType ) return newType;
110 }
111 return type;
112 }
113
114 const ast::Type * replaceTypeInst(const ast::Type * type, const ast::TypeSubstitution * env) {
115 if (!env) return type;
116 if (auto typeInst = dynamic_cast<const ast::TypeInstType*> (type)) {
117 auto newType = env->lookup(typeInst);
118 if (newType) return newType;
119 }
120 return type;
121 }
122
123 Type *isPolyType( Type *type, const TypeSubstitution *env ) {
124 type = replaceTypeInst( type, env );
125
126 if ( dynamic_cast< TypeInstType * >( type ) ) {
127 return type;
128 } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
129 return isPolyType( arrayType->base, env );
130 } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
131 if ( hasPolyParams( structType->get_parameters(), env ) ) return type;
132 } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
133 if ( hasPolyParams( unionType->get_parameters(), env ) ) return type;
134 }
135 return 0;
136 }
137
138 const ast::Type * isPolyType(const ast::Type * type, const ast::TypeSubstitution * env) {
139 type = replaceTypeInst( type, env );
140
141 if ( dynamic_cast< const ast::TypeInstType * >( type ) ) {
142 return type;
143 } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
144 return isPolyType( arrayType->base, env );
145 } else if ( auto structType = dynamic_cast< const ast::StructInstType* >( type ) ) {
146 if ( hasPolyParams( structType->params, env ) ) return type;
147 } else if ( auto unionType = dynamic_cast< const ast::UnionInstType* >( type ) ) {
148 if ( hasPolyParams( unionType->params, env ) ) return type;
149 }
150 return 0;
151 }
152
153 Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
154 type = replaceTypeInst( type, env );
155
156 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
157 if ( tyVars.find( typeInst->get_name() ) != tyVars.end() ) {
158 return type;
159 }
160 } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
161 return isPolyType( arrayType->base, tyVars, env );
162 } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
163 if ( hasPolyParams( structType->get_parameters(), tyVars, env ) ) return type;
164 } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
165 if ( hasPolyParams( unionType->get_parameters(), tyVars, env ) ) return type;
166 }
167 return 0;
168 }
169
170 const ast::Type * isPolyType(const ast::Type * type, const TyVarMap & tyVars, const ast::TypeSubstitution * env) {
171 type = replaceTypeInst( type, env );
172
173 if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
174 return tyVars.find(typeInst->typeString()) != tyVars.end() ? type : nullptr;
175 } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
176 return isPolyType( arrayType->base, env );
177 } else if ( auto structType = dynamic_cast< const ast::StructInstType* >( type ) ) {
178 if ( hasPolyParams( structType->params, env ) ) return type;
179 } else if ( auto unionType = dynamic_cast< const ast::UnionInstType* >( type ) ) {
180 if ( hasPolyParams( unionType->params, env ) ) return type;
181 }
182 return nullptr;
183 }
184
185 ReferenceToType *isDynType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
186 type = replaceTypeInst( type, env );
187
188 if ( TypeInstType *typeInst = dynamic_cast< TypeInstType * >( type ) ) {
189 auto var = tyVars.find( typeInst->get_name() );
190 if ( var != tyVars.end() && var->second.isComplete ) {
191 return typeInst;
192 }
193 } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
194 if ( hasDynParams( structType->get_parameters(), tyVars, env ) ) return structType;
195 } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
196 if ( hasDynParams( unionType->get_parameters(), tyVars, env ) ) return unionType;
197 }
198 return 0;
199 }
200
201 ReferenceToType *isDynRet( FunctionType *function, const TyVarMap &forallTypes ) {
202 if ( function->get_returnVals().empty() ) return 0;
203
204 return (ReferenceToType*)isDynType( function->get_returnVals().front()->get_type(), forallTypes );
205 }
206
207 ReferenceToType *isDynRet( FunctionType *function ) {
208 if ( function->get_returnVals().empty() ) return 0;
209
210 TyVarMap forallTypes( TypeDecl::Data{} );
211 makeTyVarMap( function, forallTypes );
212 return (ReferenceToType*)isDynType( function->get_returnVals().front()->get_type(), forallTypes );
213 }
214
215 bool needsAdapter( FunctionType *adaptee, const TyVarMap &tyVars ) {
216// if ( ! adaptee->get_returnVals().empty() && isPolyType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
217// return true;
218// } // if
219 if ( isDynRet( adaptee, tyVars ) ) return true;
220
221 for ( std::list< DeclarationWithType* >::const_iterator innerArg = adaptee->get_parameters().begin(); innerArg != adaptee->get_parameters().end(); ++innerArg ) {
222// if ( isPolyType( (*innerArg)->get_type(), tyVars ) ) {
223 if ( isDynType( (*innerArg)->get_type(), tyVars ) ) {
224 return true;
225 } // if
226 } // for
227 return false;
228 }
229
230 Type *isPolyPtr( Type *type, const TypeSubstitution *env ) {
231 type = replaceTypeInst( type, env );
232
233 if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
234 return isPolyType( ptr->get_base(), env );
235 }
236 return 0;
237 }
238
239 Type *isPolyPtr( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
240 type = replaceTypeInst( type, env );
241
242 if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
243 return isPolyType( ptr->get_base(), tyVars, env );
244 }
245 return 0;
246 }
247
248 Type * hasPolyBase( Type *type, int *levels, const TypeSubstitution *env ) {
249 int dummy;
250 if ( ! levels ) { levels = &dummy; }
251 *levels = 0;
252
253 while ( true ) {
254 type = replaceTypeInst( type, env );
255
256 if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
257 type = ptr->get_base();
258 ++(*levels);
259 } else break;
260 }
261
262 return isPolyType( type, env );
263 }
264
265 Type * hasPolyBase( Type *type, const TyVarMap &tyVars, int *levels, const TypeSubstitution *env ) {
266 int dummy;
267 if ( ! levels ) { levels = &dummy; }
268 *levels = 0;
269
270 while ( true ) {
271 type = replaceTypeInst( type, env );
272
273 if ( PointerType *ptr = dynamic_cast< PointerType *>( type ) ) {
274 type = ptr->get_base();
275 ++(*levels);
276 } else break;
277 }
278
279 return isPolyType( type, tyVars, env );
280 }
281
282 bool includesPolyType( Type *type, const TypeSubstitution *env ) {
283 type = replaceTypeInst( type, env );
284
285 if ( dynamic_cast< TypeInstType * >( type ) ) {
286 return true;
287 } else if ( PointerType *pointerType = dynamic_cast< PointerType* >( type ) ) {
288 if ( includesPolyType( pointerType->get_base(), env ) ) return true;
289 } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
290 if ( includesPolyParams( structType->get_parameters(), env ) ) return true;
291 } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
292 if ( includesPolyParams( unionType->get_parameters(), env ) ) return true;
293 }
294 return false;
295 }
296
297 bool includesPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
298 type = replaceTypeInst( type, env );
299
300 if ( TypeInstType *typeInstType = dynamic_cast< TypeInstType * >( type ) ) {
301 if ( tyVars.find( typeInstType->get_name() ) != tyVars.end() ) {
302 return true;
303 }
304 } else if ( PointerType *pointerType = dynamic_cast< PointerType* >( type ) ) {
305 if ( includesPolyType( pointerType->get_base(), tyVars, env ) ) return true;
306 } else if ( StructInstType *structType = dynamic_cast< StructInstType* >( type ) ) {
307 if ( includesPolyParams( structType->get_parameters(), tyVars, env ) ) return true;
308 } else if ( UnionInstType *unionType = dynamic_cast< UnionInstType* >( type ) ) {
309 if ( includesPolyParams( unionType->get_parameters(), tyVars, env ) ) return true;
310 }
311 return false;
312 }
313
314 FunctionType * getFunctionType( Type *ty ) {
315 PointerType *ptrType;
316 if ( ( ptrType = dynamic_cast< PointerType* >( ty ) ) ) {
317 return dynamic_cast< FunctionType* >( ptrType->get_base() ); // pointer if FunctionType, NULL otherwise
318 } else {
319 return dynamic_cast< FunctionType* >( ty ); // pointer if FunctionType, NULL otherwise
320 }
321 }
322
323 const ast::FunctionType * getFunctionType( const ast::Type * ty ) {
324 if ( auto pty = dynamic_cast< const ast::PointerType * >( ty ) ) {
325 return pty->base.as< ast::FunctionType >();
326 } else {
327 return dynamic_cast< const ast::FunctionType * >( ty );
328 }
329 }
330
331 VariableExpr * getBaseVar( Expression *expr, int *levels ) {
332 int dummy;
333 if ( ! levels ) { levels = &dummy; }
334 *levels = 0;
335
336 while ( true ) {
337 if ( VariableExpr *varExpr = dynamic_cast< VariableExpr* >( expr ) ) {
338 return varExpr;
339 } else if ( MemberExpr *memberExpr = dynamic_cast< MemberExpr* >( expr ) ) {
340 expr = memberExpr->get_aggregate();
341 } else if ( AddressExpr *addressExpr = dynamic_cast< AddressExpr* >( expr ) ) {
342 expr = addressExpr->get_arg();
343 } else if ( UntypedExpr *untypedExpr = dynamic_cast< UntypedExpr* >( expr ) ) {
344 // look for compiler-inserted dereference operator
345 NameExpr *fn = dynamic_cast< NameExpr* >( untypedExpr->get_function() );
346 if ( ! fn || fn->get_name() != std::string("*?") ) return 0;
347 expr = *untypedExpr->begin_args();
348 } else if ( CommaExpr *commaExpr = dynamic_cast< CommaExpr* >( expr ) ) {
349 // copy constructors insert comma exprs, look at second argument which contains the variable
350 expr = commaExpr->get_arg2();
351 continue;
352 } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( expr ) ) {
353 int lvl1;
354 int lvl2;
355 VariableExpr * var1 = getBaseVar( condExpr->get_arg2(), &lvl1 );
356 VariableExpr * var2 = getBaseVar( condExpr->get_arg3(), &lvl2 );
357 if ( lvl1 == lvl2 && var1 && var2 && var1->get_var() == var2->get_var() ) {
358 *levels = lvl1;
359 return var1;
360 }
361 break;
362 } else break;
363
364 ++(*levels);
365 }
366
367 return 0;
368 }
369
370 namespace {
371 /// Checks if is a pointer to D
372 template<typename D, typename B>
373 bool is( const B* p ) { return type_index{typeid(D)} == type_index{typeid(*p)}; }
374
375 /// Converts to a pointer to D without checking for safety
376 template<typename D, typename B>
377 inline D* as( B* p ) { return reinterpret_cast<D*>(p); }
378
379 /// Flattens a declaration list
380 template<typename Output>
381 void flattenList( list< DeclarationWithType* > src, Output out ) {
382 for ( DeclarationWithType* decl : src ) {
383 ResolvExpr::flatten( decl->get_type(), out );
384 }
385 }
386
387 /// Flattens a list of types
388 template<typename Output>
389 void flattenList( list< Type* > src, Output out ) {
390 for ( Type* ty : src ) {
391 ResolvExpr::flatten( ty, out );
392 }
393 }
394
395 /// Checks if two lists of parameters are equal up to polymorphic substitution.
396 bool paramListsPolyCompatible( const list< Expression* >& aparams, const list< Expression* >& bparams ) {
397 if ( aparams.size() != bparams.size() ) return false;
398
399 for ( list< Expression* >::const_iterator at = aparams.begin(), bt = bparams.begin();
400 at != aparams.end(); ++at, ++bt ) {
401 TypeExpr *aparam = dynamic_cast< TypeExpr* >(*at);
402 assertf(aparam, "Aggregate parameters should be type expressions");
403 TypeExpr *bparam = dynamic_cast< TypeExpr* >(*bt);
404 assertf(bparam, "Aggregate parameters should be type expressions");
405
406 // xxx - might need to let VoidType be a wildcard here too; could have some voids
407 // stuffed in for dtype-statics.
408 // if ( is<VoidType>( aparam->get_type() ) || is<VoidType>( bparam->get_type() ) ) continue;
409 if ( ! typesPolyCompatible( aparam->get_type(), bparam->get_type() ) ) return false;
410 }
411
412 return true;
413 }
414 }
415
416 bool typesPolyCompatible( Type *a, Type *b ) {
417 type_index aid{ typeid(*a) };
418 // polymorphic types always match
419 if ( aid == type_index{typeid(TypeInstType)} ) return true;
420
421 type_index bid{ typeid(*b) };
422 // polymorphic types always match
423 if ( bid == type_index{typeid(TypeInstType)} ) return true;
424
425 // can't match otherwise if different types
426 if ( aid != bid ) return false;
427
428 // recurse through type structure (conditions borrowed from Unify.cc)
429 if ( aid == type_index{typeid(BasicType)} ) {
430 return as<BasicType>(a)->get_kind() == as<BasicType>(b)->get_kind();
431 } else if ( aid == type_index{typeid(PointerType)} ) {
432 PointerType *ap = as<PointerType>(a), *bp = as<PointerType>(b);
433
434 // void pointers should match any other pointer type
435 return is<VoidType>( ap->get_base() ) || is<VoidType>( bp->get_base() )
436 || typesPolyCompatible( ap->get_base(), bp->get_base() );
437 } else if ( aid == type_index{typeid(ReferenceType)} ) {
438 ReferenceType *ap = as<ReferenceType>(a), *bp = as<ReferenceType>(b);
439 return is<VoidType>( ap->get_base() ) || is<VoidType>( bp->get_base() )
440 || typesPolyCompatible( ap->get_base(), bp->get_base() );
441 } else if ( aid == type_index{typeid(ArrayType)} ) {
442 ArrayType *aa = as<ArrayType>(a), *ba = as<ArrayType>(b);
443
444 if ( aa->get_isVarLen() ) {
445 if ( ! ba->get_isVarLen() ) return false;
446 } else {
447 if ( ba->get_isVarLen() ) return false;
448
449 ConstantExpr *ad = dynamic_cast<ConstantExpr*>( aa->get_dimension() );
450 ConstantExpr *bd = dynamic_cast<ConstantExpr*>( ba->get_dimension() );
451 if ( ad && bd
452 && ad->get_constant()->get_value() != bd->get_constant()->get_value() )
453 return false;
454 }
455
456 return typesPolyCompatible( aa->get_base(), ba->get_base() );
457 } else if ( aid == type_index{typeid(FunctionType)} ) {
458 FunctionType *af = as<FunctionType>(a), *bf = as<FunctionType>(b);
459
460 vector<Type*> aparams, bparams;
461 flattenList( af->get_parameters(), back_inserter( aparams ) );
462 flattenList( bf->get_parameters(), back_inserter( bparams ) );
463 if ( aparams.size() != bparams.size() ) return false;
464
465 vector<Type*> areturns, breturns;
466 flattenList( af->get_returnVals(), back_inserter( areturns ) );
467 flattenList( bf->get_returnVals(), back_inserter( breturns ) );
468 if ( areturns.size() != breturns.size() ) return false;
469
470 for ( unsigned i = 0; i < aparams.size(); ++i ) {
471 if ( ! typesPolyCompatible( aparams[i], bparams[i] ) ) return false;
472 }
473 for ( unsigned i = 0; i < areturns.size(); ++i ) {
474 if ( ! typesPolyCompatible( areturns[i], breturns[i] ) ) return false;
475 }
476 return true;
477 } else if ( aid == type_index{typeid(StructInstType)} ) {
478 StructInstType *aa = as<StructInstType>(a), *ba = as<StructInstType>(b);
479
480 if ( aa->get_name() != ba->get_name() ) return false;
481 return paramListsPolyCompatible( aa->get_parameters(), ba->get_parameters() );
482 } else if ( aid == type_index{typeid(UnionInstType)} ) {
483 UnionInstType *aa = as<UnionInstType>(a), *ba = as<UnionInstType>(b);
484
485 if ( aa->get_name() != ba->get_name() ) return false;
486 return paramListsPolyCompatible( aa->get_parameters(), ba->get_parameters() );
487 } else if ( aid == type_index{typeid(EnumInstType)} ) {
488 return as<EnumInstType>(a)->get_name() == as<EnumInstType>(b)->get_name();
489 } else if ( aid == type_index{typeid(TraitInstType)} ) {
490 return as<TraitInstType>(a)->get_name() == as<TraitInstType>(b)->get_name();
491 } else if ( aid == type_index{typeid(TupleType)} ) {
492 TupleType *at = as<TupleType>(a), *bt = as<TupleType>(b);
493
494 vector<Type*> atypes, btypes;
495 flattenList( at->get_types(), back_inserter( atypes ) );
496 flattenList( bt->get_types(), back_inserter( btypes ) );
497 if ( atypes.size() != btypes.size() ) return false;
498
499 for ( unsigned i = 0; i < atypes.size(); ++i ) {
500 if ( ! typesPolyCompatible( atypes[i], btypes[i] ) ) return false;
501 }
502 return true;
503 } else return true; // VoidType, VarArgsType, ZeroType & OneType just need the same type
504 }
505
506 namespace {
507 // temporary hack to avoid re-implementing anything related to TyVarMap
508 // does this work? these two structs have identical definitions.
509 inline TypeDecl::Data convData(const ast::TypeDecl::Data & data) {
510 return *reinterpret_cast<const TypeDecl::Data *>(&data);
511 }
512 }
513
514 bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env ) {
515 // is parameter is not polymorphic, don't need to box
516 if ( ! isPolyType( param, exprTyVars ) ) return false;
517 Type * newType = arg->clone();
518 if ( env ) env->apply( newType );
519 std::unique_ptr<Type> manager( newType );
520 // if the argument's type is polymorphic, we don't need to box again!
521 return ! isPolyType( newType );
522 }
523
524 bool needsBoxing( const ast::Type * param, const ast::Type * arg, const TyVarMap &exprTyVars, const ast::TypeSubstitution * env) {
525 // is parameter is not polymorphic, don't need to box
526 if ( ! isPolyType( param, exprTyVars ) ) return false;
527 ast::ptr<ast::Type> newType = arg;
528 if ( env ) env->apply( newType );
529 // if the argument's type is polymorphic, we don't need to box again!
530 return ! isPolyType( newType );
531 }
532
533 bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env ) {
534 FunctionType * function = getFunctionType( appExpr->function->result );
535 assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->function->result ).c_str() );
536 TyVarMap exprTyVars( TypeDecl::Data{} );
537 makeTyVarMap( function, exprTyVars );
538 return needsBoxing( param, arg, exprTyVars, env );
539 }
540
541 bool needsBoxing( const ast::Type * param, const ast::Type * arg, const ast::ApplicationExpr * appExpr, const ast::TypeSubstitution * env) {
542 const ast::FunctionType * function = getFunctionType(appExpr->func->result);
543 assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->func->result ).c_str() );
544 TyVarMap exprTyVars(TypeDecl::Data{});
545 makeTyVarMap(function, exprTyVars);
546 return needsBoxing(param, arg, exprTyVars, env);
547
548 }
549
550 void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
551 tyVarMap.insert( tyVar->name, TypeDecl::Data{ tyVar } );
552 }
553
554 void addToTyVarMap( const ast::TypeInstType * tyVar, TyVarMap & tyVarMap) {
555 tyVarMap.insert(tyVar->typeString(), convData(ast::TypeDecl::Data{tyVar->base}));
556 }
557
558 void makeTyVarMap( Type *type, TyVarMap &tyVarMap ) {
559 for ( Type::ForallList::const_iterator tyVar = type->get_forall().begin(); tyVar != type->get_forall().end(); ++tyVar ) {
560 assert( *tyVar );
561 addToTyVarMap( *tyVar, tyVarMap );
562 }
563 if ( PointerType *pointer = dynamic_cast< PointerType* >( type ) ) {
564 makeTyVarMap( pointer->get_base(), tyVarMap );
565 }
566 }
567
568 void makeTyVarMap(const ast::Type * type, TyVarMap & tyVarMap) {
569 if (auto ptype = dynamic_cast<const ast::FunctionType *>(type)) {
570 for (auto & tyVar : ptype->forall) {
571 assert (tyVar);
572 addToTyVarMap(tyVar, tyVarMap);
573 }
574 }
575 if (auto pointer = dynamic_cast<const ast::PointerType *>(type)) {
576 makeTyVarMap(pointer->base, tyVarMap);
577 }
578 }
579
580 void printTyVarMap( std::ostream &os, const TyVarMap &tyVarMap ) {
581 for ( TyVarMap::const_iterator i = tyVarMap.begin(); i != tyVarMap.end(); ++i ) {
582 os << i->first << " (" << i->second << ") ";
583 } // for
584 os << std::endl;
585 }
586
587} // namespace GenPoly
588
589// Local Variables: //
590// tab-width: 4 //
591// mode: c++ //
592// compile-command: "make install" //
593// End: //
Note: See TracBrowser for help on using the repository browser.