autosnippet 3.2.7 → 3.2.9

package/lib/core/ast/lang-rust.js

@@ -5,8 +5,12 @@
  * 提取: struct, enum, trait, impl, function, method, mod, use, const/static
  * 模式: Builder, Newtype, Factory (new/from), Error Handling (Result/Option/?),
  *        Async (tokio/async-std), Unsafe block, Derive macro
+ *
+ * Phase 5: 新增 ImportRecord 结构化导入 + extractCallSites 调用点提取
  */
 
+import { ImportRecord } from '../analysis/ImportRecord.js';
+
 function walkRust(root, ctx) {
   for (let i = 0; i < root.namedChildCount; i++) {
     const child = root.namedChild(i);
@@ -83,7 +87,6 @@ function _walkNode(node, ctx) {
 // ── Use Declaration ──────────────────────────────────────────
 
 function _parseUseDecl(node, ctx) {
-  // 提取 use 路径文本
   const argNode = node.namedChildren.find(
     (c) =>
       c.type === 'use_wildcard' ||
@@ -93,8 +96,57 @@ function _parseUseDecl(node, ctx) {
       c.type === 'identifier' ||
       c.type === 'scoped_use_list'
   );
-  if (argNode) {
-    ctx.imports.push(argNode.text);
+  if (!argNode) return;
+
+  const text = argNode.text;
+
+  if (argNode.type === 'use_as_clause') {
+    // use crate::mod::Foo as Bar
+    const pathNode = argNode.namedChildren.find(
+      (c) => c.type === 'scoped_identifier' || c.type === 'identifier'
+    );
+    const aliasNode = argNode.namedChildren.find((c) => c.type === 'identifier' && c !== pathNode);
+    const fullPath = pathNode?.text || text;
+    const segments = fullPath.split('::');
+    const lastName = segments[segments.length - 1];
+    ctx.imports.push(
+      new ImportRecord(fullPath, {
+        symbols: [lastName],
+        alias: aliasNode?.text || lastName,
+        kind: 'named',
+      })
+    );
+  } else if (argNode.type === 'use_wildcard') {
+    // use crate::mod::*
+    const pathPart = text.replace(/::\*$/, '');
+    ctx.imports.push(
+      new ImportRecord(pathPart, { symbols: ['*'], kind: 'namespace' })
+    );
+  } else if (argNode.type === 'use_list' || argNode.type === 'scoped_use_list') {
+    // use crate::mod::{A, B, C}  or  use {A, B}
+    // Extract path prefix and symbol list from text
+    const match = text.match(/^(.+)::\{(.+)\}$/s);
+    if (match) {
+      const prefix = match[1];
+      const symbolsStr = match[2];
+      const symbols = symbolsStr.split(',').map((s) => s.trim().split('::').pop().split(' as ')[0].trim()).filter(Boolean);
+      ctx.imports.push(
+        new ImportRecord(prefix, { symbols, kind: 'named' })
+      );
+    } else {
+      ctx.imports.push(new ImportRecord(text));
+    }
+  } else if (argNode.type === 'scoped_identifier') {
+    // use crate::mod::Struct
+    const segments = text.split('::');
+    const lastName = segments[segments.length - 1];
+    const prefix = segments.slice(0, -1).join('::');
+    ctx.imports.push(
+      new ImportRecord(prefix || text, { symbols: [lastName], alias: lastName, kind: 'named' })
+    );
+  } else {
+    // use identifier (rare: e.g. `use std;`)
+    ctx.imports.push(new ImportRecord(text, { symbols: ['*'], alias: text, kind: 'namespace' }));
   }
 }
 
@@ -698,6 +750,234 @@ function _maxNesting(node, depth) {
   return max;
 }
 
+// ── Rust Call Site 提取 (Phase 5) ────────────────────────────
+
+/**
+ * 从 Rust AST root 提取所有调用点
+ * 遍历 function_item / impl method 中的 block → call_expression / method_call_expression
+ *
+ * @param {TreeSitterNode} root
+ * @param {object} ctx
+ * @param {string} _lang
+ */
+function extractCallSitesRust(root, ctx, _lang) {
+  const scopes = _collectRustScopes(root);
+  for (const scope of scopes) {
+    _extractRustCallSitesFromBody(scope.body, scope.className, scope.methodName, ctx);
+  }
+}
+
+/**
+ * 递归收集 Rust 中所有函数/方法体作用域
+ */
+function _collectRustScopes(root) {
+  const scopes = [];
+
+  function visit(node, className) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+
+      if (child.type === 'impl_item') {
+        // impl Type { ... } or impl Trait for Type { ... }
+        const typeIdNodes = child.namedChildren.filter(
+          (c) => c.type === 'type_identifier' || c.type === 'scoped_type_identifier' || c.type === 'generic_type'
+        );
+        const hasFor = child.children?.some((c) => c.type === 'for');
+        let selfType = null;
+        if (hasFor && typeIdNodes.length >= 2) {
+          selfType = typeIdNodes[1]?.text;
+        } else if (typeIdNodes.length >= 1) {
+          selfType = typeIdNodes[0]?.text;
+        }
+        const body = child.namedChildren.find((c) => c.type === 'declaration_list');
+        if (body) {
+          visit(body, selfType || className);
+        }
+      } else if (child.type === 'function_item') {
+        const name = child.namedChildren.find((c) => c.type === 'identifier')?.text;
+        const body = child.namedChildren.find((c) => c.type === 'block');
+        if (name && body) {
+          scopes.push({ body, className, methodName: name });
+        }
+      } else if (child.type === 'mod_item') {
+        const body = child.namedChildren.find((c) => c.type === 'declaration_list');
+        if (body) {
+          visit(body, null);
+        }
+      }
+    }
+  }
+
+  visit(root, null);
+  return scopes;
+}
+
+/**
+ * 从 Rust block 中递归提取调用点
+ */
+function _extractRustCallSitesFromBody(bodyNode, className, methodName, ctx) {
+  if (!bodyNode) return;
+
+  const RUST_NOISE = new Set([
+    'println', 'eprintln', 'print', 'eprint', 'dbg', 'format',
+    'vec', 'panic', 'assert', 'assert_eq', 'assert_ne', 'debug_assert',
+    'todo', 'unimplemented', 'unreachable', 'cfg',
+    'write', 'writeln', 'log', 'info', 'warn', 'error', 'debug', 'trace',
+  ]);
+
+  function walk(node, isAwaited) {
+    if (!node || node.type === 'ERROR' || node.isMissing) return;
+
+    // await expression: expr.await
+    if (node.type === 'await_expression') {
+      for (let i = 0; i < node.namedChildCount; i++) {
+        walk(node.namedChild(i), true);
+      }
+      return;
+    }
+
+    // call_expression: func(args) or Struct::method(args)
+    if (node.type === 'call_expression') {
+      const func = node.namedChildren[0];
+      if (!func) { walkChildren(node, false); return; }
+
+      let callee, receiver = null, receiverType = null, callType;
+
+      if (func.type === 'scoped_identifier' || func.type === 'scoped_type_identifier') {
+        // Struct::method() or crate::mod::func()
+        const parts = func.text.split('::');
+        if (parts.length >= 2) {
+          callee = parts[parts.length - 1];
+          receiver = parts.slice(0, -1).join('::');
+          // Check if receiver looks like a type (PascalCase)
+          const lastReceiver = parts[parts.length - 2];
+          if (/^[A-Z]/.test(lastReceiver)) {
+            receiverType = lastReceiver;
+            callType = callee === 'new' || callee === 'default' ? 'constructor' : 'static';
+          } else {
+            callType = 'function'; // module-qualified function
+          }
+        } else {
+          callee = func.text;
+          callType = 'function';
+        }
+      } else if (func.type === 'field_expression') {
+        // obj.func() — though Rust usually uses method_call_expression for this
+        const parts = func.text.split('.');
+        if (parts.length >= 2) {
+          receiver = parts.slice(0, -1).join('.');
+          callee = parts[parts.length - 1];
+          callType = 'method';
+          if (receiver === 'self' || receiver === '&self' || receiver === '&mut self') {
+            receiverType = className;
+          }
+        } else {
+          callee = func.text;
+          callType = 'function';
+        }
+      } else if (func.type === 'identifier') {
+        callee = func.text;
+        if (RUST_NOISE.has(callee)) { walkChildren(node, false); return; }
+        // PascalCase → constructor pattern (rare in Rust — turbofish/struct literal more common)
+        callType = /^[A-Z]/.test(callee) ? 'constructor' : 'function';
+        if (callType === 'constructor') receiverType = callee;
+      } else {
+        callee = func.text?.slice(0, 80) || 'unknown';
+        callType = 'function';
+      }
+
+      const args = node.namedChildren.find((c) => c.type === 'arguments');
+      const argCount = args ? args.namedChildCount : 0;
+
+      ctx.callSites.push({
+        callee,
+        callerMethod: methodName,
+        callerClass: className,
+        callType,
+        receiver,
+        receiverType,
+        argCount,
+        line: node.startPosition.row + 1,
+        isAwait: isAwaited,
+      });
+
+      if (args) walkChildren(args, false);
+      return;
+    }
+
+    // method_call_expression: obj.method(args) — Rust-specific
+    if (node.type === 'method_call_expression') {
+      const valueNode = node.namedChildren.find(
+        (c) => c.type !== 'field_identifier' && c.type !== 'arguments' && c.type !== 'type_arguments'
+      );
+      const nameNode = node.namedChildren.find((c) => c.type === 'field_identifier');
+      const args = node.namedChildren.find((c) => c.type === 'arguments');
+
+      const callee = nameNode?.text || 'unknown';
+      const receiver = valueNode?.text?.slice(0, 80) || null;
+      let receiverType = null;
+      let callType = 'method';
+
+      if (receiver === 'self' || receiver === '&self' || receiver === '&mut self') {
+        receiverType = className;
+      } else if (receiver && /^[A-Z]/.test(receiver)) {
+        receiverType = receiver;
+      }
+
+      // Skip noise methods
+      if (RUST_NOISE.has(callee)) { walkChildren(node, false); return; }
+
+      const argCount = args ? args.namedChildCount : 0;
+
+      ctx.callSites.push({
+        callee,
+        callerMethod: methodName,
+        callerClass: className,
+        callType,
+        receiver,
+        receiverType,
+        argCount,
+        line: node.startPosition.row + 1,
+        isAwait: isAwaited,
+      });
+
+      if (args) walkChildren(args, false);
+      return;
+    }
+
+    // macro_invocation: some_macro!(args) — skip noise macros
+    if (node.type === 'macro_invocation') {
+      const macroName = node.namedChildren.find((c) => c.type === 'identifier')?.text;
+      if (macroName && !RUST_NOISE.has(macroName) && !RUST_NOISE.has(macroName.replace(/!$/, ''))) {
+        // Only record non-noise macros as function calls
+        ctx.callSites.push({
+          callee: macroName,
+          callerMethod: methodName,
+          callerClass: className,
+          callType: 'function',
+          receiver: null,
+          receiverType: null,
+          argCount: 0,
+          line: node.startPosition.row + 1,
+          isAwait: false,
+        });
+      }
+      // Don't recurse into macro bodies
+      return;
+    }
+
+    walkChildren(node, false);
+  }
+
+  function walkChildren(node, isAwaited) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      walk(node.namedChild(i), isAwaited);
+    }
+  }
+
+  walk(bodyNode, false);
+}
+
 // ── Plugin Export ────────────────────────────────────────────
 
 let _grammar = null;
@@ -712,5 +992,6 @@ export const plugin = {
   getGrammar,
   walk: walkRust,
   detectPatterns: detectRustPatterns,
+  extractCallSites: extractCallSitesRust,
   extensions: ['.rs'],
 };

package/lib/core/ast/lang-swift.js

@@ -1,8 +1,12 @@
 /**
  * @module lang-swift
  * @description Swift AST Walker 插件 — 从 AstAnalyzer.js 迁移
+ *
+ * Phase 5: 新增 ImportRecord 结构化导入 + extractCallSites 调用点提取
  */
 
+import { ImportRecord } from '../analysis/ImportRecord.js';
+
 // ── Swift AST 遍历 ──
 
 function walkSwift(root, ctx) {
@@ -19,7 +23,9 @@ function _walkSwiftNode(node, ctx, parentClassName) {
           (c) => c.type === 'identifier' || c.type === 'simple_identifier'
         );
         if (mod) {
-          ctx.imports.push(mod.text);
+          ctx.imports.push(
+            new ImportRecord(mod.text, { symbols: ['*'], alias: mod.text, kind: 'namespace' })
+          );
         }
         break;
       }
@@ -315,6 +321,178 @@ function _maxNesting(node, depth) {
   return max;
 }
 
+// ── Swift Call Site 提取 (Phase 5) ───────────────────────────
+
+/**
+ * 从 Swift AST root 提取所有调用点
+ * 遍历 function_declaration 中的 function_body → call_expression
+ *
+ * @param {TreeSitterNode} root
+ * @param {object} ctx
+ * @param {string} _lang
+ */
+function extractCallSitesSwift(root, ctx, _lang) {
+  const scopes = _collectSwiftScopes(root);
+  for (const scope of scopes) {
+    _extractSwiftCallSitesFromBody(scope.body, scope.className, scope.methodName, ctx);
+  }
+}
+
+/**
+ * 递归收集 Swift 中所有函数体作用域
+ */
+function _collectSwiftScopes(root) {
+  const scopes = [];
+
+  function visit(node, className) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+
+      if (child.type === 'class_declaration' || child.type === 'struct_declaration' || child.type === 'enum_declaration') {
+        const name = child.namedChildren.find(
+          (c) => c.type === 'type_identifier' || c.type === 'simple_identifier'
+        )?.text;
+        const body = child.namedChildren.find(
+          (c) => c.type === 'class_body' || c.type === 'struct_body' || c.type === 'enum_body'
+        );
+        if (body) {
+          visit(body, name || className);
+        }
+      } else if (child.type === 'extension_declaration') {
+        const extName = child.namedChildren.find(
+          (c) => c.type === 'user_type' || c.type === 'type_identifier'
+        )?.text;
+        const body = child.namedChildren.find((c) => c.type === 'extension_body');
+        if (body) {
+          visit(body, extName || className);
+        }
+      } else if (child.type === 'function_declaration') {
+        const name = child.namedChildren.find((c) => c.type === 'simple_identifier')?.text || 'unknown';
+        const body = child.namedChildren.find((c) => c.type === 'function_body');
+        if (body) {
+          scopes.push({ body, className, methodName: name });
+        }
+      } else if (child.type === 'property_declaration') {
+        // computed property with getter
+        const computed = child.namedChildren.find(
+          (c) => c.type === 'computed_property' || c.type === 'willSet_didSet_block'
+        );
+        if (computed) {
+          const propName = child.namedChildren.find(
+            (c) => c.type === 'simple_identifier' || c.type === 'pattern'
+          )?.text;
+          scopes.push({ body: computed, className, methodName: `get_${propName || 'prop'}` });
+        }
+      }
+    }
+  }
+
+  visit(root, null);
+  return scopes;
+}
+
+/**
+ * 从 Swift function body 中递归提取调用点
+ */
+function _extractSwiftCallSitesFromBody(bodyNode, className, methodName, ctx) {
+  if (!bodyNode) return;
+
+  const SWIFT_NOISE = new Set([
+    'print', 'debugPrint', 'dump', 'fatalError', 'precondition', 'preconditionFailure',
+    'assert', 'assertionFailure', 'NSLog',
+    'min', 'max', 'abs', 'stride', 'zip', 'type',
+  ]);
+
+  function walk(node) {
+    if (!node || node.type === 'ERROR' || node.isMissing) return;
+
+    // call_expression in Swift tree-sitter
+    if (node.type === 'call_expression') {
+      const func = node.namedChildren[0];
+      if (!func) { walkChildren(node); return; }
+
+      let callee, receiver = null, receiverType = null, callType;
+      let isAwait = false;
+
+      // Check if parent is await
+      if (node.parent?.type === 'await_expression') {
+        isAwait = true;
+      }
+
+      if (func.type === 'navigation_expression' || func.type === 'member_access') {
+        // obj.method() or Type.staticMethod()
+        const parts = func.text.split('.');
+        if (parts.length >= 2) {
+          receiver = parts.slice(0, -1).join('.');
+          callee = parts[parts.length - 1];
+          if (receiver === 'self') {
+            receiverType = className;
+            callType = 'method';
+          } else if (receiver === 'super') {
+            receiverType = className;
+            callType = 'super';
+          } else if (/^[A-Z]/.test(receiver)) {
+            receiverType = receiver;
+            callType = 'static';
+          } else {
+            callType = 'method';
+          }
+        } else {
+          callee = func.text;
+          callType = 'function';
+        }
+      } else if (func.type === 'simple_identifier' || func.type === 'identifier') {
+        callee = func.text;
+        if (SWIFT_NOISE.has(callee)) { walkChildren(node); return; }
+        // PascalCase → constructor (Swift initializer)
+        callType = /^[A-Z]/.test(callee) ? 'constructor' : 'function';
+        if (callType === 'constructor') receiverType = callee;
+      } else {
+        callee = func.text?.slice(0, 80) || 'unknown';
+        callType = 'function';
+      }
+
+      // Count arguments
+      const callSuffix = node.namedChildren.find(
+        (c) => c.type === 'call_suffix' || c.type === 'value_arguments'
+      );
+      const argCount = callSuffix ? callSuffix.namedChildCount : 0;
+
+      ctx.callSites.push({
+        callee,
+        callerMethod: methodName,
+        callerClass: className,
+        callType,
+        receiver,
+        receiverType,
+        argCount,
+        line: node.startPosition.row + 1,
+        isAwait,
+      });
+
+      // walk arguments for nested calls
+      if (callSuffix) walkChildren(callSuffix);
+      return;
+    }
+
+    // try expression → walk into children
+    if (node.type === 'try_expression' || node.type === 'await_expression') {
+      walkChildren(node);
+      return;
+    }
+
+    walkChildren(node);
+  }
+
+  function walkChildren(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      walk(node.namedChild(i));
+    }
+  }
+
+  walk(bodyNode);
+}
+
 // ── 插件导出 ──
 
 let _grammar = null;
@@ -329,5 +507,6 @@ export const plugin = {
   getGrammar,
   walk: walkSwift,
   detectPatterns: detectSwiftPatterns,
+  extractCallSites: extractCallSitesSwift,
   extensions: ['.swift'],
 };