Context Navigation

source: src/AST/Convert.cpp @ 60aaa51d

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

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

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

Download in other formats: