@grafema/core 0.1.0-alpha.4 → 0.1.1-alpha

package/src/plugins/analysis/ast/visitors/ClassVisitor.ts

@@ -22,22 +22,20 @@ import type {
 import type { NodePath } from '@babel/traverse';
 import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers } from './ASTVisitor.js';
 import type { AnalyzeFunctionBodyCallback } from './FunctionVisitor.js';
-import type { DecoratorInfo } from '../types.js';
+import type { DecoratorInfo, ParameterInfo } from '../types.js';
 import { ExpressionEvaluator } from '../ExpressionEvaluator.js';
+import { createParameterNodes } from '../utils/createParameterNodes.js';
+import { ScopeTracker } from '../../../../core/ScopeTracker.js';
+import { ClassNode, type ClassNodeRecord } from '../../../../core/nodes/ClassNode.js';
+import { computeSemanticId } from '../../../../core/SemanticId.js';
+import { getLine, getColumn } from '../utils/location.js';
 
 /**
  * Class declaration info
+ * Extends ClassNodeRecord with TypeScript-specific metadata
  */
-interface ClassInfo {
-  id: string;
-  type: 'CLASS';
-  name: string;
-  file: string;
-  line: number;
-  column: number;
-  superClass: string | null;
-  implements?: string[];  // TypeScript implements
-  methods: string[];
+interface ClassInfo extends ClassNodeRecord {
+  implements?: string[];  // TypeScript implements (visitor extension)
 }
 
 /**
@@ -45,7 +43,6 @@ interface ClassInfo {
  */
 interface ClassFunctionInfo {
   id: string;
-  stableId: string;
   type: 'FUNCTION';
   name: string;
   file: string;
@@ -58,6 +55,7 @@ interface ClassFunctionInfo {
   isClassMethod?: boolean;
   className: string;
   methodKind?: 'constructor' | 'method' | 'get' | 'set';
+  legacyId?: string;  // Kept for debugging/migration purposes
 }
 
 /**
@@ -65,6 +63,7 @@ interface ClassFunctionInfo {
  */
 interface ScopeInfo {
   id: string;
+  semanticId?: string;
   type: 'SCOPE';
   scopeType: string;
   name: string;
@@ -76,19 +75,23 @@ interface ScopeInfo {
 
 export class ClassVisitor extends ASTVisitor {
   private analyzeFunctionBody: AnalyzeFunctionBodyCallback;
+  private scopeTracker: ScopeTracker;
 
   /**
    * @param module - Current module being analyzed
    * @param collections - Must contain arrays and counter refs
    * @param analyzeFunctionBody - Callback to analyze method internals
+   * @param scopeTracker - REQUIRED for semantic ID generation
    */
   constructor(
     module: VisitorModule,
     collections: VisitorCollections,
-    analyzeFunctionBody: AnalyzeFunctionBodyCallback
+    analyzeFunctionBody: AnalyzeFunctionBodyCallback,
+    scopeTracker: ScopeTracker  // REQUIRED, not optional
   ) {
     super(module, collections);
     this.analyzeFunctionBody = analyzeFunctionBody;
+    this.scopeTracker = scopeTracker;
   }
 
   /**
@@ -124,15 +127,17 @@ export class ClassVisitor extends ASTVisitor {
       return null;  // Unsupported decorator type
     }
 
-    const decoratorId = `DECORATOR#${decoratorName}#${module.file}#${decorator.loc!.start.line}:${decorator.loc!.start.column}`;
+    const decoratorLine = getLine(decorator);
+    const decoratorColumn = getColumn(decorator);
+    const decoratorId = `DECORATOR#${decoratorName}#${module.file}#${decoratorLine}:${decoratorColumn}`;
 
     return {
       id: decoratorId,
       type: 'DECORATOR',
       name: decoratorName,
       file: module.file,
-      line: decorator.loc!.start.line,
-      column: decorator.loc!.start.column,
+      line: decoratorLine,
+      column: decoratorColumn,
       arguments: decoratorArgs,
       targetId,
       targetType
@@ -145,11 +150,13 @@ export class ClassVisitor extends ASTVisitor {
       functions,
       scopes,
       classDeclarations,
-      decorators
+      decorators,
+      parameters
     } = this.collections;
 
     const analyzeFunctionBody = this.analyzeFunctionBody;
     const collections = this.collections;
+    const scopeTracker = this.scopeTracker;
 
     return {
       ClassDeclaration: (classPath: NodePath) => {
@@ -158,12 +165,22 @@ export class ClassVisitor extends ASTVisitor {
 
         const className = classNode.id.name;
 
-        // Create CLASS node for declaration
-        const classId = `CLASS#${className}#${module.file}#${classNode.loc!.start.line}`;
+        // Extract superClass name
         const superClassName = classNode.superClass?.type === 'Identifier'
           ? (classNode.superClass as Identifier).name
           : null;
 
+        const classLine = getLine(classNode);
+        const classColumn = getColumn(classNode);
+
+        // Create CLASS node using NodeFactory with semantic ID
+        const classRecord = ClassNode.createWithContext(
+          className,
+          scopeTracker.getContext(),
+          { line: classLine, column: classColumn },
+          { superClass: superClassName || undefined }
+        );
+
         // Extract implements (TypeScript)
         const implementsNames: string[] = [];
         const classNodeWithImplements = classNode as ClassDeclaration & { implements?: Array<{ expression: { type: string; name?: string } }> };
@@ -175,23 +192,20 @@ export class ClassVisitor extends ASTVisitor {
           }
         }
 
+        // Store ClassNodeRecord + TypeScript metadata
         (classDeclarations as ClassInfo[]).push({
-          id: classId,
-          type: 'CLASS',
-          name: className,
-          file: module.file,
-          line: classNode.loc!.start.line,
-          column: classNode.loc!.start.column,
-          superClass: superClassName,
-          implements: implementsNames.length > 0 ? implementsNames : undefined,
-          methods: []
+          ...classRecord,
+          implements: implementsNames.length > 0 ? implementsNames : undefined
         });
 
+        // Enter class scope for tracking methods
+        scopeTracker.enterScope(className, 'CLASS');
+
         // Extract class decorators
         const classNodeWithDecorators = classNode as ClassDeclaration & { decorators?: Decorator[] };
         if (classNodeWithDecorators.decorators && classNodeWithDecorators.decorators.length > 0 && decorators) {
           for (const decorator of classNodeWithDecorators.decorators) {
-            const decoratorInfo = this.extractDecoratorInfo(decorator, classId, 'CLASS', module);
+            const decoratorInfo = this.extractDecoratorInfo(decorator, classRecord.id, 'CLASS', module);
             if (decoratorInfo) {
               (decorators as DecoratorInfo[]).push(decoratorInfo);
             }
@@ -216,11 +230,14 @@ export class ClassVisitor extends ASTVisitor {
               ? propNode.key.name
               : (propNode.key as { value?: string }).value || 'anonymous';
 
+            const propLine = getLine(propNode);
+            const propColumn = getColumn(propNode);
+
             // Extract property decorators (even for non-function properties)
             const propNodeWithDecorators = propNode as ClassProperty & { decorators?: Decorator[] };
             if (propNodeWithDecorators.decorators && propNodeWithDecorators.decorators.length > 0 && decorators) {
               // For function properties, target will be set later; for regular properties, create a target ID
-              const propertyTargetId = `PROPERTY#${className}.${propName}#${module.file}#${propNode.loc!.start.line}`;
+              const propertyTargetId = `PROPERTY#${className}.${propName}#${module.file}#${propLine}`;
               for (const decorator of propNodeWithDecorators.decorators) {
                 const decoratorInfo = this.extractDecoratorInfo(decorator, propertyTargetId, 'PROPERTY', module);
                 if (decoratorInfo) {
@@ -236,41 +253,56 @@ export class ClassVisitor extends ASTVisitor {
 
               const funcNode = propNode.value as ArrowFunctionExpression | FunctionExpression;
 
-              const functionId = `FUNCTION#${className}.${propName}#${module.file}#${propNode.loc!.start.line}:${propNode.loc!.start.column}`;
+              // Use semantic ID as primary ID (matching FunctionVisitor pattern)
+              const legacyId = `FUNCTION#${className}.${propName}#${module.file}#${propLine}:${propColumn}`;
+              const functionId = computeSemanticId('FUNCTION', propName, scopeTracker.getContext());
 
               // Add method to class methods list for CONTAINS edges
               currentClass.methods.push(functionId);
 
               (functions as ClassFunctionInfo[]).push({
                 id: functionId,
-                stableId: functionId,
                 type: 'FUNCTION',
                 name: propName,
                 file: module.file,
-                line: propNode.loc!.start.line,
-                column: propNode.loc!.start.column,
+                line: propLine,
+                column: propColumn,
                 async: funcNode.async || false,
                 generator: funcNode.type === 'FunctionExpression' ? funcNode.generator || false : false,
                 arrowFunction: funcNode.type === 'ArrowFunctionExpression',
                 isClassProperty: true,
-                className: className
+                className: className,
+                legacyId  // Keep for debugging/migration purposes
               });
 
+              // Enter method scope for tracking
+              scopeTracker.enterScope(propName, 'FUNCTION');
+
+              // Create PARAMETER nodes for class property function parameters (REG-134)
+              if (parameters) {
+                createParameterNodes(funcNode.params, functionId, module.file, propLine, parameters as ParameterInfo[], scopeTracker);
+              }
+
               // Create SCOPE for property function body
-              const propBodyScopeId = `SCOPE#${className}.${propName}:body#${module.file}#${propNode.loc!.start.line}`;
+              const propBodyScopeId = `SCOPE#${className}.${propName}:body#${module.file}#${propLine}`;
+              const propBodySemanticId = computeSemanticId('SCOPE', 'body', scopeTracker.getContext());
               (scopes as ScopeInfo[]).push({
                 id: propBodyScopeId,
+                semanticId: propBodySemanticId,
                 type: 'SCOPE',
                 scopeType: 'property_body',
                 name: `${className}.${propName}:body`,
                 conditional: false,
                 file: module.file,
-                line: propNode.loc!.start.line,
+                line: propLine,
                 parentFunctionId: functionId
               });
 
               const funcPath = propPath.get('value') as NodePath<ArrowFunctionExpression | FunctionExpression>;
               analyzeFunctionBody(funcPath, propBodyScopeId, module, collections);
+
+              // Exit method scope
+              scopeTracker.exitScope();
             }
           },
 
@@ -285,24 +317,29 @@ export class ClassVisitor extends ASTVisitor {
               return;
             }
 
-            const functionId = `FUNCTION#${className}.${methodName}#${module.file}#${methodNode.loc!.start.line}:${methodNode.loc!.start.column}`;
+            const methodLine = getLine(methodNode);
+            const methodColumn = getColumn(methodNode);
+
+            // Use semantic ID as primary ID (matching FunctionVisitor pattern)
+            const legacyId = `FUNCTION#${className}.${methodName}#${module.file}#${methodLine}:${methodColumn}`;
+            const functionId = computeSemanticId('FUNCTION', methodName, scopeTracker.getContext());
 
             // Add method to class methods list for CONTAINS edges
             currentClass.methods.push(functionId);
 
             const funcData: ClassFunctionInfo = {
               id: functionId,
-              stableId: functionId,
               type: 'FUNCTION',
               name: methodName,
               file: module.file,
-              line: methodNode.loc!.start.line,
-              column: methodNode.loc!.start.column,
+              line: methodLine,
+              column: methodColumn,
               async: methodNode.async || false,
               generator: methodNode.generator || false,
               isClassMethod: true,
               className: className,
-              methodKind: methodNode.kind as 'constructor' | 'method' | 'get' | 'set'
+              methodKind: methodNode.kind as 'constructor' | 'method' | 'get' | 'set',
+              legacyId  // Keep for debugging/migration purposes
             };
             (functions as ClassFunctionInfo[]).push(funcData);
 
@@ -317,22 +354,38 @@ export class ClassVisitor extends ASTVisitor {
               }
             }
 
+            // Enter method scope for tracking
+            scopeTracker.enterScope(methodName, 'FUNCTION');
+
+            // Create PARAMETER nodes for class method parameters (REG-134)
+            if (parameters) {
+              createParameterNodes(methodNode.params, functionId, module.file, methodLine, parameters as ParameterInfo[], scopeTracker);
+            }
+
             // Create SCOPE for method body
-            const methodBodyScopeId = `SCOPE#${className}.${methodName}:body#${module.file}#${methodNode.loc!.start.line}`;
+            const methodBodyScopeId = `SCOPE#${className}.${methodName}:body#${module.file}#${methodLine}`;
+            const methodBodySemanticId = computeSemanticId('SCOPE', 'body', scopeTracker.getContext());
             (scopes as ScopeInfo[]).push({
               id: methodBodyScopeId,
+              semanticId: methodBodySemanticId,
               type: 'SCOPE',
               scopeType: 'method_body',
               name: `${className}.${methodName}:body`,
               conditional: false,
               file: module.file,
-              line: methodNode.loc!.start.line,
+              line: methodLine,
               parentFunctionId: functionId
             });
 
             analyzeFunctionBody(methodPath, methodBodyScopeId, module, collections);
+
+            // Exit method scope
+            scopeTracker.exitScope();
           }
         });
+
+        // Exit class scope
+        scopeTracker.exitScope();
       }
     };
   }