Changes in src/AST/Convert.cpp [746ae82:20de6fb]

File:

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

src/AST/Convert.cpp

@@ -525 +525 @@
         }
 
+        Expression * visitBaseExpr_skipResultType(const ast::Expr * src, Expression * tgt) {
+
+                tgt->location  = src->location;
+                tgt->env       = convertTypeSubstitution(src->env);
+                tgt->extension = src->extension;
+
+                convertInferUnion(tgt->inferParams, tgt->resnSlots, src->inferred);
+                return tgt;
+        }
+
         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;
+                return visitBaseExpr_skipResultType(src, tgt);
         }
 
@@ -571 +574 @@
 
         const ast::Expr * visit( const ast::AddressExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new AddressExpr(
+                                get<Expression>().accept1(node->arg)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::LabelAddressExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new LabelAddressExpr(
+                                makeLabel(nullptr, node->arg)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::CastExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new CastExpr(
+                                get<Expression>().accept1(node->arg),
+                                (node->isGenerated == ast::GeneratedCast)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::KeywordCastExpr * node ) override final {
-                (void)node;
+                KeywordCastExpr::Target castTarget = KeywordCastExpr::NUMBER_OF_TARGETS;
+                switch (node->target) {
+                        case ast::KeywordCastExpr::Coroutine:
+                                castTarget = KeywordCastExpr::Coroutine;
+                                break;
+                        case ast::KeywordCastExpr::Thread:
+                                castTarget = KeywordCastExpr::Thread;
+                                break;
+                        case ast::KeywordCastExpr::Monitor:
+                                castTarget = KeywordCastExpr::Monitor;
+                                break;
+                        default:
+                                break;
+                }
+                assert ( castTarget < KeywordCastExpr::NUMBER_OF_TARGETS );
+                auto expr = visitBaseExpr( node,
+                        new KeywordCastExpr(
+                                get<Expression>().accept1(node->arg),
+                                castTarget
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::VirtualCastExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr_skipResultType( node,
+                        new VirtualCastExpr(
+                                get<Expression>().accept1(node->arg),
+                                get<Type>().accept1(node->result)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::UntypedMemberExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new UntypedMemberExpr(
+                                get<Expression>().accept1(node->member),
+                                get<Expression>().accept1(node->aggregate)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::MemberExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new MemberExpr(
+                                inCache(node->member) ?
+                                        dynamic_cast<DeclarationWithType *>(this->node) :
+                                        get<DeclarationWithType>().accept1(node->member),
+                                get<Expression>().accept1(node->aggregate)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::VariableExpr * node ) override final {
-                (void)node;
-                return nullptr;
+                auto expr = visitBaseExpr( node,
+                        new VariableExpr(
+                                inCache(node->var) ?
+                                        dynamic_cast<DeclarationWithType *>(this->node) :
+                                        get<DeclarationWithType>().accept1(node->var)
+                        )
+                );
+                this->node = expr;
+                return nullptr;
+        }
+
+        bool isIntlikeConstantType(const ast::Type *t) {
+                if ( const ast::BasicType * basicType = dynamic_cast< const ast::BasicType * >( t ) ) {
+                        if ( basicType->isInteger() ) {
+                                return true;
+                        }
+                } else if ( dynamic_cast< const ast::OneType * >( t ) ) {
+                        return true;
+                } else if ( dynamic_cast< const ast::ZeroType * >( t ) ) {
+                        return true;
+                } else if ( dynamic_cast< const ast::PointerType * >( t ) ) {
+                        // null pointer constants, with zero int-values
+                        return true;
+                }
+                return false;
+        }
+
+        bool isFloatlikeConstantType(const ast::Type *t) {
+                if ( const ast::BasicType * bty = dynamic_cast< const ast::BasicType * >( t ) ) {
+                        if ( ! bty->isInteger() ) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+
+        bool isStringlikeConstantType(const ast::Type *t) {
+                if ( const ast::ArrayType * aty = dynamic_cast< const ast::ArrayType * >( t ) ) {
+                        if ( const ast::BasicType * bty = aty->base.as<ast::BasicType>() ) {
+                           if ( bty->kind == ast::BasicType::Kind::Char ) {
+                                   return true;
+                           }
+                        }
+                }
+                return false;
         }
 
         const ast::Expr * visit( const ast::ConstantExpr * node ) override final {
-                (void)node;
+                ConstantExpr *rslt = nullptr;
+                if (isIntlikeConstantType(node->result)) {
+                        rslt = new ConstantExpr(Constant(
+                                get<Type>().accept1(node->result),
+                                node->rep,
+                                (unsigned long long) node->intValue()
+                        ));
+                } else if (isFloatlikeConstantType(node->result)) {
+                        rslt = new ConstantExpr(Constant(
+                                get<Type>().accept1(node->result),
+                                node->rep,
+                                (double) node->floatValue()
+                        ));
+                } else if (isStringlikeConstantType(node->result)) {
+                        rslt = new ConstantExpr(Constant::from_string(
+                                node->rep
+                        ));
+                }
+                assert(rslt);
+                auto expr = visitBaseExpr( node, rslt );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::SizeofExpr * node ) override final {
-                (void)node;
+                assert (node->expr || node->type);
+                assert (! (node->expr && node->type));
+                SizeofExpr *rslt;
+                if (node->expr) {
+                        rslt = new SizeofExpr(
+                                get<Expression>().accept1(node->expr)
+                        );
+                        assert (!rslt->isType);
+                }
+                if (node->type) {
+                        rslt = new SizeofExpr(
+                                get<Type>().accept1(node->type)
+                        );
+                        assert (rslt->isType);
+                }
+                auto expr = visitBaseExpr( node, rslt );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::AlignofExpr * node ) override final {
-                (void)node;
+                assert (node->expr || node->type);
+                assert (! (node->expr && node->type));
+                AlignofExpr *rslt;
+                if (node->expr) {
+                        rslt = new AlignofExpr(
+                                get<Expression>().accept1(node->expr)
+                        );
+                        assert (!rslt->isType);
+                }
+                if (node->type) {
+                        rslt = new AlignofExpr(
+                                get<Type>().accept1(node->type)
+                        );
+                        assert (rslt->isType);
+                }
+                auto expr = visitBaseExpr( node, rslt );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::UntypedOffsetofExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new UntypedOffsetofExpr(
+                                get<Type>().accept1(node->type),
+                                node->member
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::OffsetofExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new OffsetofExpr(
+                                get<Type>().accept1(node->type),
+                                inCache(node->member) ?
+                                        dynamic_cast<DeclarationWithType *>(this->node) :
+                                        get<DeclarationWithType>().accept1(node->member)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::OffsetPackExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new OffsetPackExpr(
+                                get<StructInstType>().accept1(node->type)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::LogicalExpr * node ) override final {
-                (void)node;
+                assert (node->isAnd == ast::LogicalFlag::AndExpr ||
+                                node->isAnd == ast::LogicalFlag::OrExpr );
+                auto expr = visitBaseExpr( node,
+                        new LogicalExpr(
+                                get<Expression>().accept1(node->arg1),
+                                get<Expression>().accept1(node->arg2),
+                                (node->isAnd == ast::LogicalFlag::AndExpr)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::ConditionalExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new ConditionalExpr(
+                                get<Expression>().accept1(node->arg1),
+                                get<Expression>().accept1(node->arg2),
+                                get<Expression>().accept1(node->arg3)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::CommaExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new CommaExpr(
+                                get<Expression>().accept1(node->arg1),
+                                get<Expression>().accept1(node->arg2)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::TypeExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new TypeExpr(
+                                get<Type>().accept1(node->type)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::AsmExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new AsmExpr(
+                                get<Expression>().accept1(node->inout),
+                                get<Expression>().accept1(node->constraint),
+                                get<Expression>().accept1(node->operand)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::ImplicitCopyCtorExpr * node ) override final {
-                (void)node;
+                auto rslt = new ImplicitCopyCtorExpr(
+                        get<ApplicationExpr>().accept1(node->callExpr)
+                );
+
+                rslt->tempDecls = get<ObjectDecl>().acceptL(node->tempDecls);
+                rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
+                rslt->dtors = get<Expression>().acceptL(node->dtors);
+
+                auto expr = visitBaseExpr( node, rslt );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::ConstructorExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new ConstructorExpr(
+                                get<Expression>().accept1(node->callExpr)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::CompoundLiteralExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr_skipResultType( node,
+                        new CompoundLiteralExpr(
+                                get<Type>().accept1(node->result),
+                                get<Initializer>().accept1(node->init)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::RangeExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new RangeExpr(
+                                get<Expression>().accept1(node->low),
+                                get<Expression>().accept1(node->high)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::UntypedTupleExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new UntypedTupleExpr(
+                                get<Expression>().acceptL(node->exprs)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::TupleExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new UntypedTupleExpr(
+                                get<Expression>().acceptL(node->exprs)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::TupleIndexExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new TupleIndexExpr(
+                                get<Expression>().accept1(node->tuple),
+                                node->index
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::TupleAssignExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new TupleAssignExpr(
+                                get<StmtExpr>().accept1(node->stmtExpr)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::StmtExpr * node ) override final {
-                (void)node;
+                auto rslt = new StmtExpr(
+                        get<CompoundStmt>().accept1(node->stmts)
+                );
+
+                rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
+                rslt->dtors       = get<Expression>().acceptL(node->dtors);
+
+                auto expr = visitBaseExpr( node, rslt );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::UniqueExpr * node ) override final {
-                (void)node;
+                auto rslt = new UniqueExpr(
+                        get<Expression>().accept1(node->expr)
+                );
+
+                rslt->object = get<ObjectDecl>  ().accept1(node->object);
+                rslt->var    = get<VariableExpr>().accept1(node->var);
+
+                auto expr = visitBaseExpr( node, rslt );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::UntypedInitExpr * node ) override final {
-                (void)node;
+                std::list<InitAlternative> initAlts;
+                for (auto ia : node->initAlts) {
+                        initAlts.push_back(InitAlternative(
+                                get<Type>       ().accept1(ia.type),
+                                get<Designation>().accept1(ia.designation)
+                        ));
+                }
+                auto expr = visitBaseExpr( node,
+                        new UntypedInitExpr(
+                                get<Expression>().accept1(node->expr),
+                                initAlts
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::InitExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new InitExpr(
+                                get<Expression>().accept1(node->expr),
+                                get<Designation>().accept1(node->designation)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::DeletedExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new DeletedExpr(
+                                get<Expression>().accept1(node->expr),
+                                inCache(node->deleteStmt) ?
+                                        this->node :
+                                        get<BaseSyntaxNode>().accept1(node->deleteStmt)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::DefaultArgExpr * node ) override final {
-                (void)node;
+                auto expr = visitBaseExpr( node,
+                        new DefaultArgExpr(
+                                get<Expression>().accept1(node->expr)
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
 
         const ast::Expr * visit( const ast::GenericExpr * node ) override final {
-                (void)node;
+                std::list<GenericExpr::Association> associations;
+                for (auto association : node->associations) {
+                        associations.push_back(GenericExpr::Association(
+                                get<Type>      ().accept1(association.type),
+                                get<Expression>().accept1(association.expr)
+                        ));
+                }
+                auto expr = visitBaseExpr( node,
+                        new GenericExpr(
+                                get<Expression>().accept1(node->control),
+                                associations
+                        )
+                );
+                this->node = expr;
                 return nullptr;
         }
@@ -1503 +1819 @@
         }
 
-        ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
-
-                nw->result = GET_ACCEPT_1(result, Type);
+        ast::Expr * visitBaseExpr_SkipResultType(Expression * old, ast::Expr * nw) {
+
                 nw->env    = convertTypeSubstitution(old->env);
 
@@ -1514 +1829 @@
         }
 
+        ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
+
+                nw->result = GET_ACCEPT_1(result, Type);
+                return visitBaseExpr_SkipResultType(old, nw);;
+        }
+
         virtual void visit( ApplicationExpr * old ) override final {
                 this->node = visitBaseExpr( old,
@@ -1547 +1868 @@
                         new ast::CastExpr(
                                 old->location,
-                                nullptr, // cast's "to" type is expr's result type; converted in visitBaseExpr
+                                GET_ACCEPT_1(arg, Expr),
                                 old->isGenerated ? ast::GeneratedCast : ast::ExplicitCast
                         )
@@ -1553 +1874 @@
         }
 
-        virtual void visit( KeywordCastExpr * ) override final {
-
-        }
-
-        virtual void visit( VirtualCastExpr * ) override final {
-
-        }
-
-        virtual void visit( AddressExpr * ) override final {
-
-        }
-
-        virtual void visit( LabelAddressExpr * ) override final {
-
-        }
-
-        virtual void visit( UntypedMemberExpr * ) override final {
-
-        }
-
-        virtual void visit( MemberExpr * ) override final {
-
-        }
-
-        virtual void visit( VariableExpr * ) override final {
-
-        }
-
-        virtual void visit( ConstantExpr * ) override final {
-
-        }
-
-        virtual void visit( SizeofExpr * ) override final {
-
-        }
-
-        virtual void visit( AlignofExpr * ) override final {
-
-        }
-
-        virtual void visit( UntypedOffsetofExpr * ) override final {
-
-        }
-
-        virtual void visit( OffsetofExpr * ) override final {
-
-        }
-
-        virtual void visit( OffsetPackExpr * ) override final {
-
-        }
-
-        virtual void visit( LogicalExpr * ) override final {
-
-        }
-
-        virtual void visit( ConditionalExpr * ) override final {
-
-        }
-
-        virtual void visit( CommaExpr * ) override final {
-
-        }
-
-        virtual void visit( TypeExpr * ) override final {
-
-        }
-
-        virtual void visit( AsmExpr * ) override final {
-
-        }
-
-        virtual void visit( ImplicitCopyCtorExpr * ) override final {
-
-        }
-
-        virtual void visit( ConstructorExpr *  ) override final {
-
-        }
-
-        virtual void visit( CompoundLiteralExpr * ) override final {
-
-        }
-
-        virtual void visit( RangeExpr * ) override final {
-
-        }
-
-        virtual void visit( UntypedTupleExpr * ) override final {
-
-        }
-
-        virtual void visit( TupleExpr * ) override final {
-
-        }
-
-        virtual void visit( TupleIndexExpr * ) override final {
-
-        }
-
-        virtual void visit( TupleAssignExpr * ) override final {
-
-        }
-
-        virtual void visit( StmtExpr *  ) override final {
-
-        }
-
-        virtual void visit( UniqueExpr *  ) override final {
-
-        }
-
-        virtual void visit( UntypedInitExpr *  ) override final {
-
-        }
-
-        virtual void visit( InitExpr *  ) override final {
-
-        }
-
-        virtual void visit( DeletedExpr * ) override final {
-
-        }
-
-        virtual void visit( DefaultArgExpr * ) override final {
-
-        }
-
-        virtual void visit( GenericExpr * ) override final {
-
+        virtual void visit( KeywordCastExpr * old) override final {
+                ast::KeywordCastExpr::Target castTarget = ast::KeywordCastExpr::NUMBER_OF_TARGETS;
+                switch (old->target) {
+                        case KeywordCastExpr::Coroutine:
+                                castTarget = ast::KeywordCastExpr::Coroutine;
+                                break;
+                        case KeywordCastExpr::Thread:
+                                castTarget = ast::KeywordCastExpr::Thread;
+                                break;
+                        case KeywordCastExpr::Monitor:
+                                castTarget = ast::KeywordCastExpr::Monitor;
+                                break;
+                        default:
+                                break;
+                }
+                assert ( castTarget < ast::KeywordCastExpr::NUMBER_OF_TARGETS );
+                this->node = visitBaseExpr( old,
+                        new ast::KeywordCastExpr(
+                                old->location,
+                                GET_ACCEPT_1(arg, Expr),
+                                castTarget
+                        )
+                );
+        }
+
+        virtual void visit( VirtualCastExpr * old ) override final {
+                this->node = visitBaseExpr_SkipResultType( old,
+                        new ast::VirtualCastExpr(
+                                old->location,
+                                GET_ACCEPT_1(arg, Expr),
+                                GET_ACCEPT_1(result, Type)
+                        )
+                );
+        }
+
+        virtual void visit( AddressExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::AddressExpr(
+                                old->location,
+                                GET_ACCEPT_1(arg, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( LabelAddressExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::LabelAddressExpr(
+                                old->location,
+                                make_label(&old->arg)
+                        )
+                );
+        }
+
+        virtual void visit( UntypedMemberExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::UntypedMemberExpr(
+                                old->location,
+                                GET_ACCEPT_1(member, Expr),
+                                GET_ACCEPT_1(aggregate, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( MemberExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::MemberExpr(
+                                old->location,
+                                inCache(old->member) ?
+                                        dynamic_cast<ast::DeclWithType *>(this->node) :
+                                        GET_ACCEPT_1(member, DeclWithType),
+                                GET_ACCEPT_1(aggregate, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( VariableExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::VariableExpr(
+                                old->location,
+                                inCache(old->var) ?
+                                        dynamic_cast<ast::DeclWithType *>(this->node) :
+                                        GET_ACCEPT_1(var, DeclWithType)
+                        )
+                );
+        }
+
+        bool isIntlikeConstantType(const Type *t) {
+                if ( const BasicType * basicType = dynamic_cast< const BasicType * >( t ) ) {
+                        if ( basicType->isInteger() ) {
+                                return true;
+                        }
+                } else if ( dynamic_cast< const OneType * >( t ) ) {
+                        return true;
+                } else if ( dynamic_cast< const ZeroType * >( t ) ) {
+                        return true;
+                } else if ( dynamic_cast< const PointerType * >( t ) ) {
+                        // null pointer constants, with zero int-values
+                        return true;
+                }
+                return false;
+        }
+
+        int isFloatlikeConstantType(const Type *t) {
+                if ( const BasicType * bty = dynamic_cast< const BasicType * >( t ) ) {
+                        if ( ! bty->isInteger() ) {
+                                return true;
+                        }
+                }
+                return false;
+        }
+
+        int isStringlikeConstantType(const Type *t) {
+                if ( const ArrayType * aty = dynamic_cast< const ArrayType * >( t ) ) {
+                        if ( const BasicType * bty = dynamic_cast< const BasicType * >( aty->base ) ) {
+                           if ( bty->kind == BasicType::Kind::Char ) {
+                                   return true;
+                           }
+                        }
+                }
+                return false;
+        }
+
+        virtual void visit( ConstantExpr * old ) override final {
+                ast::ConstantExpr *rslt = nullptr;
+                if (isIntlikeConstantType(old->result)) {
+                        rslt = new ast::ConstantExpr(
+                                old->location,
+                                GET_ACCEPT_1(result, Type),
+                                old->constant.get_value(),
+                                (unsigned long long) old->intValue()
+                        );
+                } else if (isFloatlikeConstantType(old->result)) {
+                        rslt = new ast::ConstantExpr(
+                                old->location,
+                                GET_ACCEPT_1(result, Type), 
+                                old->constant.get_value(), 
+                                (double) old->constant.get_dval()
+                        );
+                } else if (isStringlikeConstantType(old->result)) {
+                        rslt = ast::ConstantExpr::from_string(
+                                old->location,
+                                old->constant.get_value()
+                        );
+                }
+                assert(rslt);
+                this->node = visitBaseExpr( old, rslt );
+        }
+
+        virtual void visit( SizeofExpr * old ) override final {
+                assert (old->expr || old->type);
+                assert (! (old->expr && old->type));
+                ast::SizeofExpr *rslt;
+                if (old->expr) {
+                        assert(!old->isType);
+                        rslt = new ast::SizeofExpr(
+                                old->location, 
+                                GET_ACCEPT_1(expr, Expr)
+                        );
+                }
+                if (old->type) {
+                        assert(old->isType);
+                        rslt = new ast::SizeofExpr(
+                                old->location, 
+                                GET_ACCEPT_1(type, Type)
+                        );
+                }
+                this->node = visitBaseExpr( old, rslt );
+        }
+
+        virtual void visit( AlignofExpr * old ) override final {
+                assert (old->expr || old->type);
+                assert (! (old->expr && old->type));
+                ast::AlignofExpr *rslt;
+                if (old->expr) {
+                        assert(!old->isType);
+                        rslt = new ast::AlignofExpr(
+                                old->location, 
+                                GET_ACCEPT_1(expr, Expr)
+                        );
+                }
+                if (old->type) {
+                        assert(old->isType);
+                        rslt = new ast::AlignofExpr(
+                                old->location, 
+                                GET_ACCEPT_1(type, Type)
+                        );
+                }
+                this->node = visitBaseExpr( old, rslt );
+        }
+
+        virtual void visit( UntypedOffsetofExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::UntypedOffsetofExpr(
+                                old->location,
+                                GET_ACCEPT_1(type, Type),
+                                old->member
+                        )
+                );
+        }
+
+        virtual void visit( OffsetofExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::OffsetofExpr(
+                                old->location,
+                                GET_ACCEPT_1(type, Type),
+                                inCache(old->member) ?
+                                        dynamic_cast<ast::DeclWithType *>(this->node) :
+                                        GET_ACCEPT_1(member, DeclWithType)
+                        )
+                );
+        }
+
+        virtual void visit( OffsetPackExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::OffsetPackExpr(
+                                old->location,
+                                GET_ACCEPT_1(type, StructInstType)
+                        )
+                );
+        }
+
+        virtual void visit( LogicalExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::LogicalExpr(
+                                old->location,
+                                GET_ACCEPT_1(arg1, Expr),
+                                GET_ACCEPT_1(arg2, Expr),
+                                old->get_isAnd() ? 
+                                        ast::LogicalFlag::AndExpr :
+                                        ast::LogicalFlag::OrExpr
+                        )
+                );
+        }
+
+        virtual void visit( ConditionalExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::ConditionalExpr(
+                                old->location,
+                                GET_ACCEPT_1(arg1, Expr),
+                                GET_ACCEPT_1(arg2, Expr),
+                                GET_ACCEPT_1(arg3, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( CommaExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::CommaExpr(
+                                old->location,
+                                GET_ACCEPT_1(arg1, Expr),
+                                GET_ACCEPT_1(arg2, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( TypeExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::TypeExpr(
+                                old->location,
+                                GET_ACCEPT_1(type, Type)
+                        )
+                );
+        }
+
+        virtual void visit( AsmExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::AsmExpr(
+                                old->location,
+                                GET_ACCEPT_1(inout, Expr),
+                                GET_ACCEPT_1(constraint, Expr),
+                                GET_ACCEPT_1(operand, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( ImplicitCopyCtorExpr * old ) override final {
+                auto rslt = new ast::ImplicitCopyCtorExpr(
+                        old->location,
+                        GET_ACCEPT_1(callExpr, ApplicationExpr)
+                );
+
+                rslt->tempDecls = GET_ACCEPT_V(tempDecls, ObjectDecl);
+                rslt->returnDecls = GET_ACCEPT_V(returnDecls, ObjectDecl);
+                rslt->dtors = GET_ACCEPT_V(dtors, Expr);
+
+                this->node = visitBaseExpr( old, rslt );
+        }
+
+        virtual void visit( ConstructorExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::ConstructorExpr(
+                                old->location,
+                                GET_ACCEPT_1(callExpr, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( CompoundLiteralExpr * old ) override final {
+                this->node = visitBaseExpr_SkipResultType( old,
+                        new ast::CompoundLiteralExpr(
+                                old->location,
+                                GET_ACCEPT_1(result, Type),
+                                GET_ACCEPT_1(initializer, Init)
+                        )
+                );
+        }
+
+        virtual void visit( RangeExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::RangeExpr(
+                                old->location,
+                                GET_ACCEPT_1(low, Expr),
+                                GET_ACCEPT_1(high, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( UntypedTupleExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::UntypedTupleExpr(
+                                old->location,
+                                GET_ACCEPT_V(exprs, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( TupleExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::TupleExpr(
+                                old->location,
+                                GET_ACCEPT_V(exprs, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( TupleIndexExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::TupleIndexExpr(
+                                old->location,
+                                GET_ACCEPT_1(tuple, Expr),
+                                old->index
+                        )
+                );
+        }
+
+        virtual void visit( TupleAssignExpr * old ) override final {
+                this->node = visitBaseExpr_SkipResultType( old,
+                        new ast::TupleAssignExpr(
+                                old->location,
+                                GET_ACCEPT_1(result, Type),
+                                GET_ACCEPT_1(stmtExpr, StmtExpr)
+                        )
+                );
+        }
+
+        virtual void visit( StmtExpr * old ) override final {
+                auto rslt = new ast::StmtExpr(
+                        old->location,
+                        GET_ACCEPT_1(statements, CompoundStmt)
+                );
+                rslt->returnDecls = GET_ACCEPT_V(returnDecls, ObjectDecl);
+                rslt->dtors       = GET_ACCEPT_V(dtors      , Expr);
+
+                this->node = visitBaseExpr_SkipResultType( old, rslt );
+        }
+
+        virtual void visit( UniqueExpr * old ) override final {
+                auto rslt = new ast::UniqueExpr(
+                        old->location,
+                        GET_ACCEPT_1(expr, Expr)
+                );
+                rslt->object = GET_ACCEPT_1(object, ObjectDecl);
+                rslt->var    = GET_ACCEPT_1(var   , VariableExpr);
+
+                this->node = visitBaseExpr( old, rslt );
+        }
+
+        virtual void visit( UntypedInitExpr * old ) override final {
+                std::vector<ast::InitAlternative> initAlts;
+                for (auto ia : old->initAlts) {
+                        initAlts.push_back(ast::InitAlternative(
+                                getAccept1< ast::Type, Type * >( ia.type ),
+                                getAccept1< ast::Designation, Designation * >( ia.designation )
+                        ));
+                }
+                this->node = visitBaseExpr( old,
+                        new ast::UntypedInitExpr(
+                                old->location,
+                                GET_ACCEPT_1(expr, Expr),
+                                std::move(initAlts)
+                        )
+                );
+        }
+
+        virtual void visit( InitExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::InitExpr(
+                                old->location,
+                                GET_ACCEPT_1(expr, Expr),
+                                GET_ACCEPT_1(designation, Designation)
+                        )
+                );
+        }
+
+        virtual void visit( DeletedExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::DeletedExpr(
+                                old->location,
+                                GET_ACCEPT_1(expr, Expr),
+                                inCache(old->deleteStmt) ?
+                                        this->node :
+                                        GET_ACCEPT_1(deleteStmt, Node)
+                        )
+                );
+        }
+
+        virtual void visit( DefaultArgExpr * old ) override final {
+                this->node = visitBaseExpr( old,
+                        new ast::DefaultArgExpr(
+                                old->location,
+                                GET_ACCEPT_1(expr, Expr)
+                        )
+                );
+        }
+
+        virtual void visit( GenericExpr * old ) override final {
+                std::vector<ast::GenericExpr::Association> associations;
+                for (auto association : old->associations) {
+                        associations.push_back(ast::GenericExpr::Association(
+                                getAccept1< ast::Type, Type * >( association.type ),
+                                getAccept1< ast::Expr, Expression * >( association.expr )
+                        ));
+                }
+                this->node = visitBaseExpr( old,
+                        new ast::GenericExpr(
+                                old->location,
+                                GET_ACCEPT_1(control, Expr),
+                                std::move(associations)
+                        )
+                );
         }