source: src/AST/Convert.cpp@ a1b154d

ADT arm-eh ast-experimental cleanup-dtors enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since a1b154d was 514a791, checked in by Aaron Moss <a3moss@…>, 7 years ago

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