Changeset 954c954

Timestamp:

Sep 24, 2020, 3:56:16 PM (4 years ago)

Author:

Fangren Yu <f37yu@…>

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

Message:

Move function argument and return variable declarations from FunctionType? to FunctionDecl?

Files:

• doc/proposals/function_type_change.md (added)
• src/AST/Convert.cpp (modified) (7 diffs)
• src/AST/Decl.hpp (modified) (1 diff)
• src/AST/ForallSubstitutor.hpp (modified) (2 diffs)
• src/AST/Pass.impl.hpp (modified) (1 diff)
• src/AST/SymbolTable.cpp (modified) (3 diffs)
• src/AST/SymbolTable.hpp (modified) (1 diff)
• src/AST/Type.cpp (modified) (2 diffs)
• src/AST/Type.hpp (modified) (1 diff)
• src/InitTweak/InitTweak.cc (modified) (1 diff)
• src/ResolvExpr/CandidateFinder.cpp (modified) (3 diffs)
• src/ResolvExpr/CurrentObject.cc (modified) (2 diffs)
• src/ResolvExpr/Resolver.cc (modified) (3 diffs)
• src/ResolvExpr/SatisfyAssertions.cpp (modified) (1 diff)
• src/ResolvExpr/SpecCost.cc (modified) (1 diff)
• src/ResolvExpr/Unify.cc (modified) (12 diffs)
• src/SymTab/Mangler.cc (modified) (1 diff)
• src/SymTab/Validate.cc (modified) (3 diffs)

src/AST/Convert.cpp

