Context Navigation

source: src/AST/Convert.cpp @ 98e8b3b

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

Last change on this file since 98e8b3b was 98e8b3b, checked in by Andrew Beach <ajbeach@…>, 4 years ago
ast::ReferenceToType? is now ast::BaseInstType?.
Property mode set to `100644`
File size: 73.3 KB

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

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

Download in other formats: