diff --git a/cpp/src/compilation/advancedinstructions.cpp b/cpp/src/compilation/advancedinstructions.cpp
index 914947e..01dd15d 100644
--- a/cpp/src/compilation/advancedinstructions.cpp
+++ b/cpp/src/compilation/advancedinstructions.cpp
@@ -1,454 +1,457 @@
 /* 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));
 
-    llvm::BasicBlock *blockAfter = llvm::BasicBlock::Create(llvm::getGlobalContext(), "ifAfter", function->raw);
+    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->builder.CreateCondBr(cond, blockTrue, blockFalse);
+    llvm::BasicBlock *blockProlog = builder.GetInsertBlock();
 
     builder.SetInsertPoint(blockTrue);
     CodeScope* scopeTrue = exprIf.blocks.front();
     llvm::Value* resultTrue = function->getScopeUnit(scopeTrue)->compile();
     blockTrue = builder.GetInsertBlock();
-    builder.CreateBr(blockAfter);
+    builder.CreateBr(blockEpilog);
 
     builder.SetInsertPoint(blockFalse);
     CodeScope* scopeFalse = exprIf.blocks.back();
     llvm::Value* resultFalse = function->getScopeUnit(scopeFalse)->compile();
     blockFalse = builder.GetInsertBlock();
-    builder.CreateBr(blockAfter);
+    builder.CreateBr(blockEpilog);
 
-    builder.SetInsertPoint(blockAfter);
+    builder.SetInsertPoint(blockProlog);
+    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);
 
     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/scopedecorators.h b/cpp/src/compilation/scopedecorators.h
index b0e66ec..3fbf541 100644
--- a/cpp/src/compilation/scopedecorators.h
+++ b/cpp/src/compilation/scopedecorators.h
@@ -1,147 +1,151 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  * 
  * File:   scopedecorators.h
  * Author: pgess <v.melnychenko@xreate.org>
  *
  * Created on February 24, 2017, 11:35 AM
  */
 
 /**
  * \file    scopedecorators.h
  * \brief   Basic code block compilation xreate::compilation::ICodeScopeUnit  decorators
  */
 
 
 #ifndef SCOPEDECORATORS_H
 #define SCOPEDECORATORS_H
 
 #include "ast.h"
 #include "compilation/targetinterpretation.h"
 #include "compilation/versions.h"
 #include "compilation/transformations.h"
 #include "compilation/polymorphcompiler.h"
 
 namespace xreate { 
     
 class CompilePass;
 
 namespace compilation {
 
 class ICodeScopeUnit;
 class IFunctionUnit;
 
 /**\brief Caching ability for code scope compilation
  * \extends xreate::compilation::ICodeScopeUnit
  */
 template<class Parent>
 class CachedScopeDecorator: public Parent{
     typedef CachedScopeDecorator<Parent> SELF;
 
 public:
     CachedScopeDecorator(const CodeScope* const codeScope, IFunctionUnit* f, CompilePass* compilePass): Parent(codeScope, f, compilePass){}
 
     Symbol bindArg(llvm::Value* value, std::string&& alias)
     {
         //ensure existence of an alias
         assert(Parent::scope->__identifiers.count(alias));
 
         //memorize new value for an alias
         ScopedSymbol id{Parent::scope->__identifiers.at(alias), versions::VERSION_NONE};
         __rawVars[id] = value;
         
         return Symbol{id, Parent::scope};
     }
 
     void bindArg(llvm::Value* value, const ScopedSymbol& s) {
         __rawVars[s] = value;
     }
     
     llvm::Value* compile(const std::string& hintBlockDecl="") override{
         if (__rawVars.count(ScopedSymbol::RetSymbol)){
             return __rawVars[ScopedSymbol::RetSymbol];
         }
         
         return Parent::compile(hintBlockDecl);
     }
 
     llvm::Value* 
     processSymbol(const Symbol& s, std::string hintRetVar) override{
         const CodeScope* scope = s.scope;
         SELF* self = dynamic_cast<SELF*>(Parent::function->getScopeUnit(scope));
 
         if (self->__rawVars.count(s.identifier)){
             return self->__rawVars[s.identifier];
         }
 
         //Declaration could be overriden
+        /*
         Expression declaration = CodeScope::getDefinition(s, true);
         if (!declaration.isDefined()){
-            if (self->__declarationsOverriden.count(s.identifier)){
-                declaration = self->__declarationsOverriden[s.identifier];
+            assert(__declarationsOverriden.count(s.identifier));
+                declaration = __declarationsOverriden[s.identifier];
 
             } else {
-                assert(false); //in case of binding there should be raws provided.
+                (false); //in case of binding there should be raws provided.
             }
         }
+        */
 
-        return self->__rawVars[s.identifier] = Parent::processSymbol(s, hintRetVar);
+        llvm::Value* resultRaw = Parent::processSymbol(s, hintRetVar);
+        self->__rawVars.emplace(s.identifier, resultRaw);
+        return resultRaw;
     }
 
     void 
     overrideDeclaration(const Symbol binding, Expression&& declaration){
         SELF* self = dynamic_cast<SELF*>(Parent::function->getScopeUnit(binding.scope));
 
         self->__declarationsOverriden.emplace(binding.identifier, std::move(declaration));
     }
 
     void registerChildScope(std::shared_ptr<ICodeScopeUnit> scope){
         __childScopes.push_back(scope);
     }
 
     void reset(){
         __rawVars.clear();
         __declarationsOverriden.clear();
         __childScopes.clear();
     }
 
 private:
     std::unordered_map<ScopedSymbol, Expression> __declarationsOverriden;
     std::unordered_map<ScopedSymbol,llvm::Value*> __rawVars;
     std::list<std::shared_ptr<ICodeScopeUnit>> __childScopes;
 };
 
 /**\brief Default code scope compilation functionality*/
 typedef CachedScopeDecorator<
         polymorph::PolymorphCodeScopeUnit<
         ::xreate::compilation::TransformationsScopeDecorator<
         interpretation::InterpretationScopeDecorator<
         versions::VersionsScopeDecorator<compilation::BasicCodeScopeUnit>>>>>
 
         DefaultCodeScopeUnit;
 
 } //end of compilation namespace
 
 struct CachedScopeDecoratorTag;
 struct VersionsScopeDecoratorTag;
 
 template<>
 struct DecoratorsDict<CachedScopeDecoratorTag>{
     typedef compilation::CachedScopeDecorator<
             polymorph::PolymorphCodeScopeUnit<
             compilation::TransformationsScopeDecorator<
             interpretation::InterpretationScopeDecorator<
             versions::VersionsScopeDecorator<compilation::BasicCodeScopeUnit>>>>> result;
 };
 
 template<>
 struct DecoratorsDict<VersionsScopeDecoratorTag>{
     typedef versions::VersionsScopeDecorator<
             compilation::BasicCodeScopeUnit> result;
 };
 
 } //end of xreate
 
 #endif /* SCOPEDECORATORS_H */
 
