@boristype/bt-cli 0.1.0-alpha.0

package/build/transformers/propSemantic.js

@@ -0,0 +1,467 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = propSemanticTransformer;
+const ts = __importStar(require("typescript"));
+const utils_1 = require("./utils");
+function findSymbolByName(typeChecker, sourceFile, name) {
+    return typeChecker.getSymbolsInScope(sourceFile, ts.SymbolFlags.Class | ts.SymbolFlags.Interface | ts.SymbolFlags.TypeAlias | ts.SymbolFlags.Value).find(symbol => symbol.getName() === name);
+}
+// Проверяет, относится ли тип узла к XML-типам (XmlDocument, XmlElem и т.д.)
+// с учетом union и intersection типов. Проверка немного тупая, так как TypeScript
+// считает что любой TopElem документа не может быть isTypeAssignableTo к XmlElem.
+// Но с этим разберемся позже, а пока такое решение работает.
+function isXmlRelatedType(typeChecker, node, xmlDocumentSymbol, xmlElemSymbol) {
+    if (!xmlDocumentSymbol && !xmlElemSymbol) {
+        return false;
+    }
+    let type;
+    try {
+        type = typeChecker.getTypeAtLocation(node);
+    }
+    catch (err) {
+        return false;
+    }
+    // Проверяем является ли тип any (в этом случае пропускаем проверку)
+    if (type.flags & ts.TypeFlags.Any) {
+        return false;
+    }
+    // Проверяем XmlDocument
+    if (xmlDocumentSymbol) {
+        try {
+            const xmlDocType = typeChecker.getDeclaredTypeOfSymbol(xmlDocumentSymbol);
+            if (typeChecker.isTypeAssignableTo(type, xmlDocType)) {
+                return true;
+            }
+        }
+        catch {
+            // Игнорируем ошибки
+        }
+    }
+    // Проверяем XmlElem (включая XmElem)
+    if (xmlElemSymbol) {
+        try {
+            const xmlElemType = typeChecker.getDeclaredTypeOfSymbol(xmlElemSymbol);
+            if (typeChecker.isTypeAssignableTo(type, xmlElemType)) {
+                return true;
+            }
+        }
+        catch {
+            // Игнорируем ошибки
+        }
+    }
+    const typeString = typeChecker.typeToString(type);
+    if (typeString.startsWith("typeof tools")) {
+        return true;
+    }
+    if (typeString.startsWith("typeof botest")) {
+        return true;
+    }
+    // Проверяем по имени типа (для generic типов вроде XmlElem<T>)
+    if (typeString.startsWith('XmlElem<') ||
+        typeString.startsWith('XmElem<') ||
+        typeString.startsWith('XmlMultiElem<') ||
+        typeString.startsWith('XmlTopElem') ||
+        typeString === 'XmlDocument' ||
+        typeString === 'XmlElem' ||
+        typeString === 'XmElem') {
+        return true;
+    }
+    // Проверяем intersection types (например, XmlTopElem & PersonBase & ...)
+    if (type.isIntersection && type.isIntersection()) {
+        const hasXmlType = type.types.some(t => {
+            const tString = typeChecker.typeToString(t);
+            return tString.startsWith('XmlElem<') ||
+                tString.startsWith('XmElem<') ||
+                tString.startsWith('XmlMultiElem<') ||
+                tString.startsWith('XmlTopElem') ||
+                tString === 'XmlDocument' ||
+                tString === 'XmlElem' ||
+                tString === 'XmElem';
+        });
+        if (hasXmlType) {
+            return true;
+        }
+    }
+    // Проверяем union types (например, XmlElem<string> | string)
+    if (type.isUnion()) {
+        return type.types.some(t => {
+            const tString = typeChecker.typeToString(t);
+            const match = tString.startsWith('XmlElem<') ||
+                tString.startsWith('XmElem<') ||
+                tString.startsWith('XmlMultiElem<') ||
+                tString.startsWith('XmlTopElem') ||
+                tString === 'XmlDocument' ||
+                tString === 'XmlElem' ||
+                tString === 'XmElem';
+            return match;
+        });
+    }
+    return false;
+}
+// Собирает все объявления переменных в файле (включая var, let, const)
+function collectVariableDeclarations(sourceFile) {
+    const declarations = new Set();
+    function visit(node) {
+        // Собираем объявления переменных
+        if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+            declarations.add(node.name.text);
+        }
+        // Собираем параметры функций
+        else if (ts.isParameter(node) && ts.isIdentifier(node.name)) {
+            declarations.add(node.name.text);
+        }
+        // Собираем объявления функций
+        else if (ts.isFunctionDeclaration(node) && node.name) {
+            declarations.add(node.name.text);
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return declarations;
+}
+function propSemanticTransformer(program) {
+    return (context) => (file) => {
+        let tempCounter = 0;
+        const typeChecker = program.getTypeChecker();
+        const xmlDocumentSymbol = findSymbolByName(typeChecker, file, "XmlDocument");
+        const xmlElemSymbol = findSymbolByName(typeChecker, file, "XmlElem");
+        // Собираем все объявленные переменные в файле, без учета области их видимости,
+        // надеемся на то, что мы не можем переопределить глобальные функции в файле,
+        // и при этом компилятор TypeScript в случае неправильно использования выдаст ошибку.
+        const declaredVariables = collectVariableDeclarations(file);
+        const scopeStack = [];
+        let currentScope = { tempDeclarations: [] };
+        // Функция для создания временной переменной в текущем scope
+        function createTempVariable() {
+            const temp = ts.factory.createIdentifier(`_tmp${tempCounter++}`);
+            currentScope.tempDeclarations.push(ts.factory.createVariableDeclaration(temp, undefined, undefined, undefined));
+            return temp;
+        }
+        const visitor = (node) => {
+            if ((0, utils_1.isUntouchable)(node)) {
+                return node;
+                // return ts.visitEachChild(node, visitor, context);
+            }
+            // Обрабатываем функции как scope boundaries
+            if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node) || ts.isConstructorDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node)) {
+                // Сохраняем текущий scope и создаём новый
+                scopeStack.push(currentScope);
+                currentScope = { tempDeclarations: [] };
+                // Обрабатываем тело функции
+                let transformedNode;
+                if (ts.isFunctionDeclaration(node)) {
+                    transformedNode = ts.factory.updateFunctionDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body ? ts.visitNode(node.body, visitor) : undefined);
+                }
+                else if (ts.isFunctionExpression(node)) {
+                    transformedNode = ts.factory.updateFunctionExpression(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, ts.visitNode(node.body, visitor));
+                }
+                else if (ts.isArrowFunction(node)) {
+                    transformedNode = ts.factory.updateArrowFunction(node, node.modifiers, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, ts.visitNode(node.body, visitor));
+                }
+                else if (ts.isMethodDeclaration(node)) {
+                    transformedNode = ts.factory.updateMethodDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body ? ts.visitNode(node.body, visitor) : undefined);
+                }
+                else if (ts.isConstructorDeclaration(node)) {
+                    transformedNode = ts.factory.updateConstructorDeclaration(node, node.modifiers, node.parameters, node.body ? ts.visitNode(node.body, visitor) : undefined);
+                }
+                else if (ts.isGetAccessorDeclaration(node)) {
+                    transformedNode = ts.factory.updateGetAccessorDeclaration(node, node.modifiers, node.name, node.parameters, node.type, node.body ? ts.visitNode(node.body, visitor) : undefined);
+                }
+                else if (ts.isSetAccessorDeclaration(node)) {
+                    transformedNode = ts.factory.updateSetAccessorDeclaration(node, node.modifiers, node.name, node.parameters, node.body ? ts.visitNode(node.body, visitor) : undefined);
+                }
+                else {
+                    transformedNode = node;
+                }
+                // Если есть временные переменные для этого scope, добавляем их в начало блока
+                const scopeTempDeclarations = currentScope.tempDeclarations;
+                // Восстанавливаем предыдущий scope
+                currentScope = scopeStack.pop();
+                // Добавляем временные переменные в начало тела функции, если они есть
+                if (scopeTempDeclarations.length > 0) {
+                    const varStatement = ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList(scopeTempDeclarations, ts.NodeFlags.Let));
+                    // Проверяем, имеет ли функция блочное тело
+                    if (ts.isFunctionDeclaration(transformedNode) && transformedNode.body) {
+                        return ts.factory.updateFunctionDeclaration(transformedNode, transformedNode.modifiers, transformedNode.asteriskToken, transformedNode.name, transformedNode.typeParameters, transformedNode.parameters, transformedNode.type, ts.factory.updateBlock(transformedNode.body, [varStatement, ...transformedNode.body.statements]));
+                    }
+                    else if (ts.isFunctionExpression(transformedNode)) {
+                        return ts.factory.updateFunctionExpression(transformedNode, transformedNode.modifiers, transformedNode.asteriskToken, transformedNode.name, transformedNode.typeParameters, transformedNode.parameters, transformedNode.type, ts.factory.updateBlock(transformedNode.body, [varStatement, ...transformedNode.body.statements]));
+                    }
+                    else if (ts.isArrowFunction(transformedNode) && ts.isBlock(transformedNode.body)) {
+                        return ts.factory.updateArrowFunction(transformedNode, transformedNode.modifiers, transformedNode.typeParameters, transformedNode.parameters, transformedNode.type, transformedNode.equalsGreaterThanToken, ts.factory.updateBlock(transformedNode.body, [varStatement, ...transformedNode.body.statements]));
+                    }
+                    else if (ts.isMethodDeclaration(transformedNode) && transformedNode.body) {
+                        return ts.factory.updateMethodDeclaration(transformedNode, transformedNode.modifiers, transformedNode.asteriskToken, transformedNode.name, transformedNode.questionToken, transformedNode.typeParameters, transformedNode.parameters, transformedNode.type, ts.factory.updateBlock(transformedNode.body, [varStatement, ...transformedNode.body.statements]));
+                    }
+                    else if (ts.isConstructorDeclaration(transformedNode) && transformedNode.body) {
+                        return ts.factory.updateConstructorDeclaration(transformedNode, transformedNode.modifiers, transformedNode.parameters, ts.factory.updateBlock(transformedNode.body, [varStatement, ...transformedNode.body.statements]));
+                    }
+                    else if (ts.isGetAccessorDeclaration(transformedNode) && transformedNode.body) {
+                        return ts.factory.updateGetAccessorDeclaration(transformedNode, transformedNode.modifiers, transformedNode.name, transformedNode.parameters, transformedNode.type, ts.factory.updateBlock(transformedNode.body, [varStatement, ...transformedNode.body.statements]));
+                    }
+                    else if (ts.isSetAccessorDeclaration(transformedNode) && transformedNode.body) {
+                        return ts.factory.updateSetAccessorDeclaration(transformedNode, transformedNode.modifiers, transformedNode.name, transformedNode.parameters, ts.factory.updateBlock(transformedNode.body, [varStatement, ...transformedNode.body.statements]));
+                    }
+                }
+                return transformedNode;
+            }
+            // Handle CallExpression for simple function calls (someFunc(...))
+            if (ts.isCallExpression(node) && !ts.isPropertyAccessExpression(node.expression)) {
+                // Простой вызов функции (не метод объекта)
+                const funcExpression = ts.visitNode(node.expression, visitor);
+                const args = node.arguments.map(arg => ts.visitNode(arg, visitor));
+                // Если выражение функции помечено как untouchable, не трансформируем
+                if ((0, utils_1.isUntouchable)(funcExpression)) {
+                    return ts.factory.updateCallExpression(node, funcExpression, node.typeArguments, args);
+                }
+                // Проверяем, является ли вызываемая функция локальной переменной
+                // Если это идентификатор и он объявлен в файле - преобразуем
+                if (ts.isIdentifier(node.expression) && declaredVariables.has(node.expression.text)) {
+                    // Оборачиваем в bt.callFunction
+                    return ts.factory.createCallExpression((0, utils_1.markUntouchable)(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("bt"), "callFunction")), undefined, [funcExpression, ts.factory.createArrayLiteralExpression(args)]);
+                }
+                // Если это не локальная переменная - возвращаем как есть (глобальная функция)
+                return ts.factory.updateCallExpression(node, funcExpression, node.typeArguments, args);
+            }
+            // Handle CallExpression for method calls (obj.method(...) or obj["method"](...))
+            if (ts.isCallExpression(node) && (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
+                const propOrElemAccess = node.expression;
+                const expression = propOrElemAccess.expression;
+                const propertyName = ts.isPropertyAccessExpression(propOrElemAccess)
+                    ? ts.factory.createStringLiteral(propOrElemAccess.name.text)
+                    : ts.visitNode(propOrElemAccess.argumentExpression, visitor);
+                // Проверяем, есть ли XML тип в цепочке доступа
+                const isXmlType = isXmlRelatedType(typeChecker, expression, xmlDocumentSymbol, xmlElemSymbol);
+                // Если это XML тип, не трансформируем вообще - обрабатываем только аргументы
+                if (isXmlType) {
+                    const base = ts.visitNode(node.expression, visitor);
+                    const args = node.arguments.map(arg => ts.visitNode(arg, visitor));
+                    return ts.factory.updateCallExpression(node, base, node.typeArguments, args);
+                }
+                // Обходим base-часть и аргументы
+                const base = ts.visitNode(expression, visitor);
+                const args = node.arguments.map(arg => ts.visitNode(arg, visitor));
+                if ((0, utils_1.isUntouchable)(propOrElemAccess)) {
+                    // original method call, but args transformed
+                    return ts.factory.updateCallExpression(node, propOrElemAccess, node.typeArguments, args);
+                }
+                // Вызываем функцию сразу без шага получения свойства, если base — untouchable (например, для выражений вида __env.__parent.someFunc())
+                if ((0, utils_1.isUntouchable)(base)) {
+                    return ts.factory.createCallExpression((0, utils_1.markUntouchable)(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("bt"), "callFunction")), undefined, [propOrElemAccess, ts.factory.createArrayLiteralExpression(args)]);
+                }
+                if (propOrElemAccess.questionDotToken) {
+                    // Handle optional chaining for method calls: obj?.method(...) or obj?.["method"](...)
+                    const temp = createTempVariable();
+                    const assigned = ts.factory.createAssignment(temp, base);
+                    const nullCheck = ts.factory.createBinaryExpression(assigned, ts.factory.createToken(ts.SyntaxKind.EqualsEqualsToken), ts.factory.createNull());
+                    const undefinedCheck = ts.factory.createBinaryExpression(temp, ts.factory.createToken(ts.SyntaxKind.EqualsEqualsToken), ts.factory.createIdentifier("undefined"));
+                    const combinedCheck = ts.factory.createBinaryExpression(nullCheck, ts.factory.createToken(ts.SyntaxKind.BarBarToken), undefinedCheck);
+                    const whenTrue = ts.factory.createIdentifier("undefined");
+                    // Сначала получаем метод: bt.getProperty(temp, "method")
+                    const getMethod = ts.factory.createCallExpression((0, utils_1.markUntouchable)(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("bt"), "getProperty")), undefined, [temp, propertyName]);
+                    // Затем вызываем: bt.callFunction(method, [args])
+                    const whenFalse = ts.factory.createCallExpression((0, utils_1.markUntouchable)(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("bt"), "callFunction")), undefined, [getMethod, ts.factory.createArrayLiteralExpression(args)]);
+                    return ts.factory.createConditionalExpression(combinedCheck, undefined, whenTrue, undefined, whenFalse);
+                }
+                // Проверяем, является ли base результатом optional chaining (ConditionalExpression с undefined)
+                // Если да, то внедряем вызов в whenFalse ветку существующего conditional expression
+                if (ts.isConditionalExpression(base)) {
+                    const isOptionalChainResult = ts.isIdentifier(base.whenTrue) && base.whenTrue.text === "undefined";
+                    if (isOptionalChainResult) {
+                        // Заменяем whenFalse ветку на вызов функции
+                        const getMethod = ts.factory.createCallExpression((0, utils_1.markUntouchable)(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("bt"), "getProperty")), undefined, [base.whenFalse, propertyName]);
+                        const callFunc = ts.factory.createCallExpression((0, utils_1.markUntouchable)(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("bt"), "callFunction")), undefined, [getMethod, ts.factory.createArrayLiteralExpression(args)]);
+                        return ts.factory.updateConditionalExpression(base, base.condition, base.questionToken, base.whenTrue, base.colonToken, callFunc);
+                    }
+                }
+                // Non-optional method call: 
+                // 1. Получаем метод: bt.getProperty(obj, "method")
+                const getMethod = ts.factory.createCallExpression((0, utils_1.markUntouchable)(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("bt"), "getProperty")), undefined, [base, propertyName]);
+                // 2. Вызываем метод: bt.callFunction(method, [args])
+                return ts.factory.createCallExpression((0, utils_1.markUntouchable)(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("bt"), "callFunction")), undefined, [getMethod, ts.factory.createArrayLiteralExpression(args)]);
+            }
+            // Handle PropertyAccessExpression for property access
+            if (ts.isPropertyAccessExpression(node)) {
+                // Если это вызов метода (obj.method(...)) → уже обработано выше
+                if (node.parent && ts.isCallExpression(node.parent) && node.parent.expression === node) {
+                    // return node;
+                    // мы правильно это делаем? ну например для последовательности obj.method.prop.other()
+                    // где мы преобразуем [obj.method.prop].other()
+                    return ts.factory.updatePropertyAccessExpression(node, ts.visitNode(node.expression, visitor), node.name);
+                }
+                // Проверяем, является ли это присваиванием (obj.prop = value)
+                const isAssignment = node.parent &&
+                    ts.isBinaryExpression(node.parent) &&
+                    node.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                    node.parent.left === node;
+                if (isAssignment) {
+                    // Это присваивание: obj.prop = value
+                    // Не трансформируем здесь, обработаем в BinaryExpression
+                    return node;
+                }
+                // Проверяем, есть ли XML тип в цепочке доступа (проверяем ДО трансформации)
+                const isXmlType = isXmlRelatedType(typeChecker, node.expression, xmlDocumentSymbol, xmlElemSymbol);
+                // Если это XML тип, не трансформируем вообще - возвращаем оригинальный узел
+                // и не посещаем его дочерние узлы для трансформации
+                if (isXmlType) {
+                    // return node;
+                    const base = ts.visitNode(node.expression, visitor);
+                    return ts.factory.updatePropertyAccessExpression(node, base, node.name);
+                }
+                // Обходим base-часть
+                const base = ts.visitNode(node.expression, visitor);
+                const property = ts.factory.createStringLiteral(node.name.text);
+                // Оставляем без изменений, если base — untouchable (например, для выражений вида __env.__parent.SOME_CONSTANT)
+                if ((0, utils_1.isUntouchable)(base)) {
+                    return node;
+                }
+                if (node.questionDotToken) {
+                    // Handle optional chaining for property access
+                    const temp = createTempVariable();
+                    const assigned = ts.factory.createAssignment(temp, base);
+                    const nullCheck = ts.factory.createBinaryExpression(assigned, ts.factory.createToken(ts.SyntaxKind.EqualsEqualsToken), ts.factory.createNull());
+                    const undefinedCheck = ts.factory.createBinaryExpression(temp, ts.factory.createToken(ts.SyntaxKind.EqualsEqualsToken), ts.factory.createIdentifier("undefined"));
+                    const combinedCheck = ts.factory.createBinaryExpression(nullCheck, ts.factory.createToken(ts.SyntaxKind.BarBarToken), undefinedCheck);
+                    const whenTrue = ts.factory.createIdentifier("undefined");
+                    const whenFalse = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("bt"), "getProperty"), undefined, [temp, property]);
+                    return ts.factory.createConditionalExpression(combinedCheck, undefined, whenTrue, undefined, whenFalse);
+                }
+                // Проверяем, не является ли base результатом optional chaining (ConditionalExpression с undefined)
+                // Если да, то встраиваем getProperty в whenFalse ветку существующего conditional expression
+                // ТОЛЬКО если текущий узел не имеет ?.
+                if (ts.isConditionalExpression(base)) {
+                    const isOptionalChainResult = ts.isIdentifier(base.whenTrue) && base.whenTrue.text === "undefined";
+                    if (isOptionalChainResult) {
+                        // Заменяем whenFalse ветку на getProperty от результата whenFalse
+                        const getProp = ts.factory.createCallExpression((0, utils_1.markUntouchable)(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("bt"), "getProperty")), undefined, [base.whenFalse, property]);
+                        return ts.factory.updateConditionalExpression(base, base.condition, base.questionToken, base.whenTrue, base.colonToken, getProp);
+                    }
+                }
+                // Non-optional property access: bt.getProperty(obj, "prop")
+                return ts.factory.createCallExpression((0, utils_1.markUntouchable)(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("bt"), "getProperty")), undefined, [base, property]);
+            }
+            // Handle ElementAccessExpression for property access obj["prop"]
+            if (ts.isElementAccessExpression(node)) {
+                // Если это вызов метода (obj["method"](...)) → уже обработано выше
+                if (node.parent && ts.isCallExpression(node.parent) && node.parent.expression === node) {
+                    return ts.factory.updateElementAccessExpression(node, ts.visitNode(node.expression, visitor), ts.visitNode(node.argumentExpression, visitor));
+                }
+                // Проверяем, является ли это присваиванием (obj["prop"] = value)
+                const isAssignment = node.parent &&
+                    ts.isBinaryExpression(node.parent) &&
+                    node.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+                    node.parent.left === node;
+                if (isAssignment) {
+                    // Это присваивание: obj["prop"] = value
+                    // Не трансформируем здесь, обработаем в BinaryExpression
+                    return node;
+                }
+                // Проверяем, есть ли XML тип в цепочке доступа
+                const isXmlType = isXmlRelatedType(typeChecker, node.expression, xmlDocumentSymbol, xmlElemSymbol);
+                if (isXmlType) {
+                    const base = ts.visitNode(node.expression, visitor);
+                    const argument = ts.visitNode(node.argumentExpression, visitor);
+                    return ts.factory.updateElementAccessExpression(node, base, argument);
+                }
+                // Обходим base-часть и expression для property
+                const base = ts.visitNode(node.expression, visitor);
+                const property = ts.visitNode(node.argumentExpression, visitor);
+                if ((0, utils_1.isUntouchable)(base)) {
+                    return node;
+                }
+                if (node.questionDotToken) {
+                    // Handle optional chaining: obj?.["prop"]
+                    const temp = createTempVariable();
+                    const assigned = ts.factory.createAssignment(temp, base);
+                    const nullCheck = ts.factory.createBinaryExpression(assigned, ts.factory.createToken(ts.SyntaxKind.EqualsEqualsToken), ts.factory.createNull());
+                    const undefinedCheck = ts.factory.createBinaryExpression(temp, ts.factory.createToken(ts.SyntaxKind.EqualsEqualsToken), ts.factory.createIdentifier("undefined"));
+                    const combinedCheck = ts.factory.createBinaryExpression(nullCheck, ts.factory.createToken(ts.SyntaxKind.BarBarToken), undefinedCheck);
+                    const whenTrue = ts.factory.createIdentifier("undefined");
+                    const whenFalse = ts.factory.createCallExpression((0, utils_1.markUntouchable)(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("bt"), "getProperty")), undefined, [temp, property]);
+                    return ts.factory.createConditionalExpression(combinedCheck, undefined, whenTrue, undefined, whenFalse);
+                }
+                if (ts.isConditionalExpression(base)) {
+                    const isOptionalChainResult = ts.isIdentifier(base.whenTrue) && base.whenTrue.text === "undefined";
+                    if (isOptionalChainResult) {
+                        const getProp = ts.factory.createCallExpression((0, utils_1.markUntouchable)(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("bt"), "getProperty")), undefined, [base.whenFalse, property]);
+                        return ts.factory.updateConditionalExpression(base, base.condition, base.questionToken, base.whenTrue, base.colonToken, getProp);
+                    }
+                }
+                // Non-optional property access: bt.getProperty(obj, "prop")
+                return ts.factory.createCallExpression((0, utils_1.markUntouchable)(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("bt"), "getProperty")), undefined, [base, property]);
+            }
+            // Handle BinaryExpression for assignments (obj.prop = value or obj["prop"] = value)
+            if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && (ts.isPropertyAccessExpression(node.left) || ts.isElementAccessExpression(node.left))) {
+                const propOrElemAccess = node.left;
+                const expression = propOrElemAccess.expression;
+                // Проверяем, есть ли XML тип в цепочке доступа (проверяем ДО трансформации)
+                const isXmlType = isXmlRelatedType(typeChecker, expression, xmlDocumentSymbol, xmlElemSymbol);
+                // Если это XML тип, не трансформируем вообще - обрабатываем только правую часть
+                if (isXmlType) {
+                    const left = ts.visitNode(propOrElemAccess, visitor);
+                    const value = ts.visitNode(node.right, visitor);
+                    return ts.factory.updateBinaryExpression(node, left, node.operatorToken, value);
+                }
+                // Обходим base-часть и правую часть присваивания
+                const base = ts.visitNode(expression, visitor);
+                const property = ts.isPropertyAccessExpression(propOrElemAccess)
+                    ? ts.factory.createStringLiteral(propOrElemAccess.name.text)
+                    : ts.visitNode(propOrElemAccess.argumentExpression, visitor);
+                const value = ts.visitNode(node.right, visitor);
+                if ((0, utils_1.isUntouchable)(base)) {
+                    return ts.factory.updateBinaryExpression(node, propOrElemAccess, node.operatorToken, value);
+                }
+                // bt.setProperty(obj, "prop", value)
+                return ts.factory.createCallExpression((0, utils_1.markUntouchable)(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("bt"), "setProperty")), undefined, [base, property, value]);
+            }
+            // Continue visiting other nodes
+            return ts.visitEachChild(node, visitor, context);
+        };
+        // Visit the entire file to transform nodes
+        const transformedFile = ts.visitNode(file, visitor);
+        // Добавляем временные переменные top-level scope в начало файла (если они есть)
+        const varStatement = currentScope.tempDeclarations.length > 0
+            ? [
+                ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList(currentScope.tempDeclarations, ts.NodeFlags.Let)),
+            ]
+            : [];
+        // Update source file with variable declarations only (no helper function)
+        return ts.factory.updateSourceFile(transformedFile, [
+            ...varStatement,
+            ...transformedFile.statements,
+        ]);
+    };
+}