Context Navigation

source: src/AST/Convert.cpp @ 427854b

ADTarm-ehast-experimentalenumforall-pointer-decayjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprpthread-emulationqualifiedEnum

Last change on this file since 427854b was 37cdd97, checked in by Thierry Delisle <tdelisle@…>, 4 years ago
Added a ast node for suspend statements
Property mode set to `100644`
File size: 72.4 KB

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

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

Download in other formats: