source: src/AST/Convert.cpp @ 0aedb01

arm-ehenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-expr
Last change on this file since 0aedb01 was 0aedb01, checked in by Thierry Delisle <tdelisle@…>, 3 years ago

Fix error introduced in merge

  • Property mode set to 100644
File size: 70.2 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2019 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Convert.cpp -- Convert between the new and old syntax trees.
8//
9// Author           : Thierry Delisle
10// Created On       : Thu May 09 15::37::05 2019
11// Last Modified By : Andrew Beach
12// Last Modified On : Wed May 29 11:05:00 2019
13// Update Count     : 8
14//
15
16#include "Convert.hpp"
17
18#include <unordered_map>
19
20#include "AST/Attribute.hpp"
21#include "AST/Decl.hpp"
22#include "AST/Expr.hpp"
23#include "AST/Init.hpp"
24#include "AST/Stmt.hpp"
25#include "AST/TypeSubstitution.hpp"
26
27#include "SymTab/Autogen.h"
28#include "SynTree/Attribute.h"
29#include "SynTree/Declaration.h"
30#include "SynTree/TypeSubstitution.h"
31
32#include "Validate/FindSpecialDecls.h"
33
34//================================================================================================
35// Utilities
36template<template <class...> class C>
37struct to {
38        template<typename T>
39        static auto from( T && v ) -> C< typename T::value_type > {
40                C< typename T::value_type > l;
41                std::move(std::begin(v), std::end(v), std::back_inserter(l));
42                return l;
43        }
44};
45
46//================================================================================================
47namespace {
48
49// This is to preserve the SymTab::dereferenceOperator hack. It does not (and perhaps should not)
50// allow us to use the same stratagy in the new ast.
51ast::FunctionDecl * dereferenceOperator = nullptr;
52
53}
54
55//================================================================================================
56class ConverterNewToOld : public ast::Visitor {
57        BaseSyntaxNode * node = nullptr;
58        using Cache = std::unordered_map< const ast::Node *, BaseSyntaxNode * >;
59        Cache cache;
60
61        template<typename T>
62        struct Getter {
63                ConverterNewToOld & visitor;
64
65                template<typename U, enum ast::Node::ref_type R>
66                T * accept1( const ast::ptr_base<U, R> & ptr ) {
67                        if ( ! ptr ) return nullptr;
68                        ptr->accept( visitor );
69                        T * ret = strict_dynamic_cast< T * >( visitor.node );
70                        visitor.node = nullptr;
71                        return ret;
72                }
73
74                template<typename U>
75                std::list< T * > acceptL( const U & container ) {
76                        std::list< T * > ret;
77                        for (auto ptr : container ) {
78                                ret.emplace_back( accept1( ptr ) );
79                        }
80                        return ret;
81                }
82        };
83
84    template<typename T>
85    Getter<T> get() {
86        return Getter<T>{ *this };
87    }
88
89        Label makeLabel(Statement * labelled, const ast::Label& label) {
90                return Label(
91                        label.name,
92                        labelled,
93                        get<Attribute>().acceptL(label.attributes)
94                );
95        }
96
97        template<template <class...> class C>
98        std::list<Label> makeLabelL(Statement * labelled, const C<ast::Label>& labels) {
99                std::list<Label> ret;
100                for (auto label : labels) {
101                        ret.push_back( makeLabel(labelled, label) );
102                }
103                return ret;
104        }
105
106        /// get new qualifiers from old type
107        Type::Qualifiers cv( const ast::Type * ty ) { return { ty->qualifiers.val }; }
108
109        /// returns true and sets `node` if in cache
110        bool inCache( const ast::Node * node ) {
111                auto it = cache.find( node );
112                if ( it == cache.end() ) return false;
113                this->node = it->second;
114                return true;
115        }
116
117public:
118        Declaration * decl( const ast::Decl * declNode ) {
119                return get<Declaration>().accept1( ast::ptr<ast::Decl>( declNode ) );
120        }
121
122private:
123        void declPostamble( Declaration * decl, const ast::Decl * node ) {
124                decl->location = node->location;
125                // name comes from constructor
126                // linkage comes from constructor
127                decl->extension = node->extension;
128                decl->uniqueId = node->uniqueId;
129                // storageClasses comes from constructor
130                this->node = decl;
131        }
132
133        const ast::DeclWithType * declWithTypePostamble (
134                        DeclarationWithType * decl, const ast::DeclWithType * node ) {
135                cache.emplace( node, decl );
136                decl->mangleName = node->mangleName;
137                decl->scopeLevel = node->scopeLevel;
138                decl->asmName = get<Expression>().accept1( node->asmName );
139                // attributes comes from constructor
140                decl->isDeleted = node->isDeleted;
141                // fs comes from constructor
142                declPostamble( decl, node );
143                return nullptr;
144        }
145
146        const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
147                if ( inCache( node ) ) return nullptr;
148                auto decl = new ObjectDecl(
149                        node->name,
150                        Type::StorageClasses( node->storage.val ),
151                        LinkageSpec::Spec( node->linkage.val ),
152                        get<Expression>().accept1( node->bitfieldWidth ),
153                        get<Type>().accept1( node->type ),
154                        get<Initializer>().accept1( node->init ),
155                        get<Attribute>().acceptL( node->attributes ),
156                        Type::FuncSpecifiers( node->funcSpec.val )
157                );
158                return declWithTypePostamble( decl, node );
159        }
160
161        const ast::DeclWithType * visit( const ast::FunctionDecl * node ) override final {
162                if ( inCache( node ) ) return nullptr;
163                auto decl = new FunctionDecl(
164                        node->name,
165                        Type::StorageClasses( node->storage.val ),
166                        LinkageSpec::Spec( node->linkage.val ),
167                        get<FunctionType>().accept1( node->type ),
168                        get<CompoundStmt>().accept1( node->stmts ),
169                        get<Attribute>().acceptL( node->attributes ),
170                        Type::FuncSpecifiers( node->funcSpec.val )
171                );
172                decl->withExprs = get<Expression>().acceptL( node->withExprs );
173                if ( dereferenceOperator == node ) {
174                        Validate::dereferenceOperator = decl;
175                }
176                return declWithTypePostamble( decl, node );
177        }
178
179        const ast::Decl * namedTypePostamble( NamedTypeDecl * decl, const ast::NamedTypeDecl * node ) {
180                // base comes from constructor
181                decl->parameters = get<TypeDecl>().acceptL( node->params );
182                decl->assertions = get<DeclarationWithType>().acceptL( node->assertions );
183                declPostamble( decl, node );
184                return nullptr;
185        }
186
187        const ast::Decl * visit( const ast::TypeDecl * node ) override final {
188                if ( inCache( node ) ) return nullptr;
189                auto decl = new TypeDecl(
190                        node->name,
191                        Type::StorageClasses( node->storage.val ),
192                        get<Type>().accept1( node->base ),
193                        (TypeDecl::Kind)(unsigned)node->kind,
194                        node->sized,
195                        get<Type>().accept1( node->init )
196                );
197                cache.emplace( node, decl );
198                return namedTypePostamble( decl, node );
199        }
200
201        const ast::Decl * visit( const ast::TypedefDecl * node ) override final {
202                auto decl = new TypedefDecl(
203                        node->name,
204                        node->location,
205                        Type::StorageClasses( node->storage.val ),
206            get<Type>().accept1( node->base ),
207                        LinkageSpec::Spec( node->linkage.val )
208                );
209                return namedTypePostamble( decl, node );
210        }
211
212        const ast::Decl * aggregatePostamble( AggregateDecl * decl, const ast::AggregateDecl * node ) {
213                cache.emplace( node, decl );
214                decl->members = get<Declaration>().acceptL( node->members );
215                decl->parameters = get<TypeDecl>().acceptL( node->params );
216                decl->body = node->body;
217                // attributes come from constructor
218                decl->parent = get<AggregateDecl>().accept1( node->parent );
219                declPostamble( decl, node );
220                return nullptr;
221        }
222
223        const ast::Decl * visit( const ast::StructDecl * node ) override final {
224                if ( inCache( node ) ) return nullptr;
225                auto decl = new StructDecl(
226                        node->name,
227                        node->kind,
228                        get<Attribute>().acceptL( node->attributes ),
229                        LinkageSpec::Spec( node->linkage.val )
230                );
231                return aggregatePostamble( decl, node );
232        }
233
234        const ast::Decl * visit( const ast::UnionDecl * node ) override final {
235                if ( inCache( node ) ) return nullptr;
236                auto decl = new UnionDecl(
237                        node->name,
238                        get<Attribute>().acceptL( node->attributes ),
239                        LinkageSpec::Spec( node->linkage.val )
240                );
241                return aggregatePostamble( decl, node );
242        }
243
244        const ast::Decl * visit( const ast::EnumDecl * node ) override final {
245                if ( inCache( node ) ) return nullptr;
246                auto decl = new EnumDecl(
247                        node->name,
248                        get<Attribute>().acceptL( node->attributes ),
249                        LinkageSpec::Spec( node->linkage.val )
250                );
251                return aggregatePostamble( decl, node );
252        }
253
254        const ast::Decl * visit( const ast::TraitDecl * node ) override final {
255                if ( inCache( node ) ) return nullptr;
256                auto decl = new TraitDecl(
257                        node->name,
258                        {},
259                        LinkageSpec::Spec( node->linkage.val )
260                );
261                return aggregatePostamble( decl, node );
262        }
263
264        const ast::AsmDecl * visit( const ast::AsmDecl * node ) override final {
265                auto decl = new AsmDecl( get<AsmStmt>().accept1( node->stmt ) );
266                declPostamble( decl, node );
267                return nullptr;
268        }
269
270        const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl * node ) override final {
271                auto decl = new StaticAssertDecl(
272                        get<Expression>().accept1( node->cond ),
273                        get<ConstantExpr>().accept1( node->msg )
274                );
275                declPostamble( decl, node );
276                return nullptr;
277        }
278
279        const ast::Stmt * stmtPostamble( Statement * stmt, const ast::Stmt * node ) {
280                cache.emplace( node, stmt );
281                stmt->location = node->location;
282                stmt->labels = makeLabelL( stmt, node->labels );
283                this->node = stmt;
284                return nullptr;
285        }
286
287        const ast::CompoundStmt * visit( const ast::CompoundStmt * node ) override final {
288                if ( inCache( node ) ) return nullptr;
289                auto stmt = new CompoundStmt( get<Statement>().acceptL( node->kids ) );
290                stmtPostamble( stmt, node );
291                return nullptr;
292        }
293
294        const ast::Stmt * visit( const ast::ExprStmt * node ) override final {
295                if ( inCache( node ) ) return nullptr;
296                auto stmt = new ExprStmt( nullptr );
297                cache.emplace( node, stmt );
298                stmt->expr = get<Expression>().accept1( node->expr );
299                return stmtPostamble( stmt, node );
300        }
301
302        const ast::Stmt * visit( const ast::AsmStmt * node ) override final {
303                if ( inCache( node ) ) return nullptr;
304                auto stmt = new AsmStmt(
305                        node->isVolatile,
306                        get<Expression>().accept1( node->instruction ),
307                        get<Expression>().acceptL( node->output ),
308                        get<Expression>().acceptL( node->input ),
309                        get<ConstantExpr>().acceptL( node->clobber ),
310                        makeLabelL( nullptr, node->gotoLabels ) // What are these labelling?
311                );
312                return stmtPostamble( stmt, node );
313        }
314
315        const ast::Stmt * visit( const ast::DirectiveStmt * node ) override final {
316                if ( inCache( node ) ) return nullptr;
317                auto stmt = new DirectiveStmt( node->directive );
318                return stmtPostamble( stmt, node );
319        }
320
321        const ast::Stmt * visit( const ast::IfStmt * node ) override final {
322                if ( inCache( node ) ) return nullptr;
323                auto stmt = new IfStmt(
324                        get<Expression>().accept1( node->cond ),
325                        get<Statement>().accept1( node->thenPart ),
326                        get<Statement>().accept1( node->elsePart ),
327                        get<Statement>().acceptL( node->inits )
328                );
329                return stmtPostamble( stmt, node );
330        }
331
332        const ast::Stmt * visit( const ast::SwitchStmt * node ) override final {
333                if ( inCache( node ) ) return nullptr;
334                auto stmt = new SwitchStmt(
335                        get<Expression>().accept1( node->cond ),
336                        get<Statement>().acceptL( node->stmts )
337                );
338                return stmtPostamble( stmt, node );
339        }
340
341        const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
342                if ( inCache( node ) ) return nullptr;
343                auto stmt = new CaseStmt(
344                        get<Expression>().accept1( node->cond ),
345                        get<Statement>().acceptL( node->stmts ),
346                        node->isDefault()
347                );
348                return stmtPostamble( stmt, node );
349        }
350
351        const ast::Stmt * visit( const ast::WhileStmt * node ) override final {
352                if ( inCache( node ) ) return nullptr;
353                auto inits = get<Statement>().acceptL( node->inits );
354                auto stmt = new WhileStmt(
355                        get<Expression>().accept1( node->cond ),
356                        get<Statement>().accept1( node->body ),
357                        inits,
358                        node->isDoWhile
359                );
360                return stmtPostamble( stmt, node );
361        }
362
363        const ast::Stmt * visit( const ast::ForStmt * node ) override final {
364                if ( inCache( node ) ) return nullptr;
365                auto stmt = new ForStmt(
366                        get<Statement>().acceptL( node->inits ),
367                        get<Expression>().accept1( node->cond ),
368                        get<Expression>().accept1( node->inc ),
369                        get<Statement>().accept1( node->body )
370                );
371                return stmtPostamble( stmt, node );
372        }
373
374        const ast::Stmt * visit( const ast::BranchStmt * node ) override final {
375                if ( inCache( node ) ) return nullptr;
376                BranchStmt * stmt;
377                if (node->computedTarget) {
378                        stmt = new BranchStmt( get<Expression>().accept1( node->computedTarget ),
379                                BranchStmt::Goto );
380                } else {
381                        BranchStmt::Type type;
382                        switch (node->kind) {
383                        #define CASE(n) \
384                        case ast::BranchStmt::n: \
385                                type = BranchStmt::n; \
386                                break
387                        CASE(Goto);
388                        CASE(Break);
389                        CASE(Continue);
390                        CASE(FallThrough);
391                        CASE(FallThroughDefault);
392                        #undef CASE
393                        default:
394                                assertf(false, "Invalid ast::BranchStmt::Kind: %d\n", node->kind);
395                        }
396
397                        // The labels here are also weird.
398                        stmt = new BranchStmt( makeLabel( nullptr, node->originalTarget ), type );
399                        stmt->target = makeLabel( stmt, node->target );
400                }
401                return stmtPostamble( stmt, node );
402        }
403
404        const ast::Stmt * visit( const ast::ReturnStmt * node ) override final {
405                if ( inCache( node ) ) return nullptr;
406                auto stmt = new ReturnStmt( get<Expression>().accept1( node->expr ) );
407                return stmtPostamble( stmt, node );
408        }
409
410        const ast::Stmt * visit( const ast::ThrowStmt * node ) override final {
411                if ( inCache( node ) ) return nullptr;
412                ThrowStmt::Kind kind;
413                switch (node->kind) {
414                case ast::ExceptionKind::Terminate:
415                        kind = ThrowStmt::Terminate;
416                        break;
417                case ast::ExceptionKind::Resume:
418                        kind = ThrowStmt::Resume;
419                        break;
420                default:
421                        assertf(false, "Invalid ast::ThrowStmt::Kind: %d\n", node->kind);
422                }
423                auto stmt = new ThrowStmt(
424                        kind,
425                        get<Expression>().accept1( node->expr ),
426                        get<Expression>().accept1( node->target )
427                );
428                return stmtPostamble( stmt, node );
429        }
430
431        const ast::Stmt * visit( const ast::TryStmt * node ) override final {
432                if ( inCache( node ) ) return nullptr;
433                auto handlers = get<CatchStmt>().acceptL( node->handlers );
434                auto stmt = new TryStmt(
435                        get<CompoundStmt>().accept1( node->body ),
436                        handlers,
437                        get<FinallyStmt>().accept1( node->finally )
438                );
439                return stmtPostamble( stmt, node );
440        }
441
442        const ast::Stmt * visit( const ast::CatchStmt * node ) override final {
443                if ( inCache( node ) ) return nullptr;
444                CatchStmt::Kind kind;
445                switch (node->kind) {
446                case ast::ExceptionKind::Terminate:
447                        kind = CatchStmt::Terminate;
448                        break;
449                case ast::ExceptionKind::Resume:
450                        kind = CatchStmt::Resume;
451                        break;
452                default:
453                        assertf(false, "Invalid ast::CatchStmt::Kind: %d\n", node->kind);
454                }
455                auto stmt = new CatchStmt(
456                        kind,
457                        get<Declaration>().accept1( node->decl ),
458                        get<Expression>().accept1( node->cond ),
459                        get<Statement>().accept1( node->body )
460                );
461                return stmtPostamble( stmt, node );
462        }
463
464        const ast::Stmt * visit( const ast::FinallyStmt * node ) override final {
465                if ( inCache( node ) ) return nullptr;
466                auto stmt = new FinallyStmt( get<CompoundStmt>().accept1( node->body ) );
467                return stmtPostamble( stmt, node );
468        }
469
470        const ast::Stmt * visit( const ast::WaitForStmt * node ) override final {
471                if ( inCache( node ) ) return nullptr;
472                auto stmt = new WaitForStmt;
473                stmt->clauses.reserve( node->clauses.size() );
474                for ( auto clause : node->clauses ) {
475                        stmt->clauses.push_back({{
476                                        get<Expression>().accept1( clause.target.func ),
477                                        get<Expression>().acceptL( clause.target.args ),
478                                },
479                                get<Statement>().accept1( clause.stmt ),
480                                get<Expression>().accept1( clause.cond ),
481                        });
482                }
483                stmt->timeout = {
484                        get<Expression>().accept1( node->timeout.time ),
485                        get<Statement>().accept1( node->timeout.stmt ),
486                        get<Expression>().accept1( node->timeout.cond ),
487                };
488                stmt->orelse = {
489                        get<Statement>().accept1( node->orElse.stmt ),
490                        get<Expression>().accept1( node->orElse.cond ),
491                };
492                return stmtPostamble( stmt, node );
493        }
494
495        const ast::Stmt * visit( const ast::WithStmt * node ) override final {
496                if ( inCache( node ) ) return nullptr;
497                auto stmt = new WithStmt(
498                        get<Expression>().acceptL( node->exprs ),
499                        get<Statement>().accept1( node->stmt )
500                );
501                return stmtPostamble( stmt, node );
502        }
503
504        const ast::NullStmt * visit( const ast::NullStmt * node ) override final {
505                if ( inCache( node ) ) return nullptr;
506                auto stmt = new NullStmt();
507                stmtPostamble( stmt, node );
508                return nullptr;
509        }
510
511        const ast::Stmt * visit( const ast::DeclStmt * node ) override final {
512                if ( inCache( node ) ) return nullptr;
513                auto stmt = new DeclStmt( get<Declaration>().accept1( node->decl ) );
514                return stmtPostamble( stmt, node );
515        }
516
517        const ast::Stmt * visit( const ast::ImplicitCtorDtorStmt * node ) override final {
518                if ( inCache( node ) ) return nullptr;
519                auto stmt = new ImplicitCtorDtorStmt{
520                        get<Statement>().accept1( node->callStmt )
521                };
522                return stmtPostamble( stmt, node );
523        }
524
525        TypeSubstitution * convertTypeSubstitution(const ast::TypeSubstitution * src) {
526
527                if (!src) return nullptr;
528
529                TypeSubstitution *rslt = new TypeSubstitution();
530
531                for (decltype(src->begin()) src_i = src->begin(); src_i != src->end(); src_i++) {
532                        rslt->add( src_i->first,
533                                   get<Type>().accept1(src_i->second) );
534                }
535
536                for (decltype(src->beginVar()) src_i = src->beginVar(); src_i != src->endVar(); src_i++) {
537                        rslt->addVar( src_i->first,
538                                      get<Expression>().accept1(src_i->second) );
539                }
540
541                return rslt;
542        }
543
544        void convertInferUnion(std::map<UniqueId,ParamEntry> &tgtInferParams,
545                                                   std::vector<UniqueId>         &tgtResnSlots,
546                                                   const ast::Expr::InferUnion   &srcInferred ) {
547
548                assert( tgtInferParams.empty() );
549                assert( tgtResnSlots.empty() );
550
551                if ( srcInferred.mode == ast::Expr::InferUnion::Params ) {
552                        const ast::InferredParams &srcParams = srcInferred.inferParamsConst();
553                        for (auto srcParam : srcParams) {
554                                tgtInferParams[srcParam.first] = ParamEntry(
555                                        srcParam.second.decl,
556                                        get<Type>().accept1(srcParam.second.actualType),
557                                        get<Type>().accept1(srcParam.second.formalType),
558                                        get<Expression>().accept1(srcParam.second.expr)
559                                );
560                        }
561                } else if ( srcInferred.mode == ast::Expr::InferUnion::Slots  ) {
562                        const ast::ResnSlots &srcSlots = srcInferred.resnSlotsConst();
563                        for (auto srcSlot : srcSlots) {
564                                tgtResnSlots.push_back(srcSlot);
565                        }
566                }
567        }
568
569        Expression * visitBaseExpr_skipResultType(const ast::Expr * src, Expression * tgt) {
570
571                tgt->location  = src->location;
572                tgt->env       = convertTypeSubstitution(src->env);
573                tgt->extension = src->extension;
574
575                convertInferUnion(tgt->inferParams, tgt->resnSlots, src->inferred);
576                return tgt;
577        }
578
579        Expression * visitBaseExpr(const ast::Expr * src, Expression * tgt) {
580
581                tgt->result = get<Type>().accept1(src->result);
582                return visitBaseExpr_skipResultType(src, tgt);
583        }
584
585        const ast::Expr * visit( const ast::ApplicationExpr * node ) override final {
586                auto expr = visitBaseExpr( node,
587                        new ApplicationExpr(
588                                get<Expression>().accept1(node->func),
589                                get<Expression>().acceptL(node->args)
590                        )
591                );
592                this->node = expr;
593                return nullptr;
594        }
595
596        const ast::Expr * visit( const ast::UntypedExpr * node ) override final {
597                auto expr = visitBaseExpr( node,
598                        new UntypedExpr(
599                                get<Expression>().accept1(node->func),
600                                get<Expression>().acceptL(node->args)
601                        )
602                );
603                this->node = expr;
604                return nullptr;
605        }
606
607        const ast::Expr * visit( const ast::NameExpr * node ) override final {
608                auto expr = visitBaseExpr( node,
609                        new NameExpr(
610                                node->name
611                        )
612                );
613                this->node = expr;
614                return nullptr;
615        }
616
617        const ast::Expr * visit( const ast::AddressExpr * node ) override final {
618                auto expr = visitBaseExpr( node,
619                        new AddressExpr(
620                                get<Expression>().accept1(node->arg)
621                        )
622                );
623                this->node = expr;
624                return nullptr;
625        }
626
627        const ast::Expr * visit( const ast::LabelAddressExpr * node ) override final {
628                auto expr = visitBaseExpr( node,
629                        new LabelAddressExpr(
630                                makeLabel(nullptr, node->arg)
631                        )
632                );
633                this->node = expr;
634                return nullptr;
635        }
636
637        const ast::Expr * visit( const ast::CastExpr * node ) override final {
638                auto expr = visitBaseExpr( node,
639                        new CastExpr(
640                                get<Expression>().accept1(node->arg),
641                                (node->isGenerated == ast::GeneratedCast)
642                        )
643                );
644                this->node = expr;
645                return nullptr;
646        }
647
648        const ast::Expr * visit( const ast::KeywordCastExpr * node ) override final {
649                KeywordCastExpr::Target castTarget = KeywordCastExpr::NUMBER_OF_TARGETS;
650                switch (node->target) {
651                        case ast::KeywordCastExpr::Coroutine:
652                                castTarget = KeywordCastExpr::Coroutine;
653                                break;
654                        case ast::KeywordCastExpr::Thread:
655                                castTarget = KeywordCastExpr::Thread;
656                                break;
657                        case ast::KeywordCastExpr::Monitor:
658                                castTarget = KeywordCastExpr::Monitor;
659                                break;
660                        default:
661                                break;
662                }
663                assert ( castTarget < KeywordCastExpr::NUMBER_OF_TARGETS );
664                auto expr = visitBaseExpr( node,
665                        new KeywordCastExpr(
666                                get<Expression>().accept1(node->arg),
667                                castTarget
668                        )
669                );
670                this->node = expr;
671                return nullptr;
672        }
673
674        const ast::Expr * visit( const ast::VirtualCastExpr * node ) override final {
675                auto expr = visitBaseExpr_skipResultType( node,
676                        new VirtualCastExpr(
677                                get<Expression>().accept1(node->arg),
678                                get<Type>().accept1(node->result)
679                        )
680                );
681                this->node = expr;
682                return nullptr;
683        }
684
685        const ast::Expr * visit( const ast::UntypedMemberExpr * node ) override final {
686                auto expr = visitBaseExpr( node,
687                        new UntypedMemberExpr(
688                                get<Expression>().accept1(node->member),
689                                get<Expression>().accept1(node->aggregate)
690                        )
691                );
692                this->node = expr;
693                return nullptr;
694        }
695
696        const ast::Expr * visit( const ast::MemberExpr * node ) override final {
697                auto expr = visitBaseExpr( node,
698                        new MemberExpr(
699                                inCache(node->member) ?
700                                        dynamic_cast<DeclarationWithType *>(this->node) :
701                                        get<DeclarationWithType>().accept1(node->member),
702                                get<Expression>().accept1(node->aggregate)
703                        )
704                );
705                this->node = expr;
706                return nullptr;
707        }
708
709        const ast::Expr * visit( const ast::VariableExpr * node ) override final {
710                auto expr = visitBaseExpr( node,
711                        new VariableExpr(
712                                inCache(node->var) ?
713                                        dynamic_cast<DeclarationWithType *>(this->node) :
714                                        get<DeclarationWithType>().accept1(node->var)
715                        )
716                );
717                this->node = expr;
718                return nullptr;
719        }
720
721        const ast::Expr * visit( const ast::ConstantExpr * node ) override final {
722                ConstantExpr *rslt = nullptr;
723                switch ( node->kind ) {
724                case ast::ConstantExpr::Integer:
725                        rslt = new ConstantExpr{Constant{
726                                get<Type>().accept1( node->result ),
727                                node->rep,
728                                (unsigned long long) node->intValue()
729                        }};
730                        break;
731                case ast::ConstantExpr::FloatingPoint:
732                        rslt = new ConstantExpr{Constant{
733                                get<Type>().accept1(node->result),
734                                node->rep,
735                                (double) node->floatValue()
736                        }};
737                        break;
738                case ast::ConstantExpr::String:
739                        rslt = new ConstantExpr{Constant::from_string( node->rep )};
740                        break;
741                }
742                assert(rslt);
743                auto expr = visitBaseExpr( node, rslt );
744                this->node = expr;
745                return nullptr;
746        }
747
748        const ast::Expr * visit( const ast::SizeofExpr * node ) override final {
749                assert (node->expr || node->type);
750                assert (! (node->expr && node->type));
751                SizeofExpr *rslt;
752                if (node->expr) {
753                        rslt = new SizeofExpr(
754                                get<Expression>().accept1(node->expr)
755                        );
756                        assert (!rslt->isType);
757                }
758                if (node->type) {
759                        rslt = new SizeofExpr(
760                                get<Type>().accept1(node->type)
761                        );
762                        assert (rslt->isType);
763                }
764                auto expr = visitBaseExpr( node, rslt );
765                this->node = expr;
766                return nullptr;
767        }
768
769        const ast::Expr * visit( const ast::AlignofExpr * node ) override final {
770                assert (node->expr || node->type);
771                assert (! (node->expr && node->type));
772                AlignofExpr *rslt;
773                if (node->expr) {
774                        rslt = new AlignofExpr(
775                                get<Expression>().accept1(node->expr)
776                        );
777                        assert (!rslt->isType);
778                }
779                if (node->type) {
780                        rslt = new AlignofExpr(
781                                get<Type>().accept1(node->type)
782                        );
783                        assert (rslt->isType);
784                }
785                auto expr = visitBaseExpr( node, rslt );
786                this->node = expr;
787                return nullptr;
788        }
789
790        const ast::Expr * visit( const ast::UntypedOffsetofExpr * node ) override final {
791                auto expr = visitBaseExpr( node,
792                        new UntypedOffsetofExpr(
793                                get<Type>().accept1(node->type),
794                                node->member
795                        )
796                );
797                this->node = expr;
798                return nullptr;
799        }
800
801        const ast::Expr * visit( const ast::OffsetofExpr * node ) override final {
802                auto expr = visitBaseExpr( node,
803                        new OffsetofExpr(
804                                get<Type>().accept1(node->type),
805                                inCache(node->member) ?
806                                        dynamic_cast<DeclarationWithType *>(this->node) :
807                                        get<DeclarationWithType>().accept1(node->member)
808                        )
809                );
810                this->node = expr;
811                return nullptr;
812        }
813
814        const ast::Expr * visit( const ast::OffsetPackExpr * node ) override final {
815                auto expr = visitBaseExpr( node,
816                        new OffsetPackExpr(
817                                get<StructInstType>().accept1(node->type)
818                        )
819                );
820                this->node = expr;
821                return nullptr;
822        }
823
824        const ast::Expr * visit( const ast::LogicalExpr * node ) override final {
825                assert (node->isAnd == ast::LogicalFlag::AndExpr ||
826                                node->isAnd == ast::LogicalFlag::OrExpr );
827                auto expr = visitBaseExpr( node,
828                        new LogicalExpr(
829                                get<Expression>().accept1(node->arg1),
830                                get<Expression>().accept1(node->arg2),
831                                (node->isAnd == ast::LogicalFlag::AndExpr)
832                        )
833                );
834                this->node = expr;
835                return nullptr;
836        }
837
838        const ast::Expr * visit( const ast::ConditionalExpr * node ) override final {
839                auto expr = visitBaseExpr( node,
840                        new ConditionalExpr(
841                                get<Expression>().accept1(node->arg1),
842                                get<Expression>().accept1(node->arg2),
843                                get<Expression>().accept1(node->arg3)
844                        )
845                );
846                this->node = expr;
847                return nullptr;
848        }
849
850        const ast::Expr * visit( const ast::CommaExpr * node ) override final {
851                auto expr = visitBaseExpr( node,
852                        new CommaExpr(
853                                get<Expression>().accept1(node->arg1),
854                                get<Expression>().accept1(node->arg2)
855                        )
856                );
857                this->node = expr;
858                return nullptr;
859        }
860
861        const ast::Expr * visit( const ast::TypeExpr * node ) override final {
862                auto expr = visitBaseExpr( node,
863                        new TypeExpr(
864                                get<Type>().accept1(node->type)
865                        )
866                );
867                this->node = expr;
868                return nullptr;
869        }
870
871        const ast::Expr * visit( const ast::AsmExpr * node ) override final {
872                auto expr = visitBaseExpr( node,
873                        new AsmExpr(
874                                get<Expression>().accept1(node->inout),
875                                get<Expression>().accept1(node->constraint),
876                                get<Expression>().accept1(node->operand)
877                        )
878                );
879                this->node = expr;
880                return nullptr;
881        }
882
883        const ast::Expr * visit( const ast::ImplicitCopyCtorExpr * node ) override final {
884                auto rslt = new ImplicitCopyCtorExpr(
885                        get<ApplicationExpr>().accept1(node->callExpr)
886                );
887
888                auto expr = visitBaseExpr( node, rslt );
889                this->node = expr;
890                return nullptr;
891        }
892
893        const ast::Expr * visit( const ast::ConstructorExpr * node ) override final {
894                auto expr = visitBaseExpr( node,
895                        new ConstructorExpr(
896                                get<Expression>().accept1(node->callExpr)
897                        )
898                );
899                this->node = expr;
900                return nullptr;
901        }
902
903        const ast::Expr * visit( const ast::CompoundLiteralExpr * node ) override final {
904                auto expr = visitBaseExpr_skipResultType( node,
905                        new CompoundLiteralExpr(
906                                get<Type>().accept1(node->result),
907                                get<Initializer>().accept1(node->init)
908                        )
909                );
910                this->node = expr;
911                return nullptr;
912        }
913
914        const ast::Expr * visit( const ast::RangeExpr * node ) override final {
915                auto expr = visitBaseExpr( node,
916                        new RangeExpr(
917                                get<Expression>().accept1(node->low),
918                                get<Expression>().accept1(node->high)
919                        )
920                );
921                this->node = expr;
922                return nullptr;
923        }
924
925        const ast::Expr * visit( const ast::UntypedTupleExpr * node ) override final {
926                auto expr = visitBaseExpr( node,
927                        new UntypedTupleExpr(
928                                get<Expression>().acceptL(node->exprs)
929                        )
930                );
931                this->node = expr;
932                return nullptr;
933        }
934
935        const ast::Expr * visit( const ast::TupleExpr * node ) override final {
936                auto expr = visitBaseExpr( node,
937                        new UntypedTupleExpr(
938                                get<Expression>().acceptL(node->exprs)
939                        )
940                );
941                this->node = expr;
942                return nullptr;
943        }
944
945        const ast::Expr * visit( const ast::TupleIndexExpr * node ) override final {
946                auto expr = visitBaseExpr( node,
947                        new TupleIndexExpr(
948                                get<Expression>().accept1(node->tuple),
949                                node->index
950                        )
951                );
952                this->node = expr;
953                return nullptr;
954        }
955
956        const ast::Expr * visit( const ast::TupleAssignExpr * node ) override final {
957                auto expr = visitBaseExpr( node,
958                        new TupleAssignExpr(
959                                get<StmtExpr>().accept1(node->stmtExpr)
960                        )
961                );
962                this->node = expr;
963                return nullptr;
964        }
965
966        const ast::Expr * visit( const ast::StmtExpr * node ) override final {
967                auto rslt = new StmtExpr(
968                        get<CompoundStmt>().accept1(node->stmts)
969                );
970
971                rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
972                rslt->dtors       = get<Expression>().acceptL(node->dtors);
973
974                auto expr = visitBaseExpr( node, rslt );
975                this->node = expr;
976                return nullptr;
977        }
978
979        const ast::Expr * visit( const ast::UniqueExpr * node ) override final {
980                auto rslt = new UniqueExpr(
981                        get<Expression>().accept1(node->expr)
982                );
983
984                rslt->object = get<ObjectDecl>  ().accept1(node->object);
985                rslt->var    = get<VariableExpr>().accept1(node->var);
986
987                auto expr = visitBaseExpr( node, rslt );
988                this->node = expr;
989                return nullptr;
990        }
991
992        const ast::Expr * visit( const ast::UntypedInitExpr * node ) override final {
993                std::list<InitAlternative> initAlts;
994                for (auto ia : node->initAlts) {
995                        initAlts.push_back(InitAlternative(
996                                get<Type>       ().accept1(ia.type),
997                                get<Designation>().accept1(ia.designation)
998                        ));
999                }
1000                auto expr = visitBaseExpr( node,
1001                        new UntypedInitExpr(
1002                                get<Expression>().accept1(node->expr),
1003                                initAlts
1004                        )
1005                );
1006                this->node = expr;
1007                return nullptr;
1008        }
1009
1010        const ast::Expr * visit( const ast::InitExpr * node ) override final {
1011                auto expr = visitBaseExpr( node,
1012                        new InitExpr(
1013                                get<Expression>().accept1(node->expr),
1014                                get<Designation>().accept1(node->designation)
1015                        )
1016                );
1017                this->node = expr;
1018                return nullptr;
1019        }
1020
1021        const ast::Expr * visit( const ast::DeletedExpr * node ) override final {
1022                auto expr = visitBaseExpr( node,
1023                        new DeletedExpr(
1024                                get<Expression>().accept1(node->expr),
1025                                inCache(node->deleteStmt) ?
1026                                        this->node :
1027                                        get<BaseSyntaxNode>().accept1(node->deleteStmt)
1028                        )
1029                );
1030                this->node = expr;
1031                return nullptr;
1032        }
1033
1034        const ast::Expr * visit( const ast::DefaultArgExpr * node ) override final {
1035                auto expr = visitBaseExpr( node,
1036                        new DefaultArgExpr(
1037                                get<Expression>().accept1(node->expr)
1038                        )
1039                );
1040                this->node = expr;
1041                return nullptr;
1042        }
1043
1044        const ast::Expr * visit( const ast::GenericExpr * node ) override final {
1045                std::list<GenericExpr::Association> associations;
1046                for (auto association : node->associations) {
1047                        associations.push_back(GenericExpr::Association(
1048                                get<Type>      ().accept1(association.type),
1049                                get<Expression>().accept1(association.expr)
1050                        ));
1051                }
1052                auto expr = visitBaseExpr( node,
1053                        new GenericExpr(
1054                                get<Expression>().accept1(node->control),
1055                                associations
1056                        )
1057                );
1058                this->node = expr;
1059                return nullptr;
1060        }
1061
1062        const ast::Type * visit( const ast::VoidType * node ) override final {
1063                this->node = new VoidType{ cv( node ) };
1064                return nullptr;
1065        }
1066
1067        const ast::Type * visit( const ast::BasicType * node ) override final {
1068                this->node = new BasicType{ cv( node ), (BasicType::Kind)(unsigned)node->kind };
1069                return nullptr;
1070        }
1071
1072        const ast::Type * visit( const ast::PointerType * node ) override final {
1073                this->node = new PointerType{
1074                        cv( node ),
1075                        get<Type>().accept1( node->base ),
1076                        get<Expression>().accept1( node->dimension ),
1077                        (bool)node->isVarLen,
1078                        (bool)node->isStatic
1079                };
1080                return nullptr;
1081        }
1082
1083        const ast::Type * visit( const ast::ArrayType * node ) override final {
1084                this->node = new ArrayType{
1085                        cv( node ),
1086                        get<Type>().accept1( node->base ),
1087                        get<Expression>().accept1( node->dimension ),
1088                        (bool)node->isVarLen,
1089                        (bool)node->isStatic
1090                };
1091                return nullptr;
1092        }
1093
1094        const ast::Type * visit( const ast::ReferenceType * node ) override final {
1095                this->node = new ReferenceType{
1096                        cv( node ),
1097                        get<Type>().accept1( node->base )
1098                };
1099                return nullptr;
1100        }
1101
1102        const ast::Type * visit( const ast::QualifiedType * node ) override final {
1103                this->node = new QualifiedType{
1104                        cv( node ),
1105                        get<Type>().accept1( node->parent ),
1106                        get<Type>().accept1( node->child )
1107                };
1108                return nullptr;
1109        }
1110
1111        const ast::Type * visit( const ast::FunctionType * node ) override final {
1112                auto ty = new FunctionType {
1113                        cv( node ),
1114                        (bool)node->isVarArgs
1115                };
1116                ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
1117                ty->parameters = get<DeclarationWithType>().acceptL( node->params );
1118                ty->forall = get<TypeDecl>().acceptL( node->forall );
1119                this->node = ty;
1120                return nullptr;
1121        }
1122
1123        void postvisit( const ast::ReferenceToType * old, ReferenceToType * ty ) {
1124                ty->forall = get<TypeDecl>().acceptL( old->forall );
1125                ty->parameters = get<Expression>().acceptL( old->params );
1126                ty->hoistType = old->hoistType;
1127        }
1128
1129        const ast::Type * visit( const ast::StructInstType * node ) override final {
1130                StructInstType * ty;
1131                if ( node->base ) {
1132                        ty = new StructInstType{
1133                                cv( node ),
1134                                get<StructDecl>().accept1( node->base ),
1135                                get<Attribute>().acceptL( node->attributes )
1136                        };
1137                } else {
1138                        ty = new StructInstType{
1139                                cv( node ),
1140                                node->name,
1141                                get<Attribute>().acceptL( node->attributes )
1142                        };
1143                }
1144                postvisit( node, ty );
1145                this->node = ty;
1146                return nullptr;
1147        }
1148
1149        const ast::Type * visit( const ast::UnionInstType * node ) override final {
1150                UnionInstType * ty;
1151                if ( node->base ) {
1152                        ty = new UnionInstType{
1153                                cv( node ),
1154                                get<UnionDecl>().accept1( node->base ),
1155                                get<Attribute>().acceptL( node->attributes )
1156                        };
1157                } else {
1158                        ty = new UnionInstType{
1159                                cv( node ),
1160                                node->name,
1161                                get<Attribute>().acceptL( node->attributes )
1162                        };
1163                }
1164                postvisit( node, ty );
1165                this->node = ty;
1166                return nullptr;
1167        }
1168
1169        const ast::Type * visit( const ast::EnumInstType * node ) override final {
1170                EnumInstType * ty;
1171                if ( node->base ) {
1172                        ty = new EnumInstType{
1173                                cv( node ),
1174                                get<EnumDecl>().accept1( node->base ),
1175                                get<Attribute>().acceptL( node->attributes )
1176                        };
1177                } else {
1178                        ty = new EnumInstType{
1179                                cv( node ),
1180                                node->name,
1181                                get<Attribute>().acceptL( node->attributes )
1182                        };
1183                }
1184                postvisit( node, ty );
1185                this->node = ty;
1186                return nullptr;
1187        }
1188
1189        const ast::Type * visit( const ast::TraitInstType * node ) override final {
1190                TraitInstType * ty;
1191                if ( node->base ) {
1192                        ty = new TraitInstType{
1193                                cv( node ),
1194                                get<TraitDecl>().accept1( node->base ),
1195                                get<Attribute>().acceptL( node->attributes )
1196                        };
1197                } else {
1198                        ty = new TraitInstType{
1199                                cv( node ),
1200                                node->name,
1201                                get<Attribute>().acceptL( node->attributes )
1202                        };
1203                }
1204                postvisit( node, ty );
1205                this->node = ty;
1206                return nullptr;
1207        }
1208
1209        const ast::Type * visit( const ast::TypeInstType * node ) override final {
1210                TypeInstType * ty;
1211                if ( node->base ) {
1212                        ty = new TypeInstType{
1213                                cv( node ),
1214                                node->name,
1215                                get<TypeDecl>().accept1( node->base ),
1216                                get<Attribute>().acceptL( node->attributes )
1217                        };
1218                } else {
1219                        ty = new TypeInstType{
1220                                cv( node ),
1221                                node->name,
1222                                node->kind == ast::TypeVar::Ftype,
1223                                get<Attribute>().acceptL( node->attributes )
1224                        };
1225                }
1226                postvisit( node, ty );
1227                this->node = ty;
1228                return nullptr;
1229        }
1230
1231        const ast::Type * visit( const ast::TupleType * node ) override final {
1232                this->node = new TupleType{
1233                        cv( node ),
1234                        get<Type>().acceptL( node->types )
1235                        // members generated by TupleType c'tor
1236                };
1237                return nullptr;
1238        }
1239
1240        const ast::Type * visit( const ast::TypeofType * node ) override final {
1241                this->node = new TypeofType{
1242                        cv( node ),
1243                        get<Expression>().accept1( node->expr ),
1244                        (bool)node->kind
1245                };
1246                return nullptr;
1247        }
1248
1249        const ast::Type * visit( const ast::VarArgsType * node ) override final {
1250                this->node = new VarArgsType{ cv( node ) };
1251                return nullptr;
1252        }
1253
1254        const ast::Type * visit( const ast::ZeroType * node ) override final {
1255                this->node = new ZeroType{ cv( node ) };
1256                return nullptr;
1257        }
1258
1259        const ast::Type * visit( const ast::OneType * node ) override final {
1260                this->node = new OneType{ cv( node ) };
1261                return nullptr;
1262        }
1263
1264        const ast::Type * visit( const ast::GlobalScopeType * ) override final {
1265                this->node = new GlobalScopeType{};
1266                return nullptr;
1267        }
1268
1269        const ast::Designation * visit( const ast::Designation * node ) override final {
1270                auto designation = new Designation( get<Expression>().acceptL( node->designators ) );
1271                designation->location = node->location;
1272                this->node = designation;
1273                return nullptr;
1274        }
1275
1276        const ast::Init * visit( const ast::SingleInit * node ) override final {
1277                auto init = new SingleInit(
1278                        get<Expression>().accept1( node->value ),
1279                        ast::MaybeConstruct == node->maybeConstructed
1280                );
1281                init->location = node->location;
1282                this->node = init;
1283                return nullptr;
1284        }
1285
1286        const ast::Init * visit( const ast::ListInit * node ) override final {
1287                auto init = new ListInit(
1288                        get<Initializer>().acceptL( node->initializers ),
1289                        get<Designation>().acceptL( node->designations ),
1290                        ast::MaybeConstruct == node->maybeConstructed
1291                );
1292                init->location = node->location;
1293                this->node = init;
1294                return nullptr;
1295        }
1296
1297        const ast::Init * visit( const ast::ConstructorInit * node ) override final {
1298                auto init = new ConstructorInit(
1299                        get<Statement>().accept1( node->ctor ),
1300                        get<Statement>().accept1( node->dtor ),
1301                        get<Initializer>().accept1( node->init )
1302                );
1303                init->location = node->location;
1304                this->node = init;
1305                return nullptr;
1306        }
1307
1308        const ast::Attribute * visit( const ast::Attribute * node ) override final {
1309                auto attr = new Attribute(
1310                        node->name,
1311                        get<Expression>().acceptL(node->params)
1312                );
1313                this->node = attr;
1314                return nullptr;
1315        }
1316
1317        const ast::TypeSubstitution * visit( const ast::TypeSubstitution * node ) override final {
1318                // Handled by convertTypeSubstitution helper instead.
1319                // TypeSubstitution is not a node in the old model, so the conversion result wouldn't fit in this->node.
1320                assert( 0 );
1321                (void)node;
1322                return nullptr;
1323        }
1324};
1325
1326std::list< Declaration * > convert( const std::list< ast::ptr< ast::Decl > > && translationUnit ) {
1327        ConverterNewToOld c;
1328        std::list< Declaration * > decls;
1329        for(auto d : translationUnit) {
1330                decls.emplace_back( c.decl( d ) );
1331        }
1332        return decls;
1333}
1334
1335//================================================================================================
1336
1337class ConverterOldToNew : public Visitor {
1338public:
1339        ast::Decl * decl() {
1340                return strict_dynamic_cast< ast::Decl * >( node );
1341        }
1342private:
1343        /// conversion output
1344        ast::Node * node;
1345        /// cache of nodes that might be referenced by readonly<> for de-duplication
1346        std::unordered_map< BaseSyntaxNode *, ast::Node * > cache;
1347
1348        // Local Utilities:
1349
1350        template<typename NewT, typename OldT>
1351        NewT * getAccept1( OldT old ) {
1352                if ( ! old ) return nullptr;
1353                old->accept(*this);
1354                ast::Node * ret = node;
1355                node = nullptr;
1356                return strict_dynamic_cast< NewT * >( ret );
1357        }
1358
1359#       define GET_ACCEPT_1(child, type) \
1360                getAccept1< ast::type, decltype( old->child ) >( old->child )
1361
1362        template<typename NewT, typename OldC>
1363        std::vector< ast::ptr<NewT> > getAcceptV( OldC& old ) {
1364                std::vector< ast::ptr<NewT> > ret;
1365                ret.reserve( old.size() );
1366                for ( auto a : old ) {
1367                        a->accept( *this );
1368                        ret.emplace_back( strict_dynamic_cast< NewT * >(node) );
1369                        node = nullptr;
1370                }
1371                return ret;
1372        }
1373
1374#       define GET_ACCEPT_V(child, type) \
1375                getAcceptV< ast::type, decltype( old->child ) >( old->child )
1376
1377        ast::Label make_label(Label* old) {
1378                return ast::Label(
1379                        old->labelled->location,
1380                        old->name,
1381                        GET_ACCEPT_V(attributes, Attribute)
1382                );
1383        }
1384
1385        template<template <class...> class C>
1386        C<ast::Label> make_labels(C<Label> olds) {
1387                C<ast::Label> ret;
1388                for (auto oldn : olds) {
1389                        ret.push_back( make_label( &oldn ) );
1390                }
1391                return ret;
1392        }
1393
1394#       define GET_LABELS_V(labels) \
1395                to<std::vector>::from( make_labels( std::move( labels ) ) )
1396
1397        static ast::CV::Qualifiers cv( Type * ty ) { return { ty->get_qualifiers().val }; }
1398
1399        /// returns true and sets `node` if in cache
1400        bool inCache( BaseSyntaxNode * old ) {
1401                auto it = cache.find( old );
1402                if ( it == cache.end() ) return false;
1403                node = it->second;
1404                return true;
1405        }
1406
1407        // Now all the visit functions:
1408
1409        virtual void visit( ObjectDecl * old ) override final {
1410                if ( inCache( old ) ) return;
1411                auto decl = new ast::ObjectDecl(
1412                        old->location,
1413                        old->name,
1414                        GET_ACCEPT_1(type, Type),
1415                        GET_ACCEPT_1(init, Init),
1416                        { old->get_storageClasses().val },
1417                        { old->linkage.val },
1418                        GET_ACCEPT_1(bitfieldWidth, Expr),
1419                        GET_ACCEPT_V(attributes, Attribute),
1420                        { old->get_funcSpec().val }
1421                );
1422                cache.emplace( old, decl );
1423                decl->scopeLevel = old->scopeLevel;
1424                decl->mangleName = old->mangleName;
1425                decl->isDeleted  = old->isDeleted;
1426                decl->uniqueId   = old->uniqueId;
1427                decl->extension  = old->extension;
1428
1429                this->node = decl;
1430        }
1431
1432        virtual void visit( FunctionDecl * old ) override final {
1433                if ( inCache( old ) ) return;
1434                auto decl = new ast::FunctionDecl{
1435                        old->location,
1436                        old->name,
1437                        GET_ACCEPT_1(type, FunctionType),
1438                        GET_ACCEPT_1(statements, CompoundStmt),
1439                        { old->storageClasses.val },
1440                        { old->linkage.val },
1441                        GET_ACCEPT_V(attributes, Attribute),
1442                        { old->get_funcSpec().val }
1443                };
1444                cache.emplace( old, decl );
1445                decl->scopeLevel = old->scopeLevel;
1446                decl->mangleName = old->mangleName;
1447                decl->isDeleted  = old->isDeleted;
1448                decl->uniqueId   = old->uniqueId;
1449                decl->extension  = old->extension;
1450
1451                this->node = decl;
1452
1453                if ( Validate::dereferenceOperator == old ) {
1454                        dereferenceOperator = decl;
1455                }
1456        }
1457
1458        virtual void visit( StructDecl * old ) override final {
1459                if ( inCache( old ) ) return;
1460                auto decl = new ast::StructDecl(
1461                        old->location,
1462                        old->name,
1463                        old->kind,
1464                        GET_ACCEPT_V(attributes, Attribute),
1465                        { old->linkage.val }
1466                );
1467                cache.emplace( old, decl );
1468                decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
1469                decl->body   = old->body;
1470                decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1471                decl->members    = GET_ACCEPT_V(members, Decl);
1472                decl->extension  = old->extension;
1473                decl->uniqueId   = old->uniqueId;
1474                decl->storage    = { old->storageClasses.val };
1475
1476                this->node = decl;
1477        }
1478
1479        virtual void visit( UnionDecl * old ) override final {
1480                if ( inCache( old ) ) return;
1481                auto decl = new ast::UnionDecl(
1482                        old->location,
1483                        old->name,
1484                        GET_ACCEPT_V(attributes, Attribute),
1485                        { old->linkage.val }
1486                );
1487                cache.emplace( old, decl );
1488                decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
1489                decl->body   = old->body;
1490                decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1491                decl->members    = GET_ACCEPT_V(members, Decl);
1492                decl->extension  = old->extension;
1493                decl->uniqueId   = old->uniqueId;
1494                decl->storage    = { old->storageClasses.val };
1495
1496                this->node = decl;
1497        }
1498
1499        virtual void visit( EnumDecl * old ) override final {
1500                if ( inCache( old ) ) return;
1501                auto decl = new ast::EnumDecl(
1502                        old->location,
1503                        old->name,
1504                        GET_ACCEPT_V(attributes, Attribute),
1505                        { old->linkage.val }
1506                );
1507                cache.emplace( old, decl );
1508                decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
1509                decl->body   = old->body;
1510                decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1511                decl->members    = GET_ACCEPT_V(members, Decl);
1512                decl->extension  = old->extension;
1513                decl->uniqueId   = old->uniqueId;
1514                decl->storage    = { old->storageClasses.val };
1515
1516                this->node = decl;
1517        }
1518
1519        virtual void visit( TraitDecl * old ) override final {
1520                if ( inCache( old ) ) return;
1521                auto decl = new ast::TraitDecl(
1522                        old->location,
1523                        old->name,
1524                        GET_ACCEPT_V(attributes, Attribute),
1525                        { old->linkage.val }
1526                );
1527                cache.emplace( old, decl );
1528                decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
1529                decl->body   = old->body;
1530                decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1531                decl->members    = GET_ACCEPT_V(members, Decl);
1532                decl->extension  = old->extension;
1533                decl->uniqueId   = old->uniqueId;
1534                decl->storage    = { old->storageClasses.val };
1535
1536                this->node = decl;
1537        }
1538
1539        virtual void visit( TypeDecl * old ) override final {
1540                if ( inCache( old ) ) return;
1541                auto decl = new ast::TypeDecl{
1542                        old->location,
1543                        old->name,
1544                        { old->storageClasses.val },
1545                        GET_ACCEPT_1(base, Type),
1546                        (ast::TypeVar::Kind)(unsigned)old->kind,
1547                        old->sized,
1548                        GET_ACCEPT_1(init, Type)
1549                };
1550                cache.emplace( old, decl );
1551                decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
1552                decl->params     = GET_ACCEPT_V(parameters, TypeDecl);
1553                decl->extension  = old->extension;
1554                decl->uniqueId   = old->uniqueId;
1555
1556                this->node = decl;
1557        }
1558
1559        virtual void visit( TypedefDecl * old ) override final {
1560                auto decl = new ast::TypedefDecl(
1561                        old->location,
1562                        old->name,
1563                        { old->storageClasses.val },
1564                        GET_ACCEPT_1(base, Type),
1565                        { old->linkage.val }
1566                );
1567                decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
1568                decl->params     = GET_ACCEPT_V(parameters, TypeDecl);
1569                decl->extension  = old->extension;
1570                decl->uniqueId   = old->uniqueId;
1571                decl->storage    = { old->storageClasses.val };
1572
1573                this->node = decl;
1574        }
1575
1576        virtual void visit( AsmDecl * old ) override final {
1577                auto decl = new ast::AsmDecl{
1578                        old->location,
1579                        GET_ACCEPT_1(stmt, AsmStmt)
1580                };
1581                decl->extension  = old->extension;
1582                decl->uniqueId   = old->uniqueId;
1583                decl->storage    = { old->storageClasses.val };
1584
1585                this->node = decl;
1586        }
1587
1588        virtual void visit( StaticAssertDecl * old ) override final {
1589                auto decl = new ast::StaticAssertDecl{
1590                        old->location,
1591                        GET_ACCEPT_1(condition, Expr),
1592                        GET_ACCEPT_1(message, ConstantExpr)
1593                };
1594                decl->extension  = old->extension;
1595                decl->uniqueId   = old->uniqueId;
1596                decl->storage    = { old->storageClasses.val };
1597
1598                this->node = decl;
1599        }
1600
1601        virtual void visit( CompoundStmt * old ) override final {
1602                if ( inCache( old ) ) return;
1603                auto stmt = new ast::CompoundStmt(
1604                        old->location,
1605                        to<std::list>::from( GET_ACCEPT_V(kids, Stmt) ),
1606                        GET_LABELS_V(old->labels)
1607                );
1608
1609                this->node = stmt;
1610                cache.emplace( old, this->node );
1611        }
1612
1613        virtual void visit( ExprStmt * old ) override final {
1614                if ( inCache( old ) ) return;
1615                this->node = new ast::ExprStmt(
1616                        old->location,
1617                        GET_ACCEPT_1(expr, Expr),
1618                        GET_LABELS_V(old->labels)
1619                );
1620                cache.emplace( old, this->node );
1621        }
1622
1623        virtual void visit( AsmStmt * old ) override final {
1624                if ( inCache( old ) ) return;
1625                this->node = new ast::AsmStmt(
1626                        old->location,
1627                        old->voltile,
1628                        GET_ACCEPT_1(instruction, Expr),
1629                        GET_ACCEPT_V(output, Expr),
1630                        GET_ACCEPT_V(input, Expr),
1631                        GET_ACCEPT_V(clobber, ConstantExpr),
1632                        GET_LABELS_V(old->gotolabels),
1633                        GET_LABELS_V(old->labels)
1634                );
1635                cache.emplace( old, this->node );
1636        }
1637
1638        virtual void visit( DirectiveStmt * old ) override final {
1639                if ( inCache( old ) ) return;
1640                this->node = new ast::DirectiveStmt(
1641                        old->location,
1642                        old->directive,
1643                        GET_LABELS_V(old->labels)
1644                );
1645                cache.emplace( old, this->node );
1646        }
1647
1648        virtual void visit( IfStmt * old ) override final {
1649                if ( inCache( old ) ) return;
1650                this->node = new ast::IfStmt(
1651                        old->location,
1652                        GET_ACCEPT_1(condition, Expr),
1653                        GET_ACCEPT_1(thenPart, Stmt),
1654                        GET_ACCEPT_1(elsePart, Stmt),
1655                        GET_ACCEPT_V(initialization, Stmt),
1656                        GET_LABELS_V(old->labels)
1657                );
1658                cache.emplace( old, this->node );
1659        }
1660
1661        virtual void visit( SwitchStmt * old ) override final {
1662                if ( inCache( old ) ) return;
1663                this->node = new ast::SwitchStmt(
1664                        old->location,
1665                        GET_ACCEPT_1(condition, Expr),
1666                        GET_ACCEPT_V(statements, Stmt),
1667                        GET_LABELS_V(old->labels)
1668                );
1669                cache.emplace( old, this->node );
1670        }
1671
1672        virtual void visit( CaseStmt * old ) override final {
1673                if ( inCache( old ) ) return;
1674                this->node = new ast::CaseStmt(
1675                        old->location,
1676                        GET_ACCEPT_1(condition, Expr),
1677                        GET_ACCEPT_V(stmts, Stmt),
1678                        GET_LABELS_V(old->labels)
1679                );
1680                cache.emplace( old, this->node );
1681        }
1682
1683        virtual void visit( WhileStmt * old ) override final {
1684                if ( inCache( old ) ) return;
1685                this->node = new ast::WhileStmt(
1686                        old->location,
1687                        GET_ACCEPT_1(condition, Expr),
1688                        GET_ACCEPT_1(body, Stmt),
1689                        GET_ACCEPT_V(initialization, Stmt),
1690                        old->isDoWhile,
1691                        GET_LABELS_V(old->labels)
1692                );
1693                cache.emplace( old, this->node );
1694        }
1695
1696        virtual void visit( ForStmt * old ) override final {
1697                if ( inCache( old ) ) return;
1698                this->node = new ast::ForStmt(
1699                        old->location,
1700                        GET_ACCEPT_V(initialization, Stmt),
1701                        GET_ACCEPT_1(condition, Expr),
1702                        GET_ACCEPT_1(increment, Expr),
1703                        GET_ACCEPT_1(body, Stmt),
1704                        GET_LABELS_V(old->labels)
1705                );
1706                cache.emplace( old, this->node );
1707        }
1708
1709        virtual void visit( BranchStmt * old ) override final {
1710                if ( inCache( old ) ) return;
1711                if (old->computedTarget) {
1712                        this->node = new ast::BranchStmt(
1713                                old->location,
1714                                GET_ACCEPT_1(computedTarget, Expr),
1715                                GET_LABELS_V(old->labels)
1716                        );
1717                } else {
1718                        ast::BranchStmt::Kind kind;
1719                        switch (old->type) {
1720                        #define CASE(n) \
1721                        case BranchStmt::n: \
1722                                kind = ast::BranchStmt::n; \
1723                                break
1724                        CASE(Goto);
1725                        CASE(Break);
1726                        CASE(Continue);
1727                        CASE(FallThrough);
1728                        CASE(FallThroughDefault);
1729                        #undef CASE
1730                        default:
1731                                assertf(false, "Invalid BranchStmt::Type %d\n", old->type);
1732                        }
1733
1734                        Label label = old->originalTarget;
1735                        auto stmt = new ast::BranchStmt(
1736                                old->location,
1737                                kind,
1738                                make_label(&label),
1739                                GET_LABELS_V(old->labels)
1740                        );
1741                        stmt->target = make_label(&old->target);
1742                        this->node = stmt;
1743                }
1744                cache.emplace( old, this->node );
1745        }
1746
1747        virtual void visit( ReturnStmt * old ) override final {
1748                if ( inCache( old ) ) return;
1749                this->node = new ast::ReturnStmt(
1750                        old->location,
1751                        GET_ACCEPT_1(expr, Expr),
1752                        GET_LABELS_V(old->labels)
1753                );
1754                cache.emplace( old, this->node );
1755        }
1756
1757        virtual void visit( ThrowStmt * old ) override final {
1758                if ( inCache( old ) ) return;
1759                ast::ExceptionKind kind;
1760                switch (old->kind) {
1761                case ThrowStmt::Terminate:
1762                        kind = ast::ExceptionKind::Terminate;
1763                        break;
1764                case ThrowStmt::Resume:
1765                        kind = ast::ExceptionKind::Resume;
1766                        break;
1767                default:
1768                        assertf(false, "Invalid ThrowStmt::Kind %d\n", old->kind);
1769                }
1770
1771                this->node = new ast::ThrowStmt(
1772                        old->location,
1773                        kind,
1774                        GET_ACCEPT_1(expr, Expr),
1775                        GET_ACCEPT_1(target, Expr),
1776                        GET_LABELS_V(old->labels)
1777                );
1778                cache.emplace( old, this->node );
1779        }
1780
1781        virtual void visit( TryStmt * old ) override final {
1782                if ( inCache( old ) ) return;
1783                this->node = new ast::TryStmt(
1784                        old->location,
1785                        GET_ACCEPT_1(block, CompoundStmt),
1786                        GET_ACCEPT_V(handlers, CatchStmt),
1787                        GET_ACCEPT_1(finallyBlock, FinallyStmt),
1788                        GET_LABELS_V(old->labels)
1789                );
1790                cache.emplace( old, this->node );
1791        }
1792
1793        virtual void visit( CatchStmt * old ) override final {
1794                if ( inCache( old ) ) return;
1795                ast::ExceptionKind kind;
1796                switch (old->kind) {
1797                case CatchStmt::Terminate:
1798                        kind = ast::ExceptionKind::Terminate;
1799                        break;
1800                case CatchStmt::Resume:
1801                        kind = ast::ExceptionKind::Resume;
1802                        break;
1803                default:
1804                        assertf(false, "Invalid CatchStmt::Kind %d\n", old->kind);
1805                }
1806
1807                this->node = new ast::CatchStmt(
1808                        old->location,
1809                        kind,
1810                        GET_ACCEPT_1(decl, Decl),
1811                        GET_ACCEPT_1(cond, Expr),
1812                        GET_ACCEPT_1(body, Stmt),
1813                        GET_LABELS_V(old->labels)
1814                );
1815                cache.emplace( old, this->node );
1816        }
1817
1818        virtual void visit( FinallyStmt * old ) override final {
1819                if ( inCache( old ) ) return;
1820                this->node = new ast::FinallyStmt(
1821                        old->location,
1822                        GET_ACCEPT_1(block, CompoundStmt),
1823                        GET_LABELS_V(old->labels)
1824                );
1825                cache.emplace( old, this->node );
1826        }
1827
1828        virtual void visit( WaitForStmt * old ) override final {
1829                if ( inCache( old ) ) return;
1830                ast::WaitForStmt * stmt = new ast::WaitForStmt(
1831                        old->location,
1832                        GET_LABELS_V(old->labels)
1833                );
1834
1835                stmt->clauses.reserve( old->clauses.size() );
1836                for (size_t i = 0 ; i < old->clauses.size() ; ++i) {
1837                        stmt->clauses.push_back({
1838                                ast::WaitForStmt::Target{
1839                                        GET_ACCEPT_1(clauses[i].target.function, Expr),
1840                                        GET_ACCEPT_V(clauses[i].target.arguments, Expr)
1841                                },
1842                                GET_ACCEPT_1(clauses[i].statement, Stmt),
1843                                GET_ACCEPT_1(clauses[i].condition, Expr)
1844                        });
1845                }
1846                stmt->timeout = {
1847                        GET_ACCEPT_1(timeout.time, Expr),
1848                        GET_ACCEPT_1(timeout.statement, Stmt),
1849                        GET_ACCEPT_1(timeout.condition, Expr),
1850                };
1851                stmt->orElse = {
1852                        GET_ACCEPT_1(timeout.statement, Stmt),
1853                        GET_ACCEPT_1(timeout.condition, Expr),
1854                };
1855
1856                this->node = stmt;
1857                cache.emplace( old, this->node );
1858        }
1859
1860        virtual void visit( WithStmt * old ) override final {
1861                if ( inCache( old ) ) return;
1862                this->node = new ast::WithStmt(
1863                        old->location,
1864                        GET_ACCEPT_V(exprs, Expr),
1865                        GET_ACCEPT_1(stmt, Stmt),
1866                        GET_LABELS_V(old->labels)
1867                );
1868                cache.emplace( old, this->node );
1869        }
1870
1871        virtual void visit( NullStmt * old ) override final {
1872                if ( inCache( old ) ) return;
1873                this->node = new ast::NullStmt(
1874                        old->location,
1875                        GET_LABELS_V(old->labels)
1876                );
1877                cache.emplace( old, this->node );
1878        }
1879
1880        virtual void visit( DeclStmt * old ) override final {
1881                if ( inCache( old ) ) return;
1882                this->node = new ast::DeclStmt(
1883                        old->location,
1884                        GET_ACCEPT_1(decl, Decl),
1885                        GET_LABELS_V(old->labels)
1886                );
1887                cache.emplace( old, this->node );
1888        }
1889
1890        virtual void visit( ImplicitCtorDtorStmt * old ) override final {
1891                if ( inCache( old ) ) return;
1892                auto stmt = new ast::ImplicitCtorDtorStmt(
1893                        old->location,
1894                        nullptr,
1895                        GET_LABELS_V(old->labels)
1896                );
1897                cache.emplace( old, stmt );
1898                stmt->callStmt = GET_ACCEPT_1(callStmt, Stmt);
1899                this->node = stmt;
1900        }
1901
1902        ast::TypeSubstitution * convertTypeSubstitution(const TypeSubstitution * old) {
1903
1904                if (!old) return nullptr;
1905
1906                ast::TypeSubstitution *rslt = new ast::TypeSubstitution();
1907
1908                for (decltype(old->begin()) old_i = old->begin(); old_i != old->end(); old_i++) {
1909                        rslt->add( old_i->first,
1910                                   getAccept1<ast::Type>(old_i->second) );
1911                }
1912
1913                for (decltype(old->beginVar()) old_i = old->beginVar(); old_i != old->endVar(); old_i++) {
1914                        rslt->addVar( old_i->first,
1915                                      getAccept1<ast::Expr>(old_i->second) );
1916                }
1917
1918                return rslt;
1919        }
1920
1921        void convertInferUnion(ast::Expr::InferUnion               &newInferred,
1922                                                   const std::map<UniqueId,ParamEntry> &oldInferParams,
1923                                                   const std::vector<UniqueId>         &oldResnSlots) {
1924
1925                assert( oldInferParams.empty() || oldResnSlots.empty() );
1926                assert( newInferred.mode == ast::Expr::InferUnion::Empty );
1927
1928                if ( !oldInferParams.empty() ) {
1929                        ast::InferredParams &tgt = newInferred.inferParams();
1930                        for (auto old : oldInferParams) {
1931                                tgt[old.first] = ast::ParamEntry(
1932                                        old.second.decl,
1933                                        getAccept1<ast::Type>(old.second.actualType),
1934                                        getAccept1<ast::Type>(old.second.formalType),
1935                                        getAccept1<ast::Expr>(old.second.expr)
1936                                );
1937                        }
1938                } else if ( !oldResnSlots.empty() ) {
1939                        ast::ResnSlots &tgt = newInferred.resnSlots();
1940                        for (auto old : oldResnSlots) {
1941                                tgt.push_back(old);
1942                        }
1943                }
1944        }
1945
1946        ast::Expr * visitBaseExpr_SkipResultType(Expression * old, ast::Expr * nw) {
1947
1948                nw->env    = convertTypeSubstitution(old->env);
1949
1950                nw->extension = old->extension;
1951                convertInferUnion(nw->inferred, old->inferParams, old->resnSlots);
1952
1953                return nw;
1954        }
1955
1956        ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
1957
1958                nw->result = GET_ACCEPT_1(result, Type);
1959                return visitBaseExpr_SkipResultType(old, nw);;
1960        }
1961
1962        virtual void visit( ApplicationExpr * old ) override final {
1963                this->node = visitBaseExpr( old,
1964                        new ast::ApplicationExpr(
1965                                old->location,
1966                                GET_ACCEPT_1(function, Expr),
1967                                GET_ACCEPT_V(args, Expr)
1968                        )
1969                );
1970        }
1971
1972        virtual void visit( UntypedExpr * old ) override final {
1973                this->node = visitBaseExpr( old,
1974                        new ast::UntypedExpr(
1975                                old->location,
1976                                GET_ACCEPT_1(function, Expr),
1977                                GET_ACCEPT_V(args, Expr)
1978                        )
1979                );
1980        }
1981
1982        virtual void visit( NameExpr * old ) override final {
1983                this->node = visitBaseExpr( old,
1984                        new ast::NameExpr(
1985                                old->location,
1986                                old->get_name()
1987                        )
1988                );
1989        }
1990
1991        virtual void visit( CastExpr * old ) override final {
1992                this->node = visitBaseExpr( old,
1993                        new ast::CastExpr(
1994                                old->location,
1995                                GET_ACCEPT_1(arg, Expr),
1996                                old->isGenerated ? ast::GeneratedCast : ast::ExplicitCast
1997                        )
1998                );
1999        }
2000
2001        virtual void visit( KeywordCastExpr * old) override final {
2002                ast::KeywordCastExpr::Target castTarget = ast::KeywordCastExpr::NUMBER_OF_TARGETS;
2003                switch (old->target) {
2004                        case KeywordCastExpr::Coroutine:
2005                                castTarget = ast::KeywordCastExpr::Coroutine;
2006                                break;
2007                        case KeywordCastExpr::Thread:
2008                                castTarget = ast::KeywordCastExpr::Thread;
2009                                break;
2010                        case KeywordCastExpr::Monitor:
2011                                castTarget = ast::KeywordCastExpr::Monitor;
2012                                break;
2013                        default:
2014                                break;
2015                }
2016                assert ( castTarget < ast::KeywordCastExpr::NUMBER_OF_TARGETS );
2017                this->node = visitBaseExpr( old,
2018                        new ast::KeywordCastExpr(
2019                                old->location,
2020                                GET_ACCEPT_1(arg, Expr),
2021                                castTarget
2022                        )
2023                );
2024        }
2025
2026        virtual void visit( VirtualCastExpr * old ) override final {
2027                this->node = visitBaseExpr_SkipResultType( old,
2028                        new ast::VirtualCastExpr(
2029                                old->location,
2030                                GET_ACCEPT_1(arg, Expr),
2031                                GET_ACCEPT_1(result, Type)
2032                        )
2033                );
2034        }
2035
2036        virtual void visit( AddressExpr * old ) override final {
2037                this->node = visitBaseExpr( old,
2038                        new ast::AddressExpr(
2039                                old->location,
2040                                GET_ACCEPT_1(arg, Expr)
2041                        )
2042                );
2043        }
2044
2045        virtual void visit( LabelAddressExpr * old ) override final {
2046                this->node = visitBaseExpr( old,
2047                        new ast::LabelAddressExpr(
2048                                old->location,
2049                                make_label(&old->arg)
2050                        )
2051                );
2052        }
2053
2054        virtual void visit( UntypedMemberExpr * old ) override final {
2055                this->node = visitBaseExpr( old,
2056                        new ast::UntypedMemberExpr(
2057                                old->location,
2058                                GET_ACCEPT_1(member, Expr),
2059                                GET_ACCEPT_1(aggregate, Expr)
2060                        )
2061                );
2062        }
2063
2064        virtual void visit( MemberExpr * old ) override final {
2065                this->node = visitBaseExpr( old,
2066                        new ast::MemberExpr(
2067                                old->location,
2068                                inCache(old->member) ?
2069                                        dynamic_cast<ast::DeclWithType *>(this->node) :
2070                                        GET_ACCEPT_1(member, DeclWithType),
2071                                GET_ACCEPT_1(aggregate, Expr)
2072                        )
2073                );
2074        }
2075
2076        virtual void visit( VariableExpr * old ) override final {
2077                this->node = visitBaseExpr( old,
2078                        new ast::VariableExpr(
2079                                old->location,
2080                                inCache(old->var) ?
2081                                        dynamic_cast<ast::DeclWithType *>(this->node) :
2082                                        GET_ACCEPT_1(var, DeclWithType)
2083                        )
2084                );
2085        }
2086
2087        bool isIntlikeConstantType(const Type *t) {
2088                if ( const BasicType * basicType = dynamic_cast< const BasicType * >( t ) ) {
2089                        if ( basicType->isInteger() ) {
2090                                return true;
2091                        }
2092                } else if ( dynamic_cast< const OneType * >( t ) ) {
2093                        return true;
2094                } else if ( dynamic_cast< const ZeroType * >( t ) ) {
2095                        return true;
2096                } else if ( dynamic_cast< const PointerType * >( t ) ) {
2097                        // null pointer constants, with zero int-values
2098                        return true;
2099                }
2100                return false;
2101        }
2102
2103        int isFloatlikeConstantType(const Type *t) {
2104                if ( const BasicType * bty = dynamic_cast< const BasicType * >( t ) ) {
2105                        if ( ! bty->isInteger() ) {
2106                                return true;
2107                        }
2108                }
2109                return false;
2110        }
2111
2112        int isStringlikeConstantType(const Type *t) {
2113                if ( const ArrayType * aty = dynamic_cast< const ArrayType * >( t ) ) {
2114                        if ( const BasicType * bty = dynamic_cast< const BasicType * >( aty->base ) ) {
2115                           if ( bty->kind == BasicType::Kind::Char ) {
2116                                   return true;
2117                           }
2118                        }
2119                }
2120                return false;
2121        }
2122
2123        virtual void visit( ConstantExpr * old ) override final {
2124                ast::ConstantExpr *rslt = nullptr;
2125                if (isIntlikeConstantType(old->result)) {
2126                        rslt = new ast::ConstantExpr(
2127                                old->location,
2128                                GET_ACCEPT_1(result, Type),
2129                                old->constant.get_value(),
2130                                (unsigned long long) old->intValue()
2131                        );
2132                } else if (isFloatlikeConstantType(old->result)) {
2133                        rslt = new ast::ConstantExpr(
2134                                old->location,
2135                                GET_ACCEPT_1(result, Type),
2136                                old->constant.get_value(),
2137                                (double) old->constant.get_dval()
2138                        );
2139                } else if (isStringlikeConstantType(old->result)) {
2140                        rslt = ast::ConstantExpr::from_string(
2141                                old->location,
2142                                old->constant.get_value()
2143                        );
2144                }
2145                assert(rslt);
2146                this->node = visitBaseExpr( old, rslt );
2147        }
2148
2149        virtual void visit( SizeofExpr * old ) override final {
2150                assert (old->expr || old->type);
2151                assert (! (old->expr && old->type));
2152                ast::SizeofExpr *rslt;
2153                if (old->expr) {
2154                        assert(!old->isType);
2155                        rslt = new ast::SizeofExpr(
2156                                old->location,
2157                                GET_ACCEPT_1(expr, Expr)
2158                        );
2159                }
2160                if (old->type) {
2161                        assert(old->isType);
2162                        rslt = new ast::SizeofExpr(
2163                                old->location,
2164                                GET_ACCEPT_1(type, Type)
2165                        );
2166                }
2167                this->node = visitBaseExpr( old, rslt );
2168        }
2169
2170        virtual void visit( AlignofExpr * old ) override final {
2171                assert (old->expr || old->type);
2172                assert (! (old->expr && old->type));
2173                ast::AlignofExpr *rslt;
2174                if (old->expr) {
2175                        assert(!old->isType);
2176                        rslt = new ast::AlignofExpr(
2177                                old->location,
2178                                GET_ACCEPT_1(expr, Expr)
2179                        );
2180                }
2181                if (old->type) {
2182                        assert(old->isType);
2183                        rslt = new ast::AlignofExpr(
2184                                old->location,
2185                                GET_ACCEPT_1(type, Type)
2186                        );
2187                }
2188                this->node = visitBaseExpr( old, rslt );
2189        }
2190
2191        virtual void visit( UntypedOffsetofExpr * old ) override final {
2192                this->node = visitBaseExpr( old,
2193                        new ast::UntypedOffsetofExpr(
2194                                old->location,
2195                                GET_ACCEPT_1(type, Type),
2196                                old->member
2197                        )
2198                );
2199        }
2200
2201        virtual void visit( OffsetofExpr * old ) override final {
2202                this->node = visitBaseExpr( old,
2203                        new ast::OffsetofExpr(
2204                                old->location,
2205                                GET_ACCEPT_1(type, Type),
2206                                inCache(old->member) ?
2207                                        dynamic_cast<ast::DeclWithType *>(this->node) :
2208                                        GET_ACCEPT_1(member, DeclWithType)
2209                        )
2210                );
2211        }
2212
2213        virtual void visit( OffsetPackExpr * old ) override final {
2214                this->node = visitBaseExpr( old,
2215                        new ast::OffsetPackExpr(
2216                                old->location,
2217                                GET_ACCEPT_1(type, StructInstType)
2218                        )
2219                );
2220        }
2221
2222        virtual void visit( LogicalExpr * old ) override final {
2223                this->node = visitBaseExpr( old,
2224                        new ast::LogicalExpr(
2225                                old->location,
2226                                GET_ACCEPT_1(arg1, Expr),
2227                                GET_ACCEPT_1(arg2, Expr),
2228                                old->get_isAnd() ?
2229                                        ast::LogicalFlag::AndExpr :
2230                                        ast::LogicalFlag::OrExpr
2231                        )
2232                );
2233        }
2234
2235        virtual void visit( ConditionalExpr * old ) override final {
2236                this->node = visitBaseExpr( old,
2237                        new ast::ConditionalExpr(
2238                                old->location,
2239                                GET_ACCEPT_1(arg1, Expr),
2240                                GET_ACCEPT_1(arg2, Expr),
2241                                GET_ACCEPT_1(arg3, Expr)
2242                        )
2243                );
2244        }
2245
2246        virtual void visit( CommaExpr * old ) override final {
2247                this->node = visitBaseExpr( old,
2248                        new ast::CommaExpr(
2249                                old->location,
2250                                GET_ACCEPT_1(arg1, Expr),
2251                                GET_ACCEPT_1(arg2, Expr)
2252                        )
2253                );
2254        }
2255
2256        virtual void visit( TypeExpr * old ) override final {
2257                this->node = visitBaseExpr( old,
2258                        new ast::TypeExpr(
2259                                old->location,
2260                                GET_ACCEPT_1(type, Type)
2261                        )
2262                );
2263        }
2264
2265        virtual void visit( AsmExpr * old ) override final {
2266                this->node = visitBaseExpr( old,
2267                        new ast::AsmExpr(
2268                                old->location,
2269                                GET_ACCEPT_1(inout, Expr),
2270                                GET_ACCEPT_1(constraint, Expr),
2271                                GET_ACCEPT_1(operand, Expr)
2272                        )
2273                );
2274        }
2275
2276        virtual void visit( ImplicitCopyCtorExpr * old ) override final {
2277                auto rslt = new ast::ImplicitCopyCtorExpr(
2278                        old->location,
2279                        GET_ACCEPT_1(callExpr, ApplicationExpr)
2280                );
2281
2282                this->node = visitBaseExpr( old, rslt );
2283        }
2284
2285        virtual void visit( ConstructorExpr * old ) override final {
2286                this->node = visitBaseExpr( old,
2287                        new ast::ConstructorExpr(
2288                                old->location,
2289                                GET_ACCEPT_1(callExpr, Expr)
2290                        )
2291                );
2292        }
2293
2294        virtual void visit( CompoundLiteralExpr * old ) override final {
2295                this->node = visitBaseExpr_SkipResultType( old,
2296                        new ast::CompoundLiteralExpr(
2297                                old->location,
2298                                GET_ACCEPT_1(result, Type),
2299                                GET_ACCEPT_1(initializer, Init)
2300                        )
2301                );
2302        }
2303
2304        virtual void visit( RangeExpr * old ) override final {
2305                this->node = visitBaseExpr( old,
2306                        new ast::RangeExpr(
2307                                old->location,
2308                                GET_ACCEPT_1(low, Expr),
2309                                GET_ACCEPT_1(high, Expr)
2310                        )
2311                );
2312        }
2313
2314        virtual void visit( UntypedTupleExpr * old ) override final {
2315                this->node = visitBaseExpr( old,
2316                        new ast::UntypedTupleExpr(
2317                                old->location,
2318                                GET_ACCEPT_V(exprs, Expr)
2319                        )
2320                );
2321        }
2322
2323        virtual void visit( TupleExpr * old ) override final {
2324                this->node = visitBaseExpr( old,
2325                        new ast::TupleExpr(
2326                                old->location,
2327                                GET_ACCEPT_V(exprs, Expr)
2328                        )
2329                );
2330        }
2331
2332        virtual void visit( TupleIndexExpr * old ) override final {
2333                this->node = visitBaseExpr( old,
2334                        new ast::TupleIndexExpr(
2335                                old->location,
2336                                GET_ACCEPT_1(tuple, Expr),
2337                                old->index
2338                        )
2339                );
2340        }
2341
2342        virtual void visit( TupleAssignExpr * old ) override final {
2343                this->node = visitBaseExpr_SkipResultType( old,
2344                        new ast::TupleAssignExpr(
2345                                old->location,
2346                                GET_ACCEPT_1(result, Type),
2347                                GET_ACCEPT_1(stmtExpr, StmtExpr)
2348                        )
2349                );
2350        }
2351
2352        virtual void visit( StmtExpr * old ) override final {
2353                auto rslt = new ast::StmtExpr(
2354                        old->location,
2355                        GET_ACCEPT_1(statements, CompoundStmt)
2356                );
2357                rslt->returnDecls = GET_ACCEPT_V(returnDecls, ObjectDecl);
2358                rslt->dtors       = GET_ACCEPT_V(dtors      , Expr);
2359
2360                this->node = visitBaseExpr_SkipResultType( old, rslt );
2361        }
2362
2363        virtual void visit( UniqueExpr * old ) override final {
2364                auto rslt = new ast::UniqueExpr(
2365                        old->location,
2366                        GET_ACCEPT_1(expr, Expr)
2367                );
2368                rslt->object = GET_ACCEPT_1(object, ObjectDecl);
2369                rslt->var    = GET_ACCEPT_1(var   , VariableExpr);
2370
2371                this->node = visitBaseExpr( old, rslt );
2372        }
2373
2374        virtual void visit( UntypedInitExpr * old ) override final {
2375                std::vector<ast::InitAlternative> initAlts;
2376                for (auto ia : old->initAlts) {
2377                        initAlts.push_back(ast::InitAlternative(
2378                                getAccept1< ast::Type, Type * >( ia.type ),
2379                                getAccept1< ast::Designation, Designation * >( ia.designation )
2380                        ));
2381                }
2382                this->node = visitBaseExpr( old,
2383                        new ast::UntypedInitExpr(
2384                                old->location,
2385                                GET_ACCEPT_1(expr, Expr),
2386                                std::move(initAlts)
2387                        )
2388                );
2389        }
2390
2391        virtual void visit( InitExpr * old ) override final {
2392                this->node = visitBaseExpr( old,
2393                        new ast::InitExpr(
2394                                old->location,
2395                                GET_ACCEPT_1(expr, Expr),
2396                                GET_ACCEPT_1(designation, Designation)
2397                        )
2398                );
2399        }
2400
2401        virtual void visit( DeletedExpr * old ) override final {
2402                this->node = visitBaseExpr( old,
2403                        new ast::DeletedExpr(
2404                                old->location,
2405                                GET_ACCEPT_1(expr, Expr),
2406                                inCache(old->deleteStmt) ?
2407                                        this->node :
2408                                        GET_ACCEPT_1(deleteStmt, Node)
2409                        )
2410                );
2411        }
2412
2413        virtual void visit( DefaultArgExpr * old ) override final {
2414                this->node = visitBaseExpr( old,
2415                        new ast::DefaultArgExpr(
2416                                old->location,
2417                                GET_ACCEPT_1(expr, Expr)
2418                        )
2419                );
2420        }
2421
2422        virtual void visit( GenericExpr * old ) override final {
2423                std::vector<ast::GenericExpr::Association> associations;
2424                for (auto association : old->associations) {
2425                        associations.push_back(ast::GenericExpr::Association(
2426                                getAccept1< ast::Type, Type * >( association.type ),
2427                                getAccept1< ast::Expr, Expression * >( association.expr )
2428                        ));
2429                }
2430                this->node = visitBaseExpr( old,
2431                        new ast::GenericExpr(
2432                                old->location,
2433                                GET_ACCEPT_1(control, Expr),
2434                                std::move(associations)
2435                        )
2436                );
2437        }
2438
2439        virtual void visit( VoidType * old ) override final {
2440                this->node = new ast::VoidType{ cv( old ) };
2441        }
2442
2443        virtual void visit( BasicType * old ) override final {
2444                this->node = new ast::BasicType{ (ast::BasicType::Kind)(unsigned)old->kind, cv( old ) };
2445        }
2446
2447        virtual void visit( PointerType * old ) override final {
2448                this->node = new ast::PointerType{
2449                        GET_ACCEPT_1( base, Type ),
2450                        GET_ACCEPT_1( dimension, Expr ),
2451                        (ast::LengthFlag)old->isVarLen,
2452                        (ast::DimensionFlag)old->isStatic,
2453                        cv( old )
2454                };
2455        }
2456
2457        virtual void visit( ArrayType * old ) override final {
2458                this->node = new ast::ArrayType{
2459                        GET_ACCEPT_1( base, Type ),
2460                        GET_ACCEPT_1( dimension, Expr ),
2461                        (ast::LengthFlag)old->isVarLen,
2462                        (ast::DimensionFlag)old->isStatic,
2463                        cv( old )
2464                };
2465        }
2466
2467        virtual void visit( ReferenceType * old ) override final {
2468                this->node = new ast::ReferenceType{
2469                        GET_ACCEPT_1( base, Type ),
2470                        cv( old )
2471                };
2472        }
2473
2474        virtual void visit( QualifiedType * old ) override final {
2475                this->node = new ast::QualifiedType{
2476                        GET_ACCEPT_1( parent, Type ),
2477                        GET_ACCEPT_1( child, Type ),
2478                        cv( old )
2479                };
2480        }
2481
2482        virtual void visit( FunctionType * old ) override final {
2483                auto ty = new ast::FunctionType {
2484                        (ast::ArgumentFlag)old->isVarArgs,
2485                        cv( old )
2486                };
2487                ty->returns = GET_ACCEPT_V( returnVals, DeclWithType );
2488                ty->params = GET_ACCEPT_V( parameters, DeclWithType );
2489                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
2490                this->node = ty;
2491        }
2492
2493        void postvisit( ReferenceToType * old, ast::ReferenceToType * ty ) {
2494                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
2495                ty->params = GET_ACCEPT_V( parameters, Expr );
2496                ty->hoistType = old->hoistType;
2497        }
2498
2499        virtual void visit( StructInstType * old ) override final {
2500                ast::StructInstType * ty;
2501                if ( old->baseStruct ) {
2502                        ty = new ast::StructInstType{
2503                                GET_ACCEPT_1( baseStruct, StructDecl ),
2504                                cv( old ),
2505                                GET_ACCEPT_V( attributes, Attribute )
2506                        };
2507                } else {
2508                        ty = new ast::StructInstType{
2509                                old->name,
2510                                cv( old ),
2511                                GET_ACCEPT_V( attributes, Attribute )
2512                        };
2513                }
2514                postvisit( old, ty );
2515                this->node = ty;
2516        }
2517
2518        virtual void visit( UnionInstType * old ) override final {
2519                ast::UnionInstType * ty;
2520                if ( old->baseUnion ) {
2521                        ty = new ast::UnionInstType{
2522                                GET_ACCEPT_1( baseUnion, UnionDecl ),
2523                                cv( old ),
2524                                GET_ACCEPT_V( attributes, Attribute )
2525                        };
2526                } else {
2527                        ty = new ast::UnionInstType{
2528                                old->name,
2529                                cv( old ),
2530                                GET_ACCEPT_V( attributes, Attribute )
2531                        };
2532                }
2533                postvisit( old, ty );
2534                this->node = ty;
2535        }
2536
2537        virtual void visit( EnumInstType * old ) override final {
2538                ast::EnumInstType * ty;
2539                if ( old->baseEnum ) {
2540                        ty = new ast::EnumInstType{
2541                                GET_ACCEPT_1( baseEnum, EnumDecl ),
2542                                cv( old ),
2543                                GET_ACCEPT_V( attributes, Attribute )
2544                        };
2545                } else {
2546                        ty = new ast::EnumInstType{
2547                                old->name,
2548                                cv( old ),
2549                                GET_ACCEPT_V( attributes, Attribute )
2550                        };
2551                }
2552                postvisit( old, ty );
2553                this->node = ty;
2554        }
2555
2556        virtual void visit( TraitInstType * old ) override final {
2557                ast::TraitInstType * ty;
2558                if ( old->baseTrait ) {
2559                        ty = new ast::TraitInstType{
2560                                GET_ACCEPT_1( baseTrait, TraitDecl ),
2561                                cv( old ),
2562                                GET_ACCEPT_V( attributes, Attribute )
2563                        };
2564                } else {
2565                        ty = new ast::TraitInstType{
2566                                old->name,
2567                                cv( old ),
2568                                GET_ACCEPT_V( attributes, Attribute )
2569                        };
2570                }
2571                postvisit( old, ty );
2572                this->node = ty;
2573        }
2574
2575        virtual void visit( TypeInstType * old ) override final {
2576                ast::TypeInstType * ty;
2577                if ( old->baseType ) {
2578                        ty = new ast::TypeInstType{
2579                                old->name,
2580                                GET_ACCEPT_1( baseType, TypeDecl ),
2581                                cv( old ),
2582                                GET_ACCEPT_V( attributes, Attribute )
2583                        };
2584                } else {
2585                        ty = new ast::TypeInstType{
2586                                old->name,
2587                                old->isFtype ? ast::TypeVar::Ftype : ast::TypeVar::Dtype,
2588                                cv( old ),
2589                                GET_ACCEPT_V( attributes, Attribute )
2590                        };
2591                }
2592                postvisit( old, ty );
2593                this->node = ty;
2594        }
2595
2596        virtual void visit( TupleType * old ) override final {
2597                this->node = new ast::TupleType{
2598                        GET_ACCEPT_V( types, Type ),
2599                        // members generated by TupleType c'tor
2600                        cv( old )
2601                };
2602        }
2603
2604        virtual void visit( TypeofType * old ) override final {
2605                this->node = new ast::TypeofType{
2606                        GET_ACCEPT_1( expr, Expr ),
2607                        (ast::TypeofType::Kind)old->is_basetypeof,
2608                        cv( old )
2609                };
2610        }
2611
2612        virtual void visit( AttrType * ) override final {
2613                assertf( false, "AttrType deprecated in new AST." );
2614        }
2615
2616        virtual void visit( VarArgsType * old ) override final {
2617                this->node = new ast::VarArgsType{ cv( old ) };
2618        }
2619
2620        virtual void visit( ZeroType * old ) override final {
2621                this->node = new ast::ZeroType{ cv( old ) };
2622        }
2623
2624        virtual void visit( OneType * old ) override final {
2625                this->node = new ast::OneType{ cv( old ) };
2626        }
2627
2628        virtual void visit( GlobalScopeType * ) override final {
2629                this->node = new ast::GlobalScopeType{};
2630        }
2631
2632        virtual void visit( Designation * old ) override final {
2633                this->node = new ast::Designation(
2634                        old->location,
2635                        GET_ACCEPT_V(designators, Expr)
2636                );
2637        }
2638
2639        virtual void visit( SingleInit * old ) override final {
2640                this->node = new ast::SingleInit(
2641                        old->location,
2642                        GET_ACCEPT_1(value, Expr),
2643                        (old->get_maybeConstructed()) ? ast::MaybeConstruct : ast::DoConstruct
2644                );
2645        }
2646
2647        virtual void visit( ListInit * old ) override final {
2648                this->node = new ast::ListInit(
2649                        old->location,
2650                        GET_ACCEPT_V(initializers, Init),
2651                        GET_ACCEPT_V(designations, Designation),
2652                        (old->get_maybeConstructed()) ? ast::MaybeConstruct : ast::DoConstruct
2653                );
2654        }
2655
2656        virtual void visit( ConstructorInit * old ) override final {
2657                this->node = new ast::ConstructorInit(
2658                        old->location,
2659                        GET_ACCEPT_1(ctor, Stmt),
2660                        GET_ACCEPT_1(dtor, Stmt),
2661                        GET_ACCEPT_1(init, Init)
2662                );
2663        }
2664
2665        virtual void visit( Constant * ) override final {
2666                // Handled in visit( ConstantEpxr * ).
2667                // In the new tree, Constant fields are inlined into containing ConstantExpression.
2668                assert( 0 );
2669        }
2670
2671        virtual void visit( Attribute * old ) override final {
2672                this->node = new ast::Attribute(
2673                        old->name,
2674                        GET_ACCEPT_V( parameters, Expr )
2675                );
2676        }
2677
2678        virtual void visit( AttrExpr * ) override final {
2679                assertf( false, "AttrExpr deprecated in new AST." );
2680        }
2681};
2682
2683#undef GET_LABELS_V
2684#undef GET_ACCEPT_V
2685#undef GET_ACCEPT_1
2686
2687std::list< ast::ptr< ast::Decl > > convert( const std::list< Declaration * > && translationUnit ) {
2688        ConverterOldToNew c;
2689        std::list< ast::ptr< ast::Decl > > decls;
2690        for(auto d : translationUnit) {
2691                d->accept( c );
2692                decls.emplace_back( c.decl() );
2693        }
2694        deleteAll(translationUnit);
2695        return decls;
2696}
Note: See TracBrowser for help on using the repository browser.