fix function overloads

Author: weaming

.claude/settings.local.json

@@ -5,7 +5,9 @@
       "Bash(npm run test:lexer:*)",
       "Bash(npm run test:parser:*)",
       "Bash(npm run build:*)",
-      "Bash(npm run:*)"
+      "Bash(npm run:*)",
+      "Bash(npm test)",
+      "WebSearch"
     ],
     "deny": [],
     "ask": []

CHANGELOG.md

@@ -1,5 +1,11 @@
 # 更新日志
 
+## [0.1.4] - 2025-10-21
+
+### 改进
+
+- 修复一些函数的多签名支持
+
 ## [0.1.3] - 2025-10-15
 
 ### 新增
@@ -40,4 +46,4 @@
 - `pine.showDocs` - 显示符号文档
 
 ### 配置
-- `pine.applyFileAssociation` - 自动关联 .pine 文件类型
+- `pine.applyFileAssociation` - 自动关联 .pine 文件类型

package.json

@@ -7,7 +7,7 @@
     "name": "Garden Yuen",
     "url": "https://github.com/weaming"
   },
-  "version": "0.1.3",
+  "version": "0.1.4",
   "icon": "icon.png",
   "repository": {
     "type": "git",

src/parser/astValidator.ts

@@ -1,8 +1,8 @@
 // AST-based Pine Script Validator with Type Checking and Scope Analysis
 import { Program, Statement, Expression, CallExpression, CallArgument, Identifier, Literal } from './ast';
 import { V6_FUNCTIONS, V6_NAMESPACES, PineItem } from '../../v6/v6-manual';
-import { PINE_FUNCTIONS_MERGED } from '../../v6/parameter-requirements-merged';
-import type { FunctionSignatureSpec, FunctionParameter } from '../../v6/parameter-requirements-generated';
+import { PINE_FUNCTIONS_MERGED } from '../../v6/functions';
+import type { FunctionSignatureSpec, FunctionParameter, FunctionOverload } from '../../v6/functions';
 import { PineType, TypeChecker } from './typeSystem';
 import { SymbolTable, Symbol as SymbolInfo } from './symbolTable';
 
@@ -877,6 +877,20 @@ export class AstValidator {
       }
     }
 
+    // Check if function has overloads
+    const spec = PINE_FUNCTIONS_MERGED[functionName];
+    if (spec && spec.overloads && spec.overloads.length > 0) {
+      // Try to match against all overloads
+      const result = this.tryMatchOverloads(call, functionName, spec.overloads, providedArgs, positionalArgs);
+      if (!result.matched) {
+        // Report errors from the best matching overload
+        for (const error of result.errors) {
+          this.addError(error.line, error.column, error.length, error.message, error.severity);
+        }
+      }
+      return;
+    }
+
     // Check argument count
     const totalCount = signature.parameters.length;
 
@@ -978,6 +992,122 @@ export class AstValidator {
     this.validateSpecialCases(call, functionName, args);
   }
 
