@silvestv/migration-planificator 6.0.2 → 6.0.3

package/dist/src/core/ast/matchers/index.js

@@ -34,6 +34,9 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HtmlMatcher = exports.SymbolMatcher = exports.FileMatcher = exports.CollectionMatcher = exports.TypeMatcher = exports.ExpressionMatcher = exports.HierarchyMatcher = exports.DecoratorMatcher = exports.ImportMatcher = exports.ContextMatcher = exports.NodeMatcher = exports.clearTemplateCache = void 0;
+exports.setOverrideNode = setOverrideNode;
+exports.getOverrideNode = getOverrideNode;
+exports.clearOverrideNode = clearOverrideNode;
 exports.matchesAstPattern = matchesAstPattern;
 const ts_morph_1 = require("ts-morph");
 // Import matchers TypeScript (depuis ts/)
@@ -63,6 +66,24 @@ exports.HtmlMatcher = HtmlMatcher;
 const html_pipe_variable_matcher_1 = require("./html/html-pipe-variable-matcher");
 const host_binding_property_matcher_1 = require("./ts/host-binding-property-matcher");
 const mutation_matcher_1 = require("./ts/mutation-matcher");
+/**
+ * Mécanisme "Override Node" pour localisation précise
+ * Permet aux matchers de retourner un nœud différent pour l'affichage
+ * Exemple: hostBindingProperty retourne le PropertyAssignment au lieu du @Component
+ */
+let currentOverrideNode = null;
+/** Définit le nœud à utiliser pour la localisation (ligne, texte) */
+function setOverrideNode(node) {
+    currentOverrideNode = node;
+}
+/** Récupère le nœud override ou null si non défini */
+function getOverrideNode() {
+    return currentOverrideNode;
+}
+/** Nettoie le nœud override (à appeler après utilisation) */
+function clearOverrideNode() {
+    currentOverrideNode = null;
+}
 /**
  * Fonction principale : vérifie si un nœud correspond à un pattern AST
  * OPTIMISÉ : excludeContext en premier (88% des règles l'utilisent)
@@ -393,10 +414,13 @@ function matchesAstPattern(node, pattern) {
         }
     }
     // Vérifier hostBindingProperty (résolution host binding → TS property → vérification wrappers)
+    // Note: matchesHostBindingProperty retourne Node | null pour localisation précise
     if (pattern.hostBindingProperty !== undefined) {
-        if (!(0, host_binding_property_matcher_1.matchesHostBindingProperty)(node, pattern.hostBindingProperty)) {
+        const problematicNode = (0, host_binding_property_matcher_1.matchesHostBindingProperty)(node, pattern.hostBindingProperty);
+        if (!problematicNode) {
             return false;
         }
+        setOverrideNode(problematicNode);
     }
     // Vérifier fileMissing (identifiant absent de tout le fichier)
     if (pattern.fileMissing !== undefined) {

package/dist/src/core/ast/matchers/ts/host-binding-property-matcher.js

@@ -38,7 +38,7 @@ function getHostObject(componentNode) {
 /**
  * Trouve les property bindings dans l'objet host
  * Exemples: '[class.active]', '[attr.disabled]', '[style.color]'
- * Retourne array de {key, value}
+ * Retourne array de {key, value, node} pour localisation précise
  */
 function findPropertyBindings(hostObject) {
     const bindings = [];
@@ -60,7 +60,7 @@ function findPropertyBindings(hostObject) {
         const value = ts_morph_1.Node.isStringLiteral(initializer)
             ? initializer.getLiteralValue()
             : initializer.getText();
-        bindings.push({ key, value });
+        bindings.push({ key, value, node: property });
     }
     return bindings;
 }
@@ -79,6 +79,156 @@ function isWrappedInWrappers(propertyDecl, wrappers) {
     }
     return false;
 }
