Changes in src/AST/Convert.cpp [d148778:112fe04]

File:

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

src/AST/Convert.cpp

@@ -10 +10 @@
 // Created On       : Thu May 09 15::37::05 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri May 17 16:01:00 2019
-// Update Count     : 4
+// Last Modified On : Tue May 21 15:30:00 2019
+// Update Count     : 5
 //
 
 #include "Convert.hpp"
-
-#include <unordered_map>
 
 #include "AST/Attribute.hpp"
@@ -44 +42 @@
 class ConverterNewToOld : public ast::Visitor {
         BaseSyntaxNode * node = nullptr;
-        std::unordered_map< ast::Node *, BaseSyntaxNode * > cache;
 
         template<typename T>
@@ -52 +49 @@
                 template<typename U>
                 T * accept1( const ast::ptr<U> & ptr ) {
-                        if ( ! ptr ) return nullptr;
                         ptr->accept( visitor );
                         T * ret = strict_dynamic_cast< T * >( visitor.node );
@@ -91 +87 @@
         }
 
-        /// get new qualifiers from old type
-        Type::Qualifiers cv( const ast::Type * ty ) { return { ty->qualifiers.val }; }
-
-        template<typename NewT, typename OldT>
-        NewT * cached( OldT * old ) {
-                auto it = cache.find( old );
-                // doesn't update cache, that should be handled by the accept function
-                ast::Node * nw = it == cache.end() ? getAccept1< NewT >( old ) : it->second;
-                return strict_dynamic_cast< NewT * >( nw );
-        }
-
 public:
         Declaration * decl( const ast::Decl * declNode ) {
@@ -108 +93 @@
 
 private:
+        void declPostamble( Declaration * decl, const ast::Decl * node ) {
+                decl->location = node->location;
+                // name comes from constructor
+                // linkage comes from constructor
+                decl->extension = node->extension;
+                decl->uniqueId = node->uniqueId;
+                // storageClasses comes from constructor
+                this->node = decl;
+        }
+
+        const ast::DeclWithType * declWithTypePostamble (
+                        DeclarationWithType * decl, const ast::DeclWithType * node ) {
+                declPostamble( decl, node );
+                decl->mangleName = node->mangleName;
+                decl->scopeLevel = node->scopeLevel;
+                decl->asmName = get<Expression>().accept1( node->asmName );
+                // attributes comes from constructor
+                decl->isDeleted = node->isDeleted;
+                // fs comes from constructor
+                return nullptr;
+        }
+
         const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
-                (void)node;
-                return nullptr;
+                auto decl = new ObjectDecl(
+                        node->name,
+                        Type::StorageClasses( node->storage.val ),
+                        LinkageSpec::Spec( node->linkage.val ),
+                        get<Expression>().accept1( node->bitfieldWidth ),
+                        get<Type>().accept1( node->type ),
+                        get<Initializer>().accept1( node->init ),
+                        get<Attribute>().acceptL( node->attributes ),
+                        Type::FuncSpecifiers( node->funcSpec.val )
+                );
+                return declWithTypePostamble( decl, node );
         }
 
         const ast::DeclWithType * visit( const ast::FunctionDecl * node ) override final {
-                (void)node;
+                auto decl = new FunctionDecl(
+                        node->name,
+                        Type::StorageClasses( node->storage.val ),
+                        LinkageSpec::Spec( node->linkage.val ),
+                        get<FunctionType>().accept1( node->type ),
+                        get<CompoundStmt>().accept1( node->stmts ),
+                        get<Attribute>().acceptL( node->attributes ),
+                        Type::FuncSpecifiers( node->funcSpec.val )
+                );
+                decl->withExprs = get<Expression>().acceptL( node->withExprs );
+                return declWithTypePostamble( decl, node );
+        }
+
+        // NamedTypeDecl
+        const ast::Decl * namedTypePostamble( NamedTypeDecl * decl, const ast::NamedTypeDecl * node ) {
+                declPostamble( decl, node );
+                // base comes from constructor
+                decl->parameters = get<TypeDecl>().acceptL( node->params );
+                decl->assertions = get<DeclarationWithType>().acceptL( node->assertions );
+                return nullptr;
+        }
+
+        const ast::Decl * visit( const ast::TypeDecl * node ) override final {
+                TypeDecl::Kind kind;
+                switch (node->kind) {
+                case ast::TypeVar::Dtype:
+                        kind = TypeDecl::Dtype;
+                        break;
+                case ast::TypeVar::Ftype:
+                        kind = TypeDecl::Ftype;
+                        break;
+                case ast::TypeVar::Ttype:
+                        kind = TypeDecl::Ttype;
+                        break;
+                default:
+                        assertf(false, "Invalid ast::TypeVar::Kind: %d\n", node->kind);
+                };
+                auto decl = new TypeDecl(
+                        node->name,
+                        Type::StorageClasses( node->storage.val ),
+                        get<Type>().accept1( node->base ),
+                        kind,
+                        node->sized,
+                        get<Type>().accept1( node->init )
+                );
+                return namedTypePostamble( decl, node );
+        }
+
+        const ast::Decl * visit( const ast::TypedefDecl * node ) override final {
+                auto decl = new TypedefDecl(
+                        node->name,
+                        node->location,
+                        Type::StorageClasses( node->storage.val ),
+            get<Type>().accept1( node->base ),
+                        LinkageSpec::Spec( node->linkage.val )
+                );
+                return namedTypePostamble( decl, node );
+        }
+
+        const ast::Decl * aggregatePostamble( AggregateDecl * decl, const ast::AggregateDecl * node ) {
+                decl->members = get<Declaration>().acceptL( node->members );
+                decl->parameters = get<TypeDecl>().acceptL( node->params );
+                decl->body = node->body;
+                // attributes come from constructor
+                // TODO: Need caching for: decl->parent = node->parent;
                 return nullptr;
         }
 
         const ast::Decl * visit( const ast::StructDecl * node ) override final {
-                (void)node;
-                return nullptr;
+                auto decl = new StructDecl(
+                        node->name,
+                        node->kind,
+                        get<Attribute>().acceptL( node->attributes ),
+                        LinkageSpec::Spec( node->linkage.val )
+                );
+                return aggregatePostamble( decl, node );
         }
 
         const ast::Decl * visit( const ast::UnionDecl * node ) override final {
-                (void)node;
-                return nullptr;
+                auto decl = new UnionDecl(
+                        node->name,
+                        get<Attribute>().acceptL( node->attributes ),
+                        LinkageSpec::Spec( node->linkage.val )
+                );
+                return aggregatePostamble( decl, node );
         }
 
         const ast::Decl * visit( const ast::EnumDecl * node ) override final {
-                (void)node;
-                return nullptr;
+                auto decl = new EnumDecl(
+                        node->name,
+                        get<Attribute>().acceptL( node->attributes ),
+                        LinkageSpec::Spec( node->linkage.val )
+                );
+                return aggregatePostamble( decl, node );
         }
 
         const ast::Decl * visit( const ast::TraitDecl * node ) override final {
-                (void)node;
-                return nullptr;
-        }
-
-        const ast::Decl * visit( const ast::TypeDecl * node ) override final {
-                (void)node;
-                return nullptr;
-        }
-
-        const ast::Decl * visit( const ast::TypedefDecl * node ) override final {
-                (void)node;
-                return nullptr;
+                auto decl = new TraitDecl(
+                        node->name,
+                        {},
+                        LinkageSpec::Spec( node->linkage.val )
+                );
+                return aggregatePostamble( decl, node );
         }
 
         const ast::AsmDecl * visit( const ast::AsmDecl * node ) override final {
-                (void)node;
+                auto decl = new AsmDecl( get<AsmStmt>().accept1( node->stmt ) );
+                declPostamble( decl, node );
                 return nullptr;
         }
 
         const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl * node ) override final {
-                (void)node;
-                return nullptr;
-        }
-
-        const ast::CompoundStmt * visit( const ast::CompoundStmt * node ) override final {
-                auto stmt = new CompoundStmt( get<Statement>().acceptL( node->kids ) );
+                auto decl = new StaticAssertDecl(
+                        get<Expression>().accept1( node->cond ),
+                        get<ConstantExpr>().accept1( node->msg )
+                );
+                declPostamble( decl, node );
+                return nullptr;
+        }
+
+        const ast::Stmt * stmtPostamble( Statement * stmt, const ast::Stmt * node ) {
                 stmt->location = node->location;
                 stmt->labels = makeLabelL( stmt, node->labels );
@@ -166 +257 @@
         }
 