+  /**
+   * 尝试匹配所有函数重载
+   * 返回第一个匹配的重载，或所有重载都不匹配时返回最佳匹配的错误信息
+   */
+  private tryMatchOverloads(
+    call: CallExpression,
+    functionName: string,
+    overloads: FunctionOverload[],
+    providedArgs: Map<string, { arg: CallArgument; type: PineType }>,
+    positionalArgs: { arg: CallArgument; type: PineType }[]
+  ): { matched: boolean; errors: Array<{ line: number; column: number; length: number; message: string; severity: DiagnosticSeverity }> } {
+
+    interface OverloadMatchResult {
+      overload: FunctionOverload;
+      errors: Array<{ line: number; column: number; length: number; message: string; severity: DiagnosticSeverity }>;
+      score: number; // 匹配分数，越低越好
+    }
+
+    const results: OverloadMatchResult[] = [];
+
+    // 尝试每个重载
+    for (const overload of overloads) {
+      const errors: Array<{ line: number; column: number; length: number; message: string; severity: DiagnosticSeverity }> = [];
+      let score = 0;
+
+      // 构建参数列表
+      const allParams = [
+        ...overload.requiredParams.map(name => ({ name, optional: false })),
+        ...overload.optionalParams.map(name => ({ name, optional: true }))
+      ];
+
+      // 检查参数数量
+      const providedCount = positionalArgs.length + providedArgs.size;
+      const requiredCount = overload.requiredParams.length;
+      const maxCount = allParams.length;
+
+      if (positionalArgs.length > maxCount) {
+        errors.push({
+          line: call.line,
+          column: call.column,
+          length: functionName.length,
+          message: `Too many arguments for '${functionName}'. Expected ${maxCount}, got ${positionalArgs.length}`,
+          severity: DiagnosticSeverity.Error
+        });
+        score += 100; // 严重错误
+      }
+
+      // 检查每个参数
+      for (let i = 0; i < allParams.length; i++) {
+        const param = allParams[i];
+
+        // 检查命名参数
+        const namedArg = providedArgs.get(param.name);
+        if (namedArg) {
+          continue; // 命名参数提供了
+        }
+
+        // 检查位置参数
+        if (i < positionalArgs.length) {
+          continue; // 位置参数提供了
+        }
+
+        // 参数未提供
+        if (!param.optional) {
+          errors.push({
+            line: call.line,
+            column: call.column,
+            length: functionName.length,
+            message: `Missing required parameter '${param.name}' for function '${functionName}'`,
+            severity: DiagnosticSeverity.Error
+          });
+          score += 10; // 缺少必需参数
+        }
+      }
+
+      // 检查无效的命名参数
+      for (const [name] of providedArgs.entries()) {
+        if (!allParams.some(p => p.name === name)) {
+          errors.push({
+            line: call.line,
+            column: call.column,
+            length: name.length,
+            message: `Invalid parameter '${name}' for this overload`,
+            severity: DiagnosticSeverity.Error
+          });
+          score += 5; // 无效参数
+        }
+      }
+
+      results.push({ overload, errors, score });
+
+      // 如果找到完美匹配，立即返回
+      if (errors.length === 0) {
+        return { matched: true, errors: [] };
+      }
+    }
+
+    // 没有完美匹配，返回最佳匹配的错误
+    results.sort((a, b) => a.score - b.score);
+    const bestMatch = results[0];
+
+    // 如果有多个重载，在错误消息中提示所有可能的签名
+    if (overloads.length > 1 && bestMatch.errors.length > 0) {
+      const signatures = overloads.map(o => o.signature).join('\n  ');
+      bestMatch.errors.push({
+        line: call.line,
+        column: call.column,
+        length: functionName.length,
+        message: `Available overloads:\n  ${signatures}`,
+        severity: DiagnosticSeverity.Information
+      });
+    }
+
+    return { matched: false, errors: bestMatch.errors };
+  }
+
   private validateSpecialCases(
     call: CallExpression,
     functionName: string,

src/parser/patternValidator.ts

@@ -5,7 +5,7 @@
  */
 
 import * as vscode from 'vscode';
-import { PINE_FUNCTIONS_MERGED as ALL_FUNCTION_SIGNATURES } from '../../v6/parameter-requirements-merged';
+import { PINE_FUNCTIONS_MERGED as ALL_FUNCTION_SIGNATURES } from '../../v6/functions';
 import { isValidNamespaceMember, CONSTANT_NAMESPACES } from '../../v6/pine-constants-complete';
 import {
   VARIABLE_NAMESPACES,

v6/check-parameter-conflicts.js

@@ -0,0 +1,89 @@
+/**
+ * 检查 parameter-requirements.ts (MANUAL) 和 parameter-requirements-generated.ts (GENERATED) 之间的冲突
+ *
+ * 这个脚本帮助发现手动定义与自动生成定义之间的差异，确保参数定义的一致性。
+ *
+ * 用法: node v6/check-parameter-conflicts.js
+ */
+
+const GENERATED = require('../dist/v6/parameter-requirements-generated.js').PINE_FUNCTIONS;
+const MANUAL = require('../dist/v6/parameter-requirements.js').ALL_FUNCTION_SIGNATURES;
+
+console.log('🔍 检查手动定义与自动生成定义之间的冲突...\n');
+
+let conflictCount = 0;
+const conflicts = [];
+
+// 检查所有手动定义的函数
+for (const [funcName, manualSpec] of Object.entries(MANUAL)) {
+  const generatedSpec = GENERATED[funcName];
+
+  if (!generatedSpec) {
+    console.log(`ℹ️  ${funcName}: 仅存在于手动定义中（自动生成中不存在）`);
+    continue;
+  }
+
+  // 比较必需参数
+  const manualRequired = new Set(manualSpec.requiredParams);
+  const generatedRequired = new Set(generatedSpec.requiredParams);
+
+  const manualOptional = new Set(manualSpec.optionalParams);
+  const generatedOptional = new Set(generatedSpec.optionalParams);
+
+  let hasConflict = false;
+  const issues = [];
+
+  // 检查参数分类是否一致
+  for (const param of manualRequired) {
+    if (generatedOptional.has(param)) {
+      hasConflict = true;
+      issues.push(`  ❌ 参数 '${param}': MANUAL定义为必需，GENERATED定义为可选`);
+    } else if (!generatedRequired.has(param)) {
+      hasConflict = true;
+      issues.push(`  ⚠️  参数 '${param}': MANUAL定义为必需，GENERATED中不存在`);
+    }
+  }
+
+  for (const param of manualOptional) {
+    if (generatedRequired.has(param)) {
+      hasConflict = true;
+      issues.push(`  ❌ 参数 '${param}': MANUAL定义为可选，GENERATED定义为必需`);
+    }
+  }
+
+  if (hasConflict) {
+    conflictCount++;
+    console.log(`\n🔴 ${funcName}:`);
+    console.log(`  MANUAL:    requiredParams: [${Array.from(manualRequired).join(', ')}]`);
+    console.log(`             optionalParams: [${Array.from(manualOptional).join(', ')}]`);
+    console.log(`  GENERATED: requiredParams: [${Array.from(generatedRequired).join(', ')}]`);
+    console.log(`             optionalParams: [${Array.from(generatedOptional).join(', ')}]`);
+    issues.forEach(issue => console.log(issue));
+
+    conflicts.push({
+      function: funcName,
+      manual: {
+        required: Array.from(manualRequired),
+        optional: Array.from(manualOptional)
+      },
+      generated: {
+        required: Array.from(generatedRequired),
+        optional: Array.from(generatedOptional)
+      }
+    });
+  }
+}
+
+console.log('\n' + '='.repeat(80));
+if (conflictCount === 0) {
+  console.log('✅ 没有发现冲突！所有手动定义与自动生成定义一致。');
+} else {
+  console.log(`⚠️  发现 ${conflictCount} 个冲突函数`);
+  console.log('\n建议：');
+  console.log('1. 检查 TradingView 官方文档确认正确的参数定义');
+  console.log('2. 更新 v6/parameter-requirements.ts 中的手动定义');
+  console.log('3. 重新编译并运行测试');
+}
+console.log('='.repeat(80) + '\n');
+
+process.exit(conflictCount > 0 ? 1 : 0);