Changes in src/AST/Convert.cpp [954c954:4ef08f7]

File:

• src/AST/Convert.cpp (modified) (7 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 ),
-                        ftype,
-                        //get<FunctionType>().accept1( node->type ),
+                        get<FunctionType>().accept1( node->type ),
                         {},
                         get<Attribute>().acceptL( node->attributes ),
@@ -1168 +1152 @@
 
         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
                 };
-                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->returnVals = get<DeclarationWithType>().acceptL( node->returns );
+                ty->parameters = get<DeclarationWithType>().acceptL( node->params );
                 ty->forall = get<TypeDecl>().acceptL( node->forall );
                 return visitType( node, ty );
         }
 
-        const ast::Type * postvisit( const ast::BaseInstType * old, ReferenceToType * ty ) {
+        const ast::Type * postvisit( const ast::ReferenceToType * old, ReferenceToType * ty ) {
                 ty->forall = get<TypeDecl>().acceptL( old->forall );
                 ty->parameters = get<Expression>().acceptL( old->params );
@@ -1408 +1374 @@
         ast::Node * node = nullptr;
         /// cache of nodes that might be referenced by readonly<> for de-duplication
-        /// 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 = {};
+        std::unordered_map< const BaseSyntaxNode *, ast::Node * > cache = {};
 
         // Local Utilities:
@@ -1485 +1447 @@
                 auto it = cache.find( old );
                 if ( it == cache.end() ) return false;
-                node = const_cast<ast::Node *>(it->second.get());
+                node = it->second;
                 return true;
         }
@@ -1524 +1486 @@
         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),
-                        std::move(paramVars),
-                        std::move(returnVars),
+                        GET_ACCEPT_1(type, FunctionType),
                         {},
                         { old->storageClasses.val },
@@ -1554 +1496 @@
                         { 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);
@@ -2576 +2515 @@
                         cv( old )
                 };
-                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->returns = GET_ACCEPT_V( returnVals, DeclWithType );
+                ty->params = GET_ACCEPT_V( parameters, DeclWithType );
                 ty->forall = GET_ACCEPT_V( forall, TypeDecl );
                 visitType( old, ty );
         }
 
-        void postvisit( const ReferenceToType * old, ast::BaseInstType * ty ) {
+        void postvisit( const ReferenceToType * old, ast::ReferenceToType * ty ) {
                 ty->forall = GET_ACCEPT_V( forall, TypeDecl );
                 ty->params = GET_ACCEPT_V( parameters, Expr );