source: src/AST/Convert.cpp @ 20a5977

arm-ehcleanup-dtorsjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-expr
Last change on this file since 20a5977 was 20a5977, checked in by Aaron Moss <a3moss@…>, 3 years ago

Added kind to ConstantExpr? and some Expr prints

  • Property mode set to 100644
File size: 69.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        const ast::Expr * visit( const ast::ConstantExpr * node ) override final {
703                ConstantExpr *rslt = nullptr;
704                switch ( node->kind ) {
705                case ast::ConstantExpr::Integer:
706                        rslt = new ConstantExpr{Constant{
707                                get<Type>().accept1( node->result ),
708                                node->rep,
709                                (unsigned long long) node->intValue()
710                        }};
711                        break;
712                case ast::ConstantExpr::FloatingPoint:
713                        rslt = new ConstantExpr{Constant{
714                                get<Type>().accept1(node->result),
715                                node->rep,
716                                (double) node->floatValue()
717                        }};
718                        break;
719                case ast::ConstantExpr::String:
720                        rslt = new ConstantExpr{Constant::from_string( node->rep )};
721                        break;
722                }
723                assert(rslt);
724                auto expr = visitBaseExpr( node, rslt );
725                this->node = expr;
726                return nullptr;
727        }
728
729        const ast::Expr * visit( const ast::SizeofExpr * node ) override final {
730                assert (node->expr || node->type);
731                assert (! (node->expr && node->type));
732                SizeofExpr *rslt;
733                if (node->expr) {
734                        rslt = new SizeofExpr(
735                                get<Expression>().accept1(node->expr)
736                        );
737                        assert (!rslt->isType);
738                }
739                if (node->type) {
740                        rslt = new SizeofExpr(
741                                get<Type>().accept1(node->type)
742                        );
743                        assert (rslt->isType);
744                }
745                auto expr = visitBaseExpr( node, rslt );
746                this->node = expr;
747                return nullptr;
748        }
749
750        const ast::Expr * visit( const ast::AlignofExpr * node ) override final {
751                assert (node->expr || node->type);
752                assert (! (node->expr && node->type));
753                AlignofExpr *rslt;
754                if (node->expr) {
755                        rslt = new AlignofExpr(
756                                get<Expression>().accept1(node->expr)
757                        );
758                        assert (!rslt->isType);
759                }
760                if (node->type) {
761                        rslt = new AlignofExpr(
762                                get<Type>().accept1(node->type)
763                        );
764                        assert (rslt->isType);
765                }
766                auto expr = visitBaseExpr( node, rslt );
767                this->node = expr;
768                return nullptr;
769        }
770
771        const ast::Expr * visit( const ast::UntypedOffsetofExpr * node ) override final {
772                auto expr = visitBaseExpr( node,
773                        new UntypedOffsetofExpr(
774                                get<Type>().accept1(node->type),
775                                node->member
776                        )
777                );
778                this->node = expr;
779                return nullptr;
780        }
781
782        const ast::Expr * visit( const ast::OffsetofExpr * node ) override final {
783                auto expr = visitBaseExpr( node,
784                        new OffsetofExpr(
785                                get<Type>().accept1(node->type),
786                                inCache(node->member) ?
787                                        dynamic_cast<DeclarationWithType *>(this->node) :
788                                        get<DeclarationWithType>().accept1(node->member)
789                        )
790                );
791                this->node = expr;
792                return nullptr;
793        }
794
795        const ast::Expr * visit( const ast::OffsetPackExpr * node ) override final {
796                auto expr = visitBaseExpr( node,
797                        new OffsetPackExpr(
798                                get<StructInstType>().accept1(node->type)
799                        )
800                );
801                this->node = expr;
802                return nullptr;
803        }
804
805        const ast::Expr * visit( const ast::LogicalExpr * node ) override final {
806                assert (node->isAnd == ast::LogicalFlag::AndExpr ||
807                                node->isAnd == ast::LogicalFlag::OrExpr );
808                auto expr = visitBaseExpr( node,
809                        new LogicalExpr(
810                                get<Expression>().accept1(node->arg1),
811                                get<Expression>().accept1(node->arg2),
812                                (node->isAnd == ast::LogicalFlag::AndExpr)
813                        )
814                );
815                this->node = expr;
816                return nullptr;
817        }
818
819        const ast::Expr * visit( const ast::ConditionalExpr * node ) override final {
820                auto expr = visitBaseExpr( node,
821                        new ConditionalExpr(
822                                get<Expression>().accept1(node->arg1),
823                                get<Expression>().accept1(node->arg2),
824                                get<Expression>().accept1(node->arg3)
825                        )
826                );
827                this->node = expr;
828                return nullptr;
829        }
830
831        const ast::Expr * visit( const ast::CommaExpr * node ) override final {
832                auto expr = visitBaseExpr( node,
833                        new CommaExpr(
834                                get<Expression>().accept1(node->arg1),
835                                get<Expression>().accept1(node->arg2)
836                        )
837                );
838                this->node = expr;
839                return nullptr;
840        }
841
842        const ast::Expr * visit( const ast::TypeExpr * node ) override final {
843                auto expr = visitBaseExpr( node,
844                        new TypeExpr(
845                                get<Type>().accept1(node->type)
846                        )
847                );
848                this->node = expr;
849                return nullptr;
850        }
851
852        const ast::Expr * visit( const ast::AsmExpr * node ) override final {
853                auto expr = visitBaseExpr( node,
854                        new AsmExpr(
855                                get<Expression>().accept1(node->inout),
856                                get<Expression>().accept1(node->constraint),
857                                get<Expression>().accept1(node->operand)
858                        )
859                );
860                this->node = expr;
861                return nullptr;
862        }
863
864        const ast::Expr * visit( const ast::ImplicitCopyCtorExpr * node ) override final {
865                auto rslt = new ImplicitCopyCtorExpr(
866                        get<ApplicationExpr>().accept1(node->callExpr)
867                );
868
869                rslt->tempDecls = get<ObjectDecl>().acceptL(node->tempDecls);
870                rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
871                rslt->dtors = get<Expression>().acceptL(node->dtors);
872
873                auto expr = visitBaseExpr( node, rslt );
874                this->node = expr;
875                return nullptr;
876        }
877
878        const ast::Expr * visit( const ast::ConstructorExpr * node ) override final {
879                auto expr = visitBaseExpr( node,
880                        new ConstructorExpr(
881                                get<Expression>().accept1(node->callExpr)
882                        )
883                );
884                this->node = expr;
885                return nullptr;
886        }
887
888        const ast::Expr * visit( const ast::CompoundLiteralExpr * node ) override final {
889                auto expr = visitBaseExpr_skipResultType( node,
890                        new CompoundLiteralExpr(
891                                get<Type>().accept1(node->result),
892                                get<Initializer>().accept1(node->init)
893                        )
894                );
895                this->node = expr;
896                return nullptr;
897        }
898
899        const ast::Expr * visit( const ast::RangeExpr * node ) override final {
900                auto expr = visitBaseExpr( node,
901                        new RangeExpr(
902                                get<Expression>().accept1(node->low),
903                                get<Expression>().accept1(node->high)
904                        )
905                );
906                this->node = expr;
907                return nullptr;
908        }
909
910        const ast::Expr * visit( const ast::UntypedTupleExpr * node ) override final {
911                auto expr = visitBaseExpr( node,
912                        new UntypedTupleExpr(
913                                get<Expression>().acceptL(node->exprs)
914                        )
915                );
916                this->node = expr;
917                return nullptr;
918        }
919
920        const ast::Expr * visit( const ast::TupleExpr * node ) override final {
921                auto expr = visitBaseExpr( node,
922                        new UntypedTupleExpr(
923                                get<Expression>().acceptL(node->exprs)
924                        )
925                );
926                this->node = expr;
927                return nullptr;
928        }
929
930        const ast::Expr * visit( const ast::TupleIndexExpr * node ) override final {
931                auto expr = visitBaseExpr( node,
932                        new TupleIndexExpr(
933                                get<Expression>().accept1(node->tuple),
934                                node->index
935                        )
936                );
937                this->node = expr;
938                return nullptr;
939        }
940
941        const ast::Expr * visit( const ast::TupleAssignExpr * node ) override final {
942                auto expr = visitBaseExpr( node,
943                        new TupleAssignExpr(
944                                get<StmtExpr>().accept1(node->stmtExpr)
945                        )
946                );
947                this->node = expr;
948                return nullptr;
949        }
950
951        const ast::Expr * visit( const ast::StmtExpr * node ) override final {
952                auto rslt = new StmtExpr(
953                        get<CompoundStmt>().accept1(node->stmts)
954                );
955
956                rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
957                rslt->dtors       = get<Expression>().acceptL(node->dtors);
958
959                auto expr = visitBaseExpr( node, rslt );
960                this->node = expr;
961                return nullptr;
962        }
963
964        const ast::Expr * visit( const ast::UniqueExpr * node ) override final {
965                auto rslt = new UniqueExpr(
966                        get<Expression>().accept1(node->expr)
967                );
968
969                rslt->object = get<ObjectDecl>  ().accept1(node->object);
970                rslt->var    = get<VariableExpr>().accept1(node->var);
971
972                auto expr = visitBaseExpr( node, rslt );
973                this->node = expr;
974                return nullptr;
975        }
976
977        const ast::Expr * visit( const ast::UntypedInitExpr * node ) override final {
978                std::list<InitAlternative> initAlts;
979                for (auto ia : node->initAlts) {
980                        initAlts.push_back(InitAlternative(
981                                get<Type>       ().accept1(ia.type),
982                                get<Designation>().accept1(ia.designation)
983                        ));
984                }
985                auto expr = visitBaseExpr( node,
986                        new UntypedInitExpr(
987                                get<Expression>().accept1(node->expr),
988                                initAlts
989                        )
990                );
991                this->node = expr;
992                return nullptr;
993        }
994
995        const ast::Expr * visit( const ast::InitExpr * node ) override final {
996                auto expr = visitBaseExpr( node,
997                        new InitExpr(
998                                get<Expression>().accept1(node->expr),
999                                get<Designation>().accept1(node->designation)
1000                        )
1001                );
1002                this->node = expr;
1003                return nullptr;
1004        }
1005
1006        const ast::Expr * visit( const ast::DeletedExpr * node ) override final {
1007                auto expr = visitBaseExpr( node,
1008                        new DeletedExpr(
1009                                get<Expression>().accept1(node->expr),
1010                                inCache(node->deleteStmt) ?
1011                                        this->node :
1012                                        get<BaseSyntaxNode>().accept1(node->deleteStmt)
1013                        )
1014                );
1015                this->node = expr;
1016                return nullptr;
1017        }
1018
1019        const ast::Expr * visit( const ast::DefaultArgExpr * node ) override final {
1020                auto expr = visitBaseExpr( node,
1021                        new DefaultArgExpr(
1022                                get<Expression>().accept1(node->expr)
1023                        )
1024                );
1025                this->node = expr;
1026                return nullptr;
1027        }
1028
1029        const ast::Expr * visit( const ast::GenericExpr * node ) override final {
1030                std::list<GenericExpr::Association> associations;
1031                for (auto association : node->associations) {
1032                        associations.push_back(GenericExpr::Association(
1033                                get<Type>      ().accept1(association.type),
1034                                get<Expression>().accept1(association.expr)
1035                        ));
1036                }
1037                auto expr = visitBaseExpr( node,
1038                        new GenericExpr(
1039                                get<Expression>().accept1(node->control),
1040                                associations
1041                        )
1042                );
1043                this->node = expr;
1044                return nullptr;
1045        }
1046
1047        const ast::Type * visit( const ast::VoidType * node ) override final {
1048                this->node = new VoidType{ cv( node ) };
1049                return nullptr;
1050        }
1051
1052        const ast::Type * visit( const ast::BasicType * node ) override final {
1053                this->node = new BasicType{ cv( node ), (BasicType::Kind)(unsigned)node->kind };
1054                return nullptr;
1055        }
1056
1057        const ast::Type * visit( const ast::PointerType * node ) override final {
1058                this->node = new PointerType{
1059                        cv( node ),
1060                        get<Type>().accept1( node->base ),
1061                        get<Expression>().accept1( node->dimension ),
1062                        (bool)node->isVarLen,
1063                        (bool)node->isStatic
1064                };
1065                return nullptr;
1066        }
1067
1068        const ast::Type * visit( const ast::ArrayType * node ) override final {
1069                this->node = new ArrayType{
1070                        cv( node ),
1071                        get<Type>().accept1( node->base ),
1072                        get<Expression>().accept1( node->dimension ),
1073                        (bool)node->isVarLen,
1074                        (bool)node->isStatic
1075                };
1076                return nullptr;
1077        }
1078
1079        const ast::Type * visit( const ast::ReferenceType * node ) override final {
1080                this->node = new ReferenceType{
1081                        cv( node ),
1082                        get<Type>().accept1( node->base )
1083                };
1084                return nullptr;
1085        }
1086
1087        const ast::Type * visit( const ast::QualifiedType * node ) override final {
1088                this->node = new QualifiedType{
1089                        cv( node ),
1090                        get<Type>().accept1( node->parent ),
1091                        get<Type>().accept1( node->child )
1092                };
1093                return nullptr;
1094        }
1095
1096        const ast::Type * visit( const ast::FunctionType * node ) override final {
1097                auto ty = new FunctionType {
1098                        cv( node ),
1099                        (bool)node->isVarArgs
1100                };
1101                ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
1102                ty->parameters = get<DeclarationWithType>().acceptL( node->params );
1103                ty->forall = get<TypeDecl>().acceptL( node->forall );
1104                this->node = ty;
1105                return nullptr;
1106        }
1107
1108        void postvisit( const ast::ReferenceToType * old, ReferenceToType * ty ) {
1109                ty->forall = get<TypeDecl>().acceptL( old->forall );
1110                ty->parameters = get<Expression>().acceptL( old->params );
1111                ty->hoistType = old->hoistType;
1112        }
1113
1114        const ast::Type * visit( const ast::StructInstType * node ) override final {
1115                StructInstType * ty;
1116                if ( node->base ) {
1117                        ty = new StructInstType{
1118                                cv( node ),
1119                                get<StructDecl>().accept1( node->base ),
1120                                get<Attribute>().acceptL( node->attributes )
1121                        };
1122                } else {
1123                        ty = new StructInstType{
1124                                cv( node ),
1125                                node->name,
1126                                get<Attribute>().acceptL( node->attributes )
1127                        };
1128                }
1129                postvisit( node, ty );
1130                this->node = ty;
1131                return nullptr;
1132        }
1133
1134        const ast::Type * visit( const ast::UnionInstType * node ) override final {
1135                UnionInstType * ty;
1136                if ( node->base ) {
1137                        ty = new UnionInstType{
1138                                cv( node ),
1139                                get<UnionDecl>().accept1( node->base ),
1140                                get<Attribute>().acceptL( node->attributes )
1141                        };
1142                } else {
1143                        ty = new UnionInstType{
1144                                cv( node ),
1145                                node->name,
1146                                get<Attribute>().acceptL( node->attributes )
1147                        };
1148                }
1149                postvisit( node, ty );
1150                this->node = ty;
1151                return nullptr;
1152        }
1153
1154        const ast::Type * visit( const ast::EnumInstType * node ) override final {
1155                EnumInstType * ty;
1156                if ( node->base ) {
1157                        ty = new EnumInstType{
1158                                cv( node ),
1159                                get<EnumDecl>().accept1( node->base ),
1160                                get<Attribute>().acceptL( node->attributes )
1161                        };
1162                } else {
1163                        ty = new EnumInstType{
1164                                cv( node ),
1165                                node->name,
1166                                get<Attribute>().acceptL( node->attributes )
1167                        };
1168                }
1169                postvisit( node, ty );
1170                this->node = ty;
1171                return nullptr;
1172        }
1173
1174        const ast::Type * visit( const ast::TraitInstType * node ) override final {
1175                TraitInstType * ty;
1176                if ( node->base ) {
1177                        ty = new TraitInstType{
1178                                cv( node ),
1179                                get<TraitDecl>().accept1( node->base ),
1180                                get<Attribute>().acceptL( node->attributes )
1181                        };
1182                } else {
1183                        ty = new TraitInstType{
1184                                cv( node ),
1185                                node->name,
1186                                get<Attribute>().acceptL( node->attributes )
1187                        };
1188                }
1189                postvisit( node, ty );
1190                this->node = ty;
1191                return nullptr;
1192        }
1193
1194        const ast::Type * visit( const ast::TypeInstType * node ) override final {
1195                TypeInstType * ty;
1196                if ( node->base ) {
1197                        ty = new TypeInstType{
1198                                cv( node ),
1199                                node->name,
1200                                get<TypeDecl>().accept1( node->base ),
1201                                get<Attribute>().acceptL( node->attributes )
1202                        };
1203                } else {
1204                        ty = new TypeInstType{
1205                                cv( node ),
1206                                node->name,
1207                                node->kind == ast::TypeVar::Ftype,
1208                                get<Attribute>().acceptL( node->attributes )
1209                        };
1210                }
1211                postvisit( node, ty );
1212                this->node = ty;
1213                return nullptr;
1214        }
1215
1216        const ast::Type * visit( const ast::TupleType * node ) override final {
1217                this->node = new TupleType{
1218                        cv( node ),
1219                        get<Type>().acceptL( node->types )
1220                        // members generated by TupleType c'tor
1221                };
1222                return nullptr;
1223        }
1224
1225        const ast::Type * visit( const ast::TypeofType * node ) override final {
1226                this->node = new TypeofType{
1227                        cv( node ),
1228                        get<Expression>().accept1( node->expr ),
1229                        (bool)node->kind
1230                };
1231                return nullptr;
1232        }
1233
1234        const ast::Type * visit( const ast::VarArgsType * node ) override final {
1235                this->node = new VarArgsType{ cv( node ) };
1236                return nullptr;
1237        }
1238
1239        const ast::Type * visit( const ast::ZeroType * node ) override final {
1240                this->node = new ZeroType{ cv( node ) };
1241                return nullptr;
1242        }
1243
1244        const ast::Type * visit( const ast::OneType * node ) override final {
1245                this->node = new OneType{ cv( node ) };
1246                return nullptr;
1247        }
1248
1249        const ast::Type * visit( const ast::GlobalScopeType * ) override final {
1250                this->node = new GlobalScopeType{};
1251                return nullptr;
1252        }
1253
1254        const ast::Designation * visit( const ast::Designation * node ) override final {
1255                auto designation = new Designation( get<Expression>().acceptL( node->designators ) );
1256                designation->location = node->location;
1257                this->node = designation;
1258                return nullptr;
1259        }
1260
1261        const ast::Init * visit( const ast::SingleInit * node ) override final {
1262                auto init = new SingleInit(
1263                        get<Expression>().accept1( node->value ),
1264                        ast::MaybeConstruct == node->maybeConstructed
1265                );
1266                init->location = node->location;
1267                this->node = init;
1268                return nullptr;
1269        }
1270
1271        const ast::Init * visit( const ast::ListInit * node ) override final {
1272                auto init = new ListInit(
1273                        get<Initializer>().acceptL( node->initializers ),
1274                        get<Designation>().acceptL( node->designations ),
1275                        ast::MaybeConstruct == node->maybeConstructed
1276                );
1277                init->location = node->location;
1278                this->node = init;
1279                return nullptr;
1280        }
1281
1282        const ast::Init * visit( const ast::ConstructorInit * node ) override final {
1283                auto init = new ConstructorInit(
1284                        get<Statement>().accept1( node->ctor ),
1285                        get<Statement>().accept1( node->dtor ),
1286                        get<Initializer>().accept1( node->init )
1287                );
1288                init->location = node->location;
1289                this->node = init;
1290                return nullptr;
1291        }
1292
1293        const ast::Attribute * visit( const ast::Attribute * node ) override final {
1294                auto attr = new Attribute(
1295                        node->name,
1296                        get<Expression>().acceptL(node->params)
1297                );
1298                this->node = attr;
1299                return nullptr;
1300        }
1301
1302        const ast::TypeSubstitution * visit( const ast::TypeSubstitution * node ) override final {
1303                // Handled by convertTypeSubstitution helper instead.
1304                // TypeSubstitution is not a node in the old model, so the conversion result wouldn't fit in this->node.
1305                assert( 0 );
1306                (void)node;
1307                return nullptr;
1308        }
1309};
1310
1311std::list< Declaration * > convert( const std::list< ast::ptr< ast::Decl > > && translationUnit ) {
1312        ConverterNewToOld c;
1313        std::list< Declaration * > decls;
1314        for(auto d : translationUnit) {
1315                decls.emplace_back( c.decl( d ) );
1316        }
1317        return decls;
1318}
1319
1320//================================================================================================
1321
1322class ConverterOldToNew : public Visitor {
1323public:
1324        ast::Decl * decl() {
1325                return strict_dynamic_cast< ast::Decl * >( node );
1326        }
1327private:
1328        /// conversion output
1329        ast::Node * node;
1330        /// cache of nodes that might be referenced by readonly<> for de-duplication
1331        std::unordered_map< BaseSyntaxNode *, ast::Node * > cache;
1332
1333        // Local Utilities:
1334
1335        template<typename NewT, typename OldT>
1336        NewT * getAccept1( OldT old ) {
1337                if ( ! old ) return nullptr;
1338                old->accept(*this);
1339                return strict_dynamic_cast< NewT * >( node );
1340        }
1341
1342#       define GET_ACCEPT_1(child, type) \
1343                getAccept1< ast::type, decltype( old->child ) >( old->child )
1344
1345        template<typename NewT, typename OldC>
1346        std::vector< ast::ptr<NewT> > getAcceptV( OldC& old ) {
1347                std::vector< ast::ptr<NewT> > ret;
1348                ret.reserve( old.size() );
1349                for ( auto a : old ) {
1350                        a->accept( *this );
1351                        ret.emplace_back( strict_dynamic_cast< NewT * >(node) );
1352                }
1353                return ret;
1354        }
1355
1356#       define GET_ACCEPT_V(child, type) \
1357                getAcceptV< ast::type, decltype( old->child ) >( old->child )
1358
1359        ast::Label make_label(Label* old) {
1360                return ast::Label(
1361                        old->labelled->location,
1362                        old->name,
1363                        GET_ACCEPT_V(attributes, Attribute)
1364                );
1365        }
1366
1367        template<template <class...> class C>
1368        C<ast::Label> make_labels(C<Label> olds) {
1369                C<ast::Label> ret;
1370                for (auto oldn : olds) {
1371                        ret.push_back( make_label( &oldn ) );
1372                }
1373                return ret;
1374        }
1375
1376#       define GET_LABELS_V(labels) \
1377                to<std::vector>::from( make_labels( std::move( labels ) ) )
1378
1379        static ast::CV::Qualifiers cv( Type * ty ) { return { ty->get_qualifiers().val }; }
1380
1381        /// returns true and sets `node` if in cache
1382        bool inCache( BaseSyntaxNode * old ) {
1383                auto it = cache.find( old );
1384                if ( it == cache.end() ) return false;
1385                node = it->second;
1386                return true;
1387        }
1388
1389        // Now all the visit functions:
1390
1391        virtual void visit( ObjectDecl * old ) override final {
1392                if ( inCache( old ) ) return;
1393                auto decl = new ast::ObjectDecl(
1394                        old->location,
1395                        old->name,
1396                        GET_ACCEPT_1(type, Type),
1397                        GET_ACCEPT_1(init, Init),
1398                        { old->get_storageClasses().val },
1399                        { old->linkage.val },
1400                        GET_ACCEPT_1(bitfieldWidth, Expr),
1401                        GET_ACCEPT_V(attributes, Attribute),
1402                        { old->get_funcSpec().val }
1403                );
1404                cache.emplace( old, decl );
1405                decl->scopeLevel = old->scopeLevel;
1406                decl->mangleName = old->mangleName;
1407                decl->isDeleted  = old->isDeleted;
1408                decl->uniqueId   = old->uniqueId;
1409                decl->extension  = old->extension;
1410
1411                this->node = decl;
1412        }
1413
1414        virtual void visit( FunctionDecl * old ) override final {
1415                if ( inCache( old ) ) return;
1416                auto decl = new ast::FunctionDecl{
1417                        old->location,
1418                        old->name,
1419                        GET_ACCEPT_1(type, FunctionType),
1420                        GET_ACCEPT_1(statements, CompoundStmt),
1421                        { old->storageClasses.val },
1422                        { old->linkage.val },
1423                        GET_ACCEPT_V(attributes, Attribute),
1424                        { old->get_funcSpec().val }
1425                };
1426                cache.emplace( old, decl );
1427                decl->scopeLevel = old->scopeLevel;
1428                decl->mangleName = old->mangleName;
1429                decl->isDeleted  = old->isDeleted;
1430                decl->uniqueId   = old->uniqueId;
1431                decl->extension  = old->extension;
1432
1433                this->node = decl;
1434        }
1435
1436        virtual void visit( StructDecl * old ) override final {
1437                if ( inCache( old ) ) return;
1438                auto decl = new ast::StructDecl(
1439                        old->location,
1440                        old->name,
1441                        old->kind,
1442                        GET_ACCEPT_V(attributes, Attribute),
1443                        { old->linkage.val }
1444                );
1445                cache.emplace( old, decl );
1446                decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
1447                decl->body   = old->body;
1448                decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1449                decl->members    = GET_ACCEPT_V(members, Decl);
1450                decl->extension  = old->extension;
1451                decl->uniqueId   = old->uniqueId;
1452                decl->storage    = { old->storageClasses.val };
1453
1454                this->node = decl;
1455        }
1456
1457        virtual void visit( UnionDecl * old ) override final {
1458                if ( inCache( old ) ) return;
1459                auto decl = new ast::UnionDecl(
1460                        old->location,
1461                        old->name,
1462                        GET_ACCEPT_V(attributes, Attribute),
1463                        { old->linkage.val }
1464                );
1465                cache.emplace( old, decl );
1466                decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
1467                decl->body   = old->body;
1468                decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1469                decl->members    = GET_ACCEPT_V(members, Decl);
1470                decl->extension  = old->extension;
1471                decl->uniqueId   = old->uniqueId;
1472                decl->storage    = { old->storageClasses.val };
1473
1474                this->node = decl;
1475        }
1476
1477        virtual void visit( EnumDecl * old ) override final {
1478                if ( inCache( old ) ) return;
1479                auto decl = new ast::UnionDecl(
1480                        old->location,
1481                        old->name,
1482                        GET_ACCEPT_V(attributes, Attribute),
1483                        { old->linkage.val }
1484                );
1485                cache.emplace( old, decl );
1486                decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
1487                decl->body   = old->body;
1488                decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1489                decl->members    = GET_ACCEPT_V(members, Decl);
1490                decl->extension  = old->extension;
1491                decl->uniqueId   = old->uniqueId;
1492                decl->storage    = { old->storageClasses.val };
1493
1494                this->node = decl;
1495        }
1496
1497        virtual void visit( TraitDecl * old ) override final {
1498                if ( inCache( old ) ) return;
1499                auto decl = new ast::UnionDecl(
1500                        old->location,
1501                        old->name,
1502                        GET_ACCEPT_V(attributes, Attribute),
1503                        { old->linkage.val }
1504                );
1505                cache.emplace( old, decl );
1506                decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
1507                decl->body   = old->body;
1508                decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1509                decl->members    = GET_ACCEPT_V(members, Decl);
1510                decl->extension  = old->extension;
1511                decl->uniqueId   = old->uniqueId;
1512                decl->storage    = { old->storageClasses.val };
1513
1514                this->node = decl;
1515        }
1516
1517        virtual void visit( TypeDecl * old ) override final {
1518                if ( inCache( old ) ) return;
1519                auto decl = new ast::TypeDecl{
1520                        old->location,
1521                        old->name,
1522                        { old->storageClasses.val },
1523                        GET_ACCEPT_1(base, Type),
1524                        (ast::TypeVar::Kind)(unsigned)old->kind,
1525                        old->sized,
1526                        GET_ACCEPT_1(init, Type)
1527                };
1528                cache.emplace( old, decl );
1529                decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
1530                decl->params     = GET_ACCEPT_V(parameters, TypeDecl);
1531                decl->extension  = old->extension;
1532                decl->uniqueId   = old->uniqueId;
1533
1534                this->node = decl;
1535        }
1536
1537        virtual void visit( TypedefDecl * old ) override final {
1538                auto decl = new ast::TypedefDecl(
1539                        old->location,
1540                        old->name,
1541                        { old->storageClasses.val },
1542                        GET_ACCEPT_1(base, Type),
1543                        { old->linkage.val }
1544                );
1545                decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
1546                decl->params     = GET_ACCEPT_V(parameters, TypeDecl);
1547                decl->extension  = old->extension;
1548                decl->uniqueId   = old->uniqueId;
1549                decl->storage    = { old->storageClasses.val };
1550
1551                this->node = decl;
1552        }
1553
1554        virtual void visit( AsmDecl * old ) override final {
1555                auto decl = new ast::AsmDecl{
1556                        old->location,
1557                        GET_ACCEPT_1(stmt, AsmStmt)
1558                };
1559                decl->extension  = old->extension;
1560                decl->uniqueId   = old->uniqueId;
1561                decl->storage    = { old->storageClasses.val };
1562
1563                this->node = decl;
1564        }
1565
1566        virtual void visit( StaticAssertDecl * old ) override final {
1567                auto decl = new ast::StaticAssertDecl{
1568                        old->location,
1569                        GET_ACCEPT_1(condition, Expr),
1570                        GET_ACCEPT_1(message, ConstantExpr)
1571                };
1572                decl->extension  = old->extension;
1573                decl->uniqueId   = old->uniqueId;
1574                decl->storage    = { old->storageClasses.val };
1575
1576                this->node = decl;
1577        }
1578
1579        virtual void visit( CompoundStmt * old ) override final {
1580                if ( inCache( old ) ) return;
1581                auto stmt = new ast::CompoundStmt(
1582                        old->location,
1583                        to<std::list>::from( GET_ACCEPT_V(kids, Stmt) ),
1584                        GET_LABELS_V(old->labels)
1585                );
1586
1587                this->node = stmt;
1588                cache.emplace( old, this->node );
1589        }
1590
1591        virtual void visit( ExprStmt * old ) override final {
1592                if ( inCache( old ) ) return;
1593                this->node = new ast::ExprStmt(
1594                        old->location,
1595                        GET_ACCEPT_1(expr, Expr),
1596                        GET_LABELS_V(old->labels)
1597                );
1598                cache.emplace( old, this->node );
1599        }
1600
1601        virtual void visit( AsmStmt * old ) override final {
1602                if ( inCache( old ) ) return;
1603                this->node = new ast::AsmStmt(
1604                        old->location,
1605                        old->voltile,
1606                        GET_ACCEPT_1(instruction, Expr),
1607                        GET_ACCEPT_V(output, Expr),
1608                        GET_ACCEPT_V(input, Expr),
1609                        GET_ACCEPT_V(clobber, ConstantExpr),
1610                        GET_LABELS_V(old->gotolabels),
1611                        GET_LABELS_V(old->labels)
1612                );
1613                cache.emplace( old, this->node );
1614        }
1615
1616        virtual void visit( DirectiveStmt * old ) override final {
1617                if ( inCache( old ) ) return;
1618                this->node = new ast::DirectiveStmt(
1619                        old->location,
1620                        old->directive,
1621                        GET_LABELS_V(old->labels)
1622                );
1623                cache.emplace( old, this->node );
1624        }
1625
1626        virtual void visit( IfStmt * old ) override final {
1627                if ( inCache( old ) ) return;
1628                this->node = new ast::IfStmt(
1629                        old->location,
1630                        GET_ACCEPT_1(condition, Expr),
1631                        GET_ACCEPT_1(thenPart, Stmt),
1632                        GET_ACCEPT_1(elsePart, Stmt),
1633                        GET_ACCEPT_V(initialization, Stmt),
1634                        GET_LABELS_V(old->labels)
1635                );
1636                cache.emplace( old, this->node );
1637        }
1638
1639        virtual void visit( SwitchStmt * old ) override final {
1640                if ( inCache( old ) ) return;
1641                this->node = new ast::SwitchStmt(
1642                        old->location,
1643                        GET_ACCEPT_1(condition, Expr),
1644                        GET_ACCEPT_V(statements, Stmt),
1645                        GET_LABELS_V(old->labels)
1646                );
1647                cache.emplace( old, this->node );
1648        }
1649
1650        virtual void visit( CaseStmt * old ) override final {
1651                if ( inCache( old ) ) return;
1652                this->node = new ast::CaseStmt(
1653                        old->location,
1654                        GET_ACCEPT_1(condition, Expr),
1655                        GET_ACCEPT_V(stmts, Stmt),
1656                        GET_LABELS_V(old->labels)
1657                );
1658                cache.emplace( old, this->node );
1659        }
1660
1661        virtual void visit( WhileStmt * old ) override final {
1662                if ( inCache( old ) ) return;
1663                this->node = new ast::WhileStmt(
1664                        old->location,
1665                        GET_ACCEPT_1(condition, Expr),
1666                        GET_ACCEPT_1(body, Stmt),
1667                        GET_ACCEPT_V(initialization, Stmt),
1668                        old->isDoWhile,
1669                        GET_LABELS_V(old->labels)
1670                );
1671                cache.emplace( old, this->node );
1672        }
1673
1674        virtual void visit( ForStmt * old ) override final {
1675                if ( inCache( old ) ) return;
1676                this->node = new ast::ForStmt(
1677                        old->location,
1678                        GET_ACCEPT_V(initialization, Stmt),
1679                        GET_ACCEPT_1(condition, Expr),
1680                        GET_ACCEPT_1(increment, Expr),
1681                        GET_ACCEPT_1(body, Stmt),
1682                        GET_LABELS_V(old->labels)
1683                );
1684                cache.emplace( old, this->node );
1685        }
1686
1687        virtual void visit( BranchStmt * old ) override final {
1688                if ( inCache( old ) ) return;
1689                if (old->computedTarget) {
1690                        this->node = new ast::BranchStmt(
1691                                old->location,
1692                                GET_ACCEPT_1(computedTarget, Expr),
1693                                GET_LABELS_V(old->labels)
1694                        );
1695                } else {
1696                        ast::BranchStmt::Kind kind;
1697                        switch (old->type) {
1698                        #define CASE(n) \
1699                        case BranchStmt::n: \
1700                                kind = ast::BranchStmt::n; \
1701                                break
1702                        CASE(Goto);
1703                        CASE(Break);
1704                        CASE(Continue);
1705                        CASE(FallThrough);
1706                        CASE(FallThroughDefault);
1707                        #undef CASE
1708                        default:
1709                                assertf(false, "Invalid BranchStmt::Type %d\n", old->type);
1710                        }
1711
1712                        Label label = old->originalTarget;
1713                        auto stmt = new ast::BranchStmt(
1714                                old->location,
1715                                kind,
1716                                make_label(&label),
1717                                GET_LABELS_V(old->labels)
1718                        );
1719                        stmt->target = make_label(&old->target);
1720                        this->node = stmt;
1721                }
1722                cache.emplace( old, this->node );
1723        }
1724
1725        virtual void visit( ReturnStmt * old ) override final {
1726                if ( inCache( old ) ) return;
1727                this->node = new ast::ReturnStmt(
1728                        old->location,
1729                        GET_ACCEPT_1(expr, Expr),
1730                        GET_LABELS_V(old->labels)
1731                );
1732                cache.emplace( old, this->node );
1733        }
1734
1735        virtual void visit( ThrowStmt * old ) override final {
1736                if ( inCache( old ) ) return;
1737                ast::ThrowStmt::Kind kind;
1738                switch (old->kind) {
1739                case ThrowStmt::Terminate:
1740                        kind = ast::ThrowStmt::Terminate;
1741                        break;
1742                case ThrowStmt::Resume:
1743                        kind = ast::ThrowStmt::Resume;
1744                        break;
1745                default:
1746                        assertf(false, "Invalid ThrowStmt::Kind %d\n", old->kind);
1747                }
1748
1749                this->node = new ast::ThrowStmt(
1750                        old->location,
1751                        kind,
1752                        GET_ACCEPT_1(expr, Expr),
1753                        GET_ACCEPT_1(target, Expr),
1754                        GET_LABELS_V(old->labels)
1755                );
1756                cache.emplace( old, this->node );
1757        }
1758
1759        virtual void visit( TryStmt * old ) override final {
1760                if ( inCache( old ) ) return;
1761                this->node = new ast::TryStmt(
1762                        old->location,
1763                        GET_ACCEPT_1(block, CompoundStmt),
1764                        GET_ACCEPT_V(handlers, CatchStmt),
1765                        GET_ACCEPT_1(finallyBlock, FinallyStmt),
1766                        GET_LABELS_V(old->labels)
1767                );
1768                cache.emplace( old, this->node );
1769        }
1770
1771        virtual void visit( CatchStmt * old ) override final {
1772                if ( inCache( old ) ) return;
1773                ast::CatchStmt::Kind kind;
1774                switch (old->kind) {
1775                case CatchStmt::Terminate:
1776                        kind = ast::CatchStmt::Terminate;
1777                        break;
1778                case CatchStmt::Resume:
1779                        kind = ast::CatchStmt::Resume;
1780                        break;
1781                default:
1782                        assertf(false, "Invalid CatchStmt::Kind %d\n", old->kind);
1783                }
1784
1785                this->node = new ast::CatchStmt(
1786                        old->location,
1787                        kind,
1788                        GET_ACCEPT_1(decl, Decl),
1789                        GET_ACCEPT_1(cond, Expr),
1790                        GET_ACCEPT_1(body, Stmt),
1791                        GET_LABELS_V(old->labels)
1792                );
1793                cache.emplace( old, this->node );
1794        }
1795
1796        virtual void visit( FinallyStmt * old ) override final {
1797                if ( inCache( old ) ) return;
1798                this->node = new ast::FinallyStmt(
1799                        old->location,
1800                        GET_ACCEPT_1(block, CompoundStmt),
1801                        GET_LABELS_V(old->labels)
1802                );
1803                cache.emplace( old, this->node );
1804        }
1805
1806        virtual void visit( WaitForStmt * old ) override final {
1807                if ( inCache( old ) ) return;
1808                ast::WaitForStmt * stmt = new ast::WaitForStmt(
1809                        old->location,
1810                        GET_LABELS_V(old->labels)
1811                );
1812
1813                stmt->clauses.reserve( old->clauses.size() );
1814                for (size_t i = 0 ; i < old->clauses.size() ; ++i) {
1815                        stmt->clauses.push_back({
1816                                ast::WaitForStmt::Target{
1817                                        GET_ACCEPT_1(clauses[i].target.function, Expr),
1818                                        GET_ACCEPT_V(clauses[i].target.arguments, Expr)
1819                                },
1820                                GET_ACCEPT_1(clauses[i].statement, Stmt),
1821                                GET_ACCEPT_1(clauses[i].condition, Expr)
1822                        });
1823                }
1824                stmt->timeout = {
1825                        GET_ACCEPT_1(timeout.time, Expr),
1826                        GET_ACCEPT_1(timeout.statement, Stmt),
1827                        GET_ACCEPT_1(timeout.condition, Expr),
1828                };
1829                stmt->orElse = {
1830                        GET_ACCEPT_1(timeout.statement, Stmt),
1831                        GET_ACCEPT_1(timeout.condition, Expr),
1832                };
1833
1834                this->node = stmt;
1835                cache.emplace( old, this->node );
1836        }
1837
1838        virtual void visit( WithStmt * old ) override final {
1839                if ( inCache( old ) ) return;
1840                this->node = new ast::WithStmt(
1841                        old->location,
1842                        GET_ACCEPT_V(exprs, Expr),
1843                        GET_ACCEPT_1(stmt, Stmt),
1844                        GET_LABELS_V(old->labels)
1845                );
1846                cache.emplace( old, this->node );
1847        }
1848
1849        virtual void visit( NullStmt * old ) override final {
1850                if ( inCache( old ) ) return;
1851                this->node = new ast::NullStmt(
1852                        old->location,
1853                        GET_LABELS_V(old->labels)
1854                );
1855                cache.emplace( old, this->node );
1856        }
1857
1858        virtual void visit( DeclStmt * old ) override final {
1859                if ( inCache( old ) ) return;
1860                this->node = new ast::DeclStmt(
1861                        old->location,
1862                        GET_ACCEPT_1(decl, Decl),
1863                        GET_LABELS_V(old->labels)
1864                );
1865                cache.emplace( old, this->node );
1866        }
1867
1868        virtual void visit( ImplicitCtorDtorStmt * old ) override final {
1869                if ( inCache( old ) ) return;
1870                this->node = new ast::ImplicitCtorDtorStmt(
1871                        old->location,
1872                        GET_ACCEPT_1(callStmt, Stmt),
1873                        GET_LABELS_V(old->labels)
1874                );
1875                cache.emplace( old, this->node );
1876        }
1877
1878        ast::TypeSubstitution * convertTypeSubstitution(const TypeSubstitution * old) {
1879
1880                if (!old) return nullptr;
1881
1882                ast::TypeSubstitution *rslt = new ast::TypeSubstitution();
1883
1884                for (decltype(old->begin()) old_i = old->begin(); old_i != old->end(); old_i++) {
1885                        rslt->add( old_i->first,
1886                                   getAccept1<ast::Type>(old_i->second) );
1887                }
1888
1889                for (decltype(old->beginVar()) old_i = old->beginVar(); old_i != old->endVar(); old_i++) {
1890                        rslt->addVar( old_i->first,
1891                                      getAccept1<ast::Expr>(old_i->second) );
1892                }
1893
1894                return rslt;
1895        }
1896
1897        void convertInferUnion(ast::Expr::InferUnion               &newInferred,
1898                                                   const std::map<UniqueId,ParamEntry> &oldInferParams,
1899                                                   const std::vector<UniqueId>         &oldResnSlots) {
1900
1901                assert( oldInferParams.empty() || oldResnSlots.empty() );
1902                assert( newInferred.mode == ast::Expr::InferUnion::Empty );
1903
1904                if ( !oldInferParams.empty() ) {
1905                        ast::InferredParams &tgt = newInferred.inferParams();
1906                        for (auto old : oldInferParams) {
1907                                tgt[old.first] = ast::ParamEntry(
1908                                        old.second.decl,
1909                                        getAccept1<ast::Type>(old.second.actualType),
1910                                        getAccept1<ast::Type>(old.second.formalType),
1911                                        getAccept1<ast::Expr>(old.second.expr)
1912                                );
1913                        }
1914                } else if ( !oldResnSlots.empty() ) {
1915                        ast::ResnSlots &tgt = newInferred.resnSlots();
1916                        for (auto old : oldResnSlots) {
1917                                tgt.push_back(old);
1918                        }
1919                }
1920        }
1921
1922        ast::Expr * visitBaseExpr_SkipResultType(Expression * old, ast::Expr * nw) {
1923
1924                nw->env    = convertTypeSubstitution(old->env);
1925
1926                nw->extension = old->extension;
1927                convertInferUnion(nw->inferred, old->inferParams, old->resnSlots);
1928
1929                return nw;
1930        }
1931
1932        ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
1933
1934                nw->result = GET_ACCEPT_1(result, Type);
1935                return visitBaseExpr_SkipResultType(old, nw);;
1936        }
1937
1938        virtual void visit( ApplicationExpr * old ) override final {
1939                this->node = visitBaseExpr( old,
1940                        new ast::ApplicationExpr(
1941                                old->location,
1942                                GET_ACCEPT_1(function, Expr),
1943                                GET_ACCEPT_V(args, Expr)
1944                        )
1945                );
1946        }
1947
1948        virtual void visit( UntypedExpr * old ) override final {
1949                this->node = visitBaseExpr( old,
1950                        new ast::UntypedExpr(
1951                                old->location,
1952                                GET_ACCEPT_1(function, Expr),
1953                                GET_ACCEPT_V(args, Expr)
1954                        )
1955                );
1956        }
1957
1958        virtual void visit( NameExpr * old ) override final {
1959                this->node = visitBaseExpr( old,
1960                        new ast::NameExpr(
1961                                old->location,
1962                                old->get_name()
1963                        )
1964                );
1965        }
1966
1967        virtual void visit( CastExpr * old ) override final {
1968                this->node = visitBaseExpr( old,
1969                        new ast::CastExpr(
1970                                old->location,
1971                                GET_ACCEPT_1(arg, Expr),
1972                                old->isGenerated ? ast::GeneratedCast : ast::ExplicitCast
1973                        )
1974                );
1975        }
1976
1977        virtual void visit( KeywordCastExpr * old) override final {
1978                ast::KeywordCastExpr::Target castTarget = ast::KeywordCastExpr::NUMBER_OF_TARGETS;
1979                switch (old->target) {
1980                        case KeywordCastExpr::Coroutine:
1981                                castTarget = ast::KeywordCastExpr::Coroutine;
1982                                break;
1983                        case KeywordCastExpr::Thread:
1984                                castTarget = ast::KeywordCastExpr::Thread;
1985                                break;
1986                        case KeywordCastExpr::Monitor:
1987                                castTarget = ast::KeywordCastExpr::Monitor;
1988                                break;
1989                        default:
1990                                break;
1991                }
1992                assert ( castTarget < ast::KeywordCastExpr::NUMBER_OF_TARGETS );
1993                this->node = visitBaseExpr( old,
1994                        new ast::KeywordCastExpr(
1995                                old->location,
1996                                GET_ACCEPT_1(arg, Expr),
1997                                castTarget
1998                        )
1999                );
2000        }
2001
2002        virtual void visit( VirtualCastExpr * old ) override final {
2003                this->node = visitBaseExpr_SkipResultType( old,
2004                        new ast::VirtualCastExpr(
2005                                old->location,
2006                                GET_ACCEPT_1(arg, Expr),
2007                                GET_ACCEPT_1(result, Type)
2008                        )
2009                );
2010        }
2011
2012        virtual void visit( AddressExpr * old ) override final {
2013                this->node = visitBaseExpr( old,
2014                        new ast::AddressExpr(
2015                                old->location,
2016                                GET_ACCEPT_1(arg, Expr)
2017                        )
2018                );
2019        }
2020
2021        virtual void visit( LabelAddressExpr * old ) override final {
2022                this->node = visitBaseExpr( old,
2023                        new ast::LabelAddressExpr(
2024                                old->location,
2025                                make_label(&old->arg)
2026                        )
2027                );
2028        }
2029
2030        virtual void visit( UntypedMemberExpr * old ) override final {
2031                this->node = visitBaseExpr( old,
2032                        new ast::UntypedMemberExpr(
2033                                old->location,
2034                                GET_ACCEPT_1(member, Expr),
2035                                GET_ACCEPT_1(aggregate, Expr)
2036                        )
2037                );
2038        }
2039
2040        virtual void visit( MemberExpr * old ) override final {
2041                this->node = visitBaseExpr( old,
2042                        new ast::MemberExpr(
2043                                old->location,
2044                                inCache(old->member) ?
2045                                        dynamic_cast<ast::DeclWithType *>(this->node) :
2046                                        GET_ACCEPT_1(member, DeclWithType),
2047                                GET_ACCEPT_1(aggregate, Expr)
2048                        )
2049                );
2050        }
2051
2052        virtual void visit( VariableExpr * old ) override final {
2053                this->node = visitBaseExpr( old,
2054                        new ast::VariableExpr(
2055                                old->location,
2056                                inCache(old->var) ?
2057                                        dynamic_cast<ast::DeclWithType *>(this->node) :
2058                                        GET_ACCEPT_1(var, DeclWithType)
2059                        )
2060                );
2061        }
2062
2063        bool isIntlikeConstantType(const Type *t) {
2064                if ( const BasicType * basicType = dynamic_cast< const BasicType * >( t ) ) {
2065                        if ( basicType->isInteger() ) {
2066                                return true;
2067                        }
2068                } else if ( dynamic_cast< const OneType * >( t ) ) {
2069                        return true;
2070                } else if ( dynamic_cast< const ZeroType * >( t ) ) {
2071                        return true;
2072                } else if ( dynamic_cast< const PointerType * >( t ) ) {
2073                        // null pointer constants, with zero int-values
2074                        return true;
2075                }
2076                return false;
2077        }
2078
2079        int isFloatlikeConstantType(const Type *t) {
2080                if ( const BasicType * bty = dynamic_cast< const BasicType * >( t ) ) {
2081                        if ( ! bty->isInteger() ) {
2082                                return true;
2083                        }
2084                }
2085                return false;
2086        }
2087
2088        int isStringlikeConstantType(const Type *t) {
2089                if ( const ArrayType * aty = dynamic_cast< const ArrayType * >( t ) ) {
2090                        if ( const BasicType * bty = dynamic_cast< const BasicType * >( aty->base ) ) {
2091                           if ( bty->kind == BasicType::Kind::Char ) {
2092                                   return true;
2093                           }
2094                        }
2095                }
2096                return false;
2097        }
2098
2099        virtual void visit( ConstantExpr * old ) override final {
2100                ast::ConstantExpr *rslt = nullptr;
2101                if (isIntlikeConstantType(old->result)) {
2102                        rslt = new ast::ConstantExpr(
2103                                old->location,
2104                                GET_ACCEPT_1(result, Type),
2105                                old->constant.get_value(),
2106                                (unsigned long long) old->intValue()
2107                        );
2108                } else if (isFloatlikeConstantType(old->result)) {
2109                        rslt = new ast::ConstantExpr(
2110                                old->location,
2111                                GET_ACCEPT_1(result, Type),
2112                                old->constant.get_value(),
2113                                (double) old->constant.get_dval()
2114                        );
2115                } else if (isStringlikeConstantType(old->result)) {
2116                        rslt = ast::ConstantExpr::from_string(
2117                                old->location,
2118                                old->constant.get_value()
2119                        );
2120                }
2121                assert(rslt);
2122                this->node = visitBaseExpr( old, rslt );
2123        }
2124
2125        virtual void visit( SizeofExpr * old ) override final {
2126                assert (old->expr || old->type);
2127                assert (! (old->expr && old->type));
2128                ast::SizeofExpr *rslt;
2129                if (old->expr) {
2130                        assert(!old->isType);
2131                        rslt = new ast::SizeofExpr(
2132                                old->location,
2133                                GET_ACCEPT_1(expr, Expr)
2134                        );
2135                }
2136                if (old->type) {
2137                        assert(old->isType);
2138                        rslt = new ast::SizeofExpr(
2139                                old->location,
2140                                GET_ACCEPT_1(type, Type)
2141                        );
2142                }
2143                this->node = visitBaseExpr( old, rslt );
2144        }
2145
2146        virtual void visit( AlignofExpr * old ) override final {
2147                assert (old->expr || old->type);
2148                assert (! (old->expr && old->type));
2149                ast::AlignofExpr *rslt;
2150                if (old->expr) {
2151                        assert(!old->isType);
2152                        rslt = new ast::AlignofExpr(
2153                                old->location,
2154                                GET_ACCEPT_1(expr, Expr)
2155                        );
2156                }
2157                if (old->type) {
2158                        assert(old->isType);
2159                        rslt = new ast::AlignofExpr(
2160                                old->location,
2161                                GET_ACCEPT_1(type, Type)
2162                        );
2163                }
2164                this->node = visitBaseExpr( old, rslt );
2165        }
2166
2167        virtual void visit( UntypedOffsetofExpr * old ) override final {
2168                this->node = visitBaseExpr( old,
2169                        new ast::UntypedOffsetofExpr(
2170                                old->location,
2171                                GET_ACCEPT_1(type, Type),
2172                                old->member
2173                        )
2174                );
2175        }
2176
2177        virtual void visit( OffsetofExpr * old ) override final {
2178                this->node = visitBaseExpr( old,
2179                        new ast::OffsetofExpr(
2180                                old->location,
2181                                GET_ACCEPT_1(type, Type),
2182                                inCache(old->member) ?
2183                                        dynamic_cast<ast::DeclWithType *>(this->node) :
2184                                        GET_ACCEPT_1(member, DeclWithType)
2185                        )
2186                );
2187        }
2188
2189        virtual void visit( OffsetPackExpr * old ) override final {
2190                this->node = visitBaseExpr( old,
2191                        new ast::OffsetPackExpr(
2192                                old->location,
2193                                GET_ACCEPT_1(type, StructInstType)
2194                        )
2195                );
2196        }
2197
2198        virtual void visit( LogicalExpr * old ) override final {
2199                this->node = visitBaseExpr( old,
2200                        new ast::LogicalExpr(
2201                                old->location,
2202                                GET_ACCEPT_1(arg1, Expr),
2203                                GET_ACCEPT_1(arg2, Expr),
2204                                old->get_isAnd() ?
2205                                        ast::LogicalFlag::AndExpr :
2206                                        ast::LogicalFlag::OrExpr
2207                        )
2208                );
2209        }
2210
2211        virtual void visit( ConditionalExpr * old ) override final {
2212                this->node = visitBaseExpr( old,
2213                        new ast::ConditionalExpr(
2214                                old->location,
2215                                GET_ACCEPT_1(arg1, Expr),
2216                                GET_ACCEPT_1(arg2, Expr),
2217                                GET_ACCEPT_1(arg3, Expr)
2218                        )
2219                );
2220        }
2221
2222        virtual void visit( CommaExpr * old ) override final {
2223                this->node = visitBaseExpr( old,
2224                        new ast::CommaExpr(
2225                                old->location,
2226                                GET_ACCEPT_1(arg1, Expr),
2227                                GET_ACCEPT_1(arg2, Expr)
2228                        )
2229                );
2230        }
2231
2232        virtual void visit( TypeExpr * old ) override final {
2233                this->node = visitBaseExpr( old,
2234                        new ast::TypeExpr(
2235                                old->location,
2236                                GET_ACCEPT_1(type, Type)
2237                        )
2238                );
2239        }
2240
2241        virtual void visit( AsmExpr * old ) override final {
2242                this->node = visitBaseExpr( old,
2243                        new ast::AsmExpr(
2244                                old->location,
2245                                GET_ACCEPT_1(inout, Expr),
2246                                GET_ACCEPT_1(constraint, Expr),
2247                                GET_ACCEPT_1(operand, Expr)
2248                        )
2249                );
2250        }
2251
2252        virtual void visit( ImplicitCopyCtorExpr * old ) override final {
2253                auto rslt = new ast::ImplicitCopyCtorExpr(
2254                        old->location,
2255                        GET_ACCEPT_1(callExpr, ApplicationExpr)
2256                );
2257
2258                rslt->tempDecls = GET_ACCEPT_V(tempDecls, ObjectDecl);
2259                rslt->returnDecls = GET_ACCEPT_V(returnDecls, ObjectDecl);
2260                rslt->dtors = GET_ACCEPT_V(dtors, Expr);
2261
2262                this->node = visitBaseExpr( old, rslt );
2263        }
2264
2265        virtual void visit( ConstructorExpr * old ) override final {
2266                this->node = visitBaseExpr( old,
2267                        new ast::ConstructorExpr(
2268                                old->location,
2269                                GET_ACCEPT_1(callExpr, Expr)
2270                        )
2271                );
2272        }
2273
2274        virtual void visit( CompoundLiteralExpr * old ) override final {
2275                this->node = visitBaseExpr_SkipResultType( old,
2276                        new ast::CompoundLiteralExpr(
2277                                old->location,
2278                                GET_ACCEPT_1(result, Type),
2279                                GET_ACCEPT_1(initializer, Init)
2280                        )
2281                );
2282        }
2283
2284        virtual void visit( RangeExpr * old ) override final {
2285                this->node = visitBaseExpr( old,
2286                        new ast::RangeExpr(
2287                                old->location,
2288                                GET_ACCEPT_1(low, Expr),
2289                                GET_ACCEPT_1(high, Expr)
2290                        )
2291                );
2292        }
2293
2294        virtual void visit( UntypedTupleExpr * old ) override final {
2295                this->node = visitBaseExpr( old,
2296                        new ast::UntypedTupleExpr(
2297                                old->location,
2298                                GET_ACCEPT_V(exprs, Expr)
2299                        )
2300                );
2301        }
2302
2303        virtual void visit( TupleExpr * old ) override final {
2304                this->node = visitBaseExpr( old,
2305                        new ast::TupleExpr(
2306                                old->location,
2307                                GET_ACCEPT_V(exprs, Expr)
2308                        )
2309                );
2310        }
2311
2312        virtual void visit( TupleIndexExpr * old ) override final {
2313                this->node = visitBaseExpr( old,
2314                        new ast::TupleIndexExpr(
2315                                old->location,
2316                                GET_ACCEPT_1(tuple, Expr),
2317                                old->index
2318                        )
2319                );
2320        }
2321
2322        virtual void visit( TupleAssignExpr * old ) override final {
2323                this->node = visitBaseExpr_SkipResultType( old,
2324                        new ast::TupleAssignExpr(
2325                                old->location,
2326                                GET_ACCEPT_1(result, Type),
2327                                GET_ACCEPT_1(stmtExpr, StmtExpr)
2328                        )
2329                );
2330        }
2331
2332        virtual void visit( StmtExpr * old ) override final {
2333                auto rslt = new ast::StmtExpr(
2334                        old->location,
2335                        GET_ACCEPT_1(statements, CompoundStmt)
2336                );
2337                rslt->returnDecls = GET_ACCEPT_V(returnDecls, ObjectDecl);
2338                rslt->dtors       = GET_ACCEPT_V(dtors      , Expr);
2339
2340                this->node = visitBaseExpr_SkipResultType( old, rslt );
2341        }
2342
2343        virtual void visit( UniqueExpr * old ) override final {
2344                auto rslt = new ast::UniqueExpr(
2345                        old->location,
2346                        GET_ACCEPT_1(expr, Expr)
2347                );
2348                rslt->object = GET_ACCEPT_1(object, ObjectDecl);
2349                rslt->var    = GET_ACCEPT_1(var   , VariableExpr);
2350
2351                this->node = visitBaseExpr( old, rslt );
2352        }
2353
2354        virtual void visit( UntypedInitExpr * old ) override final {
2355                std::vector<ast::InitAlternative> initAlts;
2356                for (auto ia : old->initAlts) {
2357                        initAlts.push_back(ast::InitAlternative(
2358                                getAccept1< ast::Type, Type * >( ia.type ),
2359                                getAccept1< ast::Designation, Designation * >( ia.designation )
2360                        ));
2361                }
2362                this->node = visitBaseExpr( old,
2363                        new ast::UntypedInitExpr(
2364                                old->location,
2365                                GET_ACCEPT_1(expr, Expr),
2366                                std::move(initAlts)
2367                        )
2368                );
2369        }
2370
2371        virtual void visit( InitExpr * old ) override final {
2372                this->node = visitBaseExpr( old,
2373                        new ast::InitExpr(
2374                                old->location,
2375                                GET_ACCEPT_1(expr, Expr),
2376                                GET_ACCEPT_1(designation, Designation)
2377                        )
2378                );
2379        }
2380
2381        virtual void visit( DeletedExpr * old ) override final {
2382                this->node = visitBaseExpr( old,
2383                        new ast::DeletedExpr(
2384                                old->location,
2385                                GET_ACCEPT_1(expr, Expr),
2386                                inCache(old->deleteStmt) ?
2387                                        this->node :
2388                                        GET_ACCEPT_1(deleteStmt, Node)
2389                        )
2390                );
2391        }
2392
2393        virtual void visit( DefaultArgExpr * old ) override final {
2394                this->node = visitBaseExpr( old,
2395                        new ast::DefaultArgExpr(
2396                                old->location,
2397                                GET_ACCEPT_1(expr, Expr)
2398                        )
2399                );
2400        }
2401
2402        virtual void visit( GenericExpr * old ) override final {
2403                std::vector<ast::GenericExpr::Association> associations;
2404                for (auto association : old->associations) {
2405                        associations.push_back(ast::GenericExpr::Association(
2406                                getAccept1< ast::Type, Type * >( association.type ),
2407                                getAccept1< ast::Expr, Expression * >( association.expr )
2408                        ));
2409                }
2410                this->node = visitBaseExpr( old,
2411                        new ast::GenericExpr(
2412                                old->location,
2413                                GET_ACCEPT_1(control, Expr),
2414                                std::move(associations)
2415                        )
2416                );
2417        }
2418
2419        virtual void visit( VoidType * old ) override final {
2420                this->node = new ast::VoidType{ cv( old ) };
2421        }
2422
2423        virtual void visit( BasicType * old ) override final {
2424                this->node = new ast::BasicType{ (ast::BasicType::Kind)(unsigned)old->kind, cv( old ) };
2425        }
2426
2427        virtual void visit( PointerType * old ) override final {
2428                this->node = new ast::PointerType{
2429                        GET_ACCEPT_1( base, Type ),
2430                        GET_ACCEPT_1( dimension, Expr ),
2431                        (ast::LengthFlag)old->isVarLen,
2432                        (ast::DimensionFlag)old->isStatic,
2433                        cv( old )
2434                };
2435        }
2436
2437        virtual void visit( ArrayType * old ) override final {
2438                this->node = new ast::ArrayType{
2439                        GET_ACCEPT_1( base, Type ),
2440                        GET_ACCEPT_1( dimension, Expr ),
2441                        (ast::LengthFlag)old->isVarLen,
2442                        (ast::DimensionFlag)old->isStatic,
2443                        cv( old )
2444                };
2445        }
2446
2447        virtual void visit( ReferenceType * old ) override final {
2448                this->node = new ast::ReferenceType{
2449                        GET_ACCEPT_1( base, Type ),
2450                        cv( old )
2451                };
2452        }
2453
2454        virtual void visit( QualifiedType * old ) override final {
2455                this->node = new ast::QualifiedType{
2456                        GET_ACCEPT_1( parent, Type ),
2457                        GET_ACCEPT_1( child, Type ),
2458                        cv( old )
2459                };
2460        }
2461
2462        virtual void visit( FunctionType * old ) override final {
2463                auto ty = new ast::FunctionType {
2464                        (ast::ArgumentFlag)old->isVarArgs,
2465                        cv( old )
2466                };
2467                ty->returns = GET_ACCEPT_V( returnVals, DeclWithType );
2468                ty->params = GET_ACCEPT_V( parameters, DeclWithType );
2469                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
2470                this->node = ty;
2471        }
2472
2473        void postvisit( ReferenceToType * old, ast::ReferenceToType * ty ) {
2474                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
2475                ty->params = GET_ACCEPT_V( parameters, Expr );
2476                ty->hoistType = old->hoistType;
2477        }
2478
2479        virtual void visit( StructInstType * old ) override final {
2480                ast::StructInstType * ty;
2481                if ( old->baseStruct ) {
2482                        ty = new ast::StructInstType{
2483                                GET_ACCEPT_1( baseStruct, StructDecl ),
2484                                cv( old ),
2485                                GET_ACCEPT_V( attributes, Attribute )
2486                        };
2487                } else {
2488                        ty = new ast::StructInstType{
2489                                old->name,
2490                                cv( old ),
2491                                GET_ACCEPT_V( attributes, Attribute )
2492                        };
2493                }
2494                postvisit( old, ty );
2495                this->node = ty;
2496        }
2497
2498        virtual void visit( UnionInstType * old ) override final {
2499                ast::UnionInstType * ty;
2500                if ( old->baseUnion ) {
2501                        ty = new ast::UnionInstType{
2502                                GET_ACCEPT_1( baseUnion, UnionDecl ),
2503                                cv( old ),
2504                                GET_ACCEPT_V( attributes, Attribute )
2505                        };
2506                } else {
2507                        ty = new ast::UnionInstType{
2508                                old->name,
2509                                cv( old ),
2510                                GET_ACCEPT_V( attributes, Attribute )
2511                        };
2512                }
2513                postvisit( old, ty );
2514                this->node = ty;
2515        }
2516
2517        virtual void visit( EnumInstType * old ) override final {
2518                ast::EnumInstType * ty;
2519                if ( old->baseEnum ) {
2520                        ty = new ast::EnumInstType{
2521                                GET_ACCEPT_1( baseEnum, EnumDecl ),
2522                                cv( old ),
2523                                GET_ACCEPT_V( attributes, Attribute )
2524                        };
2525                } else {
2526                        ty = new ast::EnumInstType{
2527                                old->name,
2528                                cv( old ),
2529                                GET_ACCEPT_V( attributes, Attribute )
2530                        };
2531                }
2532                postvisit( old, ty );
2533                this->node = ty;
2534        }
2535
2536        virtual void visit( TraitInstType * old ) override final {
2537                ast::TraitInstType * ty;
2538                if ( old->baseTrait ) {
2539                        ty = new ast::TraitInstType{
2540                                GET_ACCEPT_1( baseTrait, TraitDecl ),
2541                                cv( old ),
2542                                GET_ACCEPT_V( attributes, Attribute )
2543                        };
2544                } else {
2545                        ty = new ast::TraitInstType{
2546                                old->name,
2547                                cv( old ),
2548                                GET_ACCEPT_V( attributes, Attribute )
2549                        };
2550                }
2551                postvisit( old, ty );
2552                this->node = ty;
2553        }
2554
2555        virtual void visit( TypeInstType * old ) override final {
2556                ast::TypeInstType * ty;
2557                if ( old->baseType ) {
2558                        ty = new ast::TypeInstType{
2559                                old->name,
2560                                GET_ACCEPT_1( baseType, TypeDecl ),
2561                                cv( old ),
2562                                GET_ACCEPT_V( attributes, Attribute )
2563                        };
2564                } else {
2565                        ty = new ast::TypeInstType{
2566                                old->name,
2567                                old->isFtype ? ast::TypeVar::Ftype : ast::TypeVar::Dtype,
2568                                cv( old ),
2569                                GET_ACCEPT_V( attributes, Attribute )
2570                        };
2571                }
2572                postvisit( old, ty );
2573                this->node = ty;
2574        }
2575
2576        virtual void visit( TupleType * old ) override final {
2577                this->node = new ast::TupleType{
2578                        GET_ACCEPT_V( types, Type ),
2579                        // members generated by TupleType c'tor
2580                        cv( old )
2581                };
2582        }
2583
2584        virtual void visit( TypeofType * old ) override final {
2585                this->node = new ast::TypeofType{
2586                        GET_ACCEPT_1( expr, Expr ),
2587                        (ast::TypeofType::Kind)old->is_basetypeof,
2588                        cv( old )
2589                };
2590        }
2591
2592        virtual void visit( AttrType * ) override final {
2593                assertf( false, "AttrType deprecated in new AST." );
2594        }
2595
2596        virtual void visit( VarArgsType * old ) override final {
2597                this->node = new ast::VarArgsType{ cv( old ) };
2598        }
2599
2600        virtual void visit( ZeroType * old ) override final {
2601                this->node = new ast::ZeroType{ cv( old ) };
2602        }
2603
2604        virtual void visit( OneType * old ) override final {
2605                this->node = new ast::OneType{ cv( old ) };
2606        }
2607
2608        virtual void visit( GlobalScopeType * ) override final {
2609                this->node = new ast::GlobalScopeType{};
2610        }
2611
2612        virtual void visit( Designation * old ) override final {
2613                this->node = new ast::Designation(
2614                        old->location,
2615                        GET_ACCEPT_V(designators, Expr)
2616                );
2617        }
2618
2619        virtual void visit( SingleInit * old ) override final {
2620                this->node = new ast::SingleInit(
2621                        old->location,
2622                        GET_ACCEPT_1(value, Expr),
2623                        (old->get_maybeConstructed()) ? ast::MaybeConstruct : ast::DoConstruct
2624                );
2625        }
2626
2627        virtual void visit( ListInit * old ) override final {
2628                this->node = new ast::ListInit(
2629                        old->location,
2630                        GET_ACCEPT_V(initializers, Init),
2631                        GET_ACCEPT_V(designations, Designation),
2632                        (old->get_maybeConstructed()) ? ast::MaybeConstruct : ast::DoConstruct
2633                );
2634        }
2635
2636        virtual void visit( ConstructorInit * old ) override final {
2637                this->node = new ast::ConstructorInit(
2638                        old->location,
2639                        GET_ACCEPT_1(ctor, Stmt),
2640                        GET_ACCEPT_1(dtor, Stmt),
2641                        GET_ACCEPT_1(init, Init)
2642                );
2643        }
2644
2645        virtual void visit( Constant * ) override final {
2646                // Handled in visit( ConstantEpxr * ).
2647                // In the new tree, Constant fields are inlined into containing ConstantExpression.
2648                assert( 0 );
2649        }
2650
2651        virtual void visit( Attribute * old ) override final {
2652                this->node = new ast::Attribute(
2653                        old->name,
2654                        GET_ACCEPT_V( parameters, Expr )
2655                );
2656        }
2657
2658        virtual void visit( AttrExpr * ) override final {
2659                assertf( false, "AttrExpr deprecated in new AST." );
2660        }
2661};
2662
2663#undef GET_LABELS_V
2664#undef GET_ACCEPT_V
2665#undef GET_ACCEPT_1
2666
2667std::list< ast::ptr< ast::Decl > > convert( const std::list< Declaration * > && translationUnit ) {
2668        ConverterOldToNew c;
2669        std::list< ast::ptr< ast::Decl > > decls;
2670        for(auto d : translationUnit) {
2671                d->accept( c );
2672                decls.emplace_back( c.decl() );
2673        }
2674        deleteAll(translationUnit);
2675        return decls;
2676}
Note: See TracBrowser for help on using the repository browser.