@@ -177 +177 @@
         const ast::DeclWithType * visit( const ast::FunctionDecl * node ) override final {
                 if ( inCache( node ) ) return nullptr;
+
+                // function decl contains real variables that the type must use.
+                // the structural change means function type in and out of decl
+                // must be handled **differently** on convert back to old.
+                auto ftype = new FunctionType(
+                        cv(node->type),
+                        (bool)node->type->isVarArgs
+                );
+                ftype->returnVals = get<DeclarationWithType>().acceptL(node->returns);
+                ftype->parameters = get<DeclarationWithType>().acceptL(node->params);
+
+                ftype->forall = get<TypeDecl>().acceptL( node->type->forall );
+
+                visitType(node->type, ftype);
+
                 auto decl = new FunctionDecl(
                         node->name,
                         Type::StorageClasses( node->storage.val ),
                         LinkageSpec::Spec( node->linkage.val ),
-                        get<FunctionType>().accept1( node->type ),
+                        ftype,
+                        //get<FunctionType>().accept1( node->type ),
                         {},
                         get<Attribute>().acceptL( node->attributes ),
@@ -1152 +1168 @@
 
         const ast::Type * visit( const ast::FunctionType * node ) override final {
+                static std::string dummy_paramvar_prefix = "__param_";
+                static std::string dummy_returnvar_prefix = "__retval_";
+
                 auto ty = new FunctionType {
                         cv( node ),
                         (bool)node->isVarArgs
                 };
-                ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
-                ty->parameters = get<DeclarationWithType>().acceptL( node->params );
+                auto returns = get<Type>().acceptL(node->returns);
+                auto params = get<Type>().acceptL(node->params);
+
+                int ret_index = 0;
+                for (auto t: returns) {
+                        // xxx - LinkageSpec shouldn't matter but needs to be something
+                        ObjectDecl * dummy = new ObjectDecl(dummy_returnvar_prefix + std::to_string(ret_index++), {}, LinkageSpec::C, nullptr, t, nullptr);
+                        ty->returnVals.push_back(dummy);
+                }
+                int param_index = 0;
+                for (auto t: params) {
+                        ObjectDecl * dummy = new ObjectDecl(dummy_paramvar_prefix + std::to_string(param_index++), {}, LinkageSpec::C, nullptr, t, nullptr);
+                        ty->parameters.push_back(dummy);
+                }
+
+                // ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
+                // ty->parameters = get<DeclarationWithType>().acceptL( node->params );
                 ty->forall = get<TypeDecl>().acceptL( node->forall );
                 return visitType( node, ty );
@@ -1374 +1408 @@
         ast::Node * node = nullptr;
         /// cache of nodes that might be referenced by readonly<> for de-duplication
-        std::unordered_map< const BaseSyntaxNode *, ast::Node * > cache = {};
+        /// in case that some nodes are dropped by conversion (due to possible structural change)
+        /// use smart pointers in cache value to prevent accidental invalidation.
+        /// at conversion stage, all created nodes are guaranteed to be unique, therefore
+        /// const_casting out of smart pointers is permitted.
+        std::unordered_map< const BaseSyntaxNode *, ast::ptr<ast::Node> > cache = {};
 
         // Local Utilities:
@@ -1447 +1485 @@
                 auto it = cache.find( old );
                 if ( it == cache.end() ) return false;
-                node = it->second;
+                node = const_cast<ast::Node *>(it->second.get());
                 return true;
         }
@@ -1486 +1524 @@
         virtual void visit( const FunctionDecl * old ) override final {
                 if ( inCache( old ) ) return;
+                auto paramVars = GET_ACCEPT_V(type->parameters, DeclWithType);
+                auto returnVars = GET_ACCEPT_V(type->returnVals, DeclWithType);
+                auto forall = GET_ACCEPT_V(type->forall, TypeDecl);
+
+                // function type is now derived from parameter decls instead of storing them
+                auto ftype = new ast::FunctionType((ast::ArgumentFlag)old->type->isVarArgs, cv(old->type));
+                ftype->params.reserve(paramVars.size());
+                ftype->returns.reserve(returnVars.size());
+
+                for (auto & v: paramVars) {
+                        ftype->params.emplace_back(v->get_type());
+                }
+                for (auto & v: returnVars) {
+                        ftype->returns.emplace_back(v->get_type());
+                }
+                ftype->forall = std::move(forall);
+                visitType(old->type, ftype);
+
                 auto decl = new ast::FunctionDecl{
                         old->location,
                         old->name,
-                        GET_ACCEPT_1(type, FunctionType),
+                        // GET_ACCEPT_1(type, FunctionType),
+                        std::move(paramVars),
+                        std::move(returnVars),
                         {},
                         { old->storageClasses.val },
@@ -1496 +1554 @@
                         { old->get_funcSpec().val }
                 };
+
+                decl->type = ftype;
                 cache.emplace( old, decl );
+
                 decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
                 decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);
@@ -2515 +2576 @@
                         cv( old )
                 };
-                ty->returns = GET_ACCEPT_V( returnVals, DeclWithType );
-                ty->params = GET_ACCEPT_V( parameters, DeclWithType );
+                auto returnVars = GET_ACCEPT_V(returnVals, DeclWithType);
+                auto paramVars = GET_ACCEPT_V(parameters, DeclWithType);
+                // ty->returns = GET_ACCEPT_V( returnVals, DeclWithType );
+                // ty->params = GET_ACCEPT_V( parameters, DeclWithType );
+                for (auto & v: returnVars) {
+                        ty->returns.emplace_back(v->get_type());
+                }
+                for (auto & v: paramVars) {
+                        ty->params.emplace_back(v->get_type());
+                }
                 ty->forall = GET_ACCEPT_V( forall, TypeDecl );
                 visitType( old, ty );

src/AST/Decl.hpp

@@ -124 +124 @@
 class FunctionDecl : public DeclWithType {
 public:
+        std::vector<ptr<DeclWithType>> params;
+        std::vector<ptr<DeclWithType>> returns;
+        // declared type, derived from parameter declarations
         ptr<FunctionType> type;
         ptr<CompoundStmt> stmts;
         std::vector< ptr<Expr> > withExprs;
 
-        FunctionDecl( const CodeLocation & loc, const std::string & name, FunctionType * type,
+        FunctionDecl( const CodeLocation & loc, const std::string & name, 
+                std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
                 std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {})
-        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), type( type ),
+        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
           stmts( stmts ) {}
 

src/AST/ForallSubstitutor.hpp

@@ -33 +33 @@
         }
 
+        template<typename node_t > 
+        std::vector<ptr<node_t>> operator() (const std::vector<ptr<node_t>> & o) {
+                std::vector<ptr<node_t>> n;
+                n.reserve(o.size());
+                for (const node_t * d : o) { n.emplace_back(d->accept(*visitor)); }
+                return n;
+        }
+        
+        /*
+
         /// Substitute parameter/return type
         std::vector< ptr< DeclWithType > > operator() ( const std::vector< ptr< DeclWithType > > & o ) {
@@ -48 +58 @@
                 return n;
         }
+
+        */
 };
 

src/AST/Pass.impl.hpp

