tekBlueprint

<expression>          → <block> EOF
                      | <ternary-expression> EOF

<or-expression>       → <and-expression> ("||" <and-expression>)*

<and-expression>      → <equality-expression> ("&&" <equality-expression>)*

<ternary-expression>  → <or-expression> ("?" <or-expression> ":" <ternary-expression>)?

<equality-expression> → <relational-expression> (("==" | "!=") <relational-expression>)*

<relational-expression> → <additive-expression> (("<" | ">" | "<=" | ">=") <additive-expression>)?

<additive-expression>   → <multiplicative-expression> (("+" | "-") <multiplicative-expression>)*

<multiplicative-expression> → <unary-expression> (("*" | "/" | "%") <unary-expression>)*

<unary-expression>  → ("-" | "!") <unary-expression>
                    | <if-else-expression>

<if-else-expression> → <member-access>
                     | "if" "(" <expression-inner> ")" <block> ("else" (<block> | <if-else-expression>))?

<member-access>     → <primary> ("." <member-segment>)*

<grouped-expression>→ "(" <expression-inner> ")"

<primary>           → <grouped-expression>
                    | <function-call>
                    | <ref-expression>
                    | <number>
                    | <string-literal>
                    | "true" | "false"
                    | "null"
                    | <identifier>

<ref-expression>    → "ref" <string-literal>

<member-segment>    → <identifier> ("(" [<expression-inner> ("," <expression-inner>)*] ")")?

<function-call>     → <identifier> "(" [<expression-inner> ("," <expression-inner>)*] ")"

<block>             → "{" (<block-item>+ | <expression-inner>) "}"

<block-item>        → <if-else-expression> ";"?
                    | "return" <expression-inner> ";"
                    | <expression-inner> ";"

<expression-inner>  → <ternary-expression>

<number>            → <digit>+ ["." <digit>+ ] ([eE] [-|+] <digit>+)?
<string-literal>    → '"' <chars> '"' | '\'' <chars> '\''
<identifier>        → [a-zA-Z_] [a-zA-Z0-9_]*

// Простое арифметическое выражение
2 * x + y / 3.14

// Условная логика с тернарным оператором
status == "active" ? price * discount : price

// Блок с if/else и ранним возвратом
{
    if (count > 0) {
        return total / count;
    } else {
        return 0;
    }
}

// Цепочка условий через else if
if (level == "high") {
    priority = 1;
} else if (level == "medium") {
    priority = 2;
} else {
    priority = 3;
}

// Вызов функции с доступом к полям объекта
statistics.probeBytesPerSecond * duration / 1024.0

// Безопасное приведение -- возвращает значение по умолчанию при несовпадении типа
double d = value.toDouble(0.0);    // 0.0 если значение не числовое
String s = value.toString("");      // "" если значение null или void

// Строгий доступ -- выбрасывает исключение при несовпадении типа
int i = value.asInt32();            // ошибка, если тип не INT*
boolean b = value.asBoolean();      // ошибка, если тип не BOOL

// Псевдокод оркестратора оптимизаций
Node optimize(Node ast, OptimizationOptions options) {
    Node current = ast;
    for (int i = 0; i < options.maxPasses; i++) {
        Node previous = deepCopy(current);

        // Применяем все включённые проходы последовательно
        for (OptimizationPass pass : options.enabledPasses) {
            current = pass.optimize(current);
        }

        // Проверяем структурное равенство -- если дерево не изменилось, выходим
        if (AstComparator.equals(previous, current)) {
            break;
        }
    }
    return current;
}

// Структура VM (на основе ExpressionVm.java)
class ExpressionVm {
    byte[] tags;              // опкоды инструкций (0–28)
    int[] operands;           // операнд для каждой инструкции
    double[] constants;       // пул числовых констант
    String[] strings;         // пул строк-литералов
    Object[] objects;         // пул объектов (для ref-выражений)

    String[] varNames;        // таблица имён переменных → индекс для LOAD_VAR
    String[] fnNames;         // таблица имён функций → индекс для CALL_FN

    double[] stack = new double[128];  // стек значений
    byte[] types = new byte[128];      // типы элементов стека

    // Inline-кэш: переиспользует resolved-переменные при повторном вызове с тем же контекстом
    ExpressionContext cachedCtx;
    double[] cachedVarValues;
    byte[] cachedVarTypes;
}

// Псевдокод компилятора (на основе ExpressionVm.Compiler)
class Compiler {
    List<Integer> tags;       // последовательность опкодов
    List<Integer> operands;   // операнды
    Map<Double, Integer> constantPool;     // пул чисел → индекс
    Map<String, Integer> stringPool;       // пул строк → индекс
    Map<ObjectValue, Integer> objectPool;  // пул объектов (ref) → индекс
    Map<String, Integer> varPool;          // имена переменных → индекс
    Map<String, Integer> fnPool;           // имена функций → индекс

    void emit(Node node) {
        if (node instanceof NumberNode nn) {
            tags.add(PUSH_DOUBLE);
            operands.add(getConstantIndex(nn.getValue()));
        } else if (node instanceof VariableNode vn) {
            tags.add(LOAD_VAR);
            operands.add(getVarIndex(vn.getName()));
        } else if (node instanceof BinaryOpNode bin) {
            emit(bin.getLeft());
            emit(bin.getRight());
            tags.add(mapToOpcode(bin.getOp()));  // ADD, SUB, EQ и т.д.
            operands.add(0);
        } else if (node instanceof TernaryNode tern) {
            emitTernary(tern);
        } else if (node instanceof FunctionCallNode fc) {
            for (var arg : fc.getArguments()) emit(arg);
            int fnIdx = getFnIndex(fc.getName());
            tags.add(CALL_FN);
            operands.add((fnIdx << 16) | (fc.getArguments().length & 0xFFFF));
        } else if (node instanceof ReturnNode rn) {
            emit(rn.getExpression());
            tags.add(RETURN_VALUE);
            operands.add(0);
        }
        // ... остальные узлы: BooleanNode→PUSH_BOOL, StringNode→PUSH_STRING,
        //     NullNode→PUSH_NULL, RefNode→PUSH_OBJ, IfElseNode, BlockNode, SwitchNode
    }

