source: src/AST/Convert.cpp @ 19e567dd

arm-ehcleanup-dtorsenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprpthread-emulationqualifiedEnum
Last change on this file since 19e567dd was 19e567dd, checked in by Michael Brooks <mlbrooks@…>, 4 years ago

expression conversion: first few cases and base members, both directions

  • Property mode set to 100644
File size: 37.4 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2019 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// Convert.cpp -- Convert between the new and old syntax trees.
8//
9// Author           : Thierry Delisle
10// Created On       : Thu May 09 15::37::05 2019
11// Last Modified By : Andrew Beach
12// Last Modified On : Fri May 17 16:01:00 2019
13// Update Count     : 4
14//
15
16#include "Convert.hpp"
17
18#include "AST/Attribute.hpp"
19#include "AST/Decl.hpp"
20#include "AST/Expr.hpp"
21#include "AST/Init.hpp"
22#include "AST/Stmt.hpp"
23#include "AST/TypeSubstitution.hpp"
24
25#include "SynTree/Attribute.h"
26#include "SynTree/Declaration.h"
27#include "SynTree/TypeSubstitution.h"
28
29//================================================================================================
30// Utilities
31template<template <class...> class C>
32struct to {
33        template<typename T>
34        static auto from( T && v ) -> C< typename T::value_type > {
35                C< typename T::value_type > l;
36                std::move(std::begin(v), std::end(v), std::back_inserter(l));
37                return l;
38        }
39};
40
41//================================================================================================
42class ConverterNewToOld : public ast::Visitor {
43        BaseSyntaxNode * node = nullptr;
44
45        template<typename T>
46        struct Getter {
47                ConverterNewToOld & visitor;
48
49                template<typename U>
50                T * accept1( const ast::ptr<U> & ptr ) {
51                        ptr->accept( visitor );
52                        T * ret = strict_dynamic_cast< T * >( visitor.node );
53                        visitor.node = nullptr;
54                        return ret;
55                }
56
57                template<typename U>
58                std::list< T * > acceptL( const U & container ) {
59                        std::list< T * > ret;
60                        for (auto ptr : container ) {
61                                ret.emplace_back( accept1( ptr ) );
62                        }
63                        return ret;
64                }
65        };
66
67    template<typename T>
68    Getter<T> get() {
69        return Getter<T>{ *this };
70    }
71
72        Label makeLabel(Statement * labelled, const ast::Label& label) {
73                return Label(
74                        label.name,
75                        labelled,
76                        get<Attribute>().acceptL(label.attributes)
77                );
78        }
79
80        template<template <class...> class C>
81        std::list<Label> makeLabelL(Statement * labelled, const C<ast::Label>& labels) {
82                std::list<Label> ret;
83                for (auto label : labels) {
84                        ret.push_back( makeLabel(labelled, label) );
85                }
86                return ret;
87        }
88
89public:
90        Declaration * decl( const ast::Decl * declNode ) {
91                return get<Declaration>().accept1( ast::ptr<ast::Decl>( declNode ) );
92        }
93
94private:
95        const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
96                (void)node;
97                return nullptr;
98        }
99
100        const ast::DeclWithType * visit( const ast::FunctionDecl * node ) override final {
101                (void)node;
102                return nullptr;
103        }
104
105        const ast::Decl * visit( const ast::StructDecl * node ) override final {
106                (void)node;
107                return nullptr;
108        }
109
110        const ast::Decl * visit( const ast::UnionDecl * node ) override final {
111                (void)node;
112                return nullptr;
113        }
114
115        const ast::Decl * visit( const ast::EnumDecl * node ) override final {
116                (void)node;
117                return nullptr;
118        }
119
120        const ast::Decl * visit( const ast::TraitDecl * node ) override final {
121                (void)node;
122                return nullptr;
123        }
124
125        const ast::Decl * visit( const ast::TypeDecl * node ) override final {
126                (void)node;
127                return nullptr;
128        }
129
130        const ast::Decl * visit( const ast::TypedefDecl * node ) override final {
131                (void)node;
132                return nullptr;
133        }
134
135        const ast::AsmDecl * visit( const ast::AsmDecl * node ) override final {
136                (void)node;
137                return nullptr;
138        }
139
140        const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl * node ) override final {
141                (void)node;
142                return nullptr;
143        }
144
145        const ast::CompoundStmt * visit( const ast::CompoundStmt * node ) override final {
146                auto stmt = new CompoundStmt( get<Statement>().acceptL( node->kids ) );
147                stmt->location = node->location;
148                stmt->labels = makeLabelL( stmt, node->labels );
149                this->node = stmt;
150                return nullptr;
151        }
152
153        const ast::Stmt * visit( const ast::ExprStmt * node ) override final {
154                auto stmt = new ExprStmt( get<Expression>().accept1( node->expr ) );
155                stmt->location = node->location;
156                stmt->labels = makeLabelL( stmt, node->labels );
157                this->node = stmt;
158                return nullptr;
159        }
160
161        const ast::Stmt * visit( const ast::AsmStmt * node ) override final {
162                auto stmt = new AsmStmt(
163                        node->isVolatile,
164                        get<Expression>().accept1( node->instruction ),
165                        get<Expression>().acceptL( node->output ),
166                        get<Expression>().acceptL( node->input ),
167                        get<ConstantExpr>().acceptL( node->clobber ),
168                        makeLabelL( nullptr, node->gotoLabels ) // What are these labelling?
169                );
170                stmt->location = node->location;
171                stmt->labels = makeLabelL( stmt, node->labels );
172                this->node = stmt;
173                return nullptr;
174        }
175
176        const ast::Stmt * visit( const ast::DirectiveStmt * node ) override final {
177                auto stmt = new DirectiveStmt( node->directive );
178                stmt->location = node->location;
179                stmt->labels = makeLabelL( stmt, node->labels );
180                this->node = stmt;
181                return nullptr;
182        }
183
184        const ast::Stmt * visit( const ast::IfStmt * node ) override final {
185                auto stmt = new IfStmt(
186                        get<Expression>().accept1( node->cond ),
187                        get<Statement>().accept1( node->thenPart ),
188                        get<Statement>().accept1( node->elsePart ),
189                        get<Statement>().acceptL( node->inits )
190                );
191                stmt->location = node->location;
192                stmt->labels = makeLabelL( stmt, node->labels );
193                this->node = stmt;
194                return nullptr;
195        }
196
197        const ast::Stmt * visit( const ast::SwitchStmt * node ) override final {
198                auto stmt = new SwitchStmt(
199                        get<Expression>().accept1( node->cond ),
200                        get<Statement>().acceptL( node->stmts )
201                );
202                stmt->location = node->location;
203                stmt->labels = makeLabelL( stmt, node->labels );
204                this->node = stmt;
205                return nullptr;
206        }
207
208        const ast::Stmt * visit( const ast::CaseStmt * node ) override final {
209                auto stmt = new CaseStmt(
210                        get<Expression>().accept1( node->cond ),
211                        get<Statement>().acceptL( node->stmts ),
212                        node->isDefault()
213                );
214                stmt->location = node->location;
215                stmt->labels = makeLabelL( stmt, node->labels );
216                this->node = stmt;
217                return nullptr;
218        }
219
220        const ast::Stmt * visit( const ast::WhileStmt * node ) override final {
221                auto inits = get<Statement>().acceptL( node->inits );
222                auto stmt = new WhileStmt(
223                        get<Expression>().accept1( node->cond ),
224                        get<Statement>().accept1( node->body ),
225                        inits,
226                        node->isDoWhile
227                );
228                stmt->location = node->location;
229                stmt->labels = makeLabelL( stmt, node->labels );
230                this->node = stmt;
231                return nullptr;
232        }
233
234        const ast::Stmt * visit( const ast::ForStmt * node ) override final {
235                auto stmt = new ForStmt(
236                        get<Statement>().acceptL( node->inits ),
237                        get<Expression>().accept1( node->cond ),
238                        get<Expression>().accept1( node->inc ),
239                        get<Statement>().accept1( node->body )
240                );
241                stmt->location = node->location;
242                stmt->labels = makeLabelL( stmt, node->labels );
243                this->node = stmt;
244                return nullptr;
245        }
246
247        const ast::Stmt * visit( const ast::BranchStmt * node ) override final {
248                BranchStmt * stmt;
249                if (node->computedTarget) {
250                        stmt = new BranchStmt( get<Expression>().accept1( node->computedTarget ),
251                                BranchStmt::Goto );
252                } else {
253                        BranchStmt::Type type;
254                        switch (node->kind) {
255                        #define CASE(n) \
256                        case ast::BranchStmt::n: \
257                                type = BranchStmt::n; \
258                                break
259                        CASE(Goto);
260                        CASE(Break);
261                        CASE(Continue);
262                        CASE(FallThrough);
263                        CASE(FallThroughDefault);
264                        #undef CASE
265                        default:
266                                assertf(false, "Invalid ast::BranchStmt::Kind: %d\n", node->kind);
267                        }
268
269                        // The labels here are also weird.
270                        stmt = new BranchStmt( makeLabel( nullptr, node->originalTarget ), type );
271                        stmt->target = makeLabel( stmt, node->target );
272                }
273                stmt->location = node->location;
274                stmt->labels = makeLabelL( stmt, node->labels );
275                this->node = stmt;
276                return nullptr;
277        }
278
279        const ast::Stmt * visit( const ast::ReturnStmt * node ) override final {
280                auto stmt = new ReturnStmt( get<Expression>().accept1( node->expr ) );
281                stmt->location = node->location;
282                stmt->labels = makeLabelL( stmt, node->labels );
283                this->node = stmt;
284                return nullptr;
285        }
286
287        const ast::Stmt * visit( const ast::ThrowStmt * node ) override final {
288                ThrowStmt::Kind kind;
289                switch (node->kind) {
290                case ast::ThrowStmt::Terminate:
291                        kind = ThrowStmt::Terminate;
292                        break;
293                case ast::ThrowStmt::Resume:
294                        kind = ThrowStmt::Resume;
295                        break;
296                default:
297                        assertf(false, "Invalid ast::ThrowStmt::Kind: %d\n", node->kind);
298                }
299                auto stmt = new ThrowStmt(
300                        kind,
301                        get<Expression>().accept1( node->expr ),
302                        get<Expression>().accept1( node->target )
303                );
304                stmt->location = node->location;
305                stmt->labels = makeLabelL( stmt, node->labels );
306                this->node = stmt;
307                return nullptr;
308        }
309
310        const ast::Stmt * visit( const ast::TryStmt * node ) override final {
311                auto handlers = get<CatchStmt>().acceptL( node->handlers );
312                auto stmt = new TryStmt(
313                        get<CompoundStmt>().accept1( node->body ),
314                        handlers,
315                        get<FinallyStmt>().accept1( node->finally )
316                );
317                stmt->location = node->location;
318                stmt->labels = makeLabelL( stmt, node->labels );
319                this->node = stmt;
320                return nullptr;
321        }
322
323        const ast::Stmt * visit( const ast::CatchStmt * node ) override final {
324                CatchStmt::Kind kind;
325                switch (node->kind) {
326                case ast::CatchStmt::Terminate:
327                        kind = CatchStmt::Terminate;
328                        break;
329                case ast::CatchStmt::Resume:
330                        kind = CatchStmt::Resume;
331                        break;
332                default:
333                        assertf(false, "Invalid ast::CatchStmt::Kind: %d\n", node->kind);
334                }
335                auto stmt = new CatchStmt(
336                        kind,
337                        get<Declaration>().accept1( node->decl ),
338                        get<Expression>().accept1( node->cond ),
339                        get<Statement>().accept1( node->body )
340                );
341                stmt->location = node->location;
342                stmt->labels = makeLabelL( stmt, node->labels );
343                this->node = stmt;
344                return nullptr;
345        }
346
347        const ast::Stmt * visit( const ast::FinallyStmt * node ) override final {
348                auto stmt = new FinallyStmt( get<CompoundStmt>().accept1( node->body ) );
349                stmt->location = node->location;
350                stmt->labels = makeLabelL( stmt, node->labels );
351                this->node = stmt;
352                return nullptr;
353        }
354
355        const ast::Stmt * visit( const ast::WaitForStmt * node ) override final {
356                auto stmt = new WaitForStmt;
357                stmt->clauses.reserve( node->clauses.size() );
358                for ( auto clause : node->clauses ) {
359                        stmt->clauses.push_back({{
360                                        get<Expression>().accept1( clause.target.function ),
361                                        get<Expression>().acceptL( clause.target.arguments ),
362                                },
363                                get<Statement>().accept1( clause.stmt ),
364                                get<Expression>().accept1( clause.cond ),
365                        });
366                }
367                stmt->timeout = {
368                        get<Expression>().accept1( node->timeout.time ),
369                        get<Statement>().accept1( node->timeout.stmt ),
370                        get<Expression>().accept1( node->timeout.cond ),
371                };
372                stmt->orelse = {
373                        get<Statement>().accept1( node->orElse.stmt ),
374                        get<Expression>().accept1( node->orElse.cond ),
375                };
376                stmt->location = node->location;
377                stmt->labels = makeLabelL( stmt, node->labels );
378                this->node = stmt;
379                return nullptr;
380        }
381
382        const ast::Stmt * visit( const ast::WithStmt * node ) override final {
383                auto stmt = new WithStmt(
384                        get<Expression>().acceptL( node->exprs ),
385                        get<Statement>().accept1( node->stmt )
386                );
387                stmt->location = node->location;
388                stmt->labels = makeLabelL( stmt, node->labels );
389                this->node = stmt;
390                return nullptr;
391        }
392
393        const ast::NullStmt * visit( const ast::NullStmt * node ) override final {
394                auto stmt = new NullStmt();
395                stmt->location = node->location;
396                stmt->labels = makeLabelL( stmt, node->labels );
397                this->node = stmt;
398                return nullptr;
399        }
400
401        const ast::Stmt * visit( const ast::DeclStmt * node ) override final {
402                auto stmt = new DeclStmt( get<Declaration>().accept1( node->decl ) );
403                stmt->location = node->location;
404                stmt->labels = makeLabelL( stmt, node->labels );
405                this->node = stmt;
406                return nullptr;
407        }
408
409        const ast::Stmt * visit( const ast::ImplicitCtorDtorStmt * node ) override final {
410                (void)node;
411                return nullptr;
412        }
413
414        TypeSubstitution * convertTypeSubstitution(const ast::TypeSubstitution * src) {
415
416                TypeSubstitution *rslt = new TypeSubstitution();
417
418                for (decltype(src->begin()) src_i = src->begin(); src_i != src->end(); src_i++) {
419                        rslt->add( src_i->first,
420                                   get<Type>().accept1(src_i->second) );
421                }
422
423                for (decltype(src->beginVar()) src_i = src->beginVar(); src_i != src->endVar(); src_i++) {
424                        rslt->addVar( src_i->first,
425                                      get<Expression>().accept1(src_i->second) );
426                }
427
428                return rslt;
429        }
430
431        void convertInferUnion(std::map<UniqueId,ParamEntry> &tgtInferParams,
432                                                   std::vector<UniqueId>         &tgtResnSlots,
433                                                   const ast::Expr::InferUnion   &srcInferred ) {
434
435                assert( tgtInferParams.empty() );
436                assert( tgtResnSlots.empty() );
437
438                if ( srcInferred.mode == ast::Expr::InferUnion::Params ) {
439                        const ast::InferredParams &srcParams = srcInferred.inferParamsConst();
440                        for (auto srcParam : srcParams) {
441                                tgtInferParams[srcParam.first] = ParamEntry(
442                                        srcParam.second.decl,
443                                        get<Type>().accept1(srcParam.second.actualType),
444                                        get<Type>().accept1(srcParam.second.formalType),
445                                        get<Expression>().accept1(srcParam.second.expr)
446                                );
447                        }
448                } else if ( srcInferred.mode == ast::Expr::InferUnion::Slots  ) {
449                        const ast::ResnSlots &srcSlots = srcInferred.resnSlotsConst();
450                        for (auto srcSlot : srcSlots) {
451                                tgtResnSlots.push_back(srcSlot);
452                        }
453                }
454        }
455
456        Expression * visitBaseExpr(const ast::Expr * src, Expression * tgt) {
457
458                tgt->location = src->location;
459
460                tgt->result = get<Type>().accept1(src->result);
461                tgt->env    = convertTypeSubstitution(src->env);
462
463                tgt->extension = src->extension;
464                convertInferUnion(tgt->inferParams, tgt->resnSlots, src->inferred);
465
466                return tgt;
467        }
468
469        const ast::Expr * visit( const ast::ApplicationExpr * node ) override final {
470                auto expr = visitBaseExpr( node,
471                        new ApplicationExpr(
472                                get<Expression>().accept1(node->func),
473                                get<Expression>().acceptL(node->args)
474                        )
475                );
476                this->node = expr;
477                return nullptr;
478        }
479
480        const ast::Expr * visit( const ast::UntypedExpr * node ) override final {
481                auto expr = visitBaseExpr( node,
482                        new UntypedExpr(
483                                get<Expression>().accept1(node->func),
484                                get<Expression>().acceptL(node->args)
485                        )
486                );
487                this->node = expr;
488                return nullptr;
489        }
490
491        const ast::Expr * visit( const ast::NameExpr * node ) override final {
492                auto expr = visitBaseExpr( node,
493                        new NameExpr(
494                                node->name
495                        )
496                );
497                this->node = expr;
498                return nullptr;
499        }
500
501        const ast::Expr * visit( const ast::AddressExpr * node ) override final {
502                (void)node;
503                return nullptr;
504        }
505
506        const ast::Expr * visit( const ast::LabelAddressExpr * node ) override final {
507                (void)node;
508                return nullptr;
509        }
510
511        const ast::Expr * visit( const ast::CastExpr * node ) override final {
512                (void)node;
513                return nullptr;
514        }
515
516        const ast::Expr * visit( const ast::KeywordCastExpr * node ) override final {
517                (void)node;
518                return nullptr;
519        }
520
521        const ast::Expr * visit( const ast::VirtualCastExpr * node ) override final {
522                (void)node;
523                return nullptr;
524        }
525
526        const ast::Expr * visit( const ast::UntypedMemberExpr * node ) override final {
527                (void)node;
528                return nullptr;
529        }
530
531        const ast::Expr * visit( const ast::MemberExpr * node ) override final {
532                (void)node;
533                return nullptr;
534        }
535
536        const ast::Expr * visit( const ast::VariableExpr * node ) override final {
537                (void)node;
538                return nullptr;
539        }
540
541        const ast::Expr * visit( const ast::ConstantExpr * node ) override final {
542                (void)node;
543                return nullptr;
544        }
545
546        const ast::Expr * visit( const ast::SizeofExpr * node ) override final {
547                (void)node;
548                return nullptr;
549        }
550
551        const ast::Expr * visit( const ast::AlignofExpr * node ) override final {
552                (void)node;
553                return nullptr;
554        }
555
556        const ast::Expr * visit( const ast::UntypedOffsetofExpr * node ) override final {
557                (void)node;
558                return nullptr;
559        }
560
561        const ast::Expr * visit( const ast::OffsetofExpr * node ) override final {
562                (void)node;
563                return nullptr;
564        }
565
566        const ast::Expr * visit( const ast::OffsetPackExpr * node ) override final {
567                (void)node;
568                return nullptr;
569        }
570
571        const ast::Expr * visit( const ast::LogicalExpr * node ) override final {
572                (void)node;
573                return nullptr;
574        }
575
576        const ast::Expr * visit( const ast::ConditionalExpr * node ) override final {
577                (void)node;
578                return nullptr;
579        }
580
581        const ast::Expr * visit( const ast::CommaExpr * node ) override final {
582                (void)node;
583                return nullptr;
584        }
585
586        const ast::Expr * visit( const ast::TypeExpr * node ) override final {
587                (void)node;
588                return nullptr;
589        }
590
591        const ast::Expr * visit( const ast::AsmExpr * node ) override final {
592                (void)node;
593                return nullptr;
594        }
595
596        const ast::Expr * visit( const ast::ImplicitCopyCtorExpr * node ) override final {
597                (void)node;
598                return nullptr;
599        }
600
601        const ast::Expr * visit( const ast::ConstructorExpr * node ) override final {
602                (void)node;
603                return nullptr;
604        }
605
606        const ast::Expr * visit( const ast::CompoundLiteralExpr * node ) override final {
607                (void)node;
608                return nullptr;
609        }
610
611        const ast::Expr * visit( const ast::RangeExpr * node ) override final {
612                (void)node;
613                return nullptr;
614        }
615
616        const ast::Expr * visit( const ast::UntypedTupleExpr * node ) override final {
617                (void)node;
618                return nullptr;
619        }
620
621        const ast::Expr * visit( const ast::TupleExpr * node ) override final {
622                (void)node;
623                return nullptr;
624        }
625
626        const ast::Expr * visit( const ast::TupleIndexExpr * node ) override final {
627                (void)node;
628                return nullptr;
629        }
630
631        const ast::Expr * visit( const ast::TupleAssignExpr * node ) override final {
632                (void)node;
633                return nullptr;
634        }
635
636        const ast::Expr * visit( const ast::StmtExpr * node ) override final {
637                (void)node;
638                return nullptr;
639        }
640
641        const ast::Expr * visit( const ast::UniqueExpr * node ) override final {
642                (void)node;
643                return nullptr;
644        }
645
646        const ast::Expr * visit( const ast::UntypedInitExpr * node ) override final {
647                (void)node;
648                return nullptr;
649        }
650
651        const ast::Expr * visit( const ast::InitExpr * node ) override final {
652                (void)node;
653                return nullptr;
654        }
655
656        const ast::Expr * visit( const ast::DeletedExpr * node ) override final {
657                (void)node;
658                return nullptr;
659        }
660
661        const ast::Expr * visit( const ast::DefaultArgExpr * node ) override final {
662                (void)node;
663                return nullptr;
664        }
665
666        const ast::Expr * visit( const ast::GenericExpr * node ) override final {
667                (void)node;
668                return nullptr;
669        }
670
671        const ast::Type * visit( const ast::VoidType * node ) override final {
672                (void)node;
673                return nullptr;
674        }
675
676        const ast::Type * visit( const ast::BasicType * node ) override final {
677                (void)node;
678                return nullptr;
679        }
680
681        const ast::Type * visit( const ast::PointerType * node ) override final {
682                (void)node;
683                return nullptr;
684        }
685
686        const ast::Type * visit( const ast::ArrayType * node ) override final {
687                (void)node;
688                return nullptr;
689        }
690
691        const ast::Type * visit( const ast::ReferenceType * node ) override final {
692                (void)node;
693                return nullptr;
694        }
695
696        const ast::Type * visit( const ast::QualifiedType * node ) override final {
697                (void)node;
698                return nullptr;
699        }
700
701        const ast::Type * visit( const ast::FunctionType * node ) override final {
702                (void)node;
703                return nullptr;
704        }
705
706        const ast::Type * visit( const ast::StructInstType * node ) override final {
707                (void)node;
708                return nullptr;
709        }
710
711        const ast::Type * visit( const ast::UnionInstType * node ) override final {
712                (void)node;
713                return nullptr;
714        }
715
716        const ast::Type * visit( const ast::EnumInstType * node ) override final {
717                (void)node;
718                return nullptr;
719        }
720
721        const ast::Type * visit( const ast::TraitInstType * node ) override final {
722                (void)node;
723                return nullptr;
724        }
725
726        const ast::Type * visit( const ast::TypeInstType * node ) override final {
727                (void)node;
728                return nullptr;
729        }
730
731        const ast::Type * visit( const ast::TupleType * node ) override final {
732                (void)node;
733                return nullptr;
734        }
735
736        const ast::Type * visit( const ast::TypeofType * node ) override final {
737                (void)node;
738                return nullptr;
739        }
740
741        const ast::Type * visit( const ast::VarArgsType * node ) override final {
742                (void)node;
743                return nullptr;
744        }
745
746        const ast::Type * visit( const ast::ZeroType * node ) override final {
747                (void)node;
748                return nullptr;
749        }
750
751        const ast::Type * visit( const ast::OneType * node ) override final {
752                (void)node;
753                return nullptr;
754        }
755
756        const ast::Type * visit( const ast::GlobalScopeType * node ) override final {
757                (void)node;
758                return nullptr;
759        }
760
761        const ast::Designation * visit( const ast::Designation * node ) override final {
762                (void)node;
763                return nullptr;
764        }
765
766        const ast::Init * visit( const ast::SingleInit * node ) override final {
767                (void)node;
768                return nullptr;
769        }
770
771        const ast::Init * visit( const ast::ListInit * node ) override final {
772                (void)node;
773                return nullptr;
774        }
775
776        const ast::Init * visit( const ast::ConstructorInit * node ) override final {
777                (void)node;
778                return nullptr;
779        }
780
781        const ast::Attribute * visit( const ast::Attribute * node ) override final {
782                (void)node;
783                return nullptr;
784        }
785
786        const ast::TypeSubstitution * visit( const ast::TypeSubstitution * node ) override final {
787                (void)node;
788                return nullptr;
789        }
790};
791
792std::list< Declaration * > convert( std::list< ast::ptr< ast::Decl > > && translationUnit ) {
793        ConverterNewToOld c;
794        std::list< Declaration * > decls;
795        for(auto d : translationUnit) {
796                decls.emplace_back( c.decl( d ) );
797                delete d;
798        }
799        return decls;
800}
801
802//================================================================================================
803
804class ConverterOldToNew : public Visitor {
805public:
806        ast::Decl * decl() {
807                return strict_dynamic_cast< ast::Decl * >( node );
808        }
809private:
810        ast::Node * node;
811
812        // Local Utilities:
813
814        template<typename NewT, typename OldT>
815        NewT * getAccept1( OldT old ) {
816                old->accept(*this);
817                return strict_dynamic_cast< NewT * >( node );
818        }
819
820#       define GET_ACCEPT_1(child, type) \
821                getAccept1< ast::type, decltype( old->child ) >( old->child )
822
823        template<typename NewT, typename OldC>
824        std::vector< ast::ptr<NewT> > getAcceptV( OldC& old ) {
825                std::vector< ast::ptr<NewT> > ret;
826                ret.reserve( old.size() );
827                for ( auto a : old ) {
828                        a->accept( *this );
829                        ret.emplace_back( strict_dynamic_cast< NewT * >(node) );
830                }
831                return ret;
832        }
833
834#       define GET_ACCEPT_V(child, type) \
835                getAcceptV< ast::type, decltype( old->child ) >( old->child )
836
837        ast::Label make_label(Label* old) {
838                return ast::Label(
839                        old->labelled->location,
840                        old->name,
841                        GET_ACCEPT_V(attributes, Attribute)
842                );
843        }
844
845        template<template <class...> class C>
846        C<ast::Label> make_labels(C<Label> olds) {
847                C<ast::Label> ret;
848                for (auto oldn : olds) {
849                        ret.push_back( make_label( &oldn ) );
850                }
851                return ret;
852        }
853
854#       define GET_LABELS_V(labels) \
855                to<std::vector>::from( make_labels( std::move( labels ) ) )
856
857        // Now all the visit functions:
858
859        virtual void visit( ObjectDecl * old ) override final {
860                auto decl = new ast::ObjectDecl(
861                        old->location,
862                        old->name,
863                        GET_ACCEPT_1(type, Type),
864                        GET_ACCEPT_1(init, Init),
865                        { old->get_storageClasses().val },
866                        { old->linkage.val },
867                        GET_ACCEPT_1(bitfieldWidth, Expr),
868                        GET_ACCEPT_V(attributes, Attribute),
869                        { old->get_funcSpec().val }
870                );
871                decl->scopeLevel = old->scopeLevel;
872                decl->mangleName = old->mangleName;
873                decl->isDeleted  = old->isDeleted;
874                decl->uniqueId   = old->uniqueId;
875                decl->extension  = old->extension;
876
877                this->node = decl;
878        }
879
880        virtual void visit( FunctionDecl * ) override final {
881
882        }
883
884        virtual void visit( StructDecl * old ) override final {
885                auto decl = new ast::StructDecl(
886                        old->location,
887                        old->name,
888                        old->kind,
889                        GET_ACCEPT_V(attributes, Attribute),
890                        { old->linkage.val }
891                );
892                decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
893                decl->body   = old->body;
894                decl->params = GET_ACCEPT_V(parameters, TypeDecl);
895                decl->members    = GET_ACCEPT_V(members, Decl);
896                decl->extension  = old->extension;
897                decl->uniqueId   = old->uniqueId;
898                decl->storage    = { old->storageClasses.val };
899
900                this->node = decl;
901        }
902
903        virtual void visit( UnionDecl * old ) override final {
904                auto decl = new ast::UnionDecl(
905                        old->location,
906                        old->name,
907                        GET_ACCEPT_V(attributes, Attribute),
908                        { old->linkage.val }
909                );
910                decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
911                decl->body   = old->body;
912                decl->params = GET_ACCEPT_V(parameters, TypeDecl);
913                decl->members    = GET_ACCEPT_V(members, Decl);
914                decl->extension  = old->extension;
915                decl->uniqueId   = old->uniqueId;
916                decl->storage    = { old->storageClasses.val };
917
918                this->node = decl;
919        }
920
921        virtual void visit( EnumDecl * old ) override final {
922                auto decl = new ast::UnionDecl(
923                        old->location,
924                        old->name,
925                        GET_ACCEPT_V(attributes, Attribute),
926                        { old->linkage.val }
927                );
928                decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
929                decl->body   = old->body;
930                decl->params = GET_ACCEPT_V(parameters, TypeDecl);
931                decl->members    = GET_ACCEPT_V(members, Decl);
932                decl->extension  = old->extension;
933                decl->uniqueId   = old->uniqueId;
934                decl->storage    = { old->storageClasses.val };
935
936                this->node = decl;
937        }
938
939        virtual void visit( TraitDecl * old ) override final {
940                auto decl = new ast::UnionDecl(
941                        old->location,
942                        old->name,
943                        GET_ACCEPT_V(attributes, Attribute),
944                        { old->linkage.val }
945                );
946                decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
947                decl->body   = old->body;
948                decl->params = GET_ACCEPT_V(parameters, TypeDecl);
949                decl->members    = GET_ACCEPT_V(members, Decl);
950                decl->extension  = old->extension;
951                decl->uniqueId   = old->uniqueId;
952                decl->storage    = { old->storageClasses.val };
953
954                this->node = decl;
955        }
956
957        virtual void visit( TypeDecl * ) override final {
958
959        }
960
961        virtual void visit( TypedefDecl * old ) override final {
962                auto decl = new ast::TypedefDecl(
963                        old->location,
964                        old->name,
965                        { old->storageClasses.val },
966                        GET_ACCEPT_1(base, Type),
967                        { old->linkage.val }
968                );
969                decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
970                decl->params     = GET_ACCEPT_V(parameters, TypeDecl);
971                decl->extension  = old->extension;
972                decl->uniqueId   = old->uniqueId;
973                decl->storage    = { old->storageClasses.val };
974
975                this->node = decl;
976        }
977
978        virtual void visit( AsmDecl * ) override final {
979
980        }
981
982        virtual void visit( StaticAssertDecl * ) override final {
983
984        }
985
986        virtual void visit( CompoundStmt * old ) override final {
987                auto stmt = new ast::CompoundStmt(
988                        old->location,
989                        to<std::list>::from( GET_ACCEPT_V(kids, Stmt) ),
990                        GET_LABELS_V(old->labels)
991                );
992
993                this->node = stmt;
994        }
995
996        virtual void visit( ExprStmt * old ) override final {
997                this->node = new ast::ExprStmt(
998                        old->location,
999                        GET_ACCEPT_1(expr, Expr),
1000                        GET_LABELS_V(old->labels)
1001                );
1002        }
1003
1004        virtual void visit( AsmStmt * old ) override final {
1005                this->node = new ast::AsmStmt(
1006                        old->location,
1007                        old->voltile,
1008                        GET_ACCEPT_1(instruction, Expr),
1009                        GET_ACCEPT_V(output, Expr),
1010                        GET_ACCEPT_V(input, Expr),
1011                        GET_ACCEPT_V(clobber, ConstantExpr),
1012                        GET_LABELS_V(old->gotolabels),
1013                        GET_LABELS_V(old->labels)
1014                );
1015        }
1016
1017        virtual void visit( DirectiveStmt * old ) override final {
1018                this->node = new ast::DirectiveStmt(
1019                        old->location,
1020                        old->directive,
1021                        GET_LABELS_V(old->labels)
1022                );
1023        }
1024
1025        virtual void visit( IfStmt * old ) override final {
1026                this->node = new ast::IfStmt(
1027                        old->location,
1028                        GET_ACCEPT_1(condition, Expr),
1029                        GET_ACCEPT_1(thenPart, Stmt),
1030                        GET_ACCEPT_1(elsePart, Stmt),
1031                        GET_ACCEPT_V(initialization, Stmt),
1032                        GET_LABELS_V(old->labels)
1033                );
1034        }
1035
1036        virtual void visit( SwitchStmt * old ) override final {
1037                this->node = new ast::SwitchStmt(
1038                        old->location,
1039                        GET_ACCEPT_1(condition, Expr),
1040                        GET_ACCEPT_V(statements, Stmt),
1041                        GET_LABELS_V(old->labels)
1042                );
1043        }
1044
1045        virtual void visit( CaseStmt * old ) override final {
1046                this->node = new ast::CaseStmt(
1047                        old->location,
1048                        GET_ACCEPT_1(condition, Expr),
1049                        GET_ACCEPT_V(stmts, Stmt),
1050                        GET_LABELS_V(old->labels)
1051                );
1052        }
1053
1054        virtual void visit( WhileStmt * old ) override final {
1055                this->node = new ast::WhileStmt(
1056                        old->location,
1057                        GET_ACCEPT_1(condition, Expr),
1058                        GET_ACCEPT_1(body, Stmt),
1059                        GET_ACCEPT_V(initialization, Stmt),
1060                        old->isDoWhile,
1061                        GET_LABELS_V(old->labels)
1062                );
1063        }
1064
1065        virtual void visit( ForStmt * old ) override final {
1066                this->node = new ast::ForStmt(
1067                        old->location,
1068                        GET_ACCEPT_V(initialization, Stmt),
1069                        GET_ACCEPT_1(condition, Expr),
1070                        GET_ACCEPT_1(increment, Expr),
1071                        GET_ACCEPT_1(body, Stmt),
1072                        GET_LABELS_V(old->labels)
1073                );
1074        }
1075
1076        virtual void visit( BranchStmt * old ) override final {
1077                if (old->computedTarget) {
1078                        this->node = new ast::BranchStmt(
1079                                old->location,
1080                                GET_ACCEPT_1(computedTarget, Expr),
1081                                GET_LABELS_V(old->labels)
1082                        );
1083                } else {
1084                        ast::BranchStmt::Kind kind;
1085                        switch (old->type) {
1086                        #define CASE(n) \
1087                        case BranchStmt::n: \
1088                                kind = ast::BranchStmt::n; \
1089                                break
1090                        CASE(Goto);
1091                        CASE(Break);
1092                        CASE(Continue);
1093                        CASE(FallThrough);
1094                        CASE(FallThroughDefault);
1095                        #undef CASE
1096                        default:
1097                                assertf(false, "Invalid BranchStmt::Type %d\n", old->type);
1098                        }
1099
1100                        Label label = old->originalTarget;
1101                        auto stmt = new ast::BranchStmt(
1102                                old->location,
1103                                kind,
1104                                make_label(&label),
1105                                GET_LABELS_V(old->labels)
1106                        );
1107                        stmt->target = make_label(&old->target);
1108                        this->node = stmt;
1109                }
1110        }
1111
1112        virtual void visit( ReturnStmt * old ) override final {
1113                this->node = new ast::ReturnStmt(
1114                        old->location,
1115                        GET_ACCEPT_1(expr, Expr),
1116                        GET_LABELS_V(old->labels)
1117                );
1118        }
1119
1120        virtual void visit( ThrowStmt * old ) override final {
1121                ast::ThrowStmt::Kind kind;
1122                switch (old->kind) {
1123                case ThrowStmt::Terminate:
1124                        kind = ast::ThrowStmt::Terminate;
1125                        break;
1126                case ThrowStmt::Resume:
1127                        kind = ast::ThrowStmt::Resume;
1128                        break;
1129                default:
1130                        assertf(false, "Invalid ThrowStmt::Kind %d\n", old->kind);
1131                }
1132
1133                this->node = new ast::ThrowStmt(
1134                        old->location,
1135                        kind,
1136                        GET_ACCEPT_1(expr, Expr),
1137                        GET_ACCEPT_1(target, Expr),
1138                        GET_LABELS_V(old->labels)
1139                );
1140        }
1141
1142        virtual void visit( TryStmt * old ) override final {
1143                this->node = new ast::TryStmt(
1144                        old->location,
1145                        GET_ACCEPT_1(block, CompoundStmt),
1146                        GET_ACCEPT_V(handlers, CatchStmt),
1147                        GET_ACCEPT_1(finallyBlock, FinallyStmt),
1148                        GET_LABELS_V(old->labels)
1149                );
1150        }
1151
1152        virtual void visit( CatchStmt * old ) override final {
1153                ast::CatchStmt::Kind kind;
1154                switch (old->kind) {
1155                case CatchStmt::Terminate:
1156                        kind = ast::CatchStmt::Terminate;
1157                        break;
1158                case CatchStmt::Resume:
1159                        kind = ast::CatchStmt::Resume;
1160                        break;
1161                default:
1162                        assertf(false, "Invalid CatchStmt::Kind %d\n", old->kind);
1163                }
1164
1165                this->node = new ast::CatchStmt(
1166                        old->location,
1167                        kind,
1168                        GET_ACCEPT_1(decl, Decl),
1169                        GET_ACCEPT_1(cond, Expr),
1170                        GET_ACCEPT_1(body, Stmt),
1171                        GET_LABELS_V(old->labels)
1172                );
1173        }
1174
1175        virtual void visit( FinallyStmt * old ) override final {
1176                this->node = new ast::FinallyStmt(
1177                        old->location,
1178                        GET_ACCEPT_1(block, CompoundStmt),
1179                        GET_LABELS_V(old->labels)
1180                );
1181        }
1182
1183        virtual void visit( WaitForStmt * old ) override final {
1184                ast::WaitForStmt * stmt = new ast::WaitForStmt(
1185                        old->location,
1186                        GET_LABELS_V(old->labels)
1187                );
1188
1189                stmt->clauses.reserve( old->clauses.size() );
1190                for (size_t i = 0 ; i < old->clauses.size() ; ++i) {
1191                        stmt->clauses.push_back({
1192                                ast::WaitForStmt::Target{
1193                                        GET_ACCEPT_1(clauses[i].target.function, Expr),
1194                                        GET_ACCEPT_V(clauses[i].target.arguments, Expr)
1195                                },
1196                                GET_ACCEPT_1(clauses[i].statement, Stmt),
1197                                GET_ACCEPT_1(clauses[i].condition, Expr)
1198                        });
1199                }
1200                stmt->timeout = {
1201                        GET_ACCEPT_1(timeout.time, Expr),
1202                        GET_ACCEPT_1(timeout.statement, Stmt),
1203                        GET_ACCEPT_1(timeout.condition, Expr),
1204                };
1205                stmt->orElse = {
1206                        GET_ACCEPT_1(timeout.statement, Stmt),
1207                        GET_ACCEPT_1(timeout.condition, Expr),
1208                };
1209
1210                this->node = stmt;
1211        }
1212
1213        virtual void visit( WithStmt * old ) override final {
1214                this->node = new ast::WithStmt(
1215                        old->location,
1216                        GET_ACCEPT_V(exprs, Expr),
1217                        GET_ACCEPT_1(stmt, Stmt),
1218                        GET_LABELS_V(old->labels)
1219                );
1220        }
1221
1222        virtual void visit( NullStmt * old ) override final {
1223                this->node = new ast::NullStmt(
1224                        old->location,
1225                        GET_LABELS_V(old->labels)
1226                );
1227        }
1228
1229        virtual void visit( DeclStmt * old ) override final {
1230                this->node = new ast::DeclStmt(
1231                        old->location,
1232                        GET_ACCEPT_1(decl, Decl),
1233                        GET_LABELS_V(old->labels)
1234                );
1235        }
1236
1237        virtual void visit( ImplicitCtorDtorStmt * old ) override final {
1238                this->node = new ast::ImplicitCtorDtorStmt(
1239                        old->location,
1240                        GET_ACCEPT_1(callStmt, Stmt),
1241                        GET_LABELS_V(old->labels)
1242                );
1243        }
1244
1245        ast::TypeSubstitution * convertTypeSubstitution(const TypeSubstitution * old) {
1246
1247                ast::TypeSubstitution *rslt = new ast::TypeSubstitution();
1248
1249                for (decltype(old->begin()) old_i = old->begin(); old_i != old->end(); old_i++) {
1250                        rslt->add( old_i->first,
1251                                   getAccept1<ast::Type>(old_i->second) );
1252                }
1253
1254                for (decltype(old->beginVar()) old_i = old->beginVar(); old_i != old->endVar(); old_i++) {
1255                        rslt->addVar( old_i->first,
1256                                      getAccept1<ast::Expr>(old_i->second) );
1257                }
1258
1259                return rslt;
1260        }
1261
1262        void convertInferUnion(ast::Expr::InferUnion               &newInferred, 
1263                                                   const std::map<UniqueId,ParamEntry> &oldInferParams,
1264                                                   const std::vector<UniqueId>         &oldResnSlots) {
1265
1266                assert( oldInferParams.empty() || oldResnSlots.empty() );
1267                assert( newInferred.mode == ast::Expr::InferUnion::Empty );
1268
1269                if ( !oldInferParams.empty() ) {
1270                        ast::InferredParams &tgt = newInferred.inferParams();
1271                        for (auto old : oldInferParams) {
1272                                tgt[old.first] = ast::ParamEntry(
1273                                        old.second.decl,
1274                                        getAccept1<ast::Type>(old.second.actualType),
1275                                        getAccept1<ast::Type>(old.second.formalType),
1276                                        getAccept1<ast::Expr>(old.second.expr)
1277                                );
1278                        }
1279                } else if ( !oldResnSlots.empty() ) {
1280                        ast::ResnSlots &tgt = newInferred.resnSlots();
1281                        for (auto old : oldResnSlots) {
1282                                tgt.push_back(old);
1283                        }
1284                }
1285        }
1286
1287        ast::Expr * visitBaseExpr(Expression * old, ast::Expr * nw) {
1288
1289                nw->result = GET_ACCEPT_1(result, Type);
1290                nw->env    = convertTypeSubstitution(old->env);
1291
1292                nw->extension = old->extension;
1293                convertInferUnion(nw->inferred, old->inferParams, old->resnSlots);
1294
1295                return nw;
1296        }
1297
1298        virtual void visit( ApplicationExpr * old ) override final {
1299                this->node = visitBaseExpr( old,
1300                        new ast::ApplicationExpr(
1301                                old->location,
1302                                GET_ACCEPT_1(function, Expr),
1303                                GET_ACCEPT_V(args, Expr)
1304                        )
1305                );
1306        }
1307
1308        virtual void visit( UntypedExpr * old ) override final {
1309                this->node = visitBaseExpr( old,
1310                        new ast::UntypedExpr(
1311                                old->location,
1312                                GET_ACCEPT_1(function, Expr),
1313                                GET_ACCEPT_V(args, Expr)
1314                        )
1315                );
1316        }
1317
1318        virtual void visit( NameExpr * old ) override final {
1319                this->node = visitBaseExpr( old,
1320                        new ast::NameExpr(
1321                                old->location,
1322                                old->get_name()
1323                        )
1324                );
1325        }
1326
1327        virtual void visit( CastExpr * old ) override final {
1328                this->node = visitBaseExpr( old,
1329                        new ast::CastExpr(
1330                                old->location,
1331                                nullptr, // cast's "to" type is expr's result type; converted in visitBaseExpr
1332                                old->isGenerated ? ast::GeneratedCast : ast::ExplicitCast
1333                        )
1334                );
1335        }
1336
1337        virtual void visit( KeywordCastExpr * ) override final {
1338
1339        }
1340
1341        virtual void visit( VirtualCastExpr * ) override final {
1342
1343        }
1344
1345        virtual void visit( AddressExpr * ) override final {
1346
1347        }
1348
1349        virtual void visit( LabelAddressExpr * ) override final {
1350
1351        }
1352
1353        virtual void visit( UntypedMemberExpr * ) override final {
1354
1355        }
1356
1357        virtual void visit( MemberExpr * ) override final {
1358
1359        }
1360
1361        virtual void visit( VariableExpr * ) override final {
1362
1363        }
1364
1365        virtual void visit( ConstantExpr * ) override final {
1366
1367        }
1368
1369        virtual void visit( SizeofExpr * ) override final {
1370
1371        }
1372
1373        virtual void visit( AlignofExpr * ) override final {
1374
1375        }
1376
1377        virtual void visit( UntypedOffsetofExpr * ) override final {
1378
1379        }
1380
1381        virtual void visit( OffsetofExpr * ) override final {
1382
1383        }
1384
1385        virtual void visit( OffsetPackExpr * ) override final {
1386
1387        }
1388
1389        virtual void visit( LogicalExpr * ) override final {
1390
1391        }
1392
1393        virtual void visit( ConditionalExpr * ) override final {
1394
1395        }
1396
1397        virtual void visit( CommaExpr * ) override final {
1398
1399        }
1400
1401        virtual void visit( TypeExpr * ) override final {
1402
1403        }
1404
1405        virtual void visit( AsmExpr * ) override final {
1406
1407        }
1408
1409        virtual void visit( ImplicitCopyCtorExpr * ) override final {
1410
1411        }
1412
1413        virtual void visit( ConstructorExpr *  ) override final {
1414
1415        }
1416
1417        virtual void visit( CompoundLiteralExpr * ) override final {
1418
1419        }
1420
1421        virtual void visit( RangeExpr * ) override final {
1422
1423        }
1424
1425        virtual void visit( UntypedTupleExpr * ) override final {
1426
1427        }
1428
1429        virtual void visit( TupleExpr * ) override final {
1430
1431        }
1432
1433        virtual void visit( TupleIndexExpr * ) override final {
1434
1435        }
1436
1437        virtual void visit( TupleAssignExpr * ) override final {
1438
1439        }
1440
1441        virtual void visit( StmtExpr *  ) override final {
1442
1443        }
1444
1445        virtual void visit( UniqueExpr *  ) override final {
1446
1447        }
1448
1449        virtual void visit( UntypedInitExpr *  ) override final {
1450
1451        }
1452
1453        virtual void visit( InitExpr *  ) override final {
1454
1455        }
1456
1457        virtual void visit( DeletedExpr * ) override final {
1458
1459        }
1460
1461        virtual void visit( DefaultArgExpr * ) override final {
1462
1463        }
1464
1465        virtual void visit( GenericExpr * ) override final {
1466
1467        }
1468
1469        virtual void visit( VoidType * ) override final {
1470
1471        }
1472
1473        virtual void visit( BasicType * ) override final {
1474
1475        }
1476
1477        virtual void visit( PointerType * ) override final {
1478
1479        }
1480
1481        virtual void visit( ArrayType * ) override final {
1482
1483        }
1484
1485        virtual void visit( ReferenceType * ) override final {
1486
1487        }
1488
1489        virtual void visit( QualifiedType * ) override final {
1490
1491        }
1492
1493        virtual void visit( FunctionType * ) override final {
1494
1495        }
1496
1497        virtual void visit( StructInstType * ) override final {
1498
1499        }
1500
1501        virtual void visit( UnionInstType * ) override final {
1502
1503        }
1504
1505        virtual void visit( EnumInstType * ) override final {
1506
1507        }
1508
1509        virtual void visit( TraitInstType * ) override final {
1510
1511        }
1512
1513        virtual void visit( TypeInstType * ) override final {
1514
1515        }
1516
1517        virtual void visit( TupleType * ) override final {
1518
1519        }
1520
1521        virtual void visit( TypeofType * ) override final {
1522
1523        }
1524
1525        virtual void visit( AttrType * ) override final {
1526
1527        }
1528
1529        virtual void visit( VarArgsType * ) override final {
1530
1531        }
1532
1533        virtual void visit( ZeroType * ) override final {
1534
1535        }
1536
1537        virtual void visit( OneType * ) override final {
1538
1539        }
1540
1541        virtual void visit( GlobalScopeType * ) override final {
1542
1543        }
1544
1545        virtual void visit( Designation * ) override final {
1546
1547        }
1548
1549        virtual void visit( SingleInit * ) override final {
1550
1551        }
1552
1553        virtual void visit( ListInit * ) override final {
1554
1555        }
1556
1557        virtual void visit( ConstructorInit * ) override final {
1558
1559        }
1560
1561        virtual void visit( Constant * ) override final {
1562
1563        }
1564
1565        virtual void visit( Attribute * ) override final {
1566
1567        }
1568
1569        virtual void visit( AttrExpr * ) override final {
1570
1571                assert( 0 );
1572        }
1573};
1574
1575#undef GET_LABELS_V
1576#undef GET_ACCEPT_V
1577#undef GET_ACCEPT_1
1578
1579std::list< ast::ptr< ast::Decl > > convert( const std::list< Declaration * > && translationUnit ) {
1580        ConverterOldToNew c;
1581        std::list< ast::ptr< ast::Decl > > decls;
1582        for(auto d : translationUnit) {
1583                d->accept( c );
1584                decls.emplace_back( c.decl() );
1585                delete d;
1586        }
1587        return decls;
1588}
Note: See TracBrowser for help on using the repository browser.