@aster-cloud/aster-lang-ts 0.0.1

package/dist/test/unit/typecheck/effects-and-capabilities.test.js

@@ -0,0 +1,191 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { tmpdir } from 'node:os';
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { canonicalize } from '../../../src/frontend/canonicalizer.js';
+import { lex } from '../../../src/frontend/lexer.js';
+import { parse } from '../../../src/parser.js';
+import { lowerModule } from '../../../src/lower_to_core.js';
+import { typecheckModule, typecheckModuleWithCapabilities } from '../../../src/typecheck.js';
+/**
+ * 编译源代码并返回类型检查诊断
+ */
+function runTypecheck(source) {
+    const canonical = canonicalize(source);
+    const tokens = lex(canonical);
+    const ast = parse(tokens);
+    const core = lowerModule(ast);
+    return typecheckModule(core);
+}
+/**
+ * 为类型检查结果提取诊断代码
+ */
+function codes(diags) {
+    return diags.map(d => d.code);
+}
+describe('效应与能力检查', () => {
+    it('resolveAlias 应该在使用别名的 IO 调用时触发缺失 IO 诊断', () => {
+        const diagnostics = runTypecheck(`
+This module is test.typecheck.alias_missing_io.
+
+Use Http as H.
+
+To fetchUser, produce Text:
+  Return H.get("/user").
+`);
+        assert.equal(diagnostics.some(d => d.code === "E200" /* ErrorCode.EFF_MISSING_IO */), true, '缺失 IO 诊断应该存在');
+    });
+    it('resolveAlias 在声明 IO 效应时不应该产生误报', () => {
+        const diagnostics = runTypecheck(`
+This module is test.typecheck.alias_with_effect.
+
+Use Http as H.
+
+To fetchUser, produce Text. It performs io:
+  Return H.get("/user").
+`);
+        assert.equal(diagnostics.some(d => d.code === "E200" /* ErrorCode.EFF_MISSING_IO */), false, '声明 IO 后不应报告缺失');
+    });
+    it('未使用任何 IO 调用却声明 io 应该触发冗余警告', () => {
+        const diagnostics = runTypecheck(`
+This module is test.typecheck.superfluous_io.
+
+To ping, produce Text. It performs io:
+  Return "pong".
+`);
+        // E203 已移除，现在由 E207 (EFF_INFER_REDUNDANT_IO) 基于效应推断检测
+        assert.equal(diagnostics.some(d => d.code === "E207" /* ErrorCode.EFF_INFER_REDUNDANT_IO */), true, '未使用 IO 时应该提示冗余 io');
+    });
+    it('声明 cpu 但未进行 CPU 工作应该触发冗余警告', () => {
+        const diagnostics = runTypecheck(`
+This module is test.typecheck.superfluous_cpu.
+
+To compute, produce Int. It performs cpu:
+  Return 1.
+`);
+        assert.equal(diagnostics.some(d => d.code === "E204" /* ErrorCode.EFF_SUPERFLUOUS_CPU */), true, '未执行 CPU 工作时应提示冗余 cpu');
+    });
+    it('加载自定义 CPU 前缀时缺失 CPU 应触发错误', () => {
+        const tmpDir = mkdtempSync(join(tmpdir(), 'aster-eff-'));
+        const configPath = join(tmpDir, 'effects.json');
+        const config = {
+            patterns: {
+                io: {
+                    http: ['Http.'],
+                    sql: [],
+                    files: [],
+                    secrets: [],
+                    time: []
+                },
+                cpu: ['CpuWork.'],
+                ai: []
+            }
+        };
+        writeFileSync(configPath, JSON.stringify(config), 'utf8');
+        const moduleSource = `
+This module is test.typecheck.missing_cpu_under_config.
+
+To heavy, produce Int:
+  Return CpuWork.hash(42).
+`;
+        try {
+            const script = `
+import { canonicalize } from '${join(process.cwd(), 'dist/src/frontend/canonicalizer.js').replace(/\\/g, '/')}';
+import { lex } from '${join(process.cwd(), 'dist/src/frontend/lexer.js').replace(/\\/g, '/')}';
+import { parse } from '${join(process.cwd(), 'dist/src/parser.js').replace(/\\/g, '/')}';
+import { lowerModule } from '${join(process.cwd(), 'dist/src/lower_to_core.js').replace(/\\/g, '/')}';
+import { typecheckModule } from '${join(process.cwd(), 'dist/src/typecheck.js').replace(/\\/g, '/')}';
+
+const source = ${JSON.stringify(moduleSource)};
+const canonical = canonicalize(source);
+const tokens = lex(canonical);
+const ast = parse(tokens);
+const core = lowerModule(ast);
+const diags = typecheckModule(core);
+for (const diag of diags) {
+  if (diag.code === '${"E201" /* ErrorCode.EFF_MISSING_CPU */}') {
+    console.log('FOUND');
+    process.exit(0);
+  }
+}
+process.exit(1);
+`;
+            execFileSync(process.execPath, ['--input-type=module', '--eval', script], {
+                env: {
+                    ...process.env,
+                    ASTER_EFFECT_CONFIG: configPath
+                }
+            });
+        }
+        finally {
+            rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+    it('显式能力列表未覆盖使用的调用应触发能力缺失错误', () => {
+        const diagnostics = runTypecheck(`
+This module is test.typecheck.cap_missing.
+
+To bad, produce Text. It performs io [Http]:
+  Return Db.query("select 1").
+`);
+        assert.equal(diagnostics.some(d => d.code === "E301" /* ErrorCode.EFF_CAP_MISSING */), true, '缺少相应能力时应提示错误');
+    });
+    it('显式能力未使用时应产生信息级别提示', () => {
+        const diagnostics = runTypecheck(`
+This module is test.typecheck.cap_superfluous.
+
+To onlyHttp, produce Text. It performs io [Sql]:
+  Return Http.get("/ping").
+`);
+        const superfluous = diagnostics.find(d => d.code === "E302" /* ErrorCode.EFF_CAP_SUPERFLUOUS */);
+        assert.ok(superfluous, '未使用的能力需提示冗余');
+        assert.equal(superfluous.severity, 'info');
+    });
+    it('能力清单禁止调用时应该返回 CAPABILITY_NOT_ALLOWED', () => {
+        const source = `
+This module is test.typecheck.cap_manifest_block.
+
+To callHttp, produce Text. It performs io [Http]:
+  Return Http.get("/ban").
+`;
+        const canonical = canonicalize(source);
+        const tokens = lex(canonical);
+        const ast = parse(tokens);
+        const core = lowerModule(ast);
+        const manifest = {
+            allow: {
+                Http: ['test.typecheck.cap_manifest_block.safe*']
+            }
+        };
+        const diagnostics = typecheckModuleWithCapabilities(core, manifest);
+        assert.equal(diagnostics.some(d => d.code === "E300" /* ErrorCode.CAPABILITY_NOT_ALLOWED */), true, '清单禁止时应返回错误');
+    });
+    it('能力清单允许调用时不应产生禁止诊断', () => {
+        const source = `
+This module is test.typecheck.cap_manifest_allow.
+
+To callHttp, produce Text. It performs io [Http]:
+  Return Http.get("/ok").
+`;
+        const canonical = canonicalize(source);
+        const tokens = lex(canonical);
+        const ast = parse(tokens);
+        const core = lowerModule(ast);
+        const allowPattern = ['test.typecheck.cap_manifest_allow.*'];
+        const manifest = {
+            allow: {
+                Http: allowPattern,
+                Sql: allowPattern,
+                Time: allowPattern,
+                Files: allowPattern,
+                Secrets: allowPattern,
+                AiModel: allowPattern
+            }
+        };
+        const diagnostics = typecheckModuleWithCapabilities(core, manifest);
+        assert.equal(diagnostics.some(d => d.code === "E300" /* ErrorCode.CAPABILITY_NOT_ALLOWED */), false, '允许模式应通过检查');
+    });
+});
+//# sourceMappingURL=effects-and-capabilities.test.js.map

package/dist/test/unit/typecheck/effects-and-capabilities.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effects-and-capabilities.test.js","sourceRoot":"","sources":["../../../../test/unit/typecheck/effects-and-capabilities.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,MAAM,MAAM,oBAAoB,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAC7D,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAC;AACtE,OAAO,EAAE,GAAG,EAAE,MAAM,gCAAgC,CAAC;AACrD,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,+BAA+B,EAAE,MAAM,2BAA2B,CAAC;AAK7F;;GAEG;AACH,SAAS,YAAY,CAAC,MAAc;IAClC,MAAM,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;IACvC,MAAM,MAAM,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC;IAC9B,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1B,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;IAC9B,OAAO,eAAe,CAAC,IAAI,CAAC,CAAC;AAC/B,CAAC;AAED;;GAEG;AACH,SAAS,KAAK,CAAC,KAAqC;IAClD,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAChC,CAAC;AAED,QAAQ,CAAC,SAAS,EAAE,GAAG,EAAE;IACvB,EAAE,CAAC,wCAAwC,EAAE,GAAG,EAAE;QAChD,MAAM,WAAW,GAAG,YAAY,CAAC;;;;;;;CAOpC,CAAC,CAAC;QACC,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,0CAA6B,CAAC,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC;IACjG,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,gCAAgC,EAAE,GAAG,EAAE;QACxC,MAAM,WAAW,GAAG,YAAY,CAAC;;;;;;;CAOpC,CAAC,CAAC;QACC,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,0CAA6B,CAAC,EAAE,KAAK,EAAE,eAAe,CAAC,CAAC;IACnG,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,4BAA4B,EAAE,GAAG,EAAE;QACpC,MAAM,WAAW,GAAG,YAAY,CAAC;;;;;CAKpC,CAAC,CAAC;QACC,sDAAsD;QACtD,MAAM,CAAC,KAAK,CACV,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,kDAAqC,CAAC,EAClE,IAAI,EACJ,mBAAmB,CACpB,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,4BAA4B,EAAE,GAAG,EAAE;QACpC,MAAM,WAAW,GAAG,YAAY,CAAC;;;;;CAKpC,CAAC,CAAC;QACC,MAAM,CAAC,KAAK,CACV,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,+CAAkC,CAAC,EAC/D,IAAI,EACJ,sBAAsB,CACvB,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2BAA2B,EAAE,GAAG,EAAE;QACnC,MAAM,MAAM,GAAG,WAAW,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,YAAY,CAAC,CAAC,CAAC;QACzD,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;QAChD,MAAM,MAAM,GAAG;YACb,QAAQ,EAAE;gBACR,EAAE,EAAE;oBACF,IAAI,EAAE,CAAC,OAAO,CAAC;oBACf,GAAG,EAAE,EAAE;oBACP,KAAK,EAAE,EAAE;oBACT,OAAO,EAAE,EAAE;oBACX,IAAI,EAAE,EAAE;iBACT;gBACD,GAAG,EAAE,CAAC,UAAU,CAAC;gBACjB,EAAE,EAAE,EAAE;aACP;SACF,CAAC;QACF,aAAa,CAAC,UAAU,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC;QAE1D,MAAM,YAAY,GAAG;;;;;CAKxB,CAAC;QAEE,IAAI,CAAC;YACH,MAAM,MAAM,GAAG;gCACW,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,oCAAoC,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;uBACtF,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,4BAA4B,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;yBACnE,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,oBAAoB,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;+BACvD,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,2BAA2B,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;mCAChE,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,uBAAuB,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC;;iBAElF,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC;;;;;;;uBAOtB,sCAAyB;;;;;;CAM/C,CAAC;YACI,YAAY,CACV,OAAO,CAAC,QAAQ,EAChB,CAAC,qBAAqB,EAAE,QAAQ,EAAE,MAAM,CAAC,EACzC;gBACE,GAAG,EAAE;oBACH,GAAG,OAAO,CAAC,GAAG;oBACd,mBAAmB,EAAE,UAAU;iBAChC;aACF,CACF,CAAC;QACJ,CAAC;gBAAS,CAAC;YACT,MAAM,CAAC,MAAM,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACnD,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACjC,MAAM,WAAW,GAAG,YAAY,CAAC;;;;;CAKpC,CAAC,CAAC;QACC,MAAM,CAAC,KAAK,CACV,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,2CAA8B,CAAC,EAC3D,IAAI,EACJ,cAAc,CACf,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mBAAmB,EAAE,GAAG,EAAE;QAC3B,MAAM,WAAW,GAAG,YAAY,CAAC;;;;;CAKpC,CAAC,CAAC;QACC,MAAM,WAAW,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,+CAAkC,CAAC,CAAC;QACpF,MAAM,CAAC,EAAE,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;QACtC,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAC7C,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,sCAAsC,EAAE,GAAG,EAAE;QAC9C,MAAM,MAAM,GAAG;;;;;CAKlB,CAAC;QACE,MAAM,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;QACvC,MAAM,MAAM,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC;QAC9B,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;QAC1B,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;QAC9B,MAAM,QAAQ,GAAuB;YACnC,KAAK,EAAE;gBACL,IAAI,EAAE,CAAC,yCAAyC,CAAC;aAClD;SACF,CAAC;QACF,MAAM,WAAW,GAAG,+BAA+B,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACpE,MAAM,CAAC,KAAK,CACV,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,kDAAqC,CAAC,EAClE,IAAI,EACJ,YAAY,CACb,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mBAAmB,EAAE,GAAG,EAAE;QAC3B,MAAM,MAAM,GAAG;;;;;CAKlB,CAAC;QACE,MAAM,SAAS,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;QACvC,MAAM,MAAM,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC;QAC9B,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC;QAC1B,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;QAC9B,MAAM,YAAY,GAAG,CAAC,qCAAqC,CAAC,CAAC;QAC7D,MAAM,QAAQ,GAAuB;YACnC,KAAK,EAAE;gBACL,IAAI,EAAE,YAAY;gBAClB,GAAG,EAAE,YAAY;gBACjB,IAAI,EAAE,YAAY;gBAClB,KAAK,EAAE,YAAY;gBACnB,OAAO,EAAE,YAAY;gBACrB,OAAO,EAAE,YAAY;aACtB;SACF,CAAC;QACF,MAAM,WAAW,GAAG,+BAA+B,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACpE,MAAM,CAAC,KAAK,CACV,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,kDAAqC,CAAC,EAClE,KAAK,EACL,WAAW,CACZ,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/test/unit/typecheck/regression-fixes.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 回归测试：覆盖 typecheck 模块重构后修复的关键问题
+ *
+ * 本文件测试以下修复点：
+ * 1. 重复符号检测 - defineSymbol 应报告 DUPLICATE_SYMBOL 错误
+ * 2. 补偿效应推断 - workflow 步骤的 compensate 块效应应被合并
+ * 3. 效应参数诊断 - 未声明的效应变量应触发 EFFECT_VAR_UNDECLARED
+ * 4. KNOWN_SCALARS 扩展 - 内置标量与容器类型不应被误判为未声明的类型变量
+ */
+export {};
+//# sourceMappingURL=regression-fixes.test.d.ts.map

package/dist/test/unit/typecheck/regression-fixes.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regression-fixes.test.d.ts","sourceRoot":"","sources":["../../../../test/unit/typecheck/regression-fixes.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/test/unit/typecheck/regression-fixes.test.js

@@ -0,0 +1,456 @@
+/**
+ * 回归测试：覆盖 typecheck 模块重构后修复的关键问题
+ *
+ * 本文件测试以下修复点：
+ * 1. 重复符号检测 - defineSymbol 应报告 DUPLICATE_SYMBOL 错误
+ * 2. 补偿效应推断 - workflow 步骤的 compensate 块效应应被合并
+ * 3. 效应参数诊断 - 未声明的效应变量应触发 EFFECT_VAR_UNDECLARED
+ * 4. KNOWN_SCALARS 扩展 - 内置标量与容器类型不应被误判为未声明的类型变量
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { Core, Effect } from '../../../src/core/core_ir.js';
+import { typecheckModule } from '../../../src/typecheck.js';
+import { SymbolTable } from '../../../src/typecheck/symbol_table.js';
+import { DiagnosticBuilder } from '../../../src/typecheck/diagnostics.js';
+import { defineSymbol } from '../../../src/typecheck/context.js';
+// 辅助函数：创建类型
+const typeName = (name) => Core.TypeName(name);
+const resultType = (ok, err) => Core.Result(ok, err);
+// 辅助函数：创建 Span
+const createSpan = () => ({
+    start: { line: 1, col: 1 },
+    end: { line: 1, col: 10 },
+});
+// 辅助函数：创建基本的 ModuleContext
+function createModuleContext() {
+    return {
+        datas: new Map(),
+        enums: new Map(),
+        imports: new Map(),
+        funcSignatures: new Map(),
+        importedEffects: new Map(),
+        moduleSearchPaths: [],
+    };
+}
+// 辅助函数：创建 TypecheckWalkerContext
+function createWalkerContext() {
+    return {
+        module: createModuleContext(),
+        symbols: new SymbolTable(),
+        diagnostics: new DiagnosticBuilder(),
+    };
+}
+describe('回归测试：重复符号检测', () => {
+    it('defineSymbol 应在同一作用域重复定义时报告 DUPLICATE_SYMBOL 错误', () => {
+        const context = createWalkerContext();
+        const span = createSpan();
+        // 第一次定义应成功
+        defineSymbol(context, 'myVar', typeName('Int'), 'var', span);
+        assert.ok(context.symbols.lookup('myVar'), '第一次定义应成功');
+        assert.strictEqual(context.diagnostics.getDiagnostics().length, 0, '无错误');
+        // 第二次定义同名符号应报告错误
+        defineSymbol(context, 'myVar', typeName('Text'), 'var', span);
+        const diagnostics = context.diagnostics.getDiagnostics();
+        assert.strictEqual(diagnostics.length, 1, '应产生一个诊断');
+        assert.strictEqual(diagnostics[0]?.code, "E102" /* ErrorCode.DUPLICATE_SYMBOL */, '应为 DUPLICATE_SYMBOL 错误');
+        assert.strictEqual(diagnostics[0]?.severity, 'error');
+    });
+    it('不同作用域定义同名符号不应报错（遮蔽场景）', () => {
+        const context = createWalkerContext();
+        const span = createSpan();
+        // 外层定义
+        defineSymbol(context, 'value', typeName('Int'), 'var', span);
+        // 进入新作用域
+        context.symbols.enterScope('function');
+        // 内层定义同名符号（遮蔽，非重复）
+        defineSymbol(context, 'value', typeName('Text'), 'var', span);
+        const diagnostics = context.diagnostics.getDiagnostics();
+        assert.strictEqual(diagnostics.length, 0, '遮蔽不应报错');
+        // 内层符号应为 Text 类型
+        const inner = context.symbols.lookupInCurrentScope('value');
+        assert.ok(inner, '内层符号应存在');
+        assert.strictEqual(inner.type.name, 'Text');
+    });
+    it('通过完整类型检查流程验证重复参数定义', () => {
+        // 构造一个函数有两个同名参数的场景
+        const func = {
+            kind: 'Func',
+            name: 'badFunc',
+            typeParams: [],
+            params: [
+                { name: 'x', type: typeName('Int'), annotations: [] },
+                { name: 'x', type: typeName('Text'), annotations: [] }, // 重复参数名
+            ],
+            effects: [],
+            effectCaps: [],
+            effectCapsExplicit: false,
+            ret: typeName('Int'),
+            body: {
+                kind: 'Block',
+                statements: [
+                    { kind: 'Return', expr: Core.Int(0) },
+                ],
+            },
+        };
+        const mod = {
+            kind: 'Module',
+            name: 'test.regression.duplicate_param',
+            decls: [func],
+        };
+        const diagnostics = typecheckModule(mod);
+        assert.ok(diagnostics.some(d => d.code === "E102" /* ErrorCode.DUPLICATE_SYMBOL */), '重复参数名应触发 DUPLICATE_SYMBOL 错误');
+    });
+});
+describe('回归测试：补偿效应推断', () => {
+    it('workflow 效应应包含 compensate 块的效应', () => {
+        // 创建一个 workflow，其中 step body 是 pure，但 compensate 调用了 io 函数
+        const step = {
+            kind: 'step',
+            name: 'step1',
+            dependencies: [],
+            effectCaps: [],
+            body: {
+                kind: 'Block',
+                statements: [
+                    // 纯计算，无 IO
+                    { kind: 'Return', expr: Core.Ok(Core.Int(42)) },
+                ],
+            },
+            compensate: {
+                kind: 'Block',
+                statements: [
+                    // compensate 调用 IO 函数（使用标准 IO 前缀格式）
+                    Core.Let('_cleanup', Core.Call(Core.Name('IO.cleanup'), [])),
+                    { kind: 'Return', expr: Core.Ok(Core.Null()) },
+                ],
+            },
+        };
+        const workflow = {
+            kind: 'workflow',
+            steps: [step],
+            effectCaps: [],
+        };
+        const func = {
+            kind: 'Func',
+            name: 'workflowWithCompensate',
+            typeParams: [],
+            params: [],
+            effects: [Effect.IO], // 声明 IO 效应
+            effectCaps: [],
+            effectCapsExplicit: false,
+            ret: {
+                kind: 'TypeApp',
+                base: 'Workflow',
+                args: [resultType(typeName('Int'), typeName('Text')), typeName('IO')],
+            },
+            body: {
+                kind: 'Block',
+                statements: [workflow],
+            },
+        };
+        const mod = {
+            kind: 'Module',
+            name: 'test.regression.compensate_effect',
+            decls: [func],
+        };
+        const diagnostics = typecheckModule(mod);
+        // 不应有 EFF_SUPERFLUOUS_IO 警告，因为 compensate 块确实有 IO 效应
+        const superfluousIO = diagnostics.find(d => d.code === "E203" /* ErrorCode.EFF_SUPERFLUOUS_IO */);
+        assert.strictEqual(superfluousIO, undefined, 'compensate 块的 IO 效应应被正确识别，不应报告多余的 @io 声明');
+    });
+    it('compensate 块的 IO 效应应触发 EFF_MISSING_IO（正向断言）', () => {
+        // 正向断言：如果 compensate 有 IO 但函数未声明 IO，应报错
+        // 这证明 compensate 效应确实被合并到函数效应推断中
+        const step = {
+            kind: 'step',
+            name: 'stepWithIOCompensate',
+            dependencies: [],
+            effectCaps: [],
+            body: {
+                kind: 'Block',
+                statements: [
+                    // 纯计算，无 IO
+                    { kind: 'Return', expr: Core.Ok(Core.Int(42)) },
+                ],
+            },
+            compensate: {
+                kind: 'Block',
+                statements: [
+                    // compensate 调用 IO 函数
+                    Core.Let('_cleanup', Core.Call(Core.Name('IO.cleanup'), [])),
+                    { kind: 'Return', expr: Core.Ok(Core.Null()) },
+                ],
+            },
+        };
+        const workflow = {
+            kind: 'workflow',
+            steps: [step],
+            effectCaps: [],
+        };
+        const func = {
+            kind: 'Func',
+            name: 'workflowMissingIODeclaration',
+            typeParams: [],
+            params: [],
+            effects: [], // 故意不声明 IO 效应
+            effectCaps: [],
+            effectCapsExplicit: false,
+            ret: {
+                kind: 'TypeApp',
+                base: 'Workflow',
+                args: [resultType(typeName('Int'), typeName('Text')), typeName('Unit')],
+            },
+            body: {
+                kind: 'Block',
+                statements: [workflow],
+            },
+        };
+        const mod = {
+            kind: 'Module',
+            name: 'test.regression.compensate_effect_positive',
+            decls: [func],
+        };
+        const diagnostics = typecheckModule(mod);
+        // 正向断言：应有 EFF_MISSING_IO 错误，证明 compensate 的 IO 效应被正确检测
+        assert.ok(diagnostics.some(d => d.code === "E200" /* ErrorCode.EFF_MISSING_IO */), 'compensate 块的 IO 效应应被检测，触发 EFF_MISSING_IO 错误（正向证明效应合并生效）');
+    });
+    it('缺少 compensate 的步骤在有副作用时应发出警告', () => {
+        const step = {
+            kind: 'step',
+            name: 'dangerousStep',
+            dependencies: [],
+            effectCaps: [],
+            body: {
+                kind: 'Block',
+                statements: [
+                    // 调用 IO 函数（使用标准 IO 前缀格式）
+                    Core.Let('result', Core.Call(Core.Name('IO.write'), [Core.String('data')])),
+                    { kind: 'Return', expr: Core.Ok(Core.Int(1)) },
+                ],
+            },
+            // 无 compensate 块
+        };
+        const workflow = {
+            kind: 'workflow',
+            steps: [step],
+            effectCaps: [],
+        };
+        const func = {
+            kind: 'Func',
+            name: 'workflowWithoutCompensate',
+            typeParams: [],
+            params: [],
+            effects: [Effect.IO],
+            effectCaps: [],
+            effectCapsExplicit: false,
+            ret: {
+                kind: 'TypeApp',
+                base: 'Workflow',
+                args: [resultType(typeName('Int'), typeName('Text')), typeName('IO')],
+            },
+            body: {
+                kind: 'Block',
+                statements: [workflow],
+            },
+        };
+        const mod = {
+            kind: 'Module',
+            name: 'test.regression.missing_compensate',
+            decls: [func],
+        };
+        const diagnostics = typecheckModule(mod);
+        // 应有 WORKFLOW_COMPENSATE_MISSING 警告
+        assert.ok(diagnostics.some(d => d.code === "E023" /* ErrorCode.WORKFLOW_COMPENSATE_MISSING */), '有 IO 副作用但无 compensate 的步骤应触发警告');
+    });
+});
+describe('回归测试：效应参数诊断', () => {
+    it('未声明的效应变量应触发 EFFECT_VAR_UNDECLARED', () => {
+        // 创建一个使用了未声明效应变量的函数
+        // 通过 declaredEffects 在函数上直接使用一个未声明的效应变量
+        const effectVar = { kind: 'EffectVar', name: 'E' };
+        const func = {
+            kind: 'Func',
+            name: 'funcWithUndeclaredEffect',
+            typeParams: [],
+            effectParams: [], // 空的效应参数列表
+            params: [],
+            effects: [],
+            declaredEffects: [effectVar], // 使用了效应变量 E，但未在 effectParams 中声明
+            effectCaps: [],
+            effectCapsExplicit: false,
+            ret: typeName('Unit'),
+            body: {
+                kind: 'Block',
+                statements: [
+                    { kind: 'Return', expr: Core.Null() },
+                ],
+            },
+        };
+        const mod = {
+            kind: 'Module',
+            name: 'test.regression.undeclared_effect_var',
+            decls: [func],
+        };
+        const diagnostics = typecheckModule(mod);
+        assert.ok(diagnostics.some(d => d.code === "E210" /* ErrorCode.EFFECT_VAR_UNDECLARED */), '使用未声明的效应变量应触发 EFFECT_VAR_UNDECLARED');
+    });
+    it('已声明的效应变量不应报错', () => {
+        // 创建一个正确声明了效应变量的函数
+        const effectVar = { kind: 'EffectVar', name: 'E' };
+        const func = {
+            kind: 'Func',
+            name: 'funcWithDeclaredEffect',
+            typeParams: [],
+            effectParams: ['E'], // 声明效应参数 E
+            params: [],
+            effects: [],
+            declaredEffects: [effectVar], // 函数自身使用 E
+            effectCaps: [],
+            effectCapsExplicit: false,
+            ret: typeName('Unit'),
+            body: {
+                kind: 'Block',
+                statements: [
+                    { kind: 'Return', expr: Core.Null() },
+                ],
+            },
+        };
+        const mod = {
+            kind: 'Module',
+            name: 'test.regression.declared_effect_var',
+            decls: [func],
+        };
+        const diagnostics = typecheckModule(mod);
+        assert.ok(!diagnostics.some(d => d.code === "E210" /* ErrorCode.EFFECT_VAR_UNDECLARED */), '已声明的效应变量不应触发 EFFECT_VAR_UNDECLARED');
+    });
+    it('声明但未使用的效应变量应触发警告', () => {
+        const func = {
+            kind: 'Func',
+            name: 'funcWithUnusedEffect',
+            typeParams: [],
+            effectParams: ['E'], // 声明效应参数 E，但未使用
+            params: [
+                { name: 'x', type: typeName('Int'), annotations: [] },
+            ],
+            effects: [],
+            effectCaps: [],
+            effectCapsExplicit: false,
+            ret: typeName('Int'),
+            body: {
+                kind: 'Block',
+                statements: [
+                    { kind: 'Return', expr: Core.Name('x') },
+                ],
+            },
+        };
+        const mod = {
+            kind: 'Module',
+            name: 'test.regression.unused_effect_var',
+            decls: [func],
+        };
+        const diagnostics = typecheckModule(mod);
+        assert.ok(diagnostics.some(d => d.code === "E005" /* ErrorCode.TYPE_PARAM_UNUSED */), '声明但未使用的效应变量应触发 TYPE_PARAM_UNUSED 警告');
+    });
+});
+describe('回归测试：KNOWN_SCALARS 扩展', () => {
+    it('使用 Long/Double/Unit 类型不应触发 TYPEVAR_LIKE_UNDECLARED', () => {
+        const func = {
+            kind: 'Func',
+            name: 'useBuiltinTypes',
+            typeParams: [],
+            params: [
+                { name: 'a', type: typeName('Long'), annotations: [] },
+                { name: 'b', type: typeName('Double'), annotations: [] },
+            ],
+            effects: [],
+            effectCaps: [],
+            effectCapsExplicit: false,
+            ret: typeName('Unit'),
+            body: {
+                kind: 'Block',
+                statements: [
+                    { kind: 'Return', expr: Core.Null() },
+                ],
+            },
+        };
+        const mod = {
+            kind: 'Module',
+            name: 'test.regression.known_scalars',
+            decls: [func],
+        };
+        const diagnostics = typecheckModule(mod);
+        assert.ok(!diagnostics.some(d => d.code === "E006" /* ErrorCode.TYPEVAR_LIKE_UNDECLARED */), 'Long/Double/Unit 是内置类型，不应被误认为未声明的类型变量');
+    });
+    it('使用 Result/Option/List/Map/Set/Workflow 类型不应触发 TYPEVAR_LIKE_UNDECLARED', () => {
+        // 构造 Map<Text, Int> 类型
+        const mapType = { kind: 'TypeApp', base: 'Map', args: [typeName('Text'), typeName('Int')] };
+        // 构造 Set<Int> 类型
+        const setType = { kind: 'TypeApp', base: 'Set', args: [typeName('Int')] };
+        // 构造 Workflow<Result<Int, Text>, Unit> 类型（第二个参数是效应标记，使用 Unit 避免效应类型检查）
+        const workflowType = {
+            kind: 'TypeApp',
+            base: 'Workflow',
+            args: [resultType(typeName('Int'), typeName('Text')), typeName('Unit')],
+        };
+        const func = {
+            kind: 'Func',
+            name: 'useContainerTypes',
+            typeParams: [],
+            params: [
+                { name: 'r', type: resultType(typeName('Int'), typeName('Text')), annotations: [] },
+                { name: 'o', type: Core.Option(typeName('Int')), annotations: [] },
+                { name: 'l', type: Core.List(typeName('Int')), annotations: [] },
+                { name: 'm', type: mapType, annotations: [] },
+                { name: 's', type: setType, annotations: [] },
+                { name: 'w', type: workflowType, annotations: [] },
+            ],
+            effects: [],
+            effectCaps: [],
+            effectCapsExplicit: false,
+            ret: typeName('Unit'),
+            body: {
+                kind: 'Block',
+                statements: [
+                    { kind: 'Return', expr: Core.Null() },
+                ],
+            },
+        };
+        const mod = {
+            kind: 'Module',
+            name: 'test.regression.container_types',
+            decls: [func],
+        };
+        const diagnostics = typecheckModule(mod);
+        assert.ok(!diagnostics.some(d => d.code === "E006" /* ErrorCode.TYPEVAR_LIKE_UNDECLARED */), 'Result/Option/List/Map/Set/Workflow 容器类型不应被误认为未声明的类型变量');
+    });
+    it('未知类型名应触发 TYPEVAR_LIKE_UNDECLARED（负例验证）', () => {
+        // 使用一个未在 KNOWN_SCALARS 中且未定义的类型名
+        const func = {
+            kind: 'Func',
+            name: 'useUnknownType',
+            typeParams: [],
+            params: [
+                { name: 'x', type: typeName('UnknownCustomType'), annotations: [] },
+            ],
+            effects: [],
+            effectCaps: [],
+            effectCapsExplicit: false,
+            ret: typeName('Unit'),
+            body: {
+                kind: 'Block',
+                statements: [
+                    { kind: 'Return', expr: Core.Null() },
+                ],
+            },
+        };
+        const mod = {
+            kind: 'Module',
+            name: 'test.regression.unknown_type',
+            decls: [func],
+        };
+        const diagnostics = typecheckModule(mod);
+        assert.ok(diagnostics.some(d => d.code === "E006" /* ErrorCode.TYPEVAR_LIKE_UNDECLARED */), '未知类型名 UnknownCustomType 应触发 TYPEVAR_LIKE_UNDECLARED 错误');
+    });
+});
+//# sourceMappingURL=regression-fixes.test.js.map