@grafema/core 0.2.5-beta → 0.2.7

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

@@ -16,12 +16,12 @@
  * - The final link (c) is handled by CALL
  */
 
-import type { MemberExpression, Identifier, StringLiteral, NumericLiteral, Node } from '@babel/types';
+import type { MemberExpression, MetaProperty, Identifier, StringLiteral, NumericLiteral, Node } from '@babel/types';
 import type { NodePath } from '@babel/traverse';
 import { ASTVisitor, type VisitorModule, type VisitorCollections, type VisitorHandlers } from './ASTVisitor.js';
 import type { PropertyAccessInfo, CounterRef } from '../types.js';
 import type { ScopeTracker } from '../../../../core/ScopeTracker.js';
-import { computeSemanticId } from '../../../../core/SemanticId.js';
+import { computeSemanticIdV2 } from '../../../../core/SemanticId.js';
 import { getLine, getColumn } from '../utils/location.js';
 
 /**
@@ -79,9 +79,29 @@ export class PropertyAccessVisitor extends ASTVisitor {
       );
     };
 
+    const metaPropertyHandler = (path: NodePath) => {
+      const node = path.node as unknown as MetaProperty;
+
+      // Skip if inside function — analyzeFunctionBody handles those
+      const functionParent = path.getFunctionParent();
+      if (functionParent) {
+        return;
+      }
+
+      PropertyAccessVisitor.extractMetaProperty(
+        node,
+        module,
+        propertyAccesses,
+        propertyAccessCounterRef,
+        scopeTracker,
+        module.id  // Module-level scope
+      );
+    };
+
     return {
       MemberExpression: handler,
-      OptionalMemberExpression: handler
+      OptionalMemberExpression: handler,
+      MetaProperty: metaPropertyHandler
     };
   }
 
@@ -126,7 +146,7 @@ export class PropertyAccessVisitor extends ASTVisitor {
       let id: string;
       if (scopeTracker) {
         const discriminator = scopeTracker.getItemCounter(`PROPERTY_ACCESS:${fullName}`);
-        id = computeSemanticId('PROPERTY_ACCESS', fullName, scopeTracker.getContext(), { discriminator });
+        id = computeSemanticIdV2('PROPERTY_ACCESS', fullName, module.file, scopeTracker.getNamedParent(), undefined, discriminator);
       } else {
         id = `PROPERTY_ACCESS#${fullName}#${module.file}#${info.line}:${info.column}:${propertyAccessCounterRef.value++}`;
       }
@@ -147,6 +167,48 @@ export class PropertyAccessVisitor extends ASTVisitor {
     }
   }
 
+  /**
+   * Process a MetaProperty node (new.target) and create a PROPERTY_ACCESS entry.
+   *
+   * `new.target` is represented in Babel AST as MetaProperty { meta: "new", property: "target" }.
+   * We track it as PROPERTY_ACCESS with objectName="new", propertyName="target" —
+   * consistent with how ThisExpression uses objectName="this".
+   */
+  static extractMetaProperty(
+    node: MetaProperty,
+    module: VisitorModule,
+    propertyAccesses: PropertyAccessInfo[],
+    propertyAccessCounterRef: CounterRef,
+    scopeTracker: ScopeTracker | undefined,
+    parentScopeId: string
+  ): void {
+    const objectName = node.meta.name;   // "new"
+    const propertyName = node.property.name;  // "target"
+    const fullName = `${objectName}.${propertyName}`;
+
+    let id: string;
+    if (scopeTracker) {
+      const discriminator = scopeTracker.getItemCounter(`PROPERTY_ACCESS:${fullName}`);
+      id = computeSemanticIdV2('PROPERTY_ACCESS', fullName, module.file, scopeTracker.getNamedParent(), undefined, discriminator);
+    } else {
+      const line = node.loc?.start?.line ?? 0;
+      const column = node.loc?.start?.column ?? 0;
+      id = `PROPERTY_ACCESS#${fullName}#${module.file}#${line}:${column}:${propertyAccessCounterRef.value++}`;
+    }
+
+    propertyAccesses.push({
+      id,
+      semanticId: id,
+      type: 'PROPERTY_ACCESS',
+      objectName,
+      propertyName,
+      file: module.file,
+      line: node.loc?.start?.line ?? 0,
+      column: node.loc?.start?.column ?? 0,
+      parentScopeId
+    });
+  }
+
   /**
    * Check if this MemberExpression is the direct callee of a CallExpression.
    * e.g., in `obj.method()`, the MemberExpression `obj.method` is the callee.
@@ -276,6 +338,9 @@ export class PropertyAccessVisitor extends ASTVisitor {
       baseName = (baseObject as Identifier).name;
     } else if (baseObject?.type === 'ThisExpression') {
       baseName = 'this';
+    } else if (baseObject?.type === 'MetaProperty') {
+      // import.meta → treat as base object "import.meta" (REG-300)
+      baseName = 'import.meta';
     } else {
       // Complex expression as base - not trackable as simple property access
       return [];

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

@@ -23,10 +23,11 @@ import type {
   InterfacePropertyInfo,
   TypeAliasInfo,
   EnumDeclarationInfo,
-  EnumMemberInfo
+  EnumMemberInfo,
+  TypeParameterInfo
 } from '../types.js';
 import type { ScopeTracker } from '../../../../core/ScopeTracker.js';
-import { computeSemanticId } from '../../../../core/SemanticId.js';
+import { computeSemanticIdV2 } from '../../../../core/SemanticId.js';
 import { getLine, getColumn } from '../utils/location.js';
 
 /**
@@ -62,12 +63,16 @@ export function typeNodeToString(node: unknown): string {
       return 'symbol';
     case 'TSBigIntKeyword':
       return 'bigint';
-    case 'TSTypeReference':
+    case 'TSTypeReference': {
       const typeName = typeNode.typeName as { type: string; name?: string };
-      if (typeName?.type === 'Identifier') {
-        return typeName.name || 'unknown';
+      const baseName = typeName?.type === 'Identifier' ? (typeName.name || 'unknown') : 'unknown';
+      const typeParams = typeNode.typeParameters as { params?: unknown[] } | undefined;
+      if (typeParams?.params?.length) {
+        const paramStrs = typeParams.params.map(p => typeNodeToString(p));
+        return `${baseName}<${paramStrs.join(', ')}>`;
       }
-      return 'unknown';
+      return baseName;
+    }
     case 'TSArrayType':
       return `${typeNodeToString(typeNode.elementType)}[]`;
     case 'TSUnionType':
@@ -93,11 +98,155 @@ export function typeNodeToString(node: unknown): string {
       return `[${tupleTypes.map(t => typeNodeToString(t)).join(', ')}]`;
     case 'TSTypeLiteral':
       return 'object';
+    case 'TSTypeOperator': {
+      const operator = typeNode.operator as string;
+      const operand = typeNodeToString(typeNode.typeAnnotation);
+      return `${operator} ${operand}`;
+    }
+    case 'TSIndexedAccessType': {
+      const object = typeNodeToString(typeNode.objectType);
+      const index = typeNodeToString(typeNode.indexType);
+      return `${object}[${index}]`;
+    }
+    case 'TSMappedType': {
+      const tp = typeNode.typeParameter as { name?: string; constraint?: unknown };
+      const keyName = tp?.name || 'K';
+      const constraint = tp?.constraint ? typeNodeToString(tp.constraint) : '';
+      const valType = typeNode.typeAnnotation ? typeNodeToString(typeNode.typeAnnotation) : 'unknown';
+      const readonlyMod = typeNode.readonly === '-' ? '-readonly ' : typeNode.readonly ? 'readonly ' : '';
+      const optionalMod = typeNode.optional === '-' ? '-?' : typeNode.optional ? '?' : '';
+      const asClause = typeNode.nameType ? ` as ${typeNodeToString(typeNode.nameType)}` : '';
+      return `{ ${readonlyMod}[${keyName} in ${constraint}${asClause}]${optionalMod}: ${valType} }`;
+    }
+    case 'TSConditionalType': {
+      const check = typeNodeToString(typeNode.checkType);
+      const ext = typeNodeToString(typeNode.extendsType);
+      const trueType = typeNodeToString(typeNode.trueType);
+      const falseType = typeNodeToString(typeNode.falseType);
+      return `${check} extends ${ext} ? ${trueType} : ${falseType}`;
+    }
+    case 'TSTypeQuery': {
+      const exprName = typeNode.exprName as { type: string; name?: string };
+      return exprName?.type === 'Identifier' ? `typeof ${exprName.name}` : 'typeof unknown';
+    }
+    case 'TSParenthesizedType':
+      return `(${typeNodeToString(typeNode.typeAnnotation)})`;
+    case 'TSInferType': {
+      const param = typeNode.typeParameter as { name?: string };
+      return `infer ${param?.name || 'U'}`;
+    }
+    case 'TSTemplateLiteralType': {
+      const quasis = typeNode.quasis as Array<{ value?: { raw?: string } }>;
+      const typeTypes = typeNode.types as unknown[];
+      let result = '`';
+      for (let i = 0; i < quasis.length; i++) {
+        result += quasis[i]?.value?.raw || '';
+        if (i < (typeTypes?.length || 0)) {
+          result += `\${${typeNodeToString(typeTypes[i])}}`;
+        }
+      }
+      result += '`';
+      return result;
+    }
+    case 'TSRestType':
+      return `...${typeNodeToString(typeNode.typeAnnotation)}`;
+    case 'TSOptionalType':
+      return `${typeNodeToString(typeNode.typeAnnotation)}?`;
+    case 'TSNamedTupleMember': {
+      const label = (typeNode.label as { name?: string })?.name || '';
+      const elemType = typeNodeToString(typeNode.elementType);
+      return typeNode.optional ? `${label}?: ${elemType}` : `${label}: ${elemType}`;
+    }
     default:
       return 'unknown';
   }
 }
 
+/**
+ * Extracts type parameter info from a TSTypeParameterDeclaration node.
+ *
+ * Handles:
+ * - Simple: <T>
+ * - Constrained: <T extends Serializable>
+ * - Defaulted: <T = string>
+ * - Variance: <in T>, <out T>, <in out T>
+ * - Intersection constraints: <T extends A & B>
+ *
+ * @param typeParameters - Babel TSTypeParameterDeclaration node (or undefined)
+ * @param parentId - ID of the owning declaration
+ * @param parentType - 'FUNCTION' | 'CLASS' | 'INTERFACE' | 'TYPE'
+ * @param file - File path
+ * @param line - Line of the declaration
+ * @param column - Column of the declaration
+ * @returns Array of TypeParameterInfo (empty if no type params)
+ */
+export function extractTypeParameters(
+  typeParameters: unknown,
+  parentId: string,
+  parentType: 'FUNCTION' | 'CLASS' | 'INTERFACE' | 'TYPE',
+  file: string,
+  line: number,
+  column: number
+): TypeParameterInfo[] {
+  if (!typeParameters || typeof typeParameters !== 'object') return [];
+
+  const tpDecl = typeParameters as { type?: string; params?: unknown[] };
+  if (tpDecl.type !== 'TSTypeParameterDeclaration' || !Array.isArray(tpDecl.params)) return [];
+
+  const result: TypeParameterInfo[] = [];
+
+  for (const param of tpDecl.params) {
+    const tsParam = param as {
+      type?: string;
+      name?: string;
+      constraint?: unknown;
+      default?: unknown;
+      in?: boolean;
+      out?: boolean;
+      loc?: { start?: { line?: number; column?: number } };
+    };
+
+    if (tsParam.type !== 'TSTypeParameter') continue;
+
+    const paramName = tsParam.name;
+    if (!paramName) continue;
+
+    // Extract constraint via typeNodeToString
+    const constraintType = tsParam.constraint ? typeNodeToString(tsParam.constraint) : undefined;
+
+    // Extract default via typeNodeToString
+    const defaultType = tsParam.default ? typeNodeToString(tsParam.default) : undefined;
+
+    // Extract variance
+    let variance: 'in' | 'out' | 'in out' | undefined;
+    if (tsParam.in && tsParam.out) {
+      variance = 'in out';
+    } else if (tsParam.in) {
+      variance = 'in';
+    } else if (tsParam.out) {
+      variance = 'out';
+    }
+
+    // Use param's own location if available, otherwise fall back to declaration location
+    const paramLine = tsParam.loc?.start?.line ?? line;
+    const paramColumn = tsParam.loc?.start?.column ?? column;
+
+    result.push({
+      name: paramName,
+      constraintType: constraintType !== 'unknown' ? constraintType : undefined,
+      defaultType: defaultType !== 'unknown' ? defaultType : undefined,
+      variance,
+      parentId,
+      parentType,
+      file,
+      line: paramLine,
+      column: paramColumn,
+    });
+  }
+
+  return result;
+}
+
 export class TypeScriptVisitor extends ASTVisitor {
   private scopeTracker?: ScopeTracker;
 
@@ -116,7 +265,8 @@ export class TypeScriptVisitor extends ASTVisitor {
     const {
       interfaces,
       typeAliases,
-      enums
+      enums,
+      typeParameters
     } = this.collections;
     const scopeTracker = this.scopeTracker;
 
@@ -130,7 +280,7 @@ export class TypeScriptVisitor extends ASTVisitor {
         // Generate semantic ID if scopeTracker available
         let interfaceSemanticId: string | undefined;
         if (scopeTracker) {
-          interfaceSemanticId = computeSemanticId('INTERFACE', interfaceName, scopeTracker.getContext());
+          interfaceSemanticId = computeSemanticIdV2('INTERFACE', interfaceName, module.file, scopeTracker.getNamedParent());
         }
 
         // Extract extends
@@ -171,6 +321,22 @@ export class TypeScriptVisitor extends ASTVisitor {
           }
         }
 
+        // Extract type parameters (REG-303)
+        if (typeParameters && node.typeParameters) {
+          const interfaceId = `${module.file}:INTERFACE:${interfaceName}:${getLine(node)}`;
+          const typeParamInfos = extractTypeParameters(
+            node.typeParameters,
+            interfaceId,
+            'INTERFACE',
+            module.file,
+            getLine(node),
+            getColumn(node)
+          );
+          for (const tp of typeParamInfos) {
+            (typeParameters as TypeParameterInfo[]).push(tp);
+          }
+        }
+
         (interfaces as InterfaceDeclarationInfo[]).push({
           semanticId: interfaceSemanticId,
           type: 'INTERFACE',
@@ -192,21 +358,74 @@ export class TypeScriptVisitor extends ASTVisitor {
         // Generate semantic ID if scopeTracker available
         let typeSemanticId: string | undefined;
         if (scopeTracker) {
-          typeSemanticId = computeSemanticId('TYPE', typeName, scopeTracker.getContext());
+          typeSemanticId = computeSemanticIdV2('TYPE', typeName, module.file, scopeTracker.getNamedParent());
         }
 
         // Extract the type being aliased
         const aliasOf = typeNodeToString(node.typeAnnotation);
 
-        (typeAliases as TypeAliasInfo[]).push({
+        // Extract type parameters (REG-303)
+        if (typeParameters && node.typeParameters) {
+          const typeId = `${module.file}:TYPE:${typeName}:${getLine(node)}`;
+          const typeParamInfos = extractTypeParameters(
+            node.typeParameters,
+            typeId,
+            'TYPE',
+            module.file,
+            getLine(node),
+            getColumn(node)
+          );
+          for (const tp of typeParamInfos) {
+            (typeParameters as TypeParameterInfo[]).push(tp);
+          }
+        }
+
+        // REG-304: Detect conditional type and extract branch metadata
+        const typeAnnotation = node.typeAnnotation as { type: string; [key: string]: unknown };
+        const isConditional = typeAnnotation?.type === 'TSConditionalType';
+
+        const typeInfo: TypeAliasInfo = {
           semanticId: typeSemanticId,
           type: 'TYPE',
           name: typeName,
           file: module.file,
           line: getLine(node),
           column: getColumn(node),
-          aliasOf
-        });
+          aliasOf,
+          ...(isConditional && {
+            conditionalType: true,
+            checkType: typeNodeToString(typeAnnotation.checkType),
+            extendsType: typeNodeToString(typeAnnotation.extendsType),
+            trueType: typeNodeToString(typeAnnotation.trueType),
+            falseType: typeNodeToString(typeAnnotation.falseType),
+          }),
+        };
+
+        // Detect mapped types: { [K in keyof T]: T[K] }
+        const annotation = node.typeAnnotation as { type: string; [key: string]: unknown };
+        if (annotation?.type === 'TSMappedType') {
+          typeInfo.mappedType = true;
+
+          const tp = annotation.typeParameter as { name?: string; constraint?: unknown };
+          if (tp?.name) typeInfo.keyName = tp.name;
+          if (tp?.constraint) typeInfo.keyConstraint = typeNodeToString(tp.constraint);
+
+          if (annotation.typeAnnotation) {
+            typeInfo.valueType = typeNodeToString(annotation.typeAnnotation);
+          }
+
+          if (annotation.readonly !== undefined && annotation.readonly !== null) {
+            typeInfo.mappedReadonly = annotation.readonly as boolean | '+' | '-';
+          }
+          if (annotation.optional !== undefined && annotation.optional !== null) {
+            typeInfo.mappedOptional = annotation.optional as boolean | '+' | '-';
+          }
+          if (annotation.nameType) {
+            typeInfo.nameType = typeNodeToString(annotation.nameType);
+          }
+        }
+
+        (typeAliases as TypeAliasInfo[]).push(typeInfo);
       },
 
       TSEnumDeclaration: (path: NodePath) => {
@@ -218,7 +437,7 @@ export class TypeScriptVisitor extends ASTVisitor {
         // Generate semantic ID if scopeTracker available
         let enumSemanticId: string | undefined;
         if (scopeTracker) {
-          enumSemanticId = computeSemanticId('ENUM', enumName, scopeTracker.getContext());
+          enumSemanticId = computeSemanticIdV2('ENUM', enumName, module.file, scopeTracker.getNamedParent());
         }
 
         // Extract members

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

@@ -64,6 +64,7 @@ interface VariableDeclarationInfo {
   line: number;
   parentScopeId: string;
   value?: unknown;
+  scopePath?: string[];
 }
 
 /**
@@ -181,7 +182,6 @@ export class VariableVisitor extends ASTVisitor {
     const literals = (this.collections.literals ?? []) as unknown[];
     const variableAssignments = this.collections.variableAssignments ?? [];
     const scopes = (this.collections.scopes ?? []) as unknown[];
-    const varDeclCounterRef = (this.collections.varDeclCounterRef ?? { value: 0 }) as CounterRef;
     const literalCounterRef = (this.collections.literalCounterRef ?? { value: 0 }) as CounterRef;
     const scopeCounterRef = (this.collections.scopeCounterRef ?? { value: 0 }) as CounterRef;
     // Object literal tracking collections (REG-328)
@@ -256,14 +256,9 @@ export class VariableVisitor extends ASTVisitor {
 
               // Generate ID using centralized IdGenerator
               const idGenerator = new IdGenerator(scopeTracker);
-              const varId = idGenerator.generate(
-                nodeType,
-                varInfo.name,
-                module.file,
-                varInfo.loc.start.line,
-                varInfo.loc.start.column,
-                varDeclCounterRef as CounterRef
-              );
+              const varId = idGenerator.generateV2Simple(nodeType, varInfo.name, module.file);
+
+              const currentScopePath = scopeTracker?.getContext().scopePath ?? [];
 
               if (shouldBeConstant) {
                 // CONSTANT node
@@ -273,7 +268,8 @@ export class VariableVisitor extends ASTVisitor {
                   name: varInfo.name,
                   file: module.file,
                   line: varInfo.loc.start.line,
-                  parentScopeId: module.id
+                  parentScopeId: module.id,
+                  scopePath: currentScopePath
                 };
 
                 if (isLiteral) {
@@ -303,7 +299,8 @@ export class VariableVisitor extends ASTVisitor {
                   name: varInfo.name,
                   file: module.file,
                   line: varInfo.loc.start.line,
-                  parentScopeId: module.id
+                  parentScopeId: module.id,
+                  scopePath: currentScopePath
                 });
               }
 

package/src/plugins/analysis/ast/visitors/call-expression-helpers.ts

@@ -0,0 +1,65 @@
+/**
+ * Helper functions for CallExpressionVisitor — grafema-ignore annotation detection.
+ *
+ * Extracted from CallExpressionVisitor.ts (REG-424) to reduce file size.
+ */
+
+import type { Node, Comment } from '@babel/types';
+import type { NodePath } from '@babel/traverse';
+import type { GrafemaIgnoreAnnotation } from '../types.js';
+
+/**
+ * Pattern for grafema-ignore comments (REG-332)
+ * Matches:
+ *   // grafema-ignore STRICT_UNRESOLVED_METHOD
+ *   // grafema-ignore STRICT_UNRESOLVED_METHOD - known library call
+ *   block comments with same pattern
+ */
+const GRAFEMA_IGNORE_PATTERN = /grafema-ignore(?:-next-line)?\s+([\w_]+)(?:\s+-\s+(.+))?/;
+
+/**
+ * Check node's leadingComments for grafema-ignore annotation.
+ */
+function checkNodeComments(node: Node): GrafemaIgnoreAnnotation | null {
+  const comments = (node as { leadingComments?: Comment[] }).leadingComments;
+  if (!comments || comments.length === 0) return null;
+
+  // Check comments from last to first (closest to node wins)
+  for (let i = comments.length - 1; i >= 0; i--) {
+    const comment = comments[i];
+    const text = comment.value.trim();
+    const match = text.match(GRAFEMA_IGNORE_PATTERN);
+    if (match) {
+      return {
+        code: match[1],
+        reason: match[2]?.trim(),
+      };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Check if a call has a grafema-ignore comment for suppressing strict mode errors.
+ * Babel attaches leading comments to statements (VariableDeclaration, ExpressionStatement),
+ * not to nested CallExpression nodes. So we check:
+ * 1. The call node itself (rare, but possible for standalone calls)
+ * 2. The parent statement (VariableDeclaration, ExpressionStatement, etc.)
+ *
+ * @param path - Babel NodePath for the CallExpression
+ * @returns GrafemaIgnoreAnnotation if found, null otherwise
+ */
+export function getGrafemaIgnore(path: NodePath): GrafemaIgnoreAnnotation | null {
+  // First check the call node itself
+  const callResult = checkNodeComments(path.node);
+  if (callResult) return callResult;
+
+  // Then check parent statement (where Babel typically attaches comments)
+  const statementPath = path.getStatementParent();
+  if (statementPath) {
+    return checkNodeComments(statementPath.node);
+  }
+
+  return null;
+}