No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sat, Mar 14, 4:54 AM

View Options

	diff --git a/config/default.json b/config/default.json
	index 9770109..95a6f34 100644
	--- a/config/default.json
	+++ b/config/default.json
	@@ -1,71 +1,72 @@
	{
	"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": "communication",
	+ "template": "default",

	"templates": {
	- "default": "-Adhoc.:Compilation.full_IFStatementWithVariantType:Types.full_VariantType_Switch1",
	+ "current-fix":"Compilation.full_IFStatementWithVariantType",
	+ "default": "-Adhoc.:Containers.*:Compilation.full_IFStatementWithVariantType:Types.full_VariantType_Switch1:Context.full_LateContext:Context.pathDependentContext",
	"ast": "AST.*",
	"adhocs": "Adhoc.*",
	"effects": "Effects.*",
	"basic": "Attachments.*",
	"context": "Context.*",
	"compilation": "Compilation.*-Compilation.full_IFStatementWithVariantType",
	"communication": "Communication.*",
	"cfa": "CFA.*",
	"containers": "Containers.*",
	"dfa": "DFA.*",
	"diagnostic": "Diagnostic.*",
	- "dsl": "Interpretation.SwitchVariantAlias-Association.*",
	+ "dsl": "Association.*:Interpretation.SwitchVariantAlias",
	"ExpressionSerializer": "ExpressionSerializer.*",
	"externc": "InterfaceExternC.*",
	"loops": "Loop.*",
	"modules": "Modules.*",
	"polymorphs": "Polymorphs.call1",
	"types": "Types.*",
	"vendorsAPI/clang": "ClangAPI.*",
	"vendorsAPI/xml2": "libxml2*"
	}
	}
	}
	diff --git a/core/control-context-v3.lp b/core/control-context-v3.lp
	index 264f10d..ab4cfe3 100644
	--- a/core/control-context-v3.lp
	+++ b/core/control-context-v3.lp
	@@ -1,64 +1,64 @@
	% 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/.

	%% SCHEMA:
	- %% specialization(Fn, Scope) - problem of what specialization of Fn should be picked up in Scope.
	+ %% specialization(Fn, Scope) - indicates query of exact Fn specialization to use in Scope.
	%% resolution_dependency(Resolution, Dependency) - Dependency is necessary prerequisite for choosing Resolution.
	%%

	true.

	%nested scope propagation:
	bind_scope(Scope, Context, Info) :- bind_scope(ScopeParent, Context, Info), cfa_parent(Scope, scope(ScopeParent)).

	%strong/uniform inter-function propagation:
	bind_scope(Scope, Context,Info) :- bind_scope(ScopeParent, Context, Info): cfa_call(ScopeParent, FnCurrent);
	cfa_parent(Scope, function(FnCurrent)); cfa_call(_, FnCurrent);
	bind_scope(_, Context, Info); scope(Scope).

	%weak inter-function propagation
	bind_scope(Scope, Context, weak(ScopeParent)):- not bind_scope(Scope, Context, strong), bind_scope(ScopeParent, Context, strong), cfa_call(ScopeParent, FnCurrent), cfa_parent(Scope, function(FnCurrent)).
	bind_scope(Scope, Context, weak(ScopeParent, Info)):- Info<>strong, not bind_scope(Scope, Context, Info), bind_scope(ScopeParent, Context, Info), cfa_call(ScopeParent, FnCurrent), cfa_parent(Scope, function(FnCurrent)).


	%make decisions
	%%%bind_scope_decision(Scope, loop(Subject), Scope):- cfa_contextloop(Scope, Subject), demand_dependency(loop(Subject), X), bind_scope(Scope, X, strong).*
	%%%bind_scope_decision(Scope, loop(Subject), Scope):- cfa_call(Scope, FnChild), bind_function_demand(FnChild, loop(Subject)), demand_dependency(loop(Subject), X), bind_scope(Scope, X, strong).

	%on-site decision
	% ASSERT: ON-SITE DECISION SHOULD BE FIRST CLASS (checks at least one specialization exists)
	bind_scope_decision(Scope, Subject, Resolution):- bind_scope(Scope, Resolution, strong), Subject = specialization(Fn, Scope),
	cfa_call(Scope, Fn),
	cfa_function_specializations(Fn, Resolution).

	-bind_scope_decision(ScopeSource, Subject, ):- bind_scope(Scope, Resolution, weak(ScopeSource)), Subject = specialization(Fn, Scope), cfa_call(Scope, Fn), cfa_function_specializations(Fn, Resolution).
	+bind_scope_decision(ScopeSource, Subject, Resolution):- bind_scope(Scope, Resolution, weak(ScopeSource)), Subject = specialization(Fn, Scope), cfa_call(Scope, Fn), cfa_function_specializations(Fn, Resolution).
	bind_scope_decision(ScopeSource, Subject, resolution_dependency(Resolution, Dependency)):- bind_scope(Scope, Resolution, weak(ScopeSource, Dependency)), Subject = specialization(Fn, Scope), cfa_call(Scope, Fn), cfa_function_specializations(Fn, Resolution).

	%dependent decisions
	bind_scope_demand(Scope, dependency(Subject, Scope)) :- bind_scope_decision(Scope, Subject, resolution_dependency(_, Dependency)).
	bind_scope_demand(ScopeSource, dependency(Subject, ScopeSource)) :- Dependency = weak(ScopeSource, DependencyTail), bind_scope_demand(Scope, dependency(Subject, Scope)), scope_dependencies(dependency(Subject, Scope), Dependency).

	bind_scope_decision(ScopeSource, dependency(Subject, Scope), Dependency) :- Dependency = weak(ScopeSource), bind_scope_demand(Scope, dependency(Subject, Scope)), scope_dependencies(dependency(Subject, Scope), Dependency).
	bind_scope_decision(ScopeSource, dependency(Subject, Scope), resolution_dependency(Dependency, DependencyTail)) :- Dependency = weak(ScopeSource, DependencyTail), bind_scope_demand(Scope, dependency(Subject, Scope)), scope_dependencies(dependency(Subject, Scope), Dependency).


	%dependent decision helpers:
	scope_dependencies(dependency(Subject, Scope), Dependency) :- bind_scope_decision(Scope, Subject, resolution_dependency(_, Dependency)).
	scope_dependencies(dependency(Subject, ScopeSource), DependencyTail) :- Dependency = weak(ScopeSource, DependencyTail), bind_scope_demand(Scope, dependency(Subject, Scope)), scope_dependencies(dependency(Subject, Scope), Dependency).

	%on-site demand
	% ASSERT: ON-SITE DEMAND SHOULD BE dependent OF on-site decision (check there are no specializations AT ALL)
	%%%bind_scope_demand(Scope, Subject):- cfa_contextloop(Scope, Subject), not bind_scope_decision(Scope, loop(Subject), _).
	bind_scope_demand(Scope, Subject):- Subject = specialization(FnCallee, Scope),
	cfa_call(Scope, FnCallee),
	cfa_function_specializations(FnCallee, _),
	not bind_scope_decision(Scope, Subject, _).

	%nested scope demand propagation
	%ASSERT: NO DECISION CHECKS. because decisions linked to a leaf(function execution sites) scopes
	bind_scope_demand(Scope, Subject):- bind_scope_demand(ScopeChild, Subject), cfa_parent(ScopeChild, scope(Scope)).
	bind_function_demand(Fn, Subject):- bind_scope_demand(Scope, Subject), cfa_parent(Scope, function(Fn)).

	%inter-function propagation demand
	bind_scope_demand(Scope, Subject):- cfa_call(Scope, FnChild), bind_function_demand(FnChild, Subject), not bind_scope_decision(Scope, Subject, _).
	diff --git a/cpp/src/analysis/dfagraph.cpp b/cpp/src/analysis/dfagraph.cpp
	index b63efb6..8abf8e7 100644
	--- a/cpp/src/analysis/dfagraph.cpp
	+++ b/cpp/src/analysis/dfagraph.cpp
	@@ -1,239 +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: 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 {
	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;
	}

	std::size_t operator()(const xreate::dfa::SymbolAnonymous& node) const noexcept
	{
	return 2 * node.id;
	}
	};
	}}

	std::size_t
	hash<xreate::dfa::SymbolNode>::operator()(xreate::dfa::SymbolNode const& s) const noexcept
	{
	return boost::apply_visitor(xreate::dfa::VisitorNodeHash(), s);
	}

	namespace xreate { namespace dfa {

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

	+//NOTE: Any changes should be reflected in ParseImplAtom<SymbolPacked>
	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 formatSymbNamed("s(%1%,%2%,%3%)");
	+ 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 formatArgs;
	boost::format formatInstance("dfa_callinstance(%1%, %2%).");
	boost::format formatRet("dfa_callret(%1%, %2%).");

	switch (type) {
	case WEAK:
	formatArgs = boost::format("weak(dfa_callargs(%1%, %2%, %3%)).");
	break;

	case STRONG:
	formatArgs = boost::format("weak(dfa_callargs(%1%, %2%, %3%)).\ndfa_callargs(%1%, %2%, %3%).");
	break;
	}

	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);

	if (boost::get<SymbolPacked>(&node)){
	__usedSymbols.insert(node);
	}

	if (boost::get<SymbolPacked>(&subnode)){
	__usedSymbols.insert(node);
	}
	}

	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 (boost::get<SymbolAnonymous>(&it->second)){
	if (!__usedSymbols.count(it->second)){
	printDependency(output, it->second, nodeDependent);
	continue;
	}
	}

	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()) __usedSymbols.insert(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& symbFormal, const SymbolNode& symbActual){
	__usedSymbols.insert(symbFormal); __usedSymbols.insert(symbActual);

	boost::format formatAlias("dfa_alias(%1%, %2%).");
	__output << formatAlias
	% boost::apply_visitor(VisitorFormatSymbol(), symbFormal)
	% boost::apply_visitor(VisitorFormatSymbol(), symbActual)
	<< endl;
	}

	void
	DFAGraph::printWeakAlias(const SymbolNode& symbFormal, const SymbolNode& symbActual){
	__usedSymbols.insert(symbFormal); __usedSymbols.insert(symbActual);

	boost::format formatAlias("weak(dfa_alias(%1%, %2%)).");
	__output << formatAlias
	% boost::apply_visitor(VisitorFormatSymbol(), symbFormal)
	% boost::apply_visitor(VisitorFormatSymbol(), symbActual)
	<< endl;
	}

	void
	DFAGraph::printFunctionRet(ManagedFnPtr function, const SymbolNode& symbolRet){
	boost::format formatRet("dfa_fnret(%1%, %2%).");
	__usedSymbols.insert(symbolRet);

	__output << formatRet
	% function->getName()
	% boost::apply_visitor(VisitorFormatSymbol(), symbolRet)
	<< endl;

	__roots.insert(symbolRet);
	}

	void
	DFAGraph::addCallInstance(DFACallInstance&& instance){
	__usedSymbols.insert(instance.retActual);
	for(const auto arg: instance.args){
	__usedSymbols.insert(SymbolNode(arg.first));
	__usedSymbols.insert(arg.second);
	}

	__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::printSymbols(ClaspLayer* clasp){
	boost::format formatHint("shint(%1%, \"%2%\").");

	for (const SymbolNode& node : __usedSymbols) {
	__output << "v(" << boost::apply_visitor(VisitorFormatSymbol(), node) << "). ";

	if (const SymbolPacked* symbol = boost::get<SymbolPacked>(&node)){
	__output << formatHint % boost::apply_visitor(VisitorFormatSymbol(), node) % clasp->getHintForPackedSymbol(*symbol);
	}
	__output << endl;
	}
	}

	}} //end of namespace xreate::dfa
	diff --git a/cpp/src/ast.cpp b/cpp/src/ast.cpp
	index 8d54aa7..9a5276a 100644
	--- a/cpp/src/ast.cpp
	+++ b/cpp/src/ast.cpp
	@@ -1,979 +1,977 @@
	/* 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::LIST:
	{
	assert(t.__operands.size() == 1);

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

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

	return ExpandedType(move(typNew));
	};

	case TypeOperator::VARIANT:
	{
	std::vector<TypeAnnotation>&& packOperands = expandOperands(t.__operands);
	auto typNew = TypeAnnotation(TypeOperator::VARIANT, 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)) {
	+ if (signatures.count(t)) {
	return ExpandedType(TypeAnnotation(TypeOperator::LINK, {t}));
	}
	- signatures[alias].emplace(t);
	- */
	+ signatures.emplace(t, signatures.size());
	+
	+ std::string alias = t.__valueCustom;

	//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::LIST_NAMED);

	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::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::LIST,{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 && __state != INVALID);
	}

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

	namespace details { namespace inconsistent {

	AST::AST() {
	Attachments::init<versions::VariableVersion>();
	Attachments::init<IdentifierSymbol>();
	Attachments::init<SymbolAlias>();
	Attachments::init<TypeInferred>();
	}

	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<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);
	}

	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;
	}

	const Expression&
	CodeScope::getBody() const{
	return __declarations.at(ScopedSymbol::RetSymbol);
	}

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

	const Expression&
	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/compilation/advancedinstructions.cpp b/cpp/src/compilation/advancedinstructions.cpp
	index 01dd15d..b0f9f8f 100644
	--- a/cpp/src/compilation/advancedinstructions.cpp
	+++ b/cpp/src/compilation/advancedinstructions.cpp
	@@ -1,457 +1,456 @@
	/* 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/advancedinstructions.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;

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

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

	//initialization
	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*
	AdvancedInstructions::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*
	AdvancedInstructions::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*
	AdvancedInstructions::compileFold(const Expression& fold, const std::string& hintRetVar) {
	EXPAND_CONTEXT
	assert(fold.op == Operator::FOLD);

	//initialization:
	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*
	AdvancedInstructions::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*
	AdvancedInstructions::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));
	+ assert(builder.GetInsertBlock() == scope->currentBlockRaw);

	+ //initialization:
	llvm::BasicBlock *blockEpilog = 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::BasicBlock *blockProlog = builder.GetInsertBlock();

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

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

	- builder.SetInsertPoint(blockProlog);
	+ builder.SetInsertPoint(scope->currentBlockRaw);
	llvm->builder.CreateCondBr(cond, blockTrue, blockFalse);
	-
	+
	builder.SetInsertPoint(blockEpilog);
	llvm::PHINode *ret = builder.CreatePHI(resultTrue->getType(), 2, NAME("if"));

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

	return ret;
	}

	//TODO Switch: default variant no needed when all possible conditions are considered
	llvm::Value*
	AdvancedInstructions::compileSwitch(const Expression& exprSwitch, const std::string& hintRetVar) {
	EXPAND_CONTEXT
	UNUSED(function);
	AST* root = context.pass->man->root;
	llvm::IRBuilder<>& builder = llvm->builder;
	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::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;
	}

	llvm::Value*
	AdvancedInstructions::compileSwitchVariant(const Expression& exprSwitch, const std::string& hintRetVar) {
	EXPAND_CONTEXT
	UNUSED(function);
	AST* root = context.pass->man->root;
	llvm::IRBuilder<>& builder = llvm->builder;
	llvm::Type* typI8= llvm::Type::getInt8Ty(llvm::getGlobalContext());
	const ExpandedType& typVariant = root->getType(exprSwitch.operands.at(0));
	llvm::Type* typVariantRaw = llvm->toLLVMType(typVariant);

	assert(typVariant->__operands.size() == exprSwitch.operands.size() - 1 && "Ill-formed Switch Variant");

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

	builder.SetInsertPoint(blockProlog);
	llvm::Value * conditionSwitchRaw = scope->process(exprSwitch.operands.at(0));
	llvm::Value* idRaw = builder.CreateExtractValue(conditionSwitchRaw, llvm::ArrayRef<unsigned>({0}));

	//Dereference preparation
	const bool flagDoDerefence = llvm::cast<llvm::StructType>(typVariantRaw)->getStructNumElements() > 1;
	llvm::Value* addrAsStorage = nullptr;
	if (flagDoDerefence){
	llvm::Type* typStorageRaw = llvm::cast<llvm::StructType>(typVariantRaw)->getElementType(1);
	llvm::Value* storageRaw = builder.CreateExtractValue(conditionSwitchRaw, llvm::ArrayRef<unsigned>({1}));
	addrAsStorage = llvm->builder.CreateAlloca(typStorageRaw);
	llvm->builder.CreateStore(storageRaw, addrAsStorage);
	}

	llvm::SwitchInst * instructionSwitch = builder.CreateSwitch(idRaw, nullptr, casesCount);
	llvm::BasicBlock* blockDefaultUndefined;
	std::list<CodeScope*>::const_iterator scopeCaseIt = exprSwitch.blocks.begin();
	for (int instancesSize = exprSwitch.operands.size()-1, instId = 0; instId < instancesSize; ++instId) {
	llvm::BasicBlock *blockCase = llvm::BasicBlock::Create(llvm::getGlobalContext(), "case" + std::to_string(instId), function->raw);
	builder.SetInsertPoint(blockCase);
	ICodeScopeUnit* unitCase = function->getScopeUnit(*scopeCaseIt);

	//Actual variant Derefence
	if (flagDoDerefence) {
	assert(exprSwitch.bindings.size() && "Switch condition alias not found");
	string identCondition = exprSwitch.bindings.front();
	const ExpandedType& instType = ExpandedType(typVariant->__operands.at(instId));
	llvm::Type* instTypeRaw = llvm->toLLVMType(instType);
	llvm::Value* addrAsInst = llvm->builder.CreateBitOrPointerCast(addrAsStorage, instTypeRaw->getPointerTo());
	llvm::Value* instRaw = llvm->builder.CreateLoad(instTypeRaw, addrAsInst);
	const Symbol& identSymb = unitCase->bindArg(instRaw, move(identCondition));
	Attachments::put<TypeInferred>(identSymb, instType);
	}

	llvm::Value* resultCase = function->getScopeUnit(*scopeCaseIt)->compile();
	builder.CreateBr(blockEpilog);

	ret->addIncoming(resultCase, blockDefaultUndefined = builder.GetInsertBlock());
	builder.SetInsertPoint(blockProlog);
	instructionSwitch->addCase(dyn_cast<llvm::ConstantInt>(llvm::ConstantInt::get(typI8, exprSwitch.operands.at(instId+1).getValueDouble())), blockCase);
	++scopeCaseIt;
	}

	instructionSwitch->setDefaultDest(blockDefaultUndefined);
	builder.SetInsertPoint(blockEpilog);
	return ret;
	}

	//TODO recognize cases to make const arrays/stored in global mem/stack alloced.
	llvm::Value*
	AdvancedInstructions::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::LIST);
	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*
	AdvancedInstructions::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/polymorphcompiler.h b/cpp/src/compilation/polymorphcompiler.h
	index fcc7382..1d61e1d 100644
	--- a/cpp/src/compilation/polymorphcompiler.h
	+++ b/cpp/src/compilation/polymorphcompiler.h
	@@ -1,55 +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/.
	*
	* 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(const CodeScope* const codeScope, compilation::IFunctionUnit* f, CompilePass* compilePass)
	: Parent(codeScope, f, compilePass) {}

	protected:
	compilation::ICallStatement* findFunction(const Expression& opCall) override {

	//Check does invocation require guards
	const std::string& nameCallee = opCall.getValueString();
	const std::list<ManagedFnPtr>& specializations = Parent::pass->man->root->getFunctionSpecializations(nameCallee);
	+
	+ //Extern function
	+ if (specializations.size() == 0){
	+ return Parent::findFunction(opCall);
	+ }
	+
	+ //No other specializations. Check if it has no guard
	if (specializations.size() == 1){
	if (!specializations.front()->guard.isValid()) {
	return Parent::findFunction(opCall);
	}
	}

	+ //TODO There are overlapping guards and contexts. For now, skip if context found.
	+ if (specializations.front()->guardContext.isValid()){
	+ return Parent::findFunction(opCall);
	+ }
	+
	+ //Several specializations
	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) && "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/tests/context.cpp b/cpp/tests/context.cpp
	index 942d862..3581303 100644
	--- a/cpp/tests/context.cpp
	+++ b/cpp/tests/context.cpp
	@@ -1,497 +1,497 @@
	/* Any copyright is dedicated to the Public Domain.
	* http://creativecommons.org/publicdomain/zero/1.0/
	*
	* frame-context.cpp
	*
	* Created on: Dec 3, 2015
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	#include "xreatemanager.h"
	#include "query/context.h"

	#include "gtest/gtest.h"
	#include <iostream>
	#include <boost/scoped_ptr.hpp>

	using namespace xreate;
	using namespace xreate::context;

	TEST(Context, frame_Context1){
	details::tier1::XreateManager* man = details::tier1::XreateManager::prepare(
	" import raw (\"core/control-context.lp\").\n"
	" compute = function::int {\n"
	" 0\n"
	" }\n"

	" computeFast = function:: int {\n"
	" context:: computation(fast).\n"

	" compute()\n"
	" }\n"

	" computePrecisely = function:: int {\n"
	" context:: computation(precise). \n"

	" compute()\n"
	" }\n"

	"test = function(cmnd:: int):: int; entry {\n"
	" context:: arithmetic(iee754). \n"

	" if (cmnd > 0)::int {computePrecisely()} else {computeFast()} \n"
	"}\n"
	);

	ContextQuery* query = (ContextQuery*) man->clasp->registerQuery(new ContextQuery(), QueryId::ContextQuery);
	man->analyse();

	CodeScope* scopeTestC = man->root->findFunction("compute")->getEntryScope();
	const Domain& context = query->getContext(man->clasp->pack(scopeTestC));

	int contextSize = context.size();
	- EXPECT_EQ(1, contextSize); //arithmetic(iee754)
	+ EXPECT_EQ(1, contextSize);
	}

	TEST(Context, contextAsRequirementSuccessful1){
	XreateManager* man = XreateManager::prepare(
	" import raw (\"core/control-context.lp\").\n"

	" case context::safe {\n"
	" funcSensitive = function::int {\n"
	" 0\n"
	" }}\n"

	" test = function:: int; entry {\n"
	" context:: safe; test.\n"

	" funcSensitive()\n"
	" }\n"
	);

	int (main)() = (int ()()) man->run();
	ASSERT_EQ(0, main());
	}

	TEST(Context, contextAsRequirementFailed){
	XreateManager* man = XreateManager::prepare(
	" import raw (\"core/control-context.lp\").\n"

	" case context::safe {\n"
	" funcSensitive = function::int {\n"
	" 0\n"
	" }}\n"

	" test = function:: int; entry {\n"
	" context:: non_safe; test.\n"

	" funcSensitive()\n"
	" }\n"
	);

	ASSERT_DEATH(man->run(), "findFunction");
	}

	TEST(Context, ContextPropagationNested){
	XreateManager* man = XreateManager::prepare(
	" import raw (\"core/control-context.lp\").\n"

	" case context::safe {\n"
	" square = function(x:: int) ::int {\n"
	" x * x\n"
	" }}\n"

	" test = function:: int; entry {\n"
	" context:: safe; test.\n"

	" range = [1..10]:: [int]. \n"
	" loop fold(range->x::int, 0->acc):: int { \n"
	" acc + square(x) \n"
	" } \n"
	" }\n"
	);

	int (main)() = (int ()()) man->run();
	ASSERT_EQ(385, main());
	}

	TEST(Context, ContextPropagationNestedInterfunction){

	XreateManager* man = XreateManager::prepare(
	" import raw (\"core/control-context.lp\").\n"
	" case context::toMillimeters {\n"
	" convertConcrete = function(source:: num)::num {\n"
	" 10 * source \n"
	" }\n"
	" }\n"

	" case context::toInches {\n"
	" convertConcrete = function(source:: num)::num {\n"
	" 2 * source \n"
	" }\n"
	" }\n"

	"convert= function(source:: num):: num { \n"
	"convertConcrete(source) \n"
	"} \n"

	"test = function(source:: num):: num; entry {\n"
	" context:: toMillimeters.\n"
	" convert(1)\n"
	"}\n" );

	int (main)(int) = (int ()(int)) man->run();
	ASSERT_EQ(10, main(1));
	}

	TEST(Context, full_ContextBasedFunctionSpecialization){

	XreateManager* man = XreateManager::prepare(
	" import raw (\"core/control-context.lp\").\n"
	" case context::toMillimeters {\n"
	" convert = function(source:: num)::num {\n"
	" 10 * source \n"
	" }\n"
	" }\n"

	" case context::toInches {\n"
	" convert = function(source:: num)::num {\n"
	" 2 * source \n"
	" }\n"
	" }\n"

	"test = function(vrnt:: int)::int; entry {\n"
	" switch(vrnt):: int\n"
	" case (0) {\n"
	" context:: toMillimeters.\n"
	" convert(1)\n"
	" }\n"
	"\n"
	" case (1) {\n"
	" context:: toInches.\n"
	" convert(1)\n"
	" }\n"
	" case default {0}\n"
	" }" );

	int (main)(int) = (int ()(int)) man->run();
	ASSERT_EQ(10, main(0));
	ASSERT_EQ(2, main(1));
	}

	TEST(Context, full_RuleContext){
	/*
	"rule context:: childs(Child)\n"
	" case artefact(Item)\n"
	" {\n"
	" artefact_depends(Item, Child)\n"
	" }";
	*/

	XreateManager* man = XreateManager::prepare(
	" import raw (\"core/control-context.lp\").\n"
	" case context:: toMilli {\n"
	" convert = function(length::int)::int{\n"
	" 10 * length\n"
	" }\n"
	" }\n"
	"\n"
	" case context:: toCenti {\n"
	" convert = function(length::int)::int{\n"
	" length\n"
	" }\n"
	" }\n"
	"\n"
	" main=function::int; entry {\n"
	" context:: output(milli).\n"
	"\n"
	" rule context::toMilli\n"
	" case (output(milli)) {truth}\n"
	"\n"
	" convert(1)\n"
	" }" );

	man->clasp->addRawScript("truth.");
	int (entry)() = (int ()()) man->run();
	ASSERT_EQ(10, entry());
	}

	TEST(Context, full_InheritedRuleContext){
	XreateManager* man = XreateManager::prepare(
	" import raw (\"core/control-context.lp\"). \n"

	" case context:: toMilli {\n"
	" convert = function(length::int)::int{\n"
	" 10 * length\n"
	" }\n"
	" }\n"

	" case context:: toCenti {\n"
	" convert = function(length::int)::int{\n"
	" length\n"
	" }\n"
	" }\n"
	"\n"

	"main = function(comm:: num)::num; entry{\n"
	" rule context::X case (output(X)) {truth}\n"
	"\n"
	" switch (comm)::num \n"
	" case (0) {\n"
	" context:: output(toMilli).\n"
	" convert(1)\n"
	" }\n"
	" case default {\n"
	" context:: output(toCenti).\n"
	" convert(1)\n"
	" }\n"
	" }");

	man->clasp->addRawScript("truth.");
	int (entry)(int) = (int ()(int)) man->run();
	ASSERT_EQ(10, entry(0));
	ASSERT_EQ(1, entry(1));
	}



	TEST(Context, full_LateContext){
	details::tier1::XreateManager* man = details::tier1::XreateManager::prepare(
	"import raw (\"core/control-context.lp\").\n"

	" convert = function(length:: num)::num{\n"
	" 0\n"
	" }\n"

	"case context:: milli {\n"
	" convert = function(length:: num)::num{\n"
	" 1000 * length\n"
	" }\n"
	"}\n"
	"\n"
	"case context:: centi {\n"
	" convert = function(length:: num)::num{\n"
	" 100 * length\n"
	" }\n"
	"}\n"
	"\n"
	"calculate = function(length:: num)::num {\n"
	" convert(length)\n"
	"}\n"
	"\n"
	"main = function(com:: num):: num; entry {\n"
	" switch (com):: num \n"
	" case (0) {\n"
	" context:: milli.\n"
	" calculate(1)\n"
	" }\n"
	"\n"
	" case default{\n"
	" context:: centi. \n"
	" calculate(1)\n"
	" }\n"
	"}");

	man->analyse();
	ContextQuery* queryContext = reinterpret_cast<ContextQuery*>(man->clasp->getQuery(QueryId::ContextQuery));
	const Expression& exprSwitch = man->root->findFunction("main")->__entry->getBody();
	const CodeScope* blockDefault = man->root->findFunction("main")->__entry->getBody().operands.at(1).blocks.front();
	ScopePacked blockDefaultId = man->clasp->pack(blockDefault);
	const Domain& domDefault = queryContext->getContext(blockDefaultId);
	ASSERT_EQ(1, domDefault.count(Expression(Atom<Identifier_t>("centi"))));

	std::list<ManagedFnPtr> variants = man->root->getFunctionSpecializations("convert");
	for (ManagedFnPtr f: variants){
	const Expression guard = f->guardContext;
	bool result = (guard.getValueString() == "centi" \|\| guard.getValueString() == "milli" \|\| !guard.isValid());
	ASSERT_TRUE(result);
	}

	const FunctionDemand& demMain = queryContext->getFunctionDemand("main");
	ASSERT_EQ(0, demMain.size());

	const FunctionDemand& demCalculate = queryContext->getFunctionDemand("calculate");
	ASSERT_EQ(1, demCalculate.size());

	int (entry)(int) = (int ()(int)) man->run();
	ASSERT_EQ(1000, entry(0));
	ASSERT_EQ(100, entry(1));
	}

	TEST(Context, loopContextExists){
	XreateManager* man = XreateManager::prepare (
	"import raw (\"core/control-context.lp\").\n"

	"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->run();
	}

	TEST(Context, pathDependentContext){
	std::string program =
	R"CODE(
	import raw("core/control-context.lp").

	convert = function(length:: num) :: num {
	0
	}

	case context:: convert(milli, meters) {
	convert = function(length:: num) :: num {
	1000 * length
	}
	}

	case context:: convert(centi, meters) {
	convert = function(length:: num) :: num {
	100 * length
	}
	}

	case context:: convert(centi, kilo) {
	convert = function(length:: num) :: num {
	100000 * length
	}
	}

	case context:: convert(milli, kilo) {
	convert = function(length:: num) :: num {
	1000000 * length
	}
	}

	main = function(value::num, unitsInput::num, unitsOutput::num)::num; entry{
	switch (unitsInput)::num
	case (0) {
	test_fromMilli(value, unitsOutput)
	}
	case (1) {
	test_fromCenti(value, unitsOutput)
	}

	case default {0}
	}

	test_fromCenti = function(value::num, output::num)::num{
	context:: input(centi).

	switch(output):: num
	case (0) {
	toMeters(value)
	}

	case (1) {
	toKilo(value)
	}

	case default {0}
	}

	test_fromMilli = function(value::num, output::num)::num{
	context:: input(milli).

	switch(output):: num
	case (0) {
	toMeters(value)
	}

	case (1) {
	toKilo(value)
	}

	case default {0}
	}

	toMeters = function(value::num)::num {
	rule context:: convert(X, meters) case (input(X)) {truth}

	doConvert(value)
	}

	toKilo = function(value::num)::num {
	rule context:: convert(X, kilo) case (input(X)) {truth}

	doConvert(value)
	}

	doConvert = function(value::num)::num{
	convert(value)
	})CODE";

	boost::scoped_ptr<details::tier1::XreateManager> man(details::tier1::XreateManager::prepare(move(program)));
	man->clasp->addRawScript("truth.");
	man->analyse();

	int (test)(int, int, int) = (int ()(int, int, int))man->run();

	enum {INPUT_MILLI, INPUT_CENTI};
	enum {OUTPUT_METERS, OUTPUT_KILO};

	ASSERT_EQ(1000000, test(1, INPUT_MILLI, OUTPUT_KILO));
	ASSERT_EQ(200, test(2, INPUT_CENTI, OUTPUT_METERS));
	}

	//TODO recover context loop and enable the test
	TEST(Context, DISABLED_full_LoopContext){
	XreateManager* man = XreateManager::prepare(
	" import raw (\"core/control-context.lp\")\n"
	" case context:: a {\n"
	" print = function:: string {\n"
	" \"a\"\n"
	" }}\n"
	"\n"
	" case context:: b {\n"
	" print = function:: string {\n"
	" \"b\"\n"
	" }}\n"
	"\n"
	" case context:: c {\n"
	" print = function:: string {\n"
	" \"c\"\n"
	" }}\n"
	"\n"
	" case context:: d {\n"
	" print = function:: string {\n"
	" \"d\"\n"
	" }}\n"
	"\n"
	" start = function(command::int)::string; entry {\n"
	" switch (command) :: string \n"
	" case (0) {\n"
	" context:: print(a); print(b); print(d).\n"
	"\n"
	" loop context (\"print\") {\n"
	" print()\n"
	" }\n"
	" }\n"
	"\n"
	" case default {\n"
	" context:: print(c).\n"
	" loop context (\"print\") {\n"
	" print()\n"
	" }\n"
	" }\n"
	" }");


	char* (main)(int) =(char (*)(int)) man->run();
	ASSERT_STREQ("c", main(1));
	ASSERT_STREQ("a", main(0));
	}
	diff --git a/cpp/tests/polymorph.cpp b/cpp/tests/polymorph.cpp
	index 07f1a41..bebb948 100644
	--- a/cpp/tests/polymorph.cpp
	+++ b/cpp/tests/polymorph.cpp
	@@ -1,61 +1,63 @@
	/* Any copyright is dedicated to the Public Domain.
	* http://creativecommons.org/publicdomain/zero/1.0/
	*
	* polymorph.cpp
	*
	* Author: pgess <v.melnychenko@xreate.org>
	* Created on October 11, 2017, 8:37 PM
	*/

	#include "xreatemanager.h"
	#include "ast.h"
	#include <list>
	#include "gtest/gtest.h"

	using namespace std;
	using namespace xreate;
	using namespace std;
	TEST(Polymorphs, ast1) {
	xreate::XreateManager* man = xreate::XreateManager::prepare(
	R"CODE(
	guard:: a {
	test = function:: int {0}
	}

	guard:: b {
	test = function:: int {1}
	}

	main = function:: int; entry { test() }

	)CODE");

	const std::list<ManagedFnPtr>& specs = man->root->getFunctionSpecializations("test");
	ASSERT_EQ(2, specs.size());

	auto itSpecs = specs.begin();
	ASSERT_EQ("a", (*itSpecs)->guard.getValueString());
	itSpecs++;
	ASSERT_EQ("b", (*itSpecs)->guard.getValueString());
	}

	TEST(Polymorphs, call1) {
	xreate::details::tier1::XreateManager* man = xreate::details::tier1::XreateManager::prepare(
	R"CODE(
	+ import raw("scripts/dfa/polymorphism.lp").
	+
	guard:: a {
	test = function:: int {0}
	}

	guard:: b {
	test = function:: int {1}
	}

	- main = function:: int; entry { test()::int; callguard(b) }
	+ main = function:: int; entry { test()::int; callguard(b);dfa_polym(ret)}

	)CODE");

	man->analyse();
	int (main)() = (int ()()) man->run();

	ASSERT_EQ(1, main());
	}
	\ No newline at end of file
	diff --git a/scripts/dfa/polymorphism.lp b/scripts/dfa/polymorphism.lp
	index a3bbcff..c0b39b7 100644
	--- a/scripts/dfa/polymorphism.lp
	+++ b/scripts/dfa/polymorphism.lp
	@@ -1,15 +1,16 @@
	%INPUT
	% bind(Symb, callguard(..)) - binded Ann
	+%
	%OUTPUT
	% dfa_callguard(..) - ready for processing

	dfa_callguard(Instance, Guard):-
	bind(ArgActual, callguard(Guard));
	weak(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)).

No OneTemporaryActions

File Metadata

View Options

Event Timeline

No OneTemporary
Actions