+        const ast::CompoundStmt * visit( const ast::CompoundStmt * node ) override final {
+                auto stmt = new CompoundStmt( get<Statement>().acceptL( node->kids ) );
+                stmtPostamble( stmt, node );
+                return nullptr;
+        }
+
         const ast::Stmt * visit( const ast::ExprStmt * node ) override final {
                 auto stmt = new ExprStmt( get<Expression>().accept1( node->expr ) );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
-                return nullptr;
+                return stmtPostamble( stmt, node );
         }
 
@@ -183 +277 @@
                         makeLabelL( nullptr, node->gotoLabels ) // What are these labelling?
                 );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
-                return nullptr;
+                return stmtPostamble( stmt, node );
         }
 
         const ast::Stmt * visit( const ast::DirectiveStmt * node ) override final {
                 auto stmt = new DirectiveStmt( node->directive );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
-                return nullptr;
+                return stmtPostamble( stmt, node );
         }
 
@@ -204 +292 @@
                         get<Statement>().acceptL( node->inits )
                 );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
-                return nullptr;
+                return stmtPostamble( stmt, node );
         }
 
@@ -215 +300 @@
                         get<Statement>().acceptL( node->stmts )
                 );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
-                return nullptr;
+                return stmtPostamble( stmt, node );
         }
 
