Context Navigation

source: src/AST/Convert.cpp@ 4b464b51

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 4b464b51 was 665f432, checked in by Thierry Delisle <tdelisle@…>, 6 years ago
Fixed trac #149 where operand names in asm statements where incorrectly resolved (i.e., should not have been resolved)
Property mode set to `100644`
File size: 71.8 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 : Thu Jul 25 22:21:46 2019
13	// Update Count : 13
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::Decl * 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	declPostamble( stmt, node );
527	return nullptr;
528	}
529
530	const ast::NullStmt * visit( const ast::NullStmt * node ) override final {
531	if ( inCache( node ) ) return nullptr;
532	auto stmt = new NullStmt();
533	stmtPostamble( stmt, node );
534	return nullptr;
535	}
536
537	const ast::Stmt * visit( const ast::DeclStmt * node ) override final {
538	if ( inCache( node ) ) return nullptr;
539	auto stmt = new DeclStmt( get<Declaration>().accept1( node->decl ) );
540	return stmtPostamble( stmt, node );
541	}
542
543	const ast::Stmt * visit( const ast::ImplicitCtorDtorStmt * node ) override final {
544	if ( inCache( node ) ) return nullptr;
545	auto stmt = new ImplicitCtorDtorStmt{
546	get<Statement>().accept1( node->callStmt )
547	};
548	return stmtPostamble( stmt, node );
549	}
550
551	TypeSubstitution * convertTypeSubstitution(const ast::TypeSubstitution * src) {
552
553	if (!src) return nullptr;
554
555	TypeSubstitution *rslt = new TypeSubstitution();
556
557	for (decltype(src->begin()) src_i = src->begin(); src_i != src->end(); src_i++) {
558	rslt->add( src_i->first,
559	get<Type>().accept1(src_i->second) );
560	}
561
562	for (decltype(src->beginVar()) src_i = src->beginVar(); src_i != src->endVar(); src_i++) {
563	rslt->addVar( src_i->first,
564	get<Expression>().accept1(src_i->second) );
565	}
566
567	return rslt;
568	}
569
570	void convertInferUnion(std::map<UniqueId,ParamEntry> &tgtInferParams,
571	std::vector<UniqueId> &tgtResnSlots,
572	const ast::Expr::InferUnion &srcInferred ) {
573
574	assert( tgtInferParams.empty() );
575	assert( tgtResnSlots.empty() );
576
577	if ( srcInferred.mode == ast::Expr::InferUnion::Params ) {
578	const ast::InferredParams &srcParams = srcInferred.inferParams();
579	for (auto & srcParam : srcParams) {
580	auto res = tgtInferParams.emplace(srcParam.first, ParamEntry(
581	srcParam.second.decl,
582	get<Declaration>().accept1(srcParam.second.declptr),
583	get<Type>().accept1(srcParam.second.actualType),
584	get<Type>().accept1(srcParam.second.formalType),
585	get<Expression>().accept1(srcParam.second.expr)
586	));
587	assert(res.second);
588	}
589	} else if ( srcInferred.mode == ast::Expr::InferUnion::Slots ) {
590	const ast::ResnSlots &srcSlots = srcInferred.resnSlots();
591	for (auto srcSlot : srcSlots) {
592	tgtResnSlots.push_back(srcSlot);
593	}
594	}
595	}
596
597	Expression * visitBaseExpr_skipResultType(const ast::Expr * src, Expression * tgt) {
598
599	tgt->location = src->location;
600	tgt->env = convertTypeSubstitution(src->env);
601	tgt->extension = src->extension;
602
603	convertInferUnion(tgt->inferParams, tgt->resnSlots, src->inferred);
604	return tgt;
605	}
606
607	Expression * visitBaseExpr(const ast::Expr * src, Expression * tgt) {
608
609	tgt->result = get<Type>().accept1(src->result);
610	return visitBaseExpr_skipResultType(src, tgt);
611	}
612
613	const ast::Expr * visit( const ast::ApplicationExpr * node ) override final {
614	auto expr = visitBaseExpr( node,
615	new ApplicationExpr(
616	get<Expression>().accept1(node->func),
617	get<Expression>().acceptL(node->args)
618	)
619	);
620	this->node = expr;
621	return nullptr;
622	}
623
624	const ast::Expr * visit( const ast::UntypedExpr * node ) override final {
625	auto expr = visitBaseExpr( node,
626	new UntypedExpr(
627	get<Expression>().accept1(node->func),
628	get<Expression>().acceptL(node->args)
629	)
630	);
631	this->node = expr;
632	return nullptr;
633	}
634
635	const ast::Expr * visit( const ast::NameExpr * node ) override final {
636	auto expr = visitBaseExpr( node,
637	new NameExpr(
638	node->name
639	)
640	);
641	this->node = expr;
642	return nullptr;
643	}
644
645	const ast::Expr * visit( const ast::AddressExpr * node ) override final {
646	auto expr = visitBaseExpr( node,
647	new AddressExpr(
648	get<Expression>().accept1(node->arg)
649	)
650	);
651	this->node = expr;
652	return nullptr;
653	}
654
655	const ast::Expr * visit( const ast::LabelAddressExpr * node ) override final {
656	auto expr = visitBaseExpr( node,
657	new LabelAddressExpr(
658	makeLabel(nullptr, node->arg)
659	)
660	);
661	this->node = expr;
662	return nullptr;
663	}
664
665	const ast::Expr * visit( const ast::CastExpr * node ) override final {
666	auto expr = visitBaseExpr( node,
667	new CastExpr(
668	get<Expression>().accept1(node->arg),
669	(node->isGenerated == ast::GeneratedCast)
670	)
671	);
672	this->node = expr;
673	return nullptr;
674	}
675
676	const ast::Expr * visit( const ast::KeywordCastExpr * node ) override final {
677	KeywordCastExpr::Target castTarget = KeywordCastExpr::NUMBER_OF_TARGETS;
678	switch (node->target) {
679	case ast::KeywordCastExpr::Coroutine:
680	castTarget = KeywordCastExpr::Coroutine;
681	break;
682	case ast::KeywordCastExpr::Thread:
683	castTarget = KeywordCastExpr::Thread;
684	break;
685	case ast::KeywordCastExpr::Monitor:
686	castTarget = KeywordCastExpr::Monitor;
687	break;
688	default:
689	break;
690	}
691	assert ( castTarget < KeywordCastExpr::NUMBER_OF_TARGETS );
692	auto expr = visitBaseExpr( node,
693	new KeywordCastExpr(
694	get<Expression>().accept1(node->arg),
695	castTarget
696	)
697	);
698	this->node = expr;
699	return nullptr;
700	}
701
702	const ast::Expr * visit( const ast::VirtualCastExpr * node ) override final {
703	auto expr = visitBaseExpr_skipResultType( node,
704	new VirtualCastExpr(
705	get<Expression>().accept1(node->arg),
706	get<Type>().accept1(node->result)
707	)
708	);
709	this->node = expr;
710	return nullptr;
711	}
712
713	const ast::Expr * visit( const ast::UntypedMemberExpr * node ) override final {
714	auto expr = visitBaseExpr( node,
715	new UntypedMemberExpr(
716	get<Expression>().accept1(node->member),
717	get<Expression>().accept1(node->aggregate)
718	)
719	);
720	this->node = expr;
721	return nullptr;
722	}
723
724	const ast::Expr * visit( const ast::MemberExpr * node ) override final {
725	auto expr = visitBaseExpr( node,
726	new MemberExpr(
727	get<DeclarationWithType>().accept1(node->member),
728	get<Expression>().accept1(node->aggregate)
729	)
730	);
731	this->node = expr;
732	return nullptr;
733	}
734
735	const ast::Expr * visit( const ast::VariableExpr * node ) override final {
736	auto expr = new VariableExpr();
737	expr->var = get<DeclarationWithType>().accept1(node->var);
738	visitBaseExpr( node, expr );
739	this->node = expr;
740	return nullptr;
741	}
742
743	const ast::Expr * visit( const ast::ConstantExpr * node ) override final {
744	// Old world: two types: rslt->constant.type, rslt->result
745	// New workd: one public type: node->result, plus node->underlyer only to support roundtrip conversion
746	// preserving underlyer because the correct type for string literals is complicated to construct,
747	// and distinguishing a string from other literals using the type is hard to do accurately
748	// Both worlds: the outer, expression-level type can change during resolution
749	// for a string, that's char[k] before-resolve and char * after
750	// Old world: the inner Constant type stays what it was built with
751	// for a string, that's char[k] always
752	// Both worlds: the "rep" field of a constant is the C source file fragment that compiles to the desired value
753	// for a string, that includes outer quotes, backslashes, et al cases from the Literals test
754	ConstantExpr *rslt = new ConstantExpr(Constant(
755	get<Type>().accept1(node->underlyer),
756	node->rep,
757	node->ival));
758	auto expr = visitBaseExpr( node, rslt );
759	this->node = expr;
760	return nullptr;
761	}
762
763	const ast::Expr * visit( const ast::SizeofExpr * node ) override final {
764	assert (node->expr \|\| node->type);
765	assert (! (node->expr && node->type));
766	SizeofExpr *rslt;
767	if (node->expr) {
768	rslt = new SizeofExpr(
769	get<Expression>().accept1(node->expr)
770	);
771	assert (!rslt->isType);
772	}
773	else {
774	assert(node->type);
775	rslt = new SizeofExpr(
776	get<Type>().accept1(node->type)
777	);
778	assert (rslt->isType);
779	}
780	auto expr = visitBaseExpr( node, rslt );
781	this->node = expr;
782	return nullptr;
783	}
784
785	const ast::Expr * visit( const ast::AlignofExpr * node ) override final {
786	assert (node->expr \|\| node->type);
787	assert (! (node->expr && node->type));
788	AlignofExpr *rslt;
789	if (node->expr) {
790	rslt = new AlignofExpr(
791	get<Expression>().accept1(node->expr)
792	);
793	assert (!rslt->isType);
794	}
795	else {
796	assert(node->type);
797	rslt = new AlignofExpr(
798	get<Type>().accept1(node->type)
799	);
800	assert (rslt->isType);
801	}
802	auto expr = visitBaseExpr( node, rslt );
803	this->node = expr;
804	return nullptr;
805	}
806
807	const ast::Expr * visit( const ast::UntypedOffsetofExpr * node ) override final {
808	auto expr = visitBaseExpr( node,
809	new UntypedOffsetofExpr(
810	get<Type>().accept1(node->type),
811	node->member
812	)
813	);
814	this->node = expr;
815	return nullptr;
816	}
817
818	const ast::Expr * visit( const ast::OffsetofExpr * node ) override final {
819	auto expr = visitBaseExpr( node,
820	new OffsetofExpr(
821	get<Type>().accept1(node->type),
822	get<DeclarationWithType>().accept1(node->member)
823	)
824	);
825	this->node = expr;
826	return nullptr;
827	}
828
829	const ast::Expr * visit( const ast::OffsetPackExpr * node ) override final {
830	auto expr = visitBaseExpr( node,
831	new OffsetPackExpr(
832	get<StructInstType>().accept1(node->type)
833	)
834	);
835	this->node = expr;
836	return nullptr;
837	}
838
839	const ast::Expr * visit( const ast::LogicalExpr * node ) override final {
840	assert (node->isAnd == ast::LogicalFlag::AndExpr \|\|
841	node->isAnd == ast::LogicalFlag::OrExpr );
842	auto expr = visitBaseExpr( node,
843	new LogicalExpr(
844	get<Expression>().accept1(node->arg1),
845	get<Expression>().accept1(node->arg2),
846	(node->isAnd == ast::LogicalFlag::AndExpr)
847	)
848	);
849	this->node = expr;
850	return nullptr;
851	}
852
853	const ast::Expr * visit( const ast::ConditionalExpr * node ) override final {
854	auto expr = visitBaseExpr( node,
855	new ConditionalExpr(
856	get<Expression>().accept1(node->arg1),
857	get<Expression>().accept1(node->arg2),
858	get<Expression>().accept1(node->arg3)
859	)
860	);
861	this->node = expr;
862	return nullptr;
863	}
864
865	const ast::Expr * visit( const ast::CommaExpr * node ) override final {
866	auto expr = visitBaseExpr( node,
867	new CommaExpr(
868	get<Expression>().accept1(node->arg1),
869	get<Expression>().accept1(node->arg2)
870	)
871	);
872	this->node = expr;
873	return nullptr;
874	}
875
876	const ast::Expr * visit( const ast::TypeExpr * node ) override final {
877	auto expr = visitBaseExpr( node,
878	new TypeExpr(
879	get<Type>().accept1(node->type)
880	)
881	);
882	this->node = expr;
883	return nullptr;
884	}
885
886	const ast::Expr * visit( const ast::AsmExpr * node ) override final {
887	auto expr = visitBaseExpr( node,
888	new AsmExpr(
889	new std::string(node->inout),
890	get<Expression>().accept1(node->constraint),
891	get<Expression>().accept1(node->operand)
892	)
893	);
894	this->node = expr;
895	return nullptr;
896	}
897
898	const ast::Expr * visit( const ast::ImplicitCopyCtorExpr * node ) override final {
899	auto rslt = new ImplicitCopyCtorExpr(
900	get<ApplicationExpr>().accept1(node->callExpr)
901	);
902
903	auto expr = visitBaseExpr( node, rslt );
904	this->node = expr;
905	return nullptr;
906	}
907
908	const ast::Expr * visit( const ast::ConstructorExpr * node ) override final {
909	auto expr = visitBaseExpr( node,
910	new ConstructorExpr(
911	get<Expression>().accept1(node->callExpr)
912	)
913	);
914	this->node = expr;
915	return nullptr;
916	}
917
918	const ast::Expr * visit( const ast::CompoundLiteralExpr * node ) override final {
919	auto expr = visitBaseExpr_skipResultType( node,
920	new CompoundLiteralExpr(
921	get<Type>().accept1(node->result),
922	get<Initializer>().accept1(node->init)
923	)
924	);
925	this->node = expr;
926	return nullptr;
927	}
928
929	const ast::Expr * visit( const ast::RangeExpr * node ) override final {
930	auto expr = visitBaseExpr( node,
931	new RangeExpr(
932	get<Expression>().accept1(node->low),
933	get<Expression>().accept1(node->high)
934	)
935	);
936	this->node = expr;
937	return nullptr;
938	}
939
940	const ast::Expr * visit( const ast::UntypedTupleExpr * node ) override final {
941	auto expr = visitBaseExpr( node,
942	new UntypedTupleExpr(
943	get<Expression>().acceptL(node->exprs)
944	)
945	);
946	this->node = expr;
947	return nullptr;
948	}
949
950	const ast::Expr * visit( const ast::TupleExpr * node ) override final {
951	auto expr = visitBaseExpr( node,
952	new TupleExpr(
953	get<Expression>().acceptL(node->exprs)
954	)
955	);
956	this->node = expr;
957	return nullptr;
958	}
959
960	const ast::Expr * visit( const ast::TupleIndexExpr * node ) override final {
961	auto expr = visitBaseExpr( node,
962	new TupleIndexExpr(
963	get<Expression>().accept1(node->tuple),
964	node->index
965	)
966	);
967	this->node = expr;
968	return nullptr;
969	}
970
971	const ast::Expr * visit( const ast::TupleAssignExpr * node ) override final {
972	auto expr = visitBaseExpr( node,
973	new TupleAssignExpr(
974	get<StmtExpr>().accept1(node->stmtExpr)
975	)
976	);
977	this->node = expr;
978	return nullptr;
979	}
980
981	const ast::Expr * visit( const ast::StmtExpr * node ) override final {
982	auto rslt = new StmtExpr(
983	get<CompoundStmt>().accept1(node->stmts)
984	);
985
986	rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
987	rslt->dtors = get<Expression>().acceptL(node->dtors);
988
989	auto expr = visitBaseExpr( node, rslt );
990	this->node = expr;
991	return nullptr;
992	}
993
994	const ast::Expr * visit( const ast::UniqueExpr * node ) override final {
995	auto rslt = new UniqueExpr(
996	get<Expression>().accept1(node->expr),
997	node->id
998	);
999
1000	rslt->object = get<ObjectDecl> ().accept1(node->object);
1001	rslt->var = get<VariableExpr>().accept1(node->var);
1002
1003	auto expr = visitBaseExpr( node, rslt );
1004	this->node = expr;
1005	return nullptr;
1006	}
1007
1008	const ast::Expr * visit( const ast::UntypedInitExpr * node ) override final {
1009	std::list<InitAlternative> initAlts;
1010	for (auto ia : node->initAlts) {
1011	initAlts.push_back(InitAlternative(
1012	get<Type> ().accept1(ia.type),
1013	get<Designation>().accept1(ia.designation)
1014	));
1015	}
1016	auto expr = visitBaseExpr( node,
1017	new UntypedInitExpr(
1018	get<Expression>().accept1(node->expr),
1019	initAlts
1020	)
1021	);
1022	this->node = expr;
1023	return nullptr;
1024	}
1025
1026	const ast::Expr * visit( const ast::InitExpr * node ) override final {
1027	auto expr = visitBaseExpr( node,
1028	new InitExpr(
1029	get<Expression>().accept1(node->expr),
1030	get<Designation>().accept1(node->designation)
1031	)
1032	);
1033	this->node = expr;
1034	return nullptr;
1035	}
1036
1037	const ast::Expr * visit( const ast::DeletedExpr * node ) override final {
1038	auto expr = visitBaseExpr( node,
1039	new DeletedExpr(
1040	get<Expression>().accept1(node->expr),
1041	inCache(node->deleteStmt) ?
1042	strict_dynamic_cast<Declaration*>(this->node) :
1043	get<Declaration>().accept1(node->deleteStmt)
1044	)
1045	);
1046	this->node = expr;
1047	return nullptr;
1048	}
1049
1050	const ast::Expr * visit( const ast::DefaultArgExpr * node ) override final {
1051	auto expr = visitBaseExpr( node,
1052	new DefaultArgExpr(
1053	get<Expression>().accept1(node->expr)
1054	)
1055	);
1056	this->node = expr;
1057	return nullptr;
1058	}
1059
1060	const ast::Expr * visit( const ast::GenericExpr * node ) override final {
1061	std::list<GenericExpr::Association> associations;
1062	for (auto association : node->associations) {
1063	associations.push_back(GenericExpr::Association(
1064	get<Type> ().accept1(association.type),
1065	get<Expression>().accept1(association.expr)
1066	));
1067	}
1068	auto expr = visitBaseExpr( node,
1069	new GenericExpr(
1070	get<Expression>().accept1(node->control),
1071	associations
1072	)
1073	);
1074	this->node = expr;
1075	return nullptr;
1076	}
1077
1078	const ast::Type * visitType( const ast::Type * node, Type * type ) {
1079	// Some types do this in their constructor so add a check.
1080	if ( !node->attributes.empty() && type->attributes.empty() ) {
1081	type->attributes = get<Attribute>().acceptL( node->attributes );
1082	}
1083	this->node = type;
1084	return nullptr;
1085	}
1086
1087	const ast::Type * visit( const ast::VoidType * node ) override final {
1088	return visitType( node, new VoidType{ cv( node ) } );
1089	}
1090
1091	const ast::Type * visit( const ast::BasicType * node ) override final {
1092	auto type = new BasicType{ cv( node ), (BasicType::Kind)(unsigned)node->kind };
1093	// I believe this should always be a BasicType.
1094	if ( sizeType == node ) {
1095	Validate::SizeType = type;
1096	}
1097	return visitType( node, type );
1098	}
1099
1100	const ast::Type * visit( const ast::PointerType * node ) override final {
1101	return visitType( node, new PointerType{
1102	cv( node ),
1103	get<Type>().accept1( node->base ),
1104	get<Expression>().accept1( node->dimension ),
1105	(bool)node->isVarLen,
1106	(bool)node->isStatic
1107	} );
1108	}
1109
1110	const ast::Type * visit( const ast::ArrayType * node ) override final {
1111	return visitType( node, new ArrayType{
1112	cv( node ),
1113	get<Type>().accept1( node->base ),
1114	get<Expression>().accept1( node->dimension ),
1115	(bool)node->isVarLen,
1116	(bool)node->isStatic
1117	} );
1118	}
1119
1120	const ast::Type * visit( const ast::ReferenceType * node ) override final {
1121	return visitType( node, new ReferenceType{
1122	cv( node ),
1123	get<Type>().accept1( node->base )
1124	} );
1125	}
1126
1127	const ast::Type * visit( const ast::QualifiedType * node ) override final {
1128	return visitType( node, new QualifiedType{
1129	cv( node ),
1130	get<Type>().accept1( node->parent ),
1131	get<Type>().accept1( node->child )
1132	} );
1133	}
1134
1135	const ast::Type * visit( const ast::FunctionType * node ) override final {
1136	auto ty = new FunctionType {
1137	cv( node ),
1138	(bool)node->isVarArgs
1139	};
1140	ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
1141	ty->parameters = get<DeclarationWithType>().acceptL( node->params );
1142	ty->forall = get<TypeDecl>().acceptL( node->forall );
1143	return visitType( node, ty );
1144	}
1145
1146	const ast::Type * postvisit( const ast::ReferenceToType * old, ReferenceToType * ty ) {
1147	ty->forall = get<TypeDecl>().acceptL( old->forall );
1148	ty->parameters = get<Expression>().acceptL( old->params );
1149	ty->hoistType = old->hoistType;
1150	return visitType( old, ty );
1151	}
1152
1153	const ast::Type * visit( const ast::StructInstType * node ) override final {
1154	StructInstType * ty;
1155	if ( node->base ) {
1156	ty = new StructInstType{
1157	cv( node ),
1158	get<StructDecl>().accept1( node->base ),
1159	get<Attribute>().acceptL( node->attributes )
1160	};
1161	} else {
1162	ty = new StructInstType{
1163	cv( node ),
1164	node->name,
1165	get<Attribute>().acceptL( node->attributes )
1166	};
1167	}
1168	return postvisit( node, ty );
1169	}
1170
1171	const ast::Type * visit( const ast::UnionInstType * node ) override final {
1172	UnionInstType * ty;
1173	if ( node->base ) {
1174	ty = new UnionInstType{
1175	cv( node ),
1176	get<UnionDecl>().accept1( node->base ),
1177	get<Attribute>().acceptL( node->attributes )
1178	};
1179	} else {
1180	ty = new UnionInstType{
1181	cv( node ),
1182	node->name,
1183	get<Attribute>().acceptL( node->attributes )
1184	};
1185	}
1186	return postvisit( node, ty );
1187	}
1188
1189	const ast::Type * visit( const ast::EnumInstType * node ) override final {
1190	EnumInstType * ty;
1191	if ( node->base ) {
1192	ty = new EnumInstType{
1193	cv( node ),
1194	get<EnumDecl>().accept1( node->base ),
1195	get<Attribute>().acceptL( node->attributes )
1196	};
1197	} else {
1198	ty = new EnumInstType{
1199	cv( node ),
1200	node->name,
1201	get<Attribute>().acceptL( node->attributes )
1202	};
1203	}
1204	return postvisit( node, ty );
1205	}
1206
1207	const ast::Type * visit( const ast::TraitInstType * node ) override final {
1208	TraitInstType * ty;
1209	if ( node->base ) {
1210	ty = new TraitInstType{
1211	cv( node ),
1212	get<TraitDecl>().accept1( node->base ),
1213	get<Attribute>().acceptL( node->attributes )
1214	};
1215	} else {
1216	ty = new TraitInstType{
1217	cv( node ),
1218	node->name,
1219	get<Attribute>().acceptL( node->attributes )
1220	};
1221	}
1222	return postvisit( node, ty );
1223	}
1224
1225	const ast::Type * visit( const ast::TypeInstType * node ) override final {
1226	TypeInstType * ty;
1227	if ( node->base ) {
1228	ty = new TypeInstType{
1229	cv( node ),
1230	node->name,
1231	get<TypeDecl>().accept1( node->base ),
1232	get<Attribute>().acceptL( node->attributes )
1233	};
1234	} else {
1235	ty = new TypeInstType{
1236	cv( node ),
1237	node->name,
1238	node->kind == ast::TypeVar::Ftype,
1239	get<Attribute>().acceptL( node->attributes )
1240	};
1241	}
1242	return postvisit( node, ty );
1243	}
1244
1245	const ast::Type * visit( const ast::TupleType * node ) override final {
1246	return visitType( node, new TupleType{
1247	cv( node ),
1248	get<Type>().acceptL( node->types )
1249	// members generated by TupleType c'tor
1250	} );
1251	}
1252
1253	const ast::Type * visit( const ast::TypeofType * node ) override final {
1254	return visitType( node, new TypeofType{
1255	cv( node ),
1256	get<Expression>().accept1( node->expr ),
1257	(bool)node->kind
1258	} );
1259	}
1260
1261	const ast::Type * visit( const ast::VarArgsType * node ) override final {
1262	return visitType( node, new VarArgsType{ cv( node ) } );
1263	}
1264
1265	const ast::Type * visit( const ast::ZeroType * node ) override final {
1266	return visitType( node, new ZeroType{ cv( node ) } );
1267	}
1268
1269	const ast::Type * visit( const ast::OneType * node ) override final {
1270	return visitType( node, new OneType{ cv( node ) } );
1271	}
1272
1273	const ast::Type * visit( const ast::GlobalScopeType * node ) override final {
1274	return visitType( node, new GlobalScopeType{} );
1275	}
1276
1277	const ast::Designation * visit( const ast::Designation * node ) override final {
1278	auto designation = new Designation( get<Expression>().acceptL( node->designators ) );
1279	designation->location = node->location;
1280	this->node = designation;
1281	return nullptr;
1282	}
1283
1284	const ast::Init * visit( const ast::SingleInit * node ) override final {
1285	auto init = new SingleInit(
1286	get<Expression>().accept1( node->value ),
1287	ast::MaybeConstruct == node->maybeConstructed
1288	);
1289	init->location = node->location;
1290	this->node = init;
1291	return nullptr;
1292	}
1293
1294	const ast::Init * visit( const ast::ListInit * node ) override final {
1295	auto init = new ListInit(
1296	get<Initializer>().acceptL( node->initializers ),
1297	get<Designation>().acceptL( node->designations ),
1298	ast::MaybeConstruct == node->maybeConstructed
1299	);
1300	init->location = node->location;
1301	this->node = init;
1302	return nullptr;
1303	}
1304
1305	const ast::Init * visit( const ast::ConstructorInit * node ) override final {
1306	auto init = new ConstructorInit(
1307	get<Statement>().accept1( node->ctor ),
1308	get<Statement>().accept1( node->dtor ),
1309	get<Initializer>().accept1( node->init )
1310	);
1311	init->location = node->location;
1312	this->node = init;
1313	return nullptr;
1314	}
1315
1316	const ast::Attribute * visit( const ast::Attribute * node ) override final {
1317	auto attr = new Attribute(
1318	node->name,
1319	get<Expression>().acceptL(node->params)
1320	);
1321	this->node = attr;
1322	return nullptr;
1323	}
1324
1325	const ast::TypeSubstitution * visit( const ast::TypeSubstitution * node ) override final {
1326	// Handled by convertTypeSubstitution helper instead.
1327	// TypeSubstitution is not a node in the old model, so the conversion result wouldn't fit in this->node.
1328	assert( 0 );
1329	(void)node;
1330	return nullptr;
1331	}
1332	};
1333
1334	std::list< Declaration * > convert( const std::list< ast::ptr< ast::Decl > > && translationUnit ) {
1335	ConverterNewToOld c;
1336	std::list< Declaration * > decls;
1337	for(auto d : translationUnit) {
1338	decls.emplace_back( c.decl( d ) );
1339	}
1340	return decls;
1341	}
1342
1343	//================================================================================================
1344
1345	class ConverterOldToNew : public Visitor {
1346	public:
1347	ast::Decl * decl() {
1348	return strict_dynamic_cast< ast::Decl * >( node );
1349	}
1350
1351	ConverterOldToNew() = default;
1352	ConverterOldToNew(const ConverterOldToNew &) = delete;
1353	ConverterOldToNew(ConverterOldToNew &&) = delete;
1354	private:
1355	/// conversion output
1356	ast::Node * node = nullptr;
1357	/// cache of nodes that might be referenced by readonly<> for de-duplication
1358	std::unordered_map< const BaseSyntaxNode , ast::Node > cache = {};
1359
1360	// Local Utilities:
1361
1362	template<typename NewT, typename OldT>
1363	NewT * getAccept1( OldT old ) {
1364	if ( ! old ) return nullptr;
1365	old->accept(*this);
1366	ast::Node * ret = node;
1367	node = nullptr;
1368	return strict_dynamic_cast< NewT * >( ret );
1369	}
1370
1371	# define GET_ACCEPT_1(child, type) \
1372	getAccept1< ast::type, decltype( old->child ) >( old->child )
1373
1374	template<typename NewT, typename OldC>
1375	std::vector< ast::ptr<NewT> > getAcceptV( const OldC& old ) {
1376	std::vector< ast::ptr<NewT> > ret;
1377	ret.reserve( old.size() );
1378	for ( auto a : old ) {
1379	a->accept( *this );
1380	ret.emplace_back( strict_dynamic_cast< NewT * >(node) );
1381	node = nullptr;
1382	}
1383	return ret;
1384	}
1385
1386	# define GET_ACCEPT_V(child, type) \
1387	getAcceptV< ast::type, decltype( old->child ) >( old->child )
1388
1389	template<typename NewT, typename OldC>
1390	std::deque< ast::ptr<NewT> > getAcceptD( const OldC& old ) {
1391	std::deque< ast::ptr<NewT> > ret;
1392	for ( auto a : old ) {
1393	a->accept( *this );
1394	ret.emplace_back( strict_dynamic_cast< NewT * >(node) );
1395	node = nullptr;
1396	}
1397	return ret;
1398	}
1399
1400	# define GET_ACCEPT_D(child, type) \
1401	getAcceptD< ast::type, decltype( old->child ) >( old->child )
1402
1403	ast::Label make_label(const Label* old) {
1404	CodeLocation const & location =
1405	( old->labelled ) ? old->labelled->location : CodeLocation();
1406	return ast::Label(
1407	location,
1408	old->name,
1409	GET_ACCEPT_V(attributes, Attribute)
1410	);
1411	}
1412
1413	template<template <class...> class C>
1414	C<ast::Label> make_labels(C<Label> olds) {
1415	C<ast::Label> ret;
1416	for (auto oldn : olds) {
1417	ret.push_back( make_label( &oldn ) );
1418	}
1419	return ret;
1420	}
1421
1422	# define GET_LABELS_V(labels) \
1423	to<std::vector>::from( make_labels( std::move( labels ) ) )
1424
1425	static ast::CV::Qualifiers cv( const Type * ty ) { return { ty->tq.val }; }
1426
1427	/// returns true and sets `node` if in cache
1428	bool inCache( const BaseSyntaxNode * old ) {
1429	auto it = cache.find( old );
1430	if ( it == cache.end() ) return false;
1431	node = it->second;
1432	return true;
1433	}
1434
1435	// Now all the visit functions:
1436
1437	virtual void visit( const ObjectDecl * old ) override final {
1438	auto&& type = GET_ACCEPT_1(type, Type);
1439	auto&& init = GET_ACCEPT_1(init, Init);
1440	auto&& bfwd = GET_ACCEPT_1(bitfieldWidth, Expr);
1441	auto&& attr = GET_ACCEPT_V(attributes, Attribute);
1442	if ( inCache( old ) ) {
1443	return;
1444	}
1445	auto decl = new ast::ObjectDecl(
1446	old->location,
1447	old->name,
1448	type,
1449	init,
1450	{ old->get_storageClasses().val },
1451	{ old->linkage.val },
1452	bfwd,
1453	std::move(attr),
1454	{ old->get_funcSpec().val }
1455	);
1456	cache.emplace(old, decl);
1457	assert(cache.find( old ) != cache.end());
1458	decl->scopeLevel = old->scopeLevel;
1459	decl->mangleName = old->mangleName;
1460	decl->isDeleted = old->isDeleted;
1461	decl->asmName = GET_ACCEPT_1(asmName, Expr);
1462	decl->uniqueId = old->uniqueId;
1463	decl->extension = old->extension;
1464
1465	this->node = decl;
1466	}
1467
1468	virtual void visit( const FunctionDecl * old ) override final {
1469	if ( inCache( old ) ) return;
1470	auto decl = new ast::FunctionDecl{
1471	old->location,
1472	old->name,
1473	GET_ACCEPT_1(type, FunctionType),
1474	{},
1475	{ old->storageClasses.val },
1476	{ old->linkage.val },
1477	GET_ACCEPT_V(attributes, Attribute),
1478	{ old->get_funcSpec().val }
1479	};
1480	cache.emplace( old, decl );
1481	decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
1482	decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);
1483	decl->scopeLevel = old->scopeLevel;
1484	decl->mangleName = old->mangleName;
1485	decl->isDeleted = old->isDeleted;
1486	decl->asmName = GET_ACCEPT_1(asmName, Expr);
1487	decl->uniqueId = old->uniqueId;
1488	decl->extension = old->extension;
1489
1490	this->node = decl;
1491
1492	if ( Validate::dereferenceOperator == old ) {
1493	dereferenceOperator = decl;
1494	}
1495
1496	if ( Validate::dtorStructDestroy == old ) {
1497	dtorStructDestroy = decl;
1498	}
1499	}
1500
1501	virtual void visit( const StructDecl * old ) override final {
1502	if ( inCache( old ) ) return;
1503	auto decl = new ast::StructDecl(
1504	old->location,
1505	old->name,
1506	old->kind,
1507	GET_ACCEPT_V(attributes, Attribute),
1508	{ old->linkage.val }
1509	);
1510	cache.emplace( old, decl );
1511	decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
1512	decl->body = old->body;
1513	decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1514	decl->members = GET_ACCEPT_V(members, Decl);
1515	decl->extension = old->extension;
1516	decl->uniqueId = old->uniqueId;
1517	decl->storage = { old->storageClasses.val };
1518
1519	this->node = decl;
1520
1521	if ( Validate::dtorStruct == old ) {
1522	dtorStruct = decl;
1523	}
1524	}
1525
1526	virtual void visit( const UnionDecl * old ) override final {
1527	if ( inCache( old ) ) return;
1528	auto decl = new ast::UnionDecl(
1529	old->location,
1530	old->name,
1531	GET_ACCEPT_V(attributes, Attribute),
1532	{ old->linkage.val }
1533	);
1534	cache.emplace( old, decl );
1535	decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
1536	decl->body = old->body;
1537	decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1538	decl->members = GET_ACCEPT_V(members, Decl);
1539	decl->extension = old->extension;
1540	decl->uniqueId = old->uniqueId;
1541	decl->storage = { old->storageClasses.val };
1542
1543	this->node = decl;
1544	}
1545
1546	virtual void visit( const EnumDecl * old ) override final {
1547	if ( inCache( old ) ) return;
1548	auto decl = new ast::EnumDecl(
1549	old->location,
1550	old->name,
1551	GET_ACCEPT_V(attributes, Attribute),
1552	{ old->linkage.val }
1553	);
1554	cache.emplace( old, decl );
1555	decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
1556	decl->body = old->body;
1557	decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1558	decl->members = GET_ACCEPT_V(members, Decl);
1559	decl->extension = old->extension;
1560	decl->uniqueId = old->uniqueId;
1561	decl->storage = { old->storageClasses.val };
1562
1563	this->node = decl;
1564	}
1565
1566	virtual void visit( const TraitDecl * old ) override final {
1567	if ( inCache( old ) ) return;
1568	auto decl = new ast::TraitDecl(
1569	old->location,
1570	old->name,
1571	GET_ACCEPT_V(attributes, Attribute),
1572	{ old->linkage.val }
1573	);
1574	cache.emplace( old, decl );
1575	decl->parent = GET_ACCEPT_1(parent, AggregateDecl);
1576	decl->body = old->body;
1577	decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1578	decl->members = GET_ACCEPT_V(members, Decl);
1579	decl->extension = old->extension;
1580	decl->uniqueId = old->uniqueId;
1581	decl->storage = { old->storageClasses.val };
1582
1583	this->node = decl;
1584	}
1585
1586	virtual void visit( const TypeDecl * old ) override final {
1587	if ( inCache( old ) ) return;
1588	auto decl = new ast::TypeDecl{
1589	old->location,
1590	old->name,
1591	{ old->storageClasses.val },
1592	GET_ACCEPT_1(base, Type),
1593	(ast::TypeVar::Kind)(unsigned)old->kind,
1594	old->sized,
1595	GET_ACCEPT_1(init, Type)
1596	};
1597	cache.emplace( old, decl );
1598	decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
1599	decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1600	decl->extension = old->extension;
1601	decl->uniqueId = old->uniqueId;
1602
1603	this->node = decl;
1604	}
1605
1606	virtual void visit( const TypedefDecl * old ) override final {
1607	auto decl = new ast::TypedefDecl(
1608	old->location,
1609	old->name,
1610	{ old->storageClasses.val },
1611	GET_ACCEPT_1(base, Type),
1612	{ old->linkage.val }
1613	);
1614	decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
1615	decl->params = GET_ACCEPT_V(parameters, TypeDecl);
1616	decl->extension = old->extension;
1617	decl->uniqueId = old->uniqueId;
1618	decl->storage = { old->storageClasses.val };
1619
1620	this->node = decl;
1621	}
1622
1623	virtual void visit( const AsmDecl * old ) override final {
1624	auto decl = new ast::AsmDecl{
1625	old->location,
1626	GET_ACCEPT_1(stmt, AsmStmt)
1627	};
1628	decl->extension = old->extension;
1629	decl->uniqueId = old->uniqueId;
1630	decl->storage = { old->storageClasses.val };
1631
1632	this->node = decl;
1633	}
1634
1635	virtual void visit( const StaticAssertDecl * old ) override final {
1636	auto decl = new ast::StaticAssertDecl{
1637	old->location,
1638	GET_ACCEPT_1(condition, Expr),
1639	GET_ACCEPT_1(message, ConstantExpr)
1640	};
1641	decl->extension = old->extension;
1642	decl->uniqueId = old->uniqueId;
1643	decl->storage = { old->storageClasses.val };
1644
1645	this->node = decl;
1646	}
1647
1648	virtual void visit( const CompoundStmt * old ) override final {
1649	if ( inCache( old ) ) return;
1650	auto stmt = new ast::CompoundStmt(
1651	old->location,
1652	to<std::list>::from( GET_ACCEPT_V(kids, Stmt) ),
1653	GET_LABELS_V(old->labels)
1654	);
1655
1656	this->node = stmt;
1657	cache.emplace( old, this->node );
1658	}
1659
1660	virtual void visit( const ExprStmt * old ) override final {
1661	if ( inCache( old ) ) return;
1662	this->node = new ast::ExprStmt(
1663	old->location,
1664	GET_ACCEPT_1(expr, Expr),
1665	GET_LABELS_V(old->labels)
1666	);
1667	cache.emplace( old, this->node );
1668	}
1669
1670	virtual void visit( const AsmStmt * old ) override final {
1671	if ( inCache( old ) ) return;
1672	this->node = new ast::AsmStmt(
1673	old->location,
1674	old->voltile,
1675	GET_ACCEPT_1(instruction, Expr),
1676	GET_ACCEPT_V(output, Expr),
1677	GET_ACCEPT_V(input, Expr),
1678	GET_ACCEPT_V(clobber, ConstantExpr),
1679	GET_LABELS_V(old->gotolabels),
1680	GET_LABELS_V(old->labels)
1681	);
1682	cache.emplace( old, this->node );
1683	}
1684
1685	virtual void visit( const DirectiveStmt * old ) override final {
1686	if ( inCache( old ) ) return;
1687	this->node = new ast::DirectiveStmt(
1688	old->location,
1689	old->directive,
1690	GET_LABELS_V(old->labels)
1691	);
1692	cache.emplace( old, this->node );
1693	}
1694
1695	virtual void visit( const IfStmt * old ) override final {
1696	if ( inCache( old ) ) return;
1697	this->node = new ast::IfStmt(
1698	old->location,
1699	GET_ACCEPT_1(condition, Expr),
1700	GET_ACCEPT_1(thenPart, Stmt),
1701	GET_ACCEPT_1(elsePart, Stmt),
1702	GET_ACCEPT_V(initialization, Stmt),
1703	GET_LABELS_V(old->labels)
1704	);
1705	cache.emplace( old, this->node );
1706	}
1707
1708	virtual void visit( const SwitchStmt * old ) override final {
1709	if ( inCache( old ) ) return;
1710	this->node = new ast::SwitchStmt(
1711	old->location,
1712	GET_ACCEPT_1(condition, Expr),
1713	GET_ACCEPT_V(statements, Stmt),
1714	GET_LABELS_V(old->labels)
1715	);
1716	cache.emplace( old, this->node );
1717	}
1718
1719	virtual void visit( const CaseStmt * old ) override final {
1720	if ( inCache( old ) ) return;
1721	this->node = new ast::CaseStmt(
1722	old->location,
1723	GET_ACCEPT_1(condition, Expr),
1724	GET_ACCEPT_V(stmts, Stmt),
1725	GET_LABELS_V(old->labels)
1726	);
1727	cache.emplace( old, this->node );
1728	}
1729
1730	virtual void visit( const WhileStmt * old ) override final {
1731	if ( inCache( old ) ) return;
1732	this->node = new ast::WhileStmt(
1733	old->location,
1734	GET_ACCEPT_1(condition, Expr),
1735	GET_ACCEPT_1(body, Stmt),
1736	GET_ACCEPT_V(initialization, Stmt),
1737	old->isDoWhile,
1738	GET_LABELS_V(old->labels)
1739	);
1740	cache.emplace( old, this->node );
1741	}
1742
1743	virtual void visit( const ForStmt * old ) override final {
1744	if ( inCache( old ) ) return;
1745	this->node = new ast::ForStmt(
1746	old->location,
1747	GET_ACCEPT_V(initialization, Stmt),
1748	GET_ACCEPT_1(condition, Expr),
1749	GET_ACCEPT_1(increment, Expr),
1750	GET_ACCEPT_1(body, Stmt),
1751	GET_LABELS_V(old->labels)
1752	);
1753	cache.emplace( old, this->node );
1754	}
1755
1756	virtual void visit( const BranchStmt * old ) override final {
1757	if ( inCache( old ) ) return;
1758	if (old->computedTarget) {
1759	this->node = new ast::BranchStmt(
1760	old->location,
1761	GET_ACCEPT_1(computedTarget, Expr),
1762	GET_LABELS_V(old->labels)
1763	);
1764	} else {
1765	ast::BranchStmt::Kind kind;
1766	switch (old->type) {
1767	#define CASE(n) \
1768	case BranchStmt::n: \
1769	kind = ast::BranchStmt::n; \
1770	break
1771	CASE(Goto);
1772	CASE(Break);
1773	CASE(Continue);
1774	CASE(FallThrough);
1775	CASE(FallThroughDefault);
1776	#undef CASE
1777	default:
1778	assertf(false, "Invalid BranchStmt::Type %d\n", old->type);
1779	}
1780
1781	auto stmt = new ast::BranchStmt(
1782	old->location,
1783	kind,
1784	make_label(&old->originalTarget),
1785	GET_LABELS_V(old->labels)
1786	);
1787	stmt->target = make_label(&old->target);
1788	this->node = stmt;
1789	}
1790	cache.emplace( old, this->node );
1791	}
1792
1793	virtual void visit( const ReturnStmt * old ) override final {
1794	if ( inCache( old ) ) return;
1795	this->node = new ast::ReturnStmt(
1796	old->location,
1797	GET_ACCEPT_1(expr, Expr),
1798	GET_LABELS_V(old->labels)
1799	);
1800	cache.emplace( old, this->node );
1801	}
1802
1803	virtual void visit( const ThrowStmt * old ) override final {
1804	if ( inCache( old ) ) return;
1805	ast::ExceptionKind kind;
1806	switch (old->kind) {
1807	case ThrowStmt::Terminate:
1808	kind = ast::ExceptionKind::Terminate;
1809	break;
1810	case ThrowStmt::Resume:
1811	kind = ast::ExceptionKind::Resume;
1812	break;
1813	default:
1814	assertf(false, "Invalid ThrowStmt::Kind %d\n", old->kind);
1815	}
1816
1817	this->node = new ast::ThrowStmt(
1818	old->location,
1819	kind,
1820	GET_ACCEPT_1(expr, Expr),
1821	GET_ACCEPT_1(target, Expr),
1822	GET_LABELS_V(old->labels)
1823	);
1824	cache.emplace( old, this->node );
1825	}
1826
1827	virtual void visit( const TryStmt * old ) override final {
1828	if ( inCache( old ) ) return;
1829	this->node = new ast::TryStmt(
1830	old->location,
1831	GET_ACCEPT_1(block, CompoundStmt),
1832	GET_ACCEPT_V(handlers, CatchStmt),
1833	GET_ACCEPT_1(finallyBlock, FinallyStmt),
1834	GET_LABELS_V(old->labels)
1835	);
1836	cache.emplace( old, this->node );
1837	}
1838
1839	virtual void visit( const CatchStmt * old ) override final {
1840	if ( inCache( old ) ) return;
1841	ast::ExceptionKind kind;
1842	switch (old->kind) {
1843	case CatchStmt::Terminate:
1844	kind = ast::ExceptionKind::Terminate;
1845	break;
1846	case CatchStmt::Resume:
1847	kind = ast::ExceptionKind::Resume;
1848	break;
1849	default:
1850	assertf(false, "Invalid CatchStmt::Kind %d\n", old->kind);
1851	}
1852
1853	this->node = new ast::CatchStmt(
1854	old->location,
1855	kind,
1856	GET_ACCEPT_1(decl, Decl),
1857	GET_ACCEPT_1(cond, Expr),
1858	GET_ACCEPT_1(body, Stmt),
1859	GET_LABELS_V(old->labels)
1860	);
1861	cache.emplace( old, this->node );
1862	}
1863
1864	virtual void visit( const FinallyStmt * old ) override final {
1865	if ( inCache( old ) ) return;
1866	this->node = new ast::FinallyStmt(
1867	old->location,
1868	GET_ACCEPT_1(block, CompoundStmt),
1869	GET_LABELS_V(old->labels)
1870	);
1871	cache.emplace( old, this->node );
1872	}
1873
1874	virtual void visit( const WaitForStmt * old ) override final {
1875	if ( inCache( old ) ) return;
1876	ast::WaitForStmt * stmt = new ast::WaitForStmt(
1877	old->location,
1878	GET_LABELS_V(old->labels)
1879	);
1880
1881	stmt->clauses.reserve( old->clauses.size() );
1882	for (size_t i = 0 ; i < old->clauses.size() ; ++i) {
1883	stmt->clauses.push_back({
1884	ast::WaitForStmt::Target{
1885	GET_ACCEPT_1(clauses[i].target.function, Expr),
1886	GET_ACCEPT_V(clauses[i].target.arguments, Expr)
1887	},
1888	GET_ACCEPT_1(clauses[i].statement, Stmt),
1889	GET_ACCEPT_1(clauses[i].condition, Expr)
1890	});
1891	}
1892	stmt->timeout = {
1893	GET_ACCEPT_1(timeout.time, Expr),
1894	GET_ACCEPT_1(timeout.statement, Stmt),
1895	GET_ACCEPT_1(timeout.condition, Expr),
1896	};
1897	stmt->orElse = {
1898	GET_ACCEPT_1(orelse.statement, Stmt),
1899	GET_ACCEPT_1(orelse.condition, Expr),
1900	};
1901
1902	this->node = stmt;
1903	cache.emplace( old, this->node );
1904	}
1905
1906	virtual void visit( const WithStmt * old ) override final {
1907	if ( inCache( old ) ) return;
1908	this->node = new ast::WithStmt(
1909	old->location,
1910	GET_ACCEPT_V(exprs, Expr),
1911	GET_ACCEPT_1(stmt, Stmt)
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	old->inout,
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	strict_dynamic_cast<ast::Decl*>(this->node) :
2400	GET_ACCEPT_1(deleteStmt, Decl)
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
2680	#undef GET_LABELS_V
2681	#undef GET_ACCEPT_V
2682	#undef GET_ACCEPT_1
2683
2684	std::list< ast::ptr< ast::Decl > > convert( const std::list< Declaration * > && translationUnit ) {
2685	ConverterOldToNew c;
2686	std::list< ast::ptr< ast::Decl > > decls;
2687	for(auto d : translationUnit) {
2688	d->accept( c );
2689	decls.emplace_back( c.decl() );
2690	}
2691	deleteAll(translationUnit);
2692	return decls;
2693	}

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

Download in other formats: