source: src/AST/Convert.cpp@ d3aa64f1

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation new-ast-unique-expr pthread-emulation qualifiedEnum
Last change on this file since d3aa64f1 was 4ef08f7, checked in by Thierry Delisle <tdelisle@…>, 5 years ago

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