@@ -227 +309 @@
                         node->isDefault()
                 );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
-                return nullptr;
+                return stmtPostamble( stmt, node );
         }
 
@@ -241 +320 @@
                         node->isDoWhile
                 );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
-                return nullptr;
+                return stmtPostamble( stmt, node );
         }
 
@@ -254 +330 @@
                         get<Statement>().accept1( node->body )
                 );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
-                return nullptr;
+                return stmtPostamble( stmt, node );
         }
 
@@ -286 +359 @@
                         stmt->target = makeLabel( stmt, node->target );
                 }
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
-                return nullptr;
+                return stmtPostamble( stmt, node );
         }
 
         const ast::Stmt * visit( const ast::ReturnStmt * node ) override final {
                 auto stmt = new ReturnStmt( get<Expression>().accept1( node->expr ) );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
-                return nullptr;
+                return stmtPostamble( stmt, node );
         }
 
@@ -317 +384 @@
                         get<Expression>().accept1( node->target )
                 );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
-                return nullptr;
+                return stmtPostamble( stmt, node );
         }
 
@@ -330 +394 @@
                         get<FinallyStmt>().accept1( node->finally )
                 );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
-                return nullptr;
+                return stmtPostamble( stmt, node );
         }
 
@@ -354 +415 @@
                         get<Statement>().accept1( node->body )
                 );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
-                return nullptr;
+                return stmtPostamble( stmt, node );
         }
 
         const ast::Stmt * visit( const ast::FinallyStmt * node ) override final {
                 auto stmt = new FinallyStmt( get<CompoundStmt>().accept1( node->body ) );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
-                return nullptr;
+                return stmtPostamble( stmt, node );
         }
 
@@ -373 +428 @@
                 for ( auto clause : node->clauses ) {
                         stmt->clauses.push_back({{
-                                        get<Expression>().accept1( clause.target.function ),
-                                        get<Expression>().acceptL( clause.target.arguments ),
+                                        get<Expression>().accept1( clause.target.func ),
+                                        get<Expression>().acceptL( clause.target.args ),
                                 },
                                 get<Statement>().accept1( clause.stmt ),
@@ -389 +444 @@
                         get<Expression>().accept1( node->orElse.cond ),
                 };
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
-                return nullptr;
+                return stmtPostamble( stmt, node );
         }
 
@@ -400 +452 @@
                         get<Statement>().accept1( node->stmt )
                 );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
-                return nullptr;
+                return stmtPostamble( stmt, node );
         }
 
         const ast::NullStmt * visit( const ast::NullStmt * node ) override final {
                 auto stmt = new NullStmt();
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
+                stmtPostamble( stmt, node );
                 return nullptr;
         }
@@ -416 +463 @@
         const ast::Stmt * visit( const ast::DeclStmt * node ) override final {
                 auto stmt = new DeclStmt( get<Declaration>().accept1( node->decl ) );
-                stmt->location = node->location;
-                stmt->labels = makeLabelL( stmt, node->labels );
-                this->node = stmt;
-                return nullptr;
+                return stmtPostamble( stmt, node );
         }
 
@@ -427 +471 @@
         }
 
