No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sat, Mar 14, 4:31 AM

View Options

	diff --git a/config/default.json b/config/default.json
	index a73a43d..e7f99d6 100644
	--- a/config/default.json
	+++ b/config/default.json
	@@ -1,73 +1,74 @@
	{
	"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",

	"transcend": {
	"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": "latereasoning",
	+ "template": "intrinsic-query",

	"templates": {
	"current-fix":"*",
	"default": "-Adhoc.:Containers.*:Compilation.full_IFStatementWithVariantType:Types.full_VariantType_Switch1:Context.full_LateContext:Context.pathDependentContext:CFA.testLoopContextExists",
	"ast": "AST.*",
	"effects": "Effects.*",
	"basic": "Attachments.*",
	"compilation": "Compilation.*-Compilation.full_IFStatementWithVariantType",
	"communication": "Communication.*",
	"cfa": "CFA.*",
	"containers": "Containers.*",
	"dfa": "DFA.*",
	"diagnostic": "Diagnostic.*",
	"dsl": "Association.:Interpretation.",
	"exploitation": "Exploitation.*",
	"ExpressionSerializer": "ExpressionSerializer.*",
	"externc": "InterfaceExternC.*",
	"loops": "Loop.*",
	"latereasoning": "LateReasoning.Compilation2",
	"modules": "Modules.*",
	"polymorphs": "Polymorphs.*",
	+ "intrinsic-query": "Types.SlaveTypes:Association.TypedQuery",
	"types": "Types.*",
	"virtualization": "Virtualization.test2",
	"vendorsAPI/clang": "ClangAPI.*",
	"vendorsAPI/xml2": "libxml2*"
	}
	}
	}
	diff --git a/cpp/src/CMakeLists.txt b/cpp/src/CMakeLists.txt
	index f03ed0e..8fd4295 100644
	--- a/cpp/src/CMakeLists.txt
	+++ b/cpp/src/CMakeLists.txt
	@@ -1,231 +1,232 @@
	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(STATUS "LLVM DEFS: " ${LLVM_DEFINITIONS})

	execute_process(
	COMMAND llvm-config --libs
	OUTPUT_VARIABLE LLVM_LIBS
	OUTPUT_STRIP_TRAILING_WHITESPACE)
	message(STATUS "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
	- compilation/latereasoning.cpp
	+ compilation/interpretation-instructions.cpp
	analysis/typeinference.cpp
	+ compilation/latereasoning.cpp
	aux/latereasoning.cpp
	xreatemanager.cpp
	transcendlayer.cpp
	analysis/dfagraph.cpp
	analysis/DominatorsTreeAnalysisProvider.cpp
	llvmlayer.cpp
	ExternLayer.cpp
	pass/compilepass.cpp
	query/polymorph.cpp
	analysis/utils.cpp
	pass/dfapass.cpp
	compilation/targetinterpretation.cpp
	pass/interpretationpass.cpp
	ast.cpp
	aux/xreatemanager-decorators.cpp
	compilation/operators.cpp
	compilation/transformations.cpp
	compilation/transformersaturation.cpp
	pass/versionspass.cpp
	attachments.cpp
	analysis/cfagraph.cpp
	compilation/containers.cpp
	compilation/advancedinstructions.cpp
	utils.cpp
	pass/abstractpass.cpp
	pass/cfapass.cpp
	contextrule.cpp
	query/containers.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/typeinference.cpp b/cpp/src/analysis/typeinference.cpp
	index 38b3d5d..8d3992c 100644
	--- a/cpp/src/analysis/typeinference.cpp
	+++ b/cpp/src/analysis/typeinference.cpp
	@@ -1,93 +1,185 @@
	/* 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"
	#include "transcendlayer.h"

	using namespace std;

	-namespace xreate {namespace typeinference {
	+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);
	- }
	+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()){
	+ 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);
	+getType(const Expression& expression, const AST& ast) {
	+ if(expression.type.isValid()) {
	+ return ast.expandType(expression.type);
	}

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

	- if (Attachments::exists<TypeInferred>(expression)){
	+ if(Attachments::exists<TypeInferred>(expression)) {
	return Attachments::get<TypeInferred>(expression);
	}

	- if(expression.__state==Expression::NUMBER){
	- return ExpandedType (TypeAnnotation(TypePrimitive::I32));
	+ if(expression.__state == Expression::NUMBER) {
	+ return ExpandedType(TypeAnnotation(TypePrimitive::I32));
	}


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

	-std::vector<Expression>
	-getSlaveVariants(ExpandedType t, const TranscendLayer* transcend){
	+TypeAnnotation collapseColumn(const std::list<Gringo::Symbol>& symbols);
	+
	+TypeAnnotation
	+collapseFnGroup(const std::list<Gringo::Symbol>& symbols) {
	+ Gringo::Symbol symbolAny = symbols.front();
	+ size_t operandsCount = symbolAny.args().size;
	+
	+ TypeAnnotation resultT;
	+ resultT.__operands.reserve(operandsCount);
	+
	+ for(size_t operandId = 0; operandId < operandsCount; ++operandId) {
	+ std::list<Gringo::Symbol> column;
	+
	+ for(const Gringo::Symbol& row : symbols) {
	+ column.push_back(row.args()[operandId]);
	+ }
	+
	+ TypeAnnotation operandT = collapseColumn(column);
	+ resultT.__operands.push_back(operandT);
	+ }
	+
	+ if(resultT.__operands.size() == 1) {
	+ return resultT.__operands.front();
	+ }
	+
	+ if(resultT.__operands.size() > 1) {
	+ resultT.__operator = TypeOperator::LIST_NAMED;
	+ return resultT;
	+ }
	+
	+ return resultT;
	+}
	+
	+TypeAnnotation
	+collapseColumn(const std::list<Gringo::Symbol>& symbols) {
	+ TypeAnnotation resultT;
	+ if(!symbols.size()) return resultT;
	+
	+ Gringo::Symbol symbolAny = symbols.front();
	+
	+ switch(symbolAny.type()) {
	+ case Gringo::SymbolType::Num:
	+ {
	+ return TypeAnnotation(TypePrimitive::Num);
	+ }
	+
	+ case Gringo::SymbolType::Str:
	+ {
	+ return TypeAnnotation(TypePrimitive::String);
	+ }
	+
	+ case Gringo::SymbolType::Fun:
	+ {
	+ map<string, list < Gringo::Symbol>> fnGroups;
	+
	+ for(const Gringo::Symbol& row : symbols) {
	+ fnGroups[row.name().c_str()].push_back(row);
	+ }
	+
	+ TypeAnnotation resultT;
	+ resultT.__operands.reserve(fnGroups.size());
	+ resultT.bindings.reserve(fnGroups.size());
	+
	+ for(const auto& group : fnGroups) {
	+ if(!group.second.size()) continue;
	+
	+ TypeAnnotation variantT = collapseFnGroup(group.second);
	+ Gringo::Symbol symbolAny = group.second.front();
	+ string variantName = symbolAny.name().c_str();
	+ resultT.fields.push_back(variantName);
	+ resultT.__operands.push_back(variantT);
	+ }
	+
	+ resultT.__operator = TypeOperator::VARIANT;
	+ if(resultT.__operands.size() == 1) {
	+ return resultT.__operands.front();
	+ }
	+ return resultT;
	+ }
	+
	+ case Gringo::SymbolType::Inf:
	+ case Gringo::SymbolType::Special:
	+ case Gringo::SymbolType::Sup:
	+ {
	+ break;
	+ }
	+ }
	+
	+ assert(false);
	+ return TypeAnnotation();
	+}
	+
	+ExpandedType
	+dereferenceSlaveType(ExpandedType t, const TranscendLayer* transcend) {
	assert(t->__operator == TypeOperator::SLAVE);
	const string& domain = t->__valueCustom;
	StaticModel model = transcend->query(domain);
	+ if(!model.size()) return ExpandedType(TypeAnnotation());

	- vector<Expression> result;
	- result.reserve(model.size());
	- for(auto entry: model){
	- result.push_back(get<0>(TranscendLayer::parse<Expression>(entry.second)));
	+ std::list<Gringo::Symbol> symbols;
	+ for(auto row : model) {
	+ symbols.push_back(row.second);
	}
	-
	- return result;
	+ return ExpandedType(collapseFnGroup(symbols));
	}

	-} } //end of namespace xreate::typeinference
	+}
	+} //end of namespace xreate::typeinference
	diff --git a/cpp/src/analysis/typeinference.h b/cpp/src/analysis/typeinference.h
	index aa956a3..500fc17 100644
	--- a/cpp/src/analysis/typeinference.h
	+++ b/cpp/src/analysis/typeinference.h
	@@ -1,35 +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: typeinference.h
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on April 16, 2017, 10:17 AM
	*/

	#ifndef TYPEINFERENCE_H
	#define TYPEINFERENCE_H

	#include "ast.h"
	#include "llvm/IR/IRBuilder.h"

	-namespace llvm {
	- class Value;
	- class Type;
	+namespace llvm{
	+class Value;
	+class Type;
	};

	-namespace xreate {
	- class TranscendLayer;
	+namespace xreate{
	+class TranscendLayer;
	};

	-namespace xreate { namespace typeinference {
	-
	+namespace xreate{
	+namespace typeinference{
	+
	llvm::Value* doAutomaticTypeConversion(llvm::Value* source, llvm::Type* tyTarget, llvm::IRBuilder<>& builder);
	-ExpandedType getType(const Expression& expression, const AST& ast);
	-std::vector<Expression> getSlaveVariants(ExpandedType t, const TranscendLayer* transcend);
	+ExpandedType getType(const Expression& expression, const AST& ast);
	+ExpandedType dereferenceSlaveType(ExpandedType t, const TranscendLayer* transcend);

	-} }//namespace xreate::typeinference
	+}
	+}//namespace xreate::typeinference

	#endif /* TYPEINFERENCE_H */

	diff --git a/cpp/src/compilation/interpretation-instructions.cpp b/cpp/src/compilation/interpretation-instructions.cpp
	new file mode 100644
	index 0000000..97c2634
	--- /dev/null
	+++ b/cpp/src/compilation/interpretation-instructions.cpp
	@@ -0,0 +1,167 @@
	+/*
	+ * 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>
	+ * Created on June 15, 2018, 5:32 PM
	+ *
	+ */
	+
	+#include "compilation/interpretation-instructions.h"
	+#include "analysis/typeinference.h"
	+#include "transcendlayer.h"
	+#include "targets.h"
	+
	+using namespace std;
	+
	+namespace xreate{
	+namespace interpretation{
	+
	+Expression
	+IntrinsicQueryInstruction::representTransExpression(const Gringo::Symbol& atom, ExpandedType schemaT) {
	+ TranscendLayer* transcend = static_cast<TargetInterpretation*> (__scope->function->man)->pass->man->transcend;
	+
	+ switch(schemaT->__operator) {
	+ case TypeOperator::NONE:
	+ {
	+ switch(schemaT->__value) {
	+ case TypePrimitive::I8:
	+ case TypePrimitive::I32:
	+ case TypePrimitive::I64:
	+ case TypePrimitive::Num:
	+ case TypePrimitive::Int:
	+ {
	+ return Expression(Atom<Number_t>(atom.num()));
	+ }
	+
	+ case TypePrimitive::String:
	+ {
	+ return Expression(Atom<String_t>(atom.string().c_str()));
	+ }
	+
	+ case TypePrimitive::Invalid:
	+ case TypePrimitive::Bool:
	+ case TypePrimitive::Float:
	+ {
	+ assert(false);
	+ return Expression();
	+ }
	+ }
	+ break;
	+ }
	+
	+ case TypeOperator::SLAVE:
	+ {
	+ ExpandedType contentT = typeinference::dereferenceSlaveType(schemaT, transcend);
	+ return representTransExpression(atom, contentT);
	+ }
	+
	+ case TypeOperator::VARIANT:
	+ {
	+ map<string, int> dictVariants;
	+ for(size_t variantId = 0; variantId < schemaT->fields.size(); ++variantId) {
	+ dictVariants.emplace(schemaT->fields.at(variantId), variantId);
	+ }
	+
	+ string predicateName = atom.name().c_str();
	+ assert(dictVariants.count(predicateName));
	+
	+ size_t predicateId = dictVariants.at(predicateName);
	+ Expression result(Operator::VARIANT,{});
	+ result.op = Operator::VARIANT;
	+ result.setValueDouble(predicateId);
	+
	+ if(!schemaT->__operands.size()) return result;
	+ ExpandedType contentT = schemaT->__operands.at(0).__operator == TypeOperator::SLAVE
	+ ? typeinference::dereferenceSlaveType(ExpandedType(schemaT->__operands.at(0)), transcend)
	+ : ExpandedType(schemaT->__operands.at(0));
	+
	+ //edge case, content's type is LIST_NAMED:
	+ if (contentT->__operator == TypeOperator::LIST_NAMED) {
	+ result.operands.push_back(representTransExpression(atom, contentT));
	+
	+ } else {
	+ assert(atom.args().size);
	+ result.operands.push_back(representTransExpression(atom.args()[0], contentT));
	+ }
	+
	+ return result;
	+ }
	+
	+ case TypeOperator::LIST_NAMED:
	+ {
	+ const Gringo::SymSpan& operandsRaw = atom.args();
	+ size_t opCount = operandsRaw.size;
	+ assert(opCount == schemaT->__operands.size());
	+
	+ size_t operandId = 0;
	+ std::vector<Expression> operands;
	+ operands.reserve(opCount);
	+ for(const TypeAnnotation operandT : schemaT->__operands) {
	+ operands.push_back(representTransExpression(operandsRaw[operandId], ExpandedType(operandT)));
	+ ++operandId;
	+ }
	+
	+ Expression result(Operator::LIST_NAMED,{});
	+ result.operands = operands;
	+ result.type = schemaT;
	+ return result;
	+ }
	+
	+ case TypeOperator::LIST:
	+ case TypeOperator::CALL:
	+ case TypeOperator::CUSTOM:
	+ case TypeOperator::ACCESS:
	+ case TypeOperator::LINK:
	+ {
	+ assert(false);
	+ return Expression();
	+ }
	+ }
	+
	+ assert(false);
	+ return Expression();
	+}
	+
	+Expression
	+IntrinsicQueryInstruction::process(const Expression& expression) {
	+ AST* ast = static_cast<TargetInterpretation*> (__scope->function->man)->ast;
	+ TranscendLayer* transcend = static_cast<TargetInterpretation*> (__scope->function->man)->pass->man->transcend;
	+ InterpretationFunction* function = static_cast<InterpretationFunction*> (__scope->function);
	+
	+ ExpandedType targetT = ast->expandType(expression.type);
	+ assert(expression.operands.size() == 1);
	+ assert(expression.operands.front().__state == Expression::STRING);
	+ assert(targetT->__operator == TypeOperator::LIST);
	+
	+ std::string namePredicate = expression.operands.front().getValueString();
	+ StaticModel model = (static_cast<TargetInterpretation*> (function->man))->pass->man->transcend->query(namePredicate);
	+
	+ Expression result(Operator::LIST,{});
	+ result.operands.reserve(model.size());
	+
	+ ExpandedType elementT = targetT->__operands.at(0).__operator == TypeOperator::SLAVE
	+ ? typeinference::dereferenceSlaveType(ExpandedType(targetT->__operands.at(0)), transcend)
	+ : ExpandedType(targetT->__operands.at(0));
	+
	+ if(model.size()) {
	+ if (elementT->__operator == TypeOperator::LIST_NAMED) {
	+ //edge case, content's type is LIST_NAMED:
	+ for(const auto& row : model) {
	+ result.operands.push_back(representTransExpression(row.second, elementT));
	+ }
	+ } else {
	+ for (const auto& row : model) {
	+ assert(row.second.args().size);
	+ result.operands.push_back(representTransExpression(row.second.args()[0], elementT));
	+ }
	+ }
	+ }
	+
	+ return result;
	+}
	+}
	+} //end of xreate::interpretation
	\ No newline at end of file
	diff --git a/cpp/src/compilation/interpretation-instructions.h b/cpp/src/compilation/interpretation-instructions.h
	new file mode 100644
	index 0000000..2ff6c8c
	--- /dev/null
	+++ b/cpp/src/compilation/interpretation-instructions.h
	@@ -0,0 +1,39 @@
	+/*
	+ * 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>
	+ * Created on June 15, 2018, 5:28 PM
	+ *
	+ * \file interpretation-instructions.h
	+ * \brief Additional intepretation statements
	+ */
	+
	+#ifndef INTERPRETATION_INSTRUCTIONS_H
	+#define INTERPRETATION_INSTRUCTIONS_H
	+
	+#include "compilation/targetinterpretation.h"
	+#include "ast.h"
	+
	+namespace xreate{
	+namespace interpretation{
	+
	+class IntrinsicQueryInstruction{
	+public:
	+
	+ IntrinsicQueryInstruction(InterpretationScope* scope): __scope(scope){ }
	+ Expression process(const Expression& expression);
	+
	+private:
	+ InterpretationScope* __scope;
	+ Expression representTransExpression(const Gringo::Symbol& atom, ExpandedType schemaT);
	+};
	+
	+}
	+} //end of xreate::interpretation
	+
	+#endif /* INTERPRETATION_INSTRUCTIONS_H */
	+
	diff --git a/cpp/src/compilation/latereasoning.cpp b/cpp/src/compilation/latereasoning.cpp
	index 97a7eb6..e62201f 100644
	--- a/cpp/src/compilation/latereasoning.cpp
	+++ b/cpp/src/compilation/latereasoning.cpp
	@@ -1,79 +1,79 @@
	/*
	* 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/.
	*
	* latereasoning.cpp
	*
	* Author: pgess <v.melnychenko@xreate.org>
	* Created on May 26, 2018, 3:54 PM
	*/

	#include "compilation/latereasoning.h"
	#include "aux/latereasoning.h"
	#include "compilation/scopedecorators.h"
	#include "analysis/typeinference.h"
	#include <vector>

	using namespace xreate::compilation;
	using namespace std;

	namespace xreate{ namespace latereasoning {

	llvm::Value*
	LateReasoningCompiler::compile(const Expression& expr, const std::string& identHint){
	#define HINT(x) (identHint.empty()? x : identHint)

	LLVMLayer* llvm = context.pass->man->llvm;
	compilation::ICodeScopeUnit* scope = context.scope;
	AST* root = context.pass->man->root;
	llvm::IRBuilder<>& builder = llvm->builder;
	compilation::IFunctionUnit* function = context.function;
	llvm::Type* typI8= llvm::Type::getInt8Ty(llvm->llvmContext);
	CodeScope* scopeBody = expr.blocks.front();
	Symbol guardS = Symbol{scopeBody->getSymbol(expr.bindings.front()), scopeBody};

	- const ExpandedType& typCondition = root->getType(expr.operands.at(0));
	- vector<Expression> guardVariants = typeinference::getSlaveVariants(typCondition, context.pass->man->transcend);
	- const int countVariants = guardVariants.size();
	+ const ExpandedType& conditionT = root->getType(expr.operands.at(0));
	+ const ExpandedType& conditionTPlain = typeinference::dereferenceSlaveType(conditionT, context.pass->man->transcend);
	+ const int countVariants = conditionTPlain->fields.size();
	assert(countVariants);

	llvm::Value * conditionRaw = scope->process(expr.operands.at(0));
	llvm::Value* variantRaw = builder.CreateExtractValue(conditionRaw, llvm::ArrayRef<unsigned>({0}));
	llvm::SwitchInst * instructionSwitch = builder.CreateSwitch(variantRaw, nullptr, countVariants);

	llvm::BasicBlock *blockEpilog = llvm::BasicBlock::Create(llvm->llvmContext, "switchLateAfter", function->raw);
	builder.SetInsertPoint(blockEpilog);
	llvm::Type* exprSwitchType = llvm->toLLVMType(root->getType(expr));
	llvm::PHINode *ret = builder.CreatePHI(exprSwitchType, countVariants, HINT("switchLate"));
	llvm::BasicBlock* blockDefault = nullptr;

	bool flagFirstPass = true;
	for (int variantId = 0; variantId<countVariants; ++variantId){
	//Pass information to the late model
	flagFirstPass?
	- Attachments::put<LateBindingT>(guardS, guardVariants.at(variantId))
	- : Attachments::update<LateBindingT>(guardS, guardVariants.at(variantId));
	+ Attachments::put<LateBindingT>(guardS, Expression(Operator::CALL, {Expression(Atom<Identifier_t>(string(conditionTPlain->fields.at(variantId))))}))
	+ : Attachments::update<LateBindingT>(guardS, Expression(Operator::CALL, {Expression(Atom<Identifier_t>(string(conditionTPlain->fields.at(variantId))))}));
	flagFirstPass = false;

	llvm::BasicBlock *blockCase = llvm::BasicBlock::Create(
	llvm->llvmContext,
	"case" + std::to_string(variantId),
	function->raw);
	if(variantId == 0) blockDefault = blockCase;
	builder.SetInsertPoint(blockCase);
	auto scopeBody = Decorators<CachedScopeDecoratorTag>::getInterface<>(
	function->getScopeUnit(expr.blocks.back()));
	scopeBody->reset();

	llvm::Value* resultCase = scopeBody->compile();
	ret->addIncoming(resultCase, builder.GetInsertBlock());
	instructionSwitch->addCase(llvm::dyn_cast<llvm::ConstantInt>(llvm::ConstantInt::get(typI8, variantId)), blockCase);
	builder.CreateBr(blockEpilog);
	}

	instructionSwitch->setDefaultDest(blockDefault);
	builder.SetInsertPoint(blockEpilog);
	return ret;
	}
	}}
	\ No newline at end of file
	diff --git a/cpp/src/compilation/targetinterpretation.cpp b/cpp/src/compilation/targetinterpretation.cpp
	index 9d7d29d..1658d2f 100644
	--- a/cpp/src/compilation/targetinterpretation.cpp
	+++ b/cpp/src/compilation/targetinterpretation.cpp
	@@ -1,645 +1,593 @@
	/* 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 "compilation/interpretation-instructions.h"

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

	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((const CodeScope*) 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->overrideBindings({
	{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->overrideDeclarations(
	{{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) {
	const Expression& exprElement=elementsInput[i];

	intrBody->overrideBindings({
	{exprElement, nameEl}});
	unitBody->overrideDeclarations({
	{symbEl, exprElement}}); //resets unitBody
	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) {
	#ifndef NDEBUG
	if (expression.tags.count("bpoint")){
	std::raise(SIGINT);
	}
	#endif

	PassManager* man = (static_cast<TargetInterpretation*> (function->man))->pass->man;

	switch (expression.__state){
	case Expression::INVALID:
	assert(false);

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

	case Expression::IDENT:{
	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();
	- StaticModel model = (static_cast<TargetInterpretation*>(function->man))->pass->man->transcend->query(namePredicate);
	-
	- Expression result(Operator::LIST, {});
	-
	- if(model.size())
	- for (const auto& row: model) {
	- result.addArg(representAsAnnotation(std::get<1>(row)));
	- }
	-
	- return result;
	+ return IntrinsicQueryInstruction(this).process(expression);

	- } else if(nameFunction=="query_scope"){
	- ScopePacked scopeId = man->transcend->pack(scope);
	- Expression result(Operator::VARIANT, {Expression(scopeId)});
	- result.setValueDouble(0);
	- return result;
	+ } else if(nameFunction=="query_scope"){
	+ ScopePacked scopeId = man->transcend->pack(scope);
	+ Expression result(Operator::VARIANT, {Expression(scopeId)});
	+ result.setValueDouble(0);
	+ return result;

	} else {
	- assert(false && "Unknown intrinsic");
	+ 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::VARIANT: {
	if(!expression.operands.size()) return expression;

	Expression variantData = process(expression.operands[0]);
	Expression result{Operator::VARIANT, {variantData}};
	result.setValueDouble(expression.getValueDouble());
	return result;
	}

	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->overrideBindings({
	{exprInput.getOperands()[i], argEl},
	{accum, argAccum}
	});

	accum = body->processScope();
	}

	return accum;
	}

	case Operator::LIST:
	case Operator::LIST_NAMED:
	case Operator::LIST_RANGE:
	{
	Expression result(expression.op,{});
	result.operands.resize(expression.operands.size());
	result.bindings=expression.bindings;
	result.__indexBindings=expression.__indexBindings;

	int keyId=0;
	for(const Expression& opCurrent : expression.operands) {
	result.operands[keyId++]=process(opCurrent);
	}

	return result;
	}

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

	list<pair<Expression, string>> bindings;
	for(size_t i=0, size=args.size(); i<size; ++i) {
	bindings.push_back(make_pair(args.at(i), body->scope->__bindings.at(i)));
	}

	body->overrideBindings(bindings);
	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);

	list<pair<Expression, std::string>> bindingsPartial;
	list<pair<Symbol, Expression>> declsPartial;

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

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

	entryIntrp->overrideBindings(bindingsPartial);
	entryUnit->overrideDeclarations(declsPartial);
	}

	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)
	*
	*/
	diff --git a/cpp/src/compilation/targetinterpretation.h b/cpp/src/compilation/targetinterpretation.h
	index 7634199..ba03f34 100644
	--- a/cpp/src/compilation/targetinterpretation.h
	+++ b/cpp/src/compilation/targetinterpretation.h
	@@ -1,132 +1,129 @@
	/* 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: targetstatic.h
	* Author: pgess <v.melnychenko@xreate.org>
	*
	* Created on July 2, 2016, 1:25 PM
	*/

	#ifndef TARGETSTATIC_H
	#define TARGETSTATIC_H

	#include "ast.h"
	#include "pass/compilepass.h"
	#include "compilation/targets.h"
	#include "pass/interpretationpass.h"
	#include "transcendlayer.h"

	namespace xreate{ namespace interpretation{
	class TargetInterpretation;
	class InterpretationScope;
	class InterpretationFunction;
	}}

	namespace xreate{ namespace compilation{
	template <>
	struct TargetInfo<interpretation::TargetInterpretation> {
	typedef Expression Result;
	typedef interpretation::InterpretationScope Scope;
	typedef interpretation::InterpretationFunction Function;
	};
	}}

	namespace xreate{ namespace interpretation{

	/** \brief Encapsulates interpretation of a single Code Scope */
	class InterpretationScope: public compilation::Scope<TargetInterpretation>{
	typedef Scope<TargetInterpretation> Parent;

	public:
	InterpretationScope(const CodeScope* scope, compilation::Function<TargetInterpretation>* f): Parent(scope, f) {}
	Expression process(const Expression& expression) override;

	llvm::Value* compile(const Expression& expression, const compilation::Context& context);

	private:
	llvm::Value* compileHybrid(const InterpretationOperator& op, const Expression& expression, const compilation::Context& context);
	//llvm::Value* compilePartialFnCall(const Expression& expression, const Context& context);

	CodeScope* processOperatorIf(const Expression& expression);
	CodeScope* processOperatorSwitch(const Expression& expression);
	CodeScope* processOperatorSwitchVariant(const Expression& expression);
	};

	/** \brief Encapsulates interpretation of a single %Function */
	class InterpretationFunction: public compilation::Function<TargetInterpretation>{
	public:
	InterpretationFunction(const ManagedFnPtr& function, compilation::Target<TargetInterpretation>* target);
	Expression process(const std::vector<Expression>& args);
	};

	/** \brief Signature of a partially interpreted function */
	struct PIFSignature{
	ManagedFnPtr declaration;
	std::vector<Expression> bindings;
	};

	class PIFunctionUnit;

	/** \brief Partially interpreted function */
	class PIFunction: public InterpretationFunction{
	public:
	PIFunctionUnit* functionUnit;
	PIFSignature signatureInstance;

	PIFunction(PIFSignature&& sig, size_t id, TargetInterpretation* target);
	llvm::Function* compile();
	};

	bool operator<(const PIFSignature& lhs, PIFunction* const rhs);
	bool operator<(PIFunction* const lhs, const PIFSignature& rhs);

	/** \brief Encapsulates actual [Interpretation](/w/concepts/dfa) based on InterpretationPass analysis results */
	class TargetInterpretation: public compilation::Target<TargetInterpretation>{
	public:
	TargetInterpretation(AST* root, CompilePass* passCompilation): Target<TargetInterpretation>(root), pass(passCompilation){}

	//target:
	public:
	InterpretationFunction* getFunction(compilation::IFunctionUnit* unit);
	PIFunction* getFunction(PIFSignature&& sig);

	private:
	std::map<PIFSignature, PIFunction*> __pifunctions;
	std::map<compilation::IFunctionUnit, InterpretationFunction> __dictFunctionsByUnit;

	//self:
	public:
	CompilePass* pass;
	llvm::Value* compile(const Expression& expression, const compilation::Context& ctx);
	private:
	InterpretationScope* transformContext(const compilation::Context& c);
	};

	/**\brief Interpretation-aware Code Scope decorator
	* \extends xreate::compilation::ICodeScopeUnit
	*/
	template<class Parent>
	class InterpretationScopeDecorator: public Parent{
	public:
	InterpretationScopeDecorator(const CodeScope* const codeScope, compilation::IFunctionUnit* f, CompilePass* compilePass): Parent(codeScope, f, compilePass){}

	virtual llvm::Value* process(const Expression& expr, const std::string& hintVarDecl){
	const InterpretationData& data = Attachments::get<InterpretationData>(expr, {ANY, NONE});
	bool flagInterpretationEligible = (data.resolution == INTR_ONLY \|\| data.op != InterpretationOperator::NONE);

	if (flagInterpretationEligible){
	compilation::Context ctx{this, this->function, this->pass};
	return Parent::pass->targetInterpretation->compile(expr, ctx);
	}

	return Parent::process(expr, hintVarDecl);
	}
	};

	-/** \brief translates Logic expression(Gringo::Symbol) into Xreate expression to support intrinsic function `query` */
	-Expression representAsAnnotation(const Gringo::Symbol& symbol);
	-
	}} //end of xreate:: interpretation

	#endif /* TARGETSTATIC_H */
	\ No newline at end of file
	diff --git a/cpp/src/compilation/targets.h b/cpp/src/compilation/targets.h
	index dee23be..df281ca 100644
	--- a/cpp/src/compilation/targets.h
	+++ b/cpp/src/compilation/targets.h
	@@ -1,198 +1,198 @@
	/* 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>
	#include <list>

	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:
	const CodeScope* scope;
	+ Function<ConcreteTarget>* function=0;

	typename TargetInfo<ConcreteTarget>::Result
	processSymbol(const Symbol& s){
	const 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, 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() {
	return process(scope->getBody());
	}

	// 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(const CodeScope* codeScope, Function<ConcreteTarget>* f)
	: scope(codeScope), function(f) {}

	virtual ~Scope(){}

	void
	overrideBindings(std::list<std::pair<typename TargetInfo<ConcreteTarget>::Result, std::string>> bindings){
	reset();

	for (auto entry: bindings){
	assert(scope->__identifiers.count(entry.second));
	ScopedSymbol id{scope->__identifiers.at(entry.second), versions::VERSION_NONE};

	__bindings[id] = entry.first;
	}
	}

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

	void reset(){
	__bindings.clear();
	__childScopes.clear();
	}

	protected:
	- Function<ConcreteTarget>* function=0;
	std::map<ScopedSymbol, typename TargetInfo<ConcreteTarget>::Result> __bindings;
	std::list<std::shared_ptr<Self>> __childScopes;
	};

	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(const CodeScope* const 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<const 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/tests/association.cpp b/cpp/tests/association.cpp
	index 23def6a..d97d2f3 100644
	--- a/cpp/tests/association.cpp
	+++ b/cpp/tests/association.cpp
	@@ -1,129 +1,133 @@
	/* Any copyright is dedicated to the Public Domain.
	* http://creativecommons.org/publicdomain/zero/1.0/
	*
	* association.cpp
	*
	* Author: pgess <v.melnychenko@xreate.org>
	* Created on August 12, 2017, 9:28 PM
	*/
	#include "xreatemanager.h"
	#include "transcendlayer.h"
	#include <gtest/gtest.h>

	using namespace xreate;
	using namespace std;

	-TEST(Association, test1){
	-std::string controller=
	-R"Code(
	+TEST(Association, test1) {
	+ std::string controller =
	+ R"Code(
	program(add).
	)Code";

	-std::string script=
	-R"Code(
	+ std::string script =
	+ R"Code(
	Annotation = type variant {
	Num:: int,
	String:: string,
	Func:: {name::string, arguments::[Annotation]}
	}.

	extractCmd = function(program::Annotation):: Annotation; interpretation(force){
	switch variant(program)::Annotation
	case (Num){String("wrong expression")}
	case (String){String("wrong expression")}
	case (Func){program["arguments"][0]}
	}

	main= function:: int; entry{
	x= 5::int.
	y = 6::int.

	program = intrinsic query("program")[0]::Annotation.
	cmd = extractCmd(program)::Annotation; interpretation(force).

	answer = switch variant(cmd)::int
	case (Num) {0}
	case (String){0}
	case (Func){
	switch(cmd["name"])::int
	case("add"){x + y}
	case default {0}
	}.

	answer
	}
	)Code";

	std::unique_ptr<XreateManager> man(XreateManager::prepare(std::move(script)));
	man->transcend->addRawScript(move(controller));
	int (main)() = (int ()())man->run();
	int result = main();

	ASSERT_EQ(11, result);
	}

	-TEST(Association, QueryScope1){
	-std::string script = R"Code(
	+TEST(Association, QueryScope1) {
	+ std::string script = R"Code(
	Annotation = type variant {
	Num:: int,
	String:: string,
	Func:: {name::string, arguments::[Annotation]}
	}.

	func = function::int{10} //aux func in order to have few scopes

	main = function:: int; entry {
	scope = intrinsic query_scope()::Annotation.

	answer = switch variant(scope):: int
	case (Num) {scope}
	case (String){-1}
	case (Func){-1}.

	answer
	}

	)Code";

	std::unique_ptr<XreateManager> man(XreateManager::prepare(std::move(script)));
	int (main)() = (int ()())man->run();
	int result = main();

	ASSERT_EQ(1, result);
	}

	-//std::string script=
	-//R"Code(
	-//
	-//case context:: test1 {
	-//test= function::bool; registerTest {
	-// x = 8:: int.
	-//
	-// x == 8
	-//}}
	-//
	-//case context:: test2{
	-//test= function::bool{
	-// x = 3::int.
	-// y = 12::int.,
	-//
	-// (x+y) <> 25
	-//}}
	-//
	-//runTests= function::bool{
	-// tests = intrinsic query (registeredTests)::[Expression].
	-//
	-// loop fold(tests->test::Expression, true->result):: bool {
	-// shot = {
	-// context:: make context (test)
	-// test()
	-// }
	-//
	-// result and shot
	-// }
	-//}
	-//
	-//main= function:: int; entry{
	-// runTests()
	-//}
	-//)Code";
	+TEST(Association, TypedQuery_1) {
	+ auto man = details::tier1::XreateManager::prepare(R"Code(
	+ AtomNumT = type slave atomNumT.
	+ AtomStrT = type slave atomStrT.
	+ CompListT = type slave compListT.
	+ CompArithT = type slave compArithT.
	+
	+ test = function:: num; entry
	+ {
	+ query1 = intrinsic query("atomNumT")::[AtomNumT].
	+ query2 = intrinsic query("atomStrT")::[AtomStrT].
	+ query3 = intrinsic query("compListT")::[CompListT].
	+ query4 = intrinsic query("compArithT")::[CompArithT].
	+ test1 = query1[0] == 5:: bool.
	+ test2 = query2[1] == "y":: bool.
	+ test3 = query3[0, 1] == "x" :: bool.
	+ test4 = query4[0, 0, 0] == 1:: bool.
	+
	+ test1 + test2 + test3 + test4
	+ }
	+ )Code");
	+
	+ man->transcend->addRawScript(R"RAW(
	+ atomNumT(5; 8).
	+ atomStrT("x"; "y").
	+ compListT(5, "x").
	+ compListT(8, "y").
	+ compArithT(add(1, 2)).
	+ compArithT(mul(5, 6)).
	+ )RAW");
	+
	+ man->analyse();
	+ int (test)() = (int ()())man->run();
	+ int result = test();
	+ ASSERT_EQ(4, result);
	+}
	+
	+
	+
	diff --git a/cpp/tests/types.cpp b/cpp/tests/types.cpp
	index 51facbf..5d3c9f5 100644
	--- a/cpp/tests/types.cpp
	+++ b/cpp/tests/types.cpp
	@@ -1,181 +1,235 @@
	/* Any copyright is dedicated to the Public Domain.
	* http://creativecommons.org/publicdomain/zero/1.0/
	*
	* types.cpp
	*
	* Created on: Jun 4, 2015
	* Author: pgess <v.melnychenko@xreate.org>
	*/

	#include "gtest/gtest.h"
	#include "xreatemanager.h"
	#include "llvmlayer.h"
	#include "main/Parser.h"
	+#include "transcendlayer.h"
	+#include "analysis/typeinference.h"

	using namespace std;
	using namespace xreate;
	using namespace xreate::grammar::main;

	TEST(Types, DependantTypes1) {
	- string&& code = "XmlNode = type {\n"
	- " tag:: string,\n"
	- " attrs:: [string], \n"
	- " content:: string\n"
	- "}.\n";
	-
	- std::unique_ptr<XreateManager> program(XreateManager::prepare(move(code)));
	- ExpandedType typeXmlNode = program->root->findType("XmlNode");
	-
	- ASSERT_EQ(TypeOperator::LIST_NAMED, typeXmlNode->__operator);
	- ASSERT_EQ(3, typeXmlNode->__operands.size());
	- ASSERT_EQ(TypePrimitive::String, typeXmlNode->__operands.at(0).__value);
	- ASSERT_EQ(TypeOperator::LIST, typeXmlNode->__operands.at(1).__operator);
	- ASSERT_EQ(TypePrimitive::String, typeXmlNode->__operands.at(2).__value);
	+ string&& code = "XmlNode = type {\n"
	+ " tag:: string,\n"
	+ " attrs:: [string], \n"
	+ " content:: string\n"
	+ "}.\n";
	+
	+ std::unique_ptr<XreateManager> program(XreateManager::prepare(move(code)));
	+ ExpandedType typeXmlNode = program->root->findType("XmlNode");
	+
	+ ASSERT_EQ(TypeOperator::LIST_NAMED, typeXmlNode->__operator);
	+ ASSERT_EQ(3, typeXmlNode->__operands.size());
	+ ASSERT_EQ(TypePrimitive::String, typeXmlNode->__operands.at(0).__value);
	+ ASSERT_EQ(TypeOperator::LIST, typeXmlNode->__operands.at(1).__operator);
	+ ASSERT_EQ(TypePrimitive::String, typeXmlNode->__operands.at(2).__value);
	}

	TEST(Types, ast_ParameterizedTypes_FeatureTypeIndex_1) {
	- string&& code = "XmlNode = type {\n"
	- " tag:: string,\n"
	- " attrs:: [string],\n"
	- " content:: string\n"
	- "}.\n"
	- ""
	- "Template = type(Leaf) {Leaf, [Leaf[content]]}."
	- "Concrete = type Template(XmlNode).";
	-
	- std::unique_ptr<XreateManager> program(XreateManager::prepare(move(code)));
	- ExpandedType typeConcrete = program->root->findType("Concrete");
	-
	- ASSERT_EQ(TypeOperator::LIST_NAMED, typeConcrete->__operator);
	- ASSERT_EQ(2, typeConcrete->__operands.size());
	- ASSERT_EQ(TypeOperator::LIST_NAMED, typeConcrete->__operands.at(0).__operator);
	-
	- ASSERT_EQ(TypeOperator::LIST, typeConcrete->__operands.at(1).__operator);
	- ASSERT_EQ(TypePrimitive::String, typeConcrete->__operands.at(1).__operands.at(0).__value);
	+ string&& code = "XmlNode = type {\n"
	+ " tag:: string,\n"
	+ " attrs:: [string],\n"
	+ " content:: string\n"
	+ "}.\n"
	+ ""
	+ "Template = type(Leaf) {Leaf, [Leaf[content]]}."
	+ "Concrete = type Template(XmlNode).";
	+
	+ std::unique_ptr<XreateManager> program(XreateManager::prepare(move(code)));
	+ ExpandedType typeConcrete = program->root->findType("Concrete");
	+
	+ ASSERT_EQ(TypeOperator::LIST_NAMED, typeConcrete->__operator);
	+ ASSERT_EQ(2, typeConcrete->__operands.size());
	+ ASSERT_EQ(TypeOperator::LIST_NAMED, typeConcrete->__operands.at(0).__operator);
	+
	+ ASSERT_EQ(TypeOperator::LIST, typeConcrete->__operands.at(1).__operator);
	+ ASSERT_EQ(TypePrimitive::String, typeConcrete->__operands.at(1).__operands.at(0).__value);
	}

	TEST(Types, TreeType1) {
	- string&& code = "XmlNode = type {\n"
	- " tag:: string,\n"
	- " attrs:: [string],\n"
	- " content:: string\n"
	- "}.\n"
	- ""
	- "Tree = type(Leaf) {Leaf, [Tree(Leaf)]}."
	- "Concrete = type Tree(XmlNode).";
	-
	- std::unique_ptr<XreateManager> program(XreateManager::prepare(move(code)));
	- ExpandedType typeConcrete = program->root->findType("Concrete");
	-
	- ASSERT_EQ(TypeOperator::LIST_NAMED, typeConcrete->__operator);
	- ASSERT_EQ(2, typeConcrete->__operands.size());
	- ASSERT_EQ(TypeOperator::LIST_NAMED, typeConcrete->__operands.at(0).__operator);
	-
	- ASSERT_EQ(TypeOperator::LIST, typeConcrete->__operands.at(1).__operator);
	-
	- auto typeLink = typeConcrete->__operands.at(1).__operands.at(0);
	- ASSERT_EQ(TypeOperator::LINK, typeLink.__operator);
	- ASSERT_EQ(typeConcrete->conjuctionId,typeLink.conjuctionId);
	+ string&& code = "XmlNode = type {\n"
	+ " tag:: string,\n"
	+ " attrs:: [string],\n"
	+ " content:: string\n"
	+ "}.\n"
	+ ""
	+ "Tree = type(Leaf) {Leaf, [Tree(Leaf)]}."
	+ "Concrete = type Tree(XmlNode).";
	+
	+ std::unique_ptr<XreateManager> program(XreateManager::prepare(move(code)));
	+ ExpandedType typeConcrete = program->root->findType("Concrete");
	+
	+ ASSERT_EQ(TypeOperator::LIST_NAMED, typeConcrete->__operator);
	+ ASSERT_EQ(2, typeConcrete->__operands.size());
	+ ASSERT_EQ(TypeOperator::LIST_NAMED, typeConcrete->__operands.at(0).__operator);
	+
	+ ASSERT_EQ(TypeOperator::LIST, typeConcrete->__operands.at(1).__operator);
	+
	+ auto typeLink = typeConcrete->__operands.at(1).__operands.at(0);
	+ ASSERT_EQ(TypeOperator::LINK, typeLink.__operator);
	+ ASSERT_EQ(typeConcrete->conjuctionId, typeLink.conjuctionId);
	}

	-TEST(Types, TreeType1LLvm){
	- string&& code = "XmlNode = type {\n"
	- " tag:: string,\n"
	- " /* attrs:: [string],*/\n"
	- " content:: string\n"
	- "}.\n"
	- ""
	- "Tree = type(Leaf) {Leaf, [Tree(Leaf)]}."
	- "Concrete = type Tree(XmlNode).";
	+TEST(Types, TreeType1LLvm) {
	+ string&& code = "XmlNode = type {\n"
	+ " tag:: string,\n"
	+ " /* attrs:: [string],*/\n"
	+ " content:: string\n"
	+ "}.\n"
	+ ""
	+ "Tree = type(Leaf) {Leaf, [Tree(Leaf)]}."
	+ "Concrete = type Tree(XmlNode).";

	- std::unique_ptr<XreateManager> program(XreateManager::prepare(move(code)));
	- ExpandedType typeConcrete = program->root->findType("Concrete");
	+ std::unique_ptr<XreateManager> program(XreateManager::prepare(move(code)));
	+ ExpandedType typeConcrete = program->root->findType("Concrete");

	- llvm::Type* raw = program->llvm->toLLVMType(typeConcrete);
	+ llvm::Type* raw = program->llvm->toLLVMType(typeConcrete);
	}

	-TEST(Types, ArrayOfExternal1){
	- FILE* input = fopen("scripts/containers/Containers_Implementation_LinkedList1.xreate","r");
	+TEST(Types, ArrayOfExternal1) {
	+ FILE* input = fopen("scripts/containers/Containers_Implementation_LinkedList1.xreate", "r");
	assert(input != nullptr);

	Scanner scanner(input);
	Parser parser(&scanner);

	parser.Parse();
	AST* ast = parser.root->finalize();

	CodeScope* body = ast->findFunction("test")->getEntryScope();

	const ExpandedType& t2 = ast->getType(body->getDefinition(body->getSymbol("childrenRaw")));
	EXPECT_EQ(t2->__operator, TypeOperator::LIST);
	}

	-TEST(Types, ExternType1){
	- FILE* input = fopen("scripts/containers/Containers_Implementation_LinkedList1.xreate","r");
	- assert(input != nullptr);
	+TEST(Types, ExternType1) {
	+ FILE* input = fopen("scripts/containers/Containers_Implementation_LinkedList1.xreate", "r");
	+ assert(input != nullptr);

	- Scanner scanner(input);
	- Parser parser(&scanner);
	- parser.Parse();
	+ Scanner scanner(input);
	+ Parser parser(&scanner);
	+ parser.Parse();

	- AST* ast = parser.root->finalize();
	- CodeScope* body = ast->findFunction("test")->getEntryScope();
	+ AST* ast = parser.root->finalize();
	+ CodeScope* body = ast->findFunction("test")->getEntryScope();

	const ExpandedType& t2 = ast->getType(body->getDefinition(body->getSymbol("tree")));
	EXPECT_EQ(t2->__operator, TypeOperator::CUSTOM);
	}

	-TEST(Types, ast_VariantType1){
	- string&& code =
	- " colors = type variant {RED, BLUE, GREEN}.\n"
	- " test = function:: colors; entry {GREEN()}";
	+TEST(Types, ast_VariantType1) {
	+ string&& code =
	+ " colors = type variant {RED, BLUE, GREEN}.\n"
	+ " test = function:: colors; entry {GREEN()}";

	- std::unique_ptr<XreateManager> program(XreateManager::prepare(move(code)));
	+ std::unique_ptr<XreateManager> program(XreateManager::prepare(move(code)));

	- ExpandedType typ = program->root->findType("colors");
	- EXPECT_EQ(TypeOperator::VARIANT, typ->__operator);
	+ ExpandedType typ = program->root->findType("colors");
	+ EXPECT_EQ(TypeOperator::VARIANT, typ->__operator);

	- Expression eRed = program->root->findFunction("test")->getEntryScope()->getBody();
	- EXPECT_EQ(Operator::VARIANT, eRed.op);
	+ Expression eRed = program->root->findFunction("test")->getEntryScope()->getBody();
	+ EXPECT_EQ(Operator::VARIANT, eRed.op);

	- const ExpandedType& typ2 = program->root->getType(eRed);
	- EXPECT_EQ(TypeOperator::VARIANT, typ2->__operator);
	+ const ExpandedType& typ2 = program->root->getType(eRed);
	+ EXPECT_EQ(TypeOperator::VARIANT, typ2->__operator);
	}

	-TEST(Types, full_VariantType_Switch1){
	- string&& code =
	+TEST(Types, full_VariantType_Switch1) {
	+ string&& code =
	"colors = type variant{RED, BLUE, GREEN}. \n"
	- " test = function:: colors {GREEN()} \n"
	+ " test = function:: colors {GREEN()} \n"

	- "main = function:: int; entry { \n"
	- " switch(test()):: int \n"
	- " case (GREEN()) {0} \n"
	- " case default {1} \n"
	- "}";
	+ "main = function:: int; entry { \n"
	+ " switch(test()):: int \n"
	+ " case (GREEN()) {0} \n"
	+ " case default {1} \n"
	+ "}";

	- XreateManager* man = XreateManager::prepare(move(code));
	- int (main)() = (int ()()) man->run();
	+ XreateManager* man = XreateManager::prepare(move(code));
	+ int (main)() = (int ()()) man->run();

	- EXPECT_EQ(0, main());
	+ EXPECT_EQ(0, main());
	}

	-TEST(Types, ast_VariantType2){
	- std::string script=
	-R"Code(
	+TEST(Types, ast_VariantType2) {
	+ std::string script =
	+ R"Code(
	Annotation = type
	variant {
	Num:: int,
	String:: string,
	Func:: {name::string, arguments::[Expression]}
	}.
	)Code";

	std::unique_ptr<XreateManager> program(XreateManager::prepare(move(script)));
	ExpandedType typ = program->root->findType("Annotation");
	ASSERT_EQ(3, typ.get().fields.size());
	}

	-//TEST(Types, A)
	-
	-
	-//TOTEST string type
	+TEST(Types, SlaveTypes_UnwrapSlaveType1) {
	+ auto man = details::tier1::XreateManager::prepare(R"Code(
	+ AtomNumT = type slave atomNumT.
	+ AtomStrT = type slave atomStrT.
	+ CmpndIntStrT = type slave cmpndIntStrT.
	+
	+ VariantT = type slave variantT.
	+
	+ VariantComplicatedT = type slave variantComplicatedT.
	+ )Code");
	+
	+ man->transcend->addRawScript(R"RAW(
	+ atomNumT(5). atomNumT(8).
	+ atomStrT("a"). atomStrT("b").
	+ cmpndIntStrT(1, "a").
	+ cmpndIntStrT(2, "b").
	+
	+ variantT(first).
	+ variantT(second).
	+ variantT(third).
	+
	+ variantComplicatedT(first(1, "a")).
	+ variantComplicatedT(second("b")).
	+ )RAW");
	+
	+ man->analyse();
	+ ExpandedType AtomNumT = man->root->findType("AtomNumT");
	+ ASSERT_EQ(AtomNumT->__operator, TypeOperator::SLAVE);
	+
	+ ExpandedType ContentAtomNumT = typeinference::dereferenceSlaveType(AtomNumT, man->transcend);
	+ ASSERT_EQ(TypePrimitive::Num, ContentAtomNumT->__value);
	+
	+ ExpandedType AtomStrT = man->root->findType("AtomStrT");
	+ ExpandedType ContentAtomStrT = typeinference::dereferenceSlaveType(AtomStrT,
	+ man->transcend);
	+ ASSERT_EQ(TypePrimitive::String, ContentAtomStrT->__value);
	+
	+ ExpandedType CmpndIntStrT = man->root->findType("CmpndIntStrT");
	+ ExpandedType ContentCmpndIntStrT = typeinference::dereferenceSlaveType(CmpndIntStrT,
	+ man->transcend);
	+ ASSERT_EQ(TypeOperator::LIST_NAMED, ContentCmpndIntStrT->__operator);
	+ ASSERT_EQ(2, ContentCmpndIntStrT->__operands.size());
	+
	+ ExpandedType VariantT = man->root->findType("VariantT");
	+ ExpandedType ContentVariantT = typeinference::dereferenceSlaveType(VariantT,
	+ man->transcend);
	+ ASSERT_EQ(TypeOperator::VARIANT, ContentVariantT->__operator);
	+ ASSERT_EQ(3, ContentVariantT->fields.size());
	+
	+ ExpandedType VariantComplicatedT = man->root->findType("VariantComplicatedT");
	+ ExpandedType ContentVariantComplicatedT = typeinference::dereferenceSlaveType(VariantComplicatedT,
	+ man->transcend);
	+ ASSERT_EQ(TypeOperator::VARIANT, ContentVariantComplicatedT->__operator);
	+ ASSERT_EQ(2, ContentVariantComplicatedT->fields.size());
	+ ASSERT_EQ(2, ContentVariantComplicatedT->__operands.at(0).__operands.size());
	+}
	\ No newline at end of file
	diff --git a/git-commit-template b/git-commit-template
	index 94da945..567e7b8 100644
	--- a/git-commit-template
	+++ b/git-commit-template
	@@ -1,12 +1,12 @@
	<Changeset description>

	Syntax: <syntax changes>
	Transcend: <any changes related to reasoning>
	Compilation: <any changes on compilation side>
	-Documentation: <...>
	+Documentation: <note if requires any changes in documentation>
	<component, AST, DFAPass etc>: <...>

	Malfunctions: <what is broken after commit, broken/disabled tests>

	Tests: <tests that cover commited changes>

No OneTemporaryActions

File Metadata

View Options

Event Timeline

No OneTemporary
Actions