autosnippet 3.2.6 → 3.2.8

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

@@ -6,10 +6,14 @@
  * 模式: Flutter Widget (Stateless/Stateful/Consumer), Factory, Singleton,
  *        Builder, BLoC/Cubit, Provider/Riverpod, Freezed
  *
+ * Phase 5: 新增 ImportRecord 结构化导入 + extractCallSites 调用点提取
+ *
  * 注意: tree-sitter-dart 目前尚无兼容 tree-sitter ≥0.25 的稳定版。
  *       已迁移至 web-tree-sitter (WASM)，无原生编译依赖。
  */
 
+import { ImportRecord } from '../analysis/ImportRecord.js';
+
 function walkDart(root, ctx) {
   _walkNode(root, ctx, null);
 }
@@ -22,11 +26,30 @@ function _walkNode(node, ctx, parentClassName) {
       case 'import_or_export': // tree-sitter-dart import 节点
       case 'import_specification':
       case 'library_import': {
-        const uri = child.namedChildren.find(
-          (c) => c.type === 'uri' || c.type === 'string_literal' || c.type === 'configurable_uri'
-        );
-        if (uri) {
-          ctx.imports.push(uri.text.replace(/['"]/g, ''));
+        // tree-sitter-dart AST 嵌套: import_or_export > library_import > import_specification
+        // URI 节点埋在深层，直接从文本中用正则提取更可靠
+        const text = child.text;
+        const pathMatch = text.match(/import\s+(['"])(.+?)\1/);
+        if (pathMatch) {
+          const importPath = pathMatch[2];
+          // Dart: import 'pkg' as alias
+          const asMatch = text.match(/\bas\s+(\w+)/);
+          const alias = asMatch ? asMatch[1] : null;
+          // Dart: import 'pkg' show A, B
+          const showClause = text.match(/\bshow\s+([\w\s,]+)/);
+          // Dart: import 'pkg' hide A, B  (暂不使用，记录备查)
+          // const hideClause = text.match(/\bhide\s+([\w\s,]+)/);
+
+          let symbols = ['*'];
+          let kind = 'namespace';
+          if (showClause) {
+            symbols = showClause[1].split(',').map((s) => s.trim()).filter(Boolean);
+            kind = 'named';
+          }
+
+          ctx.imports.push(
+            new ImportRecord(importPath, { symbols, alias, kind })
+          );
         }
         break;
       }
@@ -645,6 +668,329 @@ function _maxNesting(node, depth) {
   return max;
 }
 
+// ── Dart Call Site 提取 (Phase 5) ────────────────────────────
+
+/**
+ * 从 Dart AST root 提取所有调用点
+ * 遍历 function_definition / method 中的 body → 各种 invocation 节点
+ *
+ * @param {TreeSitterNode} root
+ * @param {object} ctx
+ * @param {string} _lang
+ */
+function extractCallSitesDart(root, ctx, _lang) {
+  const scopes = _collectDartScopes(root);
+  for (const scope of scopes) {
+    _extractDartCallSitesFromBody(scope.body, scope.className, scope.methodName, ctx);
+  }
+}
+
+/**
+ * 递归收集 Dart 中所有函数/方法体作用域
+ */
+function _collectDartScopes(root) {
+  const scopes = [];
+
+  function visit(node, className) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+
+      if (child.type === 'class_definition') {
+        const name = child.namedChildren.find(
+          (c) => c.type === 'identifier' || c.type === 'type_identifier'
+        )?.text;
+        const body = child.namedChildren.find((c) => c.type === 'class_body');
+        if (body) {
+          visit(body, name || className);
+        }
+      } else if (child.type === 'mixin_declaration') {
+        const name = child.namedChildren.find(
+          (c) => c.type === 'identifier' || c.type === 'type_identifier'
+        )?.text;
+        const body = child.namedChildren.find((c) => c.type === 'class_body');
+        if (body) {
+          visit(body, name || className);
+        }
+      } else if (child.type === 'extension_declaration') {
+        const name = child.namedChildren.find(
+          (c) => c.type === 'identifier' || c.type === 'type_identifier'
+        )?.text;
+        const body = child.namedChildren.find(
+          (c) => c.type === 'class_body' || c.type === 'extension_body'
+        );
+        if (body) {
+          visit(body, name || className);
+        }
+      } else if (
+        child.type === 'function_definition' ||
+        child.type === 'method_signature' ||
+        child.type === 'function_signature'
+      ) {
+        // 提取方法/函数名
+        let name;
+        if (child.type === 'method_signature' || child.type === 'function_signature') {
+          // method_signature 可能包含嵌套 function_signature
+          const funcSig = child.namedChildren.find((c) => c.type === 'function_signature') || child;
+          name = funcSig.namedChildren.find(
+            (c) => c.type === 'identifier' || c.type === 'function_name'
+          )?.text;
+        } else {
+          name = child.namedChildren.find(
+            (c) => c.type === 'identifier' || c.type === 'function_name'
+          )?.text;
+        }
+
+        // tree-sitter-dart: function_body 可能是子节点或下一个兄弟节点
+        let body = child.namedChildren.find(
+          (c) => c.type === 'function_body' || c.type === 'block'
+        );
+        // 如果 body 不在子节点中，检查下一个兄弟节点 (tree-sitter-dart 的 sibling 结构)
+        if (!body && i + 1 < node.namedChildCount) {
+          const nextSibling = node.namedChild(i + 1);
+          if (nextSibling?.type === 'function_body' || nextSibling?.type === 'block') {
+            body = nextSibling;
+            i++; // 跳过已消费的 body 节点
+          }
+        }
+        if (name && body) {
+          scopes.push({ body, className, methodName: name });
+        }
+      } else if (child.type === 'getter_signature' || child.type === 'setter_signature') {
+        const name = child.namedChildren.find((c) => c.type === 'identifier')?.text;
+        let body = child.namedChildren.find(
+          (c) => c.type === 'function_body' || c.type === 'block'
+        );
+        if (!body && i + 1 < node.namedChildCount) {
+          const nextSibling = node.namedChild(i + 1);
+          if (nextSibling?.type === 'function_body' || nextSibling?.type === 'block') {
+            body = nextSibling;
+            i++;
+          }
+        }
+        if (name && body) {
+          scopes.push({ body, className, methodName: `get_${name}` });
+        }
+      }
+    }
+  }
+
+  visit(root, null);
+  return scopes;
+}
+
+/**
+ * 从 Dart function body 中递归提取调用点
+ *
+ * tree-sitter-dart 的调用表达式由 **兄弟节点序列** 构成（而非单个 call_expression 节点）：
+ *   Pattern A:  identifier + selector("(args)")                → 直接调用: func(args)
+ *   Pattern B:  (identifier|this|super) + selector(".method")  → 方法调用: obj.method(args)
+ *               + selector("(args)")
+ * 因此需要 sibling-aware scanning，避免逐个 walk 子节点时丢失上下文。
+ */
+function _extractDartCallSitesFromBody(bodyNode, className, methodName, ctx) {
+  if (!bodyNode) return;
+
+  const DART_NOISE = new Set([
+    'print', 'debugPrint', 'log',
+    'setState', 'notifyListeners',
+    'List', 'Map', 'Set', 'Future', 'Stream',
+  ]);
+
+  /** 在 selectorNode 的子树中查找 arguments / argument_part */
+  function findArgs(selectorNode) {
+    return selectorNode.namedChildren.find(
+      (c) => c.type === 'arguments' || c.type === 'argument_part',
+    );
+  }
+
+  /**
+   * 尝试从 parent.namedChild(idx) 开始消费一条调用链。
+   * 成功 → 返回消费到的最后一个子节点索引；失败 → 返回 null。
+   */
+  function tryConsumeCall(parent, idx, startNode, isAwaited) {
+    const sib1 = parent.namedChild(idx + 1);
+    if (!sib1) return null;
+
+    // ── Pattern A: identifier + selector("(args)") → 直接调用 ────────
+    if (
+      (startNode.type === 'identifier' || startNode.type === 'type_identifier') &&
+      sib1.type === 'selector' &&
+      /^\s*\(/.test(sib1.text)
+    ) {
+      const callee = startNode.text;
+      if (!DART_NOISE.has(callee)) {
+        const callType = /^[A-Z]/.test(callee) ? 'constructor' : 'function';
+        const args = findArgs(sib1);
+        ctx.callSites.push({
+          callee,
+          callerMethod: methodName,
+          callerClass: className,
+          callType,
+          receiver: null,
+          receiverType: callType === 'constructor' ? callee : null,
+          argCount: args ? args.namedChildCount : 0,
+          line: startNode.startPosition.row + 1,
+          isAwait: isAwaited,
+        });
+      }
+      // 递归扫描 selector 内部（处理嵌套调用，如 MyApp() 内的参数调用）
+      scanChildren(sib1, false);
+      return idx + 1;
+    }
+
+    // ── Pattern B: receiver + methodSelector + argsSelector → 方法调用 ──
+    const sib2 = parent.namedChild(idx + 2);
+    const isMethodSel =
+      sib1.type === 'selector' || sib1.type === 'unconditional_assignable_selector';
+    const isArgsSel = sib2?.type === 'selector' && sib2.text.includes('(');
+
+    if (isMethodSel && isArgsSel) {
+      const methodMatch = sib1.text.match(/\.(\w+)/);
+      if (methodMatch) {
+        const callee = methodMatch[1];
+        const receiverText = startNode.text;
+        let receiver = receiverText;
+        let receiverType = null;
+        let callType;
+
+        if (startNode.type === 'this' || receiver === 'this' || receiver === 'self') {
+          receiverType = className;
+          callType = 'method';
+        } else if (startNode.type === 'super' || receiver === 'super') {
+          receiverType = className;
+          callType = 'super';
+        } else if (/^[A-Z]/.test(receiver)) {
+          receiverType = receiver;
+          callType = 'static';
+        } else {
+          callType = 'method';
+        }
+
+        if (!DART_NOISE.has(callee)) {
+          const args = findArgs(sib2);
+          ctx.callSites.push({
+            callee,
+            callerMethod: methodName,
+            callerClass: className,
+            callType,
+            receiver,
+            receiverType,
+            argCount: args ? args.namedChildCount : 0,
+            line: startNode.startPosition.row + 1,
+            isAwait: isAwaited,
+          });
+        }
+        // 递归扫描 argsSelector 内部
+        scanChildren(sib2, false);
+        return idx + 2;
+      }
+    }
+
+    return null; // 未匹配任何模式
+  }
+
+  /**
+   * 以 sibling-aware 方式扫描 node 的 namedChildren。
+   * 当发现调用起始节点(identifier / this / super)时，尝试消费完整调用链并跳过已消费兄弟。
+   */
+  function scanChildren(node, isAwaited) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      const child = node.namedChild(i);
+
+      // await → 标记子树为 awaited
+      if (child.type === 'await_expression') {
+        scanChildren(child, true);
+        continue;
+      }
+
+      // function_expression_invocation / method_invocation (部分 grammar 变体)
+      if (child.type === 'function_expression_invocation' || child.type === 'method_invocation') {
+        _processDartCall(child, className, methodName, ctx, isAwaited, DART_NOISE);
+        const args = child.namedChildren.find(
+          (c) => c.type === 'arguments' || c.type === 'argument_part',
+        );
+        if (args) scanChildren(args, false);
+        continue;
+      }
+
+      // 尝试从当前位置消费调用模式
+      const isCallStarter =
+        child.type === 'identifier' ||
+        child.type === 'type_identifier' ||
+        child.type === 'this' ||
+        child.type === 'super';
+
+      if (isCallStarter) {
+        const consumed = tryConsumeCall(node, i, child, isAwaited);
+        if (consumed !== null) {
+          i = consumed; // 跳过已消费的兄弟
+          continue;
+        }
+      }
+
+      // Dart cascade: obj..method1()..method2()
+      if (child.type === 'cascade_section') {
+        _processDartCall(child, className, methodName, ctx, isAwaited, DART_NOISE);
+        scanChildren(child, false);
+        continue;
+      }
+
+      // 未匹配 → 递归进入子节点
+      scanChildren(child, isAwaited);
+    }
+  }
+
+  scanChildren(bodyNode, false);
+}
+
+/**
+ * 处理 Dart 函数/方法调用节点
+ */
+function _processDartCall(node, className, methodName, ctx, isAwaited, DART_NOISE) {
+  const text = node.text || '';
+  const callMatch = text.match(/^(?:(\w[\w.]*?)\.)?(\w+)\s*\(/);
+  if (!callMatch) return;
+
+  const receiverText = callMatch[1] || null;
+  const callee = callMatch[2];
+
+  if (DART_NOISE.has(callee)) return;
+
+  let receiver = receiverText;
+  let receiverType = null;
+  let callType;
+
+  if (receiver === 'this' || receiver === 'super') {
+    receiverType = className;
+    callType = receiver === 'super' ? 'super' : 'method';
+  } else if (receiver && /^[A-Z]/.test(receiver)) {
+    receiverType = receiver;
+    callType = 'static';
+  } else if (receiver) {
+    callType = 'method';
+  } else {
+    callType = /^[A-Z]/.test(callee) ? 'constructor' : 'function';
+    if (callType === 'constructor') receiverType = callee;
+  }
+
+  const args = node.namedChildren.find(
+    (c) => c.type === 'arguments' || c.type === 'argument_part'
+  );
+  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,
+  });
+}
+
 // ── Plugin Export ────────────────────────────────────────────
 
 let _grammar = null;
@@ -659,5 +1005,6 @@ export const plugin = {
   getGrammar,
   walk: walkDart,
   detectPatterns: detectDartPatterns,
+  extractCallSites: extractCallSitesDart,
   extensions: ['.dart'],
 };

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

@@ -5,8 +5,12 @@
  * 提取: struct, interface, method (with receiver), function, field, import
  * 模式: Singleton (sync.Once), Factory (New*), Constructor (New*),
  *        Goroutine, Channel, Middleware (http.Handler chain)
+ *
+ * Phase 5: 新增 ImportRecord 结构化导入 + extractCallSites 调用点提取
  */
 
+import { ImportRecord } from '../analysis/ImportRecord.js';
+
 function walkGo(root, ctx) {
   for (let i = 0; i < root.namedChildCount; i++) {
     const child = root.namedChild(i);
@@ -27,22 +31,16 @@ function walkGo(root, ctx) {
           for (let j = 0; j < specList.namedChildCount; j++) {
             const spec = specList.namedChild(j);
             if (spec.type === 'import_spec') {
-              const strLit = spec.namedChildren.find(
-                (c) => c.type === 'interpreted_string_literal'
-              );
-              if (strLit) {
-                ctx.imports.push(strLit.text.replace(/"/g, ''));
-              }
+              const rec = _parseGoImportSpec(spec);
+              if (rec) ctx.imports.push(rec);
             }
           }
         } else {
           // 单行 import
           const spec = child.namedChildren.find((c) => c.type === 'import_spec');
           if (spec) {
-            const strLit = spec.namedChildren.find((c) => c.type === 'interpreted_string_literal');
-            if (strLit) {
-              ctx.imports.push(strLit.text.replace(/"/g, ''));
-            }
+            const rec = _parseGoImportSpec(spec);
+            if (rec) ctx.imports.push(rec);
           }
         }
         break;
@@ -494,6 +492,209 @@ function _maxNesting(node, depth) {
   return max;
 }
 
+// ── Go Import 解析 ──────────────────────────────────────────
+
+/**
+ * 解析 Go import_spec 节点为 ImportRecord
+ *
+ * Go import 语法:
+ *   import "fmt"                     → namespace, alias='fmt'
+ *   import alias "pkg/path"          → namespace, alias=alias
+ *   import . "pkg/path"              → named (dot import, 类似全部导入)
+ *   import _ "pkg/path"              → side-effect
+ *
+ * @param {TreeSitterNode} spec — import_spec 节点
+ * @returns {ImportRecord|null}
+ */
+function _parseGoImportSpec(spec) {
+  const strLit = spec.namedChildren.find(
+    (c) => c.type === 'interpreted_string_literal'
+  );
+  if (!strLit) return null;
+
+  const importPath = strLit.text.replace(/"/g, '');
+  const aliasNode = spec.namedChildren.find(
+    (c) => c.type === 'package_identifier' || c.type === 'dot' || c.type === 'blank_identifier'
+      || (c.type === 'identifier' && (c.text === '.' || c.text === '_'))
+  );
+
+  if (aliasNode) {
+    if (aliasNode.text === '.' || aliasNode.type === 'dot') {
+      // dot import: import . "pkg" → all exports available
+      return new ImportRecord(importPath, { symbols: ['*'], kind: 'named' });
+    }
+    if (aliasNode.text === '_' || aliasNode.type === 'blank_identifier') {
+      // blank import: side-effect only
+      return new ImportRecord(importPath, { symbols: [], kind: 'side-effect' });
+    }
+    // explicit alias: import alias "pkg/path"
+    return new ImportRecord(importPath, {
+      symbols: ['*'],
+      alias: aliasNode.text,
+      kind: 'namespace',
+    });
+  }
+
+  // default: import "pkg/path" → alias is last segment of path
+  const parts = importPath.split('/');
+  const defaultAlias = parts[parts.length - 1];
+  return new ImportRecord(importPath, {
+    symbols: ['*'],
+    alias: defaultAlias,
+    kind: 'namespace',
+  });
+}
+
+// ── Go Call Site 提取 (Phase 5) ─────────────────────────────
+
+/**
+ * 从 Go AST root 提取所有调用点
+ * 遍历 function_declaration / method_declaration 中的 block → call_expression
+ *
+ * @param {TreeSitterNode} root
+ * @param {object} ctx
+ * @param {string} _lang
+ */
+function extractCallSitesGo(root, ctx, _lang) {
+  const scopes = _collectGoScopes(root);
+  for (const scope of scopes) {
+    _extractGoCallSitesFromBody(scope.body, scope.className, scope.methodName, ctx);
+  }
+}
+
+/**
+ * 收集 Go 中所有函数/方法作用域
+ */
+function _collectGoScopes(root) {
+  const scopes = [];
+  for (let i = 0; i < root.namedChildCount; i++) {
+    const child = root.namedChild(i);
+
+    if (child.type === 'function_declaration') {
+      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: null, methodName: name });
+      }
+    } else if (child.type === 'method_declaration') {
+      const name = child.namedChildren.find((c) => c.type === 'field_identifier')?.text;
+      const body = child.namedChildren.find((c) => c.type === 'block');
+      // 提取 receiver type
+      const paramLists = child.namedChildren.filter((c) => c.type === 'parameter_list');
+      let receiverType = null;
+      if (paramLists[0]) {
+        const paramDecl = paramLists[0].namedChildren.find((c) => c.type === 'parameter_declaration');
+        if (paramDecl) {
+          const pointer = paramDecl.namedChildren.find((c) => c.type === 'pointer_type');
+          if (pointer) {
+            receiverType = pointer.namedChildren.find((c) => c.type === 'type_identifier')?.text;
+          } else {
+            receiverType = paramDecl.namedChildren.find((c) => c.type === 'type_identifier')?.text;
+          }
+        }
+      }
+      if (name && body) {
+        scopes.push({ body, className: receiverType, methodName: name });
+      }
+    }
+  }
+  return scopes;
+}
+
+/**
+ * 从 Go block 中递归提取调用点
+ */
+function _extractGoCallSitesFromBody(bodyNode, className, methodName, ctx) {
+  if (!bodyNode) return;
+
+  const GO_NOISE = new Set([
+    'fmt', 'log', 'errors', 'strings', 'strconv', 'math', 'sort',
+    'time', 'sync', 'context', 'reflect', 'unsafe', 'os', 'io',
+    'bytes', 'bufio', 'regexp', 'path', 'filepath', 'encoding',
+  ]);
+
+  function walk(node) {
+    if (!node || node.type === 'ERROR' || node.isMissing) return;
+
+    if (node.type === 'call_expression') {
+      const func = node.namedChildren[0];
+      if (!func) { walkChildren(node); return; }
+
+      let callee, receiver = null, receiverType = null, callType;
+
+      if (func.type === 'selector_expression') {
+        // pkg.Func() or obj.Method()
+        const parts = func.text.split('.');
+        if (parts.length >= 2) {
+          receiver = parts.slice(0, -1).join('.');
+          callee = parts[parts.length - 1];
+          callType = 'method';
+          // Go: uppercase receiver might be package name → static
+          if (receiver && /^[a-z]/.test(receiver) && !GO_NOISE.has(receiver)) {
+            receiverType = null; // instance method
+          } else if (GO_NOISE.has(receiver)) {
+            walkChildren(node); return; // skip noise
+          } else {
+            receiverType = receiver;
+            callType = 'static';
+          }
+        } else {
+          callee = func.text;
+          callType = 'function';
+        }
+      } else if (func.type === 'identifier') {
+        callee = func.text;
+        // Go: uppercase = exported, New* = constructor pattern
+        if (/^New[A-Z]/.test(callee)) {
+          callType = 'constructor';
+          receiverType = callee.slice(3); // NewUserService → UserService
+        } else {
+          callType = 'function';
+        }
+      } else {
+        callee = func.text?.slice(0, 80) || 'unknown';
+        callType = 'function';
+      }
+
+      // 计算参数数量
+      const args = node.namedChildren.find((c) => c.type === 'argument_list');
+      const argCount = args ? args.namedChildCount : 0;
+
+      ctx.callSites.push({
+        callee,
+        callerMethod: methodName,
+        callerClass: className,
+        callType,
+        receiver,
+        receiverType,
+        argCount,
+        line: node.startPosition.row + 1,
+        isAwait: false, // Go 不使用 await
+      });
+
+      // 遍历参数中的嵌套调用
+      if (args) { walkChildren(args); }
+      return;
+    }
+
+    // go goroutine: go func() — 异步调用
+    if (node.type === 'go_statement') {
+      walkChildren(node);
+      return;
+    }
+
+    walkChildren(node);
+  }
+
+  function walkChildren(node) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+      walk(node.namedChild(i));
+    }
+  }
+
+  walk(bodyNode);
+}
+
 // ── Plugin Export ────────────────────────────────────────────
 
 let _grammar = null;
@@ -508,5 +709,6 @@ export const plugin = {
   getGrammar,
   walk: walkGo,
   detectPatterns: detectGoPatterns,
+  extractCallSites: extractCallSitesGo,
   extensions: ['.go'],
 };