+        TypeSubstitution * convertTypeSubstitution(const ast::TypeSubstitution * src) {
+
+                TypeSubstitution *rslt = new TypeSubstitution();
+
+                for (decltype(src->begin()) src_i = src->begin(); src_i != src->end(); src_i++) {
+                        rslt->add( src_i->first,
+                                   get<Type>().accept1(src_i->second) );
+                }
+
+                for (decltype(src->beginVar()) src_i = src->beginVar(); src_i != src->endVar(); src_i++) {
+                        rslt->addVar( src_i->first,
+                                      get<Expression>().accept1(src_i->second) );
+                }
+
+                return rslt;
+        }
+
+        void convertInferUnion(std::map<UniqueId,ParamEntry> &tgtInferParams,
+                                                   std::vector<UniqueId>         &tgtResnSlots,
+                                                   const ast::Expr::InferUnion   &srcInferred ) {
+
+                assert( tgtInferParams.empty() );
+                assert( tgtResnSlots.empty() );
+
+                if ( srcInferred.mode == ast::Expr::InferUnion::Params ) {
+                        const ast::InferredParams &srcParams = srcInferred.inferParamsConst();
+                        for (auto srcParam : srcParams) {
+                                tgtInferParams[srcParam.first] = ParamEntry(
+                                        srcParam.second.decl,
+                                        get<Type>().accept1(srcParam.second.actualType),
+                                        get<Type>().accept1(srcParam.second.formalType),
+                                        get<Expression>().accept1(srcParam.second.expr)
+                                );
+                        }
+                } else if ( srcInferred.mode == ast::Expr::InferUnion::Slots  ) {
+                        const ast::ResnSlots &srcSlots = srcInferred.resnSlotsConst();
+                        for (auto srcSlot : srcSlots) {
+                                tgtResnSlots.push_back(srcSlot);
+                        }
+                }
+        }
+
+        Expression * visitBaseExpr(const ast::Expr * src, Expression * tgt) {
+
+                tgt->location = src->location;
+
+                tgt->result = get<Type>().accept1(src->result);
+                tgt->env    = convertTypeSubstitution(src->env);
+
+                tgt->extension = src->extension;
+                convertInferUnion(tgt->inferParams, tgt->resnSlots, src->inferred);
+
+                return tgt;
+        }
+
         const ast::Expr * visit( const ast::ApplicationExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new ApplicationExpr(
+                                get<Expression>().accept1(node->func),
+                                get<Expression>().acceptL(node->args)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::UntypedExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new UntypedExpr(
+                                get<Expression>().accept1(node->func),
+                                get<Expression>().acceptL(node->args)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::NameExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new NameExpr(
+                                node->name
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
@@ -613 +729 @@
 
         const ast::Type * visit( const ast::VoidType * node ) override final {
-                this->node = new VoidType{ cv( node ) };
+                (void)node;
                 return nullptr;
         }
 
         const ast::Type * visit( const ast::BasicType * node ) override final {
-                this->node = new BasicType{ cv( node ), (BasicType::Kind)(unsigned)node->kind };
+                (void)node;
                 return nullptr;
         }
 
         const ast::Type * visit( const ast::PointerType * node ) override final {
-                this->node = new PointerType{
-                        cv( node ),
-                        get<Type>().accept1( node->base ),
-                        get<Expression>().accept1( node->dimension ),
-                        node->isVarLen,
-                        node->isStatic
-                };
+                (void)node;
                 return nullptr;
         }
 
         const ast::Type * visit( const ast::ArrayType * node ) override final {
-                this->node = new ArrayType{
-                        cv( node ),
-                        get<Type>().accept1( node->base ),
-                        get<Expression>().accept1( node->dimension ),
-                        node->isVarLen,
-                        node->isStatic
-                };
+                (void)node;
                 return nullptr;
         }
 
         const ast::Type * visit( const ast::ReferenceType * node ) override final {
-                this->node = new ReferenceType{
-                        cv( node ),
-                        get<Type>().accept1( node->base )
-                };
+                (void)node;
                 return nullptr;
         }
 
         const ast::Type * visit( const ast::QualifiedType * node ) override final {
-                this->node = new QualifiedType{
-                        cv( node ),
-                        get<Type>().accept1( node->parent ),
-                        get<Type>().accept1( node->child )
-                };
+                (void)node;
                 return nullptr;
         }
 
         const ast::Type * visit( const ast::FunctionType * node ) override final {
-                auto ty = new FunctionType { cv( node ), node->isVarArgs };
-                ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
-                ty->parameters = get<DeclarationWithType>().acceptL( node->params );
-                ty->forall = get<TypeDecl>().acceptL( node->forall );
-                node = ty;
+                (void)node;
                 return nullptr;
         }
@@ -774 +867 @@
         }
 private:
-        /// conversion output
         ast::Node * node;
-        /// cache of nodes that might be referenced by readonly<> for de-duplication
-        std::unordered_map< BaseSyntaxNode *, ast::Node * > cache;
 
         // Local Utilities:
@@ -783 +873 @@
         template<typename NewT, typename OldT>
         NewT * getAccept1( OldT old ) {
-                if ( ! old ) return nullptr;
                 old->accept(*this);
                 return strict_dynamic_cast< NewT * >( node );
@@ -824 +913 @@
 #       define GET_LABELS_V(labels) \
                 to<std::vector>::from( make_labels( std::move( labels ) ) )
-        
-        static ast::CV::Qualifiers cv( Type * ty ) { return { ty->get_qualifiers().val }; }
-
-        template<typename NewT, typename OldT>
-        NewT * cached( OldT * old ) {
-                auto it = cache.find( old );
-                // doesn't update cache, that should be handled by the accept function
-                ast::Node * nw = it == cache.end() ? getAccept1< NewT >( old ) : it->second;
-                return strict_dynamic_cast< NewT * >( nw );
-        }
 
         // Now all the visit functions:
@@ -1236 +1315 @@
                                       getAccept1<ast::Expr>(old_i->second) );
                 }
-        }
-
-        void convertInferUnion(ast::Expr::InferUnion &nwInferred, InferredParams oldInferParams, const std::vector<UniqueId> &oldResnSlots) {
-                
-                (void) nwInferred;
-                (void) oldInferParams;
-                (void) oldResnSlots;
-                
-                // TODO
+
+                return rslt;
+        }
+
+        void convertInferUnion(ast::Expr::InferUnion               &newInferred,
+                                                   const std::map<UniqueId,ParamEntry> &oldInferParams,
+                                                   const std::vector<UniqueId>         &oldResnSlots) {
+
+                assert( oldInferParams.empty() || oldResnSlots.empty() );
+                assert( newInferred.mode == ast::Expr::InferUnion::Empty );
+
+                if ( !oldInferParams.empty() ) {
+                        ast::InferredParams &tgt = newInferred.inferParams();
+                        for (auto old : oldInferParams) {
+                                tgt[old.first] = ast::ParamEntry(
+                                        old.second.decl,
+                                        getAccept1<ast::Type>(old.second.actualType),
+                                        getAccept1<ast::Type>(old.second.formalType),
+                                        getAccept1<ast::Expr>(old.second.expr)
+                                );
+                        }
+                } else if ( !oldResnSlots.empty() ) {
+                        ast::ResnSlots &tgt = newInferred.resnSlots();
+                        for (auto old : oldResnSlots) {
+                                tgt.push_back(old);
+                        }
+                }
         }
 
@@ -1258 +1355 @@
         }
 
