source: src/AST/Convert.cpp @ a2a85658

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

Fixed conversion of tuple assignments to reuse the common part correctly. For example, in [x,y] = foo().[a,b], foo should be called once. Convert-convert before resolve was causing foo to be called twice, because the unique ID of a UniqueExpr? wasn't preserved on AST conversion. Symptom was failing test tuple/tupleMember (given convert-convert before resolve).

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