@aster-cloud/aster-lang-ts 1.0.37 → 1.1.0

package/dist/test/unit/core/resolve-typed-references.test.js

@@ -0,0 +1,600 @@
+/**
+ * @module test/unit/core/resolve-typed-references.test
+ *
+ * R2 类型驱动解析（ADR 0051 §4 三态表、§6.2 期望枚举跨层裁决）。
+ * 除特别注明外均为 解析器 → R1 → lower → R2 端到端。
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { canonicalize } from '../../../src/frontend/canonicalizer.js';
+import { lex } from '../../../src/frontend/lexer.js';
+import { parseWithLexicon } from '../../../src/parser.js';
+import { EN_US } from '../../../src/config/lexicons/en-US.js';
+import { DE_DE } from '../../../src/config/lexicons/de-DE.js';
+import { buildVocabularyScopes } from '../../../src/config/lexicons/identifiers/scopes.js';
+import { IdentifierKind } from '../../../src/config/lexicons/identifiers/types.js';
+import { resolveDeclarations } from '../../../src/frontend/resolve-declarations.js';
+import { NO_IMPORTS } from '../../../src/frontend/resolution-context.js';
+import { lowerModule } from '../../../src/lower_to_core.js';
+import { resolveTypedReferences } from '../../../src/core/resolve-typed-references.js';
+import { resolutionMarkOf } from '../../../src/core/resolution-mark.js';
+function parse(source, lexicon = DE_DE) {
+    const tokens = lex(canonicalize(source, lexicon), lexicon);
+    const result = parseWithLexicon(tokens, lexicon);
+    const errors = result.diagnostics.filter((d) => d.severity === 'error');
+    assert.equal(errors.length, 0, JSON.stringify(errors));
+    return result.ast;
+}
+const struct = (canonical, localized) => ({
+    canonical, localized, kind: IdentifierKind.STRUCT,
+});
+const field = (parent, canonical, localized) => ({
+    canonical, localized, kind: IdentifierKind.FIELD, parent,
+});
+const member = (parent, canonical, localized) => ({
+    canonical, localized, kind: IdentifierKind.ENUM_VALUE, parent,
+});
+const fn = (canonical, localized) => ({
+    canonical, localized, kind: IdentifierKind.FUNCTION,
+});
+function ctxOf(mappings) {
+    const vocab = {
+        id: 't', name: 't', locale: 'de-DE', version: '1',
+        structs: mappings.filter((m) => m.kind === IdentifierKind.STRUCT),
+        fields: mappings.filter((m) => m.kind === IdentifierKind.FIELD),
+        functions: mappings.filter((m) => m.kind === IdentifierKind.FUNCTION),
+        enumValues: mappings.filter((m) => m.kind === IdentifierKind.ENUM_VALUE),
+    };
+    return { scopes: buildVocabularyScopes(vocab), imports: NO_IMPORTS };
+}
+/** 解析器 → R1 → lower → R2；edit 用于改写解析器无法直接产出的 AST 形状。 */
+function run(source, mappings, lexicon = DE_DE, edit = (m) => m) {
+    const ctx = ctxOf(mappings);
+    const r1 = resolveDeclarations(edit(parse(source, lexicon)), ctx);
+    const r2 = resolveTypedReferences(lowerModule(r1.module), ctx);
+    return { module: r2.module, r1: r1.diagnostics, r2: r2.diagnostics };
+}
+const codes = (ds) => ds.map((d) => d.code);
+function func(m, name) {
+    const f = m.decls.find((d) => d.kind === 'Func' && d.name === name);
+    assert.ok(f, `函数 ${name} 不存在`);
+    return f;
+}
+function stmt(f, i, kind) {
+    const s = f.body.statements[i];
+    assert.ok(s && s.kind === kind, `body[${i}] 应为 ${kind}，实为 ${s?.kind}`);
+    return s;
+}
+function returned(f, i) {
+    return stmt(f, i, 'Return').expr;
+}
+function nameOf(e) {
+    assert.equal(e.kind, 'Name');
+    return e;
+}
+const MODULE = 'Modul m.\n\n';
+const DRIVER_DECL = 'Definiere Fahrer hat alter als Ganzzahl.\n\n';
+const LEVEL_DECL = 'Definiere Stufe als eines von Hoch, Niedrig.\n\n';
+const DRIVER = [struct('Driver', 'Fahrer'), field('Driver', 'age', 'alter')];
+const LEVEL = [struct('Level', 'Stufe'), member('Level', 'High', 'Hoch'), member('Level', 'Low', 'Niedrig')];
+describe('resolveTypedReferences（R2）', () => {
+    describe('FIELD_REF：点分后续段与 Set 目标', () => {
+        it('x 为 Fahrer 参数：x.alter → x.age，origin 记原写法与角色', () => {
+            const { module, r1, r2 } = run(MODULE + DRIVER_DECL + 'Regel f gegeben x als Fahrer, liefert Ganzzahl:\n  gib zurueck x.alter.\n', DRIVER);
+            assert.deepEqual([...codes(r1), ...codes(r2)], []);
+            const n = nameOf(returned(func(module, 'f'), 0));
+            assert.equal(n.name, 'x.age');
+            assert.equal(n.origin?.written, 'x.alter');
+            assert.equal(n.origin?.role, 'FIELD_REF');
+        });
+        it('多段路径按每段的声明类型解析', () => {
+            const { module, r2 } = run(MODULE +
+                'Definiere Halter hat fahrer als Fahrer.\n\n' + DRIVER_DECL +
+                'Regel f gegeben h als Halter, liefert Ganzzahl:\n  gib zurueck h.fahrer.alter.\n', [...DRIVER, struct('Owner', 'Halter'), field('Owner', 'driver', 'fahrer')]);
+            assert.deepEqual(codes(r2), []);
+            assert.equal(nameOf(returned(func(module, 'f'), 0)).name, 'h.driver.age');
+        });
+        it('Set x.alter → x.age（解析器只接受单段 Set 目标，AST 中改写为点分名）', () => {
+            const toDotted = (m) => ({
+                ...m,
+                decls: m.decls.map((d) => d.kind === 'Func' && d.body
+                    ? {
+                        ...d,
+                        body: {
+                            ...d.body,
+                            statements: d.body.statements.map((s) => (s.kind === 'Set' ? { ...s, name: 'x.alter' } : s)),
+                        },
+                    }
+                    : d),
+            });
+            const { module, r2 } = run(MODULE + DRIVER_DECL + 'Regel f gegeben x als Fahrer, liefert Ganzzahl:\n  setze x auf 5.\n  gib zurueck 1.\n', DRIVER, DE_DE, toDotted);
+            assert.deepEqual(codes(r2), []);
+            const set = stmt(func(module, 'f'), 0, 'Set');
+            assert.equal(set.name, 'x.age');
+            assert.equal(set.origin?.written, 'x.alter');
+            assert.equal(set.origin?.role, 'FIELD_REF');
+        });
+        it('类型已知但字段不存在 → E801', () => {
+            const { r2 } = run(MODULE + DRIVER_DECL + 'Regel f gegeben x als Fahrer, liefert Ganzzahl:\n  gib zurueck x.gewicht.\n', DRIVER);
+            assert.deepEqual(codes(r2), ["E801" /* ErrorCode.UNRESOLVED_FIELD */]);
+        });
+        it('首段不是局部名（限定调用的命名空间）→ 原样保留，不报错', () => {
+            const { module, r2 } = run('Module m.\n\nRule f given t as Text, produce Int:\n  Return Text.length(t).\n', [], EN_US);
+            assert.deepEqual(codes(r2), []);
+            const call = returned(func(module, 'f'), 0);
+            assert.equal(nameOf(call.target).name, 'Text.length');
+        });
+    });
+    describe('Let 无注解右侧：只用显式声明类型', () => {
+        const lets = [
+            ['字面量', '1'],
+            ['ListLiteral', '[x]'],
+            ['Some', 'einige von x'],
+            ['IfExpr', 'wenn wahr dann x sonst x'],
+        ];
+        for (const [label, rhs] of lets) {
+            it(`右侧为${label} → 类型未知，全局唯一候选采用 + W801`, () => {
+                const { module, r2 } = run(MODULE + DRIVER_DECL +
+                    `Regel f gegeben x als Fahrer, liefert Ganzzahl:\n  sei y gleich ${rhs}.\n  gib zurueck y.alter.\n`, DRIVER);
+                assert.deepEqual(codes(r2), ["W801" /* ErrorCode.RESOLVED_WITHOUT_TYPE */]);
+                assert.equal(r2[0].severity, 'warning');
+                assert.equal(nameOf(returned(func(module, 'f'), 1)).name, 'y.age');
+            });
+        }
+        it('右侧为构造 X with … → 类型为 X，无 W801', () => {
+            const { module, r2 } = run(MODULE + DRIVER_DECL +
+                'Regel f gegeben x als Ganzzahl, liefert Ganzzahl:\n  sei y gleich Fahrer mit alter setze auf x.\n  gib zurueck y.alter.\n', DRIVER);
+            assert.deepEqual(codes(r2), []);
+            assert.equal(nameOf(returned(func(module, 'f'), 1)).name, 'y.age');
+        });
+        it('右侧为对源码函数的直接调用 → 声明返回类型，无 W801', () => {
+            const { module, r2 } = run(MODULE + DRIVER_DECL +
+                'Regel neu gegeben x als Ganzzahl, liefert Fahrer:\n  gib zurueck Fahrer mit alter setze auf x.\n\n' +
+                'Regel f gegeben x als Ganzzahl, liefert Ganzzahl:\n  sei y gleich neu(x).\n  gib zurueck y.alter.\n', DRIVER);
+            assert.deepEqual(codes(r2), []);
+            assert.equal(nameOf(returned(func(module, 'f'), 1)).name, 'y.age');
+        });
+        it('类型未知且多个结构体各有 alter → E805', () => {
+            const { r2 } = run(MODULE + DRIVER_DECL + 'Definiere Halter hat alter als Ganzzahl.\n\n' +
+                'Regel f gegeben x als Ganzzahl, liefert Ganzzahl:\n  sei y gleich 1.\n  gib zurueck y.alter.\n', [...DRIVER, struct('Owner', 'Halter'), field('Owner', 'years', 'alter')]);
+            assert.deepEqual(codes(r2), ["E805" /* ErrorCode.AMBIGUOUS_FIELD */]);
+        });
+        it('类型未知且零候选 → E801', () => {
+            const { r2 } = run(MODULE + DRIVER_DECL +
+                'Regel f gegeben x als Ganzzahl, liefert Ganzzahl:\n  sei y gleich 1.\n  gib zurueck y.gewicht.\n', DRIVER);
+            assert.deepEqual(codes(r2), ["E801" /* ErrorCode.UNRESOLVED_FIELD */]);
+        });
+    });
+    describe('期望类型为枚举时的裸单段名', () => {
+        it('Return Hoch（返回类型 Stufe）→ High（裸名保持裸形态，R18）', () => {
+            const { module, r1, r2 } = run(MODULE + LEVEL_DECL + 'Regel f gegeben x als Ganzzahl, liefert Stufe:\n  gib zurueck Hoch.\n', LEVEL);
+            assert.deepEqual([...codes(r1), ...codes(r2)], []);
+            const n = nameOf(returned(func(module, 'f'), 0));
+            assert.equal(n.name, 'High');
+            assert.equal(n.origin?.written, 'Hoch');
+            assert.equal(n.origin?.role, 'MEMBER_REF');
+        });
+        it('R18：本地化源码与规范名拼写的同一程序产出相同 Core（去 origin 比较）；限定写法保持限定', () => {
+            const strip = (m) => JSON.stringify(m, (k, v) => (k === 'origin' ? undefined : v));
+            const de = run(MODULE + LEVEL_DECL + 'Regel f gegeben x als Stufe, liefert Stufe:\n  gib zurueck Hoch.\n\n' +
+                'Regel g gegeben x als Stufe, liefert Stufe:\n  gib zurueck Stufe.Niedrig.\n', LEVEL);
+            const en = run('Module m.\n\nDefine Level as one of High, Low.\n\n' +
+                'Rule f given x as Level, produce Level:\n  Return High.\n\n' +
+                'Rule g given x as Level, produce Level:\n  Return Level.Low.\n', [], EN_US);
+            assert.deepEqual([...codes(de.r1), ...codes(de.r2), ...codes(en.r1), ...codes(en.r2)], []);
+            assert.equal(strip(de.module), strip(en.module));
+            assert.equal(nameOf(returned(func(de.module, 'g'), 0)).name, 'Level.Low');
+        });
+        it('规则 hoch 同时存在 → E804（不静默择一）', () => {
+            const { r2 } = run(MODULE + LEVEL_DECL +
+                'Regel hoch gegeben x als Ganzzahl, liefert Ganzzahl:\n  gib zurueck x.\n\n' +
+                'Regel f gegeben x als Ganzzahl, liefert Stufe:\n  gib zurueck Hoch.\n', LEVEL);
+            assert.deepEqual(codes(r2), ["E804" /* ErrorCode.AMBIGUOUS_NAME */]);
+            assert.match(r2[0].message, /Level\.High|High/);
+        });
+        it('词汇函数同写法 → E804', () => {
+            const { r2 } = run(MODULE + LEVEL_DECL + 'Regel f gegeben x als Ganzzahl, liefert Stufe:\n  gib zurueck Hoch.\n', [...LEVEL, fn('raise', 'hoch')]);
+            assert.deepEqual(codes(r2), ["E804" /* ErrorCode.AMBIGUOUS_NAME */]);
+        });
+        it('局部名命中 → 取局部名并报 W800', () => {
+            const { module, r2 } = run(MODULE + LEVEL_DECL + 'Regel f gegeben hoch als Stufe, liefert Stufe:\n  gib zurueck Hoch.\n', LEVEL);
+            assert.deepEqual(codes(r2), ["W800" /* ErrorCode.SHADOWED_VOCABULARY */]);
+            assert.equal(nameOf(returned(func(module, 'f'), 0)).name, 'hoch');
+        });
+        it('调用实参按被调函数参数类型解析', () => {
+            const { module, r2 } = run(MODULE + LEVEL_DECL +
+                'Regel g gegeben s als Stufe, liefert Stufe:\n  gib zurueck s.\n\n' +
+                'Regel f gegeben x als Ganzzahl, liefert Stufe:\n  gib zurueck g(Niedrig).\n', LEVEL);
+            assert.deepEqual(codes(r2), []);
+            const call = returned(func(module, 'f'), 0);
+            assert.equal(nameOf(call.args[0]).name, 'Low');
+        });
+        it('ConstructField 按字段声明类型解析', () => {
+            const { module, r2 } = run(MODULE + LEVEL_DECL + 'Definiere Fahrer hat stufe als Stufe.\n\n' +
+                'Regel f gegeben x als Ganzzahl, liefert Fahrer:\n  gib zurueck Fahrer mit stufe setze auf Hoch.\n', [...LEVEL, struct('Driver', 'Fahrer'), field('Driver', 'level', 'stufe')]);
+            assert.deepEqual(codes(r2), []);
+            const c = returned(func(module, 'f'), 0);
+            assert.equal(c.typeName, 'Driver');
+            assert.equal(c.fields[0].name, 'level');
+            assert.equal(nameOf(c.fields[0].expr).name, 'High');
+        });
+        describe('相等比较：一侧为已知枚举时另一侧裸名以其为期望类型（裁决 R49）', () => {
+            const CMP_DECLS = MODULE + LEVEL_DECL + 'Definiere Fahrer hat stufe als Stufe.\n\n';
+            const CMP_VOCAB = [...LEVEL, struct('Driver', 'Fahrer'), field('Driver', 'level', 'stufe')];
+            const ifCond = (m) => stmt(func(m, 'f'), 0, 'If').cond;
+            it('wenn d.stufe entspricht Hoch → Hoch 解析为 High（与规范名孪生 d.level equals to High 一致）', () => {
+                const { module, r1, r2 } = run(CMP_DECLS + 'Regel f gegeben d als Fahrer, liefert Ganzzahl:\n  wenn d.stufe entspricht Hoch:\n    gib zurueck 1.\n  gib zurueck 0.\n', CMP_VOCAB);
+                assert.deepEqual([...codes(r1), ...codes(r2)], []);
+                const cond = ifCond(module);
+                assert.equal(nameOf(cond.target).name, '==');
+                assert.equal(nameOf(cond.args[0]).name, 'd.level');
+                const member = nameOf(cond.args[1]);
+                assert.equal(member.name, 'High');
+                assert.equal(member.origin?.written, 'Hoch');
+                assert.equal(member.origin?.role, 'MEMBER_REF');
+            });
+            it('枚举一侧在右、裸名在左同样解析；局部名参数为枚举类型时亦然', () => {
+                const { module, r1, r2 } = run(CMP_DECLS + 'Regel f gegeben s als Stufe, liefert Ganzzahl:\n  wenn Niedrig entspricht s:\n    gib zurueck 1.\n  gib zurueck 0.\n', CMP_VOCAB);
+                assert.deepEqual([...codes(r1), ...codes(r2)], []);
+                const cond = ifCond(module);
+                assert.equal(nameOf(cond.args[0]).name, 'Low');
+                assert.equal(nameOf(cond.args[1]).name, 's');
+            });
+            it('不等比较（not equal to）同样提供期望类型', () => {
+                const { module, r1, r2 } = run('Module m.\n\nDefine Level as one of High, Low.\n\n' +
+                    'Rule f given s as Level, produce Int:\n  If s not equal to Low:\n    Return 1.\n  Return 0.\n', [], EN_US);
+                assert.deepEqual([...codes(r1), ...codes(r2)], []);
+                const cond = ifCond(module);
+                assert.equal(nameOf(cond.target).name, '!=');
+                assert.equal(nameOf(cond.args[1]).name, 'Low');
+            });
+            it('词汇函数 hoch 同时存在 → E804（不静默解析为函数 high），候选不重复且帮助提示 Stufe.Hoch', () => {
+                const { r2 } = run(CMP_DECLS + 'Regel f gegeben d als Fahrer, liefert Ganzzahl:\n  wenn d.stufe entspricht Hoch:\n    gib zurueck 1.\n  gib zurueck 0.\n', [...CMP_VOCAB, fn('high', 'hoch')]);
+                // error 级诊断使调用方不发出 IR，因此 R1 的函数命中不会静默进入产物
+                assert.deepEqual(codes(r2), ["E804" /* ErrorCode.AMBIGUOUS_NAME */]);
+                assert.match(r2[0].message, /High \(Hoch\)/);
+                assert.match(r2[0].help ?? '', /Stufe\.Hoch/);
+            });
+            it('源码规则 hoch 与词汇函数 hoch→high 同时命中 → E804 候选去重', () => {
+                const { r2 } = run(CMP_DECLS +
+                    'Regel hoch gegeben x als Ganzzahl, liefert Ganzzahl:\n  gib zurueck x.\n\n' +
+                    'Regel f gegeben s als Stufe, liefert Ganzzahl:\n  wenn s entspricht Hoch:\n    gib zurueck 1.\n  gib zurueck 0.\n', [...CMP_VOCAB, fn('high', 'hoch')]);
+                assert.deepEqual(codes(r2), ["E804" /* ErrorCode.AMBIGUOUS_NAME */]);
+                const candidates = r2[0].message.split(': ').at(-1).split(', ');
+                assert.deepEqual(candidates, [...new Set(candidates)], r2[0].message);
+            });
+            it('另一侧类型不是枚举 → 无期望类型，裸成员名仍报 E802（角色 VALUE_REF）', () => {
+                const { r2 } = run(CMP_DECLS + 'Regel f gegeben x als Ganzzahl, liefert Ganzzahl:\n  wenn x entspricht Hoch:\n    gib zurueck 1.\n  gib zurueck 0.\n', CMP_VOCAB);
+                assert.deepEqual(codes(r2), ["E802" /* ErrorCode.UNRESOLVED_NAME */]);
+                assert.match(r2[0].message, /VALUE_REF/);
+                assert.match(r2[0].help ?? '', /Stufe\.Hoch/);
+            });
+        });
+        it('无期望类型的裸成员名不按枚举解析 → E802', () => {
+            const { r2 } = run(MODULE + LEVEL_DECL +
+                'Regel f gegeben x als Ganzzahl, liefert Ganzzahl:\n  sei y gleich Hoch.\n  gib zurueck x.\n', LEVEL);
+            assert.deepEqual(codes(r2), ["E802" /* ErrorCode.UNRESOLVED_NAME */]);
+        });
+        it('无期望类型的未知裸名 → E802；运算符与 R1 已解析的名字不报', () => {
+            const { r2 } = run(MODULE + 'Regel f gegeben x als Ganzzahl, liefert Ganzzahl:\n  gib zurueck x plus unbekannt.\n', []);
+            assert.deepEqual(codes(r2), ["E802" /* ErrorCode.UNRESOLVED_NAME */]);
+            assert.match(r2[0].message, /unbekannt/);
+        });
+    });
+    describe('模式匹配', () => {
+        it('主语为参数：bei Hoch（PatternName）按主语枚举解析为成员', () => {
+            const { module, r2 } = run(MODULE + LEVEL_DECL +
+                'Regel f gegeben s als Stufe, liefert Ganzzahl:\n  pruefe s:\n    bei Hoch, gib zurueck 1.\n    bei andere, gib zurueck 2.\n', LEVEL);
+            assert.deepEqual(codes(r2), []);
+            const cases = stmt(func(module, 'f'), 0, 'Match').cases;
+            const first = cases[0].pattern;
+            assert.equal(first.name, 'High');
+            assert.equal(first.origin?.written, 'Hoch');
+            assert.equal(first.origin?.role, 'MEMBER_REF');
+            assert.equal(cases[1].pattern.name, 'andere');
+        });
+        it('主语为构造得到的 Let：bei Fahrer(a) 按主语类型解析', () => {
+            const { module, r2 } = run(MODULE + DRIVER_DECL +
+                'Regel f gegeben x als Ganzzahl, liefert Ganzzahl:\n  sei d gleich Fahrer mit alter setze auf x.\n' +
+                '  pruefe d:\n    bei Fahrer(a), gib zurueck a.\n', DRIVER);
+            assert.deepEqual(codes(r2), []);
+            const pat = stmt(func(module, 'f'), 1, 'Match').cases[0].pattern;
+            assert.equal(pat.typeName, 'Driver');
+            assert.deepEqual(pat.names, ['a']);
+        });
+        it('主语未知、全部枚举成员与构造器中唯一 → 采用 + W801', () => {
+            const { module, r2 } = run(MODULE + LEVEL_DECL +
+                'Regel f gegeben x als Ganzzahl, liefert Ganzzahl:\n  sei s gleich 1.\n' +
+                '  pruefe s:\n    bei Hoch(), gib zurueck 1.\n    bei Niedrig, gib zurueck 2.\n', LEVEL);
+            assert.deepEqual(codes(r2), ["W801" /* ErrorCode.RESOLVED_WITHOUT_TYPE */, "W801" /* ErrorCode.RESOLVED_WITHOUT_TYPE */]);
+            const cases = stmt(func(module, 'f'), 1, 'Match').cases;
+            assert.equal(cases[0].pattern.typeName, 'High');
+            assert.equal(cases[1].pattern.name, 'Low');
+        });
+        it('主语未知、多个候选 → E806', () => {
+            const { r2 } = run(MODULE + LEVEL_DECL + 'Definiere Rang als eines von Hoch, Mittel.\n\n' +
+                'Regel f gegeben x als Ganzzahl, liefert Ganzzahl:\n  sei s gleich 1.\n' +
+                '  pruefe s:\n    bei Hoch(), gib zurueck 1.\n    bei Hoch, gib zurueck 2.\n', [...LEVEL, struct('Priority', 'Rang'), member('Priority', 'Top', 'Hoch'), member('Priority', 'Mid', 'Mittel')]);
+            assert.deepEqual(codes(r2), ["E806" /* ErrorCode.AMBIGUOUS_PATTERN */, "E806" /* ErrorCode.AMBIGUOUS_PATTERN */]);
+        });
+        it('主语未知、零候选 → 构造器 E803；小写模式名仍为绑定', () => {
+            const { module, r2 } = run(MODULE + 'Regel f gegeben x als Ganzzahl, liefert Ganzzahl:\n  sei s gleich 1.\n' +
+                '  pruefe s:\n    bei Riesig(), gib zurueck 1.\n    bei wert, gib zurueck wert.\n', []);
+            assert.deepEqual(codes(r2), ["E803" /* ErrorCode.UNRESOLVED_PATTERN */]);
+            const cases = stmt(func(module, 'f'), 1, 'Match').cases;
+            assert.equal(cases[1].pattern.name, 'wert');
+        });
+    });
+    describe('其它位置', () => {
+        it('UFCS：x.berechne() 的方法名按函数解析', () => {
+            const { module, r2 } = run(MODULE + DRIVER_DECL +
+                'Regel berechne gegeben d als Fahrer, liefert Ganzzahl:\n  gib zurueck d.alter.\n\n' +
+                'Regel f gegeben x als Fahrer, liefert Ganzzahl:\n  gib zurueck x.berechne().\n', [...DRIVER, fn('compute', 'berechne')]);
+            assert.deepEqual(codes(r2), []);
+            const call = returned(func(module, 'f'), 0);
+            assert.equal(nameOf(call.target).name, 'compute');
+            assert.equal(nameOf(call.args[0]).name, 'x');
+        });
+        it('限定调用：首段折叠命中局部名也不按字段路径解析；UFCS 接收者为命名空间时不报 E802', () => {
+            const { module, r2 } = run('Module m.\n\nRule f given action as Text, produce Bool. It performs io:\n' +
+                '  Let x be io.get(action).\n  Return Action.equals(action, "a").\n', [], EN_US);
+            assert.deepEqual(codes(r2), []);
+            const call = returned(func(module, 'f'), 1);
+            assert.equal(nameOf(call.target).name, 'Action.equals');
+            const ufcs = stmt(func(module, 'f'), 0, 'Let').expr;
+            assert.deepEqual([nameOf(ufcs.target).name, nameOf(ufcs.args[0]).name], ['get', 'io']);
+        });
+        it('lambda：期望类型取 lambda 声明返回类型，捕获列表随解析结果改写', () => {
+            const { module, r2 } = run('Module m.\n\nDefine Stufe as one of Hoch, Niedrig.\n\n' +
+                'Rule f given outer as Int, produce Int:\n' +
+                '  Let g be function with x as Int, produce Stufe:\n' +
+                '    Let unused be outer.\n' +
+                '    Return Hoch.\n' +
+                '  Return outer.\n', LEVEL, EN_US);
+            assert.deepEqual(codes(r2), []);
+            const lambda = stmt(func(module, 'f'), 0, 'Let').expr;
+            const ret = lambda.body.statements[1];
+            assert.equal(nameOf(ret.expr).name, 'High');
+            assert.deepEqual(lambda.captures, ['outer', 'High']);
+        });
+    });
+    describe('裁决 R19：未知调用目标交由类型检查', () => {
+        it('调用目标在声明、导入、内置、词汇中均无候选 → 保留原写法，不报 E802；值位置仍报', () => {
+            const { module, r2 } = run(MODULE + 'Regel f gegeben x als Ganzzahl, liefert Ganzzahl:\n  gib zurueck unbekannt(x).\n\n' +
+                'Regel g gegeben x als Ganzzahl, liefert Ganzzahl:\n  gib zurueck fehlend.\n', []);
+            assert.deepEqual(codes(r2), ["E802" /* ErrorCode.UNRESOLVED_NAME */]);
+            assert.match(r2[0].message, /fehlend/);
+            assert.equal(nameOf(returned(func(module, 'f'), 0).target).name, 'unbekannt');
+        });
+    });
+    describe('Core 不变量', () => {
+        const SOURCE = MODULE + LEVEL_DECL + 'Definiere Fahrer hat alter als Ganzzahl, stufe als Stufe.\n\n' +
+            'Regel bewerten gegeben fahrer als Fahrer, liefert Stufe:\n' +
+            '  sei a gleich fahrer.alter.\n' +
+            '  pruefe fahrer.stufe:\n    bei Hoch, gib zurueck Niedrig.\n    bei Niedrig, gib zurueck Hoch.\n';
+        const VOCAB = [...LEVEL, ...DRIVER, field('Driver', 'level', 'stufe'), fn('check', 'bewerten')];
+        const LOCALIZED = ['Stufe', 'Hoch', 'Niedrig', 'Fahrer', 'alter', 'stufe', 'bewerten'];
+        function collect(node, names, origins) {
+            if (Array.isArray(node))
+                return node.forEach((x) => collect(x, names, origins));
+            if (!node || typeof node !== 'object')
+                return;
+            for (const [k, v] of Object.entries(node)) {
+                if (k === 'origin')
+                    origins.push(v);
+                else if (typeof v === 'string' && ['name', 'typeName', 'base'].includes(k))
+                    names.push(...v.split('.'));
+                else if (k === 'variants' || k === 'names')
+                    names.push(...v);
+                else
+                    collect(v, names, origins);
+            }
+        }
+        it('解析后 Core 中无本地化名；origin.written/role 仅在 written !== canonical 时出现', () => {
+            const { module, r1, r2 } = run(SOURCE, VOCAB);
+            assert.deepEqual([...codes(r1), ...codes(r2)], []);
+            const names = [];
+            const origins = [];
+            collect(module, names, origins);
+            assert.deepEqual(names.filter((n) => LOCALIZED.includes(n)), []);
+            for (const o of origins) {
+                if (o?.written === undefined && o?.role === undefined)
+                    continue;
+                assert.ok(o.written !== undefined && o.role !== undefined, '两者同时出现');
+            }
+            const withWritten = origins.filter((o) => o?.written !== undefined).map((o) => o.written);
+            assert.ok(withWritten.includes('fahrer.alter'));
+            assert.ok(withWritten.includes('Hoch'));
+            const f = func(module, 'check');
+            assert.equal(f.origin?.written, 'bewerten');
+            assert.equal(f.origin?.role, 'FUNC_DECL');
+            // 局部名 fahrer 未改写：其节点 origin 不带 written
+            const let0 = stmt(f, 0, 'Let');
+            assert.equal(let0.origin?.written, undefined);
+        });
+        it('函数签名的参数 / 返回类型名记录 written/role（与 Java 对齐）', () => {
+            const { module, r1, r2 } = run(SOURCE, VOCAB);
+            assert.deepEqual([...codes(r1), ...codes(r2)], []);
+            const f = func(module, 'check');
+            const paramType = f.params[0].type;
+            assert.equal(paramType.name, 'Driver');
+            assert.equal(paramType.origin?.written, 'Fahrer');
+            assert.equal(paramType.origin?.role, 'TYPE');
+            const ret = f.ret;
+            assert.equal(ret.name, 'Level');
+            assert.equal(ret.origin?.written, 'Stufe');
+            assert.equal(ret.origin?.role, 'TYPE');
+        });
+        it('函数签名中未改写的类型名不新增 origin（无词汇 IR 不变）', () => {
+            const { module } = run('Module m.\n\nDefine Driver has age as Int.\n\nRule f given d as Driver, produce Int:\n  Return d.age.\n', DRIVER, EN_US);
+            const f = func(module, 'f');
+            assert.equal(f.params[0].type.origin, undefined);
+            assert.equal(f.ret.origin, undefined);
+        });
+        it('规范名直写的源码：origin 不带 written/role', () => {
+            const { module, r2 } = run('Module m.\n\nDefine Driver has age as Int.\n\nRule f given d as Driver, produce Int:\n  Return d.age.\n', DRIVER, EN_US);
+            assert.deepEqual(codes(r2), []);
+            const origins = [];
+            collect(module, [], origins);
+            assert.deepEqual(origins.filter((o) => o?.written !== undefined || o?.role !== undefined), []);
+        });
+        it('任一 E8xx 时 diagnostics 非空（调用方据此不发出 IR）', () => {
+            const { r2 } = run(MODULE + DRIVER_DECL + 'Regel f gegeben x als Fahrer, liefert Ganzzahl:\n  gib zurueck x.gewicht.\n', DRIVER);
+            assert.ok(r2.some((d) => d.severity === 'error' && d.code.startsWith('E80')));
+        });
+        it('R2 只读标记：输出中不再携带 ResolutionMark，输入 Core 不被修改', () => {
+            const ctx = ctxOf(DRIVER);
+            const r1 = resolveDeclarations(parse(MODULE + DRIVER_DECL + 'Regel f gegeben x als Fahrer, liefert Ganzzahl:\n  gib zurueck x.alter.\n'), ctx);
+            const core = lowerModule(r1.module);
+            const before = nameOf(returned(func(core, 'f'), 0));
+            assert.equal(before.name, 'x.alter');
+            assert.ok(resolutionMarkOf(before));
+            const out = resolveTypedReferences(core, ctx).module;
+            assert.equal(before.name, 'x.alter');
+            assert.equal(resolutionMarkOf(nameOf(returned(func(out, 'f'), 0))), undefined);
+        });
+    });
+    describe('裁决 R16：规范名直写不告警、动态字段透传', () => {
+        const TIER = 'Module m.\n\nDefine Tier as one of Gold, Silver.\n\n';
+        it('1. 接收者类型未知、字段写法即规范名 → 无 W801；模式写法即成员规范名 → 无 W801', () => {
+            const { module, r1, r2 } = run(TIER + 'Define Driver has age as Int.\n\n' +
+                'Rule f given x as Int, produce Int:\n  Let y be 1.\n  Let a be y.age.\n' +
+                '  Match y:\n    When Gold, Return 1.\n    When Silver(), Return a.\n', [], EN_US);
+            assert.deepEqual([...codes(r1), ...codes(r2)], []);
+            assert.equal(nameOf(stmt(func(module, 'f'), 1, 'Let').expr).name, 'y.age');
+            const cases = stmt(func(module, 'f'), 2, 'Match').cases;
+            assert.equal(cases[0].pattern.name, 'Gold');
+            assert.equal(cases[1].pattern.typeName, 'Silver');
+        });
+        it('2. 无期望类型的裸成员规范名 → 原样接受；期望枚举下写法即规范名不改写', () => {
+            const { module, r1, r2 } = run(TIER + 'Rule f given t as Text:\n  Return Gold.\n\n' +
+                'Rule g given t as Text, produce Bool:\n  Return Text.equals(t, Silver).\n\n' +
+                'Rule h given t as Text, produce Tier:\n  Return Gold.\n', [], EN_US);
+            assert.deepEqual([...codes(r1), ...codes(r2)], []);
+            assert.equal(nameOf(returned(func(module, 'f'), 0)).name, 'Gold');
+            assert.equal(nameOf(returned(func(module, 'g'), 0).args[1]).name, 'Silver');
+            const h = nameOf(returned(func(module, 'h'), 0));
+            assert.equal(h.name, 'Gold');
+            assert.equal(h.origin?.written, undefined);
+        });
+        it('2. 成员规范名属于多个枚举且无期望类型 → E804', () => {
+            const { r2 } = run(TIER + 'Define Medal as one of Gold, Bronze.\n\nRule f given t as Text:\n  Return Gold.\n', [], EN_US);
+            assert.deepEqual(codes(r2), ["E804" /* ErrorCode.AMBIGUOUS_NAME */]);
+        });
+        it('3. 未声明类型的字段之后的段为动态键（ADR 0040）：原样保留，不报错，经 Let 传递', () => {
+            const { module, r1, r2 } = run('Module m.\n\nDefine GuardRequest has action, context.\n\n' +
+                'Rule decide given req as GuardRequest, produce Int:\n' +
+                '  Let large be req.context.amount.\n  Let c be req.context.\n  Let b be c.limit.\n' +
+                '  Let n be req.action.size.\n  Return 1.\n', [], EN_US);
+            assert.deepEqual([...codes(r1), ...codes(r2)], []);
+            const f = func(module, 'decide');
+            assert.equal(nameOf(stmt(f, 0, 'Let').expr).name, 'req.context.amount');
+            assert.equal(nameOf(stmt(f, 2, 'Let').expr).name, 'c.limit');
+            assert.equal(nameOf(stmt(f, 3, 'Let').expr).name, 'req.action.size');
+        });
+        it('3. 已知非 Data 类型（Text）之后的段原样保留', () => {
+            const { r2 } = run('Module m.\n\nRule f given t as Text, produce Int:\n  Let n be t.size.\n  Return 1.\n', [], EN_US);
+            assert.deepEqual(codes(r2), []);
+        });
+        it('3b. 类型参数（未声明类型名成为隐式类型参数）上的字段段 → E801，不透传', () => {
+            const { r2 } = run('Module m.\n\nRule f given x as Foo, produce Int:\n  Return x.age.\n', [], EN_US);
+            assert.deepEqual(codes(r2), ["E801" /* ErrorCode.UNRESOLVED_FIELD */]);
+        });
+        it('4. lambda 绑定的局部名与内置运算符不报 E802', () => {
+            const { r1, r2 } = run('Module m.\n\nRule f given x as Int, produce Int:\n' +
+                '  Let inc be function with v as Int, produce Int:\n    Return v plus 1.\n' +
+                '  Return inc(x) times 2.\n', [], EN_US);
+            assert.deepEqual([...codes(r1), ...codes(r2)], []);
+        });
+    });
+    describe('透传白名单、标记幂等与期望枚举裁决', () => {
+        const EN_DRIVER = 'Module m.\n\nDefine Fahrer has alter as Int.\n\n';
+        const receivers = [
+            ['类型别名', 'Type Fz as Fahrer.\n\nRule f given x as Fz, produce Int:\n  Return x.alter.\n'],
+            ['Option of', 'Rule f given x as Option of Fahrer, produce Int:\n  Return x.alter.\n'],
+            ['可空 ?', 'Rule f given x as Fahrer?, produce Int:\n  Return x.alter.\n'],
+            ['未声明类型名（Data 字段）', 'Define Halter has fz as Unbekannt.\n\nRule f given x as Halter, produce Int:\n  Return x.fz.alter.\n'],
+        ];
+        for (const [label, body] of receivers) {
+            it(`接收者类型为${label} → 不透传，按全局候选采用 + W801`, () => {
+                const { module, r2 } = run(EN_DRIVER + body, DRIVER, EN_US);
+                assert.deepEqual(codes(r2), ["W801" /* ErrorCode.RESOLVED_WITHOUT_TYPE */]);
+                assert.match(nameOf(returned(func(module, 'f'), 0)).name, /\.age$/);
+            });
+        }
+        it('同一 Core 上连续两次 R2：模块与诊断相同', () => {
+            const ctx = ctxOf(DRIVER);
+            const r1 = resolveDeclarations(parse(MODULE + DRIVER_DECL + 'Regel f gegeben x als Ganzzahl, liefert Ganzzahl:\n  sei y gleich 1.\n  sei z gleich hoch.\n  gib zurueck y.alter.\n'), ctx);
+            const core = lowerModule(r1.module);
+            const a = resolveTypedReferences(core, ctx);
+            const b = resolveTypedReferences(core, ctx);
+            assert.deepEqual(codes(a.diagnostics), ["E802" /* ErrorCode.UNRESOLVED_NAME */, "W801" /* ErrorCode.RESOLVED_WITHOUT_TYPE */]);
+            assert.deepEqual(b.diagnostics, a.diagnostics);
+            assert.equal(JSON.stringify(b.module), JSON.stringify(a.module));
+            assert.equal(nameOf(returned(func(b.module, 'f'), 2)).name, 'y.age');
+        });
+        it('期望枚举下其它枚举的同名成员不冲突', () => {
+            const { module, r1, r2 } = run('Module m.\n\nDefine Tier as one of Gold, Silver.\n\nDefine Medal as one of Gold, Bronze.\n\n' +
+                'Rule f given x as Int, produce Tier:\n  Return Gold.\n', [], EN_US);
+            assert.deepEqual([...codes(r1), ...codes(r2)], []);
+            assert.equal(nameOf(returned(func(module, 'f'), 0)).name, 'Gold');
+        });
+        it('LOCAL 精确命中优先于成员的折叠歧义', () => {
+            const { module, r1, r2 } = run(MODULE + 'Definiere Stufe als eines von Hoch, HOCH.\n\n' +
+                'Regel f gegeben hoch als Stufe, liefert Stufe:\n  gib zurueck hoch.\n', [struct('Level', 'Stufe'), member('Level', 'High', 'Hoch'), member('Level', 'Top', 'HOCH')]);
+            assert.deepEqual([...codes(r1), ...codes(r2)], []);
+            assert.equal(nameOf(returned(func(module, 'f'), 0)).name, 'hoch');
+        });
+        it('局部名遮蔽模块函数：调用不取模块函数的返回类型', () => {
+            const { r2 } = run(EN_DRIVER + 'Rule make given x as Int, produce Fahrer:\n  Return Fahrer with alter set to x.\n\n' +
+                'Rule f given x as Int, produce Int:\n' +
+                '  Let make be function with v as Int, produce Int:\n    Return v.\n' +
+                '  Let y be make(x).\n  Return y.alter.\n', DRIVER, EN_US);
+            assert.deepEqual(codes(r2), ["W801" /* ErrorCode.RESOLVED_WITHOUT_TYPE */]);
+        });
+        it('R1 已在同一位置报 E804 时 R2 不重复报告', () => {
+            const { r1, r2 } = run(MODULE + LEVEL_DECL + 'Regel f gegeben x als Ganzzahl, liefert Stufe:\n  gib zurueck hoch.\n', [...LEVEL, fn('raise', 'HoCh'), fn('lift', 'HOCH')]);
+            assert.deepEqual([...codes(r1), ...codes(r2)], ["E804" /* ErrorCode.AMBIGUOUS_NAME */]);
+        });
+    });
+    describe('裁决 R30：未注解参数类型未知', () => {
+        it('未注解参数上的路径 → 全局候选采用 + W801', () => {
+            const { module, r2 } = run(MODULE + DRIVER_DECL + 'Regel f gegeben fahrer, liefert Ganzzahl:\n  gib zurueck fahrer.alter.\n', DRIVER);
+            assert.deepEqual(codes(r2), ["W801" /* ErrorCode.RESOLVED_WITHOUT_TYPE */]);
+            assert.equal(nameOf(returned(func(module, 'f'), 0)).name, 'fahrer.age');
+        });
+        it('未注解主语上的裸成员模式 → 采用 + W801', () => {
+            const { module, r2 } = run(MODULE + LEVEL_DECL + 'Regel f gegeben s, liefert Ganzzahl:\n  pruefe s:\n    bei Hoch, gib zurueck 1.\n    bei andere, gib zurueck 2.\n', LEVEL);
+            assert.deepEqual(codes(r2), ["W801" /* ErrorCode.RESOLVED_WITHOUT_TYPE */]);
+            assert.equal(stmt(func(module, 'f'), 0, 'Match').cases[0].pattern.name, 'High');
+        });
+        it('未注解 lambda 参数上的路径 → 全局候选采用 + W801（裁决 R31）', () => {
+            const { module, r2 } = run('Module m.\n\nDefine Fahrer has alter as Int.\n\n' +
+                'Rule f given x as Int, produce Int:\n  Let g be function with fahrer, produce Int:\n    Return fahrer.alter.\n  Return x.\n', DRIVER, EN_US);
+            assert.deepEqual(codes(r2), ["W801" /* ErrorCode.RESOLVED_WITHOUT_TYPE */]);
+            const lambda = stmt(func(module, 'f'), 0, 'Let').expr;
+            assert.equal(nameOf(lambda.body.statements[0].expr).name, 'fahrer.age');
+        });
+        it('未注解 lambda 参数上的未知字段 → E801（裁决 R31）', () => {
+            const { r2 } = run('Module m.\n\nDefine Fahrer has alter as Int.\n\n' +
+                'Rule f given x as Int, produce Int:\n  Let g be function with y, produce Int:\n    Return y.foo.\n  Return x.\n', DRIVER, EN_US);
+            assert.deepEqual(codes(r2), ["E801" /* ErrorCode.UNRESOLVED_FIELD */]);
+        });
+        it('未注解参数上的未知字段 → E801', () => {
+            const { r2 } = run(MODULE + DRIVER_DECL + 'Regel f gegeben x, liefert Ganzzahl:\n  gib zurueck x.foo.\n', DRIVER);
+            assert.deepEqual(codes(r2), ["E801" /* ErrorCode.UNRESOLVED_FIELD */]);
+        });
+    });
+    describe('lower 在未运行 R1 时行为不变', () => {
+        it('无 resolved 的 AST：名字保持原写法，origin 不带 written/role', () => {
+            const ast = parse(MODULE + DRIVER_DECL + 'Regel f gegeben x als Fahrer, liefert Ganzzahl:\n  gib zurueck x.alter.\n');
+            const core = lowerModule(ast);
+            const json = JSON.stringify(core);
+            assert.ok(!json.includes('"written"'));
+            assert.ok(!json.includes('"role"'));
+            assert.equal(nameOf(returned(func(core, 'f'), 0)).name, 'x.alter');
+            assert.equal(core.decls[0].name, 'Fahrer');
+        });
+    });
+});
+//# sourceMappingURL=resolve-typed-references.test.js.map