@rsconcept/domain 1.8.0 → 1.8.1

package/src/library/template-instantiation.test.ts

@@ -219,17 +219,82 @@ describe('planTemplateInstantiation', () => {
     expect(plan.items[0].definition_formal).not.toContain('F42[');
   });
 
-  it('skips template constituents that already exist in the target schema', () => {
+  it('instantiates bank dependency when target alias collides but definition differs', () => {
+    const schemaWithUnrelatedF42 = mockSchema([
+      ...targetSchema.items,
+      mockCst({
+        id: 12,
+        alias: 'F42',
+        cst_type: CstType.FUNCTION,
+        definition_formal: '[α∈R1] α'
+      })
+    ]);
+
+    const plan = planTemplateInstantiation({
+      targetSchema: schemaWithUnrelatedF42,
+      templateItems,
+      prototype: p30,
+      userArgs: [{ alias: 'σ', typification: 'ℬ((R1×R1)×R1)', value: 'S2' }],
+      mainItem: {
+        alias: 'A2',
+        cst_type: CstType.PREDICATE,
+        crucial: false,
+        convention: '',
+        definition_formal: p30.definition_formal,
+        definition_raw: '',
+        term_raw: p30.term_raw,
+        term_forms: [],
+        typification_manual: '',
+        value_is_property: false
+      }
+    });
+
+    const dependency = plan.items[0];
+    expect(plan.items).toHaveLength(2);
+    expect(dependency.alias).not.toBe('F42');
+    expect(dependency.definition_formal).toContain('S2');
+    expect(plan.items.at(-1)!.definition_formal).toContain(`${dependency.alias}[`);
+    expect(plan.items.at(-1)!.definition_formal).not.toContain('F42[');
+  });
+
+  it('reuses template dependency when target has matching substituted definition', () => {
+    const userArgs: ArgumentValue[] = [{ alias: 'σ', typification: 'ℬ((R1×R1)×R1)', value: 'S2' }];
+
+    const baseline = planTemplateInstantiation({
+      targetSchema,
+      templateItems,
+      prototype: p30,
+      userArgs,
+      mainItem: {
+        alias: 'A2',
+        cst_type: CstType.PREDICATE,
+        crucial: false,
+        convention: '',
+        definition_formal: p30.definition_formal,
+        definition_raw: '',
+        term_raw: p30.term_raw,
+        term_forms: [],
+        typification_manual: '',
+        value_is_property: false
+      }
+    });
+
+    const equivalentFunction = baseline.items[0];
     const schemaWithF42 = mockSchema([
       ...targetSchema.items,
-      mockCst({ id: 12, alias: 'F42', cst_type: CstType.FUNCTION, definition_formal: f42.definition_formal })
+      mockCst({
+        id: 12,
+        alias: 'F42',
+        cst_type: equivalentFunction.cst_type,
+        definition_formal: equivalentFunction.definition_formal
+      })
     ]);
 
     const plan = planTemplateInstantiation({
       targetSchema: schemaWithF42,
       templateItems,
       prototype: p30,
-      userArgs: [{ alias: 'σ', typification: 'ℬ((R1×R1)×R1)', value: 'S2' }],
+      userArgs,
       mainItem: {
         alias: 'A2',
         cst_type: CstType.PREDICATE,
@@ -305,4 +370,58 @@ describe('planTemplateInstantiation', () => {
     expect(plan.mainDuplicateAlias).toBe('A9');
     expect(plan.items.some(item => item.term_raw === p35.term_raw)).toBe(false);
   });
+
+  it('reports binding conflict when the same template parameter is bound to different aliases', () => {
+    const f10 = mockCst({
+      id: 5,
+      alias: 'F10',
+      cst_type: CstType.FUNCTION,
+      term_raw: 'g',
+      definition_formal: '[x∈R1] x'
+    });
+    const p11 = mockCst({
+      id: 6,
+      alias: 'P11',
+      cst_type: CstType.PREDICATE,
+      term_raw: 'h',
+      definition_formal: '[y∈R1] F10[y]'
+    });
+    const mainTemplate = mockCst({
+      id: 7,
+      alias: 'P12',
+      cst_type: CstType.PREDICATE,
+      term_raw: 'main',
+      definition_formal: '[a∈R1, b∈R1] P11[a] & P11[b]'
+    });
+
+    const plan = planTemplateInstantiation({
+      targetSchema,
+      templateItems: [f10, p11],
+      prototype: mainTemplate,
+      userArgs: [
+        { alias: 'a', typification: 'R1', value: 'S1' },
+        { alias: 'b', typification: 'R1', value: 'S2' }
+      ],
+      mainItem: {
+        alias: 'A1',
+        cst_type: CstType.PREDICATE,
+        crucial: false,
+        convention: '',
+        definition_formal: mainTemplate.definition_formal,
+        definition_raw: '',
+        term_raw: mainTemplate.term_raw,
+        term_forms: [],
+        typification_manual: '',
+        value_is_property: false
+      }
+    });
+
+    expect(plan.bindingConflict).toEqual({
+      templateAlias: 'P11',
+      paramAlias: 'y',
+      existing: 'S1',
+      incoming: 'S2'
+    });
+    expect(plan.items).toHaveLength(0);
+  });
 });

package/src/library/template-instantiation.ts

@@ -47,11 +47,19 @@ export interface TemplateInstantiationItem {
   value_is_property: boolean;
 }
 
+/** Conflicting argument bindings inferred for the same template dependency. */
+export interface TemplateBindingConflict {
+  templateAlias: string;
+  paramAlias: string;
+  existing: string;
+  incoming: string;
+}
+
 /**
  * Batch create plan: dependencies first, selected template constituent last.
  *
- * Skips bank functions/predicates whose alias already exists in the target schema, and
- * constituents whose substituted formal definition already exists (normalized comparison).
+ * Reuses constituents whose substituted formal definition already exists in the target schema
+ * (normalized comparison), even when the bank alias differs from the matched target alias.
  * {@link TemplateInstantiationPlan.mainDuplicateAlias} reports when the selected template is a duplicate.
  * Does not set `insert_after`; the caller supplies insertion on the batch DTO.
  */
@@ -59,6 +67,8 @@ export interface TemplateInstantiationPlan {
   items: TemplateInstantiationItem[];
   /** Set when the selected template expression already exists in the target schema. */
   mainDuplicateAlias: string | null;
+  /** Set when nested template calls bind the same parameter to different global aliases. */
+  bindingConflict: TemplateBindingConflict | null;
 }
 
 /**
@@ -115,6 +125,7 @@ export class TemplateInstantiationPlanner {
   private readonly userMapping: AliasMapping;
   private readonly depBindings = new Map<string, Map<string, string>>();
   private readonly depRefs = new Map<string, Set<string>>();
+  private bindingConflict: TemplateBindingConflict | null = null;
 
   /** @param input - See {@link TemplateInstantiationInput}. */
   constructor(input: TemplateInstantiationInput) {
@@ -133,6 +144,10 @@ export class TemplateInstantiationPlanner {
     const mainDefinition = substituteTemplateArgs(this.prototype.definition_formal, this.userMapping);
     this.collectDependencies(mainDefinition, this.userMapping);
 
+    if (this.bindingConflict) {
+      return { items: [], mainDuplicateAlias: null, bindingConflict: this.bindingConflict };
+    }
+
     const definitionIndex = createFormalDefinitionIndex(this.targetSchema);
     const dependencyItems = this.buildDependencyItems(definitionIndex);
     const { item: mainItem, duplicateAlias: mainDuplicateAlias } = this.buildMainItem(
@@ -144,7 +159,8 @@ export class TemplateInstantiationPlanner {
 
     return {
       items: mainItem ? [...dependencyItems.items, mainItem] : dependencyItems.items,
-      mainDuplicateAlias
+      mainDuplicateAlias,
+      bindingConflict: null
     };
   }
 
@@ -221,7 +237,10 @@ export class TemplateInstantiationPlanner {
   }
 
   private ensureDep(templateAlias: string, bindings: Map<string, string>, referrer?: string): void {
-    if (targetHasAlias(this.targetSchema, templateAlias) || !this.templateByAlias.has(templateAlias)) {
+    if (this.bindingConflict) {
+      return;
+    }
+    if (!this.templateByAlias.has(templateAlias)) {
       return;
     }
     if (referrer && this.depBindings.has(referrer)) {
@@ -229,7 +248,12 @@ export class TemplateInstantiationPlanner {
       refs.add(templateAlias);
       this.depRefs.set(referrer, refs);
     }
-    const merged = mergeBindings(this.depBindings.get(templateAlias), bindings);
+    const mergeResult = mergeBindings(this.depBindings.get(templateAlias), bindings);
+    if (!mergeResult.ok) {
+      this.bindingConflict = { templateAlias, ...mergeResult.conflict };
+      return;
+    }
+    const merged = mergeResult.bindings;
     const changed =
       !this.depBindings.has(templateAlias) || merged.size !== (this.depBindings.get(templateAlias)?.size ?? 0);
     this.depBindings.set(templateAlias, merged);
@@ -243,6 +267,9 @@ export class TemplateInstantiationPlanner {
   }
 
   private collectDependencies(expression: string, scope: AliasMapping, referrer?: string): void {
+    if (this.bindingConflict) {
+      return;
+    }
     const ast = parseRSLangExpression(expression);
     if (!ast) {
       return;
@@ -332,14 +359,21 @@ function resolveArgBinding(argExpr: string, scope: AliasMapping): string | undef
   return undefined;
 }
 
-function mergeBindings(existing: Map<string, string> | undefined, incoming: Map<string, string>): Map<string, string> {
+type MergeBindingsResult =
+  | { ok: true; bindings: Map<string, string> }
+  | { ok: false; conflict: { paramAlias: string; existing: string; incoming: string } };
+
+function mergeBindings(existing: Map<string, string> | undefined, incoming: Map<string, string>): MergeBindingsResult {
   const result = new Map(existing);
   for (const [alias, value] of incoming) {
-    if (!result.has(alias)) {
+    const existingValue = result.get(alias);
+    if (existingValue === undefined) {
       result.set(alias, value);
+    } else if (existingValue !== value) {
+      return { ok: false, conflict: { paramAlias: alias, existing: existingValue, incoming: value } };
     }
   }
-  return result;
+  return { ok: true, bindings: result };
 }
 
 function bindingMapToArgs(params: TemplateParam[], bindings: Map<string, string>): ArgumentValue[] {
@@ -401,10 +435,6 @@ function extractFuncCalls(ast: AstNode, expression: string): FuncCallRef[] {
   return result;
 }
 
-function targetHasAlias(schema: RSForm, alias: string): boolean {
-  return schema.items.some(cst => cst.alias === alias);
-}
-
 function topologicalSort(aliases: string[], refs: Map<string, Set<string>>): string[] {
   const remaining = new Set(aliases);
   const sorted: string[] = [];

package/src/rslang/api.ts

@@ -15,13 +15,14 @@ export type AliasMapping = Record<string, string>;
 const LOCALS_REGEXP = /[_a-zα-ω][a-zα-ω]*\d*/g;
 const GLOBAL_ALIAS_SOURCE = '[XCSADFPTN]\\d+';
 const GLOBALS_REGEXP = new RegExp(GLOBAL_ALIAS_SOURCE, 'g');
+const GLOBAL_ALIAS_ANCHORED_REGEXP = new RegExp(`^${GLOBAL_ALIAS_SOURCE}$`);
 const COMPLEX_SYMBOLS_REGEXP = /[∀∃×ℬ;|:]/g;
 const TYPIFICATION_SET = /^ℬ+\([ℬ\(((X|C)\d+|Z)\)×]*\)$/g;
 // cspell:enable
 
 /** Whether {@link value} is a single schema global alias (e.g. `X1`, `F42`). */
 export function isGlobalAlias(value: string): boolean {
-  return new RegExp(`^${GLOBAL_ALIAS_SOURCE}$`).test(value);
+  return GLOBAL_ALIAS_ANCHORED_REGEXP.test(value);
 }
 
 /**

package/src/rslang/labels.ts

@@ -138,6 +138,15 @@ export function labelRSLangNode(node: AstNodeBase): string {
   return 'UNKNOWN NODE: ' + String(node.typeID);
 }
 
+/** Formats a base-set alias for display (mangled radicals `func<R#>` → `<func>R#`). */
+export function labelBaseId(baseID: string): string {
+  const match = /^([^<]+)<(R[1-9]\d*)>$/.exec(baseID);
+  if (match) {
+    return `<${match[1]}>${match[2]}`;
+  }
+  return baseID;
+}
+
 /** Converts expression type to string. */
 export function labelType(type: ExpressionType | null): string {
   if (!type) {
@@ -149,7 +158,7 @@ export function labelType(type: ExpressionType | null): string {
     case TypeID.integer:
       return INTEGER_TYPE_NAME;
     case TypeID.basic:
-      return type.baseID;
+      return labelBaseId(type.baseID);
     case TypeID.tuple:
       return type.factors
         .map(factor => (factor.typeID === TypeID.tuple ? `(${labelType(factor)})` : labelType(factor)))

package/src/rslang/semantic/type-auditor.test.ts

@@ -159,12 +159,12 @@ const errorData = [
   // Functions
   ['F1[X1]', { code: RSErrorCode.invalidArgsArity, from: 0, to: 6, params: ['2', '1'] }],
   ['F1[X1, X1, X1]', { code: RSErrorCode.invalidArgsArity, from: 0, to: 14, params: ['2', '3'] }],
-  ['F1[X1, S1]', { code: RSErrorCode.invalidArgumentType, from: 7, to: 9, params: ['b∈ℬ(X1)', 'ℬ(X1×X1)'] }],
-  ['F1[S1, X1]', { code: RSErrorCode.invalidArgumentType, from: 3, to: 5, params: ['a∈ℬ(X1)', 'ℬ(X1×X1)'] }],
+  ['F1[X1, S1]', { code: RSErrorCode.invalidArgumentType, from: 7, to: 9, params: ['F1<b>∈ℬ(X1)', 'ℬ(X1×X1)'] }],
+  ['F1[S1, X1]', { code: RSErrorCode.invalidArgumentType, from: 3, to: 5, params: ['F1<a>∈ℬ(X1)', 'ℬ(X1×X1)'] }],
   ['P1[X1]', { code: RSErrorCode.invalidArgsArity, from: 0, to: 6, params: ['2', '1'] }],
   ['P1[X1, X1, X1]', { code: RSErrorCode.invalidArgsArity, from: 0, to: 14, params: ['2', '3'] }],
-  ['P1[X1, S1]', { code: RSErrorCode.invalidArgumentType, from: 7, to: 9, params: ['b∈ℬ(X1)', 'ℬ(X1×X1)'] }],
-  ['P1[S1, X1]', { code: RSErrorCode.invalidArgumentType, from: 3, to: 5, params: ['a∈ℬ(X1)', 'ℬ(X1×X1)'] }],
+  ['P1[X1, S1]', { code: RSErrorCode.invalidArgumentType, from: 7, to: 9, params: ['P1<b>∈ℬ(X1)', 'ℬ(X1×X1)'] }],
+  ['P1[S1, X1]', { code: RSErrorCode.invalidArgumentType, from: 3, to: 5, params: ['P1<a>∈ℬ(X1)', 'ℬ(X1×X1)'] }],
   // Integral
   ['card(debool(X1))', { code: RSErrorCode.invalidCard, from: 5, to: 15, params: ['X1'] }],
   ['card(S3)', { code: RSErrorCode.invalidCard, from: 5, to: 7, params: ['C1'] }],
@@ -313,7 +313,26 @@ describe('TypeAuditor', () => {
       code: RSErrorCode.invalidArgumentType,
       from: 7,
       to: 12,
-      params: ['b∈X1', 'ℬℬ(X1)']
+      params: ['F2<b>∈X1', 'ℬℬ(X1)']
+    });
+  });
+
+  it('Qualifies unresolved radicals and parameter aliases in invalidArgumentType message', () => {
+    typeContext.set('P44', {
+      typeID: TypeID.predicate,
+      result: LogicT,
+      args: [
+        { alias: 'α', type: bool(tuple([tuple([basic('R1'), basic('R2')]), basic('C1')])) },
+        { alias: 'β', type: bool(tuple([tuple([basic('R2'), basic('R3')]), basic('C1')])) }
+      ]
+    });
+    const inner = tuple([basic('X1'), basic('X2')]);
+    typeContext.set('S9', bool(tuple([inner, basic('C1')])));
+    expectError('P44[S9, S9]', {
+      code: RSErrorCode.invalidArgumentType,
+      from: 8,
+      to: 10,
+      params: ['P44<β>∈ℬ((X2×<P44>R3)×C1)', 'ℬ((X1×X2)×C1)']
     });
   });
 
@@ -331,7 +350,7 @@ describe('TypeAuditor', () => {
       code: RSErrorCode.invalidArgumentType,
       from: 7,
       to: 9,
-      params: ['ζ∈ℬℬ(X1)', 'Z']
+      params: ['P2<ζ>∈ℬℬ(X1)', 'Z']
     });
   });
 

package/src/rslang/semantic/type-auditor.ts

@@ -20,6 +20,7 @@ import {
   isTemplateRadical,
   isTypification,
   LogicT,
+  mangleParamAlias,
   mangleRadicalId,
   type Parametrized,
   tuple,
@@ -1025,7 +1026,7 @@ export class TypeAuditor {
           substituteBase(expectedType, substitutes);
         }
         this.onError(RSErrorCode.invalidArgumentType, node.children[child], [
-          `${type.args[child - 1].alias}∈${labelType(expectedType)}`,
+          `${mangleParamAlias(type.args[child - 1].alias, alias)}∈${labelType(expectedType)}`,
           labelType(childType)
         ]);
         return null;

package/src/rslang/semantic/typification-api.test.ts

@@ -1,7 +1,16 @@
 import { describe, expect, it } from 'vitest';
 
 import type { TypePath } from './typification';
-import { AnyTypificationT, basic, bool, IntegerT, mangleRadicalId, tuple, type Typification } from './typification';
+import {
+  AnyTypificationT,
+  basic,
+  bool,
+  IntegerT,
+  mangleParamAlias,
+  mangleRadicalId,
+  tuple,
+  type Typification
+} from './typification';
 import { applyPath, cloneTypification, compareTemplated, substituteBase } from './typification-api';
 
 describe('applyPath', () => {
@@ -56,15 +65,22 @@ describe('compareTemplated', () => {
 
 describe('mangleRadicalId', () => {
   it('qualifies template radical with function name', () => {
-    expect(mangleRadicalId('R1', 'P2')).toBe('R1<P2>');
-    expect(mangleRadicalId('R2', 'F10')).toBe('R2<F10>');
+    expect(mangleRadicalId('R1', 'P2')).toBe('P2<R1>');
+    expect(mangleRadicalId('R2', 'F10')).toBe('F10<R2>');
+  });
+});
+
+describe('mangleParamAlias', () => {
+  it('qualifies formal parameter alias with calling function name', () => {
+    expect(mangleParamAlias('β', 'P44')).toBe('P44<β>');
+    expect(mangleParamAlias('a', 'F1')).toBe('F1<a>');
   });
 });
 
 describe('cloneTypification + substituteBase', () => {
   it('resolves mangled radicals for error messages', () => {
-    const argType = bool(basic('R1<F2>'));
-    const substitutes = new Map<string, Typification>([['R1<F2>', basic('X1')]]);
+    const argType = bool(basic('F2<R1>'));
+    const substitutes = new Map<string, Typification>([['F2<R1>', basic('X1')]]);
     const expectedType = cloneTypification(argType);
     substituteBase(expectedType, substitutes);
     expect(expectedType).toEqual(bool(basic('X1')));

package/src/rslang/semantic/typification-parser.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 
-import { labelType } from '../labels';
+import { labelBaseId, labelType } from '../labels';
 
 import { TypeID } from './typification';
 import { applyAsciiTypeSubstitutions, parseTypeText } from './typification-parser';
@@ -47,4 +47,9 @@ describe('parseTypeText', () => {
     expect(applyAsciiTypeSubstitutions('X1*X2 -> X3')).toBe('X1×X2 → X3');
     expect(applyAsciiTypeSubstitutions('B(X1)')).toBe('ℬ(X1)');
   });
+
+  it('displays mangled radicals with function qualifier before radical', () => {
+    expect(labelBaseId('P44<R3>')).toBe('<P44>R3');
+    expect(labelType({ typeID: TypeID.basic, baseID: 'P2<R1>' })).toBe('<P2>R1');
+  });
 });

package/src/rslang/semantic/typification.ts

@@ -174,17 +174,27 @@ export function isTypification(type: ExpressionType | null): boolean {
   );
 }
 
-/** Checks if given alias is a template or mangled radical. */
-export function isRadical(alias: string): boolean {
-  return /^R[1-9]\d*(?:<[^>]+>)?$/.test(alias);
-}
-
 /** Checks if given alias is an unmangled template radical. */
 export function isTemplateRadical(alias: string): boolean {
   return /^R[1-9]\d*$/.test(alias);
 }
 
+/** Checks if given alias is a mangled template radical (`funcName<R#>`). */
+export function isMangledRadical(alias: string): boolean {
+  return /^[^<]+<R[1-9]\d*>$/.test(alias);
+}
+
+/** Checks if given alias is a template or mangled radical. */
+export function isRadical(alias: string): boolean {
+  return isTemplateRadical(alias) || isMangledRadical(alias);
+}
+
 /** Mangle template radical with calling function name. */
 export function mangleRadicalId(radical: string, funcName: string): string {
-  return `${radical}<${funcName}>`;
+  return `${funcName}<${radical}>`;
+}
+
+/** Mangle formal parameter alias with calling function name (for diagnostics). */
+export function mangleParamAlias(alias: string, funcName: string): string {
+  return `${funcName}<${alias}>`;
 }