@@ -465 +465 @@
                         __pass::symtab::addId( core, 0, func );
                         VISIT(
+                                // parameter declarations are now directly here
+                                maybe_accept( node, &FunctionDecl::params );
+                                maybe_accept( node, &FunctionDecl::returns );
+                                // foralls are still in function type
                                 maybe_accept( node, &FunctionDecl::type );
                                 // function body needs to have the same scope as parameters - CompoundStmt will not enter

src/AST/SymbolTable.cpp

@@ -335 +335 @@
 }
 
+/*
 void SymbolTable::addFunctionType( const FunctionType * ftype ) {
         addTypes( ftype->forall );
@@ -340 +341 @@
         addIds( ftype->params );
 }
+*/
 
 void SymbolTable::lazyInitScope() {
@@ -368 +370 @@
                 assert( ! params.empty() );
                 // use base type of pointer, so that qualifiers on the pointer type aren't considered.
-                const Type * base = InitTweak::getPointerBase( params.front()->get_type() );
+                const Type * base = InitTweak::getPointerBase( params.front() );
                 assert( base );
                 return Mangle::mangle( base );

src/AST/SymbolTable.hpp

@@ -145 +145 @@
 
         /// convenience function for adding all of the declarations in a function type to the indexer
-        void addFunctionType( const FunctionType * ftype );
+        // void addFunctionType( const FunctionType * ftype );
 
 private:

src/AST/Type.cpp

@@ -102 +102 @@
 // --- FunctionType
 
+
 FunctionType::FunctionType( const FunctionType & o )
 : ParameterizedType( o.qualifiers, copy( o.attributes ) ), returns(), params(),
@@ -112 +113 @@
 
 namespace {
-        bool containsTtype( const std::vector<ptr<DeclWithType>> & l ) {
+        bool containsTtype( const std::vector<ptr<Type>> & l ) {
                 if ( ! l.empty() ) {
-                        return Tuples::isTtype( l.back()->get_type() );
+                        return Tuples::isTtype( l.back() );
                 }
                 return false;

src/AST/Type.hpp

@@ -302 +302 @@
 class FunctionType final : public ParameterizedType {
 public:
-        std::vector<ptr<DeclWithType>> returns;
-        std::vector<ptr<DeclWithType>> params;
+//      std::vector<ptr<DeclWithType>> returns;
+//      std::vector<ptr<DeclWithType>> params;
+
+        std::vector<ptr<Type>> returns;
+        std::vector<ptr<Type>> params;
 
         /// Does the function accept a variable number of arguments following the arguments specified

src/InitTweak/InitTweak.cc

@@ -1026 +1026 @@
                 if ( ftype->params.size() != 2 ) return false;
 
-                const ast::Type * t1 = getPointerBase( ftype->params.front()->get_type() );
+                const ast::Type * t1 = getPointerBase( ftype->params.front() );
                 if ( ! t1 ) return false;
-                const ast::Type * t2 = ftype->params.back()->get_type();
+                const ast::Type * t2 = ftype->params.back();
 
                 return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable{} );

src/ResolvExpr/CandidateFinder.cpp

@@ -188 +188 @@
 
                         // mark conversion cost and also specialization cost of param type
-                        const ast::Type * paramType = (*param)->get_type();
+                        // const ast::Type * paramType = (*param)->get_type();
                         cand->expr = ast::mutate_field_index(
                                 appExpr, &ast::ApplicationExpr::args, i,
                                 computeExpressionConversionCost(
-                                        args[i], paramType, symtab, cand->env, convCost ) );
-                        convCost.decSpec( specCost( paramType ) );
+                                        args[i], *param, symtab, cand->env, convCost ) );
+                        convCost.decSpec( specCost( *param ) );
                         ++param;  // can't be in for-loop update because of the continue
                 }
@@ -698 +698 @@
                         if ( targetType && ! targetType->isVoid() && ! funcType->returns.empty() ) {
                                 // attempt to narrow based on expected target type
-                                const ast::Type * returnType = funcType->returns.front()->get_type();
+                                const ast::Type * returnType = funcType->returns.front();
                                 if ( ! unify(
                                         returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab )
@@ -712 +712 @@
                         std::size_t genStart = 0;
 
-                        for ( const ast::DeclWithType * param : funcType->params ) {
-                                auto obj = strict_dynamic_cast< const ast::ObjectDecl * >( param );
+                        // xxx - how to handle default arg after change to ftype representation?
+                        if (const ast::VariableExpr * varExpr = func->expr.as<ast::VariableExpr>()) {
+                                if (const ast::FunctionDecl * funcDecl = varExpr->var.as<ast::FunctionDecl>()) {
+                                        // function may have default args only if directly calling by name
+                                        // must use types on candidate however, due to RenameVars substitution
+                                        auto nParams = funcType->params.size();
+
+                                        for (size_t i=0; i<nParams; ++i) {
+                                                auto obj = funcDecl->params[i].strict_as<ast::ObjectDecl>();
+                                                if (!instantiateArgument(
+                                                        funcType->params[i], obj->init, args, results, genStart, symtab)) return;
+                                        }
+                                        goto endMatch;
+                                }
+                        }
+                        for ( const auto & param : funcType->params ) {
                                 // Try adding the arguments corresponding to the current parameter to the existing
                                 // matches
+                                // no default args for indirect calls
                                 if ( ! instantiateArgument(
-                                        obj->type, obj->init, args, results, genStart, symtab ) ) return;
-                        }
-
+                                        param, nullptr, args, results, genStart, symtab ) ) return;
+                        }
+
+                        endMatch:
                         if ( funcType->isVarArgs ) {
                                 // append any unused arguments to vararg pack

src/ResolvExpr/CurrentObject.cc

@@ -594 +594 @@
         class SimpleIterator final : public MemberIterator {
                 CodeLocation location;
-                readonly< Type > type = nullptr;
+                const Type * type = nullptr;
         public:
                 SimpleIterator( const CodeLocation & loc, const Type * t ) : location( loc ), type( t ) {}
@@ -630 +630 @@
         class ArrayIterator final : public MemberIterator {
                 CodeLocation location;
-                readonly< ArrayType > array = nullptr;
-                readonly< Type > base = nullptr;
+                const ArrayType * array = nullptr;
+                const Type * base = nullptr;
                 size_t index = 0;
                 size_t size = 0;

src/ResolvExpr/Resolver.cc

@@ -1223 +1223 @@
                 template<typename Iter>
                 inline bool nextMutex( Iter & it, const Iter & end ) {
-                        while ( it != end && ! (*it)->get_type()->is_mutex() ) { ++it; }
+                        while ( it != end && ! (*it)->is_mutex() ) { ++it; }
                         return it != end;
                 }
@@ -1638 +1638 @@
                                                                 // Check if the argument matches the parameter type in the current
                                                                 // scope
-                                                                ast::ptr< ast::Type > paramType = (*param)->get_type();
+                                                                // ast::ptr< ast::Type > paramType = (*param)->get_type();
                                                                 if (
                                                                         ! unify(
-                                                                                arg->expr->result, paramType, resultEnv, need, have, open,
+                                                                                arg->expr->result, *param, resultEnv, need, have, open,
                                                                                 symtab )
                                                                 ) {
@@ -1648 +1648 @@
                                                                         ss << "candidate function not viable: no known conversion "
                                                                                 "from '";
-                                                                        ast::print( ss, (*param)->get_type() );
+                                                                        ast::print( ss, *param );
                                                                         ss << "' to '";
                                                                         ast::print( ss, arg->expr->result );

src/ResolvExpr/SatisfyAssertions.cpp

@@ -318 +318 @@
                                         if ( ! func ) continue;
 
-                                        for ( const ast::DeclWithType * param : func->params ) {
-                                                cost.decSpec( specCost( param->get_type() ) );
+                                        for ( const auto & param : func->params ) {
+                                                cost.decSpec( specCost( param ) );
                                         }
 

src/ResolvExpr/SpecCost.cc

@@ -178 +178 @@
                 void previsit( const ast::FunctionType * fty ) {
                         int minCount = std::numeric_limits<int>::max();
-                        updateMinimumPresent( minCount, fty->params, decl_type );
-                        updateMinimumPresent( minCount, fty->returns, decl_type );
+                        updateMinimumPresent( minCount, fty->params, type_deref );
+                        updateMinimumPresent( minCount, fty->returns, type_deref );
                         // Add another level to minCount if set.
                         count = toNoneOrInc( minCount );

src/ResolvExpr/Unify.cc

@@ -395 +395 @@
 
         template< typename Iterator1, typename Iterator2 >
-        bool unifyDeclList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
+        bool unifyTypeList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
                 auto get_type = [](DeclarationWithType * dwt){ return dwt->get_type(); };
                 for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
@@ -489 +489 @@
                                         || flatOther->isTtype()
                         ) {
-                                if ( unifyDeclList( flatFunc->parameters.begin(), flatFunc->parameters.end(), flatOther->parameters.begin(), flatOther->parameters.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
-                                        if ( unifyDeclList( flatFunc->returnVals.begin(), flatFunc->returnVals.end(), flatOther->returnVals.begin(), flatOther->returnVals.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
+                                if ( unifyTypeList( flatFunc->parameters.begin(), flatFunc->parameters.end(), flatOther->parameters.begin(), flatOther->parameters.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
+                                        if ( unifyTypeList( flatFunc->returnVals.begin(), flatFunc->returnVals.end(), flatOther->returnVals.begin(), flatOther->returnVals.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
 
                                                 // the original types must be used in mark assertions, since pointer comparisons are used
@@ -784 +784 @@
 
                 /// returns flattened version of `src`
-                static std::vector< ast::ptr< ast::DeclWithType > > flattenList(
-                        const std::vector< ast::ptr< ast::DeclWithType > > & src, ast::TypeEnvironment & env
+                static std::vector< ast::ptr< ast::Type > > flattenList(
+                        const std::vector< ast::ptr< ast::Type > > & src, ast::TypeEnvironment & env
                 ) {
-                        std::vector< ast::ptr< ast::DeclWithType > > dst;
+                        std::vector< ast::ptr< ast::Type > > dst;
                         dst.reserve( src.size() );
-                        for ( const ast::DeclWithType * d : src ) {
+                        for ( const auto & d : src ) {
                                 ast::Pass<TtypeExpander_new> expander{ env };
                                 // TtypeExpander pass is impure (may mutate nodes in place)
                                 // need to make nodes shared to prevent accidental mutation
-                                ast::ptr<ast::DeclWithType> dc = d->accept(expander);
-                                auto types = flatten( dc->get_type() );
+                                ast::ptr<ast::Type> dc = d->accept(expander);
+                                auto types = flatten( dc );
                                 for ( ast::ptr< ast::Type > & t : types ) {
                                         // outermost const, volatile, _Atomic qualifiers in parameters should not play
@@ -803 +803 @@
                                         // requirements than a non-mutex function
                                         remove_qualifiers( t, ast::CV::Const | ast::CV::Volatile | ast::CV::Atomic );
-                                        dst.emplace_back( new ast::ObjectDecl{ dc->location, "", t } );
+                                        dst.emplace_back( t );
                                 }
                         }
@@ -811 +811 @@
                 /// Creates a tuple type based on a list of DeclWithType
                 template< typename Iter >
-                static ast::ptr< ast::Type > tupleFromDecls( Iter crnt, Iter end ) {
+                static ast::ptr< ast::Type > tupleFromTypes( Iter crnt, Iter end ) {
                         std::vector< ast::ptr< ast::Type > > types;
                         while ( crnt != end ) {
                                 // it is guaranteed that a ttype variable will be bound to a flat tuple, so ensure
                                 // that this results in a flat tuple
-                                flatten( (*crnt)->get_type(), types );
+                                flatten( *crnt, types );
 
                                 ++crnt;
@@ -825 +825 @@
 
                 template< typename Iter >
-                static bool unifyDeclList(
+                static bool unifyTypeList(
                         Iter crnt1, Iter end1, Iter crnt2, Iter end2, ast::TypeEnvironment & env,
                         ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
@@ -831 +831 @@
                 ) {
                         while ( crnt1 != end1 && crnt2 != end2 ) {
-                                const ast::Type * t1 = (*crnt1)->get_type();
-                                const ast::Type * t2 = (*crnt2)->get_type();
+                                const ast::Type * t1 = *crnt1;
+                                const ast::Type * t2 = *crnt2;
                                 bool isTuple1 = Tuples::isTtype( t1 );
                                 bool isTuple2 = Tuples::isTtype( t2 );
@@ -840 +840 @@
                                         // combine remainder of list2, then unify
                                         return unifyExact(
-                                                t1, tupleFromDecls( crnt2, end2 ), env, need, have, open,
+                                                t1, tupleFromTypes( crnt2, end2 ), env, need, have, open,
                                                 noWiden(), symtab );
                                 } else if ( ! isTuple1 && isTuple2 ) {
                                         // combine remainder of list1, then unify
                                         return unifyExact(
-                                                tupleFromDecls( crnt1, end1 ), t2, env, need, have, open,
+                                                tupleFromTypes( crnt1, end1 ), t2, env, need, have, open,
                                                 noWiden(), symtab );
                                 }
@@ -860 +860 @@
                         if ( crnt1 != end1 ) {
                                 // try unifying empty tuple with ttype
-                                const ast::Type * t1 = (*crnt1)->get_type();
+                                const ast::Type * t1 = *crnt1;
                                 if ( ! Tuples::isTtype( t1 ) ) return false;
                                 return unifyExact(
-                                        t1, tupleFromDecls( crnt2, end2 ), env, need, have, open,
+                                        t1, tupleFromTypes( crnt2, end2 ), env, need, have, open,
                                         noWiden(), symtab );
                         } else if ( crnt2 != end2 ) {
                                 // try unifying empty tuple with ttype
-                                const ast::Type * t2 = (*crnt2)->get_type();
+                                const ast::Type * t2 = *crnt2;
                                 if ( ! Tuples::isTtype( t2 ) ) return false;
                                 return unifyExact(
-                                        tupleFromDecls( crnt1, end1 ), t2, env, need, have, open,
+                                        tupleFromTypes( crnt1, end1 ), t2, env, need, have, open,
                                         noWiden(), symtab );
                         }
@@ -877 +877 @@
                 }
 
-                static bool unifyDeclList(
-                        const std::vector< ast::ptr< ast::DeclWithType > > & list1,
-                        const std::vector< ast::ptr< ast::DeclWithType > > & list2,
+                static bool unifyTypeList(
+                        const std::vector< ast::ptr< ast::Type > > & list1,
+                        const std::vector< ast::ptr< ast::Type > > & list2,
                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
                         const ast::OpenVarSet & open, const ast::SymbolTable & symtab
                 ) {
-                        return unifyDeclList(
+                        return unifyTypeList(
                                 list1.begin(), list1.end(), list2.begin(), list2.end(), env, need, have, open,
                                 symtab );
@@ -928 +928 @@
                         ) return;
 
-                        if ( ! unifyDeclList( params, params2, tenv, need, have, open, symtab ) ) return;
-                        if ( ! unifyDeclList(
+                        if ( ! unifyTypeList( params, params2, tenv, need, have, open, symtab ) ) return;
+                        if ( ! unifyTypeList(
                                 func->returns, func2->returns, tenv, need, have, open, symtab ) ) return;
 
@@ -1232 +1232 @@
         ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func ) {
                 if ( func->returns.empty() ) return new ast::VoidType{};
-                if ( func->returns.size() == 1 ) return func->returns[0]->get_type();
+                if ( func->returns.size() == 1 ) return func->returns[0];
 
                 std::vector<ast::ptr<ast::Type>> tys;
-                for ( const ast::DeclWithType * decl : func->returns ) {
-                        tys.emplace_back( decl->get_type() );
+                for ( const auto & decl : func->returns ) {
+                        tys.emplace_back( decl );
                 }
                 return new ast::TupleType{ std::move(tys) };

src/SymTab/Mangler.cc

@@ -551 +551 @@
                         GuardValue( inFunctionType );
                         inFunctionType = true;
-                        std::vector< ast::ptr< ast::Type > > returnTypes = getTypes( functionType->returns );
-                        if (returnTypes.empty()) mangleName << Encoding::void_t;
-                        else accept_each( returnTypes, *visitor );
+                        if (functionType->returns.empty()) mangleName << Encoding::void_t;
+                        else accept_each( functionType->returns, *visitor );
                         mangleName << "_";
-                        std::vector< ast::ptr< ast::Type > > paramTypes = getTypes( functionType->params );
-                        accept_each( paramTypes, *visitor );
+                        accept_each( functionType->params, *visitor );
                         mangleName << "_";
                 }

src/SymTab/Validate.cc

@@ -1384 +1384 @@
         /// Replaces enum types by int, and function/array types in function parameter and return
         /// lists by appropriate pointers
+        /*
         struct EnumAndPointerDecay_new {
                 const ast::EnumDecl * previsit( const ast::EnumDecl * enumDecl ) {
@@ -1434 +1435 @@
                 }
         };
+        */
 
         /// expand assertions from a trait instance, performing appropriate type variable substitutions
@@ -1837 +1839 @@
 const ast::Type * validateType(
                 const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab ) {
-        ast::Pass< EnumAndPointerDecay_new > epc;
+        // ast::Pass< EnumAndPointerDecay_new > epc;
         ast::Pass< LinkReferenceToTypes_new > lrt{ loc, symtab };
         ast::Pass< ForallPointerDecay_new > fpd{ loc };
 
-        return type->accept( epc )->accept( lrt )->accept( fpd );
+        return type->accept( lrt )->accept( fpd );
 }