Changes in / [6cc913e:cebfcb8]


Ignore:
Files:
1 deleted
17 edited

Legend:

Unmodified
Added
Removed

  • src/AST/Convert.cpp

    r6cc913e rcebfcb8  
    177177        const ast::DeclWithType * visit( const ast::FunctionDecl * node ) override final {
    178178                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 
    194179                auto decl = new FunctionDecl(
    195180                        node->name,
    196181                        Type::StorageClasses( node->storage.val ),
    197182                        LinkageSpec::Spec( node->linkage.val ),
    198                         ftype,
    199                         //get<FunctionType>().accept1( node->type ),
     183                        get<FunctionType>().accept1( node->type ),
    200184                        {},
    201185                        get<Attribute>().acceptL( node->attributes ),
    … …  
    11681152
    11691153        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 
    11731154                auto ty = new FunctionType {
    11741155                        cv( node ),
    11751156                        (bool)node->isVarArgs
    11761157                };
    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 );
     1158                ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
     1159                ty->parameters = get<DeclarationWithType>().acceptL( node->params );
    11941160                ty->forall = get<TypeDecl>().acceptL( node->forall );
    11951161                return visitType( node, ty );
    … …  
    14081374        ast::Node * node = nullptr;
    14091375        /// cache of nodes that might be referenced by readonly<> for de-duplication
    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 = {};
     1376        std::unordered_map< const BaseSyntaxNode *, ast::Node * > cache = {};
    14151377
    14161378        // Local Utilities:
    … …  
    14851447                auto it = cache.find( old );
    14861448                if ( it == cache.end() ) return false;
    1487                 node = const_cast<ast::Node *>(it->second.get());
     1449                node = it->second;
    14881450                return true;
    14891451        }
    … …  
    15241486        virtual void visit( const FunctionDecl * old ) override final {
    15251487                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 
    15441488                auto decl = new ast::FunctionDecl{
    15451489                        old->location,
    15461490                        old->name,
    1547                         // GET_ACCEPT_1(type, FunctionType),
    1548                         std::move(paramVars),
    1549                         std::move(returnVars),
     1491                        GET_ACCEPT_1(type, FunctionType),
    15501492                        {},
    15511493                        { old->storageClasses.val },
    … …  
    15541496                        { old->get_funcSpec().val }
    15551497                };
    1556 
    1557                 decl->type = ftype;
    15581498                cache.emplace( old, decl );
    1559 
    15601499                decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
    15611500                decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);
    … …  
    25762515                        cv( old )
    25772516                };
    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                 }
     2517                ty->returns = GET_ACCEPT_V( returnVals, DeclWithType );
     2518                ty->params = GET_ACCEPT_V( parameters, DeclWithType );
    25882519                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
    25892520                visitType( old, ty );

  • src/AST/Decl.hpp

    r6cc913e rcebfcb8  
    124124class FunctionDecl : public DeclWithType {
    125125public:
    126         std::vector<ptr<DeclWithType>> params;
    127         std::vector<ptr<DeclWithType>> returns;
    128         // declared type, derived from parameter declarations
    129126        ptr<FunctionType> type;
    130127        ptr<CompoundStmt> stmts;
    131128        std::vector< ptr<Expr> > withExprs;
    132129
    133         FunctionDecl( const CodeLocation & loc, const std::string & name,
    134                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
     130        FunctionDecl( const CodeLocation & loc, const std::string & name, FunctionType * type,
    135131                CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
    136132                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {})
    137         : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
     133        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), type( type ),
    138134          stmts( stmts ) {}
    139135

  • src/AST/ForallSubstitutor.hpp

    r6cc913e rcebfcb8  
    3333        }
    3434
    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 
    4535        /// Substitute parameter/return type
    4636        std::vector< ptr< DeclWithType > > operator() ( const std::vector< ptr< DeclWithType > > & o ) {
    … …  
    5848                return n;
    5949        }
    60 
    61         */
    6250};
    6351

  • src/AST/Pass.impl.hpp

    r6cc913e rcebfcb8  
    465465                        __pass::symtab::addId( core, 0, func );
    466466                        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
    471467                                maybe_accept( node, &FunctionDecl::type );
    472468                                // function body needs to have the same scope as parameters - CompoundStmt will not enter

  • src/AST/SymbolTable.cpp

    r6cc913e rcebfcb8  
    335335}
    336336
    337 /*
    338337void SymbolTable::addFunctionType( const FunctionType * ftype ) {
    339338        addTypes( ftype->forall );
    … …  
    341340        addIds( ftype->params );
    342341}
    343 */
    344342
    345343void SymbolTable::lazyInitScope() {
    … …  
    370368                assert( ! params.empty() );
    371369                // use base type of pointer, so that qualifiers on the pointer type aren't considered.
    372                 const Type * base = InitTweak::getPointerBase( params.front() );
     370                const Type * base = InitTweak::getPointerBase( params.front()->get_type() );
    373371                assert( base );
    374372                return Mangle::mangle( base );

  • src/AST/SymbolTable.hpp

    r6cc913e rcebfcb8  
    145145
    146146        /// 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 );
    148148
    149149private:

  • src/AST/Type.cpp

    r6cc913e rcebfcb8  
    102102// --- FunctionType
    103103
    104 
    105104FunctionType::FunctionType( const FunctionType & o )
    106105: ParameterizedType( o.qualifiers, copy( o.attributes ) ), returns(), params(),
    … …  
    113112
    114113namespace {
    115         bool containsTtype( const std::vector<ptr<Type>> & l ) {
     114        bool containsTtype( const std::vector<ptr<DeclWithType>> & l ) {
    116115                if ( ! l.empty() ) {
    117                         return Tuples::isTtype( l.back() );
     116                        return Tuples::isTtype( l.back()->get_type() );
    118117                }
    119118                return false;

  • src/AST/Type.hpp

    r6cc913e rcebfcb8  
    302302class FunctionType final : public ParameterizedType {
    303303public:
    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;
     304        std::vector<ptr<DeclWithType>> returns;
     305        std::vector<ptr<DeclWithType>> params;
    309306
    310307        /// Does the function accept a variable number of arguments following the arguments specified

  • src/InitTweak/InitTweak.cc

    r6cc913e rcebfcb8  
    10261026                if ( ftype->params.size() != 2 ) return false;
    10271027
    1028                 const ast::Type * t1 = getPointerBase( ftype->params.front() );
     1028                const ast::Type * t1 = getPointerBase( ftype->params.front()->get_type() );
    10291029                if ( ! t1 ) return false;
    1030                 const ast::Type * t2 = ftype->params.back();
     1030                const ast::Type * t2 = ftype->params.back()->get_type();
    10311031
    10321032                return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable{} );

  • src/ResolvExpr/CandidateFinder.cpp

    r6cc913e rcebfcb8  
    188188
    189189                        // 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();
    191191                        cand->expr = ast::mutate_field_index(
    192192                                appExpr, &ast::ApplicationExpr::args, i,
    193193                                computeExpressionConversionCost(
    194                                         args[i], *param, symtab, cand->env, convCost ) );
    195                         convCost.decSpec( specCost( *param ) );
     194                                        args[i], paramType, symtab, cand->env, convCost ) );
     195                        convCost.decSpec( specCost( paramType ) );
    196196                        ++param;  // can't be in for-loop update because of the continue
    197197                }
    … …  
    698698                        if ( targetType && ! targetType->isVoid() && ! funcType->returns.empty() ) {
    699699                                // attempt to narrow based on expected target type
    700                                 const ast::Type * returnType = funcType->returns.front();
     700                                const ast::Type * returnType = funcType->returns.front()->get_type();
    701701                                if ( ! unify(
    702702                                        returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab )
    … …  
    712712                        std::size_t genStart = 0;
    713713
    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 ) {
     714                        for ( const ast::DeclWithType * param : funcType->params ) {
     715                                auto obj = strict_dynamic_cast< const ast::ObjectDecl * >( param );
    730716                                // Try adding the arguments corresponding to the current parameter to the existing
    731717                                // matches
    732                                 // no default args for indirect calls
    733718                                if ( ! instantiateArgument(
    734                                         param, nullptr, args, results, genStart, symtab ) ) return;
    735                         }
    736 
    737                         endMatch:
     719                                        obj->type, obj->init, args, results, genStart, symtab ) ) return;
     720                        }
     721
    738722                        if ( funcType->isVarArgs ) {
    739723                                // append any unused arguments to vararg pack

  • src/ResolvExpr/CurrentObject.cc

    r6cc913e rcebfcb8  
    594594        class SimpleIterator final : public MemberIterator {
    595595                CodeLocation location;
    596                 const Type * type = nullptr;
     596                readonly< Type > type = nullptr;
    597597        public:
    598598                SimpleIterator( const CodeLocation & loc, const Type * t ) : location( loc ), type( t ) {}
    … …  
    630630        class ArrayIterator final : public MemberIterator {
    631631                CodeLocation location;
    632                 const ArrayType * array = nullptr;
    633                 const Type * base = nullptr;
     632                readonly< ArrayType > array = nullptr;
     633                readonly< Type > base = nullptr;
    634634                size_t index = 0;
    635635                size_t size = 0;

  • src/ResolvExpr/Resolver.cc

    r6cc913e rcebfcb8  
    12231223                template<typename Iter>
    12241224                inline bool nextMutex( Iter & it, const Iter & end ) {
    1225                         while ( it != end && ! (*it)->is_mutex() ) { ++it; }
     1225                        while ( it != end && ! (*it)->get_type()->is_mutex() ) { ++it; }
    12261226                        return it != end;
    12271227                }
    … …  
    16381638                                                                // Check if the argument matches the parameter type in the current
    16391639                                                                // scope
    1640                                                                 // ast::ptr< ast::Type > paramType = (*param)->get_type();
     1640                                                                ast::ptr< ast::Type > paramType = (*param)->get_type();
    16411641                                                                if (
    16421642                                                                        ! unify(
    1643                                                                                 arg->expr->result, *param, resultEnv, need, have, open,
     1643                                                                                arg->expr->result, paramType, resultEnv, need, have, open,
    16441644                                                                                symtab )
    16451645                                                                ) {
    … …  
    16481648                                                                        ss << "candidate function not viable: no known conversion "
    16491649                                                                                "from '";
    1650                                                                         ast::print( ss, *param );
     1650                                                                        ast::print( ss, (*param)->get_type() );
    16511651                                                                        ss << "' to '";
    16521652                                                                        ast::print( ss, arg->expr->result );

  • src/ResolvExpr/SatisfyAssertions.cpp

    r6cc913e rcebfcb8  
    318318                                        if ( ! func ) continue;
    319319
    320                                         for ( const auto & param : func->params ) {
    321                                                 cost.decSpec( specCost( param ) );
     320                                        for ( const ast::DeclWithType * param : func->params ) {
     321                                                cost.decSpec( specCost( param->get_type() ) );
    322322                                        }
    323323

  • src/ResolvExpr/SpecCost.cc

    r6cc913e rcebfcb8  
    178178                void previsit( const ast::FunctionType * fty ) {
    179179                        int minCount = std::numeric_limits<int>::max();
    180                         updateMinimumPresent( minCount, fty->params, type_deref );
    181                         updateMinimumPresent( minCount, fty->returns, type_deref );
     180                        updateMinimumPresent( minCount, fty->params, decl_type );
     181                        updateMinimumPresent( minCount, fty->returns, decl_type );
    182182                        // Add another level to minCount if set.
    183183                        count = toNoneOrInc( minCount );

  • src/ResolvExpr/Unify.cc

    r6cc913e rcebfcb8  
    395395
    396396        template< typename Iterator1, typename Iterator2 >
    397         bool unifyTypeList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
     397        bool unifyDeclList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
    398398                auto get_type = [](DeclarationWithType * dwt){ return dwt->get_type(); };
    399399                for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
    … …  
    489489                                        || flatOther->isTtype()
    490490                        ) {
    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 ) ) {
     491                                if ( unifyDeclList( flatFunc->parameters.begin(), flatFunc->parameters.end(), flatOther->parameters.begin(), flatOther->parameters.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
     492                                        if ( unifyDeclList( flatFunc->returnVals.begin(), flatFunc->returnVals.end(), flatOther->returnVals.begin(), flatOther->returnVals.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
    493493
    494494                                                // the original types must be used in mark assertions, since pointer comparisons are used
    … …  
    784784
    785785                /// returns flattened version of `src`
    786                 static std::vector< ast::ptr< ast::Type > > flattenList(
    787                         const std::vector< ast::ptr< ast::Type > > & src, ast::TypeEnvironment & env
     786                static std::vector< ast::ptr< ast::DeclWithType > > flattenList(
     787                        const std::vector< ast::ptr< ast::DeclWithType > > & src, ast::TypeEnvironment & env
    788788                ) {
    789                         std::vector< ast::ptr< ast::Type > > dst;
     789                        std::vector< ast::ptr< ast::DeclWithType > > dst;
    790790                        dst.reserve( src.size() );
    791                         for ( const auto & d : src ) {
     791                        for ( const ast::DeclWithType * d : src ) {
    792792                                ast::Pass<TtypeExpander_new> expander{ env };
    793793                                // TtypeExpander pass is impure (may mutate nodes in place)
    794794                                // need to make nodes shared to prevent accidental mutation
    795                                 ast::ptr<ast::Type> dc = d->accept(expander);
    796                                 auto types = flatten( dc );
     795                                ast::ptr<ast::DeclWithType> dc = d->accept(expander);
     796                                auto types = flatten( dc->get_type() );
    797797                                for ( ast::ptr< ast::Type > & t : types ) {
    798798                                        // outermost const, volatile, _Atomic qualifiers in parameters should not play
    … …  
    803803                                        // requirements than a non-mutex function
    804804                                        remove_qualifiers( t, ast::CV::Const | ast::CV::Volatile | ast::CV::Atomic );
    805                                         dst.emplace_back( t );
     805                                        dst.emplace_back( new ast::ObjectDecl{ dc->location, "", t } );
    806806                                }
    807807                        }
    … …  
    811811                /// Creates a tuple type based on a list of DeclWithType
    812812                template< typename Iter >
    813                 static ast::ptr< ast::Type > tupleFromTypes( Iter crnt, Iter end ) {
     813                static ast::ptr< ast::Type > tupleFromDecls( Iter crnt, Iter end ) {
    814814                        std::vector< ast::ptr< ast::Type > > types;
    815815                        while ( crnt != end ) {
    816816                                // it is guaranteed that a ttype variable will be bound to a flat tuple, so ensure
    817817                                // that this results in a flat tuple
    818                                 flatten( *crnt, types );
     818                                flatten( (*crnt)->get_type(), types );
    819819
    820820                                ++crnt;
    … …  
    825825
    826826                template< typename Iter >
    827                 static bool unifyTypeList(
     827                static bool unifyDeclList(
    828828                        Iter crnt1, Iter end1, Iter crnt2, Iter end2, ast::TypeEnvironment & env,
    829829                        ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
    … …  
    831831                ) {
    832832                        while ( crnt1 != end1 && crnt2 != end2 ) {
    833                                 const ast::Type * t1 = *crnt1;
    834                                 const ast::Type * t2 = *crnt2;
     833                                const ast::Type * t1 = (*crnt1)->get_type();
     834                                const ast::Type * t2 = (*crnt2)->get_type();
    835835                                bool isTuple1 = Tuples::isTtype( t1 );
    836836                                bool isTuple2 = Tuples::isTtype( t2 );
    … …  
    840840                                        // combine remainder of list2, then unify
    841841                                        return unifyExact(
    842                                                 t1, tupleFromTypes( crnt2, end2 ), env, need, have, open,
     842                                                t1, tupleFromDecls( crnt2, end2 ), env, need, have, open,
    843843                                                noWiden(), symtab );
    844844                                } else if ( ! isTuple1 && isTuple2 ) {
    845845                                        // combine remainder of list1, then unify
    846846                                        return unifyExact(
    847                                                 tupleFromTypes( crnt1, end1 ), t2, env, need, have, open,
     847                                                tupleFromDecls( crnt1, end1 ), t2, env, need, have, open,
    848848                                                noWiden(), symtab );
    849849                                }
    … …  
    860860                        if ( crnt1 != end1 ) {
    861861                                // try unifying empty tuple with ttype
    862                                 const ast::Type * t1 = *crnt1;
     862                                const ast::Type * t1 = (*crnt1)->get_type();
    863863                                if ( ! Tuples::isTtype( t1 ) ) return false;
    864864                                return unifyExact(
    865                                         t1, tupleFromTypes( crnt2, end2 ), env, need, have, open,
     865                                        t1, tupleFromDecls( crnt2, end2 ), env, need, have, open,
    866866                                        noWiden(), symtab );
    867867                        } else if ( crnt2 != end2 ) {
    868868                                // try unifying empty tuple with ttype
    869                                 const ast::Type * t2 = *crnt2;
     869                                const ast::Type * t2 = (*crnt2)->get_type();
    870870                                if ( ! Tuples::isTtype( t2 ) ) return false;
    871871                                return unifyExact(
    872                                         tupleFromTypes( crnt1, end1 ), t2, env, need, have, open,
     872                                        tupleFromDecls( crnt1, end1 ), t2, env, need, have, open,
    873873                                        noWiden(), symtab );
    874874                        }
    … …  
    877877                }
    878878
    879                 static bool unifyTypeList(
    880                         const std::vector< ast::ptr< ast::Type > > & list1,
    881                         const std::vector< ast::ptr< ast::Type > > & list2,
     879                static bool unifyDeclList(
     880                        const std::vector< ast::ptr< ast::DeclWithType > > & list1,
     881                        const std::vector< ast::ptr< ast::DeclWithType > > & list2,
    882882                        ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
    883883                        const ast::OpenVarSet & open, const ast::SymbolTable & symtab
    884884                ) {
    885                         return unifyTypeList(
     885                        return unifyDeclList(
    886886                                list1.begin(), list1.end(), list2.begin(), list2.end(), env, need, have, open,
    887887                                symtab );
    … …  
    928928                        ) return;
    929929
    930                         if ( ! unifyTypeList( params, params2, tenv, need, have, open, symtab ) ) return;
    931                         if ( ! unifyTypeList(
     930                        if ( ! unifyDeclList( params, params2, tenv, need, have, open, symtab ) ) return;
     931                        if ( ! unifyDeclList(
    932932                                func->returns, func2->returns, tenv, need, have, open, symtab ) ) return;
    933933
    … …  
    12321232        ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func ) {
    12331233                if ( func->returns.empty() ) return new ast::VoidType{};
    1234                 if ( func->returns.size() == 1 ) return func->returns[0];
     1234                if ( func->returns.size() == 1 ) return func->returns[0]->get_type();
    12351235
    12361236                std::vector<ast::ptr<ast::Type>> tys;
    1237                 for ( const auto & decl : func->returns ) {
    1238                         tys.emplace_back( decl );
     1237                for ( const ast::DeclWithType * decl : func->returns ) {
     1238                        tys.emplace_back( decl->get_type() );
    12391239                }
    12401240                return new ast::TupleType{ std::move(tys) };

  • src/SymTab/Mangler.cc

    r6cc913e rcebfcb8  
    551551                        GuardValue( inFunctionType );
    552552                        inFunctionType = true;
    553                         if (functionType->returns.empty()) mangleName << Encoding::void_t;
    554                         else accept_each( functionType->returns, *visitor );
     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 );
    555556                        mangleName << "_";
    556                         accept_each( functionType->params, *visitor );
     557                        std::vector< ast::ptr< ast::Type > > paramTypes = getTypes( functionType->params );
     558                        accept_each( paramTypes, *visitor );
    557559                        mangleName << "_";
    558560                }

  • src/SymTab/Validate.cc

    r6cc913e rcebfcb8  
    13841384        /// Replaces enum types by int, and function/array types in function parameter and return
    13851385        /// lists by appropriate pointers
    1386         /*
    13871386        struct EnumAndPointerDecay_new {
    13881387                const ast::EnumDecl * previsit( const ast::EnumDecl * enumDecl ) {
    … …  
    14351434                }
    14361435        };
    1437         */
    14381436
    14391437        /// expand assertions from a trait instance, performing appropriate type variable substitutions
    … …  
    18391837const ast::Type * validateType(
    18401838                const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab ) {
    1841         // ast::Pass< EnumAndPointerDecay_new > epc;
     1839        ast::Pass< EnumAndPointerDecay_new > epc;
    18421840        ast::Pass< LinkReferenceToTypes_new > lrt{ loc, symtab };
    18431841        ast::Pass< ForallPointerDecay_new > fpd{ loc };
    18441842
    1845         return type->accept( lrt )->accept( fpd );
     1843        return type->accept( epc )->accept( lrt )->accept( fpd );
    18461844}
    18471845
Note: See TracChangeset for help on using the changeset viewer.