diff --git a/cpp/src/pass/compilepass.cpp b/cpp/src/pass/compilepass.cpp
index 55c6b3f..66d630c 100644
--- a/cpp/src/pass/compilepass.cpp
+++ b/cpp/src/pass/compilepass.cpp
@@ -1,850 +1,865 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  *
  * Author: pgess <v.melnychenko@xreate.org>
  *
  * compilepass.cpp
  */
 
 /**
  * \file    compilepass.h
  * \brief   Compilation pass
  */
 
 #include "compilepass.h"
 #include "clasplayer.h"
 #include <ast.h>
 #include "llvmlayer.h"
 
 #include "query/containers.h"
 #include "query/context.h"
 #include "compilation/containers.h"
 #include "compilation/latecontextcompiler2.h"
 #include "ExternLayer.h"
 #include "pass/adhocpass.h"
 #include "compilation/targetinterpretation.h"
 #include "pass/versionspass.h"
 #include "compilation/scopedecorators.h"
 #include "compilation/adhocfunctiondecorator.h"
 #include "compilation/operators.h"
 #include "analysis/typeinference.h"
 
 #include <boost/optional.hpp>
 #include <memory>
 #include <iostream>
 
 using namespace std;
 using namespace llvm;
 
 //TODO use Scope<TargetLlvm>
 
     //SECTIONTAG late-context FunctionDecorator
 
 namespace xreate{namespace context{
 
 /** \brief Late Context enabled decorator for IFunctionUnit
  * \extends IFunctionUnit
  */
 template<class Parent>
 class LateContextFunctionDecorator : public Parent {
 public:
     LateContextFunctionDecorator(ManagedFnPtr f, CompilePass* p)
     : Parent(f, p), contextCompiler(this, p) {
     }
 
 protected:
     std::vector<llvm::Type*> prepareArguments() {
         std::vector<llvm::Type*>&& arguments = Parent::prepareArguments();
 
         size_t sizeLateContextDemand = contextCompiler.getFunctionDemandSize();
         if (sizeLateContextDemand) {
             llvm::Type* ty32 = llvm::Type::getInt32Ty(llvm::getGlobalContext());
             llvm::Type* tyDemand = llvm::ArrayType::get(ty32, sizeLateContextDemand);
 
             arguments.push_back(tyDemand);
         }
 
         return arguments;
     }
 
     llvm::Function::arg_iterator prepareBindings() {
         llvm::Function::arg_iterator fargsI = Parent::prepareBindings();
 
         size_t sizeLateContextDemand = contextCompiler.getFunctionDemandSize();
         if (sizeLateContextDemand) {
             fargsI->setName("latecontext");
             contextCompiler.rawContextArgument = &*fargsI;
             ++fargsI;
         }
 
         return fargsI;
     }
 
 public:
     context::LateContextCompiler2 contextCompiler;
 };
 
 }} //end of namespace xreate::context
 
 namespace xreate { namespace compilation{
 
 std::string
 BasicFunctionUnit::prepareName(){
     AST* ast = IFunctionUnit::pass->man->root;
 
     string name = ast->getFunctionSpecializations(IFunctionUnit::function->__name).size() > 1 ?
             IFunctionUnit::function->__name + std::to_string(IFunctionUnit::function.id()) :
             IFunctionUnit::function->__name;
 
     return name;
 }
 
 std::vector<llvm::Type*>
 BasicFunctionUnit::prepareArguments() {
     LLVMLayer* llvm = IFunctionUnit::pass->man->llvm;
     AST* ast = IFunctionUnit::pass->man->root;
     CodeScope* entry = IFunctionUnit::function->__entry;
     std::vector<llvm::Type*> signature;
 
     std::transform(entry->__bindings.begin(), entry->__bindings.end(), std::inserter(signature, signature.end()),
             [llvm, ast, entry](const std::string & arg)->llvm::Type* {
                 assert(entry->__identifiers.count(arg));
 
                 ScopedSymbol argid{entry->__identifiers.at(arg), versions::VERSION_NONE};
                 return llvm->toLLVMType(ast->expandType(entry->__declarations.at(argid).type));
             });
 
     return signature;
 }
 
 llvm::Type*
 BasicFunctionUnit::prepareResult() {
     LLVMLayer* llvm = IFunctionUnit::pass->man->llvm;
     AST* ast = IFunctionUnit::pass->man->root;
     CodeScope* entry = IFunctionUnit::function->__entry;
 
     return llvm->toLLVMType(ast->expandType(entry->__declarations.at(ScopedSymbol::RetSymbol).type));
 }
 
 llvm::Function::arg_iterator
 BasicFunctionUnit::prepareBindings() {
     CodeScope* entry = IFunctionUnit::function->__entry;
     ICodeScopeUnit* entryCompilation = IFunctionUnit::getScopeUnit(entry);
     llvm::Function::arg_iterator fargsI = IFunctionUnit::raw->arg_begin();
 
     for (std::string &arg : entry->__bindings) {
         ScopedSymbol argid{entry->__identifiers[arg], versions::VERSION_NONE};
 
         entryCompilation->bindArg(&*fargsI, argid);
         fargsI->setName(arg);
         ++fargsI;
     }
 
     return fargsI;
 }
 
     //DEBT compiler rigidly depends on exact definition of DefaultFunctionUnit
 typedef context::LateContextFunctionDecorator<
         adhoc::AdhocFunctionDecorator<
         BasicFunctionUnit>> DefaultFunctionUnit;
 
 ICodeScopeUnit::ICodeScopeUnit(const CodeScope* const codeScope, IFunctionUnit* f, CompilePass* compilePass)
-: pass(compilePass), function(f), scope(codeScope) {
+: pass(compilePass), function(f), scope(codeScope), currentBlockRaw(nullptr) {
 }
 
 llvm::Value*
 CallStatementRaw::operator()(std::vector<llvm::Value *>&& args, const std::string& hintDecl) {
     llvm::Function* calleeInfo = dyn_cast<llvm::Function>(__callee);
 
     if (calleeInfo) {
         auto argsFormal = calleeInfo->args();
 
         int pos = 0;
         //SECTIONTAG types/convert function ret value
         for (auto argFormal = argsFormal.begin(); argFormal != argsFormal.end(); ++argFormal, ++pos) {
             args[pos] = typeinference::doAutomaticTypeConversion(args[pos], argFormal->getType(), llvm->builder);
         }
     }
 
     return llvm->builder.CreateCall(__calleeTy, __callee, args, hintDecl);
 }
 
     //DESABLEDFEATURE implement inlining
 class CallStatementInline : public ICallStatement {
 public:
     CallStatementInline(IFunctionUnit* caller, IFunctionUnit* callee, LLVMLayer* l)
     : __caller(caller), __callee(callee), llvm(l) {
     }
 
     llvm::Value* operator()(std::vector<llvm::Value *>&& args, const std::string& hintDecl) {
         //TOTEST inlining
         //            CodeScopeUnit* entryCompilation = outer->getScopeUnit(function->__entry);
         //            for(int i=0, size = args.size(); i<size; ++i) {
         //                entryCompilation->bindArg(args.at(i), string(entryCompilation->scope->__bindings.at(i)));
         //            }
         //
         //
         //            return entryCompilation->compile();
 
         return nullptr;
     }
 
 private:
     IFunctionUnit* __caller;
     IFunctionUnit* __callee;
     LLVMLayer* llvm;
 
     bool isInline() {
         // Symbol ret = Symbol{0, function->__entry};
         // bool flagOnTheFly = SymbolAttachments::get<IsImplementationOnTheFly>(ret, false);
         //TODO consider inlining
         return false;
     }
 };
 
 BasicCodeScopeUnit::BasicCodeScopeUnit(const CodeScope* const codeScope, IFunctionUnit* f, CompilePass* compilePass)
 : ICodeScopeUnit(codeScope, f, compilePass) {
 }
 
 llvm::Value*
 BasicCodeScopeUnit::processSymbol(const Symbol& s, std::string hintRetVar) {
     Expression declaration = CodeScope::getDefinition(s);
     const CodeScope* scope = s.scope;
-    ICodeScopeUnit* self = ICodeScopeUnit::function->getScopeUnit(scope);
+    ICodeScopeUnit* scopeExternal = ICodeScopeUnit::function->getScopeUnit(scope);
 
-    return self->process(declaration, hintRetVar);
+    llvm::Value* resultRaw;
+    if (scopeExternal == this){
+        resultRaw = process(declaration, hintRetVar);
+        currentBlockRaw = pass->man->llvm->builder.GetInsertBlock();
+
+    } else {
+        assert(scopeExternal->currentBlockRaw);
+
+        llvm::BasicBlock* blockOwn = pass->man->llvm->builder.GetInsertBlock();
+        pass->man->llvm->builder.SetInsertPoint(scopeExternal->currentBlockRaw);
+        resultRaw = scopeExternal->processSymbol(s, hintRetVar);
+        pass->man->llvm->builder.SetInsertPoint(blockOwn);
+    }
+
+    return resultRaw;
 }
 
 //TASK Isolate out context functionalty in decorator
 //TOTEST static late context decisions
 //TOTEST dynamic late context decisions
 ICallStatement*
 BasicCodeScopeUnit::findFunction(const Expression& opCall) {
     const std::string& calleeName = opCall.getValueString();
     LLVMLayer* llvm = pass->man->llvm;
     ClaspLayer* clasp = pass->man->clasp;
     DefaultFunctionUnit* function = dynamic_cast<DefaultFunctionUnit*> (this->function);
     context::ContextQuery* queryContext = pass->queryContext;
 
     const std::list<ManagedFnPtr>& specializations = pass->man->root->getFunctionSpecializations(calleeName);
 
     //if no specializations registered - check external function
     if (specializations.size() == 0) {
         llvm::Function* external = llvm->layerExtern->lookupFunction(calleeName);
 
         llvm::outs() << "Debug/External function: " << calleeName;
         external->getType()->print(llvm::outs(), true);
         llvm::outs() << "\n";
 
         return new CallStatementRaw(external, llvm);
     }
 
     //no decisions required
     if (specializations.size() == 1) {
         if (!specializations.front()->guardContext.isValid()) {
             return new CallStatementRaw(pass->getFunctionUnit(specializations.front())->compile(), llvm);
         }
     }
 
     //TODO move dictSpecialization over to a separate function in order to perform cache, etc.
     //prepare specializations dictionary
     std::map<Expression, ManagedFnPtr> dictSpecializations;
 
     boost::optional<ManagedFnPtr> variantDefault;
     boost::optional<ManagedFnPtr> variant;
 
     for (const ManagedFnPtr& f : specializations) {
         const Expression& guard = f->guardContext;
 
         //default case:
         if (!guard.isValid()) {
             variantDefault = f;
             continue;
         }
 
         assert(dictSpecializations.emplace(guard, f).second && "Found several identical specializations");
     }
 
     //check static context
     ScopePacked scopeCaller = clasp->pack(this->scope);
     const string atomSpecialization = "specialization";
     const Expression topicSpecialization(Operator::CALL,{(Atom<Identifier_t>(string(atomSpecialization))),
         Expression(Operator::CALL,
         {Atom<Identifier_t>(string(calleeName))}),
         Atom<Number_t>(scopeCaller)});
 
     const context::Decisions& decisions = queryContext->getFinalDecisions(scopeCaller);
     if (decisions.count(topicSpecialization)) {
         variant = dictSpecializations.at(decisions.at(topicSpecialization));
     }
 
     //TODO check only demand for this particular topic.
     size_t sizeDemand = function->contextCompiler.getFunctionDemandSize();
 
     //decision made if static context found or no late context exists(and there is default variant)
     bool flagHasStaticDecision = variant || (variantDefault && !sizeDemand);
 
     //if no late context exists
     if (flagHasStaticDecision) {
         IFunctionUnit* calleeUnit = pass->getFunctionUnit(variant ? *variant : *variantDefault);
 
         //inlining possible based on static decision only
         //        if (calleeUnit->isInline()) {
         //            return new CallStatementInline(function, calleeUnit);
         //        }
 
         return new CallStatementRaw(calleeUnit->compile(), llvm);
     }
 
     //require default variant if no static decision made
     assert(variantDefault);
 
     llvm::Function* functionVariantDefault = this->pass->getFunctionUnit(*variantDefault)->compile();
     llvm::Value* resultFn = function->contextCompiler.findFunction(calleeName, functionVariantDefault, scopeCaller);
     llvm::PointerType *resultPTy = cast<llvm::PointerType>(resultFn->getType());
     llvm::FunctionType *resultFTy = cast<llvm::FunctionType>(resultPTy->getElementType());
     return new CallStatementRaw(resultFn, resultFTy, llvm);
 }
 
 
 
 //DISABLEDFEATURE transformations
 //    if (pass->transformations->isAcceptable(expr)){
 //        return pass->transformations->transform(expr, result, ctx);
 //    }
 
 llvm::Value*
 BasicCodeScopeUnit::process(const Expression& expr, const std::string& hintVarDecl) {
 #define DEFAULT(x) (hintVarDecl.empty()? x: hintVarDecl)
     llvm::Value *left;
     llvm::Value *right;
     LLVMLayer& l = *pass->man->llvm;
     xreate::compilation::AdvancedInstructions instructions = xreate::compilation::AdvancedInstructions({this, function, pass});
 
     switch (expr.op) {
         case Operator::SUB: case Operator::MUL:
         case Operator::DIV: case Operator::EQU: case Operator::LSS:
         case Operator::GTR: case Operator::NE: case Operator::LSE:
         case Operator::GTE:
 
             assert(expr.__state == Expression::COMPOUND);
             assert(expr.operands.size() == 2);
 
             left = process(expr.operands[0]);
             right = process(expr.operands[1]);
 
             //SECTIONTAG types/convert binary operation
             right = typeinference::doAutomaticTypeConversion(right, left->getType(), l.builder);
             break;
 
         default:;
     }
 
     switch (expr.op) {
         case Operator::ADD:
         {
             left = process(expr.operands[0]);
             Context context{this, function, pass};
 
             llvm::Value* resultSU = StructUpdate::add(expr.operands[0], left, expr.operands[1], context, DEFAULT("tmp_add"));
             if (resultSU) return resultSU;
 
             right = process(expr.operands[1]);
 
             llvm::Value* resultAddPA = pointerarithmetic::PointerArithmetic::add(left, right, context, DEFAULT("tmp_add"));
             if (resultAddPA) {
                 return resultAddPA;
             }
 
             return l.builder.CreateAdd(left, right, DEFAULT("tmp_add"));
             break;
         }
 
         case Operator::SUB:
             return l.builder.CreateSub(left, right, DEFAULT("tmp_sub"));
             break;
 
         case Operator::MUL:
             return l.builder.CreateMul(left, right, DEFAULT("tmp_mul"));
             break;
 
         case Operator::DIV:
             return l.builder.CreateSDiv(left, right, DEFAULT("tmp_div"));
             break;
 
         case Operator::EQU:
             if (left->getType()->isIntegerTy()) return l.builder.CreateICmpEQ(left, right, DEFAULT("tmp_equ"));
             if (left->getType()->isFloatingPointTy()) return l.builder.CreateFCmpOEQ(left, right, DEFAULT("tmp_equ"));
             break;
 
         case Operator::NE:
             return l.builder.CreateICmpNE(left, right, DEFAULT("tmp_ne"));
             break;
 
         case Operator::LSS:
             return l.builder.CreateICmpSLT(left, right, DEFAULT("tmp_lss"));
             break;
 
         case Operator::LSE:
             return l.builder.CreateICmpSLE(left, right, DEFAULT("tmp_lse"));
             break;
 
         case Operator::GTR:
             return l.builder.CreateICmpSGT(left, right, DEFAULT("tmp_gtr"));
             break;
 
         case Operator::GTE:
             return l.builder.CreateICmpSGE(left, right, DEFAULT("tmp_gte"));
             break;
 
         case Operator::NEG:
             left = process(expr.operands[0]);
             return l.builder.CreateNeg(left, DEFAULT("tmp_neg"));
             break;
 
         case Operator::CALL:
         {
             assert(expr.__state == Expression::COMPOUND);
             shared_ptr<ICallStatement> callee(findFunction(expr));
             const std::string& nameCallee = expr.getValueString();
 
             //prepare arguments
             std::vector<llvm::Value *> args;
             args.reserve(expr.operands.size());
 
             std::transform(expr.operands.begin(), expr.operands.end(), std::inserter(args, args.end()),
                 [this](const Expression & operand) {
                     return process(operand);
                 }
             );
 
             ScopePacked outerScopeId = pass->man->clasp->pack(this->scope);
 
             //TASK a) refactor CALL/ADHOC/find function
             //SECTIONTAG late-context propagation arg
             size_t calleeDemandSize = pass->queryContext->getFunctionDemand(nameCallee).size();
             if (calleeDemandSize) {
                 DefaultFunctionUnit* function = dynamic_cast<DefaultFunctionUnit*> (this->function);
                 llvm::Value* argLateContext = function->contextCompiler.compileContextArgument(nameCallee, outerScopeId);
                 args.push_back(argLateContext);
             }
 
             return (*callee)(move(args), DEFAULT("res_" + nameCallee));
         }
 
         case Operator::IF:
         {
             return instructions.compileIf(expr, DEFAULT("tmp_if"));
         }
 
         case Operator::SWITCH:
         {
             return instructions.compileSwitch(expr, DEFAULT("tmp_switch"));
         }
 
         case Operator::LOOP_CONTEXT:
         {
             assert(false);
             return nullptr;
             //return instructions.compileLoopContext(expr, DEFAULT("tmp_loop"));
         }
 
         case Operator::LOGIC_AND:
         {
             assert(expr.operands.size() == 1);
             return process(expr.operands[0]);
         }
 
         case Operator::LIST:
         {
             return instructions.compileListAsSolidArray(expr, DEFAULT("tmp_list"));
         };
 
         case Operator::LIST_RANGE:
         {
             assert(false); //no compilation phase for a range list
             //  return InstructionList(this).compileConstantArray(expr, l, hintRetVar);
         };
 
         case Operator::LIST_NAMED:
         {
             typedef Expanded<TypeAnnotation> ExpandedType;
 
             ExpandedType tyStructLiteral = l.ast->getType(expr);
 
             const std::vector<string> fieldsFormal = (tyStructLiteral.get().__operator == TypeOperator::CUSTOM) ?
                     l.layerExtern->getStructFields(l.layerExtern->lookupType(tyStructLiteral.get().__valueCustom))
                     : tyStructLiteral.get().fields;
 
             std::map<std::string, size_t> indexFields;
             for (size_t i = 0, size = fieldsFormal.size(); i < size; ++i) {
                 indexFields.emplace(fieldsFormal[i], i);
             }
 
             llvm::StructType* tyLiteralRaw = llvm::cast<llvm::StructType>(l.toLLVMType(tyStructLiteral));
             llvm::Value* record = llvm::UndefValue::get(tyLiteralRaw);
 
             for (size_t i = 0; i < expr.operands.size(); ++i) {
                 const Expression& operand = expr.operands.at(i);
                 unsigned int fieldId = indexFields.at(expr.bindings.at(i));
                 llvm::Value* result = process(operand);
                 assert(result);
                 record = l.builder.CreateInsertValue(record, result, llvm::ArrayRef<unsigned>({fieldId}));
             }
 
             return record;
         };
 
         case Operator::MAP:
         {
             assert(expr.blocks.size());
             return instructions.compileMapSolidOutput(expr, DEFAULT("map"));
         };
 
         case Operator::FOLD:
         {
             return instructions.compileFold(expr, DEFAULT("fold"));
         };
 
         case Operator::FOLD_INF:
         {
             return instructions.compileFoldInf(expr, DEFAULT("fold"));
         };
 
         case Operator::INDEX:
         {
             //TASK allow multiindex compilation
             assert(expr.operands.size() == 2);
             assert(expr.operands[0].__state == Expression::IDENT);
 
             const std::string& hintIdent = expr.operands[0].getValueString();
             Symbol s = Attachments::get<IdentifierSymbol>(expr.operands[0]);
             const ExpandedType& t2 = pass->man->root->getType(expr.operands[0]);
 
             llvm::Value* aggr = processSymbol(s, hintIdent);
 
             switch (t2.get().__operator) {
                 case TypeOperator::LIST_NAMED: case TypeOperator::CUSTOM:
                 {
                     std::string idxField;
                     const Expression& idx = expr.operands.at(1);
                     switch (idx.__state) {
 
                             //named struct field
                         case Expression::STRING:
                             idxField = idx.getValueString();
                             break;
 
                             //anonymous struct field
                         case Expression::NUMBER:
                             idxField = to_string((int) idx.getValueDouble());
                             break;
 
                         default:
                             assert(false && "Wrong index for a struct");
                     }
 
                     return instructions.compileStructIndex(aggr, t2, idxField);
                 };
 
                 case TypeOperator::LIST:
                 {
                     std::vector<llvm::Value*> indexes;
                     std::transform(++expr.operands.begin(), expr.operands.end(), std::inserter(indexes, indexes.end()),
                             [this] (const Expression & op) {
                                 return process(op);
                             }
                     );
 
                     return instructions.compileArrayIndex(aggr, indexes, DEFAULT(string("el_") + hintIdent));
                 };
 
                 default:
                     assert(false);
             }
         };
 
             //SECTIONTAG adhoc actual compilation
             //TODO a) make sure that it's correct: function->adhocImplementation built for Entry scope and used in another scope
         case Operator::ADHOC:
         {
             DefaultFunctionUnit* function = dynamic_cast<DefaultFunctionUnit*> (this->function);
             assert(function->adhocImplementation && "Adhoc implementation not found");
             const Expression& comm = adhoc::AdhocExpression(expr).getCommand();
 
             CodeScope* scope = function->adhocImplementation->getCommandImplementation(comm);
             ICodeScopeUnit* unitScope = function->getScopeUnit(scope);
 
             //SECTIONTAG types/convert ADHOC ret convertation
             llvm::Type* resultTy = l.toLLVMType(pass->man->root->expandType(function->adhocImplementation->getResultType()));
             return typeinference::doAutomaticTypeConversion(unitScope->compile(), resultTy, l.builder);
         };
 
         case Operator::CALL_INTRINSIC:
         {
             const std::string op = expr.getValueString();
 
             if (op == "copy") {
                 llvm::Value* result = process(expr.getOperands().at(0));
 
                 auto decoratorVersions = Decorators<VersionsScopeDecoratorTag>::getInterface(this);
                 llvm::Value* storage = decoratorVersions->processIntrinsicInit(result->getType());
                 decoratorVersions->processIntrinsicCopy(result, storage);
 
                 return l.builder.CreateLoad(storage, hintVarDecl);
             }
 
             assert(false && "undefined intrinsic");
         }
 
         case Operator::VARIANT:
         {
             const ExpandedType& typVariant = pass->man->root->getType(expr);
             llvm::Type* typVariantRaw = l.toLLVMType(typVariant);
             llvm::Type* typIdRaw = llvm::cast<llvm::StructType>(typVariantRaw)->getElementType(0);
 
             uint64_t id = expr.getValueDouble();
             llvm::Value* variantRaw = llvm::UndefValue::get(typVariantRaw);
             variantRaw = l.builder.CreateInsertValue(variantRaw, llvm::ConstantInt::get(typIdRaw, id), llvm::ArrayRef<unsigned>({0}));
 
             const bool flagDoReference =  expr.operands.size();
             if (flagDoReference){
                 const ExpandedType& subtyp = ExpandedType(typVariant->__operands.at(id));
                 llvm::Type* subtypRaw = l.toLLVMType(subtyp);
                 Attachments::put<TypeInferred>(expr.operands.at(0), subtyp);
                 llvm::Value* subtypValue = process(expr.operands.at(0));
 
                 llvm::Type* typStorageRaw = llvm::cast<llvm::StructType>(typVariantRaw)->getElementType(1);
                 llvm::Value* addrAsStorage = l.builder.CreateAlloca(typStorageRaw);
                 llvm::Value* addrAsSubtyp =  l.builder.CreateBitOrPointerCast(addrAsStorage, subtypRaw->getPointerTo());
 
                 l.builder.CreateStore(subtypValue, addrAsSubtyp);
                 llvm::Value* storageRaw = l.builder.CreateLoad(typStorageRaw, addrAsStorage);
                 variantRaw = l.builder.CreateInsertValue(variantRaw, storageRaw, llvm::ArrayRef<unsigned>({1}));
             }
 
             return variantRaw;
         }
 
         case Operator::SWITCH_VARIANT:
         {
             return instructions.compileSwitchVariant(expr, DEFAULT("tmpswitch"));
         }
 
         case Operator::NONE:
             assert(expr.__state != Expression::COMPOUND);
 
             switch (expr.__state) {
                 case Expression::IDENT:
                 {
                     Symbol s = Attachments::get<IdentifierSymbol>(expr);
                     return processSymbol(s, expr.getValueString());
                 }
 
                 case Expression::NUMBER:
                 {
                     llvm::Type* typConst;
 
                     if (expr.type.isValid()) {
                         typConst = l.toLLVMType(pass->man->root->getType(expr));
 
                     } else {
                         typConst = llvm::Type::getInt32Ty(llvm::getGlobalContext());
                     }
 
                     int literal = expr.getValueDouble();
                     return llvm::ConstantInt::get(typConst, literal);
                 }
 
                 case Expression::STRING:
                 {
                     return instructions.compileConstantStringAsPChar(expr.getValueString(), DEFAULT("tmp_str"));
                 };
 
                 default:
                 {
                     break;
                 }
             };
 
             break;
 
         default: break;
 
     }
 
     assert(false && "Can't compile expression");
     return 0;
 }
 
 llvm::Value*
 BasicCodeScopeUnit::compile(const std::string& hintBlockDecl) {
     if (!hintBlockDecl.empty()) {
         llvm::BasicBlock *block = llvm::BasicBlock::Create(llvm::getGlobalContext(), hintBlockDecl, function->raw);
         pass->man->llvm->builder.SetInsertPoint(block);
     }
 
+    currentBlockRaw = pass->man->llvm->builder.GetInsertBlock();
     Symbol symbScope = Symbol{ScopedSymbol::RetSymbol, scope};
     return processSymbol(symbScope);
 }
 
 ICodeScopeUnit::~ICodeScopeUnit() {
 }
 
 IFunctionUnit::~IFunctionUnit() {
 }
 
 llvm::Function*
 IFunctionUnit::compile() {
     if (raw != nullptr) return raw;
 
     LLVMLayer* llvm = pass->man->llvm;
     llvm::IRBuilder<>& builder = llvm->builder;
 
     string&& functionName = prepareName();
     std::vector<llvm::Type*>&& types = prepareArguments();
     llvm::Type* expectedResultType = prepareResult();
 
     llvm::FunctionType *ft = llvm::FunctionType::get(expectedResultType, types, false);
     raw = llvm::cast<llvm::Function>(llvm->module->getOrInsertFunction(functionName, ft));
     prepareBindings();
 
     const std::string&blockName = "entry";
     llvm::BasicBlock* blockCurrent = builder.GetInsertBlock();
 
     llvm::Value* result = getScopeUnit(function->__entry)->compile(blockName);
     assert(result);
 
     //SECTIONTAG types/convert function ret value
     builder.CreateRet(typeinference::doAutomaticTypeConversion(result, expectedResultType, llvm->builder));
 
     if (blockCurrent) {
         builder.SetInsertPoint(blockCurrent);
     }
 
     llvm->moveToGarbage(ft);
     return raw;
 }
 
 ICodeScopeUnit*
 IFunctionUnit::getScopeUnit(const CodeScope * const scope) {
     if (__scopes.count(scope)) {
         auto result = __scopes.at(scope).lock();
 
         if (result) {
             return result.get();
         }
     }
 
     std::shared_ptr<ICodeScopeUnit> unit(pass->buildCodeScopeUnit(scope, this));
 
     if (scope->__parent != nullptr) {
         auto parentUnit = Decorators<CachedScopeDecoratorTag>::getInterface(getScopeUnit(scope->__parent));
         parentUnit->registerChildScope(unit);
 
     } else {
         __orphanedScopes.push_back(unit);
     }
 
     if (!__scopes.emplace(scope, unit).second) {
         __scopes[scope] = unit;
     }
 
     return unit.get();
 }
 
 ICodeScopeUnit*
 IFunctionUnit::getScopeUnit(ManagedScpPtr scope) {
     return getScopeUnit(&*scope);
 }
 
 ICodeScopeUnit*
 IFunctionUnit::getEntry() {
     return getScopeUnit(function->getEntryScope());
 }
 
 template<>
 compilation::IFunctionUnit*
 CompilePassCustomDecorators<void, void>::buildFunctionUnit(const ManagedFnPtr& function){
     return new DefaultFunctionUnit(function, this);
 }
 
 template<>
 compilation::ICodeScopeUnit*
 CompilePassCustomDecorators<void, void>::buildCodeScopeUnit(const CodeScope* const scope, IFunctionUnit* function){
     return new DefaultCodeScopeUnit(scope, function, this);
 }
 
 } // emf of compilation
 
 IFunctionUnit*
 CompilePass::getFunctionUnit(const ManagedFnPtr& function) {
     unsigned int id = function.id();
 
     if (!functions.count(id)) {
         IFunctionUnit* unit = buildFunctionUnit(function);
         functions.emplace(id, unit);
         return unit;
     }
 
     return functions.at(id);
 }
 
 void
 CompilePass::run() {
     managerTransformations = new TransformationsManager();
     targetInterpretation = new interpretation::TargetInterpretation(this->man->root, this);
     queryContext = reinterpret_cast<context::ContextQuery*> (man->clasp->getQuery(QueryId::ContextQuery));
 
     //Find out main function;
     ClaspLayer::ModelFragment model = man->clasp->query(Config::get("function-entry"));
     assert(model && "Error: No entry function found");
     assert(model->first != model->second && "Error: Ambiguous entry function");
 
     string nameMain = std::get<0>(ClaspLayer::parse<std::string>(model->first->second));
     IFunctionUnit* unitMain = getFunctionUnit(man->root->findFunction(nameMain));
     entry = unitMain->compile();
 }
 
 llvm::Function*
 CompilePass::getEntryFunction() {
     assert(entry);
     return entry;
 }
 
 void
 CompilePass::prepareQueries(ClaspLayer* clasp) {
     clasp->registerQuery(new containers::Query(), QueryId::ContainersQuery);
     clasp->registerQuery(new context::ContextQuery(), QueryId::ContextQuery);
 
     Attachments::init<PolymorphGuard>();
     clasp->registerQuery(new polymorph::PolymorphQuery(), QueryId::PolymorphQuery);
 }
 } //end of namespace xreate
 
 /**
  * \class xreate::CompilePass
  * \brief Encapsulates all compilation activities
  *
  * xreate::CompilePass iterates over xreate::AST tree and produces executable code fed by data(via xreate::Attachments) gathered by previous passes  as well as data via queries(xreate::IQuery) from xreate:ClaspLayer reasoner.
  * Compilation's done using xreate::LLVMLayer(wrapper over LLVM toolchain) and based on following aspects:
  *   - Containers support. See \ref compilation/containers.h
  *   - Late Conext compilation. See xreate::context::LateContextCompiler2
  *   - Interpretation support. See xreate::interpretation::TargetInterpretation
  *   - Loop saturation support. See xreate::compilation::TransformerSaturation
  *   - External Code access. See xreate::ExternLayer(wrapper over Clang library)
  *
  * \section adaptability_sect Adaptability
  * xreate::CompilePass's architecture provides adaptability by employing:
  *   - %Function Decorators to alter function-level compilation. See xreate::compilation::IFunctionUnit
  *   - Code Block Decorators to alter code block level compilation. See xreate::compilation::ICodeScopeUnit
  *     Default functionality defined by \ref xreate::compilation::DefaultCodeScopeUnit
  *   - Targets to allow more versitile extensions.
  *     Currently only xreate::interpretation::TargetInterpretation  use Targets infrastructure. See xreate::compilation::Target
  *   - %Altering Function invocation. xreate::compilation::ICallStatement
  *
  * Client able to construct compiler with desired decorators using xreate::compilation::CompilePassCustomDecorators.
  * As a handy alias, `CompilePassCustomDecorators<void, void>` constructs default compiler
  *
  */
diff --git a/cpp/src/pass/compilepass.h b/cpp/src/pass/compilepass.h
index 7bc170f..148012b 100644
--- a/cpp/src/pass/compilepass.h
+++ b/cpp/src/pass/compilepass.h
@@ -1,218 +1,219 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  * 
  * Author: pgess <v.melnychenko@xreate.org>
  * 
  * compilepass.h
  */
 
 #ifndef COMPILEPASS_H
 #define COMPILEPASS_H
 
 #include "abstractpass.h"
 
 #include "llvm/IR/Function.h"
 
 namespace xreate {
     class ClaspLayer;
     class CompilePass;
     class LLVMLayer;
     
     namespace adhoc{
         class AdhocScheme;
     }
     
     namespace context{
         class ContextQuery;
         class LateContextCompiler2;
     }
     
     namespace interpretation{
         class TargetInterpretation;
     }
 }
 
 namespace xreate { namespace compilation {
 
 class ICodeScopeUnit;
 class IFunctionUnit;
 class TransformationsManager;
 
 /** \brief Holds current position in %AST while traversing*/
 struct Context{
     ICodeScopeUnit* scope;
     IFunctionUnit* function;
     CompilePass* pass;
 };
 
 /** \brief Interface to specify custom way of function invocation 
  *  \details Default implementation is xreate::compilation::CallStatementRaw
  */
 class ICallStatement {
 public:
     /** \brief Returns result of custom function invocation for given arguments*/
     virtual llvm::Value* operator() (std::vector<llvm::Value *>&& args, const std::string& hintDecl="") = 0;
 };
 
 /** \brief Default ICallStatement implementation */
 class CallStatementRaw: public ICallStatement{
 public:
     CallStatementRaw(llvm::Function* callee, LLVMLayer* l)
         : __callee(callee), __calleeTy(callee->getFunctionType()), llvm(l) {}
     CallStatementRaw(llvm::Value* callee, llvm::FunctionType* ty, LLVMLayer* l)
         : __callee(callee), __calleeTy(ty), llvm(l) {}
     
     /** \brief Makes type conversions and returns LLVM call statement with given arguments*/
     llvm::Value* operator() (std::vector<llvm::Value *>&& args, const std::string& hintDecl="");
         
 private:
     llvm::Value* __callee;        
     llvm::FunctionType* __calleeTy;
     LLVMLayer* llvm;
 };
 
 /** \brief Interface to allow modification of CodeScope compilation
  *  \details Default implementation defined in xreate::compilation::DefaultCodeScopeUnit
  */
 class ICodeScopeUnit{
 public:
     CompilePass* const pass;
     IFunctionUnit* const function;
     const CodeScope* const scope;
+    llvm::BasicBlock* currentBlockRaw;
     
     ICodeScopeUnit(const CodeScope* const codeScope, IFunctionUnit* f, CompilePass* compilePass);
     virtual ~ICodeScopeUnit();
 
     virtual llvm::Value* compile(const std::string& hintBlockDecl="")=0;
     virtual llvm::Value* processSymbol(const Symbol& s, std::string hintRetVar="")=0;
     virtual llvm::Value* process(const Expression& expr, const std::string& hintVarDecl="")=0;
     
     virtual Symbol bindArg(llvm::Value* value, std::string&& alias)=0;
     virtual void bindArg(llvm::Value* value, const ScopedSymbol& s)=0;
 
 protected:
     virtual ICallStatement* findFunction(const Expression& opCall)=0;
 };
 
 /** \brief Minimal useful ICodeScopeUnit implementation suited for inheritance */
 class BasicCodeScopeUnit: public ICodeScopeUnit{
 public:
     BasicCodeScopeUnit(const CodeScope* const codeScope, IFunctionUnit* f, CompilePass* compilePass);
 
     llvm::Value* processSymbol(const Symbol& s, std::string hintRetVar="") override;
     llvm::Value* process(const Expression& expr, const std::string& hintVarDecl="") override;
     llvm::Value* compile(const std::string& hintBlockDecl="") override;
     
 protected:
     ICallStatement* findFunction(const Expression& opCall) override;
 };
 
 /** \brief Interface to specify compilation of %Function */
 class IFunctionUnit{
 public:
    IFunctionUnit(ManagedFnPtr f, CompilePass* p): function(f), pass(p) {}
    virtual ~IFunctionUnit();
 
     llvm::Function* compile();
 
     ICodeScopeUnit* getEntry();
     ICodeScopeUnit* getScopeUnit(const CodeScope * const scope);
     ICodeScopeUnit* getScopeUnit(ManagedScpPtr scope);
 
     ManagedFnPtr function;
     llvm::Function* raw = nullptr;
     
 protected:
     CompilePass* pass=nullptr;
     
     virtual std::string prepareName() = 0;
     virtual std::vector<llvm::Type*>  prepareArguments() = 0;
     virtual llvm::Type* prepareResult() = 0;
     virtual llvm::Function::arg_iterator prepareBindings() = 0;
     
 private:
     std::map<const CodeScope * const, std::weak_ptr<ICodeScopeUnit>> __scopes;
     std::list<std::shared_ptr<ICodeScopeUnit>> __orphanedScopes;
 };
 
 /** \brief Minimal useful IFunctionUnit implementation suited for inheritance */
 class BasicFunctionUnit: public IFunctionUnit{
 public:
     BasicFunctionUnit(ManagedFnPtr f, CompilePass* p)
     : IFunctionUnit(f, p) {}
 
 protected:
     std::string prepareName() override;
     virtual std::vector<llvm::Type*>  prepareArguments() override;
     virtual llvm::Type* prepareResult() override;
     virtual llvm::Function::arg_iterator prepareBindings() override;
 };
 } // end of namespace compilation
 
 class CompilePass : public AbstractPass<void> {
     friend class context::LateContextCompiler2;
     friend class compilation::BasicCodeScopeUnit;
     friend class compilation::IFunctionUnit;
 
 public:
     compilation::TransformationsManager* managerTransformations;
     interpretation::TargetInterpretation* targetInterpretation;
     
     CompilePass(PassManager* manager): AbstractPass<void>(manager) {}
     /** \brief Executes compilation process */
     void run() override;
     
     /**\brief Returns compiled specified %Function
      * \details Executes function compilation or read cache if it's already done
      */
     compilation::IFunctionUnit* getFunctionUnit(const ManagedFnPtr& function);
     
     /**\brief Returns compiled main(entry) %Function in program */
     llvm::Function* getEntryFunction();
     
     /** \brief Initializes queries required by compiler. See xreate::IQuery, xreate::ClaspLayer */
     static void prepareQueries(ClaspLayer* clasp);
     
     
     
 protected:
     virtual compilation::IFunctionUnit* buildFunctionUnit(const ManagedFnPtr& function)=0;
     virtual compilation::ICodeScopeUnit* buildCodeScopeUnit(const CodeScope* const scope, compilation::IFunctionUnit* function)=0;
     
 private:
     //TODO free `functions` in destructor
     std::map<unsigned int, compilation::IFunctionUnit*> functions;
     llvm::Function* entry = 0;
 
     context::ContextQuery* queryContext;    
 };
 
 namespace compilation{
 
 /** \brief Constructs compiler with desired %Function and %Code Scope decorators. See adaptability in xreate::CompilePass*/    
 template<class FUNCTION_DECORATOR=void, class SCOPE_DECORATOR=void>
 class CompilePassCustomDecorators: public ::xreate::CompilePass{
 public:
     CompilePassCustomDecorators(PassManager* manager): ::xreate::CompilePass(manager) {}
     
     virtual compilation::IFunctionUnit* buildFunctionUnit(const ManagedFnPtr& function) override{
         return new FUNCTION_DECORATOR(function, this);
     }
     
     virtual compilation::ICodeScopeUnit* buildCodeScopeUnit(const CodeScope* const scope, IFunctionUnit* function) override{
         return new SCOPE_DECORATOR(scope, function, this);
     }        
 };
 
 template<>
 compilation::IFunctionUnit* 
 CompilePassCustomDecorators<void, void>::buildFunctionUnit(const ManagedFnPtr& function);
 
 template<>
 compilation::ICodeScopeUnit*
 CompilePassCustomDecorators<void, void>::buildCodeScopeUnit(const CodeScope* const scope, IFunctionUnit* function);
 
 }} //end of namespace xreate::compilation
 
 #endif // COMPILEPASS_H
diff --git a/cpp/tests/compilation.cpp b/cpp/tests/compilation.cpp
index b383279..5e61494 100644
--- a/cpp/tests/compilation.cpp
+++ b/cpp/tests/compilation.cpp
@@ -1,187 +1,201 @@
 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/
  *
  * compilation.cpp
  *
  *  Created on: -
  *      Author: pgess <v.melnychenko@xreate.org>
  */
 
 #include "xreatemanager.h"
 #include "gtest/gtest.h"
 using namespace xreate;
 //DEBT implement no pkgconfig ways to link libs
-
 //TOTEST FunctionUnit::compileInline
-TEST(Compilation, DISABLED_functionInline1){
-}
 
 TEST(Compilation, functionEntry1){
     std::unique_ptr<XreateManager> program(XreateManager::prepare(
         "func1 = function(a:: int):: int {a+8} \
          func2 = function::int; entry {12 + func1(4)}      \
         "));
 
     void* entryPtr = program->run();
     int (*entry)() = (int (*)())(intptr_t)entryPtr;
 
     int answer = entry();
     ASSERT_EQ(24, answer);
 }
 
 TEST(Compilation, full_IFStatementWithVariantType){
     XreateManager* man = XreateManager::prepare(
         "Color = type variant {RED, BLUE, GREEN}.\n"
         "\n"
         "   main = function(x::int):: bool; entry {\n"
         "       color = if (x == 0 )::Color {RED()} else {BLUE()}.\n"
         "       if (color == BLUE())::bool {true} else {false}\n"
         "   }"
     );
 
     bool (*main)(int) = (bool (*)(int)) man->run();
     ASSERT_FALSE(main(0));
     ASSERT_TRUE(main(1));
 }
 
 TEST(Compilation, full_Variant1){
     XreateManager* man = XreateManager::prepare(R"Code(
         OneArgument = type{x::int}.
         TwoArguments = type{x::int, y::int}.
 
         Command= type variant{
             Add::TwoArguments,
             Dec::OneArgument
         }.
 
         main = function::Command; entry {
             Dec({x=2})::Command
         }
     )Code");
 
     void (*main)() = (void (*)()) man->run();
 }
 
 TEST(Compilation, full_SwitchVariant1){
     XreateManager* man = XreateManager::prepare(R"Code(
         OneArgument = type{x::int}.
         TwoArguments = type{x::int, y::int}.
 
         Command= type variant{
             Add::TwoArguments,
             Dec::OneArgument
         }.
 
         main = function::int; entry {
             //command = Dec({x = 8}):: Command.
             command = Add({x= 3, y= 5}):: Command.
 
             switch variant(command)::int
             case(Add){command["x"] + command["y"]}
             case(Dec){command["x"]}
         }
     )Code");
 
     int (*mainFn)() = (int (*)()) man->run();
     int result = mainFn();
     ASSERT_EQ(8, result);
 }
 
 TEST(Compilation, full_SwitchVariantNoArguments2){
     XreateManager* man = XreateManager::prepare(R"Code(
         Command= type variant{Add, Dec}.
 
         main = function::int; entry {
             command = Dec():: Command.
 
             switch variant(command)::int
             case(Add){0}
             case(Dec){1}
         }
     )Code");
 
     int (*mainFn)() = (int (*)()) man->run();
     int result = mainFn();
     ASSERT_EQ(1, result);
 }
 
 TEST(Compilation, full_SwitchVariantMixedArguments3){
     XreateManager* man = XreateManager::prepare(R"Code(
         TwoArguments = type{x::int, y::int}.
         Command= type variant{
             Add::TwoArguments,
             Dec
         }.
 
         main = function(arg::int)::     int; entry {
             command = if (arg > 0)::Command {Dec()} else {Add({x=1,y=2})}.
 
             switch variant(command)::int
             case(Add){0}
             case(Dec){1}
         }
     )Code");
 
     int (*mainFn)(int) = (int (*)(int)) man->run();
     int result = mainFn(5);
     ASSERT_EQ(1, result);
 }
 
 TEST(Compilation, full_StructUpdate){
     XreateManager* man = XreateManager::prepare(
     R"Code(
 
     Rec = type {
         a :: int,
         b:: int
     }.
 
     test= function:: int; entry {
         a = {a = 18, b = 20}:: Rec.
 
         b = a + {a = 11}:: Rec.
         b["a"]
     }
     )Code");
 
     int (*main)() = (int (*)()) man->run();
     int result = main();
 
     ASSERT_EQ(11, result);
 }
 
 TEST(Compilation, AnonymousStruct_init_index){
     std::string code =
 R"Code(
 
     main = function:: int; entry {
         x = {10, 15} :: {int, int}.
         x[1]
     }
 
 )Code";
 
     std::unique_ptr<XreateManager> man(XreateManager::prepare(move(code)));
     int (*main)() = (int (*)()) man->run();
 
     EXPECT_EQ(15, main());
 }
 
 TEST(Compilation, AnonymousStruct_init_update){
     std::string code =
 R"Code(
 
     main = function:: int; entry {
         x = {10, 15} :: {int, int}.
         y = x + {6}:: {int, int}.
         y[0]
     }
 
 )Code";
 
     std::unique_ptr<XreateManager> man(XreateManager::prepare(move(code)));
     int (*main)() = (int (*)()) man->run();
 
     EXPECT_EQ(6, main());
 }
 
