Changes in src/AST/Convert.cpp [293dc1c:954c954]

File:

• src/AST/Convert.cpp (modified) (22 diffs)

src/AST/Convert.cpp

@@ -25 +25 @@
 #include "AST/Init.hpp"
 #include "AST/Stmt.hpp"
-#include "AST/TranslationUnit.hpp"
 #include "AST/TypeSubstitution.hpp"
 
@@ -48 +47 @@
 
 //================================================================================================
-namespace ast {
+namespace {
 
 // This is to preserve the FindSpecialDecls hack. It does not (and perhaps should not)
 // allow us to use the same stratagy in the new ast.
-// xxx - since convert back pass works, this concern seems to be unnecessary.
-
-// these need to be accessed in new FixInit now
 ast::Type * sizeType = nullptr;
 ast::FunctionDecl * dereferenceOperator = nullptr;
@@ -67 +63 @@
         using Cache = std::unordered_map< const ast::Node *, BaseSyntaxNode * >;
         Cache cache;
-
-        // Statements can no longer be shared.
-        // however, since StmtExprResult is now implemented, need to still maintain
-        // readonly references.
-        Cache readonlyCache;
 
         template<typename T>
@@ -163 +154 @@
         }
 
-        const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {        
+        const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
+                auto&& bfwd = get<Expression>().accept1( node->bitfieldWidth );
+                auto&& type = get<Type>().accept1( node->type );
+                auto&& init = get<Initializer>().accept1( node->init );
+                auto&& attr = get<Attribute>().acceptL( node->attributes );
                 if ( inCache( node ) ) {
                         return nullptr;
                 }
-                auto bfwd = get<Expression>().accept1( node->bitfieldWidth );
-                auto type = get<Type>().accept1( node->type );
-                auto attr = get<Attribute>().acceptL( node->attributes );
-
                 auto decl = new ObjectDecl(
                         node->name,
@@ -177 +168 @@
                         bfwd,
                         type->clone(),
-                        nullptr, // prevent infinite loop
+                        init,
                         attr,
                         Type::FuncSpecifiers( node->funcSpec.val )
                 );
-
-                // handles the case where node->init references itself
-                // xxx - does it really happen?
-                declWithTypePostamble(decl, node);
-                auto init = get<Initializer>().accept1( node->init );
-                decl->init = init;
-                
-                this->node = decl;
-                return nullptr;
+                return declWithTypePostamble( decl, node );
         }
 
@@ -222 +205 @@
                 decl->statements = get<CompoundStmt>().accept1( node->stmts );
                 decl->withExprs = get<Expression>().acceptL( node->withExprs );
-                if ( ast::dereferenceOperator == node ) {
+                if ( dereferenceOperator == node ) {
                         Validate::dereferenceOperator = decl;
                 }
-                if ( ast::dtorStructDestroy == node ) {
+                if ( dtorStructDestroy == node ) {
                         Validate::dtorStructDestroy = decl;
                 }
@@ -284 +267 @@
                 );
 
-                if ( ast::dtorStruct == node ) {
+                if ( dtorStruct == node ) {
                         Validate::dtorStruct = decl;
                 }
@@ -337 +320 @@
 
         const ast::Stmt * stmtPostamble( Statement * stmt, const ast::Stmt * node ) {
-                // force statements in old tree to be unique.
-                // cache.emplace( node, stmt );
-                readonlyCache.emplace( node, stmt );
+                cache.emplace( node, stmt );
                 stmt->location = node->location;
                 stmt->labels = makeLabelL( stmt, node->labels );
@@ -356 +337 @@
                 if ( inCache( node ) ) return nullptr;
                 auto stmt = new ExprStmt( nullptr );
+                cache.emplace( node, stmt );
                 stmt->expr = get<Expression>().accept1( node->expr );
                 return stmtPostamble( stmt, node );
@@ -1029 +1011 @@
                 auto stmts = node->stmts;
                 // disable sharing between multiple StmtExprs explicitly.
-                // this should no longer be true.
-
+                if (inCache(stmts)) {
+                        stmts = ast::deepCopy(stmts.get());
+                }
                 auto rslt = new StmtExpr(
                         get<CompoundStmt>().accept1(stmts)
@@ -1037 +1020 @@
                 rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
                 rslt->dtors       = get<Expression>().acceptL(node->dtors);
-                if (node->resultExpr) {
-                        // this MUST be found by children visit
-                        rslt->resultExpr  = strict_dynamic_cast<ExprStmt *>(readonlyCache.at(node->resultExpr));
-                }
 
                 auto expr = visitBaseExpr( node, rslt );
@@ -1057 +1036 @@
 
                 auto expr = visitBaseExpr( node, rslt );
-                this->node = expr->clone();
+                this->node = expr;
                 return nullptr;
         }
@@ -1147 +1126 @@
                 auto type = new BasicType{ cv( node ), (BasicType::Kind)(unsigned)node->kind };
                 // I believe this should always be a BasicType.
-                if ( ast::sizeType == node ) {
+                if ( sizeType == node ) {
                         Validate::SizeType = type;
                 }
@@ -1405 +1384 @@
 };
 
-std::list< Declaration * > convert( const ast::TranslationUnit && translationUnit ) {
+std::list< Declaration * > convert( const std::list< ast::ptr< ast::Decl > > && translationUnit ) {
         ConverterNewToOld c;
         std::list< Declaration * > decls;
-        for(auto d : translationUnit.decls) {
+        for(auto d : translationUnit) {
                 decls.emplace_back( c.decl( d ) );
         }
@@ -1550 +1529 @@
 
                 // 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());
@@ -1563 +1540 @@
                 }
                 ftype->forall = std::move(forall);
-                */
-
-                // can function type have attributes? seems not to be the case.
-                // visitType(old->type, ftype);
+                visitType(old->type, ftype);
 
                 auto decl = new ast::FunctionDecl{
@@ -1572 +1546 @@
                         old->name,
                         // GET_ACCEPT_1(type, FunctionType),
-                        std::move(forall),
                         std::move(paramVars),
                         std::move(returnVars),
@@ -1579 +1552 @@
                         { old->linkage.val },
                         GET_ACCEPT_V(attributes, Attribute),
-                        { old->get_funcSpec().val },
-                        old->type->isVarArgs
+                        { old->get_funcSpec().val }
                 };
 
-                // decl->type = ftype;
+                decl->type = ftype;
                 cache.emplace( old, decl );
 
@@ -1598 +1570 @@
 
                 if ( Validate::dereferenceOperator == old ) {
-                        ast::dereferenceOperator = decl;
+                        dereferenceOperator = decl;
                 }
 
                 if ( Validate::dtorStructDestroy == old ) {
-                        ast::dtorStructDestroy = decl;
+                        dtorStructDestroy = decl;
                 }
         }
@@ -1627 +1599 @@
 
                 if ( Validate::dtorStruct == old ) {
-                        ast::dtorStruct = decl;
+                        dtorStruct = decl;
                 }
         }
@@ -2559 +2531 @@
                 // I believe this should always be a BasicType.
                 if ( Validate::SizeType == old ) {
-                        ast::sizeType = type;
+                        sizeType = type;
                 }
                 visitType( old, type );
@@ -2804 +2776 @@
 #undef GET_ACCEPT_1
 
-ast::TranslationUnit convert( const std::list< Declaration * > && translationUnit ) {
+std::list< ast::ptr< ast::Decl > > convert( const std::list< Declaration * > && translationUnit ) {
         ConverterOldToNew c;
-        ast::TranslationUnit unit;
+        std::list< ast::ptr< ast::Decl > > decls;
         for(auto d : translationUnit) {
                 d->accept( c );
-                unit.decls.emplace_back( c.decl() );
+                decls.emplace_back( c.decl() );
         }
         deleteAll(translationUnit);
-        return unit;
+        return decls;
 }