source: src/AST/Convert.cpp@ b56ad5e

ADT ast-experimental enum forall-pointer-decay pthread-emulation qualifiedEnum
Last change on this file since b56ad5e was ff3b0249, checked in by Peter A. Buhr <pabuhr@…>, 4 years ago

add else clause into WhileDoStmt and ForStmt

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