Changes in src/AST/Convert.cpp [c86b08d:561354f]

File:

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

src/AST/Convert.cpp

@@ -283 +283 @@
                 decl->parent = get<AggregateDecl>().accept1( node->parent );
                 declPostamble( decl, node );
-                return nullptr; // ??
+                return nullptr;
         }
 
@@ -320 +320 @@
                         LinkageSpec::Spec( node->linkage.val ),
                         get<Type>().accept1(node->base)
+                );
+                // decl->data_constructors = get<StructDecl>().acceptL( node->data_constructors );
+                // decl->data_union = get<UnionDecl>().accept1( node->data_union );
+                // decl->tag = get<EnumDecl>().accept1( node->tag );
+                // decl->tag_union = get<StructDecl>().accept1( node->tag_union );
+                return aggregatePostamble( decl, node );
+        }
+
+        const ast::Decl * visit( const ast::AdtDecl * node ) override final {
+                if ( inCache(node) ) return nullptr;
+                auto decl = new AdtDecl(
+                        node->name,
+                        get<Attribute>().acceptL( node->attributes ),
+                        LinkageSpec::Spec( node->linkage.val ),
+                        get<StructDecl>().acceptL( node->data_constructors ),
+                        get<UnionDecl>().accept1( node->data_union ),
+                        get<EnumDecl>().accept1( node->tag ),
+                        get<StructDecl>().accept1( node->tag_union )
                 );
                 return aggregatePostamble( decl, node );
@@ -559 +577 @@
                 auto stmt = new SuspendStmt();
                 stmt->then   = get<CompoundStmt>().accept1( node->then   );
-                switch(node->type) {
+                switch (node->kind) {
                         case ast::SuspendStmt::None     : stmt->type = SuspendStmt::None     ; break;
                         case ast::SuspendStmt::Coroutine: stmt->type = SuspendStmt::Coroutine; break;
@@ -565 +583 @@
                 }
                 return stmtPostamble( stmt, node );
-        }
-
-    const ast::WhenClause * visit( const ast::WhenClause * node ) override final {
-                // There is no old-AST WhenClause, so this should never be called.
-                assert( !node );
-                return nullptr;
         }
 
@@ -579 +591 @@
                 for ( auto clause : node->clauses ) {
                         stmt->clauses.push_back({{
-                                        get<Expression>().accept1( clause->target ),
+                                        get<Expression>().accept1( clause->target_func ),
                                         get<Expression>().acceptL( clause->target_args ),
                                 },
                                 get<Statement>().accept1( clause->stmt ),
-                                get<Expression>().accept1( clause->when_cond ),
+                                get<Expression>().accept1( clause->cond ),
                         });
                 }
@@ -600 +612 @@
         const ast::WaitForClause * visit( const ast::WaitForClause * node ) override final {
                 // There is no old-AST WaitForClause, so this should never be called.
-                assert( !node );
-                return nullptr;
-        }
-
-    const ast::Stmt * visit( const ast::WaitUntilStmt * node ) override final {
-        // There is no old-AST WaitUntilStmt, so this should never be called.
                 assert( !node );
                 return nullptr;
@@ -1695 +1701 @@
                         GET_ACCEPT_V(attributes, Attribute),
                         { old->get_funcSpec().val },
-                        old->type->isVarArgs
+                        (old->type->isVarArgs) ? ast::VariableArgs : ast::FixedArgs
                 };
 
@@ -1787 +1793 @@
                 decl->uniqueId   = old->uniqueId;
                 decl->storage    = { old->storageClasses.val };
+                this->node = decl;
+        }
+
+        virtual void visit( const AdtDecl * old ) override final {
+                if ( inCache( old ) ) return;
+                auto decl = new ast::AdtDecl(
+                        old->location,
+                        old->name,
+                        GET_ACCEPT_V(attributes, Attribute),
+                        { old->linkage.val }
+                );
+                cache.emplace( old, decl );
+                decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
+                decl->body = old->body;
+                decl->params = GET_ACCEPT_V(parameters, TypeDecl);
+                decl->members = GET_ACCEPT_V(members, Decl);
+                decl->extension = old->extension;
+                decl->uniqueId = old->uniqueId;
+                decl->storage = { old->storageClasses.val };
+                decl->data_constructors = GET_ACCEPT_V( data_constructors, StructDecl );
+                decl->data_union = GET_ACCEPT_1( data_union, UnionDecl );
+                decl->tag = GET_ACCEPT_1( tag, EnumDecl );
+                decl->tag_union = GET_ACCEPT_1( tag_union, StructDecl );
                 this->node = decl;
         }
@@ -2001 +2030 @@
                         GET_ACCEPT_1(else_, Stmt),
                         GET_ACCEPT_V(initialization, Stmt),
-                        old->isDoWhile,
+                        (old->isDoWhile) ? ast::DoWhile : ast::While,
                         GET_LABELS_V(old->labels)
                 );
@@ -2143 +2172 @@
         virtual void visit( const SuspendStmt * old ) override final {
                 if ( inCache( old ) ) return;
-                ast::SuspendStmt::Type type;
+                ast::SuspendStmt::Kind type;
                 switch (old->type) {
                         case SuspendStmt::Coroutine: type = ast::SuspendStmt::Coroutine; break;
@@ -2170 +2199 @@
                         auto clause = new ast::WaitForClause( old->location );
 
-                        clause->target = GET_ACCEPT_1(clauses[i].target.function, Expr);
+                        clause->target_func = GET_ACCEPT_1(clauses[i].target.function, Expr);
                         clause->target_args = GET_ACCEPT_V(clauses[i].target.arguments, Expr);
                         clause->stmt = GET_ACCEPT_1(clauses[i].statement, Stmt);
-                        clause->when_cond = GET_ACCEPT_1(clauses[i].condition, Expr);
+                        clause->cond = GET_ACCEPT_1(clauses[i].condition, Expr);
 
                         stmt->clauses.push_back( clause );