-        virtual void visit( ApplicationExpr * ) override final {
-                // TODO
-        }
-
-        virtual void visit( UntypedExpr * ) override final {
-                // TODO
+        virtual void visit( ApplicationExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::ApplicationExpr(
+                                old->location,
+                                GET_ACCEPT_1(function, Expr),
+                                GET_ACCEPT_V(args, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( UntypedExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::UntypedExpr(
+                                old->location,
+                                GET_ACCEPT_1(function, Expr),
+                                GET_ACCEPT_V(args, Expr)
+                        )
+                );
         }
 
@@ -1275 +1384 @@
         }
 
-        virtual void visit( CastExpr * ) override final {
-                // TODO ... (rest)
+        virtual void visit( CastExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::CastExpr(
+                                old->location,
+                                nullptr, // cast's "to" type is expr's result type; converted in visitBaseExpr
+                                old->isGenerated ? ast::GeneratedCast : ast::ExplicitCast
+                        )
+                );
         }
 
@@ -1411 +1526 @@
         }
 
-        virtual void visit( VoidType * old ) override final {
-                this->node = new ast::VoidType{ cv( old ) };
-        }
-
-        virtual void visit( BasicType * old ) override final {
-                this->node = new ast::BasicType{ (ast::BasicType::Kind)(unsigned)old->kind, cv( old ) };
-        }
-
-        virtual void visit( PointerType * old ) override final {
-                this->node = new ast::PointerType{
-                        GET_ACCEPT_1( base, Type ),
-                        GET_ACCEPT_1( dimension, Expr ),
-                        (ast::LengthFlag)old->isVarLen,
-                        (ast::DimensionFlag)old->isStatic,
-                        cv( old )
-                };
-        }
-
-        virtual void visit( ArrayType * old ) override final {
-                this->node = new ast::ArrayType{
-                        GET_ACCEPT_1( base, Type ),
-                        GET_ACCEPT_1( dimension, Expr ),
-                        (ast::LengthFlag)old->isVarLen,
-                        (ast::DimensionFlag)old->isStatic,
-                        cv( old )
-                };
-        }
-
-        virtual void visit( ReferenceType * old ) override final {
-                this->node = new ast::ReferenceType{
-                        GET_ACCEPT_1( base, Type ),
-                        cv( old )
-                };
-        }
-
-        virtual void visit( QualifiedType * old ) override final {
-                this->node = new ast::QualifiedType{
-                        GET_ACCEPT_1( parent, Type ),
-                        GET_ACCEPT_1( child, Type ),
-                        cv( old )
-                };
-        }
-
-        virtual void visit( FunctionType * old ) override final {
-                auto ty = new ast::FunctionType {
-                        (ast::ArgumentFlag)old->isVarArgs,
-                        cv( old )
-                };
-                ty->returns = GET_ACCEPT_V( returnVals, DeclWithType );
-                ty->params = GET_ACCEPT_V( parameters, DeclWithType );
-                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
-                this->node = ty;
-        }
-
-        void postvisit( ReferenceToType * old, ast::ReferenceToType * ty ) {
-                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
-                ty->params = GET_ACCEPT_V( parameters, Expr );
-                ty->hoistType = old->hoistType;
-        }
-
-        virtual void visit( StructInstType * old ) override final {
-                auto ty = new ast::StructInstType{
-                        cached< ast::StructDecl >( old->baseStruct ),
-                        cv( old ),
-                        GET_ACCEPT_V( attributes, Attribute )
-                };
-                postvisit( old, ty );
-                this->node = ty;
-        }
-
-        virtual void visit( UnionInstType * old ) override final {
-                auto ty = new ast::UnionInstType{
-                        cached< ast::UnionDecl >( old->baseUnion ),
-                        cv( old ),
-                        GET_ACCEPT_V( attributes, Attribute )
-                };
-                postvisit( old, ty );
-                this->node = ty;
-        }
-
-        virtual void visit( EnumInstType * old ) override final {
-                auto ty = new ast::EnumInstType{
-                        cached< ast::EnumDecl >( old->baseEnum ),
-                        cv( old ),
-                        GET_ACCEPT_V( attributes, Attribute )
-                };
-                postvisit( old, ty );
-                this->node = ty;
-        }
-
-        virtual void visit( TraitInstType * old ) override final {
-                auto ty = new ast::TraitInstType{
-                        cached< ast::TraitDecl >( old->baseTrait ),
-                        cv( old ),
-                        GET_ACCEPT_V( attributes, Attribute )
-                };
-                postvisit( old, ty );
-                this->node = ty;
-        }
-
-        virtual void visit( TypeInstType * old ) override final {
-                auto ty = new ast::TypeInstType{
-                        cached< ast::TypeDecl >( old->baseStruct ),
-                        cv( old ),
-                        GET_ACCEPT_V( attributes, Attribute )
-                };
-                postvisit( old, ty );
-                this->node = ty;
+        virtual void visit( VoidType * ) override final {
+
+        }
+
+        virtual void visit( BasicType * ) override final {
+
+        }
+
+        virtual void visit( PointerType * ) override final {
+
+        }
+
+        virtual void visit( ArrayType * ) override final {
+
+        }
+
+        virtual void visit( ReferenceType * ) override final {
+
+        }
+
+        virtual void visit( QualifiedType * ) override final {
+
+        }
+
+        virtual void visit( FunctionType * ) override final {
+
+        }
+
+        virtual void visit( StructInstType * ) override final {
+
+        }
+
+        virtual void visit( UnionInstType * ) override final {
+
+        }
+
+        virtual void visit( EnumInstType * ) override final {
+
+        }
+
+        virtual void visit( TraitInstType * ) override final {
+
+        }
+
+        virtual void visit( TypeInstType * ) override final {
+
         }