    void emitTernary(TernaryNode tern) {
        emit(tern.getCondition());
        int branchIdx = operands.size();
        tags.add(TERNARY_BRANCH);
        operands.add(-1);          // заглушка
        emit(tern.getTrueBranch());
        int jumpIdx = operands.size();
        tags.add(JUMP);
        operands.add(-1);          // заглушка
        int falseStart = tags.size();
        operands.set(branchIdx, falseStart);  // патчим переход
        emit(tern.getFalseBranch());
        operands.set(jumpIdx, tags.size());   // патчим jump к концу
    }
}

// Псевдокод (на основе ExpressionVm.execute)
ExpressionValue execute(ExpressionContext ctx) {
    if (cacheValid && ctx == cachedCtx) {
        // Тот же объект контекста -- переиспользуем resolved-переменные, пропускаем HashMap
        varValues = cachedVarValues;
        varTypes = cachedVarTypes;
    } else {
        // Разрешаем все переменные один раз через HashMap → массив
        for (int i = 0; i < varNames.length; i++) {
            ExpressionValue v = ctx.getVariable(varNames[i]);
            switch (v.getType()) {
                case BOOL:
                    varValues[i] = v.asBoolean() ? 1.0 : 0.0;
                    varTypes[i] = T_BOOL;
                    break;
                case STRING:
                    int sIdx = indexOfString(v.asString());
                    if (sIdx < 0) sIdx = addDynamicString(v.asString());
                    varValues[i] = (double) sIdx;
                    varTypes[i] = T_STRING;
                    break;
                // ... NULL, VOID, OBJECT -- аналогично маппинг в тип стека + индекс пула
                default:
                    varValues[i] = v.toDouble();
                    varTypes[i] = T_DOUBLE;
            }
        }
        cachedCtx = ctx;
        cachedVarValues = varValues;
        cachedVarTypes = varTypes;
        cacheValid = true;
    }
}

// Псевдокод (на основе ExpressionVm.execute)
ExpressionValue execute(ExpressionContext ctx) {
    int sp = 0;   // stack pointer
    int pc = 0;   // program counter

    while (pc < tags.length) {
        switch (tags[pc]) {
            case PUSH_DOUBLE:
                stack[sp] = constants[operands[pc]];
                types[sp] = T_DOUBLE;
                sp++;
                pc++;
                break;

            case LOAD_VAR: {
                int vi = operands[pc];  // индекс переменной в resolved-массиве
                stack[sp] = varValues[vi];
                types[sp] = varTypes[vi];
                sp++;
                pc++;
                break;
            }

            case ADD: {
                int tb = --sp, ta = --sp;
                if (types[tb] == T_STRING && types[ta] == T_STRING) {
                    // Конкатенация строк через индексы в string pool с дедупликацией
                    String concat = getStringAt((int) stack[ta]) + getStringAt((int) stack[tb]);
                    int idx = indexOfString(concat);
                    if (idx < 0) idx = addDynamicString(concat);
                    stack[sp] = (double) idx;
                    types[sp] = T_STRING;
                } else {
                    stack[sp] = stack[ta] + stack[tb];
                    types[sp] = T_DOUBLE;
                }
                sp++;
                pc++;
                break;
            }

            // ... SUB, MUL, DIV, MOD -- аналогичный шаблон: pop два операнда → операция → push результат
            // ... EQ, NEQ, LT, GT, LTE, GTE -- сравнение с учётом типов (NULL, VOID, строки, объекты)
            // ... AND, OR, NOT, NEG -- логические операции

            case TERNARY_BRANCH: {
                --sp;  // pop condition
                if (stack[sp] == 0.0) {
                    pc = operands[pc];  // переход к else-ветви
                } else {
                    pc++;               // продолжаем к then-ветви
                }
                break;
            }

            case JUMP:
                pc = operands[pc];
                break;

            case CALL_FN: {
                int encoded = operands[pc];
                int fnIdx = encoded >>> 16;
                int argCount = encoded & 0xFFFF;
                // Снимаем аргументы со стека в обратном порядке (LIFO)
                ExpressionValue[] args = new ExpressionValue[argCount];
                for (int i = argCount - 1; i >= 0; i--) {
                    int idx = --sp;
                    args[i] = toFormulaValue(stack[idx], types[idx]);
                }
                ExpressionValue result = ctx.findFunction(fnNames[fnIdx]).call(args);
                // Маппинг результата в тип стека (BOOL→1.0/0.0, STRING→index пула, и т.д.)
                pushResult(result, sp);  // см. ExpressionVm.java:551-583
                pc++;
                break;
            }

            case RETURN_VALUE: {
                ExpressionValue ret = toFormulaValue(stack[sp - 1], types[sp - 1]);
                ctx.setReturn(ret);  // устанавливаем return-значение для раннего выхода из блока
                return ret;
            }
        }
    }
    // Если выполнение дошло до конца без RETURN -- возвращаем верхний элемент стека
    return toFormulaValue(stack[sp - 1], types[sp - 1]);
}