Context Navigation

source: src/AST/Convert.cpp @ 043a5b6

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

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

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

Download in other formats: