source: src/AST/Convert.cpp @ 60aaa51d

arm-ehenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprpthread-emulationqualifiedEnum
Last change on this file since 60aaa51d was 60aaa51d, checked in by Aaron Moss <a3moss@…>, 4 years ago

More resolver porting; mostly CurrentObject?

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