- Timestamp:
- Sep 24, 2020, 3:56:16 PM (4 years ago)
- Branches:
- ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
- Children:
- 6cc913e
- Parents:
- eccb14d
- Location:
- src
- Files:
-
- 17 edited
Legend:
- Unmodified
- Added
- Removed
-
src/AST/Convert.cpp
reccb14d r954c954 177 177 const ast::DeclWithType * visit( const ast::FunctionDecl * node ) override final { 178 178 if ( inCache( node ) ) return nullptr; 179 180 // function decl contains real variables that the type must use. 181 // the structural change means function type in and out of decl 182 // must be handled **differently** on convert back to old. 183 auto ftype = new FunctionType( 184 cv(node->type), 185 (bool)node->type->isVarArgs 186 ); 187 ftype->returnVals = get<DeclarationWithType>().acceptL(node->returns); 188 ftype->parameters = get<DeclarationWithType>().acceptL(node->params); 189 190 ftype->forall = get<TypeDecl>().acceptL( node->type->forall ); 191 192 visitType(node->type, ftype); 193 179 194 auto decl = new FunctionDecl( 180 195 node->name, 181 196 Type::StorageClasses( node->storage.val ), 182 197 LinkageSpec::Spec( node->linkage.val ), 183 get<FunctionType>().accept1( node->type ), 198 ftype, 199 //get<FunctionType>().accept1( node->type ), 184 200 {}, 185 201 get<Attribute>().acceptL( node->attributes ), … … 1152 1168 1153 1169 const ast::Type * visit( const ast::FunctionType * node ) override final { 1170 static std::string dummy_paramvar_prefix = "__param_"; 1171 static std::string dummy_returnvar_prefix = "__retval_"; 1172 1154 1173 auto ty = new FunctionType { 1155 1174 cv( node ), 1156 1175 (bool)node->isVarArgs 1157 1176 }; 1158 ty->returnVals = get<DeclarationWithType>().acceptL( node->returns ); 1159 ty->parameters = get<DeclarationWithType>().acceptL( node->params ); 1177 auto returns = get<Type>().acceptL(node->returns); 1178 auto params = get<Type>().acceptL(node->params); 1179 1180 int ret_index = 0; 1181 for (auto t: returns) { 1182 // xxx - LinkageSpec shouldn't matter but needs to be something 1183 ObjectDecl * dummy = new ObjectDecl(dummy_returnvar_prefix + std::to_string(ret_index++), {}, LinkageSpec::C, nullptr, t, nullptr); 1184 ty->returnVals.push_back(dummy); 1185 } 1186 int param_index = 0; 1187 for (auto t: params) { 1188 ObjectDecl * dummy = new ObjectDecl(dummy_paramvar_prefix + std::to_string(param_index++), {}, LinkageSpec::C, nullptr, t, nullptr); 1189 ty->parameters.push_back(dummy); 1190 } 1191 1192 // ty->returnVals = get<DeclarationWithType>().acceptL( node->returns ); 1193 // ty->parameters = get<DeclarationWithType>().acceptL( node->params ); 1160 1194 ty->forall = get<TypeDecl>().acceptL( node->forall ); 1161 1195 return visitType( node, ty ); … … 1374 1408 ast::Node * node = nullptr; 1375 1409 /// cache of nodes that might be referenced by readonly<> for de-duplication 1376 std::unordered_map< const BaseSyntaxNode *, ast::Node * > cache = {}; 1410 /// in case that some nodes are dropped by conversion (due to possible structural change) 1411 /// use smart pointers in cache value to prevent accidental invalidation. 1412 /// at conversion stage, all created nodes are guaranteed to be unique, therefore 1413 /// const_casting out of smart pointers is permitted. 1414 std::unordered_map< const BaseSyntaxNode *, ast::ptr<ast::Node> > cache = {}; 1377 1415 1378 1416 // Local Utilities: … … 1447 1485 auto it = cache.find( old ); 1448 1486 if ( it == cache.end() ) return false; 1449 node = it->second;1487 node = const_cast<ast::Node *>(it->second.get()); 1450 1488 return true; 1451 1489 } … … 1486 1524 virtual void visit( const FunctionDecl * old ) override final { 1487 1525 if ( inCache( old ) ) return; 1526 auto paramVars = GET_ACCEPT_V(type->parameters, DeclWithType); 1527 auto returnVars = GET_ACCEPT_V(type->returnVals, DeclWithType); 1528 auto forall = GET_ACCEPT_V(type->forall, TypeDecl); 1529 1530 // function type is now derived from parameter decls instead of storing them 1531 auto ftype = new ast::FunctionType((ast::ArgumentFlag)old->type->isVarArgs, cv(old->type)); 1532 ftype->params.reserve(paramVars.size()); 1533 ftype->returns.reserve(returnVars.size()); 1534 1535 for (auto & v: paramVars) { 1536 ftype->params.emplace_back(v->get_type()); 1537 } 1538 for (auto & v: returnVars) { 1539 ftype->returns.emplace_back(v->get_type()); 1540 } 1541 ftype->forall = std::move(forall); 1542 visitType(old->type, ftype); 1543 1488 1544 auto decl = new ast::FunctionDecl{ 1489 1545 old->location, 1490 1546 old->name, 1491 GET_ACCEPT_1(type, FunctionType), 1547 // GET_ACCEPT_1(type, FunctionType), 1548 std::move(paramVars), 1549 std::move(returnVars), 1492 1550 {}, 1493 1551 { old->storageClasses.val }, … … 1496 1554 { old->get_funcSpec().val } 1497 1555 }; 1556 1557 decl->type = ftype; 1498 1558 cache.emplace( old, decl ); 1559 1499 1560 decl->withExprs = GET_ACCEPT_V(withExprs, Expr); 1500 1561 decl->stmts = GET_ACCEPT_1(statements, CompoundStmt); … … 2515 2576 cv( old ) 2516 2577 }; 2517 ty->returns = GET_ACCEPT_V( returnVals, DeclWithType ); 2518 ty->params = GET_ACCEPT_V( parameters, DeclWithType ); 2578 auto returnVars = GET_ACCEPT_V(returnVals, DeclWithType); 2579 auto paramVars = GET_ACCEPT_V(parameters, DeclWithType); 2580 // ty->returns = GET_ACCEPT_V( returnVals, DeclWithType ); 2581 // ty->params = GET_ACCEPT_V( parameters, DeclWithType ); 2582 for (auto & v: returnVars) { 2583 ty->returns.emplace_back(v->get_type()); 2584 } 2585 for (auto & v: paramVars) { 2586 ty->params.emplace_back(v->get_type()); 2587 } 2519 2588 ty->forall = GET_ACCEPT_V( forall, TypeDecl ); 2520 2589 visitType( old, ty ); -
src/AST/Decl.hpp
reccb14d r954c954 124 124 class FunctionDecl : public DeclWithType { 125 125 public: 126 std::vector<ptr<DeclWithType>> params; 127 std::vector<ptr<DeclWithType>> returns; 128 // declared type, derived from parameter declarations 126 129 ptr<FunctionType> type; 127 130 ptr<CompoundStmt> stmts; 128 131 std::vector< ptr<Expr> > withExprs; 129 132 130 FunctionDecl( const CodeLocation & loc, const std::string & name, FunctionType * type, 133 FunctionDecl( const CodeLocation & loc, const std::string & name, 134 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns, 131 135 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C, 132 136 std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}) 133 : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), type( type),137 : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)), 134 138 stmts( stmts ) {} 135 139 -
src/AST/ForallSubstitutor.hpp
reccb14d r954c954 33 33 } 34 34 35 template<typename node_t > 36 std::vector<ptr<node_t>> operator() (const std::vector<ptr<node_t>> & o) { 37 std::vector<ptr<node_t>> n; 38 n.reserve(o.size()); 39 for (const node_t * d : o) { n.emplace_back(d->accept(*visitor)); } 40 return n; 41 } 42 43 /* 44 35 45 /// Substitute parameter/return type 36 46 std::vector< ptr< DeclWithType > > operator() ( const std::vector< ptr< DeclWithType > > & o ) { … … 48 58 return n; 49 59 } 60 61 */ 50 62 }; 51 63 -
src/AST/Pass.impl.hpp
reccb14d r954c954 465 465 __pass::symtab::addId( core, 0, func ); 466 466 VISIT( 467 // parameter declarations are now directly here 468 maybe_accept( node, &FunctionDecl::params ); 469 maybe_accept( node, &FunctionDecl::returns ); 470 // foralls are still in function type 467 471 maybe_accept( node, &FunctionDecl::type ); 468 472 // function body needs to have the same scope as parameters - CompoundStmt will not enter -
src/AST/SymbolTable.cpp
reccb14d r954c954 335 335 } 336 336 337 /* 337 338 void SymbolTable::addFunctionType( const FunctionType * ftype ) { 338 339 addTypes( ftype->forall ); … … 340 341 addIds( ftype->params ); 341 342 } 343 */ 342 344 343 345 void SymbolTable::lazyInitScope() { … … 368 370 assert( ! params.empty() ); 369 371 // use base type of pointer, so that qualifiers on the pointer type aren't considered. 370 const Type * base = InitTweak::getPointerBase( params.front() ->get_type());372 const Type * base = InitTweak::getPointerBase( params.front() ); 371 373 assert( base ); 372 374 return Mangle::mangle( base ); -
src/AST/SymbolTable.hpp
reccb14d r954c954 145 145 146 146 /// convenience function for adding all of the declarations in a function type to the indexer 147 void addFunctionType( const FunctionType * ftype );147 // void addFunctionType( const FunctionType * ftype ); 148 148 149 149 private: -
src/AST/Type.cpp
reccb14d r954c954 102 102 // --- FunctionType 103 103 104 104 105 FunctionType::FunctionType( const FunctionType & o ) 105 106 : ParameterizedType( o.qualifiers, copy( o.attributes ) ), returns(), params(), … … 112 113 113 114 namespace { 114 bool containsTtype( const std::vector<ptr< DeclWithType>> & l ) {115 bool containsTtype( const std::vector<ptr<Type>> & l ) { 115 116 if ( ! l.empty() ) { 116 return Tuples::isTtype( l.back() ->get_type());117 return Tuples::isTtype( l.back() ); 117 118 } 118 119 return false; -
src/AST/Type.hpp
reccb14d r954c954 302 302 class FunctionType final : public ParameterizedType { 303 303 public: 304 std::vector<ptr<DeclWithType>> returns; 305 std::vector<ptr<DeclWithType>> params; 304 // std::vector<ptr<DeclWithType>> returns; 305 // std::vector<ptr<DeclWithType>> params; 306 307 std::vector<ptr<Type>> returns; 308 std::vector<ptr<Type>> params; 306 309 307 310 /// Does the function accept a variable number of arguments following the arguments specified -
src/InitTweak/InitTweak.cc
reccb14d r954c954 1026 1026 if ( ftype->params.size() != 2 ) return false; 1027 1027 1028 const ast::Type * t1 = getPointerBase( ftype->params.front() ->get_type());1028 const ast::Type * t1 = getPointerBase( ftype->params.front() ); 1029 1029 if ( ! t1 ) return false; 1030 const ast::Type * t2 = ftype->params.back() ->get_type();1030 const ast::Type * t2 = ftype->params.back(); 1031 1031 1032 1032 return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable{} ); -
src/ResolvExpr/CandidateFinder.cpp
reccb14d r954c954 188 188 189 189 // mark conversion cost and also specialization cost of param type 190 const ast::Type * paramType = (*param)->get_type();190 // const ast::Type * paramType = (*param)->get_type(); 191 191 cand->expr = ast::mutate_field_index( 192 192 appExpr, &ast::ApplicationExpr::args, i, 193 193 computeExpressionConversionCost( 194 args[i], paramType, symtab, cand->env, convCost ) );195 convCost.decSpec( specCost( paramType) );194 args[i], *param, symtab, cand->env, convCost ) ); 195 convCost.decSpec( specCost( *param ) ); 196 196 ++param; // can't be in for-loop update because of the continue 197 197 } … … 698 698 if ( targetType && ! targetType->isVoid() && ! funcType->returns.empty() ) { 699 699 // attempt to narrow based on expected target type 700 const ast::Type * returnType = funcType->returns.front() ->get_type();700 const ast::Type * returnType = funcType->returns.front(); 701 701 if ( ! unify( 702 702 returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab ) … … 712 712 std::size_t genStart = 0; 713 713 714 for ( const ast::DeclWithType * param : funcType->params ) { 715 auto obj = strict_dynamic_cast< const ast::ObjectDecl * >( param ); 714 // xxx - how to handle default arg after change to ftype representation? 715 if (const ast::VariableExpr * varExpr = func->expr.as<ast::VariableExpr>()) { 716 if (const ast::FunctionDecl * funcDecl = varExpr->var.as<ast::FunctionDecl>()) { 717 // function may have default args only if directly calling by name 718 // must use types on candidate however, due to RenameVars substitution 719 auto nParams = funcType->params.size(); 720 721 for (size_t i=0; i<nParams; ++i) { 722 auto obj = funcDecl->params[i].strict_as<ast::ObjectDecl>(); 723 if (!instantiateArgument( 724 funcType->params[i], obj->init, args, results, genStart, symtab)) return; 725 } 726 goto endMatch; 727 } 728 } 729 for ( const auto & param : funcType->params ) { 716 730 // Try adding the arguments corresponding to the current parameter to the existing 717 731 // matches 732 // no default args for indirect calls 718 733 if ( ! instantiateArgument( 719 obj->type, obj->init, args, results, genStart, symtab ) ) return; 720 } 721 734 param, nullptr, args, results, genStart, symtab ) ) return; 735 } 736 737 endMatch: 722 738 if ( funcType->isVarArgs ) { 723 739 // append any unused arguments to vararg pack -
src/ResolvExpr/CurrentObject.cc
reccb14d r954c954 594 594 class SimpleIterator final : public MemberIterator { 595 595 CodeLocation location; 596 readonly< Type >type = nullptr;596 const Type * type = nullptr; 597 597 public: 598 598 SimpleIterator( const CodeLocation & loc, const Type * t ) : location( loc ), type( t ) {} … … 630 630 class ArrayIterator final : public MemberIterator { 631 631 CodeLocation location; 632 readonly< ArrayType >array = nullptr;633 readonly< Type >base = nullptr;632 const ArrayType * array = nullptr; 633 const Type * base = nullptr; 634 634 size_t index = 0; 635 635 size_t size = 0; -
src/ResolvExpr/Resolver.cc
reccb14d r954c954 1223 1223 template<typename Iter> 1224 1224 inline bool nextMutex( Iter & it, const Iter & end ) { 1225 while ( it != end && ! (*it)-> get_type()->is_mutex() ) { ++it; }1225 while ( it != end && ! (*it)->is_mutex() ) { ++it; } 1226 1226 return it != end; 1227 1227 } … … 1638 1638 // Check if the argument matches the parameter type in the current 1639 1639 // scope 1640 ast::ptr< ast::Type > paramType = (*param)->get_type();1640 // ast::ptr< ast::Type > paramType = (*param)->get_type(); 1641 1641 if ( 1642 1642 ! unify( 1643 arg->expr->result, paramType, resultEnv, need, have, open,1643 arg->expr->result, *param, resultEnv, need, have, open, 1644 1644 symtab ) 1645 1645 ) { … … 1648 1648 ss << "candidate function not viable: no known conversion " 1649 1649 "from '"; 1650 ast::print( ss, (*param)->get_type());1650 ast::print( ss, *param ); 1651 1651 ss << "' to '"; 1652 1652 ast::print( ss, arg->expr->result ); -
src/ResolvExpr/SatisfyAssertions.cpp
reccb14d r954c954 318 318 if ( ! func ) continue; 319 319 320 for ( const a st::DeclWithType *param : func->params ) {321 cost.decSpec( specCost( param ->get_type()) );320 for ( const auto & param : func->params ) { 321 cost.decSpec( specCost( param ) ); 322 322 } 323 323 -
src/ResolvExpr/SpecCost.cc
reccb14d r954c954 178 178 void previsit( const ast::FunctionType * fty ) { 179 179 int minCount = std::numeric_limits<int>::max(); 180 updateMinimumPresent( minCount, fty->params, decl_type);181 updateMinimumPresent( minCount, fty->returns, decl_type);180 updateMinimumPresent( minCount, fty->params, type_deref ); 181 updateMinimumPresent( minCount, fty->returns, type_deref ); 182 182 // Add another level to minCount if set. 183 183 count = toNoneOrInc( minCount ); -
src/ResolvExpr/Unify.cc
reccb14d r954c954 395 395 396 396 template< typename Iterator1, typename Iterator2 > 397 bool unify DeclList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {397 bool unifyTypeList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) { 398 398 auto get_type = [](DeclarationWithType * dwt){ return dwt->get_type(); }; 399 399 for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) { … … 489 489 || flatOther->isTtype() 490 490 ) { 491 if ( unify DeclList( flatFunc->parameters.begin(), flatFunc->parameters.end(), flatOther->parameters.begin(), flatOther->parameters.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {492 if ( unify DeclList( flatFunc->returnVals.begin(), flatFunc->returnVals.end(), flatOther->returnVals.begin(), flatOther->returnVals.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {491 if ( unifyTypeList( flatFunc->parameters.begin(), flatFunc->parameters.end(), flatOther->parameters.begin(), flatOther->parameters.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) { 492 if ( unifyTypeList( flatFunc->returnVals.begin(), flatFunc->returnVals.end(), flatOther->returnVals.begin(), flatOther->returnVals.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) { 493 493 494 494 // the original types must be used in mark assertions, since pointer comparisons are used … … 784 784 785 785 /// returns flattened version of `src` 786 static std::vector< ast::ptr< ast:: DeclWithType > > flattenList(787 const std::vector< ast::ptr< ast:: DeclWithType > > & src, ast::TypeEnvironment & env786 static std::vector< ast::ptr< ast::Type > > flattenList( 787 const std::vector< ast::ptr< ast::Type > > & src, ast::TypeEnvironment & env 788 788 ) { 789 std::vector< ast::ptr< ast:: DeclWithType > > dst;789 std::vector< ast::ptr< ast::Type > > dst; 790 790 dst.reserve( src.size() ); 791 for ( const a st::DeclWithType *d : src ) {791 for ( const auto & d : src ) { 792 792 ast::Pass<TtypeExpander_new> expander{ env }; 793 793 // TtypeExpander pass is impure (may mutate nodes in place) 794 794 // need to make nodes shared to prevent accidental mutation 795 ast::ptr<ast:: DeclWithType> dc = d->accept(expander);796 auto types = flatten( dc ->get_type());795 ast::ptr<ast::Type> dc = d->accept(expander); 796 auto types = flatten( dc ); 797 797 for ( ast::ptr< ast::Type > & t : types ) { 798 798 // outermost const, volatile, _Atomic qualifiers in parameters should not play … … 803 803 // requirements than a non-mutex function 804 804 remove_qualifiers( t, ast::CV::Const | ast::CV::Volatile | ast::CV::Atomic ); 805 dst.emplace_back( new ast::ObjectDecl{ dc->location, "", t });805 dst.emplace_back( t ); 806 806 } 807 807 } … … 811 811 /// Creates a tuple type based on a list of DeclWithType 812 812 template< typename Iter > 813 static ast::ptr< ast::Type > tupleFrom Decls( Iter crnt, Iter end ) {813 static ast::ptr< ast::Type > tupleFromTypes( Iter crnt, Iter end ) { 814 814 std::vector< ast::ptr< ast::Type > > types; 815 815 while ( crnt != end ) { 816 816 // it is guaranteed that a ttype variable will be bound to a flat tuple, so ensure 817 817 // that this results in a flat tuple 818 flatten( (*crnt)->get_type(), types );818 flatten( *crnt, types ); 819 819 820 820 ++crnt; … … 825 825 826 826 template< typename Iter > 827 static bool unify DeclList(827 static bool unifyTypeList( 828 828 Iter crnt1, Iter end1, Iter crnt2, Iter end2, ast::TypeEnvironment & env, 829 829 ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open, … … 831 831 ) { 832 832 while ( crnt1 != end1 && crnt2 != end2 ) { 833 const ast::Type * t1 = (*crnt1)->get_type();834 const ast::Type * t2 = (*crnt2)->get_type();833 const ast::Type * t1 = *crnt1; 834 const ast::Type * t2 = *crnt2; 835 835 bool isTuple1 = Tuples::isTtype( t1 ); 836 836 bool isTuple2 = Tuples::isTtype( t2 ); … … 840 840 // combine remainder of list2, then unify 841 841 return unifyExact( 842 t1, tupleFrom Decls( crnt2, end2 ), env, need, have, open,842 t1, tupleFromTypes( crnt2, end2 ), env, need, have, open, 843 843 noWiden(), symtab ); 844 844 } else if ( ! isTuple1 && isTuple2 ) { 845 845 // combine remainder of list1, then unify 846 846 return unifyExact( 847 tupleFrom Decls( crnt1, end1 ), t2, env, need, have, open,847 tupleFromTypes( crnt1, end1 ), t2, env, need, have, open, 848 848 noWiden(), symtab ); 849 849 } … … 860 860 if ( crnt1 != end1 ) { 861 861 // try unifying empty tuple with ttype 862 const ast::Type * t1 = (*crnt1)->get_type();862 const ast::Type * t1 = *crnt1; 863 863 if ( ! Tuples::isTtype( t1 ) ) return false; 864 864 return unifyExact( 865 t1, tupleFrom Decls( crnt2, end2 ), env, need, have, open,865 t1, tupleFromTypes( crnt2, end2 ), env, need, have, open, 866 866 noWiden(), symtab ); 867 867 } else if ( crnt2 != end2 ) { 868 868 // try unifying empty tuple with ttype 869 const ast::Type * t2 = (*crnt2)->get_type();869 const ast::Type * t2 = *crnt2; 870 870 if ( ! Tuples::isTtype( t2 ) ) return false; 871 871 return unifyExact( 872 tupleFrom Decls( crnt1, end1 ), t2, env, need, have, open,872 tupleFromTypes( crnt1, end1 ), t2, env, need, have, open, 873 873 noWiden(), symtab ); 874 874 } … … 877 877 } 878 878 879 static bool unify DeclList(880 const std::vector< ast::ptr< ast:: DeclWithType > > & list1,881 const std::vector< ast::ptr< ast:: DeclWithType > > & list2,879 static bool unifyTypeList( 880 const std::vector< ast::ptr< ast::Type > > & list1, 881 const std::vector< ast::ptr< ast::Type > > & list2, 882 882 ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have, 883 883 const ast::OpenVarSet & open, const ast::SymbolTable & symtab 884 884 ) { 885 return unify DeclList(885 return unifyTypeList( 886 886 list1.begin(), list1.end(), list2.begin(), list2.end(), env, need, have, open, 887 887 symtab ); … … 928 928 ) return; 929 929 930 if ( ! unify DeclList( params, params2, tenv, need, have, open, symtab ) ) return;931 if ( ! unify DeclList(930 if ( ! unifyTypeList( params, params2, tenv, need, have, open, symtab ) ) return; 931 if ( ! unifyTypeList( 932 932 func->returns, func2->returns, tenv, need, have, open, symtab ) ) return; 933 933 … … 1232 1232 ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func ) { 1233 1233 if ( func->returns.empty() ) return new ast::VoidType{}; 1234 if ( func->returns.size() == 1 ) return func->returns[0] ->get_type();1234 if ( func->returns.size() == 1 ) return func->returns[0]; 1235 1235 1236 1236 std::vector<ast::ptr<ast::Type>> tys; 1237 for ( const a st::DeclWithType *decl : func->returns ) {1238 tys.emplace_back( decl ->get_type());1237 for ( const auto & decl : func->returns ) { 1238 tys.emplace_back( decl ); 1239 1239 } 1240 1240 return new ast::TupleType{ std::move(tys) }; -
src/SymTab/Mangler.cc
reccb14d r954c954 551 551 GuardValue( inFunctionType ); 552 552 inFunctionType = true; 553 std::vector< ast::ptr< ast::Type > > returnTypes = getTypes( functionType->returns ); 554 if (returnTypes.empty()) mangleName << Encoding::void_t; 555 else accept_each( returnTypes, *visitor ); 553 if (functionType->returns.empty()) mangleName << Encoding::void_t; 554 else accept_each( functionType->returns, *visitor ); 556 555 mangleName << "_"; 557 std::vector< ast::ptr< ast::Type > > paramTypes = getTypes( functionType->params ); 558 accept_each( paramTypes, *visitor ); 556 accept_each( functionType->params, *visitor ); 559 557 mangleName << "_"; 560 558 } -
src/SymTab/Validate.cc
reccb14d r954c954 1384 1384 /// Replaces enum types by int, and function/array types in function parameter and return 1385 1385 /// lists by appropriate pointers 1386 /* 1386 1387 struct EnumAndPointerDecay_new { 1387 1388 const ast::EnumDecl * previsit( const ast::EnumDecl * enumDecl ) { … … 1434 1435 } 1435 1436 }; 1437 */ 1436 1438 1437 1439 /// expand assertions from a trait instance, performing appropriate type variable substitutions … … 1837 1839 const ast::Type * validateType( 1838 1840 const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab ) { 1839 ast::Pass< EnumAndPointerDecay_new > epc;1841 // ast::Pass< EnumAndPointerDecay_new > epc; 1840 1842 ast::Pass< LinkReferenceToTypes_new > lrt{ loc, symtab }; 1841 1843 ast::Pass< ForallPointerDecay_new > fpd{ loc }; 1842 1844 1843 return type->accept( epc )->accept(lrt )->accept( fpd );1845 return type->accept( lrt )->accept( fpd ); 1844 1846 } 1845 1847
Note: See TracChangeset
for help on using the changeset viewer.