source: src/AST/Convert.cpp @ 21300d7

arm-ehjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-expr
Last change on this file since 21300d7 was 21300d7, checked in by Thierry Delisle <tdelisle@…>, 2 years ago

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

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