Context Navigation

source: src/AST/Convert.cpp @ 9d264e18

ADTarm-ehast-experimentalenumforall-pointer-decayjacob/cs343-translationnew-ast-unique-exprpthread-emulationqualifiedEnum

Last change on this file since 9d264e18 was 23954b6, checked in by Andrew Beach <ajbeach@…>, 3 years ago
Convert now fills in the globals of the TranslationUnit?.
Property mode set to `100644`
File size: 77.0 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: