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

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 );
@@ -577 +559 @@
                 auto stmt = new SuspendStmt();
                 stmt->then   = get<CompoundStmt>().accept1( node->then   );
-                switch (node->kind) {
+                switch(node->type) {
                         case ast::SuspendStmt::None     : stmt->type = SuspendStmt::None     ; break;
                         case ast::SuspendStmt::Coroutine: stmt->type = SuspendStmt::Coroutine; break;
@@ -583 +565 @@
                 }
                 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;
         }
 
@@ -591 +579 @@
                 for ( auto clause : node->clauses ) {
                         stmt->clauses.push_back({{
-                                        get<Expression>().accept1( clause->target_func ),
+                                        get<Expression>().accept1( clause->target ),
                                         get<Expression>().acceptL( clause->target_args ),
                                 },
                                 get<Statement>().accept1( clause->stmt ),
-                                get<Expression>().accept1( clause->cond ),
+                                get<Expression>().accept1( clause->when_cond ),
                         });
                 }
@@ -612 +600 @@
         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;
@@ -1701 +1695 @@
                         GET_ACCEPT_V(attributes, Attribute),
                         { old->get_funcSpec().val },
-                        (old->type->isVarArgs) ? ast::VariableArgs : ast::FixedArgs
+                        old->type->isVarArgs
                 };
 
@@ -1793 +1787 @@
                 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;
         }
@@ -2030 +2001 @@
                         GET_ACCEPT_1(else_, Stmt),
                         GET_ACCEPT_V(initialization, Stmt),
-                        (old->isDoWhile) ? ast::DoWhile : ast::While,
+                        old->isDoWhile,
                         GET_LABELS_V(old->labels)
                 );
@@ -2172 +2143 @@
         virtual void visit( const SuspendStmt * old ) override final {
                 if ( inCache( old ) ) return;
-                ast::SuspendStmt::Kind type;
+                ast::SuspendStmt::Type type;
                 switch (old->type) {
                         case SuspendStmt::Coroutine: type = ast::SuspendStmt::Coroutine; break;
@@ -2199 +2170 @@
                         auto clause = new ast::WaitForClause( old->location );
 
-                        clause->target_func = GET_ACCEPT_1(clauses[i].target.function, Expr);
+                        clause->target = 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->cond = GET_ACCEPT_1(clauses[i].condition, Expr);
+                        clause->when_cond = GET_ACCEPT_1(clauses[i].condition, Expr);
 
                         stmt->clauses.push_back( clause );