No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Wed, Jul 8, 7:54 AM

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/config/default.json b/config/default.json
	index 93cc036..21b7af6 100644
	--- a/config/default.json
	+++ b/config/default.json
	@@ -1,70 +1,71 @@
	{
	"containers": {
	"id": {
	"implementations": "impl_fulfill_cluster",
	"clusters": "var_cluster",
	"prototypes": "proto_cluster",
	"linkedlist": "linkedlist"
	},

	"impl": {
	"solid": "solid",
	"onthefly": "on_the_fly"
	}
	},

	"logging": {
	"id": "logging"
	},

	"function-entry": "entry",

	"clasp": {
	"bindings" : {
	"variable": "bind",
	"function": "bind_func",
	"scope": "bind_scope",
	"function_demand" : "bind_function_demand",
	"scope_decision": "bind_scope_decision"
	},

	"context" : {
	"decisions":{
	"dependent": "resolution_dependency"
	}
	},

	"nonevalue": "nonevalue",
	"ret": {
	"symbol": "retv",
	"tag": "ret"
	}
	},

	"tests": {
	- "template": "polymorphs",
	+ "template": "communication",

	"templates": {
	"default": "-Adhoc.:Compilation.full_IFStatementWithVariantType:Types.full_VariantType_Switch1",
	"ast": "AST.*",
	"adhocs": "Adhoc.*",
	"effects": "Effects.*",
	"basic": "Attachments.*",
	"context": "Context.*",
	"compilation": "Compilation.*",
	+ "communication": "Communication.FullDirectAndGuarded1",
	"cfa": "CFA.*",
	"containers": "Containers.*",
	"dfa": "DFA.*",
	"diagnostic": "Diagnostic.*",
	"dsl": "Interpretation.SwitchVariantAlias-Association.*",
	"ExpressionSerializer": "ExpressionSerializer.*",
	"externc": "InterfaceExternC.*",
	"loops": "Loop.*",
	"modules": "Modules.*",
	"polymorphs": "Polymorphs.call1",
	"types": "Types.*",
	"vendorsAPI/clang": "ClangAPI.*",
	"vendorsAPI/xml2": "libxml2*"
	}
	}
	}
	diff --git a/cpp/src/CMakeLists.txt b/cpp/src/CMakeLists.txt
	index 61049e9..3a19723 100644
	--- a/cpp/src/CMakeLists.txt
	+++ b/cpp/src/CMakeLists.txt
	@@ -1,229 +1,230 @@
	cmake_minimum_required(VERSION 2.8.11)
	project(xreate)
	cmake_policy(SET CMP0022 NEW)

	message("MODULES" ${CMAKE_MODULE_PATH})

	# LLVM
	#======================
	FIND_PACKAGE (LLVM REQUIRED)
	set(LLVM_VERSION ${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR})

	message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
	message("LLVM LIB PATH:" ${LLVM_LIBRARY_DIRS})
	message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")

	INCLUDE_DIRECTORIES(${LLVM_INCLUDE_DIRS})
	message(STATUS "INCLUDE DIR: ${LLVM_INCLUDE_DIRS}")

	add_definitions(${LLVM_DEFINITIONS})
	message("LLVM DEFS: " ${LLVM_DEFINITIONS})

	llvm_map_components_to_libnames(LLVM_LIBS core nativecodegen native executionengine mcjit support option)
	message("LLVM LIBS: " ${LLVM_LIBS})



	# CLANG
	#======================
	set(CLANG_LIBS
	clangCodeGen
	clangASTMatchers
	clangQuery
	clangTooling
	clangFrontend
	clangSerialization
	clangDriver
	clangParse
	clangSema
	clangAnalysis
	clangAST
	clangEdit
	clangLex
	clangBasic
	)



	# POTASSCO
	#======================
	set(POTASSCO_PATH "/opt/potassco/clingo" CACHE PATH "Path to potassco sources")
	set(POTASSCO_INCLUDE_PATH
	${POTASSCO_PATH}/libgringo
	${POTASSCO_PATH}/libclasp
	${POTASSCO_PATH}/libclingo
	${POTASSCO_PATH}/libprogram_opts
	${POTASSCO_PATH}/liblp
	)
	INCLUDE_DIRECTORIES(${POTASSCO_INCLUDE_PATH})
	set(LIBCLASP_LIBS
	clingo
	clasp
	gringo
	program_opts
	reify
	lp
	)
	message("CLASP LIBS: " ${LIBCLASP_LIBS})



	# OTHER DEPENDENCIES
	#===========================
	set(JEAYESON_INCLUDE_PATH
	${CMAKE_HOME_DIRECTORY}/../vendors/jeayeson/include/
	)
	INCLUDE_DIRECTORIES(${JEAYESON_INCLUDE_PATH})



	# COCO
	#===========================

	set(COCO_EXECUTABLE "" CACHE PATH "Path to coco executable")
	set(COCO_FRAMES_PATH "" CACHE PATH "Path to coco frames")

	set(COCO_GRAMMAR_PATH ${CMAKE_HOME_DIRECTORY}/../grammar/)
	set(COCO_SOURCE_FILES_MAIN
	${COCO_GRAMMAR_PATH}/main/Parser.cpp
	${COCO_GRAMMAR_PATH}/main/Scanner.cpp
	)

	set(COCO_SOURCE_FILES_MODULES
	${COCO_GRAMMAR_PATH}/modules/Parser.cpp
	${COCO_GRAMMAR_PATH}/modules/Scanner.cpp
	)

	set(COCO_SOURCE_FILES ${COCO_SOURCE_FILES_MODULES} ${COCO_SOURCE_FILES_MAIN})

	INCLUDE_DIRECTORIES(${COCO_GRAMMAR_PATH})

	add_custom_command(OUTPUT ${COCO_SOURCE_FILES_MAIN}
	COMMAND ${COCO_GRAMMAR_PATH}/gen-grammar main ${COCO_EXECUTABLE} ${COCO_FRAMES_PATH}
	WORKING_DIRECTORY ${COCO_GRAMMAR_PATH}
	MAIN_DEPENDENCY ${COCO_GRAMMAR_PATH}/xreate.ATG
	)

	add_custom_command(OUTPUT ${COCO_SOURCE_FILES_MODULES}
	COMMAND ${COCO_GRAMMAR_PATH}/gen-grammar modules ${COCO_EXECUTABLE} ${COCO_FRAMES_PATH}
	WORKING_DIRECTORY ${COCO_GRAMMAR_PATH}
	MAIN_DEPENDENCY ${COCO_GRAMMAR_PATH}/modules.ATG
	)

	message(STATUS "COCO GRAMMAR BUILD STATUS:" ${COCO_OUTPUT})



	# XREATE
	#======================
	set(SOURCE_FILES
	+ query/polymorph.cpp
	+ analysis/dfagraph.cpp
	+ pass/dfapass.cpp
	compilation/targetinterpretation.cpp
	pass/interpretationpass.cpp
	ast.cpp
	xreatemanager.cpp
	analysis/typeinference.cpp
	aux/xreatemanager-decorators.cpp
	compilation/operators.cpp
	compilation/transformations.cpp
	compilation/transformersaturation.cpp
	pass/compilepass.cpp
	- pass/dfapass.cpp
	- analysis/dfagraph.cpp
	pass/versionspass.cpp
	attachments.cpp
	ExternLayer.cpp
	analysis/cfagraph.cpp
	analysis/aux.cpp
	compilation/containers.cpp
	compilation/advanced.cpp
	clasplayer.cpp
	compilation/latecontextcompiler2.cpp
	query/context.cpp
	llvmlayer.cpp
	utils.cpp
	pass/abstractpass.cpp
	pass/cfapass.cpp
	pass/adhocpass.cpp
	contextrule.cpp
	query/containers.cpp
	analysis/DominatorsTreeAnalysisProvider.cpp
	aux/serialization/expressionserializer.cpp
	modules.cpp
	)

	set(XREATE_INCLUDE_DIRS
	${CMAKE_CURRENT_SOURCE_DIR}/
	)

	INCLUDE_DIRECTORIES(${XREATE_INCLUDE_DIRS})

	set(XREATE_PRIVATE_INCLUDE_DIRS
	${XREATE_INCLUDE_DIRS}
	${COCO_GRAMMAR_PATH}
	${JEAYESON_INCLUDE_PATH}
	${LLVM_INCLUDE_DIRS}
	${POTASSCO_INCLUDE_PATH}
	)

	add_library(${PROJECT_NAME} SHARED ${COCO_SOURCE_FILES} ${SOURCE_FILES})

	target_link_libraries(${PROJECT_NAME})


	target_include_directories(${PROJECT_NAME} INTERFACE
	${XREATE_INCLUDE_DIRS}
	${COCO_GRAMMAR_PATH}
	${JEAYESON_INCLUDE_PATH}
	${LLVM_INCLUDE_DIRS}
	${POTASSCO_INCLUDE_PATH}
	)

	get_directory_property(DEFINITIONS_ALL DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_DEFINITIONS)
	message("definitions all: " ${DEFINITIONS_ALL})
	target_compile_definitions(${PROJECT_NAME} INTERFACE ${DEFINITIONS_ALL})

	get_directory_property(COMPILATION_OPTIONS_ALL DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_OPTIONS)
	message("compilations all: " ${COMPILATION_OPTIONS_ALL})
	target_compile_options(${PROJECT_NAME} INTERFACE ${COMPILATION_OPTIONS_ALL})

	SET_PROPERTY(TARGET ${PROJECT_NAME} PROPERTY
	INTERFACE_LINK_LIBRARIES ${LIBCLASP_LIBS} ${CLANG_LIBS} ${LLVM_LIBS} tbb boost_system boost_filesystem
	)

	#${CLANG_LIBS}


	#set (LINK_INTERFACE_LIBRARIES "")

	# FUNCTION(PREPEND var prefix)
	# SET(listVar "")
	# FOREACH(f ${ARGN})
	# LIST(APPEND listVar "${prefix}/${f}")
	# ENDFOREACH(f)
	# SET(${var} "${listVar}" PARENT_SCOPE)
	# ENDFUNCTION(PREPEND)

	#set(COTIRE_UNITY_SOURCE_MAXIMUM_NUMBER_OF_INCLUDES "-j4")
	#cotire(xreate)


	# MACRO (ADD_PCH_RULE _header_filename _src_list)
	# SET(_gch_filename "${_header_filename}.gch")
	# LIST(APPEND ${_src_list} ${_gch_filename})
	# SET (_args ${CMAKE_CXX_FLAGS})
	# LIST(APPEND _args -c ${_header_filename} -o ${_gch_filename})
	# GET_DIRECTORY_PROPERTY(DIRINC INCLUDE_DIRECTORIES)
	# foreach (_inc ${DIRINC})
	# LIST(APPEND _args "-I" ${_inc})
	# endforeach(_inc ${DIRINC})
	# SEPARATE_ARGUMENTS(_args)
	# add_custom_command(OUTPUT ${_gch_filename}
	# COMMAND rm -f ${_gch_filename}
	# COMMAND ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} ${_args}
	# DEPENDS ${_header_filename})
	# ENDMACRO(ADD_PCH_RULE _header_filename _src_list)

	# ADD_PCH_RULE (${CMAKE_HOME_DIRECTORY}/src/ast.h SOURCE_FILES)
	# ADD_PCH_RULE (${CMAKE_HOME_DIRECTORY}/src/llvmlayer.h SOURCE_FILES)
	# ADD_PCH_RULE (${CMAKE_HOME_DIRECTORY}/src/clasplayer.h SOURCE_FILES)
	# ADD_PCH_RULE (${CMAKE_HOME_DIRECTORY}/src/pass/abstractpass.h SOURCE_FILES)
	diff --git a/cpp/src/analysis/DominatorsTreeAnalysisProvider.cpp b/cpp/src/analysis/DominatorsTreeAnalysisProvider.cpp
	index 22111cd..c6a928b 100644
	--- a/cpp/src/analysis/DominatorsTreeAnalysisProvider.cpp
	+++ b/cpp/src/analysis/DominatorsTreeAnalysisProvider.cpp
	@@ -1,241 +1,239 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: DominatorsTreeAnalysisProvider.cpp
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on May 13, 2016, 11:39 AM
	*/

	/**
	* \file DominatorsTreeAnalysisProvider.h
	* \brief Dominators Tree analysis
	*/

	#include "analysis/cfagraph.h"
	#include "analysis/DominatorsTreeAnalysisProvider.h"

	#include "llvm/ADT/GraphTraits.h"
	#include "llvm/Support/GenericDomTreeConstruction.h"
	#include "llvm/Support/GenericDomTree.h"

	#include <list>
	#include <iostream>
	#include <boost/format.hpp>

	using namespace std;
	using namespace xreate;
	using namespace boost;
	using namespace boost::bimaps;

	namespace xreate{ namespace dominators {

	struct ControlFlowTree;
	struct Node {
	ScopePacked scope;
	ControlFlowTree* tree;
	};

	/*
	bool operator !=(const Node& a, const Node& b){
	return (a.tree != b.tree) \|\| (a.scope != b.scope);
	}

	Node& operator++(Node& a){
	++a.scope;
	return a;
	}
	*/

	struct ControlFlowTree{
	typedef bimap<multiset_of<ScopePacked>, multiset_of<ScopePacked>> CHILD_RELATIONS;
	CHILD_RELATIONS edges;
	std::vector<Node> nodes;
	Node* entry = nullptr;
	size_t size;

	ControlFlowTree(const size_t nodesCount): nodes(nodesCount), size(nodesCount){
	}

	- static ControlFlowTree* build(const ClaspLayer* engine){
	+ static ControlFlowTree* build(const ClaspLayer* engine, cfa::CFAGraph* graph){
	ControlFlowTree* tree = new ControlFlowTree(engine->getScopesCount());

	- cfa::CFAGraph* graph = engine->dataCFA.get();
	-
	for (const auto& edge: graph->__parentScopeRelations){
	tree->edges.insert(CHILD_RELATIONS::value_type(edge.second, edge.first));
	}

	for (const auto& edge: graph->__callRelations){
	unsigned int calleeFunction = edge.right;
	ScopePacked caller = edge.left;

	auto range = graph->__parentFunctionRelations.right.equal_range(calleeFunction);
	for (auto& i=range.first; i!= range.second; ++i){
	tree->edges.insert(CHILD_RELATIONS::value_type(caller, i->second));
	}
	}

	for (size_t i=0; i<tree->size; ++i){
	tree->nodes[i]= Node{(unsigned int) i, tree};
	}

	return tree;
	}

	std::list<unsigned int> getRootFunctions() const{
	size_t idMax = size;
	size_t id =0;
	std::list<unsigned int> results;
	auto i = edges.right.begin();

	while (id < idMax) {
	if (i!= edges.right.end() && i->first == id){
	i = edges.right.upper_bound(i->first);

	} else {
	results.push_back(id);
	}

	++id;
	}

	return std::move(results);
	}
	};
	}} //end of namespace xreate::dominators

	namespace llvm {
	using namespace xreate::dominators;

	template <> struct GraphTraits<Node*> {
	typedef Node* nodes_iterator;
	typedef Node NodeType;

	typedef std::function<Node*(ControlFlowTree::CHILD_RELATIONS::left_value_type)> Transformer;
	typedef typename boost::transform_iterator<Transformer, ControlFlowTree::CHILD_RELATIONS::left_iterator> ChildIteratorType;

	static ChildIteratorType child_begin(const nodes_iterator& node) {
	auto range = node->tree->edges.left.equal_range(node->scope);
	Transformer x = [node](auto edge){return &node->tree->nodes[edge.second];};

	return boost::make_transform_iterator(range.first, x);
	}

	static ChildIteratorType child_end(const nodes_iterator& node) {
	auto range = node->tree->edges.left.equal_range(node->scope);
	Transformer x = [node](auto edge){return &node->tree->nodes[edge.second];};

	return boost::make_transform_iterator(range.second, x);
	}
	};

	template <> struct GraphTraits<Inverse<Node*>> {
	typedef Node* nodes_iterator;
	typedef Node NodeType;

	typedef std::function<Node*(ControlFlowTree::CHILD_RELATIONS::right_value_type)> Transformer;
	typedef typename boost::transform_iterator<Transformer, ControlFlowTree::CHILD_RELATIONS::right_iterator> ChildIteratorType;

	static ChildIteratorType child_begin(const nodes_iterator& node) {
	auto range = node->tree->edges.right.equal_range(node->scope);
	Transformer x = [node](auto edge){return &node->tree->nodes[edge.second];};

	return boost::make_transform_iterator(range.first, x);
	}

	static ChildIteratorType child_end(const nodes_iterator& node) {
	auto range = node->tree->edges.right.equal_range(node->scope);
	Transformer x = [node](auto edge){return &node->tree->nodes[edge.second];};

	return boost::make_transform_iterator(range.second, x);
	}
	};

	template <> struct GraphTraits<ControlFlowTree>: public GraphTraits<Node> {
	static NodeType*
	getEntryNode(ControlFlowTree* F) {
	if (F->entry) return F->entry;

	list<unsigned int>&& roots = F->getRootFunctions();
	assert(roots.size()==1);

	return F->entry = &F->nodes[roots.front()];
	}

	static nodes_iterator nodes_begin(ControlFlowTree* F) { return &F->nodes[0]; }
	static nodes_iterator nodes_end(ControlFlowTree* F) { return &F->nodes[F->size]; }
	static size_t size(ControlFlowTree* F) { return F->size; }
	};
	}

	namespace xreate{ namespace dominators {
	class DominatorTree: public llvm::DominatorTreeBase<Node> {
	public:
	DominatorsTreeAnalysisProvider::Dominators dominators;

	DominatorTree(bool isPostDom): llvm::DominatorTreeBase<Node>(isPostDom) {}

	void run(ControlFlowTree& program){
	recalculate(program);

	//extract dominators info
	for (auto& entry: DomTreeNodes){
	if (!entry.getFirst()) continue;

	dominators.emplace(entry.getFirst()->scope, make_pair(entry.getSecond()->getDFSNumIn(), entry.getSecond()->getDFSNumOut()));
	}
	}

	void print(std::ostringstream& output, const std::string& atom) const {
	boost::format formatAtom(atom + "(%1%, range(%2%, %3%)).");
	for (auto entry: dominators){
	output << formatAtom % (entry.first) % (entry.second.first) % (entry.second.second)
	<< endl;
	}
	}
	};

	void
	-DominatorsTreeAnalysisProvider::run(const ClaspLayer* engine){
	- boost::scoped_ptr<ControlFlowTree> program(ControlFlowTree::build(engine));
	+DominatorsTreeAnalysisProvider::run(const ClaspLayer* engine, cfa::CFAGraph* graph){
	+ boost::scoped_ptr<ControlFlowTree> program(ControlFlowTree::build(engine, graph));

	treeForwardDominators->run(*program);
	treePostDominators->run(*program);
	}

	void
	DominatorsTreeAnalysisProvider::print(std::ostringstream& output) const{
	treeForwardDominators->print(output, "cfa_forwdom");
	treePostDominators->print(output, "cfa_postdom");
	}

	const DominatorsTreeAnalysisProvider::Dominators&
	DominatorsTreeAnalysisProvider::getForwardDominators() const{
	return treeForwardDominators->dominators;
	}

	const DominatorsTreeAnalysisProvider::Dominators&
	DominatorsTreeAnalysisProvider::getPostDominators() const{
	return treePostDominators->dominators;
	}

	DominatorsTreeAnalysisProvider::DominatorsTreeAnalysisProvider()
	: treeForwardDominators(new DominatorTree(false))
	, treePostDominators(new DominatorTree(true))
	{}

	DominatorsTreeAnalysisProvider::~DominatorsTreeAnalysisProvider() {}

	}} //end of namespace xreate::dominators
	//void
	//CodeScopesTree::print(){
	// typedef llvm::GraphTraits<Node*> Traits;
	// for (size_t i=0; i<size; ++i){
	//
	// for (auto j = Traits::child_begin(&nodes[i]); j!= Traits::child_end(&nodes[i]); ++j){
	// cout << i << "->" << (*j)->scope << endl;
	// }
	// }
	//}
	diff --git a/cpp/src/analysis/DominatorsTreeAnalysisProvider.h b/cpp/src/analysis/DominatorsTreeAnalysisProvider.h
	index 5363c6d..f0223c6 100644
	--- a/cpp/src/analysis/DominatorsTreeAnalysisProvider.h
	+++ b/cpp/src/analysis/DominatorsTreeAnalysisProvider.h
	@@ -1,42 +1,42 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: DominatorsTreeAnalysisProvider.h
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on May 13, 2016, 11:39 AM
	*/

	#ifndef DOMINATORSTREEANALYSISPROVIDER_H
	#define DOMINATORSTREEANALYSISPROVIDER_H

	#include "clasplayer.h"
	#include <boost/smart_ptr/scoped_ptr.hpp>

	namespace xreate{namespace dominators{
	class DominatorTree;

	/** \brief Dominators Analysis report */
	class DominatorsTreeAnalysisProvider: public IAnalysisReport {
	public:
	typedef std::pair<ScopePacked, ScopePacked> DominatedRange;
	typedef std::map<ScopePacked, DominatedRange> Dominators;

	DominatorsTreeAnalysisProvider();
	virtual ~DominatorsTreeAnalysisProvider();

	- void run(const ClaspLayer* engine);
	- void print(std::ostringstream& output) const;
	+ void run(const ClaspLayer* engine, cfa::CFAGraph* graph);
	+ void print(std::ostringstream& output) const override;

	const Dominators& getForwardDominators() const;
	const Dominators& getPostDominators() const;

	private:
	boost::scoped_ptr<DominatorTree> treeForwardDominators;
	boost::scoped_ptr<DominatorTree> treePostDominators;
	};
	}} //end of namespace xreate::dominators

	#endif /* DOMINATORSTREEANALYSISPROVIDER_H */

	diff --git a/cpp/src/analysis/aux.cpp b/cpp/src/analysis/aux.cpp
	index e7e2e1f..109a6aa 100644
	--- a/cpp/src/analysis/aux.cpp
	+++ b/cpp/src/analysis/aux.cpp
	@@ -1,155 +1,142 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* aux.cpp
	*
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	/**
	* \file aux.h
	* \brief Data representation in ASP format ready for use by reasoner
	*/

	#include "aux.h"
	#include <boost/format.hpp>

	namespace xreate { namespace analysis {

	using namespace std;

	list<string>
	multiplyLists(list<list<string>> &&lists) {
	typedef list<string> StringList;
	assert(lists.size());
	StringList result(*lists.begin());
	lists.pop_front();

	boost::format concat("%s, %s");
	for (StringList &list: lists) {
	StringList::const_iterator end = result.end();
	for (StringList::iterator expr1I = result.begin(); expr1I != end; ++expr1I) {
	if (list.size() == 0) continue;

	StringList::const_iterator expr2I = list.begin();
	for (int expr2No = 0, size = list.size() - 1; expr2No < size; ++expr2No, ++expr1I)
	result.push_back(str(concat %(expr1I) %(expr2I)));

	expr1I = str(concat %(expr1I) %(*expr2I));
	}
	}

	return result;
	}

	std::list<std::string>
	compile(const Expression &e){
	list<string> result;

	switch (e.op) {
	case Operator::CALL: {
	assert(e.__state == Expression::COMPOUND);

	if(!e.operands.size()){
	result.push_back(e.getValueString());
	break;
	}

	std::list<list<string>> operands;
	std::transform(e.operands.begin(), e.operands.end(), std::inserter(operands, operands.begin()),
	[](const Expression &e) {
	return compile(e);
	});

	list<string> &&operands_ = multiplyLists(std::move(operands));
	result.push_back(boost::str(boost::format("%1%(%2%)") % (e.getValueString()) % (boost::algorithm::join(operands_, ", "))));
	break;
	}
	case Operator::NEG: {
	assert(e.operands.size() == 1);

	const Expression &op = e.operands.at(0);
	list<string> &&rawOp = compile(op);

	assert(rawOp.size() == 1);
	result.push_back((boost::format("not %1%")%(rawOp.front())).str());
	break;
	};

	case Operator::NONE: {
	switch (e.__state) {
	case Expression::IDENT:
	result.push_back(e.getValueString());
	break;

	case Expression::NUMBER:
	result.push_back(to_string(e.getValueDouble()));
	break;

	default:
	assert(true);
	}
	break;
	}

	default: break;
	}

	//TODO Null ad hoc ClaspLayer implementation
	// if (e.isNone()){
	// result.push_back(e.__valueS);
	// }

	assert(result.size());
	return result;
	}

	std::list<std::string>
	compileNeg(const Expression &e){
	list<string> result;
	switch (e.op) {
	case Operator::IMPL: {
	assert(e.__state == Expression::COMPOUND);
	assert(e.operands.size() == 2);
	list<string> operands1 = compile(e.operands.at(0));
	list<string> operands2 = compile(e.operands.at(1));

	boost::format formatNeg("%1%, not %2%");
	for (const auto &op1: operands1)
	for (const auto &op2: operands2) {
	result.push_back(boost::str(formatNeg %(op1) % (op2)));
	}
	break;
	}
	case Operator::NEG: {
	assert(e.operands.size() == 1);

	const Expression &op = e.operands.at(0);
	list<string> &&rawOp = compile(op);

	assert(rawOp.size() == 1);
	result.push_back(rawOp.front());
	break;
	};

	default:
	assert(true);
	}

	return result;
	}
	-
	-boost::format
	-formatSymbol(const SymbolPacked& s){
	- boost::format formatSymbNamed("(%1%, %2%, %3%)");
	- boost::format formatSymbAnonymous("anonym(%1%, %2%)");
	-
	- if (!s.categoryTransient){
	- return formatSymbNamed % s.identifier % s.version % s.scope;
	- } else {
	- return formatSymbAnonymous % s.identifier % s.scope;
	- }
	-}
	-
	}}
	diff --git a/cpp/src/analysis/aux.h b/cpp/src/analysis/aux.h
	index e470d5d..ec6a332 100644
	--- a/cpp/src/analysis/aux.h
	+++ b/cpp/src/analysis/aux.h
	@@ -1,28 +1,27 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: aux.h
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on June 26, 2016, 6:49 PM
	*/

	#ifndef AUX_H
	#define AUX_H

	#include "ast.h"
	#include "clasplayer.h"

	#include <list>
	#include <boost/format.hpp>

	namespace xreate { namespace analysis {
	std::list<std::string> compile(const Expression &e);
	std::list<std::string> compileNeg(const Expression &e);
	std::list<std::string> multiplyLists(std::list<std::list<std::string>> &&lists);
	- boost::format formatSymbol(const SymbolPacked& s);
	}}

	#endif /* AUX_H */

	diff --git a/cpp/src/analysis/cfagraph.h b/cpp/src/analysis/cfagraph.h
	index 5219525..49c66d6 100644
	--- a/cpp/src/analysis/cfagraph.h
	+++ b/cpp/src/analysis/cfagraph.h
	@@ -1,60 +1,60 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: CFAGraph.h
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on June 27, 2016, 2:09 PM
	*/

	#ifndef CFAGRAPH_H
	#define CFAGRAPH_H

	#include "clasplayer.h"

	namespace xreate {namespace cfa {

	/** \brief Represents CFA analysis data produced by CFAPass */
	class CFAGraph: public IAnalysisReport {
	public:
	typedef boost::bimap<ScopePacked, boost::bimaps::multiset_of<unsigned int>> PARENT_FUNCTION_RELATIONS;
	PARENT_FUNCTION_RELATIONS __parentFunctionRelations;
	std::map<ScopePacked, ScopePacked> __parentScopeRelations;

	typedef boost::bimap<
	boost::bimaps::multiset_of<ScopePacked>,
	boost::bimaps::multiset_of<unsigned int>,
	boost::bimaps::set_of_relation<>
	> CALL_RELATIONS;

	CALL_RELATIONS __callRelations;

	boost::bimap<unsigned int, std::string > __nodesFunction;
	std::multimap<unsigned int, Expression> __functionTags;
	std::multimap<ScopePacked, Expression> __scopeTags;
	std::multimap<ScopePacked, ContextRule> __contextRules;

	- void print(std::ostringstream& output) const;
	+ void print(std::ostringstream& output) const override;
	CFAGraph(ClaspLayer* engine): __clasp(engine){}

	void addFunctionAnnotations(const std::string& function, const std::map<std::string, Expression>& tags);
	void addScopeAnnotations(const ScopePacked& scope, const std::vector<Expression>&tags);
	void addContextRules(const ScopePacked& scope, const std::vector<Expression>&rules);

	void addCallConnection(const ScopePacked& scopeFrom, const std::string& functionTo);
	void addParentConnection(const ScopePacked& scope, const std::string& functionParent);
	void addParentConnection(const ScopePacked& scope, const ScopePacked& scopeParent);
	// void addScopeRetIdentifier(const ScopePacked& scope, const SymbolPacked& identifier);

	private:
	ClaspLayer* __clasp;

	unsigned int registerNodeFunction(const std::string& fname);

	};

	}} //end of namespace xreate::cfa

	#endif /* CFAGRAPH_H */

	diff --git a/cpp/src/analysis/dfagraph.cpp b/cpp/src/analysis/dfagraph.cpp
	index 38a9601..f5c01e5 100644
	--- a/cpp/src/analysis/dfagraph.cpp
	+++ b/cpp/src/analysis/dfagraph.cpp
	@@ -1,260 +1,227 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: DFAGraph.h
	* Author: pgess <v.melnychenko@xreate.org>
	*
	*/

	/**
	* \file dfagraph.h
	* \brief Data Flow Analysis(DFA) graph data
	*
	*/

	#include "analysis/dfagraph.h"
	#include "analysis/aux.h"

	#include <list>

	-
	using namespace std;
	-namespace xreate { namespace dfa {
	-
	- void
	- DFAGraph::print(std::ostringstream& output) const {
	- std::set<SymbolPacked> symbols;
	-
	- output << endl << "%\t\tStatic analysis: DFA" << endl;
	-
	- std::vector<std::pair<SymbolPacked, SymbolPacked>>::const_iterator i1;
	- std::vector<DFGConnection>::const_iterator i2;
	-
	- boost::format formatDfaConnection("dfa_connection(%1%, %2%, %3%).");
	- for (i1 = this->__edges.begin(), i2 = this->__data.begin(); i1 != this->__edges.end(); ++i1, ++i2) {
	- string edgeName;
	- switch (*i2) {
	- case DFGConnection::WEAK: edgeName = "weak";
	- break;
	- case DFGConnection::STRONG: edgeName = "strong";
	- break;
	- case DFGConnection::PROTOTYPE: edgeName = "proto";
	- break;
	- }
	-
	- output << formatDfaConnection
	- % analysis::formatSymbol(i1->first)
	- % analysis::formatSymbol(i1->second)
	- % edgeName
	- << " %" << this->__clasp->getHintForPackedSymbol(i1->first) << " - " << this->__clasp->getHintForPackedSymbol(i1->second)
	- << endl;
	-
	- symbols.insert(i1->first);
	- symbols.insert(i1->second);
	- }
	-
	- boost::format formatDfaDependency("dfa_dependency(%1%, %2%).");
	- for (auto i = this->__dependencies.begin(); i != this->__dependencies.end(); ++i) {
	- output << formatDfaDependency
	- % analysis::formatSymbol(i->first)
	- % analysis::formatSymbol(i->second)
	- << " %"
	- << this->__clasp->getHintForPackedSymbol(i->first) << " - "
	- << this->__clasp->getHintForPackedSymbol(i->second)
	- << endl;
	- }
	-
	- boost::format formatBind("bind(%1%, %2%).");
	- for (const pair<SymbolPacked, Expression>& tag : this->__tags) {
	- for (string variant : xreate::analysis::compile(tag.second)) {
	- output << formatBind
	- % analysis::formatSymbol(tag.first)
	- % (variant)
	- << "%" << this->__clasp->getHintForPackedSymbol(tag.first)
	- << endl;
	- }
	-
	- symbols.insert(tag.first);
	- }

	- for (const SymbolPacked& s : symbols) {
	- output << "v(" << analysis::formatSymbol(s) << ")."
	- << " %" << this->__clasp->getHintForPackedSymbol(s)
	- << endl;
	- }
	+namespace xreate {namespace dfa {
	+ struct VisitorNodeHash : public boost::static_visitor<size_t>
	+ {
	+ std::size_t operator()(const xreate::SymbolPacked& node) const noexcept
	+ {
	+ return 2* (node.identifier + 2 * node.scope + 3 * std::abs(node.version)) + 1;
	}

	- class VisitorAddTag : public boost::static_visitor<> {
	- public:
	-
	- void operator()(const SymbolPacked& symbol) {
	- __graph->__tags.emplace(symbol, move(__tag));
	- }
	-
	- void operator()(SymbolAnonymous& symbol) {
	- symbol.tags.push_back(move(__tag));
	- }
	-
	- void operator()(const SymbolInvalid& symbol) {
	- assert(false && "Undefined behaviour");
	- }
	-
	- VisitorAddTag(DFAGraph * const dfagraph, Expression&& tag) :
	- __graph(dfagraph), __tag(tag) {
	- }
	-
	- private:
	- DFAGraph * const __graph;
	- Expression __tag;
	- };
	-
	- class VisitorAddLink : public boost::static_visitor<> {
	- public:
	-
	- void operator()(const SymbolPacked& nodeFrom) {
	- if (!__graph->isConnected(__nodeTo, nodeFrom)) {
	- __graph->__edges.emplace_back(__nodeTo, nodeFrom);
	- __graph->__data.push_back(__link);
	-
	- DFAGraph::EdgeId eid = __graph->__edges.size() - 1;
	- __graph->__outEdges.emplace(nodeFrom, eid);
	- }
	- }
	-
	- void operator()(const SymbolAnonymous& symbolFrom) {
	- switch (__link) {
	- case DFGConnection::WEAK:
	- {
	- //virtual symbol to hold transient annotations
	- SymbolPacked symbPivot = __graph->createAnonymousSymbol(symbolFrom.scope);
	-
	- __graph->addConnection(symbPivot, symbolFrom, DFGConnection::STRONG);
	- __graph->addConnection(__nodeTo, symbPivot, DFGConnection::WEAK);
	- break;
	- }
	-
	- case DFGConnection::STRONG:
	- {
	- for (const Expression& tag : symbolFrom.tags) {
	- __graph->__tags.emplace(__nodeTo, tag);
	- }
	- break;
	- }
	-
	- default:
	- assert(false && "Undefined behavior");
	- }
	- }
	-
	- void operator()(const SymbolInvalid&) {
	- if (__link == DFGConnection::STRONG) return;
	- if (__link == DFGConnection::WEAK) return;
	-
	- assert(false && "Undefined behavior");
	- }
	-
	- VisitorAddLink(DFAGraph * const dfagraph, const SymbolPacked& nodeTo, DFGConnection link) :
	- __graph(dfagraph), __nodeTo(nodeTo), __link(link) {
	- }
	-
	- private:
	- DFAGraph * const __graph;
	- SymbolPacked __nodeTo;
	- DFGConnection __link;
	- };
	-
	- class VisitorGetDependencyConnection : public boost::static_visitor<list<SymbolPacked>>
	+ std::size_t operator()(const xreate::dfa::SymbolAnonymous& node) const noexcept
	{
	- public:
	-
	- list<SymbolPacked>
	- operator()(const SymbolPacked & nodeFrom) {
	- return
	- {
	- nodeFrom
	- };
	- }
	-
	- list<SymbolPacked>
	- operator()(const SymbolAnonymous & nodeFrom) {
	- return nodeFrom.dependencies;
	- }
	-
	- list<SymbolPacked>
	- operator()(const SymbolInvalid&) {
	- assert(false && "Undefined behavior");
	- }
	-
	- VisitorGetDependencyConnection(DFAGraph * const g) : graph(g) {
	- }
	- DFAGraph * const graph;
	- };
	-
	- class VisitorSetDependencyConnection : public boost::static_visitor<> {
	- public:
	-
	- void operator()(SymbolPacked& nodeTo) {
	- VisitorGetDependencyConnection visitorGetDepenencies(graph);
	- auto deps = boost::apply_visitor(visitorGetDepenencies, nodeFrom);
	-
	- for (const SymbolPacked& dep : deps) {
	- graph->__dependencies.emplace(nodeTo, dep);
	- }
	- }
	-
	- void operator()(SymbolAnonymous& nodeTo) {
	- VisitorGetDependencyConnection visitorGetDepenencies(graph);
	- auto deps = boost::apply_visitor(visitorGetDepenencies, nodeFrom);
	+ return 2 * node.id;
	+ }
	+ };
	+}}

	- for (const SymbolPacked& dep : deps) {
	- nodeTo.dependencies.push_back(dep);
	- }
	- }
	+std::size_t
	+hash<xreate::dfa::SymbolNode>::operator()(xreate::dfa::SymbolNode const& s) const noexcept
	+{
	+ return boost::apply_visitor(xreate::dfa::VisitorNodeHash(), s);
	+}

	- void operator()(SymbolInvalid&) {
	- assert(false && "Undefined behavior");
	- }
	+namespace xreate { namespace dfa {

	- VisitorSetDependencyConnection(DFAGraph * const g, SymbolNode s) : graph(g), nodeFrom(s) {
	+bool operator==(const SymbolAnonymous& s1, const SymbolAnonymous& s2){
	+ return s1.id == s2.id && s1.flagIsUsed == s2.flagIsUsed;
	+}
	+
	+class VisitorFormatSymbol: public boost::static_visitor<boost::format> {
	+public:
	+
	+ boost::format operator()(const SymbolPacked& node) const {
	+ //boost::format formatSymbNamed("s(%1%, %2%, %3%)");
	+ boost::format formatSymbNamed("s%1%%2%");
	+ return formatSymbNamed % node.identifier /% node.version/ % node.scope ;
	+ }
	+
	+ boost::format operator()(const SymbolAnonymous& node) const {
	+ //boost::format formatSymbAnonymous("anon(%1%)");
	+ boost::format formatSymbAnonymous("a%1%");
	+ return formatSymbAnonymous % node.id;
	+ }
	+};
	+
	+void
	+DFACallInstance::print(std::ostringstream& output) const{
	+ boost::format formatInstance("dfa_callinstance(%1%, %2%).");
	+ boost::format formatArgs("dfa_callargs(%1%, %2%, %3%).");
	+ boost::format formatRet("dfa_callret(%1%, %2%).");
	+
	+ output << formatInstance
	+ % id % fnName
	+ << endl;
	+
	+ for(std::pair<SymbolPacked, SymbolNode> rec: args) {
	+ SymbolNode argFormal(rec.first);
	+
	+ output << formatArgs
	+ % id
	+ % boost::apply_visitor(VisitorFormatSymbol(), argFormal)
	+ % boost::apply_visitor(VisitorFormatSymbol(), rec.second)
	+ << endl;
	+ }
	+
	+ output << formatRet
	+ % id
	+ % boost::apply_visitor(VisitorFormatSymbol(), retActual)
	+ << endl;
	+}
	+
	+void
	+DFAGraph::addDependency(const SymbolNode& node, const SymbolNode& subnode){
	+ __dependencies.emplace(node, subnode);
	+}
	+
	+void
	+DFAGraph::printDependencies(std::ostringstream& output) const{
	+ for(const SymbolNode& root: __roots){
	+ printDependency(output, root, root);
	+ }
	+}
	+
	+void
	+DFAGraph::printDependency(std::ostringstream& output, const SymbolNode& nodeCurrent, const SymbolNode& nodeDependent) const {
	+ auto range = __dependencies.equal_range(nodeCurrent);
	+ for (auto it = range.first; it != range.second; ++it){
	+ if (const SymbolAnonymous* symbAnon = boost::get<SymbolAnonymous>(&it->second)){
	+ if (!__usedAnonymousSymbols.count(symbAnon->id)){
	+ printDependency(output, it->second, nodeDependent);
	+ continue;
	}
	- DFAGraph * const graph;
	- SymbolNode nodeFrom;
	- };
	+ }

	- bool
	- DFAGraph::isConnected(const SymbolPacked& identifierTo, const SymbolPacked& identifierFrom) {
	- auto range = __outEdges.equal_range(identifierFrom);
	+ boost::format formatDependency("dfa_depends(%1%, %2%).");
	+
	+ output << formatDependency
	+ % boost::apply_visitor(VisitorFormatSymbol(), nodeDependent)
	+ % boost::apply_visitor(VisitorFormatSymbol(), it->second)
	+ << endl;
	+
	+ printDependency(output, it->second, it->second);
	+ }
	+}
	+
	+void
	+DFAGraph::printInplaceAnnotations(SymbolNode node, const Expression& expression) {
	+ // write down in-place expression tags:
	+ boost::format formatBind("bind(%1%, %2%).");
	+
	+ if (expression.tags.size())
	+ if (boost::get<SymbolAnonymous>(&node)){
	+ markSymbolsAsUsed(vector<SymbolNode>({node}));
	+ }
	+
	+ for (const pair<std::string, Expression>& tag : expression.tags) {
	+ for (const string& tagPart: xreate::analysis::compile(tag.second)) {
	+ __output << formatBind
	+ % boost::apply_visitor(VisitorFormatSymbol(), node)
	+ % tagPart
	+ << endl;
	+ }
	+ }
	+}
	+
	+void
	+DFAGraph::printAlias(const SymbolNode& symbolFormal, const SymbolNode& symbActual){
	+ boost::format formatAlias("dfa_alias(%1%, %2%).");
	+ __output << formatAlias
	+ % boost::apply_visitor(VisitorFormatSymbol(), symbolFormal)
	+ % boost::apply_visitor(VisitorFormatSymbol(), symbActual)
	+ << endl;
	+}
	+
	+void
	+DFAGraph::printFunctionRet(ManagedFnPtr function, const SymbolNode& symbolRet){
	+ boost::format formatRet("dfa_fnret(%1%, %2%).");
	+
	+ __output << formatRet
	+ % function->getName()
	+ % boost::apply_visitor(VisitorFormatSymbol(), symbolRet)
	+ << endl;
	+
	+ __roots.insert(symbolRet);
	+}
	+
	+void
	+DFAGraph::addCallInstance(DFACallInstance&& instance){
	+ __callInstances.push_back(std::move(instance));
	+}
	+
	+void
	+DFAGraph::print(std::ostringstream& output) const{
	+ output << endl << "%\t\tStatic analysis: DFA" << endl;
	+
	+ //Dependencies
	+ printDependencies(output);
	+
	+ //Add generated report
	+ output << __output.str() << endl;
	+
	+ //Call instances
	+ for(const DFACallInstance& instance: __callInstances){
	+ instance.print(output);
	+ }
	+
	+ output << endl;
	+}
	+
	+void
	+DFAGraph::markSymbolsAsUsed(const std::vector<SymbolNode>& usedNodes){
	+ for (const SymbolNode& node: usedNodes){
	+ if (const SymbolAnonymous* symbol = boost::get<SymbolAnonymous>(&node)){
	+ __usedAnonymousSymbols.insert(symbol->id);
	+ }
	+ }
	+}

	- for (std::multimap<SymbolPacked, EdgeId>::iterator edge = range.first; edge != range.second; ++edge) {
	- if (__edges[edge->second].second == identifierTo)
	- return true;
	- }
	+bool
	+DFAGraph::isSymbolUsed(const SymbolNode& node) const{
	+ if (const SymbolAnonymous* symbol = boost::get<SymbolAnonymous>(&node)){
	+ if (!__usedAnonymousSymbols.count(symbol->id)) {return false;}
	+ }

	- return false;
	- }
	+ return true;
	+}

	- void
	- DFAGraph::addConnection(const SymbolPacked& nodeTo, const SymbolNode& nodeFrom, DFGConnection link) {
	- VisitorAddLink visitor(this, nodeTo, link);
	- boost::apply_visitor(visitor, nodeFrom);
	- }
	+void
	+DFAGraph::printSymbols(ClaspLayer* clasp){
	+ std::unordered_set<SymbolNode> symbols;

	- void
	- DFAGraph::addDependencyConnection(SymbolNode& identifierTo, SymbolNode& identifierFrom) {
	- VisitorSetDependencyConnection visitor(this, identifierFrom);
	- boost::apply_visitor(visitor, identifierTo);
	- }
	+ for (auto entry: __dependencies){
	+ if (isSymbolUsed(entry.first)) {symbols.insert(entry.first);}
	+ if (isSymbolUsed(entry.second)) {symbols.insert(entry.second);}
	+ }

	- void
	- DFAGraph::addAnnotation(SymbolNode& node, Expression&& tag) {
	- VisitorAddTag visitor(this, move(tag));
	- boost::apply_visitor(visitor, node);
	- }
	+ for (const SymbolNode& node : symbols) {
	+ __output << "v(" << boost::apply_visitor(VisitorFormatSymbol(), node) << ").";

	- SymbolPacked
	- DFAGraph::createAnonymousSymbol(const ScopePacked& scope) {
	- return SymbolPacked(ScopedSymbol{__countAnonymousSymbols++, 0}, scope, true);
	+ if (const SymbolPacked* symbol = boost::get<SymbolPacked>(&node)){
	+ __output << " %" << clasp->getHintForPackedSymbol(*symbol);
	}
	+ __output << endl;
	+ }
	+}

	}} //end of namespace xreate::dfa
	diff --git a/cpp/src/analysis/dfagraph.h b/cpp/src/analysis/dfagraph.h
	index 531151e..ff297e5 100644
	--- a/cpp/src/analysis/dfagraph.h
	+++ b/cpp/src/analysis/dfagraph.h
	@@ -1,64 +1,74 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: dfa.h
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on June 27, 2016, 1:50 PM
	*/

	#ifndef DFA_H
	#define DFA_H

	#include "clasplayer.h"
	+#include <unordered_set>

	namespace xreate {namespace dfa {
	-
	struct SymbolAnonymous {
	- SymbolAnonymous(unsigned int symbolId): id(symbolId){}
	-
	unsigned int id;
	- std::list<Expression> tags;
	- ScopePacked scope;
	- std::list<SymbolPacked> dependencies;
	+ bool flagIsUsed = false;
	};

	- struct SymbolInvalid { };
	-
	- typedef boost::variant<SymbolInvalid, SymbolAnonymous, SymbolPacked> SymbolNode;
	-
	- /** \brief Holds DFA Analysis report produced by DFAPass */
	- class DFAGraph: public IAnalysisReport{
	- friend class VisitorAddTag;
	- friend class VisitorAddLink;
	- friend class VisitorGetDependencyConnection;
	- friend class VisitorSetDependencyConnection;
	-
	-
	- public:
	- DFAGraph(ClaspLayer* engine): __clasp(engine){}
	-
	- SymbolPacked createAnonymousSymbol(const ScopePacked& scope);
	- void addAnnotation(SymbolNode& identifier, Expression&& tag);
	- void addConnection(const SymbolPacked& identifierTo, const SymbolNode& identifierFrom, DFGConnection link);
	- void addDependencyConnection(SymbolNode& identifierTo, SymbolNode& identifierFrom);
	- bool isConnected(const SymbolPacked& identifierTo, const SymbolPacked& identifierFrom);
	+ bool operator==(const SymbolAnonymous& s1, const SymbolAnonymous& s2);

	- void print(std::ostringstream& output) const;
	-
	- private:
	- typedef unsigned int EdgeId;
	- std::vector<std::pair<SymbolPacked, SymbolPacked>> __edges;
	- std::multimap<SymbolPacked, EdgeId> __outEdges;
	- std::vector<DFGConnection> __data;
	- std::multimap<SymbolPacked, Expression> __tags;
	- std::multimap<SymbolPacked, SymbolPacked> __dependencies;
	+ typedef boost::variant<SymbolAnonymous, SymbolPacked> SymbolNode;
	+}}

	- unsigned int __countAnonymousSymbols=0;
	- ClaspLayer* __clasp;
	+namespace std{
	+ template<>
	+ struct hash<xreate::dfa::SymbolNode>{
	+ std::size_t operator()(xreate::dfa::SymbolNode const& s) const noexcept;
	};
	+}
	+
	+namespace xreate {namespace dfa {
	+class DFACallInstance{
	+public:
	+ unsigned int id;
	+ std::string fnName;
	+ std::vector<std::pair<SymbolPacked, SymbolNode>> args;
	+ SymbolNode retActual;
	+
	+ void print(std::ostringstream& output) const;
	+};
	+
	+/** \brief Holds DFA Analysis report produced by DFAPass */
	+class DFAGraph: public IAnalysisReport{
	+public:
	+ // DFAGraph(ClaspLayer* engine): __clasp(engine){}
	+ virtual void print(std::ostringstream& output) const override;
	+ void addCallInstance(DFACallInstance && instance);
	+ void addDependency(const SymbolNode& node, const SymbolNode& subnodeBlock);
	+ void printInplaceAnnotations(SymbolNode node, const Expression& expression);
	+ void printAlias(const SymbolNode& symbolFormal, const SymbolNode& symbActual);
	+ void printFunctionRet(ManagedFnPtr function, const SymbolNode& symbolRet);
	+ void printDependencies(std::ostringstream& output) const;
	+ void markSymbolsAsUsed(const std::vector<SymbolNode>& usedNodes);
	+ void printSymbols(ClaspLayer* clasp);
	+
	+private:
	+ mutable std::ostringstream __output;
	+ std::list<DFACallInstance> __callInstances;
	+ std::unordered_multimap<SymbolNode, SymbolNode> __dependencies;
	+ std::unordered_set<unsigned int> __usedAnonymousSymbols;
	+ std::unordered_set<SymbolNode> __roots;
	+
	+
	+ void printDependency(std::ostringstream& output, const SymbolNode& nodeCurrent, const SymbolNode& nodeDependent) const;
	+ bool isSymbolUsed(const SymbolNode& node) const;
	+};
	}} // end of namespace xreate::dfa

	#endif /* DFA_H */

	diff --git a/cpp/src/analysis/typeinference.cpp b/cpp/src/analysis/typeinference.cpp
	index 3107a24..ec38c58 100644
	--- a/cpp/src/analysis/typeinference.cpp
	+++ b/cpp/src/analysis/typeinference.cpp
	@@ -1,68 +1,68 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* typeinference.cpp
	*
	* Author: pgess <v.melnychenko@xreate.org>
	* Created on April 16, 2017, 10:13 AM
	*/

	/**
	* \file typeinference.h
	* \brief Type inference analysis
	*/

	#include "typeinference.h"
	#include "llvmlayer.h"

	#include "llvm/IR/Function.h"
	#include "llvm/IR/DerivedTypes.h"

	namespace xreate {namespace typeinference {

	//TODO type conversion:
	//a) automatically expand types int -> bigger int; int -> floating
	//b) detect exact type of `num` based on max used numeral / function type
	//c) warning if need to truncate (allow/dissalow based on annotations)

	llvm::Value*
	doAutomaticTypeConversion(llvm::Value* source, llvm::Type* tyTarget, llvm::IRBuilder<>& builder){
	if (tyTarget->isIntegerTy() && source->getType()->isIntegerTy())
	{
	llvm::IntegerType* tyTargetInt = llvm::dyn_cast<llvm::IntegerType>(tyTarget);
	llvm::IntegerType* tySourceInt = llvm::dyn_cast<llvm::IntegerType>(source->getType());

	if (tyTargetInt->getBitWidth() < tySourceInt->getBitWidth()){
	return builder.CreateCast(llvm::Instruction::Trunc, source, tyTarget);
	}

	if (tyTargetInt->getBitWidth() > tySourceInt->getBitWidth()){
	return builder.CreateCast(llvm::Instruction::SExt, source, tyTarget);
	}
	}

	if (source->getType()->isIntegerTy() && tyTarget->isFloatingPointTy()){
	return builder.CreateCast(llvm::Instruction::SIToFP, source, tyTarget);
	}

	return source;
	}

	ExpandedType
	getType(const Expression& expression, const AST& ast){
	if (expression.type.isValid()){
	return ast.expandType(expression.type);
	}

	if (expression.__state == Expression::IDENT){
	- Symbol s = Attachments::get<Symbol>(expression);
	+ Symbol s = Attachments::get<IdentifierSymbol>(expression);
	return getType(CodeScope::getDefinition(s), ast);
	}

	assert(false && "Type can't be determined for an expression");
	}



	} } //end of namespace xreate::typeinference
	diff --git a/cpp/src/ast.cpp b/cpp/src/ast.cpp
	index 6a8eae8..70c3923 100644
	--- a/cpp/src/ast.cpp
	+++ b/cpp/src/ast.cpp
	@@ -1,968 +1,976 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* Author: pgess <v.melnychenko@xreate.org>
	* File: ast.cpp
	*/

	/**
	* \file ast.h
	* \brief Syntax Tree and related code
	*
	* \sa xreate::AST
	*/

	#include "ast.h"
	#include "ExternLayer.h"
	#include "analysis/typeinference.h"

	#include <stdexcept>
	#include <iostream>

	//TODO BDecl. forbid multiple body declaration (ExprTyped)

	namespace std {

	std::size_t
	hash<xreate::ScopedSymbol>::operator()(xreate::ScopedSymbol const& s) const {
	return s.id ^ (s.version << 2);
	}

	bool
	equal_to<xreate::ScopedSymbol>::operator()(const xreate::ScopedSymbol& __x, const xreate::ScopedSymbol& __y) const {
	return __x.id == __y.id && __x.version == __y.version;
	}

	size_t
	hash<xreate::Symbol>::operator()(xreate::Symbol const& s) const {
	return hash<xreate::ScopedSymbol>()(s.identifier) ^ ((long int) s.scope << 1);
	}

	bool
	equal_to<xreate::Symbol>::operator()(const xreate::Symbol& __x, const xreate::Symbol& __y) const {
	return __x == __y;
	};
	}

	using namespace std;

	namespace xreate {

	Atom<Identifier_t>::Atom(const std::wstring& value) {
	__value = wstring_to_utf8(value);
	}

	Atom<Identifier_t>::Atom(std::string && name) : __value(name) {
	}

	const std::string&
	Atom<Identifier_t>::get() const {
	return __value;
	}

	Atom<Number_t>::Atom(wchar_t* value) {
	//DEBT reconsider number literal recognition
	__value = wcstol(value, 0, 10);
	}

	Atom<Number_t>::Atom(int value)
	: __value(value) {
	}

	double
	Atom<Number_t>::get()const {
	return __value;
	}

	Atom<String_t>::Atom(const std::wstring& value) {
	assert(value.size() >= 2);
	__value = wstring_to_utf8(value.substr(1, value.size() - 2));
	}

	Atom<String_t>::Atom(std::string && name) : __value(name) {}

	const std::string&
	Atom<String_t>::get() const {
	return __value;
	}

	class ExpressionHints {
	public:

	static bool
	isStringValueValid(const Expression& e) {
	switch (e.__state) {
	case Expression::INVALID:
	assert(false);

	case Expression::IDENT:
	case Expression::STRING:
	return true;

	case Expression::NUMBER:
	case Expression::BINDING:
	return false;

	case Expression::COMPOUND:
	{
	switch (e.op) {
	case Operator::CALL:
	return true;

	default: return false;
	}
	}
	}

	return false;
	}

	static bool
	isDoubleValueValid(const Expression& e) {
	switch (e.__state) {
	case Expression::NUMBER:
	return true;

	case Expression::INVALID:
	assert(false);

	case Expression::IDENT:
	case Expression::STRING:
	case Expression::BINDING:
	return false;

	case Expression::COMPOUND: {
	switch (e.op) {
	case Operator::VARIANT:
	return true;
	default: return false;
	}
	}
	}

	return false;
	}
	};

	class TypesResolver {
	private:
	const AST* ast;
	std::map<std::string, TypeAnnotation> scope;
	std::map<TypeAnnotation, int> signatures;

	ExpandedType expandType(const TypeAnnotation &t, const std::vector<TypeAnnotation> &args = std::vector<TypeAnnotation>()) {
	return TypesResolver(ast, scope, signatures)(t, args);
	}

	std::vector<TypeAnnotation>
	expandOperands(const std::vector<TypeAnnotation>& operands) {
	std::vector<TypeAnnotation> pack;

	pack.reserve(operands.size());
	std::transform(operands.begin(), operands.end(), std::inserter(pack, pack.end()),
	[this](const TypeAnnotation & t) {
	return expandType(t);
	});

	return pack;
	}

	public:

	TypesResolver(const AST* root, const std::map<std::string, TypeAnnotation>& scopeOuter = std::map<std::string, TypeAnnotation>(),
	std::map<TypeAnnotation, int> signaturesOuter = std::map<TypeAnnotation, int>())
	: ast(root), scope(scopeOuter), signatures(signaturesOuter) {
	}

	ExpandedType
	operator()(const TypeAnnotation &t, const std::vector<TypeAnnotation> &args = std::vector<TypeAnnotation>()) {
	//assert(args.size() == t.bindings.size()); // invalid number of arguments
	for (size_t i = 0; i < args.size(); ++i) {
	scope[t.bindings.at(i)] = args.at(i);
	}

	switch (t.__operator) {
	case TypeOperator::ARRAY:
	{
	assert(t.__operands.size() == 1);

	Expanded<TypeAnnotation> elTy = expandType(t.__operands.at(0));
	return ExpandedType(TypeAnnotation(tag_array, elTy, 0));
	}

	case TypeOperator::STRUCT:
	{
	assert(t.__operands.size());

	std::vector<TypeAnnotation>&& packOperands = expandOperands(t.__operands);
	auto typNew = TypeAnnotation(TypeOperator::STRUCT, move(packOperands));
	typNew.fields = t.fields;

	return ExpandedType(move(typNew));
	};

	case TypeOperator::CALL:
	{
	std::string alias = t.__valueCustom;

	//find in local scope:
	TypeAnnotation ty;
	if (scope.count(alias)) {
	ty = scope.at(alias);

	} else if (ast->__indexTypeAliases.count(alias)) {
	ty = ast->__indexTypeAliases.at(alias);

	} else {
	assert(false && "Undefined or external type");
	}

	std::vector<TypeAnnotation>&& operands = expandOperands(t.__operands);
	TypeAnnotation signature(TypeOperator::CALL, move(operands));
	signature.__valueCustom = alias;

	if (signatures.count(signature)) {
	auto link = TypeAnnotation(TypeOperator::LINK,{});
	link.conjuctionId = signatures.at(signature);

	return ExpandedType(move(link));
	}

	int cid = signatures.size();
	signatures[signature] = cid;
	TypeAnnotation tyResult = expandType(ty, operands);
	tyResult.conjuctionId = cid;

	return ExpandedType(move(tyResult));
	};

	case TypeOperator::CUSTOM:
	{
	std::string alias = t.__valueCustom;

	/*
	if (signatures.count(alias)) {
	return ExpandedType(TypeAnnotation(TypeOperator::LINK, {t}));
	}
	signatures[alias].emplace(t);
	*/

	//find in local scope:
	if (scope.count(alias)) {
	return expandType(scope.at(alias));
	}

	// find in general scope:
	if (ast->__indexTypeAliases.count(alias)) {
	return expandType(ast->__indexTypeAliases.at(t.__valueCustom));
	}

	//if type is unknown keep it as is.
	return ExpandedType(TypeAnnotation(t));
	};

	case TypeOperator::ACCESS:
	{
	std::string alias = t.__valueCustom;
	ExpandedType tyAlias = ExpandedType(TypeAnnotation());

	//find in local scope:
	if (scope.count(alias)) {
	tyAlias = expandType(scope.at(alias));

	//find in global scope:
	} else if ((ast->__indexTypeAliases.count(alias))) {
	tyAlias = expandType(ast->__indexTypeAliases.at(alias));

	} else {
	assert(false && "Undefined or external type");
	}

	assert(tyAlias->__operator == TypeOperator::STRUCT);

	for (const string& field : t.fields) {
	auto fieldIt = std::find(tyAlias->fields.begin(), tyAlias->fields.end(), field);
	assert(fieldIt != tyAlias->fields.end() && "unknown field");

	int fieldId = fieldIt - tyAlias->fields.begin();
	tyAlias = expandType(tyAlias->__operands.at(fieldId));
	}

	return tyAlias;
	}

	case TypeOperator::VARIANT:
	{
	return ExpandedType(TypeAnnotation(t));
	}

	case TypeOperator::NONE:
	{
	return ExpandedType(TypeAnnotation(t));
	}

	default:
	assert(false);
	}

	assert(false);
	return ExpandedType(TypeAnnotation());
	}
	};

	TypeAnnotation::TypeAnnotation()
	: __operator(TypeOperator::NONE), __value(TypePrimitive::Invalid) {
	}

	TypeAnnotation::TypeAnnotation(TypePrimitive typ)
	: __value(typ) {
	}

	TypeAnnotation::TypeAnnotation(TypeOperator op, std::initializer_list<TypeAnnotation> operands)
	: __operator(op), __operands(operands) {

	}

	TypeAnnotation::TypeAnnotation(TypeOperator op, std::vector<TypeAnnotation>&& operands)
	: __operator(op), __operands(operands) {
	}

	TypeAnnotation::TypeAnnotation(llvm_array_tag, TypeAnnotation typ, int size)
	: TypeAnnotation(TypeOperator::ARRAY,{typ}) {
	__size = size;
	}

	bool
	TypeAnnotation::isValid() const {
	return !(__value == TypePrimitive::Invalid && __operator == TypeOperator::NONE);
	}

	bool
	TypeAnnotation::operator<(const TypeAnnotation& t) const {
	if (__operator != t.__operator) return __operator < t.__operator;

	if (__operator == TypeOperator::NONE)
	return __value < t.__value;

	if (__operator == TypeOperator::CALL \|\| __operator == TypeOperator::CUSTOM \|\| __operator == TypeOperator::ACCESS) {
	if (__valueCustom != t.__valueCustom)
	return __valueCustom < t.__valueCustom;
	}

	return __operands < t.__operands;
	}

	/*
	TypeAnnotation (struct_tag, std::initializer_list<TypeAnnotation>)
	{}
	*/

	void
	TypeAnnotation::addBindings(std::vector<Atom<Identifier_t>>&& params) {
	bindings.reserve(bindings.size() + params.size());

	std::transform(params.begin(), params.end(), std::inserter(bindings, bindings.end()),
	[](const Atom<Identifier_t>& ident) {
	return ident.get(); });
	}

	void
	TypeAnnotation::addFields(std::vector<Atom<Identifier_t>>&& listFields) {
	fields.reserve(fields.size() + listFields.size());

	std::transform(listFields.begin(), listFields.end(), std::inserter(fields, fields.end()),
	[](const Atom<Identifier_t>& ident) {
	return ident.get(); });
	}

	unsigned int Expression::nextVacantId = 0;

	Expression::Expression(const Atom<Number_t>& number)
	: Expression() {
	__state = NUMBER;
	op = Operator::NONE;
	__valueD = number.get();
	}

	Expression::Expression(const Atom<String_t>& a)
	: Expression() {
	__state = STRING;
	op = Operator::NONE;
	__valueS = a.get();
	}

	Expression::Expression(const Atom<Identifier_t> &ident)
	: Expression() {
	__state = IDENT;
	op = Operator::NONE;
	__valueS = ident.get();
	}

	Expression::Expression(const Operator &oprt, std::initializer_list<Expression> params)
	: Expression() {
	__state = COMPOUND;
	op = oprt;

	if (op == Operator::CALL) {
	assert(params.size() > 0);
	Expression arg = *params.begin();

	assert(arg.__state == Expression::IDENT);
	__valueS = std::move(arg.__valueS);

	operands.insert(operands.end(), params.begin() + 1, params.end());
	return;
	}

	operands.insert(operands.end(), params.begin(), params.end());
	}

	void
	Expression::setOp(Operator oprt) {
	op = oprt;

	switch (op) {
	case Operator::NONE:
	__state = INVALID;
	break;

	default:
	__state = COMPOUND;
	break;
	}
	}

	void
	Expression::addArg(Expression &&arg) {
	operands.push_back(arg);
	}

	void
	Expression::addTags(const std::list<Expression> tags) const {
	std::transform(tags.begin(), tags.end(), std::inserter(this->tags, this->tags.end()),
	[](const Expression & tag) {
	return make_pair(tag.getValueString(), tag);
	});
	}

	void
	Expression::addBindings(std::initializer_list<Atom<Identifier_t>> params) {
	addBindings(params.begin(), params.end());
	}

	void
	Expression::bindType(TypeAnnotation t) {
	type = move(t);
	}

	void
	Expression::addBlock(ManagedScpPtr scope) {
	blocks.push_back(scope.operator->());
	}

	const std::vector<Expression>&
	Expression::getOperands() const {
	return operands;
	}

	double
	Expression::getValueDouble() const {
	return __valueD;
	}

	const std::string&
	Expression::getValueString() const {
	return __valueS;
	}

	void
	Expression::setValue(const Atom<Identifier_t>&& v) {
	__valueS = v.get();
	}

	void Expression::setValueDouble(double value) {
	__valueD = value;
	}

	bool
	Expression::isValid() const {
	return (__state != INVALID);
	}

	bool
	Expression::isDefined() const {
	- return (__state != BINDING);
	+ return (__state != BINDING && __state != INVALID);
	}

	Expression::Expression()
	: __state(INVALID), op(Operator::NONE), id(nextVacantId++) {
	}

	namespace details { namespace inconsistent {

	AST::AST() {
	Attachments::init<versions::VariableVersion>();
	- Attachments::init<Symbol>();
	+ Attachments::init<IdentifierSymbol>();
	+ Attachments::init<SymbolAlias>();
	}

	void
	AST::addInterfaceData(const ASTInterface& interface, Expression&& data) {
	__interfacesData.emplace(interface, move(data));
	}

	void
	AST::addDFAData(Expression &&data) {
	__dfadata.push_back(data);
	}

	void
	AST::addExternData(ExternData &&data) {
	__externdata.insert(__externdata.end(), data.entries.begin(), data.entries.end());
	}

	void
	AST::add(Function* f) {
	__functions.push_back(f);
	__indexFunctions.emplace(f->getName(), __functions.size() - 1);
	}

	void
	AST::add(MetaRuleAbstract *r) {
	__rules.push_back(r);
	}

	void
	AST::add(TypeAnnotation t, Atom<Identifier_t> alias) {
	if (t.__operator == TypeOperator::VARIANT) {
	for (int i = 0, size = t.fields.size(); i < size; ++i) {
	__dictVariants.emplace(t.fields[i], make_pair(t, i));
	}
	}

	__indexTypeAliases.emplace(alias.get(), move(t));
	}

	ManagedScpPtr
	AST::add(CodeScope* scope) {
	this->__scopes.push_back(scope);
	return ManagedScpPtr(this->__scopes.size() - 1, &this->__scopes);
	}

	std::string
	AST::getModuleName() {
	const std::string name = "moduleTest";

	return name;
	}

	ManagedPtr<Function>
	AST::findFunction(const std::string& name) {
	int count = __indexFunctions.count(name);
	if (!count) {
	return ManagedFnPtr::Invalid();
	}

	assert(count == 1);

	auto range = __indexFunctions.equal_range(name);
	return ManagedPtr<Function>(range.first->second, &this->__functions);
	}

	std::list<ManagedFnPtr>
	AST::getAllFunctions() const {
	const size_t size = __functions.size();

	std::list<ManagedFnPtr> result;
	for (size_t i = 0; i < size; ++i) {
	result.push_back(ManagedFnPtr(i, &this->__functions));
	}

	return result;
	}

	//TASK select default specializations
	std::list<ManagedFnPtr>
	AST::getFunctionSpecializations(const std::string& fnName) const {
	auto functions = __indexFunctions.equal_range(fnName);

	std::list<ManagedFnPtr> result;
	std::transform(functions.first, functions.second, inserter(result, result.end()),
	[this](auto f) {
	return ManagedFnPtr(f.second, &this->__functions);
	});

	return result;
	}

	template<>
	ManagedPtr<Function>
	AST::begin<Function>() {
	return ManagedPtr<Function>(0, &this->__functions);
	}

	template<>
	ManagedPtr<CodeScope>
	AST::begin<CodeScope>() {
	return ManagedPtr<CodeScope>(0, &this->__scopes);
	}

	template<>
	ManagedPtr<MetaRuleAbstract>
	AST::begin<MetaRuleAbstract>() {
	return ManagedPtr<MetaRuleAbstract>(0, &this->__rules);
	}

	void
	AST::recognizeVariantConstructor(Expression& function) {
	assert(function.op == Operator::CALL);

	std::string variant = function.getValueString();
	if (!__dictVariants.count(variant)) {
	return;
	}

	auto record = __dictVariants.at(variant);
	const TypeAnnotation& typ = record.first;

	function.op = Operator::VARIANT;
	function.setValueDouble(record.second);
	function.type = typ;
	}

	Atom<Number_t>
	AST::recognizeVariantConstructor(Atom<Identifier_t> ident) {
	std::string variant = ident.get();
	assert(__dictVariants.count(variant) && "Can't recognize variant constructor");
	auto record = __dictVariants.at(variant);

	return Atom<Number_t>(record.second);
	}

	void
	AST::postponeIdentifier(CodeScope* scope, const Expression& id) {
	bucketUnrecognizedIdentifiers.emplace(scope, id);
	}

	void
	AST::recognizePostponedIdentifiers() {
	for (const auto& identifier : bucketUnrecognizedIdentifiers) {
	if (!identifier.first->recognizeIdentifier(identifier.second)) {
	//exception: Ident not found
	std::cout << "Unknown symbol: " << identifier.second.getValueString() << std::endl;
	assert(false && "Symbol not found");
	}
	}
	}

	xreate::AST*
	AST::finalize() {
	//all finalization steps:
	recognizePostponedIdentifiers();

	return reinterpret_cast<xreate::AST*> (this);
	}

	} } //namespace details::incomplete

	Expanded<TypeAnnotation>
	AST::findType(const std::string& name) {
	// find in general scope:
	if (__indexTypeAliases.count(name))
	return expandType(__indexTypeAliases.at(name));

	//if type is unknown keep it as is.
	TypeAnnotation t(TypeOperator::CUSTOM,{});
	t.__valueCustom = name;
	return ExpandedType(move(t));
	}

	Expanded<TypeAnnotation>
	AST::expandType(const TypeAnnotation &t) const {
	return TypesResolver(this)(t);
	}

	ExpandedType
	AST::getType(const Expression& expression) {
	return typeinference::getType(expression, *this);
	}

	Function::Function(const Atom<Identifier_t>& name)
	: __entry(new CodeScope(0)) {
	__name = name.get();
	}

	void
	Function::addTag(Expression&& tag, const TagModifier mod) {
	string name = tag.getValueString();
	__tags.emplace(move(name), move(tag));
	}

	const std::map<std::string, Expression>&
	Function::getTags() const {
	return __tags;
	}

	CodeScope*
	Function::getEntryScope() const {
	return __entry;
	}

	void
	Function::addBinding(Atom <Identifier_t>&& name, Expression&& argument) {
	__entry->addBinding(move(name), move(argument));
	}

	const std::string&
	Function::getName() const {
	return __name;
	}

	ScopedSymbol
	CodeScope::registerIdentifier(const Expression& identifier) {
	versions::VariableVersion version = Attachments::get<versions::VariableVersion>(identifier, versions::VERSION_NONE);

	auto result = __identifiers.emplace(identifier.getValueString(), __vCounter);
	if (result.second) {
	++__vCounter;
	return { __vCounter - 1, version };
	}

	return { result.first->second, version };
	}

	bool
	CodeScope::recognizeIdentifier(const Expression& identifier) const {
	versions::VariableVersion version = Attachments::get<versions::VariableVersion>(identifier, versions::VERSION_NONE);
	const std::string& name = identifier.getValueString();

	//search identifier in the current block
	if (__identifiers.count(name)) {
	VNameId id = __identifiers.at(name);

	Symbol s;
	s.identifier = ScopedSymbol{id, version};
	s.scope = const_cast<CodeScope*> (this);
	- Attachments::put<Symbol>(identifier, s);
	+ Attachments::put<IdentifierSymbol>(identifier, s);

	return true;
	}

	//search in the parent scope
	if (__parent) {
	return __parent->recognizeIdentifier(identifier);
	}

	return false;
	}

	ScopedSymbol
	CodeScope::getSymbol(const std::string& alias) {
	assert(__identifiers.count(alias));
	VNameId id = __identifiers.at(alias);

	return {id, versions::VERSION_NONE };
	}

	void
	CodeScope::addBinding(Expression&& var, Expression&& argument) {
	argument.__state = Expression::BINDING;

	__bindings.push_back(var.getValueString());
	ScopedSymbol binding = registerIdentifier(var);
	__declarations[binding] = move(argument);
	}

	-void
	+Symbol
	CodeScope::addDefinition(Expression&& var, Expression&& body) {
	ScopedSymbol s = registerIdentifier(var);
	__declarations[s] = move(body);
	+
	+ return Symbol{s, this};
	}

	CodeScope::CodeScope(CodeScope* parent)
	: __parent(parent) {
	}

	CodeScope::~CodeScope() {
	}

	void
	CodeScope::setBody(const Expression &body) {
	assert(__declarations.count(ScopedSymbol::RetSymbol)==0 && "Attempt to reassign scope body");
	__declarations[ScopedSymbol::RetSymbol] = body;
	}

	Expression&
	CodeScope::getBody() {
	return __declarations[ScopedSymbol::RetSymbol];
	}

	const Expression&
	-CodeScope::getDefinition(const Symbol& symbol) {
	+CodeScope::getDefinition(const Symbol& symbol, bool flagAllowUndefined){
	CodeScope* self = symbol.scope;
	- return self->getDefinition(symbol.identifier);
	+ return self->getDefinition(symbol.identifier, flagAllowUndefined);
	}

	const Expression&
	-CodeScope::getDefinition(const ScopedSymbol& symbol) {
	- assert(__declarations.count(symbol) && "Symbol's declaration not found");
	+CodeScope::getDefinition(const ScopedSymbol& symbol, bool flagAllowUndefined) const{
	+ static Expression expressionInvalid;
	+
	+ if (!__declarations.count(symbol)){
	+ if (flagAllowUndefined) return expressionInvalid;
	+ assert(false && "Symbol's declaration not found");
	+ }

	return __declarations.at(symbol);
	}

	void
	RuleArguments::add(const Atom<Identifier_t> &arg, DomainAnnotation typ) {
	emplace_back(arg.get(), typ);
	}

	void
	RuleGuards::add(Expression&& e) {
	push_back(e);
	}

	MetaRuleAbstract::
	MetaRuleAbstract(RuleArguments&& args, RuleGuards&& guards)
	: __args(std::move(args)), __guards(std::move(guards)) {
	}

	MetaRuleAbstract::~MetaRuleAbstract() {
	}

	RuleWarning::
	RuleWarning(RuleArguments&& args, RuleGuards&& guards, Expression&& condition, Atom<String_t>&& message)
	: MetaRuleAbstract(std::move(args), std::move(guards)), __message(message.get()), __condition(condition) {
	}

	RuleWarning::~RuleWarning() {
	}

	void
	RuleWarning::compile(ClaspLayer& layer) {
	//TODO restore addRuleWarning
	//layer.addRuleWarning(*this);
	}

	bool operator<(const ScopedSymbol& s1, const ScopedSymbol& s2) {
	return (s1.id < s2.id) \|\| (s1.id == s2.id && s1.version < s2.version);
	}

	bool operator==(const ScopedSymbol& s1, const ScopedSymbol& s2) {
	return (s1.id == s2.id) && (s1.version == s2.version);
	}

	bool operator<(const Symbol& s1, const Symbol& s2) {
	return (s1.scope < s2.scope) \|\| (s1.scope == s2.scope && s1.identifier < s2.identifier);
	}

	bool operator==(const Symbol& s1, const Symbol& s2) {
	return (s1.scope == s2.scope) && (s1.identifier == s2.identifier);
	}

	bool operator<(const Expression&a, const Expression&b) {
	if (a.__state != b.__state) return a.__state < b.__state;
	assert(a.__state != Expression::INVALID);
	switch (a.__state) {
	case Expression::IDENT:
	case Expression::STRING:
	return a.getValueString() < b.getValueString();

	case Expression::NUMBER:
	return a.getValueDouble() < b.getValueDouble();

	case Expression::COMPOUND:
	{
	assert(a.blocks.size() == 0);
	assert(b.blocks.size() == 0);

	if (a.op != b.op) {
	return a.op < b.op;
	}

	bool flagAValid = ExpressionHints::isStringValueValid(a);
	bool flagBValid = ExpressionHints::isStringValueValid(b);

	if (flagAValid != flagBValid) {
	return flagAValid < flagBValid;
	}

	if (flagAValid) {
	if (a.getValueString() != b.getValueString()) {
	return a.getValueString() < b.getValueString();
	}
	}

	flagAValid = ExpressionHints::isDoubleValueValid(a);
	flagBValid = ExpressionHints::isDoubleValueValid(b);

	if (flagAValid != flagBValid) {
	return flagAValid < flagBValid;
	}

	if (flagAValid) {
	if (a.getValueDouble() != b.getValueDouble()) {
	return a.getValueDouble() < b.getValueDouble();
	}
	}

	if (a.operands.size() != b.operands.size()) {
	return (a.operands.size() < b.operands.size());
	}

	for (size_t i = 0; i < a.operands.size(); ++i) {
	bool result = a.operands[i] < b.operands[i];
	if (result) return true;
	}

	return false;
	}

	case Expression::BINDING:
	case Expression::INVALID:
	assert(false);
	}

	return false;
	}

	bool
	Expression::operator==(const Expression& other) const {
	if (this->__state != other.__state) return false;

	if (ExpressionHints::isStringValueValid(*this)) {
	if (this->__valueS != other.__valueS) return false;
	}

	if (ExpressionHints::isDoubleValueValid(*this)) {
	if (this->__valueD != other.__valueD) return false;
	}

	if (this->__state != Expression::COMPOUND) {
	return true;
	}

	if (this->op != other.op) {
	return false;
	}

	if (this->operands.size() != other.operands.size()) {
	return false;
	}

	for (size_t i = 0; i<this->operands.size(); ++i) {
	if (!(this->operands[i] == other.operands[i])) return false;
	}

	assert(!this->blocks.size());
	assert(!other.blocks.size());

	return true;
	}

	const ScopedSymbol
	ScopedSymbol::RetSymbol = ScopedSymbol{0, versions::VERSION_NONE};

	} //end of namespace xreate




	diff --git a/cpp/src/ast.h b/cpp/src/ast.h
	index 66a0f46..cea76a7 100644
	--- a/cpp/src/ast.h
	+++ b/cpp/src/ast.h
	@@ -1,711 +1,727 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* Author: pgess <v.melnychenko@xreate.org>
	* File: ast.h
	*/

	#ifndef AST_H
	#define AST_H

	#include "attachments.h"

	#include <vector>
	#include <stdlib.h>
	#include <string>
	#include <list>
	#include <unordered_map>
	#include <unordered_set>
	#include <climits>
	#include "utils.h"
	#include <algorithm>

	namespace llvm {
	class Value;
	}

	namespace xreate {
	struct ScopedSymbol;
	struct Symbol;
	}

	namespace std {
	template<>
	struct hash<xreate::ScopedSymbol> {
	std::size_t operator()(xreate::ScopedSymbol const& s) const;
	};

	template<>
	struct equal_to<xreate::ScopedSymbol> {
	bool operator()(const xreate::ScopedSymbol& __x, const xreate::ScopedSymbol& __y) const;
	};

	template<>
	struct hash<xreate::Symbol> {
	size_t operator()(xreate::Symbol const& s) const;
	};

	template<>
	struct equal_to<xreate::Symbol> {
	bool operator()(const xreate::Symbol& __x, const xreate::Symbol& __y) const;
	};
	}

	namespace xreate {

	struct String_t {
	};

	struct Identifier_t {
	};

	struct Number_t {
	};

	struct Type_t {
	};

	template<typename A>
	class Atom {
	};

	//DEBT store line:col for all atoms/identifiers
	template<> class
	Atom<Identifier_t> {
	public:
	Atom(const std::wstring& value);
	Atom(std::string && name);
	const std::string& get() const;

	private:
	std::string __value;
	};

	template<>
	class Atom<Number_t> {
	public:
	Atom(wchar_t* value);
	Atom(int value);
	double get()const;

	private:
	double __value;
	};

	template<>
	class Atom<String_t> {
	public:
	Atom(const std::wstring& value);
	Atom(std::string && name);
	const std::string& get() const;

	private:
	std::string __value;
	};

	enum class TypePrimitive {
	Invalid, Bool, I8, I32, I64, Num, Int, Float, String
	};

	enum class TypeOperator {
	NONE, CALL, CUSTOM, VARIANT, ARRAY, STRUCT, ACCESS, LINK
	};

	struct llvm_array_tag {
	};

	struct struct_tag {
	};
	const llvm_array_tag tag_array = llvm_array_tag();
	const struct_tag tag_struct = struct_tag();

	/**
	* \brief Represents type to support type system
	*
	* This class represents type in denormalized form, i.e. without arguments and aliases substitution
	* \sa AST::expandType()
	*/
	class TypeAnnotation {
	public:
	TypeAnnotation();
	TypeAnnotation(const Atom<Type_t>& typ);
	TypeAnnotation(TypePrimitive typ);
	TypeAnnotation(llvm_array_tag, TypeAnnotation typ, int size);

	TypeAnnotation(TypeOperator op, std::initializer_list<TypeAnnotation> operands);
	TypeAnnotation(TypeOperator op, std::vector<TypeAnnotation>&& operands);
	void addBindings(std::vector<Atom<Identifier_t>>&& params);
	void addFields(std::vector<Atom<Identifier_t>>&& listFields);
	bool operator<(const TypeAnnotation& t) const;
	// TypeAnnotation (struct_tag, std::initializer_list<TypePrimitive>);

	bool isValid() const;

	TypeOperator __operator = TypeOperator::NONE;

	std::vector<TypeAnnotation> __operands;
	TypePrimitive __value;
	std::string __valueCustom;
	int conjuctionId = -1; //conjunction point id (relevant for recursive types)

	uint64_t __size = 0;
	std::vector<std::string> fields;
	std::vector<std::string> bindings;
	private:
	};

	enum class Operator {
	ADD, SUB, MUL, DIV,
	EQU, NE, NEG, LSS,
	LSE, GTR, GTE, LIST,
	LIST_RANGE, LIST_NAMED,
	CALL, CALL_INTRINSIC, NONE,
	IMPL/* implication */, MAP,
	FOLD, FOLD_INF, LOOP_CONTEXT,
	INDEX, IF, SWITCH, SWITCH_ADHOC, SWITCH_VARIANT,
	CASE, CASE_DEFAULT, LOGIC_AND,
	ADHOC, CONTEXT_RULE, VARIANT
	};

	class Function;
	class AST;
	class CodeScope;
	class MetaRuleAbstract;

	typedef ManagedPtr<Function> ManagedFnPtr;
	typedef ManagedPtr<CodeScope> ManagedScpPtr;
	typedef ManagedPtr<MetaRuleAbstract> ManagedRulePtr;
	const ManagedScpPtr NO_SCOPE = ManagedScpPtr(UINT_MAX, 0);

	/**
	* \brief Represents every instruction in Xreate's syntax tree
	* \attention In case of any changes update xreate::ExpressionHints auxiliary helper as well
	*
	* Expression is generic building block of syntax tree able to hold node data
	* as well as child nodes as operands. Not only instructions use expression for representation in syntax tree
	* but annotation as well.
	*
	* Additionally, `types` as a special kind of annotations use Expression-like data structure TypeAnnotation
	* \sa xreate::AST, xreate::TypeAnnotation
	*/
	//
	struct Expression {
	friend class CodeScope;
	friend class ClaspLayer;
	friend class CFAPass;
	friend class ExpressionHints;

	Expression(const Operator &oprt, std::initializer_list<Expression> params);
	Expression(const Atom<Identifier_t>& ident);
	Expression(const Atom<Number_t>& number);
	Expression(const Atom<String_t>& a);

	Expression();

	void setOp(Operator oprt);
	void addArg(Expression&& arg);
	void addBindings(std::initializer_list<Atom<Identifier_t>> params);
	void bindType(TypeAnnotation t);

	template<class InputIt>
	void addBindings(InputIt paramsBegin, InputIt paramsEnd);
	void addTags(const std::list<Expression> tags) const;
	void addBlock(ManagedScpPtr scope);

	const std::vector<Expression>& getOperands() const;
	double getValueDouble() const;
	void setValueDouble(double value);
	const std::string& getValueString() const;
	void setValue(const Atom<Identifier_t>&& v);
	bool isValid() const;
	bool isDefined() const;


	bool operator==(const Expression& other) const;

	/**
	* \brief is it string, number, compound operation and so on
	*/
	enum {
	INVALID, COMPOUND, IDENT, NUMBER, STRING, BINDING
	} __state = INVALID;

	/**
	* \brief Valid for compound State. Holds type of compound operator
	*/
	Operator op;

	/**
	* \brief Unique id to identify expression within syntax tree
	*/
	unsigned int id;

	/**
	* \brief Exact meaning depends on particular instruction
	* \details As an example, named lists/structs hold field names in bindings
	*/
	std::vector<std::string> bindings;
	std::map<std::string, size_t> __indexBindings;

	/**
	* \brief Holds child instructions as arguments
	*/
	std::vector<Expression> operands;

	/**
	* \brief Holds type of instruction's result
	*/
	TypeAnnotation type;

	/**
	* \brief Holds additional annotations
	*/
	mutable std::map<std::string, Expression> tags;

	/**
	* \brief Child code blocks
	* \details For example, If statement holds TRUE-branch as first and FALSE-branch as second block here
	*/
	std::list<CodeScope*> blocks;

	private:
	std::string __valueS;
	double __valueD;

	static unsigned int nextVacantId;
	};

	bool operator<(const Expression&, const Expression&);

	template<class InputIt>
	void Expression::addBindings(InputIt paramsBegin, InputIt paramsEnd) {
	size_t index = bindings.size();

	std::transform(paramsBegin, paramsEnd, std::inserter(bindings, bindings.end()),
	[&index, this] (const Atom<Identifier_t> atom) {
	std::string key = atom.get();
	this->__indexBindings[key] = index++;
	return key;
	});
	}

	typedef std::list<Expression> ExpressionList;

	enum class TagModifier {
	NONE, ASSERT, REQUIRE
	};

	enum class DomainAnnotation {
	FUNCTION, VARIABLE
	};

	class RuleArguments : public std::vector<std::pair<std::string, DomainAnnotation>>
	{
	public:
	void add(const Atom<Identifier_t>& name, DomainAnnotation typ);
	};

	class RuleGuards : public std::vector<Expression> {
	public:
	void add(Expression&& e);
	};


	class ClaspLayer;
	class LLVMLayer;

	class MetaRuleAbstract {
	public:
	MetaRuleAbstract(RuleArguments&& args, RuleGuards&& guards);
	virtual ~MetaRuleAbstract();
	virtual void compile(ClaspLayer& layer) = 0;
	protected:
	RuleArguments __args;
	RuleGuards __guards;
	};

	class RuleWarning : public MetaRuleAbstract {
	friend class ClaspLayer;
	public:
	RuleWarning(RuleArguments&& args, RuleGuards&& guards, Expression&& condition, Atom<String_t>&& message);
	virtual void compile(ClaspLayer& layer);
	~RuleWarning();

	private:
	std::string __message;
	Expression __condition;
	};

	typedef unsigned int VNameId;

	namespace versions {
	typedef int VariableVersion;
	const VariableVersion VERSION_NONE = -2;
	const VariableVersion VERSION_INIT = 0;
	}

	template<>
	struct AttachmentsDict<versions::VariableVersion> {
	typedef versions::VariableVersion Data;
	static const unsigned int key = 6;
	};

	struct ScopedSymbol {
	VNameId id;
	versions::VariableVersion version;

	static const ScopedSymbol RetSymbol;
	};

	struct Symbol {
	ScopedSymbol identifier;
	CodeScope * scope;
	};

	+struct IdentifierSymbol{};
	+struct SymbolAlias{};
	+
	template<>
	-struct AttachmentsDict<Symbol> {
	+struct AttachmentsDict<IdentifierSymbol> {
	typedef Symbol Data;
	static const unsigned int key = 7;
	};

	+template<>
	+struct AttachmentsDict<SymbolAlias> {
	+ typedef Symbol Data;
	+ static const unsigned int key = 9;
	+};
	+
	typedef std::pair<Expression, TagModifier> Tag;

	bool operator<(const ScopedSymbol& s1, const ScopedSymbol& s2);
	bool operator==(const ScopedSymbol& s1, const ScopedSymbol& s2);
	bool operator<(const Symbol& s1, const Symbol& s2);
	bool operator==(const Symbol& s1, const Symbol& s2);

	/**
	* \brief Represents code block and single scope of visibility
	*
	* Holds single expression as a body and set of variable assignments(declarations) used in body's expression
	* \sa xreate::AST
	*/
	class CodeScope {
	friend class Function;
	friend class PassManager;

	public:
	CodeScope(CodeScope* parent = 0);
	~CodeScope();

	/** \brief Set expression as a body */
	void setBody(const Expression& body);

	/** \brief Returns current code scope body */
	Expression& getBody();

	/** \brief Adds variable definition to be used in body as well as in other declarations */
	- void addDefinition(Expression&& var, Expression&& body);
	+ Symbol addDefinition(Expression&& var, Expression&& body);

	/** \brief Returns symbols' definition */
	- static const Expression& getDefinition(const Symbol& symbol);
	- const Expression& getDefinition(const ScopedSymbol& symbol);
	+ static const Expression& getDefinition(const Symbol& symbol, bool flagAllowUndefined = false);
	+ const Expression& getDefinition(const ScopedSymbol& symbol, bool flagAllowUndefined = false) const;

	/** \brief Adds variable defined elsewhere */
	void addBinding(Expression&& var, Expression&& argument);

	std::vector<std::string> __bindings;
	std::map<std::string, VNameId> __identifiers;
	CodeScope* __parent;

	//TODO move __definitions to SymbolsAttachments data
	//NOTE: definition of return type has index 0
	std::unordered_map<ScopedSymbol, Expression> __declarations;
	std::vector<Expression> tags;
	std::vector<Expression> contextRules;

	private:
	VNameId __vCounter = 1;
	ScopedSymbol registerIdentifier(const Expression& identifier);

	public:
	bool recognizeIdentifier(const Expression& identifier) const;
	ScopedSymbol getSymbol(const std::string& alias);
	};

	/**
	* \brief Represents single function in Xreate's syntax tree
	*
	* Holds an entry code scope and `guardContext` required for function to operate
	* \sa xreate::AST
	*/
	class Function {
	friend class Expression;
	friend class CodeScope;
	friend class AST;

	public:
	Function(const Atom<Identifier_t>& name);

	/**
	* \brief Adds function arguments
	*/
	void addBinding(Atom <Identifier_t>&& name, Expression&& argument);

	/**
	* \brief Adds additional function annotations
	*/
	void addTag(Expression&& tag, const TagModifier mod);

	const std::string& getName() const;
	const std::map<std::string, Expression>& getTags() const;
	CodeScope* getEntryScope() const;
	CodeScope* __entry;
	std::string __name;
	bool isPrefunction = false; //SECTIONTAG adhoc Function::isPrefunction flag

	Expression guardContext;
	Expression guard;
	private:

	std::map<std::string, Expression> __tags;
	};


	class ExternData;

	struct ExternEntry {
	std::string package;
	std::vector<std::string> headers;
	};

	typedef Expanded<TypeAnnotation> ExpandedType;

	enum ASTInterface {
	CFA, DFA, Extern, Adhoc
	};

	struct FunctionSpecialization {
	std::string guard;
	size_t id;
	};

	struct FunctionSpecializationQuery {
	std::unordered_set<std::string> context;
	};

	template<>
	struct AttachmentsId<Expression>{
	static unsigned int getId(const Expression& expression){
	return expression.id;
	}
	};

	template<>
	struct AttachmentsId<Symbol>{
	static unsigned int getId(const Symbol& s){
	return s.scope->__declarations.at(s.identifier).id;
	}
	};

	template<>
	struct AttachmentsId<ManagedFnPtr>{
	static unsigned int getId(const ManagedFnPtr& f){
	const Symbol symbolFunction{ScopedSymbol::RetSymbol, f->getEntryScope()};

	return AttachmentsId<Symbol>::getId(symbolFunction);
	}
	};

	+template<>
	+struct AttachmentsId<unsigned int>{
	+ static unsigned int getId(const unsigned int id){
	+ return id;
	+ }
	+};
	+
	class TypesResolver;
	namespace details { namespace inconsistent {

	/**
	* \brief Syntax tree under construction in inconsistent form
	*
	* Represents Syntax Tree under construction(inconsistent state).
	* \attention Clients should use rather xreate::AST unless client's code explicitly works with Syntax Tree during construction.
	*
	* Typically instance only created by xreate::XreateManager and filled in by Parser
	* \sa xreate::XreateManager::prepare(std::string&&)
	*/
	class AST {
	friend class xreate::TypesResolver;
	public:
	AST();

	/**
	* \brief Adds new function to AST
	* \param f Function to register
	*/
	void add(Function* f);

	/**
	* \brief Adds new declarative rule to AST
	* \param r Declarative Rule
	*/
	void add(MetaRuleAbstract* r);

	/** \brief Registers new code block */
	ManagedScpPtr add(CodeScope* scope);

	/**
	* \brief Add new type to AST
	* @param t Type definition
	* @param alias Typer name
	*/
	void add(TypeAnnotation t, Atom<Identifier_t> alias);

	/** \brief Current module's name */
	std::string getModuleName();

	/**
	* \brief Looks for function with given name
	* \param name Function name to find
	* \note Requires that only one function exists under given name
	* \return Found function
	*/
	ManagedPtr<Function> findFunction(const std::string& name);

	/** \brief Returns all function in AST */
	std::list<ManagedFnPtr> getAllFunctions() const;

	/**
	* \brief Returns all specializations of a function with a given name
	* \param fnName function to find
	* \return list of found function specializations
	*/
	std::list<ManagedFnPtr> getFunctionSpecializations(const std::string& fnName) const;

	/**
	* \return First element in Functions/Scopes/Rules list depending on template parameter
	* \tparam Target either Function or CodeScope or MetaRuleAbstract
	*/
	template<class Target>
	ManagedPtr<Target> begin();

	/**
	* \brief Performs all necessary steps after AST is built
	*
	* Performs all finzalisation steps and move AST into consistent state represented by xreate::AST
	* \sa xreate::AST
	* \return AST in consistent state
	*/
	xreate::AST* finalize();

	typedef std::multimap<std::string, unsigned int> FUNCTIONS_REGISTRY;

	std::vector<ExternEntry> __externdata;
	std::list<Expression> __dfadata; //TODO move to more appropriate place
	std::list<std::string> __rawImports; //TODO move to more appropriate place
	std::multimap<ASTInterface, Expression> __interfacesData; //TODO CFA data here.

	private:
	std::vector<MetaRuleAbstract*> __rules;
	std::vector<Function*> __functions;
	std::vector<CodeScope*> __scopes;

	FUNCTIONS_REGISTRY __indexFunctions;

	protected:
	std::map<std::string, TypeAnnotation> __indexTypeAliases;

	public:
	/**
	* \brief Stores DFA scheme for later use by DFA Pass
	*
	* Treats expression as a DFA scheme and feeds to a DFA Pass later
	* \paramn Expression DFA Scheme
	* \sa xreate::DFAPass
	*/
	void addDFAData(Expression&& data);

	/** \brief Stores data for later use by xreate::ExternLayer */
	void addExternData(ExternData&& data);

	/**
	* \brief Generalized function to store particular data for later use by particular pass
	* \param interface Particular Interface
	* \param data Particular data
	*/
	void addInterfaceData(const ASTInterface& interface, Expression&& data);


	/*\name Symbols Recognition /
	///@{
	public:
	//TODO revisit enums/variants, move to codescope
	/**
	* \brief Tries to find out whether expression is Variant constructor
	*/
	void recognizeVariantConstructor(Expression& function);
	Atom<Number_t> recognizeVariantConstructor(Atom<Identifier_t> ident);

	private:
	std::map<std::string, std::pair<TypeAnnotation, int>> __dictVariants;

	public:
	std::set<std::pair<CodeScope*, Expression>> bucketUnrecognizedIdentifiers;

	public:
	/**
	* \brief Postpones unrecognized identifier for future second round of recognition
	* \param scope Code block identifier is encountered
	* \param id Identifier
	*/
	void postponeIdentifier(CodeScope* scope, const Expression& id);

	/** \brief Second round of identifiers recognition done right after AST is fully constructed */
	void recognizePostponedIdentifiers();
	///@}
	};

	template<>
	ManagedPtr<Function>
	AST::begin<Function>();

	template<>
	ManagedPtr<CodeScope>
	AST::begin<CodeScope>();

	template<>
	ManagedPtr<MetaRuleAbstract>
	AST::begin<MetaRuleAbstract>();

	} } // namespace details::incomplete

	/**
	* \brief Xreate's Syntax Tree in consistent state
	*
	* Syntax Tree has two mutually exclusive possible states:
	* - inconsistent state while AST is under construction. Represented by xreate::details::inconsistent::AST
	* - consistent state when AST is built and finalize() is done.
	*
	* This class represents consistent state and should be used everywhere unless client's code explicitly works with AST under construction.
	* Consistent AST enables access to additional functions(currently related to type management).
	* \sa xreate::details::inconsistent::AST
	*/
	class AST : public details::inconsistent::AST {
	public:

	AST() : details::inconsistent::AST() {}

	/**
	* \brief Computes fully expanded form of type by substituting all arguments and aliases
	* \param t Type to expand
	* \return Expdanded or normal form of type
	* \sa TypeAnnotation
	*/
	ExpandedType expandType(const TypeAnnotation &t) const;

	/**
	* Searches type by given name
	* \param name Typename to search
	* \return Expanded or normal form of desired type
	* \note if type name is not found returns new undefined type with this name
	*/
	ExpandedType findType(const std::string& name);

	/**
	* Invokes Type Inference Analysis to find out expanded(normal) form expressions's type
	* \sa typeinference.h
	* \param expression
	* \return Type of expression

	*/
	ExpandedType getType(const Expression& expression);
	};
	}
	#endif // AST_H
	diff --git a/cpp/src/attachments.h b/cpp/src/attachments.h
	index 5812a6d..40a6db7 100644
	--- a/cpp/src/attachments.h
	+++ b/cpp/src/attachments.h
	@@ -1,175 +1,177 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* Author: pgess <v.melnychenko@xreate.org>
	* File: attachments.h
	* Date: 3/15/15
	*/

	#ifndef _XREATE_ATTACHMENTS_H_
	#define _XREATE_ATTACHMENTS_H_
	#include <unordered_map>
	#include <vector>
	#include <assert.h>
	#include <type_traits>

	namespace xreate
	{
	//Attachments dictionary
	template<class Tag>
	struct AttachmentsDict
	{
	// typedef void Data;
	- // static const unsigned int key (current unreserved - 9);
	+ // static const unsigned int key (current unreserved - 11);
	//reserved attachments:
	// 1 containers::Implementation
	// 3 interpretation::InterpretationData
	// 5 interpretation::FunctionInterpretationData
	// 6 VariableVersion
	-// 7 Symbol
	+// 7 IdentifierSymbol
	// 8 versions::VersionImposedDependency
	+// 9 SymbolAlias
	+// 10 CallGuard Expression
	};

	template<class Object>
	struct AttachmentsId{
	//static unsigned int getId(const Object& object);
	};


	template<class Data>
	class IAttachmentsContainer{
	protected:
	virtual bool __exists(const unsigned int object)=0;
	virtual Data& __get(const unsigned int object)=0;
	virtual void __put(const unsigned int object, Data data)=0;

	public:
	template<class Id>
	bool exists(const Id& object){
	unsigned int id = AttachmentsId<Id>::getId(object);

	return __exists(id);
	}

	template<class Id>
	Data& get(const Id& object){
	unsigned int id = AttachmentsId<Id>::getId(object);

	return __get(id);
	}

	template<class Id>
	Data get(const Id& object, const Data& dataDefault){
	unsigned int id = AttachmentsId<Id>::getId(object);

	if (! __exists(id)){
	return dataDefault;
	}

	return __get(id);
	}

	template<class Id>
	void put(const Id& object, Data data){
	unsigned int id = AttachmentsId<Id>::getId(object);

	__put(id, data);
	}

	virtual ~IAttachmentsContainer(){};
	};

	template<class Data>
	class AttachmentsContainerDefault: public IAttachmentsContainer<Data>{
	private:
	std::unordered_map<unsigned int, Data> __data;

	virtual bool __exists(const unsigned int id){
	return __data.count(id);
	}

	virtual Data& __get(const unsigned int id){
	return __data.at(id);
	}

	virtual void __put(const unsigned int id, Data data){
	auto result = __data.emplace(id, data);
	assert(result.second);
	}

	public:
	std::unordered_map<unsigned int, Data>& getRawStorage() {
	return __data;
	}
	};


	class Attachments{
	private:
	static std::vector<void*> __storage;

	template<class Tag>
	using Data = typename AttachmentsDict<Tag>::Data;

	public:
	template<class Tag, class Id>
	static bool exists(const Id& object) {
	assert(AttachmentsDict<Tag>::key < __storage.size());
	assert(__storage.at(AttachmentsDict<Tag>::key));

	IAttachmentsContainer<Data<Tag>>* self = reinterpret_cast<IAttachmentsContainer<Data<Tag>>*>(__storage.at(AttachmentsDict<Tag>::key));
	return self->exists<Id>(object);
	}

	template<class Tag, class Id>
	static Data<Tag>& get(const Id& object){
	assert(AttachmentsDict<Tag>::key < __storage.size());
	assert(__storage.at(AttachmentsDict<Tag>::key));

	IAttachmentsContainer<Data<Tag>>* self = reinterpret_cast<IAttachmentsContainer<Data<Tag>>*>(__storage.at(AttachmentsDict<Tag>::key));
	return self->get<Id>(object);
	}

	template<class Tag, class Id>
	static Data<Tag> get(const Id& object, const Data<Tag>& dataDefault){
	assert(AttachmentsDict<Tag>::key < __storage.size());
	assert(__storage.at(AttachmentsDict<Tag>::key));

	IAttachmentsContainer<Data<Tag>>* self = reinterpret_cast<IAttachmentsContainer<Data<Tag>>*>(__storage.at(AttachmentsDict<Tag>::key));
	return self->get<Id>(object, dataDefault);
	}

	template<class Tag, class Id>
	static void put(const Id& object, Data<Tag> data){
	assert(AttachmentsDict<Tag>::key < __storage.size());
	assert(__storage.at(AttachmentsDict<Tag>::key));

	IAttachmentsContainer<Data<Tag>>* self = reinterpret_cast<IAttachmentsContainer<Data<Tag>>*>(__storage.at(AttachmentsDict<Tag>::key));
	self->put<Id>(object, data);
	}

	template<class Tag>
	static void init(){
	unsigned int keyStorage = AttachmentsDict<Tag>::key;
	if (keyStorage+1 > __storage.size()){
	__storage.resize(keyStorage + 1, nullptr);
	}

	__storage[keyStorage] = new AttachmentsContainerDefault<Data<Tag>>();
	}

	template<class Tag>
	static void init(IAttachmentsContainer<Data<Tag>>* container){
	unsigned int keyStorage = AttachmentsDict<Tag>::key;
	if (keyStorage+1 > __storage.size()){
	__storage.resize(keyStorage + 1, nullptr);
	}

	__storage[keyStorage] = container;
	}
	};

	}

	#endif //_XREATE_ATTACHMENTS_H_
	diff --git a/cpp/src/clasplayer.cpp b/cpp/src/clasplayer.cpp
	index 8294af4..5dc47e5 100644
	--- a/cpp/src/clasplayer.cpp
	+++ b/cpp/src/clasplayer.cpp
	@@ -1,387 +1,382 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* Author: pgess <v.melnychenko@xreate.org>
	* File: clasplayer.cpp
	*/

	/**
	* \file clasplayer.h
	* \brief Resoner. Wrapper over Clasp reasoner library
	*/

	#include "clasplayer.h"
	-
	-#include <iostream>
	+#include "analysis/aux.h"
	#include "utils.h"
	+
	+#include <gringo/scripts.hh>
	#include <boost/format.hpp>
	#include <boost/algorithm/string/join.hpp>
	-#include <gringo/scripts.hh>
	-
	-#include "analysis/aux.h"
	-#include "analysis/DominatorsTreeAnalysisProvider.h"
	-#include "analysis/cfagraph.h"
	-#include "analysis/dfagraph.h"
	+#include <iostream>

	using namespace std;

	//TODO escape identifiers started with upper case symbol
	namespace xreate {

	void
	ClaspLayer::printWarnings(std::ostream& out)
	{
	const std::string warningTag = "warning";

	auto warningsRange = __model.equal_range(warningTag);

	for (auto warning=warningsRange.first; warning!= warningsRange.second; ++warning) {
	unsigned int warningId;

	Gringo::Symbol params;
	std::tie(warningId, params) = parse<unsigned int, Gringo::Symbol>(warning->second);

	cout << "Warning: " << __warnings.at(warningId) << " ";
	params.print(out);
	out<<params;
	}
	}

	bool
	ClaspLayer::handleSolution(Gringo::Model const &model) {
	std::list<std::string> warnings;
	cout << "Model: " << endl;

	const string& atomBindVar = Config::get("clasp.bindings.variable");
	const string& atomBindFunc = Config::get("clasp.bindings.function");
	const string& atomBindScope = Config::get("clasp.bindings.scope");

	for (Gringo::Symbol atom : model.atoms(clingo_show_type_atoms)) {
	atom.print(cout);
	cout <<" \| "<< endl;

	string atomName(atom.name().c_str());
	if (atomName == atomBindVar \|\| atomName == atomBindFunc \|\| atomName == atomBindScope){
	string name = std::get<1>(parse<Gringo::Symbol, Gringo::Symbol>(atom)).name().c_str();
	__model.emplace(move(name), move(atom));
	}

	__model.emplace(atomName, move(atom));
	}

	return true;
	}

	void
	-ClaspLayer::setCFAData(xreate::cfa::CFAGraph* graph) {
	- dataCFA.reset(graph);
	+ClaspLayer::registerReport(IAnalysisReport* report){
	+ __reports.push_back(report);
	}

	void
	-ClaspLayer::setDFAData(xreate::dfa::DFAGraph* graph){
	- dataDFA.reset(graph);
	+ClaspLayer::runReports(){
	+ for(IAnalysisReport* report: __reports){
	+ report->print(__partGeneral);
	+ delete report;
	+ }
	+
	+ __reports.clear();
	}

	void
	ClaspLayer::addRuleWarning(const RuleWarning &rule) {
	//__partGeneral << rule << endl;

	list<string> domains;
	boost::format formatDef("%1%(%2%)");
	std::transform(rule.__args.begin(), rule.__args.end(), std::inserter(domains, domains.begin()),
	[&formatDef](const std::pair<std::string, DomainAnnotation> &argument) {
	string domain;
	switch (argument.second) {
	case DomainAnnotation::FUNCTION:
	domain = "function";
	break;
	case DomainAnnotation::VARIABLE:
	domain = "variable";
	break;
	}

	return boost::str(formatDef % domain % argument.first);
	});

	list<string> vars;
	std::transform(rule.__args.begin(), rule.__args.end(), std::inserter(vars, vars.begin()),
	[](const std::pair<std::string, DomainAnnotation> &argument) {
	return argument.first.c_str();
	});

	list<list<string>> guardsRaw;
	std::transform(rule.__guards.begin(), rule.__guards.end(), std::inserter(guardsRaw, guardsRaw.begin()),
	[this](const Expression &guard) {
	return xreate::analysis::compile(guard);
	});

	const list<string>& guards = xreate::analysis::multiplyLists(std::move(guardsRaw));
	list<string> &&branches = xreate::analysis::compileNeg(rule.__condition);

	boost::format formatWarning("warning(%1%, (%2%)):- %3%, %4%, %5%.");
	for (const string &guardsJoined: guards)
	for (const string &branch: branches) {
	unsigned int hook = registerWarning(string(rule.__message));

	__partGeneral << formatWarning
	%(hook)
	%(boost::algorithm::join(vars, ", "))
	%(branch)
	%(guardsJoined)
	%(boost::algorithm::join(domains, ", "))
	<<endl;
	}
	}



	unsigned int
	ClaspLayer::registerWarning(std::string &&message) {
	static int warningId = 0;
	__warnings.emplace(warningId, message);
	return warningId++;;
	}

	void
	ClaspLayer::involveImports() {
	ostream &out = __partGeneral;

	for (string fn: ast->__rawImports)
	{
	std::ifstream file(fn);
	if (!file) continue;

	while(!file.eof()){
	string line;
	std::getline(file, line);
	out << line << endl;
	}
	}
	}

	void
	ClaspLayer::addRawScript(std::string&& script){
	__partGeneral << script;
	}

	void
	ClaspLayer::run() {
	involveImports();
	-
	- if (this->dataDFA){
	- this->dataDFA->print(__partGeneral);
	- }
	-
	- if (this->dataCFA){
	- this->dataCFA->print(__partGeneral);
	- }
	-
	- dominators::DominatorsTreeAnalysisProvider providerDominators;
	- providerDominators.run(this);
	- providerDominators.print(__partGeneral);
	+ runReports();

	ostringstream program;
	program << __partTags.str() << __partGeneral.str();
	cout << FYEL(program.str()) << endl;

	std::vector<char const *> args{"clingo", nullptr};
	DefaultGringoModule moduleDefault;
	Gringo::Scripts scriptsDefault(moduleDefault);
	ClingoLib ctl(scriptsDefault, 0, args.data(), {}, 0);

	ctl.add("base", {}, program.str());
	ctl.ground({{"base", {}}}, nullptr);

	// solve
	Gringo::SolveResult result = ctl.solve([this](Gringo::Model const &model) {
	this->handleSolution(model);
	return true;
	}, {});

	if (result.satisfiable() == Gringo::SolveResult::Satisfiable) {
	cout << FGRN("SUCCESSFULLY") << endl;
	} else {
	cout << FRED("UNSUCCESSFULLY") << endl;
	}

	// invoke all query plugins to process clasp data
	for (auto q: __queries)
	{
	q.second->init(this);
	}
	}

	ClaspLayer::ClaspLayer() {
	}

	ClaspLayer::ModelFragment
	ClaspLayer::query(const std::string& atom)
	{
	if (! __model.count(atom)){
	return boost::none;
	}

	return ModelFragment(__model.equal_range(atom));
	}

	ScopePacked
	ClaspLayer::pack(CodeScope* const scope) {
	auto pos = __indexScopes.emplace(scope, __indexScopes.size());
	if (pos.second)
	__registryScopes.push_back(scope);

	return pos.first->second;
	}

	size_t
	ClaspLayer::getScopesCount() const{
	return __registryScopes.size();
	}

	SymbolPacked
	ClaspLayer::pack(const Symbol& symbol, std::string hintSymbolName)
	{
	SymbolPacked result(symbol.identifier.id, symbol.identifier.version, pack(symbol.scope));
	__indexSymbolNameHints.emplace(result, hintSymbolName);

	return result;
	}

	Symbol
	ClaspLayer::unpack(const SymbolPacked& symbol)
	{
	return Symbol{ScopedSymbol{symbol.identifier, symbol.version}, __registryScopes[symbol.scope]};
	};

	std::string
	ClaspLayer::getHintForPackedSymbol(const SymbolPacked& symbol){
	- if (!symbol.categoryTransient) {
	- auto result = __indexSymbolNameHints.find(symbol);
	- return (result == __indexSymbolNameHints.end())? "" : result->second;
	-
	- } else {
	- return "anonym(" + to_string(symbol.identifier) + ")";
	- }
	+ auto result = __indexSymbolNameHints.find(symbol);
	+ return (result == __indexSymbolNameHints.end())? "" : result->second;
	}

	bool operator==(const SymbolPacked& s1, const SymbolPacked& s2)
	{
	return s1.identifier == s2.identifier && s1.scope == s2.scope;
	}

	bool operator<(const SymbolPacked& s1, const SymbolPacked& s2)
	{
	return s1.scope < s2.scope \|\| (s1.scope == s2.scope && s1.identifier < s2.identifier);
	}

	IQuery*
	ClaspLayer::registerQuery(IQuery *query, const QueryId& id) {
	return __queries.emplace(id, query).first->second;
	}

	IQuery*
	ClaspLayer::getQuery(const QueryId& id){
	assert(__queries.count(id) && "Undefined query");
	return __queries.at(id);
	}

	Expression
	ParseImplAtom<Expression>::get(const Gringo::Symbol& atom) {
	switch (atom.type()) {
	case Gringo::SymbolType::Num: return Expression(atom.num());
	case Gringo::SymbolType::Str: return Expression(Atom<String_t>(std::string(atom.string().c_str())));

	case Gringo::SymbolType::Fun:
	{
	//FUNC
	Expression result(Operator::CALL,{Expression(Atom<Identifier_t>(std::string(atom.name().c_str())))});
	for (const Gringo::Symbol& arg : atom.args()) {
	result.addArg(ParseImplAtom<Expression>::get(arg));
	}

	return result;
	}

	default:
	{
	assert(false);
	}
	}
	}

	+int
	+ParseImplAtom<int>::get(const Gringo::Symbol& atom) {
	+ switch (atom.type()){
	+ case Gringo::SymbolType::Num: return atom.num();
	+ default: break;
	+ }
	+
	+ assert(false && "Inappropriate symbol type");
	+}
	+
	std::string
	ParseImplAtom<std::string>::get(const Gringo::Symbol& atom) {
	switch (atom.type()) {
	case Gringo::SymbolType::Str: return atom.string().c_str();
	case Gringo::SymbolType::Fun: return atom.name().c_str();

	default: break;
	}

	assert(false && "Inappropriate symbol type");
	}

	SymbolPacked
	ParseImplAtom<SymbolPacked>::get(const Gringo::Symbol& atom) {
	auto result = ClaspLayer::parse<unsigned int, unsigned int, unsigned int>(atom);
	return SymbolPacked(std::get<0>(result), std::get<1>(result), std::get<2>(result));
	};

	Gringo::Symbol
	ParseImplAtom<Gringo::Symbol>::get(const Gringo::Symbol& atom) {
	return atom;
	}

	std::list<Gringo::Symbol>
	ParseImplAtom<std::list<Gringo::Symbol>>::get(const Gringo::Symbol& atom){
	assert (atom.type() == Gringo::SymbolType::Fun);
	std::list<Gringo::Symbol> result;

	for (const Gringo::Symbol& arg: atom.args()) {
	result.push_back(ParseImplAtom<Gringo::Symbol>::get(arg));
	}

	return result;
	}

	} //end of xreate namespace

	/**
	* \class xreate::ClaspLayer
	* \brief Reasoning and logic Solver.
	*
	* Wraps external brilliant fantastic tool [Clasp solver](https://potassco.org/clasp/)
	*
	* For building logic program for reasoning ClaspLayer takes input from:
	* - Raw scripts. Client could append arbitrary ASP script to _logic program_. \ref addRawScript()
	* - Includes. There is possibility to specify external files with ASP scripts
	* to append to _logic program_. \ref involveImports() (private member)
	* - Diagnostic rules. Rules that produce diagnostic messages during
	* compilation(warnings) or even able to halt compilation with errors.
	* addRuleWarning(), \ref registerWarning()
	* - DFA data. \ref setDFAData()
	* - CFA data. \ref setCFAData()
	* - Dominators Analysis. See xreate::dominators::DominatorsTreeAnalysisProvider.
	* Executed by \ref run()
	* - Context rules. See xreate::ContextRule and general [Context Explanation](/w/concepts/context)
	*
	* Data sources implement xreate::IAnalysisReport. Generally, input could be loosely divided into three categories:
	* - Internally derived data. CFA, DFA, Dominators analyses automatically feed reasoner by
	* useful insights about data, structure and algorithms of a program
	* - User provided data. CFA, DFA, Diagnostic/Context rules feed reasoner by
	* annotations Developer specifically provides manually
	* - External data. Raw scripts and includes feed reasoner with third-party data
	* related to a different aspects of a program possibly produced by external analyzers
	*
	* Once ClaspLayer got input from all providers and logic program is fully constructed
	* it runs external Clasp solver and receives back desired solutions.
	*
	* Output of Clasp reasoner is recognized and accessed via queries.
	* IQuery represents an interface between reasoner's output and rest of Xreate.
	* Each query inherits xreate::IQuery interface. Currently there are queries as follows:
	* - xreate::containers::Query to catch solutions regarding Containers implementation. See [Containers Explanation](/w/concepts/containers)
	* - xreate::context::ContextQuery to catch solution regarding Context. See [Context Explanation](/w/concepts/context)
	*
	* \sa See xreate::dfa::DFAPass, xreate::cfa::CFAPass, xreate::IQuery, xreate::IAnalysisReport, xreate::dominators::DominatorsTreeAnalysisProvider
	*/
	\ No newline at end of file
	diff --git a/cpp/src/clasplayer.h b/cpp/src/clasplayer.h
	index 03ef0e8..f2c097f 100644
	--- a/cpp/src/clasplayer.h
	+++ b/cpp/src/clasplayer.h
	@@ -1,228 +1,229 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* Author: pgess <v.melnychenko@xreate.org>
	* File: clasplayer.h
	*/

	#ifndef CLASPLAYER_H
	#define CLASPLAYER_H

	#include "ast.h"
	#include "contextrule.h"

	#include <clingo/clingocontrol.hh>
	#include <string>
	#include <climits>
	#include <boost/bimap.hpp>
	#include <boost/bimap/multiset_of.hpp>
	#include <boost/optional.hpp>
	#include <boost/scoped_ptr.hpp>
	#include <list>

	namespace xreate {

	typedef unsigned int ScopePacked;

	struct SymbolPacked {
	+ SymbolPacked(){}
	+ SymbolPacked(ScopedSymbol i, ScopePacked s): identifier(i.id), version(i.version), scope(s){}
	+ SymbolPacked(VNameId symbolId, versions::VariableVersion symbolVersion, ScopePacked symbolScope)
	+ : identifier(symbolId), version(symbolVersion), scope(symbolScope){}
	+
	VNameId identifier;
	versions::VariableVersion version;
	ScopePacked scope;
	- bool categoryTransient;
	-
	- SymbolPacked(): categoryTransient(false){}
	- SymbolPacked(ScopedSymbol i, ScopePacked s, bool isTransient = false): identifier(i.id), version(i.version), scope(s), categoryTransient(isTransient){}
	- SymbolPacked(VNameId symbolId, versions::VariableVersion symbolVersion, ScopePacked symbolScope, bool isTransient = false)
	- : identifier(symbolId), version(symbolVersion), scope(symbolScope), categoryTransient(isTransient){}
	};

	bool operator==(const SymbolPacked& s1, const SymbolPacked& s2);
	bool operator<(const SymbolPacked& s1, const SymbolPacked& s2);

	enum class DFGConnection {
	STRONG, WEAK, PROTOTYPE
	};

	/** \brief Designated to mark analysis results that can be composed as logic program */
	class IAnalysisReport {
	public:
	/** \brief Composes logic program based on analysis data into ASP format and appends to a stream*/
	- void print(std::ostringstream& output) const;
	+ virtual void print(std::ostringstream& output) const = 0;
	virtual ~IAnalysisReport(){};
	};

	/** \brief Logic program query interface */
	class IQuery {
	public:
	virtual void init(ClaspLayer* clasp) = 0;
	virtual ~IQuery() {}
	};

	enum class QueryId {
	ContainersQuery,
	ContextQuery,
	- PtrvalidQuery
	+ PtrvalidQuery,
	+ PolymorphQuery
	};

	namespace dfa{
	class DFAGraph;
	}

	namespace cfa {
	class CFAGraph;
	}

	class ClaspLayer {
	friend class ContextRule;

	/*\name Data Providers Management /
	///@{
	public:
	- /** \brief Provides DFA graph as output from xreate::DFAPass */
	- void setDFAData(xreate::dfa::DFAGraph* graph);
	-
	- /** \brief Provides CFA graph as output from xreate::CFAPass */
	- void setCFAData(xreate::cfa::CFAGraph* graph);
	-
	- /** \brief Appends arbitrary string to *logic program
	+ void registerReport(IAnalysisReport* report);
	+ void runReports();
	+
	+ /** \brief Appends arbitrary string to logic program
	*/
	void addRawScript(std::string&& script);

	- boost::scoped_ptr<xreate::dfa::DFAGraph> dataDFA;
	- boost::scoped_ptr<xreate::cfa::CFAGraph> dataCFA;
	-
	private:
	+ std::list<IAnalysisReport*> __reports;
	+
	/** Includes external text files to a logic program */
	void involveImports();
	///@}

	/*\name Queries Management /
	///@{
	public:
	/** \brief Adds query. See xreate::IQuery */
	IQuery* registerQuery(IQuery* query, const QueryId& id);

	/** \brief Returns particular query. See xreate::IQuery */
	IQuery* getQuery(const QueryId& id);

	template<class ...Types>
	static std::tuple<Types...> parse(const Gringo::Symbol& atom);

	typedef std::multimap<std::string, Gringo::Symbol>::const_iterator ModelIterator;
	typedef boost::optional<std::pair<ClaspLayer::ModelIterator, ClaspLayer::ModelIterator>> ModelFragment;
	ModelFragment query(const std::string& atom);

	size_t getScopesCount() const;
	SymbolPacked pack(const Symbol& symbol, std::string hintSymbolName = "");
	ScopePacked pack(CodeScope * const scope);
	Symbol unpack(const SymbolPacked& symbol);
	std::string getHintForPackedSymbol(const SymbolPacked& symbol);
	///@}

	private:
	std::map<QueryId, IQuery*> __queries;
	std::multimap<std::string, Gringo::Symbol> __model;
	std::map<SymbolPacked, std::string> __indexSymbolNameHints;
	std::unordered_map<const CodeScope*, unsigned int> __indexScopes;
	std::vector<CodeScope*> __registryScopes;

	/*\name Diagnostic /
	///@{
	//TODO diagnostic move over to separate provider/query
	public:
	/** \brief Adds diagnostic rule */
	void addRuleWarning(const RuleWarning &rule);

	/** \brief Registers diagnostic messages */
	unsigned int registerWarning(std::string &&message);

	private:
	std::map<unsigned int, std::string> __warnings;
	void printWarnings(std::ostream& out);
	///@}

	///@{
	public:
	ClaspLayer();

	/** \brief Executes reasoning */
	void run();
	///@}
	AST *ast;

	private:

	std::ostringstream __partTags;
	std::ostringstream __partGeneral;

	bool handleSolution(Gringo::Model const &model);
	};

	template<class typ>
	struct ParseImplAtom {

	static typ get(const Gringo::Symbol& atom) {
	return atom.num();
	}
	};

	+template<>
	+struct ParseImplAtom<int> {
	+ static int get(const Gringo::Symbol& atom);
	+};
	+
	template<>
	struct ParseImplAtom<std::string> {
	static std::string get(const Gringo::Symbol& atom);
	};

	template<>
	struct ParseImplAtom<SymbolPacked> {
	static SymbolPacked get(const Gringo::Symbol& atom);
	};

	template<>
	struct ParseImplAtom<Gringo::Symbol> {
	static Gringo::Symbol get(const Gringo::Symbol& atom);
	};

	template<>
	struct ParseImplAtom<std::list<Gringo::Symbol>>{
	static std::list<Gringo::Symbol> get(const Gringo::Symbol& atom);
	};

	template<>
	struct ParseImplAtom<Expression> {
	static Expression get(const Gringo::Symbol& atom);
	};

	template<class Tuple, size_t index>
	struct Parse_Impl {

	static void parse(Tuple& tup, Gringo::SymSpan::iterator arg) {
	const size_t tupleSize = std::tuple_size<Tuple>::value;
	typedef typename std::tuple_element < tupleSize - index, Tuple>::type ElType;

	ElType& el = std::get < tupleSize - index > (tup);

	Gringo::Symbol atom = *arg;
	el = ParseImplAtom<ElType>::get(atom);

	Parse_Impl<Tuple, index - 1 > ::parse(tup, ++arg);
	}
	};

	template<class Tuple>
	struct Parse_Impl<Tuple, 0> {

	static void parse(Tuple& tup, Gringo::SymSpan::iterator arg) {
	}
	};

	template<class ...Types>
	std::tuple<Types...>
	ClaspLayer::parse(const Gringo::Symbol& atom) {
	typedef std::tuple < Types...> Tuple;
	Tuple tup;
	Parse_Impl<Tuple, std::tuple_size<Tuple>::value>::parse(tup, atom.args().first);

	return tup;
	}
	} //end of xreate namespace
	#endif
	diff --git a/cpp/src/compilation/advanced.cpp b/cpp/src/compilation/advanced.cpp
	index f7a8ddf..04db2cf 100644
	--- a/cpp/src/compilation/advanced.cpp
	+++ b/cpp/src/compilation/advanced.cpp
	@@ -1,390 +1,390 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: InstructionsAdvanced.cpp
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on June 26, 2016, 6:00 PM
	*/

	/**
	* \file advanced.h
	* \brief Compilation of statements that require more than one LLVM instruction
	*/

	#include "compilation/advanced.h"
	#include "compilation/containers.h"
	#include "compilation/transformersaturation.h"

	#include "query/context.h"
	#include "query/containers.h"
	#include "llvmlayer.h"
	#include "ast.h"

	using namespace std;
	using namespace llvm;
	using namespace xreate;
	using namespace xreate::containers;
	using namespace xreate::compilation;

	#define NAME(x) (hintRetVar.empty()? x : hintRetVar)
	#define UNUSED(x) (void)(x)
	#define EXPAND_CONTEXT \
	LLVMLayer* llvm = context.pass->man->llvm; \
	compilation::ICodeScopeUnit* scope = context.scope; \
	compilation::IFunctionUnit* function = context.function;

	Advanced::Advanced(compilation::Context ctx)
	: context(ctx), tyNum(static_cast<llvm::IntegerType*> (ctx.pass->man->llvm->toLLVMType(ExpandedType(TypeAnnotation(TypePrimitive::Num))))) {
	}

	llvm::Value*
	Advanced::compileMapSolidOutput(const Expression &expr, const std::string hintRetVar) {
	EXPAND_CONTEXT
	UNUSED(scope);

	//initialization
	- Symbol symbolIn = Attachments::get<Symbol>(expr.getOperands()[0]);
	+ Symbol symbolIn = Attachments::get<IdentifierSymbol>(expr.getOperands()[0]);

	ImplementationRec<SOLID> implIn = containers::Query::queryImplementation(symbolIn).extract<SOLID>(); // impl of input list
	size_t size = implIn.size;
	CodeScope* scopeLoop = expr.blocks.front();
	std::string varEl = scopeLoop->__bindings[0];

	Iterator* it = Iterator::create(context, symbolIn);
	llvm::Value *rangeFrom = it->begin();
	llvm::Value *rangeTo = it->end();

	//definitions
	ArrayType* tyNumArray = (ArrayType*) (llvm->toLLVMType(ExpandedType(TypeAnnotation(tag_array, TypePrimitive::Num, size))));
	llvm::IRBuilder<> &builder = llvm->builder;

	llvm::BasicBlock *blockLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "loop", function->raw);
	llvm::BasicBlock *blockBeforeLoop = builder.GetInsertBlock();
	llvm::BasicBlock *blockAfterLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "postloop", function->raw);
	Value* dataOut = llvm->builder.CreateAlloca(tyNumArray, ConstantInt::get(tyNum, size), NAME("map"));

	// * initial check
	Value* condBefore = builder.CreateICmpSLE(rangeFrom, rangeTo);
	builder.CreateCondBr(condBefore, blockLoop, blockAfterLoop);

	// create PHI:
	builder.SetInsertPoint(blockLoop);
	llvm::PHINode *stateLoop = builder.CreatePHI(tyNum, 2, "mapIt");
	stateLoop->addIncoming(rangeFrom, blockBeforeLoop);

	// loop body:
	Value* elIn = it->get(stateLoop, varEl);
	compilation::ICodeScopeUnit* scopeLoopUnit = function->getScopeUnit(scopeLoop);
	scopeLoopUnit->bindArg(elIn, move(varEl));
	Value* elOut = scopeLoopUnit->compile();
	Value pElOut = builder.CreateGEP(dataOut, ArrayRef<Value >(std::vector<Value*>{ConstantInt::get(tyNum, 0), stateLoop}));
	builder.CreateStore(elOut, pElOut);

	//next iteration preparing
	Value *stateLoopNext = builder.CreateAdd(stateLoop, llvm::ConstantInt::get(tyNum, 1));
	stateLoop->addIncoming(stateLoopNext, builder.GetInsertBlock());

	//next iteration checks:
	Value* condAfter = builder.CreateICmpSLE(stateLoopNext, rangeTo);
	builder.CreateCondBr(condAfter, blockLoop, blockAfterLoop);

	//finalization:
	builder.SetInsertPoint(blockAfterLoop);

	return dataOut;
	}

	Value*
	Advanced::compileArrayIndex(llvm::Value* aggregate, std::vector<llvm::Value *> indexes, std::string hintRetVar) {
	EXPAND_CONTEXT
	UNUSED(function);
	UNUSED(scope);

	indexes.insert(indexes.begin(), llvm::ConstantInt::get(tyNum, 0));
	llvm::Value pEl = llvm->builder.CreateGEP(aggregate, llvm::ArrayRef<llvm::Value >(indexes));
	return llvm->builder.CreateLoad(pEl, NAME("el"));
	}

	Value*
	Advanced::compileStructIndex(llvm::Value* aggregate, const ExpandedType& t, const std::string& idx) {
	EXPAND_CONTEXT
	UNUSED(scope);
	UNUSED(function);
	TypeUtils types(llvm);
	std::vector<std::string>&& fields = types.getStructFields(t);

	for (unsigned i = 0, size = fields.size(); i < size; ++i) {
	if (fields.at(i) == idx) {
	//dereference pointer
	if (types.isPointer(t)) {
	llvm::Value* addr = llvm->builder.CreateConstGEP2_32(nullptr, aggregate, 0, i);
	return llvm->builder.CreateLoad(addr);
	}

	return llvm->builder.CreateExtractValue(aggregate, llvm::ArrayRef<unsigned>{i});
	}
	}

	assert(false && "not found required struct field");
	return nullptr;
	}

	llvm::Value*
	Advanced::compileFold(const Expression& fold, const std::string& hintRetVar) {
	EXPAND_CONTEXT
	assert(fold.op == Operator::FOLD);

	//initialization:
	- Symbol varInSymbol = Attachments::get<Symbol>(fold.getOperands()[0]);
	+ Symbol varInSymbol = Attachments::get<IdentifierSymbol>(fold.getOperands()[0]);
	Implementation info = Query::queryImplementation(varInSymbol);

	Iterator* it = Iterator::create(context, varInSymbol);
	llvm::Value* rangeBegin = it->begin();
	llvm::Value* rangeEnd = it->end();
	llvm::Value* accumInit = scope->process(fold.getOperands()[1]);
	std::string varIn = fold.getOperands()[0].getValueString();
	std::string varAccum = fold.bindings[1];
	std::string varEl = fold.bindings[0];

	llvm::BasicBlock *blockBeforeLoop = llvm->builder.GetInsertBlock();
	std::unique_ptr<TransformerSaturation> transformerSaturation(new TransformerSaturation(blockBeforeLoop, context.pass->managerTransformations));


	llvm::BasicBlock *blockLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "fold", function->raw);
	llvm::BasicBlock *blockLoopBody = llvm::BasicBlock::Create(llvm::getGlobalContext(), "fold_body", function->raw);
	llvm::BasicBlock *blockAfterLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "fold_after", function->raw);
	llvm::BasicBlock *blockNext = llvm::BasicBlock::Create(llvm::getGlobalContext(), "fold_next", function->raw);

	llvm->builder.CreateBr(blockLoop);

	// * create phi
	llvm->builder.SetInsertPoint(blockLoop);
	llvm::PHINode *accum = llvm->builder.CreatePHI(accumInit->getType(), 2, varAccum);
	accum->addIncoming(accumInit, blockBeforeLoop);
	llvm::PHINode *itLoop = llvm->builder.CreatePHI(rangeBegin->getType(), 2, "foldIt");
	itLoop->addIncoming(rangeBegin, blockBeforeLoop);

	// * loop checks
	Value* condRange = llvm->builder.CreateICmpNE(itLoop, rangeEnd);
	llvm->builder.CreateCondBr(condRange, blockLoopBody, blockAfterLoop);

	// * loop body
	llvm->builder.SetInsertPoint(blockLoopBody);
	CodeScope* scopeLoop = fold.blocks.front();
	compilation::ICodeScopeUnit* loopUnit = function->getScopeUnit(scopeLoop);
	Value* elIn = it->get(itLoop);
	loopUnit->bindArg(accum, move(varAccum));
	loopUnit->bindArg(elIn, move(varEl));
	Value* accumNext = loopUnit->compile();

	// * Loop saturation checks
	bool flagSaturationTriggered = transformerSaturation->insertSaturationChecks(blockNext, blockAfterLoop, context);
	llvm::BasicBlock* blockSaturation = llvm->builder.GetInsertBlock();
	if (!flagSaturationTriggered){
	llvm->builder.CreateBr(blockNext);
	}

	// * computing next iteration state
	llvm->builder.SetInsertPoint(blockNext);
	Value *itLoopNext = it->advance(itLoop);
	accum->addIncoming(accumNext, llvm->builder.GetInsertBlock());
	itLoop->addIncoming(itLoopNext, llvm->builder.GetInsertBlock());
	llvm->builder.CreateBr(blockLoop);

	// * finalization:
	llvm->builder.SetInsertPoint(blockAfterLoop);
	if (!flagSaturationTriggered){
	return accum;
	}

	llvm::PHINode* result = llvm->builder.CreatePHI(accumInit->getType(), 2);
	result->addIncoming(accum, blockLoop);
	result->addIncoming(accumNext, blockSaturation);
	return result;
	}

	llvm::Value*
	Advanced::compileFoldInf(const Expression& fold, const std::string& hintRetVar) {
	EXPAND_CONTEXT
	assert(fold.op == Operator::FOLD_INF);

	std::string accumName = fold.bindings[0];
	llvm::Value* accumInit = scope->process(fold.getOperands()[0]);

	llvm::BasicBlock *blockBeforeLoop = llvm->builder.GetInsertBlock();
	llvm::BasicBlock *blockLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "foldinf", function->raw);
	llvm::BasicBlock *blockNext = llvm::BasicBlock::Create(llvm::getGlobalContext(), "foldinf_next", function->raw);
	llvm::BasicBlock *blockAfterLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "foldinf_post", function->raw);
	std::unique_ptr<TransformerSaturation> transformerSaturation(new TransformerSaturation(blockBeforeLoop, context.pass->managerTransformations));

	llvm->builder.CreateBr(blockLoop);

	// * create phi
	llvm->builder.SetInsertPoint(blockLoop);
	llvm::PHINode *accum = llvm->builder.CreatePHI(accumInit->getType(), 2, accumName);
	accum->addIncoming(accumInit, blockBeforeLoop);

	// * loop body
	CodeScope* scopeLoop = fold.blocks.front();
	compilation::ICodeScopeUnit* unitLoop = function->getScopeUnit(scopeLoop);
	unitLoop->bindArg(accum, move(accumName));
	Value* accumNext = unitLoop->compile();

	// * Loop saturation checks
	bool flagSaturationTriggered = transformerSaturation->insertSaturationChecks(blockNext, blockAfterLoop, context);
	assert(flagSaturationTriggered);

	// * computing next iteration state
	llvm->builder.SetInsertPoint(blockNext);
	accum->addIncoming(accumNext, llvm->builder.GetInsertBlock());
	llvm->builder.CreateBr(blockLoop);

	// finalization:
	llvm->builder.SetInsertPoint(blockAfterLoop);
	return accumNext;
	}

	llvm::Value*
	Advanced::compileIf(const Expression& exprIf, const std::string& hintRetVar) {
	EXPAND_CONTEXT

	//initialization:
	const Expression& condExpr = exprIf.getOperands()[0];
	llvm::IRBuilder<>& builder = llvm->builder;
	//llvm::Type* tyResultType = llvm->toLLVMType(llvm->ast->expandType(exprIf.type));

	llvm::BasicBlock *blockAfter = llvm::BasicBlock::Create(llvm::getGlobalContext(), "ifAfter", function->raw);
	llvm::BasicBlock *blockTrue = llvm::BasicBlock::Create(llvm::getGlobalContext(), "ifTrue", function->raw);
	llvm::BasicBlock *blockFalse = llvm::BasicBlock::Create(llvm::getGlobalContext(), "ifFalse", function->raw);

	llvm::Value* cond = scope->process(condExpr);
	llvm->builder.CreateCondBr(cond, blockTrue, blockFalse);

	builder.SetInsertPoint(blockTrue);
	CodeScope* scopeTrue = exprIf.blocks.front();
	llvm::Value* resultTrue = function->getScopeUnit(scopeTrue)->compile();
	blockTrue = builder.GetInsertBlock();
	builder.CreateBr(blockAfter);

	builder.SetInsertPoint(blockFalse);
	CodeScope* scopeFalse = exprIf.blocks.back();
	llvm::Value* resultFalse = function->getScopeUnit(scopeFalse)->compile();
	blockFalse = builder.GetInsertBlock();
	builder.CreateBr(blockAfter);

	builder.SetInsertPoint(blockAfter);
	llvm::PHINode *ret = builder.CreatePHI(resultTrue->getType(), 2, NAME("if"));

	ret->addIncoming(resultTrue, blockTrue);
	ret->addIncoming(resultFalse, blockFalse);

	return ret;
	}

	//TODO Switch: default variant no needed when all possible conditions are considered

	llvm::Value*
	Advanced::compileSwitch(const Expression& exprSwitch, const std::string& hintRetVar) {
	EXPAND_CONTEXT
	AST* root = context.pass->man->root;
	UNUSED(function);


	assert(exprSwitch.operands.size() >= 2);
	assert(exprSwitch.operands[1].op == Operator::CASE_DEFAULT && "No default case in Switch Statement");
	int countCases = exprSwitch.operands.size() - 1;
	llvm::IRBuilder<>& builder = llvm->builder;

	llvm::BasicBlock* blockProlog = builder.GetInsertBlock();
	llvm::BasicBlock *blockEpilog = llvm::BasicBlock::Create(llvm::getGlobalContext(), "switchAfter", function->raw);
	builder.SetInsertPoint(blockEpilog);
	llvm::Type* exprSwitchType = llvm->toLLVMType(root->getType(exprSwitch));
	llvm::PHINode *ret = builder.CreatePHI(exprSwitchType, countCases, NAME("switch"));

	builder.SetInsertPoint(blockProlog);
	llvm::Value * conditionSwitch = scope->process(exprSwitch.operands[0]);
	llvm::BasicBlock *blockDefault = llvm::BasicBlock::Create(llvm::getGlobalContext(), "caseDefault", function->raw);
	llvm::SwitchInst * instructionSwitch = builder.CreateSwitch(conditionSwitch, blockDefault, countCases);

	for (int size = exprSwitch.operands.size(), i = 2; i < size; ++i) {
	llvm::BasicBlock *blockCase = llvm::BasicBlock::Create(llvm::getGlobalContext(), "case" + std::to_string(i), function->raw);

	llvm::Value* condCase = function->getScopeUnit(exprSwitch.operands[i].blocks.front())->compile();
	builder.SetInsertPoint(blockCase);
	llvm::Value* resultCase = function->getScopeUnit(exprSwitch.operands[i].blocks.back())->compile();
	builder.CreateBr(blockEpilog);

	ret->addIncoming(resultCase, builder.GetInsertBlock());
	builder.SetInsertPoint(blockProlog);
	instructionSwitch->addCase(dyn_cast<llvm::ConstantInt>(condCase), blockCase);
	}

	//compile default block:
	builder.SetInsertPoint(blockDefault);
	CodeScope* scopeDefault = exprSwitch.operands[1].blocks.front();
	llvm::Value* resultDefault = function->getScopeUnit(scopeDefault)->compile();
	builder.CreateBr(blockEpilog);
	ret->addIncoming(resultDefault, builder.GetInsertBlock());
	builder.SetInsertPoint(blockEpilog);

	return ret;
	}

	//TODO recognize cases to make const arrays/stored in global mem/stack alloced.
	llvm::Value*
	Advanced::compileListAsSolidArray(const Expression &expr, const std::string& hintRetVar) {
	EXPAND_CONTEXT
	UNUSED(scope);
	UNUSED(function);

	AST* root = context.pass->man->root;
	const size_t& length = expr.getOperands().size();
	const Expression& expression = expr;
	llvm::Value* zero = ConstantInt::get(tyNum, 0);
	llvm::Value* one = ConstantInt::get(tyNum, 1);

	ExpandedType typAggrExpanded = root->getType(expression);
	assert(typAggrExpanded->__operator == TypeOperator::ARRAY);
	llvm::Type* typEl = llvm->toLLVMType(ExpandedType(typAggrExpanded->__operands[0]));
	ArrayType* typAggr = (ArrayType*) llvm::ArrayType::get(typEl, length);
	llvm::Value* list = llvm->builder.CreateAlloca(typAggr, ConstantInt::get(Type::getInt32Ty(llvm::getGlobalContext()), length, false), hintRetVar);

	const std::vector<Expression>& operands = expression.getOperands();
	llvm::Value* addrOperand = llvm->builder.CreateGEP(typAggr, list, ArrayRef<Value >(std::vector<Value>{zero, zero}));
	llvm->builder.CreateStore(scope->process(operands.front()), addrOperand) ;
	for (auto i=++operands.begin(); i!=operands.end(); ++i){
	addrOperand = llvm->builder.CreateGEP(typEl, addrOperand, ArrayRef<Value >(std::vector<Value>{one}));
	llvm->builder.CreateStore(scope->process(*i), addrOperand) ;
	}

	return list;
	// Value* listDest = l.builder.CreateAlloca(typList, ConstantInt::get(typI32, __size), *hintRetVar);
	// l.buil1der.CreateMemCpy(listDest, listSource, __size, 16);
	}

	llvm::Value*
	Advanced::compileConstantStringAsPChar(const string& data, const std::string& hintRetVar) {
	EXPAND_CONTEXT
	UNUSED(function);
	UNUSED(scope);

	Type* typPchar = PointerType::getUnqual(Type::getInt8Ty(llvm::getGlobalContext()));
	//ArrayType* typStr = (ArrayType*) (llvm->toLLVMType(ExpandedType(TypeAnnotation(tag_array, TypePrimitive::I8, size+1))));

	/*
	std::vector<Constant *> chars;
	chars.reserve(size+1);

	for (size_t i=0; i< size; ++i){
	chars[i] = ConstantInt::get(typI8, (unsigned char) data[i]);
	}
	chars[size] = ConstantInt::get(typI8, 0);
	*/

	Value* rawData = ConstantDataArray::getString(llvm::getGlobalContext(), data);
	Value* rawPtrData = llvm->builder.CreateAlloca(rawData->getType(), ConstantInt::get(Type::getInt32Ty(llvm::getGlobalContext()), 1, false));
	llvm->builder.CreateStore(rawData, rawPtrData);
	return llvm->builder.CreateCast(llvm::Instruction::BitCast, rawPtrData, typPchar, hintRetVar);
	}
	diff --git a/cpp/src/compilation/containers.cpp b/cpp/src/compilation/containers.cpp
	index c50d43a..5735440 100644
	--- a/cpp/src/compilation/containers.cpp
	+++ b/cpp/src/compilation/containers.cpp
	@@ -1,206 +1,206 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: containers.cpp
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* \file compilation/containers.h
	* \brief Containers compilation support. See more [details on Containers](/w/concepts/containers)
	*/

	#include "compilation/containers.h"

	using namespace std;
	using namespace llvm;
	using namespace xreate;
	using namespace xreate::containers;

	Iterator*
	Iterator::create(xreate::compilation::Context context, const xreate::Symbol& var){

	const Implementation& data = Query::queryImplementation(var);

	switch(data.impl){
	case ON_THE_FLY:
	return new IteratorForward<ON_THE_FLY>(context, var, data.extract<ON_THE_FLY>());

	case SOLID:
	return new IteratorForward<SOLID>(context, var, data.extract<SOLID>());

	default: assert(true);
	}

	assert(false && "Unknown declaration");
	return nullptr;
	}

	llvm::Value*
	IteratorForward<ON_THE_FLY>::begin() {
	switch(sourceDecl.op) {
	case xreate::Operator::LIST:
	{
	sourceRawType = llvm::Type::getInt32Ty(llvm::getGlobalContext());
	return llvm::ConstantInt::get(Type::getInt32Ty(llvm::getGlobalContext()), 0);
	};

	case xreate::Operator::LIST_RANGE:{
	assert(sourceDecl.operands.size()==2);

	llvm::Value* result = sourceUnit->process(sourceDecl.operands.at(0));
	sourceRawType = result->getType();

	return result;
	};

	default: break;
	}

	if (linkedlist){
	llvm::Value* result = sourceUnit->process(sourceDecl);
	sourceRawType = result->getType();
	return result;
	}

	assert(false);
	}

	llvm::Value*
	IteratorForward<ON_THE_FLY>::end(){
	switch(sourceDecl.op) {
	case xreate::Operator::LIST: {
	size_t idLast = sourceDecl.operands.size() - 1;
	return ConstantInt::get(sourceRawType, idLast);
	}

	case xreate::Operator::LIST_RANGE: {
	assert(sourceDecl.operands.size() == 2);
	llvm::Value* valueEndOfRange = sourceUnit->process(sourceDecl.operands.at(1));
	llvm::Value* valueConstOne = llvm::ConstantInt::get(llvm::Type::getInt32Ty(llvm::getGlobalContext()), 1);

	return llvm->builder.CreateAdd(valueEndOfRange, valueConstOne);
	};

	default: break;
	}

	//return null pointer
	if (linkedlist){
	return ConstantPointerNull::getNullValue(sourceRawType);
	}

	assert(false && "Unknown declaration");
	return nullptr;
	}

	llvm::Value*
	IteratorForward<ON_THE_FLY>::get(Value* index,const std::string& hintRetVar){
	const Expression& currentDecl = CodeScope::getDefinition(current);

	switch (currentDecl.op) {
	case xreate::Operator::LIST: {
	//TODO re check is it right scope(source) to compile currentDecl. Provide unittests.
	llvm::Value* currentValue = sourceUnit->processSymbol(current);
	return xreate::compilation::Advanced(context).compileArrayIndex(currentValue, std::vector<Value *>{index});
	};

	case xreate::Operator::LIST_RANGE: {
	return index;
	};

	case xreate::Operator::MAP: {
	assert(currentDecl.getOperands().size()==1);
	assert(currentDecl.bindings.size());
	assert(currentDecl.blocks.size());

	CodeScope* scopeLoop = currentDecl.blocks.front();
	std::string varEl = currentDecl.bindings[0];

	- const Symbol& symbIn = Attachments::get<Symbol>(currentDecl.getOperands()[0]);
	+ const Symbol& symbIn = Attachments::get<IdentifierSymbol>(currentDecl.getOperands()[0]);
	auto it = std::unique_ptr<Iterator>(Iterator::create(context, symbIn));

	Value* elIn = it->get(index, varEl);
	compilation::ICodeScopeUnit* unitLoop = function->getScopeUnit(scopeLoop);
	unitLoop->bindArg(elIn, std::move(varEl));
	return unitLoop->compile();
	}

	case xreate::Operator::NONE: {
	//TODO review iterator determination strategy for case of Expression::BINDING
	assert(currentDecl.__state==Expression::IDENT);

	- const Symbol& symbIn = Attachments::get<Symbol>(currentDecl);
	+ const Symbol& symbIn = Attachments::get<IdentifierSymbol>(currentDecl);
	auto it = std::unique_ptr<Iterator>(Iterator::create(context, symbIn));
	return it->get(index);
	};

	default: break;
	}

	if (linkedlist){
	return index;
	}

	assert(false && "Unknown declaration");
	return nullptr;
	}

	llvm::Value*
	IteratorForward<ON_THE_FLY>::advance(Value* index, const std::string& hintRetVar){
	switch(sourceDecl.op)
	{
	case xreate::Operator::LIST:
	case xreate::Operator::LIST_RANGE:
	return llvm->builder.CreateAdd(index, llvm::ConstantInt::get(llvm::Type::getInt32Ty(llvm::getGlobalContext()), 1), hintRetVar);

	default: break;
	}

	if (linkedlist){
	ExpandedType tySource = llvm->ast->getType(CodeScope::getDefinition(source));
	assert(tySource->__operator == TypeOperator::ARRAY && "Linked list implementation has to have ARRAY type");
	assert(tySource->__operands.size());

	return xreate::compilation::Advanced(context).compileStructIndex(index, ExpandedType(TypeAnnotation(tySource->__operands.at(0))), linkedlist.fieldPointer);
	}

	assert(false && "Unknown declaration");
	return nullptr;
	}

	//const ImplementationRec<ON_THE_FLY>& implementation

	IteratorForward<SOLID>::IteratorForward(const compilation::Context& ctx, const xreate::Symbol& symbolContainer, const ImplementationRec<SOLID>& implementation)
	: Iterator(), __length(implementation.size), llvm(ctx.pass->man->llvm)
	{
	__container = ctx.function->getScopeUnit(symbolContainer.scope)->processSymbol(symbolContainer);
	}

	llvm::Value*
	IteratorForward<SOLID>::begin(){
	//0
	return llvm::ConstantInt::get(llvm::Type::getInt32Ty(llvm::getGlobalContext()), 0);
	}

	llvm::Value*
	IteratorForward<SOLID>::end(){
	//length
	return llvm::ConstantInt::get(llvm::Type::getInt32Ty(llvm::getGlobalContext()), __length);
	}

	llvm::Value*
	IteratorForward<SOLID>::get(llvm::Value* index,const std::string& hintRetVar){
	//GEP[index]]

	llvm::Type* tyNum = llvm::Type::getInt32Ty(llvm::getGlobalContext());
	llvm::Value* pResult = llvm->builder.CreateGEP(__container, ArrayRef<Value >(std::vector<Value>{ConstantInt::get(tyNum, 0), index}));
	return llvm->builder.CreateLoad(pResult, hintRetVar);
	}

	llvm::Value*
	IteratorForward<SOLID>::advance(llvm::Value* index, const std::string& hintRetVar){
	//index + 1

	llvm::Type* tyNum = llvm::Type::getInt32Ty(llvm::getGlobalContext());
	return llvm->builder.CreateAdd(index, llvm::ConstantInt::get(tyNum, 1), hintRetVar);
	}
	diff --git a/cpp/src/compilation/polymorphcompiler.h b/cpp/src/compilation/polymorphcompiler.h
	index 48ff6b5..d2c933e 100644
	--- a/cpp/src/compilation/polymorphcompiler.h
	+++ b/cpp/src/compilation/polymorphcompiler.h
	@@ -1,49 +1,55 @@
	/*
	* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: polymorphcompiler.h
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on October 7, 2017
	*/

	#ifndef POLYMORPHCOMPILER_H
	#define POLYMORPHCOMPILER_H

	#include "pass/compilepass.h"
	+#include "query/polymorph.h"

	namespace xreate { namespace polymorph {

	typedef Expression Guard;

	template <class Parent>
	class PolymorphCodeScopeUnit: public Parent{
	public:
	PolymorphCodeScopeUnit(CodeScope* codeScope, compilation::IFunctionUnit* f, CompilePass* compilePass)
	: Parent(codeScope, f, compilePass) {}

	protected:
	compilation::ICallStatement* findFunction(const Expression& opCall) override {
	- const std::string& keyAnnotationGuard = "callguard";
	- if (!opCall.tags.count(keyAnnotationGuard)) return Parent::findFunction(opCall);

	- const Expression& annotationGuard = opCall.tags.at(keyAnnotationGuard);
	- assert(annotationGuard.operands.size()==1);
	- const Expression& guardSelected = annotationGuard.operands.at(0);
	-
	- std::map<Guard, ManagedFnPtr> indexSpecs;
	+ //Check does invocation require guards
	const std::string& nameCallee = opCall.getValueString();
	const std::list<ManagedFnPtr>& specializations = Parent::pass->man->root->getFunctionSpecializations(nameCallee);
	+ if (specializations.size() == 1){
	+ if (!specializations.front()->guard.isValid()) {
	+ return Parent::findFunction(opCall);
	+ }
	+ }
	+
	+ assert(Attachments::exists<PolymorphGuard>(opCall) && "Guard required");
	+ const Expression& guardSelected = Attachments::get<PolymorphGuard>(opCall);
	+ std::map<Guard, ManagedFnPtr> indexSpecs;
	for(ManagedFnPtr specialization: specializations){
	indexSpecs.emplace(specialization->guard, specialization);
	}

	- assert(indexSpecs.count(guardSelected));
	+ assert(indexSpecs.count(guardSelected) && "Can't found appropriate guard");
	return new compilation::CallStatementRaw(Parent::pass->getFunctionUnit(indexSpecs.at(guardSelected))->compile(), Parent::pass->man->llvm);
	}
	};

	+} } //end of xreate::polymorph
	+
	#endif /* POLYMORPHCOMPILER_H */

	diff --git a/cpp/src/compilation/scopedecorators.h b/cpp/src/compilation/scopedecorators.h
	index 01cb9aa..54e7a23 100644
	--- a/cpp/src/compilation/scopedecorators.h
	+++ b/cpp/src/compilation/scopedecorators.h
	@@ -1,145 +1,145 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: scopedecorators.h
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on February 24, 2017, 11:35 AM
	*/

	/**
	* \file scopedecorators.h
	* \brief Basic code block compilation xreate::compilation::ICodeScopeUnit decorators
	*/


	#ifndef SCOPEDECORATORS_H
	#define SCOPEDECORATORS_H

	#include "ast.h"
	#include "compilation/targetinterpretation.h"
	#include "compilation/versions.h"
	#include "compilation/transformations.h"
	#include "compilation/polymorphcompiler.h"

	namespace xreate {

	class CompilePass;

	namespace compilation {

	class ICodeScopeUnit;
	class IFunctionUnit;

	/**\brief Caching ability for code scope compilation
	* \extends xreate::compilation::ICodeScopeUnit
	*/
	template<class Parent>
	class CachedScopeDecorator: public Parent{
	typedef CachedScopeDecorator<Parent> SELF;

	public:
	CachedScopeDecorator(CodeScope* codeScope, IFunctionUnit* f, CompilePass* compilePass): Parent(codeScope, f, compilePass){}

	void bindArg(llvm::Value* value, std::string&& alias)
	{
	//ensure existence of an alias
	assert(Parent::scope->__identifiers.count(alias));

	//memorize new value for an alias
	ScopedSymbol id{Parent::scope->__identifiers.at(alias), versions::VERSION_NONE};
	__rawVars[id] = value;
	}

	void bindArg(llvm::Value* value, const ScopedSymbol& s) {
	__rawVars[s] = value;
	}

	llvm::Value* compile(const std::string& hintBlockDecl="") override{
	if (__rawVars.count(ScopedSymbol::RetSymbol)){
	return __rawVars[ScopedSymbol::RetSymbol];
	}

	return Parent::compile(hintBlockDecl);
	}

	llvm::Value*
	processSymbol(const Symbol& s, std::string hintRetVar) override{
	CodeScope* scope = s.scope;
	SELF* self = dynamic_cast<SELF*>(Parent::function->getScopeUnit(scope));

	if (self->__rawVars.count(s.identifier)){
	return self->__rawVars[s.identifier];
	}

	//Declaration could be overriden
	- Expression declaration = CodeScope::getDefinition(s);
	+ Expression declaration = CodeScope::getDefinition(s, true);
	if (!declaration.isDefined()){
	if (self->__declarationsOverriden.count(s.identifier)){
	declaration = self->__declarationsOverriden[s.identifier];

	} else {
	assert(false); //in case of binding there should be raws provided.
	}
	}

	return self->__rawVars[s.identifier] = Parent::processSymbol(s, hintRetVar);
	}

	void
	overrideDeclaration(const Symbol binding, Expression&& declaration){
	SELF* self = dynamic_cast<SELF*>(Parent::function->getScopeUnit(binding.scope));

	self->__declarationsOverriden.emplace(binding.identifier, std::move(declaration));
	}

	void registerChildScope(std::shared_ptr<ICodeScopeUnit> scope){
	__childScopes.push_back(scope);
	}

	void reset(){
	__rawVars.clear();
	__declarationsOverriden.clear();
	__childScopes.clear();
	}

	private:
	std::unordered_map<ScopedSymbol, Expression> __declarationsOverriden;
	std::unordered_map<ScopedSymbol,llvm::Value*> __rawVars;
	std::list<std::shared_ptr<ICodeScopeUnit>> __childScopes;
	};

	/*\brief Default code scope compilation functionality/
	typedef CachedScopeDecorator<
	polymorph::PolymorphCodeScopeUnit<
	- compilation::TransformationsScopeDecorator<
	+ ::xreate::compilation::TransformationsScopeDecorator<
	interpretation::InterpretationScopeDecorator<
	versions::VersionsScopeDecorator<compilation::BasicCodeScopeUnit>>>>>

	DefaultCodeScopeUnit;

	} //end of compilation namespace

	struct CachedScopeDecoratorTag;
	struct VersionsScopeDecoratorTag;

	template<>
	struct DecoratorsDict<CachedScopeDecoratorTag>{
	typedef compilation::CachedScopeDecorator<
	polymorph::PolymorphCodeScopeUnit<
	compilation::TransformationsScopeDecorator<
	interpretation::InterpretationScopeDecorator<
	versions::VersionsScopeDecorator<compilation::BasicCodeScopeUnit>>>>> result;
	};

	template<>
	struct DecoratorsDict<VersionsScopeDecoratorTag>{
	typedef versions::VersionsScopeDecorator<
	compilation::BasicCodeScopeUnit> result;
	};

	} //end of xreate

	#endif /* SCOPEDECORATORS_H */

	diff --git a/cpp/src/compilation/targetinterpretation.cpp b/cpp/src/compilation/targetinterpretation.cpp
	index d550918..00637b1 100644
	--- a/cpp/src/compilation/targetinterpretation.cpp
	+++ b/cpp/src/compilation/targetinterpretation.cpp
	@@ -1,595 +1,595 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: targetinterpretation.cpp
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on June 29, 2016, 6:45 PM
	*/

	/**
	* \file targetinterpretation.h
	* \brief Interpretation support. See more [details on Interpretation](/w/concepts/dsl/)
	*/

	#include "compilation/targetinterpretation.h"
	#include "pass/interpretationpass.h"
	#include "analysis/typeinference.h"
	#include "llvmlayer.h"
	#include "compilation/scopedecorators.h"

	#include <boost/scoped_ptr.hpp>
	#include <iostream>
	#include <clang/AST/DeclBase.h>

	using namespace std;
	using namespace xreate::compilation;

	namespace xreate{ namespace interpretation{

	const Expression EXPRESSION_FALSE = Expression(Atom<Number_t>(0));
	const Expression EXPRESSION_TRUE = Expression(Atom<Number_t>(1));

	Expression
	representAsAnnotation(const Gringo::Symbol& atom){
	switch (atom.type()) {
	case Gringo::SymbolType::Num: {
	Expression result(Operator::VARIANT, {Expression(atom.num())});
	result.setValueDouble(0);
	return result;
	}

	case Gringo::SymbolType::Str: {
	Expression result(Operator::VARIANT, {Expression(Atom<String_t>(std::string(atom.string().c_str())))});
	result.setValueDouble(1);
	return result;
	}

	case Gringo::SymbolType::Fun:
	{
	Expression fnDescription(Operator::LIST_NAMED, {});
	std::list<Atom<Identifier_t>> bindings{Atom<Identifier_t>("name"), Atom<Identifier_t>("arguments")};
	fnDescription.addBindings(bindings.begin(), bindings.end());

	fnDescription.addArg(Expression(Atom<String_t>(std::string(atom.name().c_str()))));

	Expression args(Operator::LIST, {});
	for (const Gringo::Symbol& arg : atom.args()) {
	args.addArg(representAsAnnotation(arg));
	}

	fnDescription.addArg(std::move(args));

	Expression result(Operator::VARIANT, {fnDescription});
	result.setValueDouble(2);
	return result;
	}

	default:
	{
	assert(false);
	}
	}
	}

	CodeScope*
	InterpretationScope::processOperatorIf(const Expression& expression){
	const Expression& exprCondition = process(expression.getOperands()[0]);

	if (exprCondition == EXPRESSION_TRUE){
	return expression.blocks.front();
	}

	return expression.blocks.back();
	}

	CodeScope*
	InterpretationScope::processOperatorSwitch(const Expression& expression) {
	const Expression& exprCondition = process(expression.operands[0]);

	bool flagHasDefault = expression.operands[1].op == Operator::CASE_DEFAULT;

	//TODO check that one and only one case variant is appropriate
	for (size_t size = expression.operands.size(), i= flagHasDefault? 2: 1; i<size; ++i){
	const Expression& exprCase = process(expression.operands[i]);

	if (function->getScope(exprCase.blocks.front())->processScope() == exprCondition){
	return exprCase.blocks.back();
	}
	}

	if (flagHasDefault){
	const Expression& exprCaseDefault = expression.operands[1];
	return exprCaseDefault.blocks.front();
	}

	assert(false && "Switch has no appropriate variant");
	return nullptr;
	}

	CodeScope*
	InterpretationScope::processOperatorSwitchVariant(const Expression& expression){
	const Expression& condition = process(expression.operands.at(0));
	assert(condition.op == Operator::VARIANT);
	const string identCondition = expression.bindings.front();

	Expression opExpected(Atom<Number_t>(condition.getValueDouble()));
	auto itFoundValue = std::find(++expression.operands.begin(), expression.operands.end(), opExpected);
	assert(itFoundValue != expression.operands.end());

	int indexBlock = itFoundValue - expression.operands.begin() -1;
	auto blockFound = expression.blocks.begin();
	std::advance(blockFound, indexBlock);

	InterpretationScope* scopeI12n = function->getScope(*blockFound);

	if (condition.operands.size()) {
	const Expression& value = condition.operands.at(0);
	scopeI12n->overrideBinding(value, identCondition);
	}

	return *blockFound;
	}

	llvm::Value*
	InterpretationScope::compileHybrid(const InterpretationOperator& op, const Expression& expression, const Context& context){
	switch(op){
	case IF_INTERPRET_CONDITION: {
	CodeScope* scopeResult = processOperatorIf(expression);

	llvm::Value* result = context.function->getScopeUnit(scopeResult)->compile();
	return result;
	}

	case SWITCH_INTERPRET_CONDITION:{
	CodeScope* scopeResult = processOperatorSwitch(expression);

	llvm::Value* result = context.function->getScopeUnit(scopeResult)->compile();
	return result;
	}

	case SWITCH_VARIANT: {
	CodeScope* scopeResult = processOperatorSwitchVariant(expression);
	const Expression& condition = expression.operands.at(0);
	const Expression& valueCondition = process(condition);

	const string identCondition = expression.bindings.front();
	auto scopeCompilation = Decorators<CachedScopeDecoratorTag>::getInterface(context.function->getScopeUnit(scopeResult));

	if(valueCondition.operands.size()){
	//override value
	Symbol symbCondition{ScopedSymbol{scopeResult->__identifiers.at(identCondition), versions::VERSION_NONE}, scopeResult};
	scopeCompilation->overrideDeclaration(symbCondition, Expression(valueCondition.operands.at(0)));

	//set correct type for binding:
	TypeAnnotation typeVariant = typeinference::getType(condition, *function->man->ast);
	int conditionIndex = valueCondition.getValueDouble();
	ScopedSymbol symbolInternal = scopeResult->getSymbol(identCondition);
	scopeResult->__declarations[symbolInternal].bindType(typeVariant.__operands.at(conditionIndex));
	}

	llvm::Value* result = context.function->getScopeUnit(scopeResult)->compile();
	return result;
	}

	case FOLD_INTERPRET_INPUT: {
	//initialization
	const Expression& exprInput = process(expression.getOperands()[0]);
	assert(exprInput.op == Operator::LIST);

	CodeScope* scopeBody = expression.blocks.front();

	const string& nameEl = expression.bindings[0];
	Symbol symbEl{ScopedSymbol{scopeBody->__identifiers.at(nameEl), versions::VERSION_NONE}, scopeBody};
	const std::string& idAccum = expression.bindings[1];
	llvm::Value* rawAccum = context.scope->process(expression.getOperands()[1]);

	InterpretationScope* intrBody = function->getScope(scopeBody);
	auto unitBody = Decorators<CachedScopeDecoratorTag>::getInterface(context.function->getScopeUnit(scopeBody));

	const std::vector<Expression> elementsInput= exprInput.getOperands();

	for (size_t i=0; i<elementsInput.size(); ++i){
	intrBody->reset();
	unitBody->reset();

	Expression exprElement = elementsInput[i];

	intrBody->overrideBinding(exprElement, nameEl);
	unitBody->overrideDeclaration(symbEl, move(exprElement));
	unitBody->bindArg(rawAccum, string(idAccum));

	rawAccum = unitBody->compile();
	}

	return rawAccum;
	}

	/*
	case FOLD_INF_INTERPRET_INOUT{
	}
	*/

	//TODO refactor as InterpretationCallStatement class
	case CALL_INTERPRET_PARTIAL: {
	const std::string &calleeName = expression.getValueString();
	ICodeScopeUnit* scopeUnitSelf = context.scope;
	ManagedFnPtr callee = this->function->man->ast->findFunction(calleeName);
	const FunctionInterpretationData& calleeData = FunctionInterpretationHelper::getSignature(callee);
	std::vector<llvm::Value *> argsActual;
	PIFSignature sig;
	sig.declaration = callee;

	for(size_t no=0, size = expression.operands.size(); no < size; ++no){
	const Expression& op = expression.operands[no];

	if (calleeData.signature.at(no) == INTR_ONLY){
	sig.bindings.push_back(process(op));
	continue;
	}

	argsActual.push_back(scopeUnitSelf->process(op));
	}

	TargetInterpretation* man = dynamic_cast<TargetInterpretation*>(this->function->man);
	PIFunction* pifunction = man->getFunction(move(sig));

	llvm::Function* raw = pifunction->compile();
	boost::scoped_ptr<CallStatementRaw> statement(new CallStatementRaw(raw, man->pass->man->llvm));
	return (*statement)(move(argsActual));
	}

	default: break;
	}

	assert(false&& "Unknown hybrid operator");
	return nullptr;
	}

	llvm::Value*
	InterpretationScope::compile(const Expression& expression, const Context& context){
	const InterpretationData& data = Attachments::get<InterpretationData>(expression);

	if (data.op != InterpretationOperator::NONE){
	return compileHybrid(data.op, expression, context);
	}

	Expression result = process(expression);
	return context.scope->process(result);
	}

	Expression
	InterpretationScope::process(const Expression& expression){
	switch (expression.__state){
	case Expression::INVALID:
	assert(false);

	case Expression::NUMBER:
	case Expression::STRING:
	return expression;

	case Expression::IDENT:{
	- Symbol s = Attachments::get<Symbol>(expression);
	+ Symbol s = Attachments::get<IdentifierSymbol>(expression);
	return Parent::processSymbol(s);
	}

	case Expression::COMPOUND:
	break;

	default: assert(false);
	}

	switch (expression.op) {
	case Operator::EQU: {
	const Expression& left = process(expression.operands[0]);
	const Expression& right = process(expression.operands[1]);

	if (left == right) return EXPRESSION_TRUE;
	return EXPRESSION_FALSE;
	}

	case Operator::NE: {
	const Expression& left = process(expression.operands[0]);
	const Expression& right = process(expression.operands[1]);

	if (left == right) return EXPRESSION_FALSE;
	return EXPRESSION_TRUE;
	}

	case Operator::LOGIC_AND: {
	assert(expression.operands.size() == 1);
	return process (expression.operands[0]);
	}


	// case Operator::LOGIC_OR:
	case Operator::CALL: {
	const std::string &fnName = expression.getValueString();
	ManagedFnPtr fnAst = this->function->man->ast->findFunction(fnName);
	InterpretationFunction* fnUnit = this->function->man->getFunction(fnAst);

	vector<Expression> args;
	args.reserve(expression.getOperands().size());

	for(size_t i=0, size = expression.getOperands().size(); i<size; ++i) {
	args.push_back(process(expression.getOperands()[i]));
	}

	return fnUnit->process(args);
	}

	case Operator::CALL_INTRINSIC: {
	std::string nameFunction = expression.getValueString();

	if(nameFunction=="query"){
	assert(expression.operands.size() == 1);
	assert(expression.operands.front().__state == Expression::STRING);

	std::string namePredicate = expression.operands.front().getValueString();
	ClaspLayer::ModelFragment model = (static_cast<TargetInterpretation*>(function->man))->pass->man->clasp->query(namePredicate);

	Expression result(Operator::LIST, {});

	if(model)
	for (const auto& row: boost::make_iterator_range(model.get())) {
	result.addArg(representAsAnnotation(std::get<1>(row)));
	}

	return result;

	} else {
	assert(false && "Unknown intrinsic");
	}
	}

	case Operator::IF:{
	CodeScope* scopeResult = processOperatorIf(expression);
	return function->getScope(scopeResult)->processScope();
	}

	case Operator::SWITCH: {
	CodeScope* scopeResult = processOperatorSwitch(expression);
	return function->getScope(scopeResult)->processScope();
	}

	case Operator::SWITCH_VARIANT: {
	CodeScope* scopeResult = processOperatorSwitchVariant(expression);
	return function->getScope(scopeResult)->processScope();
	}

	case Operator::INDEX: {
	Expression exprData = process(expression.operands[0]);

	for (size_t keyId=1; keyId<expression.operands.size(); ++keyId){
	const Expression& exprKey = process(expression.operands[keyId]);

	if (exprKey.__state == Expression::STRING){
	const string& key = exprKey.getValueString();
	assert(exprData.__indexBindings.count(key));
	size_t idxKey = exprData.__indexBindings.at(key);

	exprData = Expression(exprData.operands.at(idxKey));
	continue;
	}

	if (exprKey.__state == Expression::NUMBER){
	int key = exprKey.getValueDouble();
	exprData = Expression(exprData.operands[key]);
	continue;
	}

	assert(false && "Inappropriate key");
	}

	return exprData;
	}

	case Operator::FOLD: {
	const Expression& exprInput = process(expression.getOperands()[0]);
	const Expression& exprInit = process(expression.getOperands()[1]);

	const std::string& argEl = expression.bindings[0];
	const std::string& argAccum = expression.bindings[1];

	InterpretationScope* body = function->getScope(expression.blocks.front());

	Expression accum = exprInit;
	for(size_t size=exprInput.getOperands().size(), i=0; i<size; ++i){
	body->overrideBinding(exprInput.getOperands()[i], argEl);
	body->overrideBinding(accum, argAccum);

	accum = body->processScope();
	}

	return accum;
	}

	// case Operator::MAP: {
	// break;
	// }

	default: break;
	}

	return expression;
	}

	InterpretationFunction*
	TargetInterpretation::getFunction(IFunctionUnit* unit){
	if (__dictFunctionsByUnit.count(unit)) {
	return __dictFunctionsByUnit.at(unit);
	}

	InterpretationFunction* f = new InterpretationFunction(unit->function, this);
	__dictFunctionsByUnit.emplace(unit, f);
	assert(__functions.emplace(unit->function.id(), f).second);

	return f;
	}

	PIFunction*
	TargetInterpretation::getFunction(PIFSignature&& sig){

	auto f = __pifunctions.find(sig);
	if (f != __pifunctions.end()){
	return f->second;
	}

	PIFunction* result = new PIFunction(PIFSignature(sig), __pifunctions.size(), this);
	__pifunctions.emplace(move(sig), result);
	assert(__dictFunctionsByUnit.emplace(result->functionUnit, result).second);

	return result;
	}

	InterpretationScope*
	TargetInterpretation::transformContext(const Context& c){
	return this->getFunction(c.function)->getScope(c.scope->scope);
	}

	llvm::Value*
	TargetInterpretation::compile(const Expression& expression, const Context& ctx){
	return transformContext(ctx)->compile(expression, ctx);
	}

	InterpretationFunction::InterpretationFunction(const ManagedFnPtr& function, Target<TargetInterpretation>* target)
	: Function<TargetInterpretation>(function, target)
	{}

	Expression
	InterpretationFunction::process(const std::vector<Expression>& args){
	InterpretationScope* body = getScope(__function->__entry);

	for(size_t i=0, size = args.size(); i<size; ++i) {
	body->overrideBinding(args.at(i), string(body->scope->__bindings.at(i)));
	}

	return body->processScope();
	}

	// Partial function interpretation

	typedef BasicFunctionUnit PIFunctionUnitParent;
	class PIFunctionUnit: public PIFunctionUnitParent{
	public:

	PIFunctionUnit(ManagedFnPtr f, std::set<size_t>&& arguments, size_t id, CompilePass* p)
	: PIFunctionUnitParent(f, p), argumentsActual(move(arguments)), __id(id)
	{}

	protected:
	std::vector<llvm::Type*> prepareArguments(){
	LLVMLayer* llvm = PIFunctionUnitParent::pass->man->llvm;
	AST* ast = PIFunctionUnitParent::pass->man->root;
	CodeScope* entry = PIFunctionUnitParent::function->__entry;
	std::vector<llvm::Type*> signature;

	for(size_t no: argumentsActual){
	VNameId argId = entry->__identifiers.at(entry->__bindings.at(no));
	ScopedSymbol arg{argId, versions::VERSION_NONE};

	signature.push_back(llvm->toLLVMType(ast->expandType(entry->__declarations.at(arg).type)));
	}

	return signature;
	}

	llvm::Function::arg_iterator prepareBindings(){
	CodeScope* entry = PIFunctionUnitParent::function->__entry;
	ICodeScopeUnit* entryCompilation = PIFunctionUnitParent::getScopeUnit(entry);
	llvm::Function::arg_iterator fargsI = PIFunctionUnitParent::raw->arg_begin();

	for(size_t no: argumentsActual){
	ScopedSymbol arg{entry->__identifiers.at(entry->__bindings.at(no)), versions::VERSION_NONE};

	entryCompilation->bindArg(&*fargsI, arg);
	fargsI->setName(entry->__bindings.at(no));
	++fargsI;
	}

	return fargsI;
	}

	virtual std::string prepareName(){
	return PIFunctionUnitParent::prepareName() + "_" + std::to_string(__id);
	}

	private:
	std::set<size_t> argumentsActual;
	size_t __id;
	};

	PIFunction::PIFunction(PIFSignature&& sig, size_t id, TargetInterpretation* target)
	: InterpretationFunction(sig.declaration, target), signatureInstance(move(sig))
	{
	const FunctionInterpretationData& functionData = FunctionInterpretationHelper::getSignature(signatureInstance.declaration);

	std::set<size_t> argumentsActual;
	for (size_t no=0, size=functionData.signature.size(); no < size; ++no){
	if (functionData.signature.at(no) != INTR_ONLY){
	argumentsActual.insert(no);
	}
	}

	functionUnit = new PIFunctionUnit(signatureInstance.declaration, move(argumentsActual), id, target->pass);
	CodeScope* entry = signatureInstance.declaration->__entry;
	auto entryUnit = Decorators<CachedScopeDecoratorTag>::getInterface<>(functionUnit->getEntry());
	InterpretationScope* entryIntrp = InterpretationFunction::getScope(entry);

	for(size_t no=0, sigNo=0, size = entry->__bindings.size(); no < size; ++no){
	if (functionData.signature.at(no) == INTR_ONLY){
	entryIntrp->overrideBinding(signatureInstance.bindings[sigNo], entry->__bindings[no]);

	VNameId argId = entry->__identifiers.at(entry->__bindings[no]);
	Symbol argSymbol{ScopedSymbol{argId, versions::VERSION_NONE}, entry};
	entryUnit->overrideDeclaration(argSymbol, Expression(signatureInstance.bindings[sigNo]));
	++sigNo;
	}
	}
	}

	llvm::Function*
	PIFunction::compile(){
	llvm::Function* raw = functionUnit->compile();

	return raw;
	}

	bool operator<(const PIFSignature& lhs, const PIFSignature& rhs){
	if (lhs.declaration.id() != rhs.declaration.id()) {
	return lhs.declaration.id() < rhs.declaration.id();
	}

	return lhs.bindings < rhs.bindings;
	}

	bool operator<(const PIFSignature& lhs, PIFunction* const rhs){
	return lhs < rhs->signatureInstance;
	}

	bool operator<(PIFunction* const lhs, const PIFSignature& rhs){
	return lhs->signatureInstance < rhs;
	}

	}}

	/** \class xreate::interpretation::InterpretationFunction
	*
	* Holds list of xreate::interpretation::InterpretationScope 's focused on interpretation of individual code scopes
	*
	* There is particulat subclass PIFunction intended to represent partially interpreted functions
	*\sa TargetInterpretation, [Interpretation Concept](/w/concepts/dfa)
	*/
	/** \class xreate::interpretation::TargetInterpretation
	*
	* Executed during compilation and intented to preprocess eligible parts of code.
	* Established on [Targets Infrastructure](\ref compilation::Target)
	*
	* Holds list of InterpretationFunction / PIFunction to represent interpretation process for individual functions
	*
	* In order to be activated during compilation process there is
	* InterpretationScopeDecorator implementation of ICodeScopeUnit
	* \sa InterpretationPass, compilation::Target, [Interpretation Concept](/w/concepts/dfa)
	*
	*/
	\ No newline at end of file
	diff --git a/cpp/src/compilation/targets.h b/cpp/src/compilation/targets.h
	index 2da1ce4..5c39425 100644
	--- a/cpp/src/compilation/targets.h
	+++ b/cpp/src/compilation/targets.h
	@@ -1,201 +1,201 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: targetabstract.h
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on July 2, 2016, 1:25 PM
	*/

	/**
	* \file
	* \brief Compilation targets infrastructure
	*/


	#ifndef TARGETABSTRACT_H
	#define TARGETABSTRACT_H
	#include "ast.h"

	#include <boost/optional.hpp>
	#include <map>

	namespace xreate{ namespace compilation {

	template <typename ConcreteTarget>
	struct TargetInfo{
	//typedef Result
	//typedef Function
	//typedef Scope
	};

	template<typename ConcreteTarget>
	class Function;

	template<typename ConcreteTarget>
	class Target;

	template<typename ConcreteTarget>
	class Scope{
	typedef typename TargetInfo<ConcreteTarget>::Scope Self;

	public:
	CodeScope* scope;

	typename TargetInfo<ConcreteTarget>::Result
	processSymbol(const Symbol& s){
	CodeScope* scope = s.scope;
	Self* self = function->getScope(scope);

	if (self->__bindings.count(s.identifier)) {
	return self->__bindings[s.identifier];
	}

	- const Expression& declaration = CodeScope::getDefinition(s);
	+ const Expression& declaration = CodeScope::getDefinition(s, true);
	if (!declaration.isDefined()){
	assert(false); //for bindings there should be result already
	}

	return self->__bindings[s.identifier] = self->process(declaration);
	}

	typename TargetInfo<ConcreteTarget>::Result
	processScope() {
	if (raw) return *raw;

	raw = process(scope->getBody());
	return *raw;
	}

	// typename TargetInfo<ConcreteTarget>::Result
	// processFunction(typename TargetInfo<ConcreteTarget>::Function* fnRemote, const std::vector<typename TargetInfo<ConcreteTarget>::Result>& args){
	// Scope<ConcreteTarget> scopeRemote = fnRemote->getScope(fnRemote->__function->__entry);
	//
	// if (scopeRemote->raw){
	// return scopeRemote->raw;
	// }
	//
	// return fnRemote->process(args);
	// }

	virtual typename TargetInfo<ConcreteTarget>::Result
	process(const Expression& expression)=0;

	Scope(CodeScope* codeScope, Function<ConcreteTarget>* f)
	: scope(codeScope), function(f) {}

	virtual ~Scope(){}

	void
	overrideBinding(typename TargetInfo<ConcreteTarget>::Result arg, const std::string& name){
	assert(scope->__identifiers.count(name));

	ScopedSymbol id{scope->__identifiers.at(name), versions::VERSION_NONE};
	__bindings[id] = arg;

	//reset the result if any:
	raw.reset();
	}

	void registerChildScope(std::shared_ptr<Self> scope){
	__childScopes.push_back(scope);
	}

	void reset(){
	__bindings.clear();
	__childScopes.clear();
	raw.reset();
	}

	protected:
	Function<ConcreteTarget>* function=0;
	std::map<ScopedSymbol, typename TargetInfo<ConcreteTarget>::Result> __bindings;
	std::list<std::shared_ptr<Self>> __childScopes;
	typename boost::optional<typename TargetInfo<ConcreteTarget>::Result> raw;
	};

	template<typename ConcreteTarget>
	class Function{
	typedef typename TargetInfo<ConcreteTarget>::Result Result;
	typedef typename TargetInfo<ConcreteTarget>::Scope ConcreteScope;

	public:
	Function(const ManagedFnPtr& function, Target<ConcreteTarget>* target)
	: man(target), __function(function) {}

	virtual ~Function(){};

	ConcreteScope*
	getScope(CodeScope* scope){
	if (__scopes.count(scope)) {
	auto result = __scopes.at(scope).lock();

	if (result){
	return result.get();
	}
	}

	std::shared_ptr<ConcreteScope> unit(new ConcreteScope(scope, this));

	if (scope->__parent != nullptr){
	getScope(scope->__parent)->registerChildScope(unit);

	} else {
	assert(!__entryScope);
	__entryScope = unit;
	}

	if (!__scopes.emplace(scope, unit).second){
	__scopes[scope] = unit;
	}

	return unit.get();
	}

	virtual Result
	process(const std::vector<Result>& args)=0;

	Target<ConcreteTarget>* man=0;
	ManagedFnPtr __function;

	protected:
	std::map<CodeScope*, std::weak_ptr<ConcreteScope>> __scopes;
	std::shared_ptr<ConcreteScope> __entryScope;
	};

	/** \brief Similar to xreate::IPass */
	template<typename ConcreteTarget>
	class Target {
	typedef typename TargetInfo<ConcreteTarget>::Function ConcreteFunction;

	public:
	Target(AST* root): ast(root){}

	ConcreteFunction*
	getFunction(const ManagedFnPtr& function){
	unsigned int id = function.id();

	if (!__functions.count(id)){
	ConcreteFunction* unit = new ConcreteFunction(function, this);
	__functions.emplace(id, unit);
	return unit;
	}

	return __functions.at(id);
	}

	AST* ast;
	virtual ~Target(){
	for (const auto& entry: __functions){
	delete entry.second;
	}
	}

	protected:
	std::map<unsigned int, ConcreteFunction*> __functions;
	};

	}}

	#endif /* TARGETABSTRACT_H */
	diff --git a/cpp/src/compilation/versions.h b/cpp/src/compilation/versions.h
	index 6369d31..d63d03c 100644
	--- a/cpp/src/compilation/versions.h
	+++ b/cpp/src/compilation/versions.h
	@@ -1,139 +1,153 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* versions.cpp
	*
	* Author: pgess <v.melnychenko@xreate.org>
	* Created on January 21, 2017, 1:24 PM
	*/

	/**
	* \file
	* \brief CodeScope's Decorator to support Versions
	*/

	#include "pass/versionspass.h"
	#include "pass/compilepass.h"
	#include "llvmlayer.h"

	namespace xreate {
	class CompilePass;

	namespace compilation {
	class ICodeScopeUnit;
	class IFunctionUnit;
	}

	namespace versions{

	/**\brief Enables compilation of code with versioned variables
	* \details Dictates order of computation determined by VersionsPass
	* \extends xreate::compilation::ICodeScopeUnit
	* \sa VersionsPass, VersionsGraph
	*/
	template<class Parent>
	class VersionsScopeDecorator: public Parent{
	typedef VersionsScopeDecorator<Parent> SELF;

	public:
	VersionsScopeDecorator(CodeScope* codeScope, compilation::IFunctionUnit* f, CompilePass* compilePass): Parent(codeScope, f, compilePass){}

	virtual llvm::Value* processSymbol(const Symbol& s, std::string hintSymbol=""){
	if (Attachments::exists<VersionImposedDependency>(s)){
	const std::list<Symbol> dependencies = Attachments::get<VersionImposedDependency>(s);

	for(const Symbol& symbolDependent: dependencies){
	processSymbol(symbolDependent);
	}
	}

	llvm::Value* result = Parent::processSymbol(s, hintSymbol);

	if (s.identifier.version == VERSION_INIT){
	llvm::Value* storage = SELF::processIntrinsicInit(result->getType(), hintSymbol);
	setSymbolStorage(s, storage);

	processIntrinsicCopy(result, storage);
	return compilation::ICodeScopeUnit::pass->man->llvm->builder.CreateLoad(storage);

	} else if (s.identifier.version != VERSION_NONE){
	Symbol symbolInitVersion = getSymbolInitVersion(s);

	llvm::Value* storage = getSymbolStorage(symbolInitVersion);
	processIntrinsicCopy(result, storage);

	return compilation::ICodeScopeUnit::pass->man->llvm->builder.CreateLoad(storage);
	}

	return result;
	}

	llvm::Value*
	processIntrinsicInit(llvm::Type* typeStorage, const std::string& hintVarDecl=""){
	llvm::IntegerType* tyInt = llvm::Type::getInt32Ty(llvm::getGlobalContext());
	llvm::ConstantInt* constOne = llvm::ConstantInt::get(tyInt, 1, false);

	return compilation::ICodeScopeUnit::pass->man->llvm->builder.CreateAlloca(typeStorage, constOne, hintVarDecl);
	}

	void
	processIntrinsicCopy(llvm::Value* value, llvm::Value* storage){
	compilation::ICodeScopeUnit::pass->man->llvm->builder.CreateStore(value, storage);
	}

	private:
	std::map<Symbol, llvm::Value*> __symbolStorage;

	static Symbol
	getSymbolInitVersion(const Symbol& s){
	return Symbol{ScopedSymbol{s.identifier.id, VERSION_INIT}, s.scope};
	}

	llvm::Value*
	getSymbolStorage(const Symbol& s){
	return __symbolStorage.at(s);
	}

	void setSymbolStorage(const Symbol& s, llvm::Value* storage){
	__symbolStorage[s] = storage;
	}

	};
	+
	+template<class Parent>
	+class VersionedFunctionDecorator : public Parent {
	+public:
	+ VersionedFunctionDecorator(ManagedFnPtr f, CompilePass* p)
	+ : Parent(f, p){}
	+
	+protected:
	+ std::vector<llvm::Type*> prepareArguments() {
	+ std::vector<llvm::Type*>&& arguments = Parent::prepareArguments();
	+
	+ return arguments;
	+ }
	+};
	} } //end of namespace xreate::versions

	// llvm::Value*
	// processIntrinsicInitAndCopy(){
	//
	// }

	//llvm::Value*
	//process(const Expression& expr, const std::string& hintVarDecl){
	// case Operator::CALL_INTRINSIC: {
	// enum INRINSIC{INIT, COPY};
	//
	// const ExpandedType& typSymbol = pass->man->root->expandType(expr.type);
	//
	// INTRINSIC op = (INTRINSIC) expr.getValueDouble();
	//
	// switch (op){
	// case INIT: {
	// llvm::Type* typSymbolRaw = l.toLLVMType(typSymbol);
	//
	//
	// return storage;
	// }
	//
	// case COPY: {
	// llvm::Type* typSymbolRaw = l.toLLVMType(typSymbol);
	// llvm::value* valueOriginal = process(expr.getOperands()[0], hintVarDecl);
	// llvm::Value* storage = l.builder.CreateAlloca(typSymbolRaw, constOne, hintVarDecl);
	// llvm::Value* valueCopy = l.builder.CreateStore(valueOriginal, storage);
	//
	// return valueCopy;
	// }
	// }
	// return;
	// }
	//}
	//};
	diff --git a/cpp/src/pass/abstractpass.cpp b/cpp/src/pass/abstractpass.cpp
	index 387efbf..17f8385 100644
	--- a/cpp/src/pass/abstractpass.cpp
	+++ b/cpp/src/pass/abstractpass.cpp
	@@ -1,103 +1,103 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	/**
	* \file abstractpass.h
	* \brief Infrastructure to iterate over AST to facilitate analysis and compilation.
	*/

	#include "abstractpass.h"
	#include "attachments.h"
	#include "xreatemanager.h"

	using namespace std;

	namespace xreate {

	template<>
	void defaultValue<void>(){}

	void IPass::finish(){}

	IPass::IPass(PassManager *manager)
	: man(manager) {
	}

	template<>
	void
	AbstractPass<void>::processSymbol(const Symbol& symbol, PassContext context, const std::string& hintSymbol)
	{
	if (__visitedSymbols.isCached(symbol))
	return;

	__visitedSymbols.setCachedValue(symbol);
	- const Expression& declaration = CodeScope::getDefinition(symbol);
	+ const Expression& declaration = CodeScope::getDefinition(symbol, true);

	if (declaration.isDefined()){
	PassContext context2 = context.updateScope(symbol.scope);
	process(declaration, context2, hintSymbol);
	}
	}

	template<>
	void
	AbstractPass<void>::process(const Expression& expression, PassContext context, const std::string& varDecl){
	if (expression.__state == Expression::COMPOUND){
	for (const Expression &op: expression.getOperands()) {
	process(op, context);
	}

	for (CodeScope* scope: expression.blocks) {
	process(scope, context);
	}

	if (expression.op == Operator::CALL){
	processExpressionCall(expression, context);
	}

	return;
	}

	if (expression.__state == Expression::IDENT){
	assert(context.scope);
	- processSymbol(Attachments::get<Symbol>(expression), context, expression.getValueString());
	+ processSymbol(Attachments::get<IdentifierSymbol>(expression), context, expression.getValueString());
	}
	}
	}

	/**
	* \class xreate::IPass
	*
	* Each pass has to have IPass interface to be controllable by XreateManager.
	* However in most cases users should inherit minimal useful implementation xreate::AbstractPass
	*
	* \note It's usually expected that custom Pass publish processing results by one of the following means:
	* - xreate::Attachments for communicating with other Passes
	* - IAnalysisReport to feed xreate::ClaspLayer solver
	*
	* \sa xreate::XreateManager, xreate::AbstractPass
	*/

	/**
	* \class xreate::AbstractPass
	*
	* Iterates over %AST and provides functions to alter processing of particular %AST nodes.
	* Thus client should not re-implement every possible node processing
	* and it's enough to focus only on relevant nodes.
	*
	* Template parameter `Output` specify type of node processing result data.
	*
	* Automatically caches already visited nodes
	*
	* \note It's usually expected that custom Pass publish processing results by one of the following means:
	* - xreate::Attachments for communicating with other Passes
	* - IAnalysisReport to feed xreate::ClaspLayer solver
	*
	*
	* \sa xreate::XreateManager, xreate::IPass, xreate::AST
	*/

	diff --git a/cpp/src/pass/abstractpass.h b/cpp/src/pass/abstractpass.h
	index 5ed39cb..93322d9 100644
	--- a/cpp/src/pass/abstractpass.h
	+++ b/cpp/src/pass/abstractpass.h
	@@ -1,205 +1,206 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	#ifndef ABSTRACTPASS_H
	#define ABSTRACTPASS_H
	#include "ast.h"
	#include "xreatemanager.h"

	#include<iostream>
	namespace xreate
	{
	/** \brief Holds current position in %AST while traversing*/
	struct PassContext
	{
	CodeScope* scope = 0;
	ManagedFnPtr function;
	ManagedRulePtr rule;
	std::string varDecl;

	PassContext()
	{}

	PassContext updateScope(CodeScope* scopeNew) {
	PassContext context2{*this};
	context2.scope = scopeNew;
	return context2;
	}

	~PassContext(){}
	};

	/** \brief Base class for all passes to inherit */
	class IPass {
	public:
	IPass(PassManager* manager);

	/** \brief Executes pass */
	virtual void run()=0;

	/** \brief Finalizes pass. Empty by default*/
	virtual void finish();

	PassManager* man;
	};

	template<class Output>
	Output defaultValue();

	template<>
	void defaultValue<void>();

	/** \brief Stores processing results for already visited nodes */
	template<class Output>
	class SymbolCache: private std::map<Symbol, Output>{
	public:
	bool isCached(const Symbol& symbol){
	return this->count(symbol);
	}

	Output setCachedValue(const Symbol& symbol, Output&& value){
	(*this)[symbol] = value;
	return value;
	}

	Output getCachedValue(const Symbol& symbol){
	assert(this->count(symbol));
	return this->at(symbol);
	}
	};

	/** \brief Set of already visited nodes */
	template<>
	class SymbolCache<void>: private std::set<Symbol>{
	public:
	bool isCached(const Symbol& symbol){
	bool result = this->count(symbol) > 0;
	return result;
	}
	void setCachedValue(const Symbol& symbol){
	this->insert(symbol);
	}

	void getCachedValue(const Symbol& symbol){
	}
	};

	/** \brief Minimal useful IPass implementation*/
	template<class Output>
	class AbstractPass: public IPass {
	SymbolCache<Output> __visitedSymbols;

	protected:
	virtual Output processSymbol(const Symbol& symbol, PassContext context, const std::string& hintSymbol=""){
	if (__visitedSymbols.isCached(symbol))
	return __visitedSymbols.getCachedValue(symbol);


	- const Expression& declaration = CodeScope::getDefinition(symbol);
	+ const Expression& declaration = CodeScope::getDefinition(symbol, true);
	if (declaration.isDefined()){
	PassContext context2 = context.updateScope(symbol.scope);

	Output&& result = process(declaration, context2, hintSymbol);
	return __visitedSymbols.setCachedValue(symbol, std::move(result));
	}

	return defaultValue<Output>();
	}

	Output processExpressionCall(const Expression& expression, PassContext context){
	const std::string &calleeName = expression.getValueString();
	std::list<ManagedFnPtr> callees = man->root->getFunctionSpecializations(calleeName);
	if (callees.size() == 1 && callees.front()){
	return processFnCall(callees.front(), context);

	} else {
	for (const ManagedFnPtr& callee: callees){
	processFnCallUncertain(callee, context);
	}

	return defaultValue<Output>();
	}
	}

	SymbolCache<Output>& getSymbolCache(){
	return __visitedSymbols;
	}

	public:
	AbstractPass(PassManager* manager)
	: IPass(manager){}

	/** \brief Processes function invocation instruction */
	virtual Output processFnCall(ManagedFnPtr functionCallee, PassContext context){
	return defaultValue<Output>();
	}

	/** \brief Processes function invocation instruction in uncertain cases
	* \details Executed when it's impossible statically determine exact function invocation.
	* In this case get executed for all possible candidates
	*/
	virtual void processFnCallUncertain(ManagedFnPtr functionCallee, PassContext context)
	{}

	/** \brief Processes Logic Rule */
	virtual void process(ManagedRulePtr rule)
	{}

	/** \brief Processes Function */
	virtual Output process(ManagedFnPtr function)
	{
	PassContext context;
	context.function = function;

	return process(function->getEntryScope(), context);
	}

	/** \brief Processes single CodeScope */
	virtual Output process(CodeScope* scope, PassContext context, const std::string& hintBlockDecl=""){
	context.scope = scope;

	return processSymbol(Symbol{ScopedSymbol::RetSymbol, scope}, context);
	}
	-
	+
	+ //TODO expose Symbol instead of varDecl. Required by DFAPass.
	/** \brief Processes single Expression */
	virtual Output process(const Expression& expression, PassContext context, const std::string& varDecl=""){
	if (expression.__state == Expression::IDENT){
	assert(context.scope);
	- return processSymbol(Attachments::get<Symbol>(expression), context, expression.getValueString());
	+ return processSymbol(Attachments::get<IdentifierSymbol>(expression), context, expression.getValueString());
	}

	assert(false);
	return defaultValue<Output>();
	}

	/** \brief Executes AST traverse */
	void run() {
	ManagedRulePtr rule = man->root->begin<MetaRuleAbstract>();
	while (rule.isValid()) {
	process(rule);
	++rule;
	}

	ManagedFnPtr f = man->root->begin<Function>();
	while (f.isValid()) {
	process(f);
	++f;
	}
	}

	};

	template<>
	void
	AbstractPass<void>::processSymbol(const Symbol& symbol, PassContext context, const std::string& hintSymbol);

	template<>
	void
	AbstractPass<void>::process(const Expression& expression, PassContext context, const std::string& hintSymbol);

	}
	#endif
	diff --git a/cpp/src/pass/cfapass.cpp b/cpp/src/pass/cfapass.cpp
	index cf2a829..f231187 100644
	--- a/cpp/src/pass/cfapass.cpp
	+++ b/cpp/src/pass/cfapass.cpp
	@@ -1,119 +1,124 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* cfapass.cpp
	*
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	/**
	* \file cfapass.h
	* \brief Control Flow Analysis(CFA)
	*/

	#include "cfapass.h"
	#include "analysis/cfagraph.h"
	+#include "analysis/DominatorsTreeAnalysisProvider.h"

	#include <boost/range/iterator_range_core.hpp>

	using namespace std;
	using namespace xreate::cfa;

	void
	CFAPass::initSignatures(){
	auto range = man->root->__interfacesData.equal_range(CFA);
	for (auto i = range.first; i!= range.second; ++i){
	__signatures.emplace(i->second.op, i->second);
	}
	}

	void CFAPass::run(){
	initSignatures();

	return AbstractPass::run();
	}

	void
	CFAPass::finish()
	{
	- man->clasp->setCFAData(move(__context.graph));
	+ man->clasp->registerReport(__context.graph);
	+
	+ dominators::DominatorsTreeAnalysisProvider* reportDominators = new dominators::DominatorsTreeAnalysisProvider();
	+ reportDominators->run(man->clasp, __context.graph);
	+ man->clasp->registerReport(reportDominators);

	return AbstractPass::finish();
	}

	void
	CFAPass::processFnCall(ManagedFnPtr function, PassContext context)
	{
	ClaspLayer* clasp = man->clasp;
	__context.graph->addCallConnection(clasp->pack(context.scope), function->getName());

	return AbstractPass::processFnCall(function, context);
	}

	void
	CFAPass::processFnCallUncertain(ManagedFnPtr function, PassContext context){
	ClaspLayer* clasp = man->clasp;
	__context.graph->addCallConnection(clasp->pack(context.scope), function->getName());

	return AbstractPass::processFnCallUncertain(function, context);
	}

	void
	CFAPass::process(CodeScope* scope, PassContext context, const std::string& hintBlockDecl){
	ClaspLayer* clasp = man->clasp;

	CodeScope* scopeParent = context.scope;
	ScopePacked scopeId = clasp->pack(scope);

	if (scopeParent){
	__context.graph->addParentConnection(scopeId, clasp->pack(scopeParent));
	} else {
	__context.graph->addParentConnection(scopeId, context.function->getName());
	}

	//TOTEST scope annotations
	//SECTIONTAG context gather scope annotations
	__context.graph->addScopeAnnotations(scopeId, scope->tags);

	__context.graph->addContextRules(scopeId, scope->contextRules);

	return AbstractPass::process(scope, context, hintBlockDecl);
	}

	//TOTEST scope annotations via scheme
	void
	CFAPass::process(const Expression& expression, PassContext context, const std::string& varDecl){
	ClaspLayer* clasp = man->clasp;

	if (expression.__state == Expression::COMPOUND){
	- Operator op= expression.op;
	+ Operator op= expression.op;

	- if (__signatures.count(op)) {
	- assert(expression.blocks.size());
	+ if (__signatures.count(op)) {
	+ assert(expression.blocks.size());

	- for (const auto& scheme: boost::make_iterator_range(__signatures.equal_range(expression.op))) {
	- __context.graph->addScopeAnnotations(clasp->pack(expression.blocks.front()), scheme.second.getOperands());
	- }
	+ for (const auto& scheme: boost::make_iterator_range(__signatures.equal_range(expression.op))) {
	+ __context.graph->addScopeAnnotations(clasp->pack(expression.blocks.front()), scheme.second.getOperands());
	}
	+ }
	}

	return AbstractPass::process(expression, context, varDecl);
	}

	void
	CFAPass::process(ManagedFnPtr function)
	{
	__context.graph->addFunctionAnnotations(function->getName(), function->getTags());
	return AbstractPass::process(function);
	}

	CFAPass::CFAPass(PassManager* manager)
	: AbstractPass(manager)
	, __context{new CFAGraph(manager->clasp)}
	{}

	/**
	* \class xreate::cfa::CFAPass
	* \details Provides CFA, important analysis for reasoning. Iterates over AST and stores collected data in CFAGraph
	*/
	\ No newline at end of file
	diff --git a/cpp/src/pass/compilepass.cpp b/cpp/src/pass/compilepass.cpp
	index 255e5e2..66021a2 100644
	--- a/cpp/src/pass/compilepass.cpp
	+++ b/cpp/src/pass/compilepass.cpp
	@@ -1,824 +1,827 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* compilepass.cpp
	*/

	/**
	* \file compilepass.h
	* \brief Compilation pass
	*/

	#include "compilepass.h"
	#include "clasplayer.h"
	#include <ast.h>
	#include "llvmlayer.h"

	#include "query/containers.h"
	#include "query/context.h"
	#include "compilation/containers.h"
	#include "compilation/latecontextcompiler2.h"
	#include "ExternLayer.h"
	#include "pass/adhocpass.h"
	#include "compilation/targetinterpretation.h"
	#include "pass/versionspass.h"
	#include "compilation/scopedecorators.h"
	#include "compilation/adhocfunctiondecorator.h"
	#include "compilation/operators.h"
	#include "analysis/typeinference.h"

	#include <boost/optional.hpp>
	#include <memory>
	#include <iostream>

	using namespace std;
	using namespace llvm;

	//TODO use Scope<TargetLlvm>

	//SECTIONTAG late-context FunctionDecorator

	namespace xreate{namespace context{

	/** \brief Late Context enabled decorator for IFunctionUnit
	* \extends IFunctionUnit
	*/
	template<class Parent>
	class LateContextFunctionDecorator : public Parent {
	public:
	LateContextFunctionDecorator(ManagedFnPtr f, CompilePass* p)
	: Parent(f, p), contextCompiler(this, p) {
	}

	protected:
	std::vector<llvm::Type*> prepareArguments() {
	std::vector<llvm::Type*>&& arguments = Parent::prepareArguments();

	size_t sizeLateContextDemand = contextCompiler.getFunctionDemandSize();
	if (sizeLateContextDemand) {
	llvm::Type* ty32 = llvm::Type::getInt32Ty(llvm::getGlobalContext());
	llvm::Type* tyDemand = llvm::ArrayType::get(ty32, sizeLateContextDemand);

	arguments.push_back(tyDemand);
	}

	return arguments;
	}

	llvm::Function::arg_iterator prepareBindings() {
	llvm::Function::arg_iterator fargsI = Parent::prepareBindings();

	size_t sizeLateContextDemand = contextCompiler.getFunctionDemandSize();
	if (sizeLateContextDemand) {
	fargsI->setName("latecontext");
	contextCompiler.rawContextArgument = &*fargsI;
	++fargsI;
	}

	return fargsI;
	}

	public:
	context::LateContextCompiler2 contextCompiler;
	};

	}} //end of namespace xreate::context

	namespace xreate { namespace compilation{

	std::string
	BasicFunctionUnit::prepareName(){
	AST* ast = IFunctionUnit::pass->man->root;

	string name = ast->getFunctionSpecializations(IFunctionUnit::function->__name).size() > 1 ?
	IFunctionUnit::function->__name + std::to_string(IFunctionUnit::function.id()) :
	IFunctionUnit::function->__name;

	return name;
	}

	std::vector<llvm::Type*>
	BasicFunctionUnit::prepareArguments() {
	LLVMLayer* llvm = IFunctionUnit::pass->man->llvm;
	AST* ast = IFunctionUnit::pass->man->root;
	CodeScope* entry = IFunctionUnit::function->__entry;
	std::vector<llvm::Type*> signature;

	std::transform(entry->__bindings.begin(), entry->__bindings.end(), std::inserter(signature, signature.end()),
	[llvm, ast, entry](const std::string & arg)->llvm::Type* {
	assert(entry->__identifiers.count(arg));

	ScopedSymbol argid{entry->__identifiers.at(arg), versions::VERSION_NONE};
	return llvm->toLLVMType(ast->expandType(entry->__declarations.at(argid).type));
	});

	return signature;
	}

	llvm::Type*
	BasicFunctionUnit::prepareResult() {
	LLVMLayer* llvm = IFunctionUnit::pass->man->llvm;
	AST* ast = IFunctionUnit::pass->man->root;
	CodeScope* entry = IFunctionUnit::function->__entry;

	return llvm->toLLVMType(ast->expandType(entry->__declarations.at(ScopedSymbol::RetSymbol).type));
	}

	llvm::Function::arg_iterator
	BasicFunctionUnit::prepareBindings() {
	CodeScope* entry = IFunctionUnit::function->__entry;
	ICodeScopeUnit* entryCompilation = IFunctionUnit::getScopeUnit(entry);
	llvm::Function::arg_iterator fargsI = IFunctionUnit::raw->arg_begin();

	for (std::string &arg : entry->__bindings) {
	ScopedSymbol argid{entry->__identifiers[arg], versions::VERSION_NONE};

	entryCompilation->bindArg(&*fargsI, argid);
	fargsI->setName(arg);
	++fargsI;
	}

	return fargsI;
	}

	//DEBT compiler rigidly depends on exact definition of DefaultFunctionUnit
	typedef context::LateContextFunctionDecorator<
	adhoc::AdhocFunctionDecorator<
	BasicFunctionUnit>> DefaultFunctionUnit;

	ICodeScopeUnit::ICodeScopeUnit(CodeScope* codeScope, IFunctionUnit* f, CompilePass* compilePass)
	: pass(compilePass), function(f), scope(codeScope) {
	}

	llvm::Value*
	CallStatementRaw::operator()(std::vector<llvm::Value *>&& args, const std::string& hintDecl) {
	llvm::Function* calleeInfo = dyn_cast<llvm::Function>(__callee);

	if (calleeInfo) {
	auto argsFormal = calleeInfo->args();

	int pos = 0;
	//SECTIONTAG types/convert function ret value
	for (auto argFormal = argsFormal.begin(); argFormal != argsFormal.end(); ++argFormal, ++pos) {
	args[pos] = typeinference::doAutomaticTypeConversion(args[pos], argFormal->getType(), llvm->builder);
	}
	}

	return llvm->builder.CreateCall(__calleeTy, __callee, args, hintDecl);
	}

	//DESABLEDFEATURE implement inlining
	class CallStatementInline : public ICallStatement {
	public:
	CallStatementInline(IFunctionUnit* caller, IFunctionUnit* callee, LLVMLayer* l)
	: __caller(caller), __callee(callee), llvm(l) {
	}

	llvm::Value* operator()(std::vector<llvm::Value *>&& args, const std::string& hintDecl) {
	//TOTEST inlining
	// CodeScopeUnit* entryCompilation = outer->getScopeUnit(function->__entry);
	// for(int i=0, size = args.size(); i<size; ++i) {
	// entryCompilation->bindArg(args.at(i), string(entryCompilation->scope->__bindings.at(i)));
	// }
	//
	//
	// return entryCompilation->compile();

	return nullptr;
	}

	private:
	IFunctionUnit* __caller;
	IFunctionUnit* __callee;
	LLVMLayer* llvm;

	bool isInline() {
	// Symbol ret = Symbol{0, function->__entry};
	// bool flagOnTheFly = SymbolAttachments::get<IsImplementationOnTheFly>(ret, false);
	//TODO consider inlining
	return false;
	}
	};

	BasicCodeScopeUnit::BasicCodeScopeUnit(CodeScope* codeScope, IFunctionUnit* f, CompilePass* compilePass)
	: ICodeScopeUnit(codeScope, f, compilePass) {
	}

	llvm::Value*
	BasicCodeScopeUnit::processSymbol(const Symbol& s, std::string hintRetVar) {
	Expression declaration = CodeScope::getDefinition(s);
	CodeScope* scope = s.scope;
	ICodeScopeUnit* self = ICodeScopeUnit::function->getScopeUnit(scope);

	return self->process(declaration, hintRetVar);
	}

	//TASK Isolate out context functionalty in decorator
	//TOTEST static late context decisions
	//TOTEST dynamic late context decisions
	ICallStatement*
	BasicCodeScopeUnit::findFunction(const Expression& opCall) {
	const std::string& calleeName = opCall.getValueString();
	LLVMLayer* llvm = pass->man->llvm;
	ClaspLayer* clasp = pass->man->clasp;
	DefaultFunctionUnit* function = dynamic_cast<DefaultFunctionUnit*> (this->function);
	context::ContextQuery* queryContext = pass->queryContext;

	const std::list<ManagedFnPtr>& specializations = pass->man->root->getFunctionSpecializations(calleeName);

	//if no specializations registered - check external function
	if (specializations.size() == 0) {
	llvm::Function* external = llvm->layerExtern->lookupFunction(calleeName);

	llvm::outs() << "Debug/External function: " << calleeName;
	external->getType()->print(llvm::outs(), true);
	llvm::outs() << "\n";

	return new CallStatementRaw(external, llvm);
	}

	//no decisions required
	if (specializations.size() == 1) {
	if (!specializations.front()->guardContext.isValid()) {
	return new CallStatementRaw(pass->getFunctionUnit(specializations.front())->compile(), llvm);
	}
	}

	//TODO move dictSpecialization over to a separate function in order to perform cache, etc.
	//prepare specializations dictionary
	std::map<Expression, ManagedFnPtr> dictSpecializations;

	boost::optional<ManagedFnPtr> variantDefault;
	boost::optional<ManagedFnPtr> variant;

	for (const ManagedFnPtr& f : specializations) {
	const Expression& guard = f->guardContext;

	//default case:
	if (!guard.isValid()) {
	variantDefault = f;
	continue;
	}

	assert(dictSpecializations.emplace(guard, f).second && "Found several identical specializations");
	}

	//check static context
	ScopePacked scopeCaller = clasp->pack(this->scope);
	const string atomSpecialization = "specialization";
	const Expression topicSpecialization(Operator::CALL,{(Atom<Identifier_t>(string(atomSpecialization))),
	Expression(Operator::CALL,
	{Atom<Identifier_t>(string(calleeName))}),
	Atom<Number_t>(scopeCaller)});

	const context::Decisions& decisions = queryContext->getFinalDecisions(scopeCaller);
	if (decisions.count(topicSpecialization)) {
	variant = dictSpecializations.at(decisions.at(topicSpecialization));
	}

	//TODO check only demand for this particular topic.
	size_t sizeDemand = function->contextCompiler.getFunctionDemandSize();

	//decision made if static context found or no late context exists(and there is default variant)
	bool flagHasStaticDecision = variant \|\| (variantDefault && !sizeDemand);

	//if no late context exists
	if (flagHasStaticDecision) {
	IFunctionUnit* calleeUnit = pass->getFunctionUnit(variant ? variant : variantDefault);

	//inlining possible based on static decision only
	// if (calleeUnit->isInline()) {
	// return new CallStatementInline(function, calleeUnit);
	// }

	return new CallStatementRaw(calleeUnit->compile(), llvm);
	}

	//require default variant if no static decision made
	assert(variantDefault);

	llvm::Function* functionVariantDefault = this->pass->getFunctionUnit(*variantDefault)->compile();
	llvm::Value* resultFn = function->contextCompiler.findFunction(calleeName, functionVariantDefault, scopeCaller);
	llvm::PointerType *resultPTy = cast<llvm::PointerType>(resultFn->getType());
	llvm::FunctionType *resultFTy = cast<llvm::FunctionType>(resultPTy->getElementType());
	return new CallStatementRaw(resultFn, resultFTy, llvm);
	}



	//DISABLEDFEATURE transformations
	// if (pass->transformations->isAcceptable(expr)){
	// return pass->transformations->transform(expr, result, ctx);
	// }

	llvm::Value*
	BasicCodeScopeUnit::process(const Expression& expr, const std::string& hintVarDecl) {
	#define DEFAULT(x) (hintVarDecl.empty()? x: hintVarDecl)
	llvm::Value *left;
	llvm::Value *right;
	LLVMLayer& l = *pass->man->llvm;
	xreate::compilation::Advanced instructions = xreate::compilation::Advanced({this, function, pass});

	switch (expr.op) {
	case Operator::SUB: case Operator::MUL:
	case Operator::DIV: case Operator::EQU: case Operator::LSS:
	case Operator::GTR: case Operator::NE: case Operator::LSE:
	case Operator::GTE:

	assert(expr.__state == Expression::COMPOUND);
	assert(expr.operands.size() == 2);

	left = process(expr.operands[0]);
	right = process(expr.operands[1]);

	//SECTIONTAG types/convert binary operation
	right = typeinference::doAutomaticTypeConversion(right, left->getType(), l.builder);
	break;

	default:;
	}

	switch (expr.op) {
	case Operator::ADD:
	{
	left = process(expr.operands[0]);
	Context context{this, function, pass};

	llvm::Value* resultSU = StructUpdate::add(expr.operands[0], left, expr.operands[1], context, DEFAULT("tmp_add"));
	if (resultSU) return resultSU;

	right = process(expr.operands[1]);

	llvm::Value* resultAddPA = pointerarithmetic::PointerArithmetic::add(left, right, context, DEFAULT("tmp_add"));
	if (resultAddPA) {
	return resultAddPA;
	}

	return l.builder.CreateAdd(left, right, DEFAULT("tmp_add"));
	break;
	}

	case Operator::SUB:
	return l.builder.CreateSub(left, right, DEFAULT("tmp_sub"));
	break;

	case Operator::MUL:
	return l.builder.CreateMul(left, right, DEFAULT("tmp_mul"));
	break;

	case Operator::DIV:
	return l.builder.CreateSDiv(left, right, DEFAULT("tmp_div"));
	break;

	case Operator::EQU:
	if (left->getType()->isIntegerTy()) return l.builder.CreateICmpEQ(left, right, DEFAULT("tmp_equ"));
	if (left->getType()->isFloatingPointTy()) return l.builder.CreateFCmpOEQ(left, right, DEFAULT("tmp_equ"));
	break;

	case Operator::NE:
	return l.builder.CreateICmpNE(left, right, DEFAULT("tmp_ne"));
	break;

	case Operator::LSS:
	return l.builder.CreateICmpSLT(left, right, DEFAULT("tmp_lss"));
	break;

	case Operator::LSE:
	return l.builder.CreateICmpSLE(left, right, DEFAULT("tmp_lse"));
	break;

	case Operator::GTR:
	return l.builder.CreateICmpSGT(left, right, DEFAULT("tmp_gtr"));
	break;

	case Operator::GTE:
	return l.builder.CreateICmpSGE(left, right, DEFAULT("tmp_gte"));
	break;

	case Operator::NEG:
	left = process(expr.operands[0]);
	return l.builder.CreateNeg(left, DEFAULT("tmp_neg"));
	break;

	case Operator::CALL:
	{
	assert(expr.__state == Expression::COMPOUND);
	shared_ptr<ICallStatement> callee(findFunction(expr));
	const std::string& nameCallee = expr.getValueString();

	//prepare arguments
	std::vector<llvm::Value *> args;
	args.reserve(expr.operands.size());

	std::transform(expr.operands.begin(), expr.operands.end(), std::inserter(args, args.end()),
	[this](const Expression & operand) {
	return process(operand);
	}
	);

	ScopePacked outerScopeId = pass->man->clasp->pack(this->scope);

	//TASK a) refactor CALL/ADHOC/find function
	//SECTIONTAG late-context propagation arg
	size_t calleeDemandSize = pass->queryContext->getFunctionDemand(nameCallee).size();
	if (calleeDemandSize) {
	DefaultFunctionUnit* function = dynamic_cast<DefaultFunctionUnit*> (this->function);
	llvm::Value* argLateContext = function->contextCompiler.compileContextArgument(nameCallee, outerScopeId);
	args.push_back(argLateContext);
	}

	return (*callee)(move(args), DEFAULT("res_" + nameCallee));
	}

	case Operator::IF:
	{
	return instructions.compileIf(expr, DEFAULT("tmp_if"));
	}

	case Operator::SWITCH:
	{
	return instructions.compileSwitch(expr, DEFAULT("tmp_switch"));
	}

	case Operator::LOOP_CONTEXT:
	{
	assert(false);
	return nullptr;
	//return instructions.compileLoopContext(expr, DEFAULT("tmp_loop"));
	}

	case Operator::LOGIC_AND:
	{
	assert(expr.operands.size() == 1);
	return process(expr.operands[0]);
	}

	case Operator::LIST:
	{
	return instructions.compileListAsSolidArray(expr, DEFAULT("tmp_list"));
	};

	case Operator::LIST_RANGE:
	{
	assert(false); //no compilation phase for a range list
	// return InstructionList(this).compileConstantArray(expr, l, hintRetVar);
	};

	case Operator::LIST_NAMED:
	{
	typedef Expanded<TypeAnnotation> ExpandedType;

	ExpandedType tyStructLiteral = l.ast->getType(expr);

	const std::vector<string> fieldsFormal = (tyStructLiteral.get().__operator == TypeOperator::CUSTOM) ?
	l.layerExtern->getStructFields(l.layerExtern->lookupType(tyStructLiteral.get().__valueCustom))
	: tyStructLiteral.get().fields;

	std::map<std::string, size_t> indexFields;
	for (size_t i = 0, size = fieldsFormal.size(); i < size; ++i) {
	indexFields.emplace(fieldsFormal[i], i);
	}

	llvm::StructType* tyLiteralRaw = llvm::cast<llvm::StructType>(l.toLLVMType(tyStructLiteral));
	llvm::Value* record = llvm::UndefValue::get(tyLiteralRaw);

	for (size_t i = 0; i < expr.operands.size(); ++i) {
	const Expression& operand = expr.operands.at(i);
	unsigned int fieldId = indexFields.at(expr.bindings.at(i));
	llvm::Value* result = process(operand);
	assert(result);
	record = l.builder.CreateInsertValue(record, result, llvm::ArrayRef<unsigned>({fieldId}));
	}

	return record;
	};

	case Operator::MAP:
	{
	assert(expr.blocks.size());
	return instructions.compileMapSolidOutput(expr, DEFAULT("map"));
	};

	case Operator::FOLD:
	{
	return instructions.compileFold(expr, DEFAULT("fold"));
	};

	case Operator::FOLD_INF:
	{
	return instructions.compileFoldInf(expr, DEFAULT("fold"));
	};

	case Operator::INDEX:
	{
	//TASK allow multiindex compilation
	assert(expr.operands.size() == 2);
	assert(expr.operands[0].__state == Expression::IDENT);

	const std::string& hintIdent = expr.operands[0].getValueString();
	- Symbol s = Attachments::get<Symbol>(expr.operands[0]);
	+ Symbol s = Attachments::get<IdentifierSymbol>(expr.operands[0]);
	const ExpandedType& t2 = pass->man->root->getType(expr.operands[0]);

	llvm::Value* aggr = processSymbol(s, hintIdent);

	switch (t2.get().__operator) {
	case TypeOperator::STRUCT: case TypeOperator::CUSTOM:
	{
	std::string idxField;
	const Expression& idx = expr.operands.at(1);
	switch (idx.__state) {

	//named struct field
	case Expression::STRING:
	idxField = idx.getValueString();
	break;

	//anonymous struct field
	case Expression::NUMBER:
	idxField = to_string((int) idx.getValueDouble());
	break;

	default:
	assert(false && "Wrong index for a struct");
	}

	return instructions.compileStructIndex(aggr, t2, idxField);
	};

	case TypeOperator::ARRAY:
	{
	std::vector<llvm::Value*> indexes;
	std::transform(++expr.operands.begin(), expr.operands.end(), std::inserter(indexes, indexes.end()),
	[this] (const Expression & op) {
	return process(op);
	}
	);

	return instructions.compileArrayIndex(aggr, indexes, DEFAULT(string("el_") + hintIdent));
	};

	default:
	assert(false);
	}
	};

	//SECTIONTAG adhoc actual compilation
	//TODO a) make sure that it's correct: function->adhocImplementation built for Entry scope and used in another scope
	case Operator::ADHOC:
	{
	DefaultFunctionUnit* function = dynamic_cast<DefaultFunctionUnit*> (this->function);
	assert(function->adhocImplementation && "Adhoc implementation not found");
	const Expression& comm = adhoc::AdhocExpression(expr).getCommand();

	CodeScope* scope = function->adhocImplementation->getCommandImplementation(comm);
	ICodeScopeUnit* unitScope = function->getScopeUnit(scope);

	//SECTIONTAG types/convert ADHOC ret convertation
	llvm::Type* resultTy = l.toLLVMType(pass->man->root->expandType(function->adhocImplementation->getResultType()));
	return typeinference::doAutomaticTypeConversion(unitScope->compile(), resultTy, l.builder);
	};

	case Operator::CALL_INTRINSIC:
	{
	const std::string op = expr.getValueString();

	if (op == "copy") {
	llvm::Value* result = process(expr.getOperands().at(0));

	auto decoratorVersions = Decorators<VersionsScopeDecoratorTag>::getInterface(this);
	llvm::Value* storage = decoratorVersions->processIntrinsicInit(result->getType());
	decoratorVersions->processIntrinsicCopy(result, storage);

	return l.builder.CreateLoad(storage, hintVarDecl);
	}

	assert(false && "undefined intrinsic");
	}

	case Operator::VARIANT:
	{
	//TASK Variant compilation to implement
	assert(false&& "Variant compilation not implemented yet");
	return nullptr;
	// const ExpandedType& typVariant = pass->man->root->getType(expr);
	// llvm::Type* typRaw = l.toLLVMType(typVariant);
	// int value = expr.getValueDouble();
	// return llvm::ConstantInt::get(typRaw, value);
	}

	case Operator::NONE:
	assert(expr.__state != Expression::COMPOUND);

	switch (expr.__state) {
	case Expression::IDENT:
	{
	- Symbol s = Attachments::get<Symbol>(expr);
	+ Symbol s = Attachments::get<IdentifierSymbol>(expr);
	return processSymbol(s, expr.getValueString());
	}

	case Expression::NUMBER:
	{
	llvm::Type* typConst;

	if (expr.type.isValid()) {
	typConst = l.toLLVMType(pass->man->root->getType(expr));

	} else {
	typConst = llvm::Type::getInt32Ty(llvm::getGlobalContext());
	}

	int literal = expr.getValueDouble();
	return llvm::ConstantInt::get(typConst, literal);
	}

	case Expression::STRING:
	{
	return instructions.compileConstantStringAsPChar(expr.getValueString(), DEFAULT("tmp_str"));
	};

	default:
	{
	break;
	}
	};

	break;

	default: break;

	}

	assert(false && "Can't compile expression");
	return 0;
	}

	llvm::Value*
	BasicCodeScopeUnit::compile(const std::string& hintBlockDecl) {
	if (!hintBlockDecl.empty()) {
	llvm::BasicBlock *block = llvm::BasicBlock::Create(llvm::getGlobalContext(), hintBlockDecl, function->raw);
	pass->man->llvm->builder.SetInsertPoint(block);
	}

	Symbol symbScope = Symbol{ScopedSymbol::RetSymbol, scope};
	return processSymbol(symbScope);
	}

	ICodeScopeUnit::~ICodeScopeUnit() {
	}

	IFunctionUnit::~IFunctionUnit() {
	}

	llvm::Function*
	IFunctionUnit::compile() {
	if (raw != nullptr) return raw;

	LLVMLayer* llvm = pass->man->llvm;
	llvm::IRBuilder<>& builder = llvm->builder;

	string&& functionName = prepareName();
	std::vector<llvm::Type*>&& types = prepareArguments();
	llvm::Type* expectedResultType = prepareResult();

	llvm::FunctionType *ft = llvm::FunctionType::get(expectedResultType, types, false);
	raw = llvm::cast<llvm::Function>(llvm->module->getOrInsertFunction(functionName, ft));
	prepareBindings();

	const std::string&blockName = "entry";
	llvm::BasicBlock* blockCurrent = builder.GetInsertBlock();

	llvm::Value* result = getScopeUnit(function->__entry)->compile(blockName);
	assert(result);

	//SECTIONTAG types/convert function ret value
	builder.CreateRet(typeinference::doAutomaticTypeConversion(result, expectedResultType, llvm->builder));

	if (blockCurrent) {
	builder.SetInsertPoint(blockCurrent);
	}

	llvm->moveToGarbage(ft);
	return raw;
	}

	ICodeScopeUnit*
	IFunctionUnit::getScopeUnit(CodeScope* scope) {
	if (__scopes.count(scope)) {
	auto result = __scopes.at(scope).lock();

	if (result) {
	return result.get();
	}
	}

	std::shared_ptr<ICodeScopeUnit> unit(pass->buildCodeScopeUnit(scope, this));

	if (scope->__parent != nullptr) {
	auto parentUnit = Decorators<CachedScopeDecoratorTag>::getInterface(getScopeUnit(scope->__parent));
	parentUnit->registerChildScope(unit);

	} else {
	__orphanedScopes.push_back(unit);
	}

	if (!__scopes.emplace(scope, unit).second) {
	__scopes[scope] = unit;
	}

	return unit.get();
	}

	ICodeScopeUnit*
	IFunctionUnit::getScopeUnit(ManagedScpPtr scope) {
	return getScopeUnit(&*scope);
	}

	ICodeScopeUnit*
	IFunctionUnit::getEntry() {
	return getScopeUnit(function->getEntryScope());
	}

	template<>
	compilation::IFunctionUnit*
	CompilePassCustomDecorators<void, void>::buildFunctionUnit(const ManagedFnPtr& function){
	return new DefaultFunctionUnit(function, this);
	}

	template<>
	compilation::ICodeScopeUnit*
	CompilePassCustomDecorators<void, void>::buildCodeScopeUnit(CodeScope* scope, IFunctionUnit* function){
	return new DefaultCodeScopeUnit(scope, function, this);
	}

	} // emf of compilation

	IFunctionUnit*
	CompilePass::getFunctionUnit(const ManagedFnPtr& function) {
	unsigned int id = function.id();

	if (!functions.count(id)) {
	IFunctionUnit* unit = buildFunctionUnit(function);
	functions.emplace(id, unit);
	return unit;
	}

	return functions.at(id);
	}

	void
	CompilePass::run() {
	managerTransformations = new TransformationsManager();
	targetInterpretation = new interpretation::TargetInterpretation(this->man->root, this);
	queryContext = reinterpret_cast<context::ContextQuery*> (man->clasp->getQuery(QueryId::ContextQuery));

	//Find out main function;
	ClaspLayer::ModelFragment model = man->clasp->query(Config::get("function-entry"));
	assert(model && "Error: No entry function found");
	assert(model->first != model->second && "Error: Ambiguous entry function");

	string nameMain = std::get<0>(ClaspLayer::parse<std::string>(model->first->second));
	IFunctionUnit* unitMain = getFunctionUnit(man->root->findFunction(nameMain));
	entry = unitMain->compile();
	}

	llvm::Function*
	CompilePass::getEntryFunction() {
	assert(entry);
	return entry;
	}

	void
	CompilePass::prepareQueries(ClaspLayer* clasp) {
	clasp->registerQuery(new containers::Query(), QueryId::ContainersQuery);
	clasp->registerQuery(new context::ContextQuery(), QueryId::ContextQuery);
	+
	+ Attachments::init<PolymorphGuard>();
	+ clasp->registerQuery(new polymorph::PolymorphQuery(), QueryId::PolymorphQuery);
	}
	} //end of namespace xreate

	/**
	* \class xreate::CompilePass
	* \brief Encapsulates all compilation activities
	*
	* xreate::CompilePass iterates over xreate::AST tree and produces executable code fed by data(via xreate::Attachments) gathered by previous passes as well as data via queries(xreate::IQuery) from xreate:ClaspLayer reasoner.
	* Compilation's done using xreate::LLVMLayer(wrapper over LLVM toolchain) and based on following aspects:
	* - Containers support. See \ref compilation/containers.h
	* - Late Conext compilation. See xreate::context::LateContextCompiler2
	* - Interpretation support. See xreate::interpretation::TargetInterpretation
	* - Loop saturation support. See xreate::compilation::TransformerSaturation
	* - External Code access. See xreate::ExternLayer(wrapper over Clang library)
	*
	* \section adaptability_sect Adaptability
	* xreate::CompilePass's architecture provides adaptability by employing:
	* - %Function Decorators to alter function-level compilation. See xreate::compilation::IFunctionUnit
	* - Code Block Decorators to alter code block level compilation. See xreate::compilation::ICodeScopeUnit
	* Default functionality defined by \ref xreate::compilation::DefaultCodeScopeUnit
	* - Targets to allow more versitile extensions.
	* Currently only xreate::interpretation::TargetInterpretation use Targets infrastructure. See xreate::compilation::Target
	* - %Altering Function invocation. xreate::compilation::ICallStatement
	*
	* Client able to construct compiler with desired decorators using xreate::compilation::CompilePassCustomDecorators.
	* As a handy alias, `CompilePassCustomDecorators<void, void>` constructs default compiler
	*
	*/
	diff --git a/cpp/src/pass/dfapass.cpp b/cpp/src/pass/dfapass.cpp
	index 2186964..030a4ad 100644
	--- a/cpp/src/pass/dfapass.cpp
	+++ b/cpp/src/pass/dfapass.cpp
	@@ -1,238 +1,204 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* dfapass.cpp
	*/

	/**
	* \file dfapass.h
	* \brief Data Flow Analysis(DFA)
	*/

	//DEBT DFA represent VersionaPass in declarative form using applyDependencies
	// applyDependencies(expression, context, cache, decl);

	//DEBT DFA prepare static annotations and represent InterpretationPass in declarative form
	// applyStaticAnnotations(expression, context, cache, decl);

	//DEBT DFA Eliminate dfa schemes

	#include "pass/dfapass.h"
	-#include "analysis/dfagraph.h"
	-
	#include "xreatemanager.h"
	#include "clasplayer.h"

	#include <boost/format.hpp>
	+#include <boost/variant/variant.hpp>

	using namespace std;
	namespace xreate { namespace dfa {

	-class DfaExpressionProcessor {
	- std::vector<SymbolNode> operands;
	- std::vector<SymbolPacked> blocks;
	-
	- const Expression expression;
	- SymbolNode result;
	- DFAPass * const pass;
	- const PassContext context;
	+DFAPass::DFAPass(PassManager* manager)
	+ : AbstractPass(manager)
	+ , graph{new DFAGraph()}
	+ , clasp(manager->clasp)
	+{}

	-public:
	- DfaExpressionProcessor(const Expression& expr, SymbolNode resInitial, DFAPass * const p, const PassContext c)
	- : expression(expr), result(resInitial), pass(p), context(c) {
	+void
	+DFAPass::processCallInstance(const Expression& expr, PassContext context, const SymbolNode& result){
	+ const string &nameCalleeFunction = expr.getValueString();

	- operands.reserve(expression.getOperands().size());
	- for (const Expression &op : expression.getOperands()) {
	- SymbolAnonymous symbOp(op.id);
	+ //TODO implement processFnCall/Uncertain
	+ list<ManagedFnPtr> variantsCalleeFunction = man->root->getFunctionSpecializations(nameCalleeFunction);

	- operands.push_back(DfaExpressionProcessor(op, symbOp, pass, context).process());
	- }
	+ vector<SymbolNode> operands;
	+ operands.reserve(expr.getOperands().size());

	- blocks.reserve(expression.blocks.size());
	- for (CodeScope* scope : expression.blocks) {
	- blocks.push_back(pass->process(scope, context));
	- }
	+ for (const Expression& arg: expr.getOperands()){
	+ operands.push_back(process(arg, context));
	}
	-
	- SymbolNode
	- process() {
	- if (expression.__state == Expression::COMPOUND) {
	- processCompoundOp();
	-
	- } else {
	- processElementaryOp();
	+ graph->markSymbolsAsUsed(operands);
	+ graph->markSymbolsAsUsed(std::vector<SymbolNode>{result});
	+
	+ //Set calling relations:
	+ for (ManagedFnPtr function: variantsCalleeFunction){
	+ CodeScope *scopeRemote = function->getEntryScope();
	+ DFACallInstance callInstance;
	+ callInstance.id = expr.id;
	+ callInstance.fnName = function->getName();
	+
	+ std::vector<SymbolNode>::const_iterator nodeActual = operands.begin();
	+ for (const std::string &identFormal: scopeRemote->__bindings){
	+ const ScopedSymbol symbolFormal{scopeRemote->__identifiers.at(identFormal), versions::VERSION_NONE};
	+ SymbolPacked symbolFormalPacked = clasp->pack(Symbol{symbolFormal, scopeRemote});
	+ callInstance.args.push_back(std::make_pair(symbolFormalPacked, *nodeActual));
	+
	+ graph->addDependency(symbolFormalPacked, *nodeActual);
	+ ++nodeActual;
	}

	- applySignatureAnnotations();
	- applyInPlaceAnnotations();
	+ callInstance.retActual = result;
	+ SymbolNode retFormal = SymbolNode(clasp->pack(Symbol{ScopedSymbol::RetSymbol, scopeRemote}));
	+ graph->addDependency(result, retFormal);

	- return result;
	+ graph->addCallInstance(std::move(callInstance));
	}

	-private:
	- void
	- processElementaryOp() {
	- switch (expression.__state) {
	- case Expression::IDENT:
	- {
	- SymbolPacked symbFrom = pass->processSymbol(Attachments::get<Symbol>(expression), context, expression.getValueString());
	-
	- SymbolPacked* symbTo = boost::get<SymbolPacked>(&result);
	- if (symbTo) {
	- pass->__context.graph->addConnection(*symbTo, SymbolNode(symbFrom), DFGConnection::STRONG);

	- } else {
	- result = SymbolNode(symbFrom);
	- }
	+}

	- break;
	- }
	+void
	+DFAPass::processDependencies(const SymbolNode& node, const Expression& expression, PassContext context, ProcessingCache& cache){
	+ cache.operands.reserve(expression.getOperands().size());
	+ for (const Expression &op: expression.getOperands()) {
	+ const SymbolNode& subnodeOperand = process(op, context);

	- default: break;
	- }
	+ cache.operands.push_back(subnodeOperand);
	+ graph->addDependency(node, subnodeOperand);
	}

	- void
	- processCompoundOp() {
	- switch (expression.op) {
	-
	- //DEBT provide CALL processing
	- // case Operator::CALL: {
	- // const string &nameCalleeFunction = expression.getValueString();
	- //
	- // //TODO implement processFnCall/Uncertain
	- // list<ManagedFnPtr> variantsCalleeFunction = man->root->getFunctionVariants(nameCalleeFunction);
	- // if (variantsCalleeFunction.size()!=1) return;
	- // ManagedFnPtr function= variantsCalleeFunction.front();
	- //
	- // // set calling relations:
	- // CodeScope *scopeRemote = function->getEntryScope();
	- // std::vector<SymbolNode>::iterator nodeActual = cache.operands.begin();
	- // for (const std::string &identFormal: scopeRemote->__bindings){
	- // const ScopedSymbol symbolFormal{scopeRemote->__identifiers.at(identFormal), versions::VERSION_NONE};
	- //
	- // __context.graph->addConnection(clasp->pack(Symbol{symbolFormal, scopeRemote}, nameCalleeFunction + ":" + identFormal), *nodeActual, DFGConnection::WEAK);
	- // ++nodeActual;
	- // }
	- //
	- // //TODO add RET connection
	- // break;
	- // }
	-
	- //MAP processing: apply PROTOTYPE relation
	- case Operator::MAP:
	- {
	- SymbolNode nodeFrom = operands.front();
	-
	- SymbolPacked* nodeTo = boost::get<SymbolPacked>(&result);
	- assert(nodeTo);
	-
	- pass->__context.graph->addConnection(*nodeTo, nodeFrom, DFGConnection::PROTOTYPE);
	- break;
	- }
	+ cache.blocks.reserve(expression.blocks.size());
	+ for (CodeScope* block : expression.blocks) {
	+ const SymbolNode& subnodeBlock = process(block, context);

	- default: break;
	- }
	+ cache.blocks.push_back(subnodeBlock);
	+ graph->addDependency(node, subnodeBlock);
	}
	+}

	- void
	- applySignatureAnnotations() {
	- if (pass->__signatures.count(expression.op)) {
	- const Expression &scheme = pass->__signatures.at(expression.op);
	+SymbolNode
	+DFAPass::process(const Expression& expression, PassContext context, const std::string& varDecl)
	+{
	+ SymbolNode result;

	+ if (Attachments::exists<SymbolAlias>(expression))
	+ {
	+ Symbol varSymbol = Attachments::get<SymbolAlias>(expression);
	+ result = clasp->pack(varSymbol, varDecl);

	+ } else if (expression.__state == Expression::IDENT && expression.tags.size() == 0) {
	+ Symbol varSymbol = Attachments::get<IdentifierSymbol>(expression);
	+ result = clasp->pack(varSymbol, expression.getValueString());

	- std::vector<SymbolNode>::iterator arg = operands.begin();
	- std::vector<Expression>::const_iterator tag = scheme.getOperands().begin();
	+ } else {
	+ result = SymbolAnonymous{expression.id};
	+ }

	- //Assign scheme RET annotation
	- Expression retTag = *scheme.getOperands().begin();
	- if (retTag.__state != Expression::INVALID) {
	- pass->__context.graph->addAnnotation(result, move(retTag));
	- }
	+ graph->printInplaceAnnotations(result, expression);

	- ++tag;
	- while (tag != scheme.getOperands().end()) {
	- if (tag->__state != Expression::INVALID) {
	- pass->__context.graph->addAnnotation(arg, Expression(tag));
	- }
	+ switch(expression.__state){
	+ case Expression::COMPOUND: {
	+ switch (expression.op) {
	+ case Operator::CALL:
	+ processCallInstance(expression, context, result);
	+ break;

	- ++arg;
	- ++tag;
	+ default:
	+ ProcessingCache cache;
	+ processDependencies(result, expression, context, cache);
	+ break;
	}
	+ break;
	+ }
	+
	+ case Expression::IDENT: {
	+ SymbolNode symbIdent = AbstractPass<SymbolNode>::process(expression, context, varDecl);

	- // TODO add possibility to have specific signature for a particular function
	- // if (expression.op == Operator::CALL \|\| expression.op == Operator::INDEX){
	- // string caption = expression.getValueString();
	- // operands.push_back(process(Expression(move(caption)), context, ""));
	- // }
	+ if (!(result == symbIdent)) {
	+ graph->addDependency(result, symbIdent);
	+ graph->printAlias(result, symbIdent);
	+ }

	+ break;
	+ }

	+ case Expression::NUMBER:
	+ case Expression::STRING: {
	+ break;
	}
	- }

	- void
	- applyInPlaceAnnotations() {
	- // write down in-place expression tags:
	- for (pair<std::string, Expression> tag : expression.tags) {
	- pass->__context.graph->addAnnotation(result, Expression(tag.second));
	+ case Expression::INVALID:
	+ case Expression::BINDING: {
	+ assert(false);
	+ break;
	}
	}
	-};

	+ return result;
	+}

	-DFAPass::DFAPass(PassManager* manager)
	- : AbstractPass(manager)
	- , __context{new DFAGraph(manager->clasp)}
	- , clasp(manager->clasp)
	-{}
	+SymbolNode
	+DFAPass::process(CodeScope* scope, PassContext context, const std::string& hintBlockDecl){
	+ for(const std::string& binding: scope->__bindings){
	+ Symbol bindingSymbol{scope->getSymbol(binding), scope};
	+ SymbolPacked bindingPacked = clasp->pack(bindingSymbol, binding);
	+
	+ getSymbolCache().setCachedValue(bindingSymbol, SymbolNode(bindingPacked));
	+ }

	-SymbolPacked
	-DFAPass::process(CodeScope* scope, PassContext context, const std::string& hintBlockDecl) {
	- const SymbolPacked& symbRet = AbstractPass::process(scope, context, hintBlockDecl);
	- return symbRet;
	+ return AbstractPass<SymbolNode>::process(scope, context, hintBlockDecl);
	}

	-SymbolPacked
	-DFAPass::processSymbol(const Symbol& symbol, PassContext context, const std::string& hintSymbol) {
	- const Expression& declaration = CodeScope::getDefinition(symbol);
	- const SymbolPacked& symbPacked = clasp->pack(symbol, hintSymbol);
	- DfaExpressionProcessor(declaration, symbPacked, this, context).process();
	+SymbolNode
	+DFAPass::process(ManagedFnPtr function){
	+ SymbolNode result = AbstractPass<SymbolNode>::process(function);

	- return symbPacked;
	+ graph->printFunctionRet(function, result);
	+ return result;
	}

	void
	-DFAPass::run() {
	- init();
	- return AbstractPass::run();
	-}
	+DFAPass::finish(){
	+ clasp->registerReport(graph);

	-void
	-DFAPass::init() {
	- for (const Expression& scheme : man->root->__dfadata) {
	- __signatures.emplace(scheme.op, scheme);
	- }
	-}
	+ //Declare symbols:
	+ graph->printSymbols(clasp);

	-void
	-DFAPass::finish() {
	- clasp->setDFAData(move(__context.graph));
	+ AbstractPass::finish();
	}

	} //end of namespace dfa

	template<>
	-SymbolPacked defaultValue(){
	+dfa::SymbolNode defaultValue(){
	assert(false);
	}

	} //xreate namespace

	/**
	* \class xreate::dfa::DFAPass
	* \details Provides DFA, important analysis for reasoning. Iterates over AST and stores collected data in DFAGraph
	*/
	diff --git a/cpp/src/pass/dfapass.h b/cpp/src/pass/dfapass.h
	index 2d4bd14..51b3eb1 100644
	--- a/cpp/src/pass/dfapass.h
	+++ b/cpp/src/pass/dfapass.h
	@@ -1,50 +1,51 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* dfapass.h
	* Data Flow Graph building pass
	*/

	#ifndef DFGPASS_H
	#define DFGPASS_H

	#include "abstractpass.h"
	#include "analysis/dfagraph.h"

	namespace xreate {
	class ClaspLayer;
	}

	namespace xreate { namespace dfa {
	-class DfaExpressionProcessor;
	-
	-/** \brief Data Flow Analysis Pass(%DFA) */
	-class DFAPass: public AbstractPass<SymbolPacked> {
	- friend class DfaExpressionProcessor;

	+struct ProcessingCache {
	+ std::vector<SymbolNode> operands;
	+ std::vector<SymbolNode> blocks;
	+};
	+
	+/** \brief Data Flow Analysis Pass(%DFA) */
	+class DFAPass: public AbstractPass<SymbolNode> {
	public:
	DFAPass(PassManager* manager);

	- SymbolPacked processSymbol(const Symbol& symbol, PassContext context, const std::string& hintSymbol="") override;
	- SymbolPacked process(CodeScope* scope, PassContext context, const std::string& hintBlockDecl="") override;
	+protected:
	+ virtual SymbolNode process(const Expression& expression, PassContext context, const std::string& varDecl="") override;
	+ virtual SymbolNode process(CodeScope* scope, PassContext context, const std::string& hintBlockDecl="") override;
	+ virtual SymbolNode process(ManagedFnPtr function) override;

	void init();
	- void run() override;
	void finish() override;

	private:
	- struct
	- {
	- DFAGraph* graph;
	- } __context;
	+ void processCallInstance(const Expression& expr, PassContext context, const SymbolNode& result);
	+ void processDependencies(const SymbolNode& node, const Expression& expression, PassContext context, ProcessingCache& cache);

	- std::map<Operator, Expression> __signatures; //DFA data for particular operators
	+ DFAGraph* graph;
	ClaspLayer* clasp;
	};

	}} //end of xreate::dfa namespace

	#endif
	diff --git a/cpp/src/pass/interpretationpass.cpp b/cpp/src/pass/interpretationpass.cpp
	index 61ec926..89bf2fc 100644
	--- a/cpp/src/pass/interpretationpass.cpp
	+++ b/cpp/src/pass/interpretationpass.cpp
	@@ -1,522 +1,522 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* File: interpretationpass.cpp
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on July 5, 2016, 5:21 PM
	*/

	/**
	* \file interpretationpass.h
	* \brief Interpretation analysis: determines what parts of code could be interpreted
	*/

	#include "pass/interpretationpass.h"
	#include <compilation/targetinterpretation.h>
	#include <bits/stl_vector.h>
	#include "ast.h"
	//DEBT implement InterpretationPass purely in clasp
	//DEBT represent InterpretationPass as general type inference

	using namespace std;

	namespace xreate {

	template<>
	interpretation::InterpretationResolution
	defaultValue<interpretation::InterpretationResolution>() {
	return interpretation::CMPL_ONLY;
	}

	namespace interpretation {

	enum InterpretationQuery {
	QUERY_INTR_ONLY, QUERY_CMPL_ONLY
	};

	namespace details {

	template<InterpretationQuery FLAG_REQUIRED>
	bool
	checkConstraints(InterpretationResolution flag) {
	return( (flag==INTR_ONLY&&FLAG_REQUIRED==QUERY_INTR_ONLY)
	\|\|(flag==CMPL_ONLY&&FLAG_REQUIRED==QUERY_CMPL_ONLY));
	}

	InterpretationResolution
	recognizeTags(const map<std::string, Expression>& tags) {
	auto i=tags.find("interpretation");
	if(i==tags.end()){
	return ANY;
	}

	assert(i->second.op==Operator::CALL);
	const string& cmd=i->second.operands.at(0).getValueString();

	//TODO make consistent names of annotation and resolution
	if(cmd=="force"){
	return INTR_ONLY;

	} else if(cmd=="suppress"){
	return CMPL_ONLY;
	}

	return ANY;
	}
	}

	InterpretationResolution
	unify(InterpretationResolution flag) {
	return flag;
	}

	template<typename FLAG_A, typename FLAG_B, typename... FLAGS>
	InterpretationResolution
	unify(FLAG_A flagA, FLAG_B flagB, FLAGS... flags) {

	if(flagA==ANY){
	return unify(flagB, flags...);
	}

	if(flagB==ANY){
	return unify(flagA, flags...);
	}

	assert(flagA==flagB);
	return flagA;
	}

	template<InterpretationQuery FLAG_REQUIRED>
	bool
	checkConstraints(std::vector<InterpretationResolution>&& flags) {
	assert(flags.size());

	InterpretationResolution flag=flags.front();
	return details::checkConstraints<FLAG_REQUIRED>(flag);
	}

	template<InterpretationQuery FLAG_REQUIRED_A, InterpretationQuery FLAG_REQUIRED_B, InterpretationQuery... FLAGS>
	bool
	checkConstraints(std::vector<InterpretationResolution>&& flags) {
	assert(flags.size());

	InterpretationResolution flag=flags.front();
	flags.pop_back();

	if(details::checkConstraints<FLAG_REQUIRED_A>(flag)){
	return checkConstraints<FLAG_REQUIRED_B, FLAGS...>(move(flags));
	}

	return false;
	}

	bool
	InterpretationData::isDefault() const {
	return(resolution==ANY&&op==NONE);
	}

	void
	recognizeTags(const Expression& e) {
	InterpretationData tag{details::recognizeTags(e.tags), NONE};
	if(!tag.isDefault())
	Attachments::put<InterpretationData>(e, tag);
	}

	InterpretationResolution
	recognizeTags(const ManagedFnPtr& f) {
	return details::recognizeTags(f->getTags());
	}

	InterpretationPass::InterpretationPass(PassManager* manager)
	: AbstractPass(manager) {

	Attachments::init<FunctionInterpretationData>();
	Attachments::init<InterpretationData>();
	}

	void
	InterpretationPass::run() {
	ManagedFnPtr f=man->root->begin<Function>();
	auto& visitedSymbols=getSymbolCache();

	while(f.isValid()) {
	const Symbol&symbolFunction{ScopedSymbol::RetSymbol, f->getEntryScope()};

	if(!visitedSymbols.isCached(symbolFunction)){
	visitedSymbols.setCachedValue(symbolFunction, process(f));
	}

	++f;
	}
	}

	InterpretationResolution
	InterpretationPass::process(const Expression& expression, PassContext context, const std::string& decl) {
	recognizeTags(expression);

	InterpretationResolution resolution=ANY;
	InterpretationOperator op=NONE;

	switch(expression.__state) {

	case Expression::NUMBER:
	case Expression::STRING:
	{
	break;
	}

	case Expression::IDENT:
	{
	- resolution=Parent::processSymbol(Attachments::get<Symbol>(expression), context);
	+ resolution=Parent::processSymbol(Attachments::get<IdentifierSymbol>(expression), context);
	break;
	}

	case Expression::COMPOUND:
	break;

	default:
	{
	resolution=CMPL_ONLY;
	break;
	}
	}

	if(expression.__state==Expression::COMPOUND)
	switch(expression.op) {
	case Operator::EQU:
	case Operator::NE:
	{
	InterpretationResolution left=process(expression.operands[0], context);
	InterpretationResolution right=process(expression.operands[1], context);

	resolution=unify(left, right);
	break;
	}

	case Operator::LOGIC_AND:
	{
	assert(expression.operands.size()==1);
	resolution=process(expression.operands[0], context);
	break;
	}

	case Operator::CALL:
	{
	//TODO cope with static/dynamic context
	//TODO BUG here: if several variants they all are processed as CMPL careless of signature
	list<ManagedFnPtr> callees=man->root->getFunctionSpecializations(expression.getValueString());
	if(callees.size()!=1){
	resolution=CMPL_ONLY;
	break;
	}

	ManagedFnPtr callee=callees.front();
	const Symbol&symbCalleeFunc{ScopedSymbol::RetSymbol, callee->getEntryScope()};

	//recursion-aware processing:
	// - skip self recursion
	const Symbol&symbSelfFunc{ScopedSymbol::RetSymbol, context.function->getEntryScope()};
	if(!(symbSelfFunc==symbCalleeFunc)){
	InterpretationResolution resCallee=processFnCall(callee, context);
	assert(resCallee!=FUNC_POSTPONED&&"Indirect recursion detected: can't decide on interpretation resolution");

	resolution=unify(resolution, resCallee);
	}

	//check arguments compatibility
	const FunctionInterpretationData& calleeSignature=FunctionInterpretationHelper::getSignature(callee);
	for(size_t op=0, size=expression.operands.size(); op<size; ++op) {
	const Expression &operand=expression.operands[op];
	InterpretationResolution argActual=process(operand, context);
	InterpretationResolution argExpected=calleeSignature.signature[op];

	//TODO use args unification result to properly process function call
	unify(argActual, argExpected);
	}

	if(FunctionInterpretationHelper::needPartialInterpretation(callee)){
	op=CALL_INTERPRET_PARTIAL;
	}

	break;
	}

	case Operator::CALL_INTRINSIC:
	{
	std::string nameFunction=expression.getValueString();

	if(nameFunction=="query"){
	resolution=INTR_ONLY;

	} else {
	resolution=CMPL_ONLY;
	}
	break;
	}

	case Operator::IF:
	{
	InterpretationResolution flagCondition=process(expression.getOperands()[0], context);
	InterpretationResolution flagScope1=Parent::process(expression.blocks.front(), context);
	InterpretationResolution flagScope2=Parent::process(expression.blocks.back(), context);

	//special case: IF_INTERPRET_CONDITION
	if(checkConstraints<QUERY_INTR_ONLY>({flagCondition})){
	op=IF_INTERPRET_CONDITION;
	flagCondition=ANY;
	}

	resolution=unify(flagCondition, flagScope1, flagScope2);
	break;
	}

	case Operator::FOLD:
	{
	InterpretationResolution flagInput=process(expression.getOperands()[0], context);
	InterpretationResolution flagAccumInit=process(expression.getOperands()[1], context);

	CodeScope* scopeBody=expression.blocks.front();
	const std::string& nameEl=expression.bindings[0];
	Symbol symbEl{ScopedSymbol
	{scopeBody->__identifiers.at(nameEl), versions::VERSION_NONE}, scopeBody};
	getSymbolCache().setCachedValue(symbEl, InterpretationResolution(flagInput));

	const std::string& nameAccum=expression.bindings[1];
	Symbol symbAccum{ScopedSymbol
	{scopeBody->__identifiers.at(nameAccum), versions::VERSION_NONE}, scopeBody};
	getSymbolCache().setCachedValue(symbAccum, InterpretationResolution(flagAccumInit));

	InterpretationResolution flagBody=Parent::process(expression.blocks.front(), context);

	//special case: FOLD_INTERPRET_INPUT
	if(checkConstraints<QUERY_INTR_ONLY>({flagInput})){
	op=FOLD_INTERPRET_INPUT;
	flagInput=ANY;
	}

	resolution=unify(flagInput, flagAccumInit, flagBody);
	break;
	}

	case Operator::INDEX:
	{
	for(const Expression &op : expression.getOperands()) {
	resolution=unify(resolution, process(op, context));
	}

	break;
	}

	case Operator::SWITCH:
	{
	InterpretationResolution flagCondition=process(expression.operands[0], context);
	bool hasDefaultCase=expression.operands[1].op==Operator::CASE_DEFAULT;


	//determine conditions resolution
	InterpretationResolution flagHeaders=flagCondition;
	for(size_t size=expression.operands.size(), i=hasDefaultCase?2:1; i<size; ++i) {
	const Expression& exprCase=expression.operands[i];

	flagHeaders=unify(flagHeaders, Parent::process(exprCase.blocks.front(), context));
	}

	if(checkConstraints<QUERY_INTR_ONLY>({flagHeaders})){
	op=SWITCH_INTERPRET_CONDITION;
	flagHeaders=ANY;
	}

	//determine body resolutions
	resolution=flagHeaders;
	for(size_t size=expression.operands.size(), i=1; i<size; ++i) {
	const Expression& exprCase=expression.operands[i];

	resolution=unify(resolution, Parent::process(exprCase.blocks.back(), context));
	}

	break;
	}

	case Operator::SWITCH_VARIANT:
	{
	InterpretationResolution resolutionCondition=process(expression.operands.at(0), context);
	resolution=resolutionCondition;

	if(checkConstraints<QUERY_INTR_ONLY>({resolution})){
	op=SWITCH_VARIANT;
	resolution=ANY;
	}

	const string identCondition=expression.bindings.front();
	for(auto scope : expression.blocks) {
	//set binding resolution
	ScopedSymbol symbolInternal=scope->getSymbol(identCondition);
	getSymbolCache().setCachedValue(Symbol{symbolInternal, scope}, InterpretationResolution(resolutionCondition));

	resolution=unify(resolution, Parent::process(scope, context));
	}

	for(auto scope : expression.blocks) {
	resolution=unify(resolution, Parent::process(scope, context));
	}
	break;
	}

	case Operator::LIST:
	case Operator::LIST_NAMED:
	{
	for(const Expression &op : expression.getOperands()) {
	resolution=unify(resolution, process(op, context));
	}

	break;
	}

	case Operator::VARIANT:
	{
	if(expression.getOperands().size()){
	resolution=process(expression.getOperands().front(), context);
	} else {
	resolution=ANY;
	}

	break;
	}

	default:
	{
	resolution=CMPL_ONLY;

	for(const Expression &op : expression.getOperands()) {
	process(op, context);
	}

	for(CodeScope* scope : expression.blocks) {
	Parent::process(scope, context);
	}

	break;
	}
	}

	InterpretationResolution resolutionExpected=
	Attachments::get<InterpretationData>(expression,{ANY, NONE}).resolution;

	resolution=unify(resolution, resolutionExpected);
	if(resolution!=resolutionExpected&&(op!=NONE\|\|resolution==INTR_ONLY)){
	Attachments::put<InterpretationData>(expression,{resolution, op});
	}

	return resolution;
	}

	InterpretationResolution
	InterpretationPass::processFnCall(ManagedFnPtr function, PassContext context) {
	return process(function);
	}

	InterpretationResolution
	InterpretationPass::process(ManagedFnPtr function) {
	CodeScope* entry=function->getEntryScope();
	std::vector<std::string> arguments=entry->__bindings;
	const Symbol&symbSelfFunc{ScopedSymbol::RetSymbol, function->getEntryScope()};
	auto& cache=getSymbolCache();

	if(cache.isCached(symbSelfFunc))
	return cache.getCachedValue(symbSelfFunc);

	const FunctionInterpretationData& fnSignature=FunctionInterpretationHelper::getSignature(function);
	InterpretationResolution fnResolutionExpected=details::recognizeTags(function->getTags());

	//mark preliminary function resolution as expected
	if(fnResolutionExpected!=ANY){
	cache.setCachedValue(symbSelfFunc, move(fnResolutionExpected));

	} else {
	// - in order to recognize indirect recursion mark this function resolution as POSTPONED
	cache.setCachedValue(symbSelfFunc, FUNC_POSTPONED);
	}

	//set resolution for function arguments as expected
	for(int argNo=0, size=arguments.size(); argNo<size; ++argNo) {
	Symbol symbArg{ScopedSymbol
	{entry->__identifiers.at(arguments[argNo]), versions::VERSION_NONE}, entry};
	cache.setCachedValue(symbArg, InterpretationResolution(fnSignature.signature[argNo]));
	}

	PassContext context;
	context.function=function;
	context.scope=entry;
	InterpretationResolution resActual=process(CodeScope::getDefinition(symbSelfFunc), context);
	resActual=unify(resActual, fnResolutionExpected);
	return cache.setCachedValue(symbSelfFunc, move(resActual));
	}

	const FunctionInterpretationData
	FunctionInterpretationHelper::getSignature(ManagedFnPtr function) {
	if(Attachments::exists<FunctionInterpretationData>(function)){
	return Attachments::get<FunctionInterpretationData>(function);
	}

	FunctionInterpretationData&& data=recognizeSignature(function);
	Attachments::put<FunctionInterpretationData>(function, data);
	return data;
	}

	FunctionInterpretationData
	FunctionInterpretationHelper::recognizeSignature(ManagedFnPtr function) {
	CodeScope* entry=function->__entry;
	FunctionInterpretationData result;
	result.signature.reserve(entry->__bindings.size());

	bool flagPartialInterpretation=false;
	for(size_t no=0, size=entry->__bindings.size(); no<size; ++no) {
	const std::string& argName=entry->__bindings[no];
	Symbol symbArg{ScopedSymbol
	{entry->__identifiers.at(argName), versions::VERSION_NONE}, entry};

	const Expression& arg=CodeScope::getDefinition(symbArg);

	InterpretationResolution argResolution=details::recognizeTags(arg.tags);
	flagPartialInterpretation\|=(argResolution==INTR_ONLY);

	result.signature.push_back(argResolution);
	}
	result.flagPartialInterpretation=flagPartialInterpretation;
	return result;
	}

	bool
	FunctionInterpretationHelper::needPartialInterpretation(ManagedFnPtr function) {
	const FunctionInterpretationData& data=getSignature(function);
	return data.flagPartialInterpretation;
	}
	}
	} //end of namespace xreate::interpretation


	/** \class xreate::interpretation::InterpretationPass
	*
	* Encapsulates Interpretation Analysis to support [Interpretation Concept](/w/concepts/dfa)
	*
	* Recognizes program functions, expressions, instructions eligible for interpretation
	* and stores output in Attachments<FunctionInterpretationData> and Attachments<InterpretationData>
	*
	* There are number of instructions currently able to be interpreted:
	* - Basic literals: numbers and strings
	* - Compounds: lists, structs, variants
	* - Non-versioned identifiers
	* - Comparison and logic operators
	* - %Function calls
	* - `query` intrinsic function calls
	* - Branching: `if`, `loop fold`, `switch`, `switch variant` statements
	*
	* Some of those instructions are eligibile for hybrid interpretation to allow coupling
	* of compiled instructions with interpreted ones, those are:
	* - Partial function calls
	* - Branching: `if`, `loop fold`, `switch`, `switch variant` statements
	*
	* \sa xreate::interpretation::TargetInterpretation, [Interpretation Concept](/w/concepts/dfa)
	*/
	\ No newline at end of file
	diff --git a/cpp/src/pass/versionspass.cpp b/cpp/src/pass/versionspass.cpp
	index 7b2acf4..7071147 100644
	--- a/cpp/src/pass/versionspass.cpp
	+++ b/cpp/src/pass/versionspass.cpp
	@@ -1,375 +1,375 @@
	/* This Source Code Form is subject to the terms of the Mozilla Public
	* License, v. 2.0. If a copy of the MPL was not distributed with this
	* file, You can obtain one at http://mozilla.org/MPL/2.0/.
	*
	* versionspass.cpp
	*
	* Author: pgess <v.melnychenko@xreate.org>
	* Created on January 4, 2017, 3:13 PM
	*/

	/** \class xreate::versions::VersionsPass
	* Has two parts:
	* - Validates correctness of versioned variables with regard to variables lifespan
	* - Determines versioned variables computation order
	* \sa VersionsScopeDecorator, VersionsGraph, [Versions Concept](/w/concepts/versions)
	*/

	#include <boost/optional/optional.hpp>
	#include "pass/versionspass.h"

	namespace std{
	std::size_t
	hash<xreate::versions::SymbolOrPlaceholder>::operator()(xreate::versions::SymbolOrPlaceholder const& s) const
	{return std::hash<xreate::Symbol>()(s.symbol) + (s.flagEndOfLifePlaceholder? 9849 : 1);}

	bool
	equal_to<xreate::versions::SymbolOrPlaceholder>::operator()(const xreate::versions::SymbolOrPlaceholder& __x, const xreate::versions::SymbolOrPlaceholder& __y) const
	{ return __x.flagEndOfLifePlaceholder == __y.flagEndOfLifePlaceholder && __x.symbol == __y.symbol; }
	}

	using namespace std;

	namespace xreate{ namespace versions{

	template<>
	std::list<Symbol>
	defaultValue<std::list<Symbol>>(){
	return std::list<Symbol>();
	};

	inline std::string
	printSymbol(const SymbolOrPlaceholder& s){
	switch(s.flagEndOfLifePlaceholder){
	case SYMBOL: return string("(") + std::to_string(s.symbol.identifier.id) + ", "+ std::to_string(s.symbol.identifier.version) + ")";
	case PLACEHOLDER: return string("(") + std::to_string(s.symbol.identifier.id) + ", "+ std::to_string(s.symbol.identifier.version) + ")+";
	}

	return "";
	}

	void
	VersionsGraph::__debug_print(std::ostream& output) const{
	for(auto entry: __inferiors){
	output << printSymbol(entry.second) << " <-" << printSymbol(entry.first) << "\n";
	}
	}

	void
	VersionsGraph::defineEndOfLife(const Symbol& symbol, const Symbol& symbolSuccessor){
	if(__dictSuccessors.count(symbol)){
	assert("No version branches allowed yet" && false);
	}

	const SymbolOrPlaceholder& placeholder = getEndOfLife(symbol);

	auto inferiorsDeferred = __inferiors.equal_range(placeholder);
	std::unordered_multimap<SymbolOrPlaceholder, SymbolOrPlaceholder> inferiorsReassigned;

	for (const auto& inf: boost::make_iterator_range(inferiorsDeferred)){
	inferiorsReassigned.emplace(SymbolOrPlaceholder{SYMBOL, symbolSuccessor}, inf.second);
	}

	__inferiors.erase(placeholder);
	__inferiors.insert(inferiorsReassigned.begin(), inferiorsReassigned.end());
	__inferiors.emplace(SymbolOrPlaceholder{SYMBOL, symbolSuccessor}, SymbolOrPlaceholder{SYMBOL, symbol});

	__dictSuccessors.emplace(symbol, symbolSuccessor);
	}

	SymbolOrPlaceholder
	VersionsGraph::getEndOfLife(const Symbol& s){
	if (__dictSuccessors.count(s)){
	return SymbolOrPlaceholder{SYMBOL, __dictSuccessors.at(s)}; }


	return SymbolOrPlaceholder{PLACEHOLDER, s};
	}

	void
	VersionsGraph::applyNatualDependencies(const Symbol& symbol, const std::list<Symbol>& dependencies){
	for (const Symbol& right: dependencies){
	__inferiorsNatural.emplace(symbol, right);
	}
	}

	void
	VersionsGraph::applyDependentEndOfLife(const SymbolOrPlaceholder& symbol, const list<Symbol>& dependencies){
	for (const Symbol& right: dependencies){
	auto rightEOF = getEndOfLife(right);

	__inferiors.emplace(rightEOF, symbol);
	}
	}

	bool
	VersionsGraph::tryEliminateEofAliases(const std::list<SymbolOrPlaceholder>& aliases){

	if (aliases.size()==1){
	return true;
	}

	boost::optional<Symbol> symbolActualEoF;
	for(const SymbolOrPlaceholder alias: aliases){
	switch(alias.flagEndOfLifePlaceholder){
	case SYMBOL:
	if(symbolActualEoF){
	return false;
	}

	symbolActualEoF = alias.symbol;
	break;

	case PLACEHOLDER:
	continue;
	}
	}

	if(!symbolActualEoF){
	return false;
	}

	for(const SymbolOrPlaceholder alias: aliases){
	switch(alias.flagEndOfLifePlaceholder){
	case SYMBOL:
	continue;

	case PLACEHOLDER:
	defineEndOfLife(alias.symbol, symbolActualEoF.get());
	break;
	}
	}

	return true;
	}

	std::list<SymbolOrPlaceholder>
	VersionsGraph::extractCycle(const Path& path, const SymbolOrPlaceholder& symbolBeginning){
	unsigned int posBeginning = path.at(symbolBeginning);

	std::list<SymbolOrPlaceholder> result;

	auto i=path.begin();
	while(true){
	i = std::find_if(i, path.end(), [&posBeginning](const auto& el){return el.second >=posBeginning;});

	if (i!= path.end()){
	result.push_back(i->first);
	++i;

	} else {break; }
	}

	return result;
	}

	bool
	VersionsGraph::validateCycles(const SymbolOrPlaceholder& s,
	std::unordered_multimap<SymbolOrPlaceholder, SymbolOrPlaceholder>& graph,
	std::unordered_set<SymbolOrPlaceholder>& symbolsVisited,
	Path& path)
	{
	if (symbolsVisited.count(s)) return true;

	symbolsVisited.insert(s);
	path.emplace(s, path.size());

	if (graph.count(s)){
	//iterate over imposed dependencies
	auto candidates = graph.equal_range(s);
	for (auto candidate = candidates.first; candidate != candidates.second; ++candidate){
	if (path.count(candidate->second)) {
	std::list<SymbolOrPlaceholder> cycle = extractCycle(path, candidate->second);
	if (!tryEliminateEofAliases(cycle)) return false;
	continue;
	}

	if(!validateCycles(candidate->second, graph, symbolsVisited, path)) return false;
	}
	}

	//iterate over natural dependencies
	if (s.flagEndOfLifePlaceholder == SYMBOL) {
	auto candidates = __inferiorsNatural.equal_range(s.symbol);
	for (auto candidate = candidates.first; candidate != candidates.second; ++candidate){
	if (path.count(SymbolOrPlaceholder{SYMBOL, candidate->second})){
	return false;
	}

	if(!validateCycles(SymbolOrPlaceholder{SYMBOL,candidate->second}, graph, symbolsVisited, path)) return false;
	}
	}

	//check previous version
	if (s.flagEndOfLifePlaceholder == PLACEHOLDER){
	const Symbol& candidate = s.symbol;

	if (path.count(SymbolOrPlaceholder{SYMBOL, candidate})){
	std::list<SymbolOrPlaceholder> cycle = extractCycle(path, SymbolOrPlaceholder{SYMBOL, candidate});
	if (!tryEliminateEofAliases(cycle)) return false;
	}

	if(!validateCycles(SymbolOrPlaceholder{SYMBOL,candidate}, graph, symbolsVisited, path)) return false;
	}

	path.erase(s);
	return true;
	}

	bool
	VersionsGraph::validateCycles(){
	std::unordered_set<SymbolOrPlaceholder> symbolsVisited;
	Path path;
	std::unordered_multimap<SymbolOrPlaceholder, SymbolOrPlaceholder> graph(__inferiors);

	std::unordered_multimap<SymbolOrPlaceholder, SymbolOrPlaceholder>::const_iterator s;
	for (s = graph.begin(); s != graph.end(); ++s){
	if(!validateCycles(s->first, graph, symbolsVisited, path)) return false;
	}

	return true;
	}

	bool
	VersionsGraph::validate(){
	return validateCycles();
	}

	std::list<Symbol>
	VersionsGraph::expandPlaceholder(const SymbolOrPlaceholder& symbol, const Symbol& symbolPrev) const{
	std::list<Symbol> result;

	switch (symbol.flagEndOfLifePlaceholder){
	case SYMBOL:
	//skip self-loops
	if (symbol.symbol == symbolPrev) return {};

	return {symbol.symbol};

	case PLACEHOLDER:
	for (const auto& entry: boost::make_iterator_range(__inferiors.equal_range(symbol))){
	list<Symbol>&& childResult = expandPlaceholder(entry.second, symbolPrev);
	result.insert(result.end(), childResult.begin(), childResult.end());
	}

	if (__dictSuccessors.count(symbol.symbol)){
	Symbol knownSuccessor = __dictSuccessors.at(symbol.symbol);

	//skip alias loop
	if (knownSuccessor == symbolPrev) return {};

	for (const auto& entry: boost::make_iterator_range(__inferiors.equal_range(SymbolOrPlaceholder{SYMBOL, knownSuccessor}))){
	list<Symbol>&& childResult = expandPlaceholder(entry.second, knownSuccessor);
	result.insert(result.end(), childResult.begin(), childResult.end());
	}
	}

	break;
	}

	return result;
	}

	AttachmentsContainerDefault<std::list<Symbol>>*
	VersionsGraph::representAsAttachments() const {
	AttachmentsContainerDefault<std::list<Symbol>>* container = new AttachmentsContainerDefault<std::list<Symbol>>();

	std::map<Symbol, std::list<Symbol>> containerData;

	for(const auto& entry: __inferiors){
	if(entry.first.flagEndOfLifePlaceholder == PLACEHOLDER) continue;

	list<Symbol>& infs = containerData[entry.first.symbol];
	list<Symbol>&& infsExpanded = expandPlaceholder(entry.second, entry.first.symbol);
	infs.insert(infs.begin(), infsExpanded.begin(), infsExpanded.end());
	}

	for(const auto& entry: containerData){
	container->put(entry.first, entry.second);
	}

	return container;
	}

	std::list<Symbol>
	VersionsPass::process(const Expression& expression, PassContext context, const std::string& hintSymbol){
	if (expression.__state == Expression::COMPOUND){
	std::list<Symbol> resultDependencies;

	for (const Expression &op: expression.getOperands()) {
	std::list<Symbol> deps = process(op, context);

	resultDependencies.insert(resultDependencies.end(), deps.begin(), deps.end());
	}

	for (CodeScope* scope: expression.blocks) {
	std::list<Symbol> deps = Parent::process(scope, context);

	resultDependencies.insert(resultDependencies.end(), deps.begin(), deps.end());
	}

	return resultDependencies;
	}

	if (expression.__state == Expression::IDENT){
	- const Symbol symb = Attachments::get<Symbol>(expression);
	+ const Symbol symb = Attachments::get<IdentifierSymbol>(expression);

	return processSymbol(symb, context, expression.getValueString());
	}

	return {};
	}

	//TODO versions, check (declaration.isDefined()) before processing declaration
	list<Symbol>
	VersionsPass::processSymbol(const Symbol& symbol, PassContext context, const std::string& hintSymbol){
	list<Symbol> result{symbol};

	if (__symbolsVisited.exists(symbol)){
	return result;
	}
	enum {MODE_ALIAS, MODE_COPY } mode = MODE_ALIAS;

	const Expression& declaration = CodeScope::getDefinition(symbol);

	if (declaration.op == Operator::CALL_INTRINSIC){
	if (declaration.getValueString() == "copy"){
	mode = MODE_COPY;
	}
	}

	if (symbol.identifier.version != VERSION_NONE){
	mode = MODE_COPY;

	if (symbol.identifier.version > 0){
	Symbol versionPrev = Symbol{ScopedSymbol{symbol.identifier.id, symbol.identifier.version-1}, symbol.scope};
	__graph.defineEndOfLife(versionPrev, symbol);
	}
	}

	PassContext context2 = context.updateScope(symbol.scope);
	std::list<Symbol> dependencies = process(declaration, context2, hintSymbol);

	switch (mode) {
	case MODE_COPY: __graph.applyDependentEndOfLife(SymbolOrPlaceholder{SYMBOL, symbol}, dependencies); break;
	case MODE_ALIAS: __graph.applyDependentEndOfLife(__graph.getEndOfLife(symbol), dependencies); break;
	}

	__graph.applyNatualDependencies(symbol, dependencies);
	__symbolsVisited.put(symbol, true);
	return list<Symbol>{symbol};
	}

	VersionsGraph&
	VersionsPass::getResultGraph(){
	return __graph;
	}

	void
	VersionsPass::finish(){
	assert(__graph.validate() && "Can't validate versions graph");

	Attachments::init<VersionImposedDependency>(__graph.representAsAttachments());
	}

	}} //end of namespace xreate::versions
	diff --git a/cpp/src/query/polymorph.cpp b/cpp/src/query/polymorph.cpp
	new file mode 100644
	index 0000000..fa4038b
	--- /dev/null
	+++ b/cpp/src/query/polymorph.cpp
	@@ -0,0 +1,34 @@
	+/*
	+ * This Source Code Form is subject to the terms of the Mozilla Public
	+ * License, v. 2.0. If a copy of the MPL was not distributed with this
	+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
	+ *
	+ * File: polymorph.cpp
	+ * Author: pgess <v.melnychenko@xreate.org>
	+ *
	+ * Created on November 9, 2017, 12:14 PM
	+ */
	+
	+#include "polymorph.h"
	+
	+using namespace std;
	+namespace xreate { namespace polymorph {
	+
	+void
	+PolymorphQuery::init(ClaspLayer* clasp){
	+ const std::string& atomGuard = "dfa_callguard";
	+
	+ ClaspLayer::ModelFragment query = clasp->query(atomGuard);
	+ if (query){
	+ for (auto entry = query->first; entry!=query->second; ++entry){
	+ unsigned int callId;
	+ Expression exprGuard;
	+
	+ tie(callId, exprGuard)=ClaspLayer::parse<int, Expression>(entry->second);
	+
	+ Attachments::put<PolymorphGuard>(callId, exprGuard);
	+ }
	+ }
	+}
	+
	+}} //end of xreate::polymorph
	diff --git a/cpp/src/query/polymorph.h b/cpp/src/query/polymorph.h
	new file mode 100644
	index 0000000..de67d35
	--- /dev/null
	+++ b/cpp/src/query/polymorph.h
	@@ -0,0 +1,37 @@
	+/*
	+ * This Source Code Form is subject to the terms of the Mozilla Public
	+ * License, v. 2.0. If a copy of the MPL was not distributed with this
	+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
	+ *
	+ * File: polymorph.h
	+ * Author: pgess <v.melnychenko@xreate.org>
	+ *
	+ * Created on November 9, 2017, 12:14 PM
	+ */
	+
	+#ifndef POLYMORPHQUERY_H
	+#define POLYMORPHQUERY_H
	+
	+#include "clasplayer.h"
	+
	+namespace xreate {
	+ struct PolymorphGuard{};
	+
	+ template<>
	+ struct AttachmentsDict<PolymorphGuard>
	+ {
	+ typedef Expression Data;
	+ static const unsigned int key = 10;
	+ };
	+}
	+
	+namespace xreate { namespace polymorph {
	+class PolymorphQuery: public IQuery {
	+public:
	+ virtual void init(ClaspLayer* clasp) override;
	+};
	+
	+}}//end of xreate::polymorph
	+
	+#endif /* POLYMORPHQUERY_H */
	+
	diff --git a/cpp/tests/CMakeLists.txt b/cpp/tests/CMakeLists.txt
	index 46d37c2..f5211f9 100644
	--- a/cpp/tests/CMakeLists.txt
	+++ b/cpp/tests/CMakeLists.txt
	@@ -1,53 +1,54 @@
	cmake_minimum_required(VERSION 2.8.11)
	project(xreate-tests)

	find_package(GTest REQUIRED)
	INCLUDE_DIRECTORIES(${GTEST_INCLUDE_DIRS})
	INCLUDE_DIRECTORIES("/usr/include/libxml2")
	INCLUDE_DIRECTORIES($<TARGET_PROPERTY:xreate,INCLUDE_DIRECTORIES>)


	# TESTS
	#=========================
	FIND_PACKAGE (LLVM REQUIRED)
	message("LLVM_LIBRARY_DIRS: " ${LLVM_LIBRARY_DIRS})
	link_directories(${LLVM_LIBRARY_DIRS})

	set (LIBCLASP_PATH ${POTASSCO_PATH}/build/debug)
	link_directories(${LIBCLASP_PATH})

	#aux_source_directory(. TEST_FILES)
	set(TEST_FILES
	+ communication.cpp
	polymorph.cpp
	association.cpp
	main.cpp
	modules.cpp
	adhoc.cpp
	attachments.cpp
	ast.cpp
	cfa.cpp
	dfa.cpp
	compilation.cpp
	ExpressionSerializer.cpp
	externc.cpp
	context.cpp
	types.cpp
	vendorAPI/clangAPI.cpp
	vendorAPI/xml2.cpp
	vendorAPI/json.cpp

	containers.cpp
	context.cpp
	interpretation.cpp
	loops.cpp

	#supplemental/versions-algorithm-data_dependency.cpp
	effects-versions.cpp
	)

	add_executable(${PROJECT_NAME} ${TEST_FILES})
	target_link_libraries(${PROJECT_NAME} xreate ${GTEST_LIBRARIES} pthread xml2 gcov)

	add_custom_target (coverage
	COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/src/code-coverage.sh
	WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
	diff --git a/cpp/tests/cfa.cpp b/cpp/tests/cfa.cpp
	index 13d9141..7681f73 100644
	--- a/cpp/tests/cfa.cpp
	+++ b/cpp/tests/cfa.cpp
	@@ -1,122 +1,122 @@
	/* Any copyright is dedicated to the Public Domain.
	* http://creativecommons.org/publicdomain/zero/1.0/
	*
	* testsCFG.cpp
	*
	* Created on: Jul 17, 2015
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	#include "xreatemanager.h"
	#include "pass/dfapass.h"
	#include "pass/cfapass.h"

	#include "analysis/DominatorsTreeAnalysisProvider.h"

	#include "gtest/gtest.h"

	#include <boost/scoped_ptr.hpp>
	#include <boost/smart_ptr/scoped_array.hpp>

	using namespace xreate;
	using namespace xreate::cfa;
	using namespace std;

	TEST(CFA, testFunctionAnnotationsClasp){
	string&& program =
	"f2 = function::int; annotationF2 {\n"
	" 0\n"
	"}\n"
	"\n"
	"f1 = function:: int; entry; annotationF1 {\n"
	" f2() + 10\n"
	"}";


	details::tier1::XreateManager* man = details::tier1::XreateManager::prepare(move(program));
	man->analyse();

	ClaspLayer::ModelFragment answer = man->clasp->query("annotationF1");
	int countNoneValue = 0;
	if (answer) countNoneValue = std::distance(answer->first, answer->second);
	EXPECT_EQ(1, countNoneValue);

	answer = man->clasp->query("annotationF2");
	countNoneValue = 0;
	if (answer) countNoneValue = std::distance(answer->first, answer->second);

	EXPECT_EQ(1, countNoneValue);
	}

	TEST(CFA, testLoopContextExists){
	details::tier1::XreateManager* man = details::tier1::XreateManager::prepare (
	"interface(cfa){\n"
	" operator fold:: annotation1.\n"
	"}\n"
	"\n"
	"main = function:: int; entry {\n"
	" x = [1..10]:: [int].\n"
	" sum = loop fold (x->el:: int, 0->sum):: int {\n"
	" el + sum + f1()\n"
	" }. \n"
	" sum\n"
	"}"
	"case context:: annotation1 {"
	" f1 = function::int {\n"
	" x = 0:: int. "
	" x\n"
	" }"
	"}"
	);

	man->analyse();
	ClaspLayer::ModelFragment model = man->clasp->query("annotation1");
	ScopePacked scopeIdActual = std::get<0>(ClaspLayer::parse<ScopePacked>(model->first->second));

	CodeScope* scopeEntry = man->root->findFunction("main")->getEntryScope();
	const Expression& exprSum = scopeEntry->getDefinition(scopeEntry->getSymbol("sum"));
	CodeScope* scopeExpected = exprSum.blocks.front();

	ScopePacked scopeIdExpected = man->clasp->pack(scopeExpected);
	ASSERT_EQ(scopeIdExpected, scopeIdActual);
	}

	TEST(CFA, CFGRoots){
	- std::string program =
	-R"CODE(
	- main = function::int{a()+ b()}
	- a= function::int {c1() + c2()}
	- b= function::int {c2()}
	- c1=function::int{0}
	- c2=function::int{0}
	-)CODE";
	-
	- boost::scoped_ptr<XreateManager> manager
	- (XreateManager::prepare(move(program)));
	-
	- manager->registerPass(new CFAPass(manager.get()) , PassId::CFGPass);
	- manager->executePasses();
	- manager->clasp->run();
	-
	- dominators::DominatorsTreeAnalysisProvider domProvider;
	- domProvider.run(manager->clasp);
	-
	- dominators::DominatorsTreeAnalysisProvider::Dominators expectedFDom= {
	- {0, {0, 9}}
	- ,{1, {1, 4}}
	- ,{2, {7, 8}}
	- ,{3, {2, 3}}
	- ,{4, {5, 6}}
	- };
	-
	- dominators::DominatorsTreeAnalysisProvider::Dominators expectedPostDom= {
	- {0, {5, 6}}
	- ,{1, {3, 4}}
	- ,{2, {8, 9}}
	- ,{3, {1, 2}}
	- ,{4, {7, 10}}
	- };
	-
	- ASSERT_EQ(expectedFDom, domProvider.getForwardDominators());
	- ASSERT_EQ(expectedPostDom, domProvider.getPostDominators());
	+// std::string program =
	+//R"CODE(
	+// main = function::int{a()+ b()}
	+// a= function::int {c1() + c2()}
	+// b= function::int {c2()}
	+// c1=function::int{0}
	+// c2=function::int{0}
	+//)CODE";
	+//
	+// boost::scoped_ptr<XreateManager> manager
	+// (XreateManager::prepare(move(program)));
	+//
	+// manager->registerPass(new CFAPass(manager.get()) , PassId::CFGPass);
	+// manager->executePasses();
	+// manager->clasp->run();
	+//
	+// dominators::DominatorsTreeAnalysisProvider domProvider;
	+// domProvider.run(manager->clasp);
	+//
	+// dominators::DominatorsTreeAnalysisProvider::Dominators expectedFDom= {
	+// {0, {0, 9}}
	+// ,{1, {1, 4}}
	+// ,{2, {7, 8}}
	+// ,{3, {2, 3}}
	+// ,{4, {5, 6}}
	+// };
	+//
	+// dominators::DominatorsTreeAnalysisProvider::Dominators expectedPostDom= {
	+// {0, {5, 6}}
	+// ,{1, {3, 4}}
	+// ,{2, {8, 9}}
	+// ,{3, {1, 2}}
	+// ,{4, {7, 10}}
	+// };
	+//
	+// ASSERT_EQ(expectedFDom, domProvider.getForwardDominators());
	+// ASSERT_EQ(expectedPostDom, domProvider.getPostDominators());
	}
	diff --git a/cpp/tests/communication.cpp b/cpp/tests/communication.cpp
	new file mode 100644
	index 0000000..0b89e90
	--- /dev/null
	+++ b/cpp/tests/communication.cpp
	@@ -0,0 +1,51 @@
	+/* Any copyright is dedicated to the Public Domain.
	+ * http://creativecommons.org/publicdomain/zero/1.0/
	+ *
	+ * communication.cpp
	+ *
	+ * Author: pgess <v.melnychenko@xreate.org>
	+ * Created on October 14, 2017, 5:24 PM
	+ */
	+
	+#include "xreatemanager.h"
	+#include "gtest/gtest.h"
	+using namespace xreate;
	+
	+TEST(Communication, ast1){
	+ FILE* script = fopen("scripts/effects-communication/example1-wr.xreate", "r");
	+ std::unique_ptr<XreateManager> program(XreateManager::prepare(script));
	+
	+ ASSERT_TRUE(true);
	+ fclose(script);
	+}
	+
	+TEST(Communication, Analysis1){
	+ FILE* script = fopen("scripts/effects-communication/example1-wr.xreate", "r");
	+ std::unique_ptr<details::tier1::XreateManager> program(details::tier1::XreateManager::prepare(script));
	+ fclose(script);
	+
	+ program->analyse();
	+ ASSERT_TRUE(true);
	+}
	+
	+TEST(Communication, FullOnlyDirect1){
	+ FILE* script = fopen("scripts/effects-communication/example1-wr.xreate", "r");
	+ std::unique_ptr<XreateManager> program(XreateManager::prepare(script));
	+ fclose(script);
	+
	+ int (programEntry)() = (int ()())program->run();
	+ int result = programEntry();
	+
	+ ASSERT_EQ(1, result);
	+}
	+
	+TEST(Communication, FullDirectAndGuarded1){
	+ FILE* script = fopen("scripts/effects-communication/example2-wr.xreate", "r");
	+ std::unique_ptr<XreateManager> program(XreateManager::prepare(script));
	+ fclose(script);
	+
	+ int (programEntry)() = (int ()())program->run();
	+ int result = programEntry();
	+
	+ ASSERT_EQ(1, result);
	+}
	\ No newline at end of file
	diff --git a/cpp/tests/dfa.cpp b/cpp/tests/dfa.cpp
	index 8396abc..a695b02 100644
	--- a/cpp/tests/dfa.cpp
	+++ b/cpp/tests/dfa.cpp
	@@ -1,16 +1,32 @@
	/* Any copyright is dedicated to the Public Domain.
	* http://creativecommons.org/publicdomain/zero/1.0/
	- *
	+ *
	* DFGtests.cpp
	*
	* Created on: Jul 23, 2015
	* Author: pgess <v.melnychenko@xreate.org>
	*/
	#include "xreatemanager.h"
	#include "pass/dfapass.h"

	#include "gtest/gtest.h"
	using namespace xreate;
	using namespace std;

	//DEBT dfa tests: dfa scheme, dfa scheme + return value annoation (example: script/testpass/containers...)
	+
	+TEST(DFA, CallInstance1) {
	+ std::string program=
	+ R"CODE(
	+ main = function::int{
	+ a(5, 8)
	+ }
	+
	+ a= function(x::int, y::int)::int;entry { x + y}
	+)CODE";
	+
	+ std::unique_ptr<XreateManager> manager
	+ (XreateManager::prepare(move(program)));
	+
	+ manager->run();
	+}
	\ No newline at end of file
	diff --git a/cpp/tests/main.cpp b/cpp/tests/main.cpp
	index c45667e..5186ff6 100644
	--- a/cpp/tests/main.cpp
	+++ b/cpp/tests/main.cpp
	@@ -1,23 +1,23 @@
	/* Any copyright is dedicated to the Public Domain.
	* http://creativecommons.org/publicdomain/zero/1.0/
	- *
	+ *
	* main.cpp
	*
	* Created on: -
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	#include "utils.h"
	#include <gtest/gtest.h>

	using namespace std;
	using namespace xreate;

	int main(int argc, char **argv) { testing::GTEST_FLAG(color) = "yes";

	string testsTemplate = Config::get("tests.template");
	string testsFilter = Config::get(string("tests.templates.") + testsTemplate);
	testing::GTEST_FLAG(filter) = testsFilter;
	testing::InitGoogleTest(&argc, argv);
	return RUN_ALL_TESTS();
	}
	diff --git a/grammar/xreate.ATG b/grammar/xreate.ATG
	index 012ace5..e9b8f81 100644
	--- a/grammar/xreate.ATG
	+++ b/grammar/xreate.ATG
	@@ -1,658 +1,660 @@
	//TODO add ListLiteral
	//TODO ExprTyped: assign default(none) type

	#include "ast.h"
	#include "ExternLayer.h"
	#include "pass/adhocpass.h"
	#include <string>
	#include <stack>

	#define wprintf(format, ...) \
	char __buffer[100]; \
	wcstombs(__buffer, format, 100); \
	fprintf(stderr, __buffer, __VA_ARGS__)

	using namespace std;

	COMPILER Xreate

	details::inconsistent::AST* root = nullptr; // current program unit

	void ensureInitalizedAST(){
	if (root == nullptr) root = new details::inconsistent::AST();
	}

	struct {
	std::stack<CodeScope*> scopesOld;
	CodeScope* scope = nullptr;
	} context;

	void pushContextScope(CodeScope* scope){
	context.scopesOld.push(context.scope);
	context.scope = scope;
	}

	void popContextScope(){
	context.scope = context.scopesOld.top();
	context.scopesOld.pop();
	}

	int nextToken()
	{
	scanner->ResetPeek();
	return scanner->Peek()->kind;
	}

	bool checkTokenAfterIdent(int key){
	if (la->kind != _ident) return false;
	return nextToken() == key;
	}

	bool checkParametersList()
	{
	return la->kind == _ident && nextToken() == _lparen;
	}

	bool checkInfix()
	{
	return la->kind == _ident && nextToken() == _ident;
	}

	bool checkIndex()
	{
	return la->kind == _ident && nextToken() == _lbrack;
	}

	bool checkFuncDecl()
	{
	if (la->kind != _ident) return false;

	int token2 = nextToken();
	int token3 = scanner->Peek()->kind;

	return token2 == _assign && (token3 == _function \|\| token3 == _pre);
	}



	bool checkAssignment()
	{
	if (la->kind != _ident) return false;

	scanner->ResetPeek();
	int token2 = scanner->Peek()->kind;
	if (token2 == _lcurbrack) {
	scanner->Peek();
	int token3 = scanner->Peek()->kind;
	if (token3 != _rcurbrack) return false;

	int token4 = scanner->Peek()->kind;
	return token4 == _assign;
	}

	return token2 == _assign;
	}

	void recognizeIdentifier(Expression& i){
	if (!context.scope->recognizeIdentifier(i)){
	root->postponeIdentifier(context.scope, i);
	}
	}

	enum SwitchKind{SWITCH_NORMAL, SWITCH_META};

	CHARACTERS
	letter = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".
	any = ANY - '"'.
	digit = "0123456789".
	cr = '\r'.
	lf = '\n'.
	tab = '\t'.

	TOKENS
	ident = (letter \| '_') {letter \| digit \| '_'}.
	number = (digit \| '-' digit) {digit}.
	string = '"' { any } '"'.
	function = "function".
	pre = "pre".
	lparen = '('.
	rparen = ')'.
	lbrack = '['.
	rbrack = ']'.
	lcurbrack = '{'.
	rcurbrack = '}'.
	equal = "==".
	assign = '='.
	implic = '-' '>'.
	colon = ':'.
	context = "context".
	tagcolon = "::".
	lse = "<=".
	lss = "<".
	gte = ">=".
	gtr = ">".

	ne1 = "!=".
	ne2= "<>".


	COMMENTS FROM "/" TO "/" NESTED
	COMMENTS FROM "//" TO lf

	IGNORE cr + lf + tab

	PRODUCTIONS

	Xreate = (. Function* function; ensureInitalizedAST(); .)
	{( RuleDecl
	\| InterfaceData \| Imprt \| ContextSection \| GuardSection
	\| IF(checkFuncDecl()) FDecl<function> (. root->add(function); .)
	\| TDecl
	\| SkipModulesSection
	)} (. .)
	.

	Ident<std::wstring& name>
	= ident (. name = t->val; .).

	VarIdent<Expression& e>
	= ident (. e = Expression(Atom<Identifier_t>(t->val)); .)
	[ lcurbrack (
	ident (. SemErr(coco_string_create("var version as ident is not implemented yet")); .)
	\| number (. Attachments::put<versions::VariableVersion>(e, Atom<Number_t>(t->val).get()); .)
	) rcurbrack ]
	.


	FDecl<Function*& f> = (. std::wstring fname; std::wstring argName; TypeAnnotation typIn; TypeAnnotation typOut; bool flagIsPrefunct = false; Expression binding; .)
	Ident<fname> assign
	[pre (. flagIsPrefunct = true; .)]
	function (. f = new Function(fname); f->isPrefunction = flagIsPrefunct; CodeScope* entry = f->getEntryScope(); .)

	['(' Ident<argName> tagcolon ExprAnnotations<binding> (. f->addBinding(Atom<Identifier_t>(argName), move(binding)); .)
	{',' Ident<argName> tagcolon ExprAnnotations<binding> (. f->addBinding(Atom <Identifier_t>(argName), move(binding));.)
	} ')']

	[ tagcolon
	( IF(flagIsPrefunct) FnTag<f>
	\| Type<typOut>
	)
	{';' FnTag<f> }]
	BDecl<entry> (. entry->getBody().bindType(move(typOut));.)
	.

	ContextSection<>= (. Expression context; Function* f; .)
	"case" "context" tagcolon MetaSimpExpr<context>
	lcurbrack { FDecl<f> (. f->guardContext = context; root->add(f); .)
	} rcurbrack.

	GuardSection<>= (. Expression guard; Function* f; .)
	"guard" tagcolon MetaSimpExpr<guard>
	lcurbrack { FDecl<f> (. f->guard = guard; root->add(f); .)
	} rcurbrack.

	/**
	* TYPES
	*
	*/
	TypeTerm<TypePrimitive& typ> = (. std::wstring tid; .)
	("string" (. typ = TypePrimitive::String;.)
	\| "num" (. typ = TypePrimitive::Num;.)
	\| "int" (. typ = TypePrimitive::Int;.)
	\| "float" (. typ = TypePrimitive::Float;.)
	\| "bool" (. typ = TypePrimitive::Bool; .)
	\| "i8" (. typ = TypePrimitive::I8; .)
	\| "i32" (. typ = TypePrimitive::I32; .)
	\| "i64" (. typ = TypePrimitive::I64; .)
	).

	Type<TypeAnnotation& typ> = (. TypeAnnotation typ2; TypePrimitive typ3; std::wstring tid, field; .)
	(
	TList<typ>
	\| TStruct<typ>
	\| TVariant<typ>
	\| TypeTerm<typ3> (. typ = typ3; .)
	\| IF (checkIndex()) Ident<tid> lbrack
	Ident<field> (. typ = TypeAnnotation(TypeOperator::ACCESS, {}); typ.__valueCustom = Atom<Identifier_t>(tid).get(); typ.fields.push_back(Atom<Identifier_t>(field).get()); .)
	{',' Ident<field> (. typ.fields.push_back(Atom<Identifier_t>(field).get()); .)
	} rbrack

	\| Ident<tid> (. typ = TypeAnnotation(TypeOperator::CUSTOM, {}); typ.__valueCustom = Atom<Identifier_t>(tid).get(); .)
	['(' Type<typ2> (. typ.__operator = TypeOperator::CALL; typ.__operands.push_back(typ2); .)
	{',' Type<typ2> (. typ.__operands.push_back(typ2); .)
	} ')']
	) .

	TList<TypeAnnotation& typ> = (. TypeAnnotation ty; .)
	'[' Type<ty> ']' (. typ = TypeAnnotation(TypeOperator::ARRAY, {ty}); .)
	.

	TStruct<TypeAnnotation& typ> = (. TypeAnnotation t; std::wstring key; size_t keyCounter=0; .)
	lcurbrack
	(
	IF(checkTokenAfterIdent(_tagcolon)) Ident<key> tagcolon Type<t>
	\| Type<t> (. key = to_wstring(keyCounter++); .)

	) (. typ = TypeAnnotation(TypeOperator::STRUCT, {t}); typ.fields.push_back(Atom<Identifier_t>(key).get()); .)
	{',' (
	IF(checkTokenAfterIdent(_tagcolon)) Ident<key> tagcolon Type<t>
	\| Type<t> (. key = to_wstring(keyCounter++); .)

	) (. typ.__operands.push_back(t); typ.fields.push_back(Atom<Identifier_t>(key).get()); .)
	} rcurbrack.

	TVariant<TypeAnnotation& typ>= (. TypeAnnotation t, typVoid(TypeOperator::STRUCT, {}); std::vector<TypeAnnotation> operands; std::vector<Atom<Identifier_t>> keys; std::wstring variant; .)
	"variant" lcurbrack
	Ident<variant> (. t=typVoid; .)
	[tagcolon Type<t>] (. keys.push_back(Atom<Identifier_t>(variant)); operands.push_back(t); .)

	{',' Ident<variant> (. t=typVoid; .)
	[tagcolon Type<t>] (. keys.push_back(Atom<Identifier_t>(variant)); operands.push_back(t); .)
	}
	rcurbrack (. typ = TypeAnnotation(TypeOperator::VARIANT, {}); typ.__operands = operands; typ.addFields(std::move(keys)); .)
	.

	TDecl = (. TypeAnnotation t; std::wstring tname, arg; std::vector<Atom<Identifier_t>> args; .)
	Ident<tname> assign "type"
	['(' Ident<arg> (. args.push_back(Atom<Identifier_t>(arg)); .)
	{',' Ident<arg> (. args.push_back(Atom<Identifier_t>(arg)); .)
	} ')']
	Type<t>'.' (. t.addBindings(move(args)); root->add(move(t), Atom<Identifier_t>(tname)); .)
	.

	ContextDecl<CodeScope * scope> = (. Expression tag; .)
	context tagcolon
	MetaSimpExpr<tag> (. scope->tags.push_back(tag); .)
	{';' MetaSimpExpr<tag> (. scope->tags.push_back(tag); .)
	}.

	VDecl<CodeScope* f> = (. std::wstring vname; Expression var, value;.)
	- VarIdent<var> assign ExprTyped<value> (. f->addDefinition(move(var), move(value)); .)
	+ VarIdent<var> assign ExprTyped<value> (. Symbol identSymbol = f->addDefinition(move(var), move(value));
	+ Attachments::put<SymbolAlias>(value, identSymbol);
	+ .)
	.

	BDecl<CodeScope* scope> = lcurbrack (. Expression body; pushContextScope(scope); .)
	{(IF(checkAssignment()) VDecl<scope> '.'
	\| RuleContextDecl<scope>
	\| ContextDecl<scope>'.'
	- \| ExprTyped<body> (. scope->setBody(body); .)
	+ \| ExprTyped<body> (. scope->setBody(body); Attachments::put<SymbolAlias>(body, Symbol{ScopedSymbol::RetSymbol, scope});.)
	)}
	rcurbrack (. popContextScope(); .)
	.

	IfDecl<Expression& e> = (. Expression cond; ManagedScpPtr blockTrue = root->add(new CodeScope(context.scope)); ManagedScpPtr blockFalse = root->add(new CodeScope(context.scope)); .)
	"if" '(' Expr<cond> ')' (. e = Expression(Operator::IF, {cond}); .)
	tagcolon ExprAnnotations<e>
	BDecl<&blockTrue> "else" BDecl<&blockFalse> (. e.addBlock(blockTrue); e.addBlock(blockFalse); .)
	.

	LoopDecl<Expression& e> =
	(. Expression eIn, eAcc, eFilters; std::wstring varEl, varAcc, contextClass; Expression tagsEl;
	ManagedScpPtr block = root->add(new CodeScope(context.scope)); .)
	"loop"
	("map" '(' Expr<eIn> implic Ident<varEl> (. e = Expression(Operator::MAP, {eIn}); .)
	tagcolon ExprAnnotations<tagsEl> ')' tagcolon ExprAnnotations<e>
	(.
	e.addBindings({Atom<Identifier_t>(varEl)});
	block->addBinding(Atom<Identifier_t>(varEl), move(tagsEl));
	.)
	BDecl<&*block>
	(. e.addBlock(block); .)

	\|"fold"
	("inf" '(' Expr<eAcc> implic Ident<varAcc> ')'
	(.
	e = Expression(Operator::FOLD_INF, {eAcc});
	e.addBindings({Atom<Identifier_t>(varAcc)});
	block->addBinding(Atom<Identifier_t>(varAcc), Expression());
	.)
	tagcolon ExprAnnotations<e> BDecl<&*block>
	(. e.addBlock(block); .)

	\| '(' Expr<eIn> implic Ident<varEl> tagcolon ExprAnnotations<tagsEl> ['\|' Expr<eFilters> ] ',' Expr<eAcc> implic Ident<varAcc>')'
	(.
	e = Expression(Operator::FOLD, {eIn, eAcc});
	e.addBindings({Atom<Identifier_t>(varEl), Atom<Identifier_t>(varAcc)});
	.)
	tagcolon ExprAnnotations<e>
	(.
	block->addBinding(Atom<Identifier_t>(varEl), move(tagsEl));
	block->addBinding(Atom<Identifier_t>(varAcc), Expression());
	.)
	BDecl<&*block>
	(. e.addBlock(block); .)
	)
	\| "context" '(' string (. contextClass = t->val; .)
	')' BDecl<&*block>
	(. e = Expression(Operator::LOOP_CONTEXT, {Expression(Atom<String_t>(std::move(contextClass)))});
	e.addBlock(block);
	.)
	).

	// Switches
	SwitchDecl<Expression& eSwitch, SwitchKind flagSwitchKind> = (. TypeAnnotation typ; eSwitch = Expression(Operator::SWITCH, {}); Expression eCondition; Expression tag;.)
	"switch"
	(
	SwitchVariantDecl<eSwitch>
	\| lparen ExprTyped<eCondition> rparen tagcolon ExprAnnotations<eSwitch> (. eSwitch.operands.push_back(eCondition);.)
	CaseDecl<eSwitch, flagSwitchKind> {CaseDecl<eSwitch, flagSwitchKind>}
	)
	.

	CaseDecl<Expression& outer, SwitchKind flagSwitchKind> = (. ManagedScpPtr scope = root->add(new CodeScope(context.scope)); Expression condition; .)
	"case"
	( IF(flagSwitchKind == SWITCH_META)
	lparen MetaSimpExpr<condition> rparen BDecl<&*scope> (. Expression exprCase(Operator::CASE, {}); exprCase.addTags({condition}); exprCase.addBlock(scope); outer.addArg(move(exprCase));.)

	\| "default" BDecl<&*scope> (. Expression exprCase(Operator::CASE_DEFAULT, {});
	exprCase.addBlock(scope);
	outer.operands.insert(++outer.operands.begin(), exprCase); .)

	\| lparen CaseParams<&scope> rparen (. ManagedScpPtr scopeBody = root->add(new CodeScope(&scope)); Expression exprCase(Operator::CASE, {}); .)
	BDecl<&*scopeBody> (. exprCase.addBlock(scope); exprCase.addBlock(scopeBody); outer.addArg(move(exprCase)); .)
	).

	CaseParams<CodeScope* scope> = (. Expression condition; Expression guard(Operator::LOGIC_AND, {}); pushContextScope(scope); .)
	ExprTyped<condition> (. guard.addArg(Expression(condition)); .)
	{',' ExprTyped<condition> (. guard.addArg(Expression(condition)); .)
	} (. scope->setBody(guard); popContextScope(); .)
	.

	SwitchVariantDecl<Expression& expr> =
	(. Expression varTested; std::wstring varAlias; bool flagAliasFound = false; expr = Expression(Operator::SWITCH_VARIANT, {}); .)

	"variant" lparen Expr<varTested> [implic Ident<varAlias>
	(. flagAliasFound = true; .)

	] [tagcolon ExprAnnotations<varTested>] rparen tagcolon ExprAnnotations<expr>
	(. expr.addArg(std::move(varTested));
	if (flagAliasFound) {
	expr.addBindings({Atom<Identifier_t>(varAlias)});

	} else {
	if(varTested.__state != Expression::IDENT){
	SemErr(coco_string_create("Switch variant expects identifier"));

	}

	expr.addBindings({Atom<Identifier_t>(string(varTested.getValueString()))});
	}
	.)

	CaseVariantDecl<expr> {CaseVariantDecl<expr>}
	.

	CaseVariantDecl<Expression& expr> = (. ManagedScpPtr scope = root->add(new CodeScope(context.scope)); std::wstring key; scope->addBinding(Atom<Identifier_t>(string(expr.bindings.front())), Expression()); .)
	"case" lparen Ident<key> rparen (. expr.addArg(root->recognizeVariantConstructor(Atom<Identifier_t>(std::move(key)))); .)
	BDecl<&*scope> (. expr.addBlock(scope); .)
	.

	IntrinsicDecl<Expression& outer>= (. std::wstring name; .)
	"intrinsic" Ident< name> (. outer = Expression(Operator::CALL_INTRINSIC, {}); outer.setValue(Atom<Identifier_t>(name)); .)
	lparen [CalleeParams<outer>] rparen .

	/============================ INTERFACES ===============================/
	Imprt<> =
	"import" "raw" lparen string (. root->__rawImports.push_back(Atom<String_t>(t->val).get()); .)
	rparen '.'.

	InterfaceData<> = "interface" '('
	( "dfa" ')' InterfaceDFA
	\| "extern-c" ')' InterfaceExternC
	\| "cfa" ')' InterfaceCFA
	\| "adhoc" ')' InterfaceAdhoc

	).

	InterfaceAdhoc<> =
	'{' { PrefunctionSchemeDecl } '}'.

	PrefunctionSchemeDecl<> = (. TypeAnnotation typReturn; std::wstring prefName; Expression exprCases; .)
	pre function Ident<prefName> tagcolon Type<typReturn>
	lcurbrack SwitchDecl<exprCases, SWITCH_META> rcurbrack
	(. Expression prefData(Operator::CALL, {Atom<Identifier_t>(prefName), exprCases});
	prefData.bindType(typReturn);
	root->addInterfaceData(Adhoc, move(prefData));
	.).


	InterfaceExternC<> = (. ExternData data; .)
	'{' {IncludeExternDecl<data> \| LibExternDecl<data> } '}'
	(. root->addExternData(move(data)); .)
	.

	LibExternDecl<ExternData& data> = (. std::wstring pkgname, libname; .)
	Ident<libname> assign "library" tagcolon "pkgconfig"
	'(' string (. pkgname = t->val; .)
	')' '.' (. data.addLibrary(Atom<Identifier_t>(libname), Atom<String_t>(pkgname)); .)
	.

	IncludeExternDecl<ExternData& data> = (. Expression inc; .)
	"include" StructLiteral<inc> '.' (. data.addIncludeDecl(move(inc)); .)
	.

	InterfaceDFA<> = '{' { InstructDecl } '}' .

	InstructDecl = (.Operator op; Expression tag;
	Expression scheme;
	std::vector<Expression>& tags = scheme.operands;
	tags.push_back(Expression()); /* return value */ .)
	"operator" InstructAlias<op> tagcolon '(' (.scheme.setOp(op); .)
	[
	MetaSimpExpr<tag> (. tags.push_back(tag); .)
	{
	',' MetaSimpExpr<tag> (. tags.push_back(tag); .)
	}
	] ')' [ implic MetaSimpExpr<tag> (. tags[0] = tag; .)
	] (. root->addDFAData(move(scheme)); .)
	'.'.

	InstructAlias<Operator& op> =
	(
	"map" (. op = Operator::MAP; .)
	\| "list_range" (. op = Operator::LIST_RANGE; .)
	\| "list" (. op = Operator::LIST; .)
	\| "fold" (. op = Operator::FOLD; .)
	\| "index" (. op = Operator::INDEX; .)
	).


	InterfaceCFA<> = '{' { InstructCFADecl } '}' .

	InstructCFADecl<> = (.Operator op; Expression tag;
	Expression scheme;
	std::vector<Expression>& tags = scheme.operands; .)

	"operator" InstructAlias<op> tagcolon (. scheme.setOp(op); .)
	[
	MetaSimpExpr<tag> (. tags.push_back(tag); .)
	{
	',' MetaSimpExpr<tag> (. tags.push_back(tag); .)
	}
	] '.' (. root->addInterfaceData(CFA, move(scheme)); .).

	/============================ METAPROGRAMMING ===============================/
	// TagsDecl<CodeScope* f> = (. Expression tag; TagModifier mod = TagModifier::NONE; .)
	// ':' { MetaSimpExpr<tag> (. /f.addTag(std::move(tag), mod); / .)
	// }.


	FnTag<Function* f> = (. Expression tag; TagModifier mod = TagModifier::NONE; .)
	MetaSimpExpr<tag>
	['-' TagMod<mod>] (. f->addTag(std::move(tag), mod); .).

	TagMod<TagModifier& mod> =
	( "assert" (. mod = TagModifier::ASSERT; .)
	\| "require" (. mod = TagModifier::REQUIRE; .)
	).

	RuleDecl<> =
	"rule" tagcolon (. RuleArguments args; RuleGuards guards; DomainAnnotation typ; std::wstring arg; .)
	'(' Ident<arg> tagcolon Domain<typ> (. args.add(arg, typ); .)
	{',' Ident<arg> tagcolon Domain<typ> (. args.add(arg, typ); .)
	} ')'
	["case" RGuard<guards> {',' RGuard<guards>}]
	'{' RBody<args, guards> '}' .

	/* - TODO use RGuard for guards-*/
	RuleContextDecl<CodeScope* scope> = (.Expression eHead, eGuards, eBody; .)
	"rule" "context" tagcolon MetaSimpExpr<eHead>
	"case" lparen MetaSimpExpr<eGuards> rparen
	'{' MetaSimpExpr<eBody> '}' (.scope->contextRules.push_back(Expression(Operator::CONTEXT_RULE, {eHead, eGuards, eBody})); .).

	Domain<DomainAnnotation& dom> =
	(
	"function" (. dom = DomainAnnotation::FUNCTION; .)
	\| "variable" (. dom = DomainAnnotation::VARIABLE; .)
	).

	RGuard<RuleGuards& guards>= (. Expression e; .)
	MetaExpr<e> (. guards.add(std::move(e)); .).

	MetaExpr<Expression& e>= (.Operator op; Expression e2; .)
	MetaExpr2<e>
	[MetaOp<op> MetaExpr2<e2> (. e = Expression(op, {e, e2}); .)
	].

	MetaExpr2<Expression& e>=
	(
	'(' MetaExpr<e> ')'
	\| MetaSimpExpr<e>
	).

	MetaSimpExpr<Expression& e>= (. std::wstring i1, infix; Expression e2; .)
	( '-' MetaSimpExpr<e2> (. e = Expression(Operator::NEG, {e2}); .)
	\| IF(checkParametersList()) Ident<i1> (. e = Expression(Operator::CALL, {Expression(Atom<Identifier_t>(i1))}); .)
	'(' [ MetaCalleeParams<e> ] ')'
	\| IF(checkInfix()) Ident<i1> Ident<infix> MetaSimpExpr<e2>
	(. e = Expression(Operator::CALL, {Expression(Atom<Identifier_t>(infix))});
	e.addArg(Expression(Atom<Identifier_t>(i1)));
	e.addArg(std::move(e2));
	.)
	\| Ident<i1> (. e = Expression(Operator::CALL, {Atom<Identifier_t>(i1)}); .)
	).

	MetaCalleeParams<Expression& e> = (. Expression e2; .)
	MetaSimpExpr<e2> (. e.addArg(Expression(e2)); .)
	{',' MetaSimpExpr<e2> (. e.addArg(Expression(e2)); .)
	}.

	RBody<const RuleArguments& args, const RuleGuards& guards> =
	(. Expression e; std::wstring msg; .)
	"warning" MetaExpr<e> ["message" string (. msg = t->val; .)
	] (. root->add(new RuleWarning(RuleArguments(args), RuleGuards(guards), std::move(e), Atom<String_t>(msg))); .)
	.

	MetaOp< Operator& op> =
	implic (. op = Operator::IMPL; .)
	.

	/============================ Expressions ===============================/
	ExprAnnotations<Expression& e> = (. TypeAnnotation typ; std::list<Expression> tags; Expression tag; e.tags.clear();.)
	Type<typ> (. e.bindType(move(typ)); .)
	{';' MetaSimpExpr<tag> (. tags.push_back(tag); .)
	} (. e.addTags(tags); .)
	.

	ExprTyped<Expression&e> = Expr<e> [tagcolon ExprAnnotations<e>].

	Expr< Expression& e> (. Operator op; Expression e2; .)
	= ExprArithmAdd<e>
	[ RelOp<op>
	ExprArithmAdd<e2> (. e = Expression(op, {e, e2}); .)
	].

	ExprArithmAdd< Expression& e>= (. Operator op; Expression e2; .)
	ExprArithmMul< e>
	[ AddOp< op>
	ExprArithmAdd< e2> (. e = Expression(op, {e, e2});.)
	].

	ExprArithmMul< Expression& e> (. Operator op; Expression e2; .)
	= ExprPostfix< e>
	[ MulOp< op>
	ExprArithmMul< e2> (. e = Expression(op, {e, e2}); .)
	].

	ExprPostfix<Expression& e>
	= Term<e>
	[ (. e = Expression(Operator::INDEX, {e}); .)
	{lbrack CalleeParams<e> rbrack }
	].


	Term< Expression& e> (. std::wstring name; e = Expression(); .)
	=
	(IF (checkParametersList()) Ident< name>
	(. e = Expression(Operator::CALL, {Atom<Identifier_t>(name)}); root->recognizeVariantConstructor(e); .)
	'(' [CalleeParams<e>] ')'
	\| VarIdent<e> (. recognizeIdentifier(e); .)
	\| ListLiteral<e> (. /* tuple */.)
	\| StructLiteral<e> (. /* struct */.)
	\| LoopDecl<e>
	\| IfDecl<e>
	\| SwitchDecl<e, SWITCH_NORMAL>
	\| AdhocDecl<e>
	\| IntrinsicDecl<e>
	\| number (. e = Expression(Atom<Number_t>(t->val)); .)
	\| string (. e = Expression(Atom<String_t>(t->val)); .)
	\| "true" (. e = Expression(Atom<Number_t>(1)); e.bindType(TypePrimitive::Bool); .)
	\| "false" (. e = Expression(Atom<Number_t>(0)); e.bindType(TypePrimitive::Bool); .)
	\| '-' Term<e> (. e = Expression(Operator::NEG, {e}); .)
	\| '(' ExprTyped<e> ')'
	).

	StructLiteral<Expression& e> = (. std::wstring key; Expression val; std::list<Atom<Identifier_t>> keys; size_t keyCounter=0; .)
	lcurbrack
	(IF(checkTokenAfterIdent(_assign)) Ident<key> '=' Expr<val>
	\| Expr<val> (. key = to_wstring(keyCounter++); .)
	) (. keys.push_back(Atom<Identifier_t>(key)); e = Expression(Operator::LIST_NAMED, {val}); .)
	{',' (IF(checkTokenAfterIdent(_assign)) Ident<key> '=' Expr<val>
	\| Expr<val> (. key = to_wstring(keyCounter++); .)
	) (. e.addArg(Expression(val)); keys.push_back(Atom<Identifier_t>(key)); .)
	} rcurbrack (. e.addBindings(keys.begin(), keys.end()); .)
	.

	ListLiteral<Expression& e> = (. Expression eFrom, eTo; .)
	'['
	[ Expr<eFrom> (. e.addArg(Expression(eFrom)); .)
	(".." Expr<eTo> (. e.addArg(Expression(eTo)); e.setOp(Operator::LIST_RANGE); .)
	\|{',' Expr<eFrom> (. e.addArg(Expression(eFrom)); .)
	} (. e.setOp(Operator::LIST); .)
	) ] ']'.

	AdhocDecl<Expression& e> = (. Expression command; .)
	"ad" "hoc" MetaSimpExpr<command> (. adhoc::AdhocExpression exprAdhoc; exprAdhoc.setCommand(command); e = exprAdhoc; .).

	CalleeParams<Expression& e> = (. Expression e2; .)
	ExprTyped<e2> (. e.addArg(Expression(e2)); .)
	{',' ExprTyped<e2> (. e.addArg(Expression(e2)); .)
	}.

	AddOp< Operator& op>
	= (. op = Operator::ADD; .)
	( '+'
	\| '-' (. op = Operator::SUB; .)
	).

	MulOp< Operator& op>
	= (. op = Operator::MUL; .)
	( '*'
	\| '/' (. op = Operator::DIV; .)
	).

	RelOp< Operator& op>
	= (. op = Operator::EQU; .)
	( equal
	\| (ne1 \| ne2) (. op = Operator::NE; .)

	\| lse (. op = Operator::LSE; .)
	\| lss (. op = Operator::LSS; .)

	\| gte (. op = Operator::GTE; .)
	\| gtr (. op = Operator::GTR; .)

	).

	SkipModulesSection = "module" '{' {ANY} '}'.

	END Xreate.
	diff --git a/scripts/dfa/polymorphism.lp b/scripts/dfa/polymorphism.lp
	new file mode 100644
	index 0000000..9c11fe3
	--- /dev/null
	+++ b/scripts/dfa/polymorphism.lp
	@@ -0,0 +1,15 @@
	+%INPUT
	+% bind(Symb, callguard(..)) - binded Ann
	+%OUTPUT
	+% dfa_callguard(..) - ready for processing
	+
	+dfa_callguard(Instance, Guard):-
	+ bind(ArgActual, callguard(Guard));
	+ dfa_callargs(Instance,_, ArgActual);
	+ dfa_callret(Instance, SymbRet);
	+ bind(SymbRet, dfa_polym(arg)).
	+
	+dfa_callguard(Instance, Guard):-
	+ bind(SymbRet, callguard(Guard));
	+ dfa_callret(Instance, SymbRet);
	+ bind(SymbRet, dfa_polym(ret)).
	diff --git a/scripts/dfa/propagation.lp b/scripts/dfa/propagation.lp
	new file mode 100644
	index 0000000..ac8e81e
	--- /dev/null
	+++ b/scripts/dfa/propagation.lp
	@@ -0,0 +1,20 @@
	+%Propagates symbol bindings registered by dfa_propagation over dfa_uppy edges
	+%
	+% INPUT:
	+% dfa_propagation(X) - register propagated Ann
	+% bind(Symb, X) - initial symbol
	+%
	+% CALCULATED:
	+% dfa_uppy - UPdate or coPY
	+
	+bind(SymbA, DfaAnn):- bind(SymbB, DfaAnn); dfa_propagation(DfaAnn);
	+ 1{dfa_uppy(SymbA, SymbB); dfa_uppy(SymbB,SymbA)};
	+ v(SymbA); v(SymbB).
	+
	+dfa_uppy(X, Y):- bind(X, dfa_uppy(Pseudo)); bind(Y, dfa_pseudo(Pseudo)).
	+dfa_uppy(X, Y):- dfa_alias(X, Y).
	+
	+dfa_uppy(ArgFormal, ArgActual):- dfa_callargs(_,ArgFormal, ArgActual).
	+dfa_uppy(RetActual, RetFormal):-
	+ dfa_callret(CallId, RetActual); dfa_callinstance(CallId, FnName);
	+ dfa_fnret(FnName, RetFormal).
	diff --git a/scripts/effects-communication/communication.lp b/scripts/effects-communication/communication.lp
	new file mode 100644
	index 0000000..481a564
	--- /dev/null
	+++ b/scripts/effects-communication/communication.lp
	@@ -0,0 +1,77 @@
	+%INPUT:
	+% const horizon - Max Depth of communication analysis
	+% comm_order(Alias)), bind(X, comm_alias(Alias) - to apply additional order constraints
	+% dfa_uppy from dfa-propagation
	+
	+
	+% INIT
	+%===========================================================
	+comm_bind(end, end).
	+comm_bind(begin, begin).
	+comm_bind(X, Op):- bind(X, commop(Op)).
	+
	+
	+% ORDER
	+%============================================================
	+comm_path(X2, X1) :- bind(X2, comm_order(Alias)); bind(X1, comm_alias(Alias)).
	+
	+
	+% INHERITS
	+%============================================================
	+comm_path(X, Y) :- dfa_uppy(X, Y).
	+
	+comm_path(end, X) :- v(X); #sum{1: comm_path(Smth, X), v(Smth)}0.
	+comm_path(X, begin):- v(X); #sum{1: comm_path(X, Smth), v(Smth)}0.
	+
	+
	+% SCAN
	+%============================================================
	+%SOURCE
	+scan(X, source(X), length(0)) :- comm_bind(X, write).
	+
	+scan(Z, source(X), length(Length + 1)) :-
	+ comm_path(Z, Y);
	+ scan(Y, source(X), length(Length)); Length < horizon;
	+ not comm_bind(Z, _).
	+
	+scan(Z, source(X), report(Op)) :-
	+ comm_path(Z, Y);
	+ scan(Y, source(X), length(Length)); Length < horizon;
	+ comm_bind(Z, Op).
	+
	+%SINK
	+scan(X, sink(X), length(0)) :- comm_bind(X, read).
	+
	+scan(Z, sink(X), length(Length + 1)) :-
	+ comm_path(Y, Z);
	+ scan(Y, sink(X), length(Length)); Length < horizon;
	+ not comm_bind(Z, _).
	+
	+scan(Z, sink(X), report(Op)) :-
	+ comm_path(Y, Z);
	+ scan(Y, sink(X), length(Length)); Length < horizon;
	+ comm_bind(Z, Op).
	+
	+
	+% ISSUES
	+%==============================================================
	+comm_spot_lost_end(Source) :- scan(_, source(Source), report(end)).
	+comm_spot_lost(Source, Spot) :- scan(Spot, source(Source), report(write)).
	+comm_spot_outofreach(X, Spot) :- scan(Spot, source(X), length(horizon)).
	+comm_spot_outofreach(X, Spot) :- scan(Spot, sink(X), length(horizon)).
	+
	+comm_spot_corrupt_null(Sink) :- scan(_, sink(Sink), report(begin_)).
	+comm_spot_dup(Sink, Spot) :- scan(Spot, sink(Sink), report(read)).
	+
	+comm_spot(Source):-comm_spot_lost_end(Source).
	+comm_spot(Source):-comm_spot_lost(Source, Spot).
	+comm_spot(X):-comm_spot_outofreach(X, Spot).
	+comm_spot(Sink):-comm_spot_corrupt_null(Sink).
	+comm_spot(Sink):-comm_spot_dup(Sink, Spot).
	+
	+
	+% IMPLEMENTATION
	+%=============================================================
	+comm_impl(Source, commDirect):- comm_bind(Source, write); not comm_spot(Source).
	+bind(Source, callguard(commDirect)):- comm_impl(Source, commDirect).
	+
	diff --git a/scripts/effects-communication/config.lp b/scripts/effects-communication/config.lp
	new file mode 100644
	index 0000000..c6867d9
	--- /dev/null
	+++ b/scripts/effects-communication/config.lp
	@@ -0,0 +1,2 @@
	+#const horizon = 10.
	+dfa_propagation(callguard(commDirect)).
	diff --git a/scripts/effects-communication/example1-wr.xreate b/scripts/effects-communication/example1-wr.xreate
	new file mode 100644
	index 0000000..d5d734a
	--- /dev/null
	+++ b/scripts/effects-communication/example1-wr.xreate
	@@ -0,0 +1,38 @@
	+//Only Direct implementatino defined
	+
	+import raw ("scripts/effects-communication/communication.lp").
	+import raw ("scripts/effects-communication/dfa/propagation.lp").
	+import raw ("scripts/dfa/polymorphism.lp").
	+import raw ("scripts/effects-communication/config.lp").
	+
	+CommGuard = type variant{Invalid, Valid, Outdated}.
	+
	+CommDirect = type {
	+ value:: int
	+}.
	+
	+CommGuarded = type {
	+ value:: int,
	+ state:: CommGuard
	+}.
	+
	+guard:: commDirect {
	+ init=function::CommDirect{
	+ {value = 0}
	+ }
	+
	+ read= function(vault1:: CommDirect):: int{
	+ (vault1::CommDirect; commop(read))["value"]
	+ }
	+
	+ write= function(vault2:: CommDirect, valueNew:: int)::CommDirect{
	+ (vault2::CommDirect;dfa_pseudo(vault2)) + {value = valueNew}:: int; commop(write); dfa_uppy(vault2)
	+ }
	+}
	+
	+main=function::int; entry {
	+ x1 = init():: Comm; dfa_polym(ret).
	+ x2 = write(x1, 1)::Comm; dfa_polym(arg).
	+ a = read(x2):: int; dfa_polym(arg).
	+ a
	+}
	diff --git a/scripts/effects-communication/example2-wr.xreate b/scripts/effects-communication/example2-wr.xreate
	new file mode 100644
	index 0000000..95aba14
	--- /dev/null
	+++ b/scripts/effects-communication/example2-wr.xreate
	@@ -0,0 +1,76 @@
	+//Direct and Guarded implementation defined
	+
	+import raw ("scripts/effects-communication/communication.lp").
	+import raw ("scripts/dfa/propagation.lp").
	+import raw ("scripts/dfa/polymorphism.lp").
	+import raw ("scripts/effects-communication/config.lp").
	+
	+CommGuard = type variant{Invalid, Valid, Outdated}.
	+
	+CommDirect = type {
	+ value:: int
	+}.
	+
	+CommGuarded = type {
	+ value:: int,
	+ state:: CommGuard
	+}.
	+
	+guard:: commDirect {
	+ init=function::CommDirect{
	+ {value = 0}
	+ }
	+
	+ read= function(vault1:: CommDirect):: int{
	+ (vault1::CommDirect; commop(read))["value"]
	+ }
	+
	+ write= function(vault2:: CommDirect, valueNew:: int)::CommDirect{
	+ (vault2::CommDirect;dfa_pseudo(vault2)) + {value = valueNew}:: int; commop(write); dfa_uppy(vault2)
	+ }
	+}
	+
	+errorRead = function:: int { -1 }
	+
	+errorWrite = function:: CommGuarded{
	+ {
	+ value = -1,
	+ state = Invalid()
	+ }
	+}
	+
	+guard:: commGuarded{
	+ init=function::CommGuarded{
	+ {
	+ value = 0,
	+ state = Invalid()
	+ }
	+ }
	+
	+ read=function(vault3:: CommGuarded):: int {
	+ switch variant (vault3::CommGuarded;commop(read)):: int
	+ case (Invalid) { errorRead() }
	+ case (Outdated) { errorRead() }
	+ case (Valid) { vault3["value"] }
	+ }
	+
	+ write=function(vault4:: CommGuarded, valueNew:: int)::CommGuarded{
	+ switch variant (vault4)::int
	+ case (Invalid) {
	+ {value = valueNew, state = Valid()}
	+ }
	+
	+ case (Outdated) {
	+ {value = valueNew, state = Valid()}
	+ }
	+
	+ case (Valid) { errorWrite() }
	+ }
	+}
	+
	+main=function::int; entry {
	+ x1 = init():: Comm; dfa_polym(ret).
	+ x2 = write(x1, 1)::Comm; dfa_polym(arg).
	+ a = read(x2):: int; dfa_polym(arg).
	+ a
	+}

No OneTemporaryActions

File Metadata

View Options

Event Timeline

No OneTemporary
Actions