+TEST(Compilation, BugIncorrectScopes1){
+    std::string code =
+R"Code(
+
+    init = function:: int {10}
+    main = function(cmd:: int):: int; entry {
+        x = init():: int.
+        if(cmd > 0):: int { x + 1 } else { x }
+    }
+)Code";
+
+    std::unique_ptr<XreateManager> man(XreateManager::prepare(move(code)));
+    int (*mainFn)(int) = (int (*)(int)) man->run();
+
+    EXPECT_EQ(11, mainFn(1));
+}
+
diff --git a/cpp/tests/main.cpp b/cpp/tests/main.cpp
index 5186ff6..5ab9a9b 100644
--- a/cpp/tests/main.cpp
+++ b/cpp/tests/main.cpp
@@ -1,23 +1,24 @@
 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/
  *
  * main.cpp
  *
  *  Created on: -
  *      Author: pgess <v.melnychenko@xreate.org>
  */
 
 #include "utils.h"
 #include <gtest/gtest.h>
 
 using namespace std;
 using namespace xreate;
 
-int main(int argc, char **argv) {    testing::GTEST_FLAG(color) = "yes";
-
+int main(int argc, char **argv) {
+    testing::GTEST_FLAG(color) = "yes";
     string testsTemplate = Config::get("tests.template");
     string testsFilter = Config::get(string("tests.templates.") + testsTemplate);
     testing::GTEST_FLAG(filter) = testsFilter;
     testing::InitGoogleTest(&argc, argv);
+    
     return RUN_ALL_TESTS();
 }