source: src/AST/Convert.cpp @ 37cdd97

arm-ehjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-expr
Last change on this file since 37cdd97 was 37cdd97, checked in by Thierry Delisle <tdelisle@…>, 20 months ago

Added a ast node for suspend statements

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