@boristype/bt-cli 0.1.0-alpha.0

package/build/transformers/precedence.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.precedenceTransformer = precedenceTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Трансформер для явной расстановки скобок в выражениях.
+ *
+ * Добавляет скобки вокруг операндов в бинарных выражениях,
+ * чтобы гарантировать корректный порядок вычисления в BorisScript.
+ *
+ * @example
+ * // Вход: a + b * c
+ * // Выход: a + (b * c)
+ *
+ * @example
+ * // Вход: a && b || c
+ * // Выход: (a && b) || c
+ */
+// Таблица приоритетов операторов согласно MDN
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_precedence
+const PRECEDENCE = {
+    // 13: Exponentiation (right-to-left)
+    [typescript_1.default.SyntaxKind.AsteriskAsteriskToken]: 13,
+    // 12: Multiplicative operators (left-to-right)
+    [typescript_1.default.SyntaxKind.AsteriskToken]: 12,
+    [typescript_1.default.SyntaxKind.SlashToken]: 12,
+    [typescript_1.default.SyntaxKind.PercentToken]: 12,
+    // 11: Additive operators (left-to-right)
+    [typescript_1.default.SyntaxKind.PlusToken]: 11,
+    [typescript_1.default.SyntaxKind.MinusToken]: 11,
+    // 10: Bitwise shift (left-to-right)
+    [typescript_1.default.SyntaxKind.LessThanLessThanToken]: 10,
+    [typescript_1.default.SyntaxKind.GreaterThanGreaterThanToken]: 10,
+    [typescript_1.default.SyntaxKind.GreaterThanGreaterThanGreaterThanToken]: 10,
+    // 9: Relational operators (left-to-right)
+    [typescript_1.default.SyntaxKind.LessThanToken]: 9,
+    [typescript_1.default.SyntaxKind.LessThanEqualsToken]: 9,
+    [typescript_1.default.SyntaxKind.GreaterThanToken]: 9,
+    [typescript_1.default.SyntaxKind.GreaterThanEqualsToken]: 9,
+    [typescript_1.default.SyntaxKind.InKeyword]: 9,
+    [typescript_1.default.SyntaxKind.InstanceOfKeyword]: 9,
+    // 8: Equality operators (left-to-right)
+    [typescript_1.default.SyntaxKind.EqualsEqualsToken]: 8,
+    [typescript_1.default.SyntaxKind.ExclamationEqualsToken]: 8,
+    [typescript_1.default.SyntaxKind.EqualsEqualsEqualsToken]: 8,
+    [typescript_1.default.SyntaxKind.ExclamationEqualsEqualsToken]: 8,
+    // 7: Bitwise AND (left-to-right)
+    [typescript_1.default.SyntaxKind.AmpersandToken]: 7,
+    // 6: Bitwise XOR (left-to-right)
+    [typescript_1.default.SyntaxKind.CaretToken]: 6,
+    // 5: Bitwise OR (left-to-right)
+    [typescript_1.default.SyntaxKind.BarToken]: 5,
+    // 4: Logical AND (left-to-right)
+    [typescript_1.default.SyntaxKind.AmpersandAmpersandToken]: 4,
+    // 3: Logical OR, Nullish coalescing (left-to-right)
+    [typescript_1.default.SyntaxKind.BarBarToken]: 3,
+    [typescript_1.default.SyntaxKind.QuestionQuestionToken]: 3,
+    // 2: Assignment operators (right-to-left)
+    [typescript_1.default.SyntaxKind.EqualsToken]: 2,
+    [typescript_1.default.SyntaxKind.PlusEqualsToken]: 2,
+    [typescript_1.default.SyntaxKind.MinusEqualsToken]: 2,
+    [typescript_1.default.SyntaxKind.AsteriskEqualsToken]: 2,
+    [typescript_1.default.SyntaxKind.AsteriskAsteriskEqualsToken]: 2,
+    [typescript_1.default.SyntaxKind.SlashEqualsToken]: 2,
+    [typescript_1.default.SyntaxKind.PercentEqualsToken]: 2,
+    [typescript_1.default.SyntaxKind.LessThanLessThanEqualsToken]: 2,
+    [typescript_1.default.SyntaxKind.GreaterThanGreaterThanEqualsToken]: 2,
+    [typescript_1.default.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken]: 2,
+    [typescript_1.default.SyntaxKind.AmpersandEqualsToken]: 2,
+    [typescript_1.default.SyntaxKind.CaretEqualsToken]: 2,
+    [typescript_1.default.SyntaxKind.BarEqualsToken]: 2,
+    [typescript_1.default.SyntaxKind.AmpersandAmpersandEqualsToken]: 2,
+    [typescript_1.default.SyntaxKind.BarBarEqualsToken]: 2,
+    [typescript_1.default.SyntaxKind.QuestionQuestionEqualsToken]: 2,
+    // 1: Comma operator (left-to-right)
+    [typescript_1.default.SyntaxKind.CommaToken]: 1,
+};
+// Операторы с правоассоциативностью (вычисляются справа налево)
+const RIGHT_ASSOCIATIVE = new Set([
+    typescript_1.default.SyntaxKind.AsteriskAsteriskToken, // **
+    typescript_1.default.SyntaxKind.EqualsToken,
+    typescript_1.default.SyntaxKind.PlusEqualsToken,
+    typescript_1.default.SyntaxKind.MinusEqualsToken,
+    typescript_1.default.SyntaxKind.AsteriskEqualsToken,
+    typescript_1.default.SyntaxKind.AsteriskAsteriskEqualsToken,
+    typescript_1.default.SyntaxKind.SlashEqualsToken,
+    typescript_1.default.SyntaxKind.PercentEqualsToken,
+    typescript_1.default.SyntaxKind.LessThanLessThanEqualsToken,
+    typescript_1.default.SyntaxKind.GreaterThanGreaterThanEqualsToken,
+    typescript_1.default.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken,
+    typescript_1.default.SyntaxKind.AmpersandEqualsToken,
+    typescript_1.default.SyntaxKind.CaretEqualsToken,
+    typescript_1.default.SyntaxKind.BarEqualsToken,
+    typescript_1.default.SyntaxKind.AmpersandAmpersandEqualsToken,
+    typescript_1.default.SyntaxKind.BarBarEqualsToken,
+    typescript_1.default.SyntaxKind.QuestionQuestionEqualsToken,
+]);
+function getPrecedence(kind) {
+    return PRECEDENCE[kind] ?? 999; // Высокий приоритет для неизвестных операторов
+}
+function isRightAssociative(kind) {
+    return RIGHT_ASSOCIATIVE.has(kind);
+}
+function needsParentheses(parent, child, isLeft) {
+    const parentOp = parent.operatorToken.kind;
+    const childOp = child.operatorToken.kind;
+    const parentPrec = getPrecedence(parentOp);
+    const childPrec = getPrecedence(childOp);
+    // Если приоритет дочернего оператора ниже, нужны скобки
+    if (childPrec < parentPrec) {
+        return true;
+    }
+    // Если приоритет дочернего оператора выше, нужны скобки
+    if (childPrec > parentPrec) {
+        return true;
+    }
+    // Если приоритет одинаковый, зависит от ассоциативности
+    if (childPrec === parentPrec) {
+        // Для правоассоциативных операторов: левый операнд нужно оборачивать
+        if (isRightAssociative(parentOp)) {
+            return isLeft;
+        }
+        // Для левоассоциативных операторов: правый операнд нужно оборачивать
+        else {
+            return !isLeft;
+        }
+    }
+    return false;
+}
+function precedenceTransformer() {
+    return (context) => (sourceFile) => {
+        function visit(node) {
+            // Сначала рекурсивно обрабатываем дочерние узлы
+            node = typescript_1.default.visitEachChild(node, visit, context);
+            // Обрабатываем бинарные выражения
+            if (typescript_1.default.isBinaryExpression(node)) {
+                let left = node.left;
+                let right = node.right;
+                // Проверяем левый операнд
+                if (typescript_1.default.isBinaryExpression(left)) {
+                    if (needsParentheses(node, left, true)) {
+                        left = typescript_1.default.factory.createParenthesizedExpression(left);
+                    }
+                }
+                // Проверяем правый операнд
+                if (typescript_1.default.isBinaryExpression(right)) {
+                    if (needsParentheses(node, right, false)) {
+                        right = typescript_1.default.factory.createParenthesizedExpression(right);
+                    }
+                }
+                // Если были изменения, создаём новое выражение
+                if (left !== node.left || right !== node.right) {
+                    return typescript_1.default.factory.updateBinaryExpression(node, left, node.operatorToken, right);
+                }
+            }
+            // Обрабатываем условные выражения (тернарный оператор)
+            if (typescript_1.default.isConditionalExpression(node)) {
+                let condition = node.condition;
+                let whenTrue = node.whenTrue;
+                let whenFalse = node.whenFalse;
+                // Условие: оборачиваем бинарные выражения с приоритетом <= 2
+                if (typescript_1.default.isBinaryExpression(condition)) {
+                    const condPrec = getPrecedence(condition.operatorToken.kind);
+                    if (condPrec <= 2) {
+                        condition = typescript_1.default.factory.createParenthesizedExpression(condition);
+                    }
+                }
+                // whenTrue и whenFalse: оборачиваем запятую и присваивания
+                if (typescript_1.default.isBinaryExpression(whenTrue)) {
+                    const truePrec = getPrecedence(whenTrue.operatorToken.kind);
+                    if (truePrec <= 2) {
+                        whenTrue = typescript_1.default.factory.createParenthesizedExpression(whenTrue);
+                    }
+                }
+                if (typescript_1.default.isBinaryExpression(whenFalse)) {
+                    const falsePrec = getPrecedence(whenFalse.operatorToken.kind);
+                    if (falsePrec <= 2) {
+                        whenFalse = typescript_1.default.factory.createParenthesizedExpression(whenFalse);
+                    }
+                }
+                if (condition !== node.condition || whenTrue !== node.whenTrue || whenFalse !== node.whenFalse) {
+                    return typescript_1.default.factory.updateConditionalExpression(node, condition, node.questionToken, whenTrue, node.colonToken, whenFalse);
+                }
+            }
+            return node;
+        }
+        return typescript_1.default.visitNode(sourceFile, visit);
+    };
+}