@rsconcept/domain 1.7.7 → 1.8.1

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}>`;
 }