+/** Opérateurs d'assignation (réutilisé de mutation-matcher.ts) */
+const ASSIGNMENT_OPERATORS = new Set([
+    ts_morph_1.SyntaxKind.EqualsToken,
+    ts_morph_1.SyntaxKind.PlusEqualsToken,
+    ts_morph_1.SyntaxKind.MinusEqualsToken,
+    ts_morph_1.SyntaxKind.AsteriskEqualsToken,
+    ts_morph_1.SyntaxKind.SlashEqualsToken
+]);
+/**
+ * Vérifie si un BinaryExpression est une assignation à this.propertyName
+ */
+function isAssignmentToThisProperty(expr, propertyName) {
+    if (!ts_morph_1.Node.isBinaryExpression(expr))
+        return false;
+    const operatorKind = expr.getOperatorToken().getKind();
+    if (!ASSIGNMENT_OPERATORS.has(operatorKind))
+        return false;
+    const left = expr.getLeft();
+    if (!ts_morph_1.Node.isPropertyAccessExpression(left))
+        return false;
+    const expression = left.getExpression();
+    const name = left.getName();
+    return expression.getText() === 'this' && name === propertyName;
+}
+/**
+ * Trouve la MethodDeclaration parente d'un nœud
+ */
+function findParentMethod(node) {
+    let current = node.getParent();
+    while (current) {
+        if (ts_morph_1.Node.isMethodDeclaration(current)) {
+            return current;
+        }
+        if (ts_morph_1.Node.isClassDeclaration(current)) {
+            return null; // Arrêter si on atteint la classe (initializer de propriété)
+        }
+        current = current.getParent();
+    }
+    return null;
+}
+/**
+ * Trouve toutes les mutations d'une propriété dans une classe
+ * Détecte : this.prop = value, this.prop += value, etc.
+ */
+function findPropertyMutationsInClass(classDecl, propertyName) {
+    const mutations = [];
+    classDecl.forEachDescendant((descendant) => {
+        if (isAssignmentToThisProperty(descendant, propertyName)) {
+            mutations.push({
+                mutationNode: descendant,
+                containingMethod: findParentMethod(descendant)
+            });
+        }
+    });
+    return mutations;
+}
+/**
+ * Vérifie si un nœud contient un appel à markForCheck()
+ */
+function containsMarkForCheckCall(node) {
+    let found = false;
+    node.forEachDescendant((child) => {
+        if (found)
+            return;
+        if (!ts_morph_1.Node.isCallExpression(child))
+            return;
+        const expr = child.getExpression();
+        if (!ts_morph_1.Node.isPropertyAccessExpression(expr))
+            return;
+        if (expr.getName() === 'markForCheck') {
+            found = true;
+        }
+    });
+    return found;
+}
+/**
+ * Trouve la position du premier appel markForCheck() dans un nœud
+ * Retourne -1 si non trouvé
+ */
+function findMarkForCheckPosition(node) {
+    let position = -1;
+    node.forEachDescendant((child) => {
+        if (position !== -1)
+            return;
+        if (!ts_morph_1.Node.isCallExpression(child))
+            return;
+        const expr = child.getExpression();
+        const isMarkForCheck = ts_morph_1.Node.isPropertyAccessExpression(expr) && expr.getName() === 'markForCheck';
+        if (isMarkForCheck) {
+            position = child.getStart();
+        }
+    });
+    return position;
+}
+/**
+ * Vérifie si markForCheck() est appelé APRÈS une mutation dans la même méthode
+ */
+function hasMarkForCheckAfterMutation(method, mutationNode) {
+    const body = method.getBody();
+    if (!body || !ts_morph_1.Node.isBlock(body))
+        return false;
+    const statements = body.getStatements();
+    const mutationPos = mutationNode.getStart();
+    // Trouver l'index du statement contenant la mutation
+    let mutationIndex = -1;
+    for (let i = 0; i < statements.length; i++) {
+        const stmtStart = statements[i].getStart();
+        const stmtEnd = statements[i].getEnd();
+        if (mutationPos >= stmtStart && mutationPos <= stmtEnd) {
+            mutationIndex = i;
+            break;
+        }
+    }
+    if (mutationIndex === -1)
+        return false;
+    // Chercher markForCheck() APRÈS la mutation (même statement ou suivants)
+    for (let i = mutationIndex; i < statements.length; i++) {
+        if (containsMarkForCheckCall(statements[i])) {
+            if (i === mutationIndex) {
+                // Même statement : vérifier que markForCheck est APRÈS mutation
+                const markForCheckPos = findMarkForCheckPosition(statements[i]);
+                if (markForCheckPos > mutationPos)
+                    return true;
+            }
+            else {
+                return true; // Statement suivant
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Vérifie si TOUTES les mutations d'une propriété ont markForCheck() appelé après
+ * Retourne true si :
+ * - La propriété n'est jamais mutée (seulement initialisée)
+ * - Toutes les mutations sont suivies de markForCheck()
+ */
+function allMutationsHaveMarkForCheck(classDecl, propertyName) {
+    const mutations = findPropertyMutationsInClass(classDecl, propertyName);
+    // Si aucune mutation → propriété jamais changée → PAS problématique
+    if (mutations.length === 0) {
+        return true;
+    }
+    // Vérifier que TOUTES les mutations ont markForCheck() après
+    return mutations.every(({ mutationNode, containingMethod }) => {
+        if (!containingMethod)
+            return false; // Mutation hors méthode = non protégée
+        return hasMarkForCheckAfterMutation(containingMethod, mutationNode);
+    });
+}
 /**
  * Vérifie si un getter utilise uniquement des propriétés signal/computed dans son body
  * Retourne true si le getter est "safe" (ne nécessite pas markForCheck)
@@ -188,6 +338,31 @@ function findHostBindingDecorators(componentNode) {
     extractHostBindings(parent.getGetAccessors());
     return results;
 }
+/**
+ * Vérifie si un membre résolu (PropertyDeclaration ou GetAccessor) est problématique
+ * Factorise la logique commune entre isProblematicBinding() et matchesHostBindingProperty()
+ * @returns true si problématique, false sinon
+ */
+function isResolvedMemberProblematic(resolved, propertyName, classDecl, notWrappedIn) {
+    // Si c'est un getter → Vérifier si son body utilise uniquement des signals
+    if (ts_morph_1.Node.isGetAccessorDeclaration(resolved)) {
+        if (classDecl && isGetterUsingOnlySignals(resolved, classDecl, notWrappedIn)) {
+            return false; // Getter safe (utilise uniquement des signals)
+        }
+        return true; // Getter problématique
+    }
+    // Si PropertyDeclaration, vérifier wrapper
+    if (ts_morph_1.Node.isPropertyDeclaration(resolved)) {
+        if (!isWrappedInWrappers(resolved, notWrappedIn)) {
+            // Propriété simple - vérifier si markForCheck() est appelé après chaque mutation
+            if (classDecl && allMutationsHaveMarkForCheck(classDecl, propertyName)) {
+                return false; // Toutes mutations protégées par markForCheck() → PAS problématique
+            }
+            return true; // Propriété simple sans markForCheck, PROBLÉMATIQUE
+        }
+    }
+    return false;
+}
 /**
  * Vérifie si un binding est problématique (nécessite markForCheck)
  * Vérifie TOUTES les variables dans l'expression
@@ -211,18 +386,8 @@ function isProblematicBinding(componentNode, bindingValue, notWrappedIn) {
         if (!resolved) {
             continue; // Variable non trouvée, skip
         }
-        // Si c'est un getter → Vérifier si son body utilise uniquement des signals
-        if (ts_morph_1.Node.isGetAccessorDeclaration(resolved)) {
-            if (classDecl && isGetterUsingOnlySignals(resolved, classDecl, notWrappedIn)) {
-                continue; // Getter safe (utilise uniquement des signals)
-            }
-            return true; // Getter problématique
-        }
-        // Si PropertyDeclaration, vérifier wrapper
-        if (ts_morph_1.Node.isPropertyDeclaration(resolved)) {
-            if (!isWrappedInWrappers(resolved, notWrappedIn)) {
-                return true; // Propriété simple, PROBLÉMATIQUE
-            }
+        if (isResolvedMemberProblematic(resolved, variableName, classDecl, notWrappedIn)) {
+            return true;
         }
     }
     return false;
@@ -234,19 +399,21 @@ function isProblematicBinding(componentNode, bindingValue, notWrappedIn) {
  * Détecte 2 sources de host bindings:
  * 1. Objet host dans @Component: host: { '[class.active]': 'isActive' }
  * 2. @HostBinding() decorators sur properties/getters
+ *
+ * @returns Le nœud problématique (PropertyAssignment ou Decorator @HostBinding) ou null si pas de match
  */
 function matchesHostBindingProperty(componentNode, pattern) {
     if (!ts_morph_1.Node.isDecorator(componentNode)) {
-        return false;
+        return null;
     }
     const notWrappedIn = pattern.resolvedProperty.notWrappedIn || [];
     // Source 1: Objet host dans @Component
     const hostObject = getHostObject(componentNode);
     if (hostObject) {
         const bindings = findPropertyBindings(hostObject);
-        for (const { value } of bindings) {
+        for (const { value, node } of bindings) {
             if (isProblematicBinding(componentNode, value, notWrappedIn)) {
-                return true;
+                return node; // Retourner le PropertyAssignment problématique
             }
         }
     }
@@ -254,26 +421,17 @@ function matchesHostBindingProperty(componentNode, pattern) {
     const parent = componentNode.getParent();
     const classDecl = parent && ts_morph_1.Node.isClassDeclaration(parent) ? parent : null;
     const hostBindingDecorators = findHostBindingDecorators(componentNode);
-    for (const { propertyName } of hostBindingDecorators) {
+    for (const { decorator, propertyName } of hostBindingDecorators) {
         const resolved = resolveBindingVariable(componentNode, propertyName);
         if (!resolved) {
             continue;
         }
-        // Si c'est un getter → Vérifier si son body utilise uniquement des signals
-        if (ts_morph_1.Node.isGetAccessorDeclaration(resolved)) {
-            if (classDecl && isGetterUsingOnlySignals(resolved, classDecl, notWrappedIn)) {
-                continue; // Getter safe (utilise uniquement des signals)
-            }
-            return true; // Getter problématique
-        }
-        // Si PropertyDeclaration, vérifier wrapper
-        if (ts_morph_1.Node.isPropertyDeclaration(resolved)) {
-            if (!isWrappedInWrappers(resolved, notWrappedIn)) {
-                return true;
-            }
+        // Utiliser la fonction factorisée (DRY)
+        if (isResolvedMemberProblematic(resolved, propertyName, classDecl, notWrappedIn)) {
+            return decorator; // Retourner le @HostBinding decorator problématique
         }
     }
-    return false;
+    return null;
 }
 /**
  * Vérifie si un composant a des @HostListener sur ses méthodes

package/dist/src/core/ast/matchers/utils/matcher-helpers.js

@@ -56,13 +56,19 @@ function stripQuotes(str) {
  *   'isActive' → ['isActive']
  *   'count > 0' → ['count']
  *   'count1 + count2' → ['count1', 'count2']
- *   'sig() ? "a" : "b"' → ['sig']
+ *   'sig() ? "a" : "b"' → ['sig'] (strings littérales ignorées)
  *   'obj.prop' → ['obj']
+ *   '"search"' → [] (string littérale pure = pas de variable)
  * @param expression Expression de binding
  * @returns Array de noms de variables
  */
 function extractVariableNames(expression) {
-    const cleaned = expression.trim();
+    // Supprimer les strings littérales pour éviter les faux positifs
+    // '"search"' → '', 'sig() ? "a" : "b"' → 'sig() ?  : '
+    const withoutStrings = expression
+        .replace(/"[^"]*"/g, '') // Supprimer strings double quotes
+        .replace(/'[^']*'/g, ''); // Supprimer strings single quotes
+    const cleaned = withoutStrings.trim();
     const variables = new Set();
     // Pattern pour extraire tous les identifiants valides
     const identifierPattern = /\b([a-zA-Z_$][a-zA-Z0-9_$]*)\b/g;

package/dist/src/core/ast/scanner-ast.js

@@ -131,18 +131,22 @@ function processNodeWithRules(node, rules, sourceFile, relativeFilePath, matches
             // Vérifier testSetup si présent
             if (rule.astPattern.testSetup &&
                 !matchers_1.FileMatcher.matchesTestSetup(sourceFile, rule.astPattern.testSetup)) {
+                (0, matchers_1.clearOverrideNode)(); // Nettoyer même si on skip
                 continue;
             }
+            // Utiliser le nœud override si disponible (localisation précise)
+            const reportNode = (0, matchers_1.getOverrideNode)() || node;
+            (0, matchers_1.clearOverrideNode)(); // Toujours nettoyer après utilisation
             // Optimisation getText() : vérifier width d'abord
-            const width = node.getWidth();
+            const width = reportNode.getWidth();
             const matchedText = width > 100
-                ? node.getText().substring(0, 100).trim()
-                : node.getText().trim();
+                ? reportNode.getText().substring(0, 100).trim()
+                : reportNode.getText().trim();
             matches.push({
                 ruleKey: rule.key,
                 ruleSummary: rule.summary,
                 filePath: relativeFilePath,
-                lineNumber: node.getStartLineNumber(),
+                lineNumber: reportNode.getStartLineNumber(),
                 matchedText
             });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@silvestv/migration-planificator",
-  "version": "6.0.2",
+  "version": "6.0.3",
   "description": "Professional Angular migration analysis tool with AST precision for version upgrades (17→18, 18→19, 19→20, 20→21), Nx monorepo refactoring, workload estimation, and technical debt assessment. Interactive HTML reports with Gantt timeline and real-time editing.",
   "main": "dist/src/index.js",
   "publishConfig": {