source: src/AST/Convert.cpp @ 8abee13

arm-ehcleanup-dtorsjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-expr
Last change on this file since 8abee13 was 8abee13, checked in by Michael Brooks <mlbrooks@…>, 3 years ago

early bug fixes from running conversion old-new-old, just before resolver

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