Context Navigation

source: src/AST/Convert.cpp @ 53449a4

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

Last change on this file since 53449a4 was 3e5dd913, checked in by Fangren Yu <f37yu@…>, 3 years ago
reimplement function type and eliminate deep copy
Property mode set to `100644`
File size: 78.4 KB

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

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

Download in other formats: