Context Navigation

source: src/AST/Convert.cpp@ 6f096d2

Visit:

ADT arm-eh ast-experimental enum forall-pointer-decay jacob/cs343-translation jenkins-sandbox new-ast new-ast-unique-expr pthread-emulation qualifiedEnum

Last change on this file since 6f096d2 was 7870799, checked in by Thierry Delisle <tdelisle@…>, 6 years ago
Cast cost and conversion cost now take constant parameters. This required supporting visiting const node. The PassVisitor can now visit const nodes but not when using the Indexer
Property mode set to `100644`
File size: 71.9 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 : Mon Jun 17 16:44:00 2019
13	// Update Count : 12
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	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::WaitForStmt * node ) override final {
496	if ( inCache( node ) ) return nullptr;
497	auto stmt = new WaitForStmt;
498	stmt->clauses.reserve( node->clauses.size() );
499	for ( auto clause : node->clauses ) {
500	stmt->clauses.push_back({{
501	get<Expression>().accept1( clause.target.func ),
502	get<Expression>().acceptL( clause.target.args ),
503	},
504	get<Statement>().accept1( clause.stmt ),
505	get<Expression>().accept1( clause.cond ),
506	});
507	}
508	stmt->timeout = {
509	get<Expression>().accept1( node->timeout.time ),
510	get<Statement>().accept1( node->timeout.stmt ),
511	get<Expression>().accept1( node->timeout.cond ),
512	};
513	stmt->orelse = {
514	get<Statement>().accept1( node->orElse.stmt ),
515	get<Expression>().accept1( node->orElse.cond ),
516	};
517	return stmtPostamble( stmt, node );
518	}
519
520	const ast::Stmt * visit( const ast::WithStmt * node ) override final {
521	if ( inCache( node ) ) return nullptr;
522	auto stmt = new WithStmt(
523	get<Expression>().acceptL( node->exprs ),
524	get<Statement>().accept1( node->stmt )
525	);
526	return stmtPostamble( stmt, node );
527	}
528
529	const ast::NullStmt * visit( const ast::NullStmt * node ) override final {
530	if ( inCache( node ) ) return nullptr;
531	auto stmt = new NullStmt();
532	stmtPostamble( stmt, node );
533	return nullptr;
534	}
535
536	const ast::Stmt * visit( const ast::DeclStmt * node ) override final {
537	if ( inCache( node ) ) return nullptr;
538	auto stmt = new DeclStmt( get<Declaration>().accept1( node->decl ) );
539	return stmtPostamble( stmt, node );
540	}
541
542	const ast::Stmt * visit( const ast::ImplicitCtorDtorStmt * node ) override final {
543	if ( inCache( node ) ) return nullptr;
544	auto stmt = new ImplicitCtorDtorStmt{
545	get<Statement>().accept1( node->callStmt )
546	};
547	return stmtPostamble( stmt, node );
548	}
549
550	TypeSubstitution * convertTypeSubstitution(const ast::TypeSubstitution * src) {
551
552	if (!src) return nullptr;
553
554	TypeSubstitution *rslt = new TypeSubstitution();
555
556	for (decltype(src->begin()) src_i = src->begin(); src_i != src->end(); src_i++) {
557	rslt->add( src_i->first,
558	get<Type>().accept1(src_i->second) );
559	}
560
561	for (decltype(src->beginVar()) src_i = src->beginVar(); src_i != src->endVar(); src_i++) {
562	rslt->addVar( src_i->first,
563	get<Expression>().accept1(src_i->second) );
564	}
565
566	return rslt;
567	}
568
569	void convertInferUnion(std::map<UniqueId,ParamEntry> &tgtInferParams,
570	std::vector<UniqueId> &tgtResnSlots,
571	const ast::Expr::InferUnion &srcInferred ) {
572
573	assert( tgtInferParams.empty() );
574	assert( tgtResnSlots.empty() );
575
576	if ( srcInferred.mode == ast::Expr::InferUnion::Params ) {
577	const ast::InferredParams &srcParams = srcInferred.inferParams();
578	for (auto & srcParam : srcParams) {
579	auto res = tgtInferParams.emplace(srcParam.first, ParamEntry(
580	srcParam.second.decl,
581	get<Declaration>().accept1(srcParam.second.declptr),
582	get<Type>().accept1(srcParam.second.actualType),
583	get<Type>().accept1(srcParam.second.formalType),
584	get<Expression>().accept1(srcParam.second.expr)
585	));
586	assert(res.second);
587	}
588	} else if ( srcInferred.mode == ast::Expr::InferUnion::Slots ) {
589	const ast::ResnSlots &srcSlots = srcInferred.resnSlots();
590	for (auto srcSlot : srcSlots) {
591	tgtResnSlots.push_back(srcSlot);
592	}
593	}
594	}
595
596	Expression * visitBaseExpr_skipResultType(const ast::Expr * src, Expression * tgt) {
597
598	tgt->location = src->location;
599	tgt->env = convertTypeSubstitution(src->env);
600	tgt->extension = src->extension;
601
602	convertInferUnion(tgt->inferParams, tgt->resnSlots, src->inferred);
603	return tgt;
604	}
605
606	Expression * visitBaseExpr(const ast::Expr * src, Expression * tgt) {
607
608	tgt->result = get<Type>().accept1(src->result);
609	return visitBaseExpr_skipResultType(src, tgt);
610	}
611
612	const ast::Expr * visit( const ast::ApplicationExpr * node ) override final {
613	auto expr = visitBaseExpr( node,
614	new ApplicationExpr(
615	get<Expression>().accept1(node->func),
616	get<Expression>().acceptL(node->args)
617	)
618	);
619	this->node = expr;
620	return nullptr;
621	}
622
623	const ast::Expr * visit( const ast::UntypedExpr * node ) override final {
624	auto expr = visitBaseExpr( node,
625	new UntypedExpr(
626	get<Expression>().accept1(node->func),
627	get<Expression>().acceptL(node->args)
628	)
629	);
630	this->node = expr;
631	return nullptr;
632	}
633
634	const ast::Expr * visit( const ast::NameExpr * node ) override final {
635	auto expr = visitBaseExpr( node,
636	new NameExpr(
637	node->name
638	)
639	);
640	this->node = expr;
641	return nullptr;
642	}
643
644	const ast::Expr * visit( const ast::AddressExpr * node ) override final {
645	auto expr = visitBaseExpr( node,
646	new AddressExpr(
647	get<Expression>().accept1(node->arg)
648	)
649	);
650	this->node = expr;
651	return nullptr;
652	}
653
654	const ast::Expr * visit( const ast::LabelAddressExpr * node ) override final {
655	auto expr = visitBaseExpr( node,
656	new LabelAddressExpr(
657	makeLabel(nullptr, node->arg)
658	)
659	);
660	this->node = expr;
661	return nullptr;
662	}
663
664	const ast::Expr * visit( const ast::CastExpr * node ) override final {
665	auto expr = visitBaseExpr( node,
666	new CastExpr(
667	get<Expression>().accept1(node->arg),
668	(node->isGenerated == ast::GeneratedCast)
669	)
670	);
671	this->node = expr;
672	return nullptr;
673	}
674
675	const ast::Expr * visit( const ast::KeywordCastExpr * node ) override final {
676	KeywordCastExpr::Target castTarget = KeywordCastExpr::NUMBER_OF_TARGETS;
677	switch (node->target) {
678	case ast::KeywordCastExpr::Coroutine:
679	castTarget = KeywordCastExpr::Coroutine;
680	break;
681	case ast::KeywordCastExpr::Thread:
682	castTarget = KeywordCastExpr::Thread;
683	break;
684	case ast::KeywordCastExpr::Monitor:
685	castTarget = KeywordCastExpr::Monitor;
686	break;
687	default:
688	break;
689	}
690	assert ( castTarget < KeywordCastExpr::NUMBER_OF_TARGETS );
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	get<Expression>().accept1(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	this->node :
1042	get<BaseSyntaxNode>().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::TypeVar::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	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::TypeVar::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 WaitForStmt * old ) override final {
1874	if ( inCache( old ) ) return;
1875	ast::WaitForStmt * stmt = new ast::WaitForStmt(
1876	old->location,
1877	GET_LABELS_V(old->labels)
1878	);
1879
1880	stmt->clauses.reserve( old->clauses.size() );
1881	for (size_t i = 0 ; i < old->clauses.size() ; ++i) {
1882	stmt->clauses.push_back({
1883	ast::WaitForStmt::Target{
1884	GET_ACCEPT_1(clauses[i].target.function, Expr),
1885	GET_ACCEPT_V(clauses[i].target.arguments, Expr)
1886	},
1887	GET_ACCEPT_1(clauses[i].statement, Stmt),
1888	GET_ACCEPT_1(clauses[i].condition, Expr)
1889	});
1890	}
1891	stmt->timeout = {
1892	GET_ACCEPT_1(timeout.time, Expr),
1893	GET_ACCEPT_1(timeout.statement, Stmt),
1894	GET_ACCEPT_1(timeout.condition, Expr),
1895	};
1896	stmt->orElse = {
1897	GET_ACCEPT_1(orelse.statement, Stmt),
1898	GET_ACCEPT_1(orelse.condition, Expr),
1899	};
1900
1901	this->node = stmt;
1902	cache.emplace( old, this->node );
1903	}
1904
1905	virtual void visit( const WithStmt * old ) override final {
1906	if ( inCache( old ) ) return;
1907	this->node = new ast::WithStmt(
1908	old->location,
1909	GET_ACCEPT_V(exprs, Expr),
1910	GET_ACCEPT_1(stmt, Stmt),
1911	GET_LABELS_V(old->labels)
1912	);
1913	cache.emplace( old, this->node );
1914	}
1915
1916	virtual void visit( const NullStmt * old ) override final {
1917	if ( inCache( old ) ) return;
1918	this->node = new ast::NullStmt(
1919	old->location,
1920	GET_LABELS_V(old->labels)
1921	);
1922	cache.emplace( old, this->node );
1923	}
1924
1925	virtual void visit( const DeclStmt * old ) override final {
1926	if ( inCache( old ) ) return;
1927	this->node = new ast::DeclStmt(
1928	old->location,
1929	GET_ACCEPT_1(decl, Decl),
1930	GET_LABELS_V(old->labels)
1931	);
1932	cache.emplace( old, this->node );
1933	}
1934
1935	virtual void visit( const ImplicitCtorDtorStmt * old ) override final {
1936	if ( inCache( old ) ) return;
1937	auto stmt = new ast::ImplicitCtorDtorStmt(
1938	old->location,
1939	nullptr,
1940	GET_LABELS_V(old->labels)
1941	);
1942	cache.emplace( old, stmt );
1943	stmt->callStmt = GET_ACCEPT_1(callStmt, Stmt);
1944	this->node = stmt;
1945	}
1946
1947	ast::TypeSubstitution * convertTypeSubstitution(const TypeSubstitution * old) {
1948
1949	if (!old) return nullptr;
1950
1951	ast::TypeSubstitution *rslt = new ast::TypeSubstitution();
1952
1953	for (decltype(old->begin()) old_i = old->begin(); old_i != old->end(); old_i++) {
1954	rslt->add( old_i->first,
1955	getAccept1<ast::Type>(old_i->second) );
1956	}
1957
1958	for (decltype(old->beginVar()) old_i = old->beginVar(); old_i != old->endVar(); old_i++) {
1959	rslt->addVar( old_i->first,
1960	getAccept1<ast::Expr>(old_i->second) );
1961	}
1962
1963	return rslt;
1964	}
1965
1966	void convertInferUnion(ast::Expr::InferUnion &newInferred,
1967	const std::map<UniqueId,ParamEntry> &oldInferParams,
1968	const std::vector<UniqueId> &oldResnSlots) {
1969
1970	assert( oldInferParams.empty() \|\| oldResnSlots.empty() );
1971	assert( newInferred.mode == ast::Expr::InferUnion::Empty );
1972
1973	if ( !oldInferParams.empty() ) {
1974	ast::InferredParams &tgt = newInferred.inferParams();
1975	for (auto & old : oldInferParams) {
1976	tgt[old.first] = ast::ParamEntry(
1977	old.second.decl,
1978	getAccept1<ast::Decl>(old.second.declptr),
1979	getAccept1<ast::Type>(old.second.actualType),
1980	getAccept1<ast::Type>(old.second.formalType),
1981	getAccept1<ast::Expr>(old.second.expr)
1982	);
1983	}
1984	} else if ( !oldResnSlots.empty() ) {
1985	ast::ResnSlots &tgt = newInferred.resnSlots();
1986	for (auto old : oldResnSlots) {
1987	tgt.push_back(old);
1988	}
1989	}
1990	}
1991
1992	ast::Expr * visitBaseExpr_SkipResultType( const Expression * old, ast::Expr * nw) {
1993
1994	nw->env = convertTypeSubstitution(old->env);
1995
1996	nw->extension = old->extension;
1997	convertInferUnion(nw->inferred, old->inferParams, old->resnSlots);
1998
1999	return nw;
2000	}
2001
2002	ast::Expr * visitBaseExpr( const Expression * old, ast::Expr * nw) {
2003
2004	nw->result = GET_ACCEPT_1(result, Type);
2005	return visitBaseExpr_SkipResultType(old, nw);;
2006	}
2007
2008	virtual void visit( const ApplicationExpr * old ) override final {
2009	this->node = visitBaseExpr( old,
2010	new ast::ApplicationExpr(
2011	old->location,
2012	GET_ACCEPT_1(function, Expr),
2013	GET_ACCEPT_V(args, Expr)
2014	)
2015	);
2016	}
2017
2018	virtual void visit( const UntypedExpr * old ) override final {
2019	this->node = visitBaseExpr( old,
2020	new ast::UntypedExpr(
2021	old->location,
2022	GET_ACCEPT_1(function, Expr),
2023	GET_ACCEPT_V(args, Expr)
2024	)
2025	);
2026	}
2027
2028	virtual void visit( const NameExpr * old ) override final {
2029	this->node = visitBaseExpr( old,
2030	new ast::NameExpr(
2031	old->location,
2032	old->get_name()
2033	)
2034	);
2035	}
2036
2037	virtual void visit( const CastExpr * old ) override final {
2038	this->node = visitBaseExpr( old,
2039	new ast::CastExpr(
2040	old->location,
2041	GET_ACCEPT_1(arg, Expr),
2042	old->isGenerated ? ast::GeneratedCast : ast::ExplicitCast
2043	)
2044	);
2045	}
2046
2047	virtual void visit( const KeywordCastExpr * old) override final {
2048	ast::KeywordCastExpr::Target castTarget = ast::KeywordCastExpr::NUMBER_OF_TARGETS;
2049	switch (old->target) {
2050	case KeywordCastExpr::Coroutine:
2051	castTarget = ast::KeywordCastExpr::Coroutine;
2052	break;
2053	case KeywordCastExpr::Thread:
2054	castTarget = ast::KeywordCastExpr::Thread;
2055	break;
2056	case KeywordCastExpr::Monitor:
2057	castTarget = ast::KeywordCastExpr::Monitor;
2058	break;
2059	default:
2060	break;
2061	}
2062	assert ( castTarget < ast::KeywordCastExpr::NUMBER_OF_TARGETS );
2063	this->node = visitBaseExpr( old,
2064	new ast::KeywordCastExpr(
2065	old->location,
2066	GET_ACCEPT_1(arg, Expr),
2067	castTarget
2068	)
2069	);
2070	}
2071
2072	virtual void visit( const VirtualCastExpr * old ) override final {
2073	this->node = visitBaseExpr_SkipResultType( old,
2074	new ast::VirtualCastExpr(
2075	old->location,
2076	GET_ACCEPT_1(arg, Expr),
2077	GET_ACCEPT_1(result, Type)
2078	)
2079	);
2080	}
2081
2082	virtual void visit( const AddressExpr * old ) override final {
2083	this->node = visitBaseExpr( old,
2084	new ast::AddressExpr(
2085	old->location,
2086	GET_ACCEPT_1(arg, Expr)
2087	)
2088	);
2089	}
2090
2091	virtual void visit( const LabelAddressExpr * old ) override final {
2092	this->node = visitBaseExpr( old,
2093	new ast::LabelAddressExpr(
2094	old->location,
2095	make_label(&old->arg)
2096	)
2097	);
2098	}
2099
2100	virtual void visit( const UntypedMemberExpr * old ) override final {
2101	this->node = visitBaseExpr( old,
2102	new ast::UntypedMemberExpr(
2103	old->location,
2104	GET_ACCEPT_1(member, Expr),
2105	GET_ACCEPT_1(aggregate, Expr)
2106	)
2107	);
2108	}
2109
2110	virtual void visit( const MemberExpr * old ) override final {
2111	this->node = visitBaseExpr( old,
2112	new ast::MemberExpr(
2113	old->location,
2114	GET_ACCEPT_1(member, DeclWithType),
2115	GET_ACCEPT_1(aggregate, Expr)
2116	)
2117	);
2118	}
2119
2120	virtual void visit( const VariableExpr * old ) override final {
2121	auto expr = new ast::VariableExpr(
2122	old->location
2123	);
2124
2125	expr->var = GET_ACCEPT_1(var, DeclWithType);
2126	visitBaseExpr( old, expr );
2127
2128	this->node = expr;
2129	}
2130
2131	virtual void visit( const ConstantExpr * old ) override final {
2132	ast::ConstantExpr *rslt = new ast::ConstantExpr(
2133	old->location,
2134	GET_ACCEPT_1(result, Type),
2135	old->constant.rep,
2136	old->constant.ival
2137	);
2138	rslt->underlyer = getAccept1< ast::Type, Type* >( old->constant.type );
2139	this->node = visitBaseExpr( old, rslt );
2140	}
2141
2142	virtual void visit( const SizeofExpr * old ) override final {
2143	assert (old->expr \|\| old->type);
2144	assert (! (old->expr && old->type));
2145	ast::SizeofExpr *rslt;
2146	if (old->expr) {
2147	assert(!old->isType);
2148	rslt = new ast::SizeofExpr(
2149	old->location,
2150	GET_ACCEPT_1(expr, Expr)
2151	);
2152	}
2153	if (old->type) {
2154	assert(old->isType);
2155	rslt = new ast::SizeofExpr(
2156	old->location,
2157	GET_ACCEPT_1(type, Type)
2158	);
2159	}
2160	this->node = visitBaseExpr( old, rslt );
2161	}
2162
2163	virtual void visit( const AlignofExpr * old ) override final {
2164	assert (old->expr \|\| old->type);
2165	assert (! (old->expr && old->type));
2166	ast::AlignofExpr *rslt;
2167	if (old->expr) {
2168	assert(!old->isType);
2169	rslt = new ast::AlignofExpr(
2170	old->location,
2171	GET_ACCEPT_1(expr, Expr)
2172	);
2173	}
2174	if (old->type) {
2175	assert(old->isType);
2176	rslt = new ast::AlignofExpr(
2177	old->location,
2178	GET_ACCEPT_1(type, Type)
2179	);
2180	}
2181	this->node = visitBaseExpr( old, rslt );
2182	}
2183
2184	virtual void visit( const UntypedOffsetofExpr * old ) override final {
2185	this->node = visitBaseExpr( old,
2186	new ast::UntypedOffsetofExpr(
2187	old->location,
2188	GET_ACCEPT_1(type, Type),
2189	old->member
2190	)
2191	);
2192	}
2193
2194	virtual void visit( const OffsetofExpr * old ) override final {
2195	this->node = visitBaseExpr( old,
2196	new ast::OffsetofExpr(
2197	old->location,
2198	GET_ACCEPT_1(type, Type),
2199	GET_ACCEPT_1(member, DeclWithType)
2200	)
2201	);
2202	}
2203
2204	virtual void visit( const OffsetPackExpr * old ) override final {
2205	this->node = visitBaseExpr( old,
2206	new ast::OffsetPackExpr(
2207	old->location,
2208	GET_ACCEPT_1(type, StructInstType)
2209	)
2210	);
2211	}
2212
2213	virtual void visit( const LogicalExpr * old ) override final {
2214	this->node = visitBaseExpr( old,
2215	new ast::LogicalExpr(
2216	old->location,
2217	GET_ACCEPT_1(arg1, Expr),
2218	GET_ACCEPT_1(arg2, Expr),
2219	old->get_isAnd() ?
2220	ast::LogicalFlag::AndExpr :
2221	ast::LogicalFlag::OrExpr
2222	)
2223	);
2224	}
2225
2226	virtual void visit( const ConditionalExpr * old ) override final {
2227	this->node = visitBaseExpr( old,
2228	new ast::ConditionalExpr(
2229	old->location,
2230	GET_ACCEPT_1(arg1, Expr),
2231	GET_ACCEPT_1(arg2, Expr),
2232	GET_ACCEPT_1(arg3, Expr)
2233	)
2234	);
2235	}
2236
2237	virtual void visit( const CommaExpr * old ) override final {
2238	this->node = visitBaseExpr( old,
2239	new ast::CommaExpr(
2240	old->location,
2241	GET_ACCEPT_1(arg1, Expr),
2242	GET_ACCEPT_1(arg2, Expr)
2243	)
2244	);
2245	}
2246
2247	virtual void visit( const TypeExpr * old ) override final {
2248	this->node = visitBaseExpr( old,
2249	new ast::TypeExpr(
2250	old->location,
2251	GET_ACCEPT_1(type, Type)
2252	)
2253	);
2254	}
2255
2256	virtual void visit( const AsmExpr * old ) override final {
2257	this->node = visitBaseExpr( old,
2258	new ast::AsmExpr(
2259	old->location,
2260	GET_ACCEPT_1(inout, Expr),
2261	GET_ACCEPT_1(constraint, Expr),
2262	GET_ACCEPT_1(operand, Expr)
2263	)
2264	);
2265	}
2266
2267	virtual void visit( const ImplicitCopyCtorExpr * old ) override final {
2268	auto rslt = new ast::ImplicitCopyCtorExpr(
2269	old->location,
2270	GET_ACCEPT_1(callExpr, ApplicationExpr)
2271	);
2272
2273	this->node = visitBaseExpr( old, rslt );
2274	}
2275
2276	virtual void visit( const ConstructorExpr * old ) override final {
2277	this->node = visitBaseExpr( old,
2278	new ast::ConstructorExpr(
2279	old->location,
2280	GET_ACCEPT_1(callExpr, Expr)
2281	)
2282	);
2283	}
2284
2285	virtual void visit( const CompoundLiteralExpr * old ) override final {
2286	this->node = visitBaseExpr_SkipResultType( old,
2287	new ast::CompoundLiteralExpr(
2288	old->location,
2289	GET_ACCEPT_1(result, Type),
2290	GET_ACCEPT_1(initializer, Init)
2291	)
2292	);
2293	}
2294
2295	virtual void visit( const RangeExpr * old ) override final {
2296	this->node = visitBaseExpr( old,
2297	new ast::RangeExpr(
2298	old->location,
2299	GET_ACCEPT_1(low, Expr),
2300	GET_ACCEPT_1(high, Expr)
2301	)
2302	);
2303	}
2304
2305	virtual void visit( const UntypedTupleExpr * old ) override final {
2306	this->node = visitBaseExpr( old,
2307	new ast::UntypedTupleExpr(
2308	old->location,
2309	GET_ACCEPT_V(exprs, Expr)
2310	)
2311	);
2312	}
2313
2314	virtual void visit( const TupleExpr * old ) override final {
2315	this->node = visitBaseExpr( old,
2316	new ast::TupleExpr(
2317	old->location,
2318	GET_ACCEPT_V(exprs, Expr)
2319	)
2320	);
2321	}
2322
2323	virtual void visit( const TupleIndexExpr * old ) override final {
2324	this->node = visitBaseExpr( old,
2325	new ast::TupleIndexExpr(
2326	old->location,
2327	GET_ACCEPT_1(tuple, Expr),
2328	old->index
2329	)
2330	);
2331	}
2332
2333	virtual void visit( const TupleAssignExpr * old ) override final {
2334	this->node = visitBaseExpr_SkipResultType( old,
2335	new ast::TupleAssignExpr(
2336	old->location,
2337	GET_ACCEPT_1(result, Type),
2338	GET_ACCEPT_1(stmtExpr, StmtExpr)
2339	)
2340	);
2341	}
2342
2343	virtual void visit( const StmtExpr * old ) override final {
2344	auto rslt = new ast::StmtExpr(
2345	old->location,
2346	GET_ACCEPT_1(statements, CompoundStmt)
2347	);
2348	rslt->returnDecls = GET_ACCEPT_V(returnDecls, ObjectDecl);
2349	rslt->dtors = GET_ACCEPT_V(dtors , Expr);
2350
2351	this->node = visitBaseExpr_SkipResultType( old, rslt );
2352	}
2353
2354	virtual void visit( const UniqueExpr * old ) override final {
2355	auto rslt = new ast::UniqueExpr(
2356	old->location,
2357	GET_ACCEPT_1(expr, Expr),
2358	old->get_id()
2359	);
2360	rslt->object = GET_ACCEPT_1(object, ObjectDecl);
2361	rslt->var = GET_ACCEPT_1(var , VariableExpr);
2362
2363	this->node = visitBaseExpr( old, rslt );
2364	}
2365
2366	virtual void visit( const UntypedInitExpr * old ) override final {
2367	std::deque<ast::InitAlternative> initAlts;
2368	for (auto ia : old->initAlts) {
2369	initAlts.push_back(ast::InitAlternative(
2370	getAccept1< ast::Type, Type * >( ia.type ),
2371	getAccept1< ast::Designation, Designation * >( ia.designation )
2372	));
2373	}
2374	this->node = visitBaseExpr( old,
2375	new ast::UntypedInitExpr(
2376	old->location,
2377	GET_ACCEPT_1(expr, Expr),
2378	std::move(initAlts)
2379	)
2380	);
2381	}
2382
2383	virtual void visit( const InitExpr * old ) override final {
2384	this->node = visitBaseExpr( old,
2385	new ast::InitExpr(
2386	old->location,
2387	GET_ACCEPT_1(expr, Expr),
2388	GET_ACCEPT_1(designation, Designation)
2389	)
2390	);
2391	}
2392
2393	virtual void visit( const DeletedExpr * old ) override final {
2394	this->node = visitBaseExpr( old,
2395	new ast::DeletedExpr(
2396	old->location,
2397	GET_ACCEPT_1(expr, Expr),
2398	inCache(old->deleteStmt) ?
2399	this->node :
2400	GET_ACCEPT_1(deleteStmt, Node)
2401	)
2402	);
2403	}
2404
2405	virtual void visit( const DefaultArgExpr * old ) override final {
2406	this->node = visitBaseExpr( old,
2407	new ast::DefaultArgExpr(
2408	old->location,
2409	GET_ACCEPT_1(expr, Expr)
2410	)
2411	);
2412	}
2413
2414	virtual void visit( const GenericExpr * old ) override final {
2415	std::vector<ast::GenericExpr::Association> associations;
2416	for (auto association : old->associations) {
2417	associations.push_back(ast::GenericExpr::Association(
2418	getAccept1< ast::Type, Type * >( association.type ),
2419	getAccept1< ast::Expr, Expression * >( association.expr )
2420	));
2421	}
2422	this->node = visitBaseExpr( old,
2423	new ast::GenericExpr(
2424	old->location,
2425	GET_ACCEPT_1(control, Expr),
2426	std::move(associations)
2427	)
2428	);
2429	}
2430
2431	void visitType( const Type * old, ast::Type * type ) {
2432	// Some types do this in their constructor so add a check.
2433	if ( !old->attributes.empty() && type->attributes.empty() ) {
2434	type->attributes = GET_ACCEPT_V(attributes, Attribute);
2435	}
2436	this->node = type;
2437	}
2438
2439	virtual void visit( const VoidType * old ) override final {
2440	visitType( old, new ast::VoidType{ cv( old ) } );
2441	}
2442
2443	virtual void visit( const BasicType * old ) override final {
2444	auto type = new ast::BasicType{ (ast::BasicType::Kind)(unsigned)old->kind, cv( old ) };
2445	// I believe this should always be a BasicType.
2446	if ( Validate::SizeType == old ) {
2447	sizeType = type;
2448	}
2449	visitType( old, type );
2450	}
2451
2452	virtual void visit( const PointerType * old ) override final {
2453	visitType( old, new ast::PointerType{
2454	GET_ACCEPT_1( base, Type ),
2455	GET_ACCEPT_1( dimension, Expr ),
2456	(ast::LengthFlag)old->isVarLen,
2457	(ast::DimensionFlag)old->isStatic,
2458	cv( old )
2459	} );
2460	}
2461
2462	virtual void visit( const ArrayType * old ) override final {
2463	visitType( old, new ast::ArrayType{
2464	GET_ACCEPT_1( base, Type ),
2465	GET_ACCEPT_1( dimension, Expr ),
2466	(ast::LengthFlag)old->isVarLen,
2467	(ast::DimensionFlag)old->isStatic,
2468	cv( old )
2469	} );
2470	}
2471
2472	virtual void visit( const ReferenceType * old ) override final {
2473	visitType( old, new ast::ReferenceType{
2474	GET_ACCEPT_1( base, Type ),
2475	cv( old )
2476	} );
2477	}
2478
2479	virtual void visit( const QualifiedType * old ) override final {
2480	visitType( old, new ast::QualifiedType{
2481	GET_ACCEPT_1( parent, Type ),
2482	GET_ACCEPT_1( child, Type ),
2483	cv( old )
2484	} );
2485	}
2486
2487	virtual void visit( const FunctionType * old ) override final {
2488	auto ty = new ast::FunctionType {
2489	(ast::ArgumentFlag)old->isVarArgs,
2490	cv( old )
2491	};
2492	ty->returns = GET_ACCEPT_V( returnVals, DeclWithType );
2493	ty->params = GET_ACCEPT_V( parameters, DeclWithType );
2494	ty->forall = GET_ACCEPT_V( forall, TypeDecl );
2495	visitType( old, ty );
2496	}
2497
2498	void postvisit( const ReferenceToType * old, ast::ReferenceToType * ty ) {
2499	ty->forall = GET_ACCEPT_V( forall, TypeDecl );
2500	ty->params = GET_ACCEPT_V( parameters, Expr );
2501	ty->hoistType = old->hoistType;
2502	visitType( old, ty );
2503	}
2504
2505	virtual void visit( const StructInstType * old ) override final {
2506	ast::StructInstType * ty;
2507	if ( old->baseStruct ) {
2508	ty = new ast::StructInstType{
2509	GET_ACCEPT_1( baseStruct, StructDecl ),
2510	cv( old ),
2511	GET_ACCEPT_V( attributes, Attribute )
2512	};
2513	} else {
2514	ty = new ast::StructInstType{
2515	old->name,
2516	cv( old ),
2517	GET_ACCEPT_V( attributes, Attribute )
2518	};
2519	}
2520	postvisit( old, ty );
2521	}
2522
2523	virtual void visit( const UnionInstType * old ) override final {
2524	ast::UnionInstType * ty;
2525	if ( old->baseUnion ) {
2526	ty = new ast::UnionInstType{
2527	GET_ACCEPT_1( baseUnion, UnionDecl ),
2528	cv( old ),
2529	GET_ACCEPT_V( attributes, Attribute )
2530	};
2531	} else {
2532	ty = new ast::UnionInstType{
2533	old->name,
2534	cv( old ),
2535	GET_ACCEPT_V( attributes, Attribute )
2536	};
2537	}
2538	postvisit( old, ty );
2539	}
2540
2541	virtual void visit( const EnumInstType * old ) override final {
2542	ast::EnumInstType * ty;
2543	if ( old->baseEnum ) {
2544	ty = new ast::EnumInstType{
2545	GET_ACCEPT_1( baseEnum, EnumDecl ),
2546	cv( old ),
2547	GET_ACCEPT_V( attributes, Attribute )
2548	};
2549	} else {
2550	ty = new ast::EnumInstType{
2551	old->name,
2552	cv( old ),
2553	GET_ACCEPT_V( attributes, Attribute )
2554	};
2555	}
2556	postvisit( old, ty );
2557	}
2558
2559	virtual void visit( const TraitInstType * old ) override final {
2560	ast::TraitInstType * ty;
2561	if ( old->baseTrait ) {
2562	ty = new ast::TraitInstType{
2563	GET_ACCEPT_1( baseTrait, TraitDecl ),
2564	cv( old ),
2565	GET_ACCEPT_V( attributes, Attribute )
2566	};
2567	} else {
2568	ty = new ast::TraitInstType{
2569	old->name,
2570	cv( old ),
2571	GET_ACCEPT_V( attributes, Attribute )
2572	};
2573	}
2574	postvisit( old, ty );
2575	}
2576
2577	virtual void visit( const TypeInstType * old ) override final {
2578	ast::TypeInstType * ty;
2579	if ( old->baseType ) {
2580	ty = new ast::TypeInstType{
2581	old->name,
2582	GET_ACCEPT_1( baseType, TypeDecl ),
2583	cv( old ),
2584	GET_ACCEPT_V( attributes, Attribute )
2585	};
2586	} else {
2587	ty = new ast::TypeInstType{
2588	old->name,
2589	old->isFtype ? ast::TypeVar::Ftype : ast::TypeVar::Dtype,
2590	cv( old ),
2591	GET_ACCEPT_V( attributes, Attribute )
2592	};
2593	}
2594	postvisit( old, ty );
2595	}
2596
2597	virtual void visit( const TupleType * old ) override final {
2598	visitType( old, new ast::TupleType{
2599	GET_ACCEPT_V( types, Type ),
2600	// members generated by TupleType c'tor
2601	cv( old )
2602	} );
2603	}
2604
2605	virtual void visit( const TypeofType * old ) override final {
2606	visitType( old, new ast::TypeofType{
2607	GET_ACCEPT_1( expr, Expr ),
2608	(ast::TypeofType::Kind)old->is_basetypeof,
2609	cv( old )
2610	} );
2611	}
2612
2613	virtual void visit( const AttrType * ) override final {
2614	assertf( false, "AttrType deprecated in new AST." );
2615	}
2616
2617	virtual void visit( const VarArgsType * old ) override final {
2618	visitType( old, new ast::VarArgsType{ cv( old ) } );
2619	}
2620
2621	virtual void visit( const ZeroType * old ) override final {
2622	visitType( old, new ast::ZeroType{ cv( old ) } );
2623	}
2624
2625	virtual void visit( const OneType * old ) override final {
2626	visitType( old, new ast::OneType{ cv( old ) } );
2627	}
2628
2629	virtual void visit( const GlobalScopeType * old ) override final {
2630	visitType( old, new ast::GlobalScopeType{} );
2631	}
2632
2633	virtual void visit( const Designation * old ) override final {
2634	this->node = new ast::Designation(
2635	old->location,
2636	GET_ACCEPT_D(designators, Expr)
2637	);
2638	}
2639
2640	virtual void visit( const SingleInit * old ) override final {
2641	this->node = new ast::SingleInit(
2642	old->location,
2643	GET_ACCEPT_1(value, Expr),
2644	(old->get_maybeConstructed()) ? ast::MaybeConstruct : ast::DoConstruct
2645	);
2646	}
2647
2648	virtual void visit( const ListInit * old ) override final {
2649	this->node = new ast::ListInit(
2650	old->location,
2651	GET_ACCEPT_V(initializers, Init),
2652	GET_ACCEPT_V(designations, Designation),
2653	(old->get_maybeConstructed()) ? ast::MaybeConstruct : ast::DoConstruct
2654	);
2655	}
2656
2657	virtual void visit( const ConstructorInit * old ) override final {
2658	this->node = new ast::ConstructorInit(
2659	old->location,
2660	GET_ACCEPT_1(ctor, Stmt),
2661	GET_ACCEPT_1(dtor, Stmt),
2662	GET_ACCEPT_1(init, Init)
2663	);
2664	}
2665
2666	virtual void visit( const Constant * ) override final {
2667	// Handled in visit( ConstantEpxr * ).
2668	// In the new tree, Constant fields are inlined into containing ConstantExpression.
2669	assert( 0 );
2670	}
2671
2672	virtual void visit( const Attribute * old ) override final {
2673	this->node = new ast::Attribute(
2674	old->name,
2675	GET_ACCEPT_V( parameters, Expr )
2676	);
2677	}
2678
2679	virtual void visit( const AttrExpr * ) override final {
2680	assertf( false, "AttrExpr deprecated in new AST." );
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: