@rsconcept/domain 1.7.4 → 1.7.6

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

@@ -313,7 +313,25 @@ describe('TypeAuditor', () => {
       code: RSErrorCode.invalidArgumentType,
       from: 7,
       to: 12,
-      params: ['b∈R1F2', 'ℬℬ(X1)']
+      params: ['b∈X1', 'ℬℬ(X1)']
+    });
+  });
+
+  it('Resolves templated radicals in invalidArgumentType message', () => {
+    typeContext.set('S5', bool(bool(basic('X1'))));
+    typeContext.set('P2', {
+      typeID: TypeID.predicate,
+      result: LogicT,
+      args: [
+        { alias: 'σ', type: bool(bool(basic('R1'))) },
+        { alias: 'ζ', type: bool(bool(basic('R1'))) }
+      ]
+    });
+    expectError('P2[S5, 12]', {
+      code: RSErrorCode.invalidArgumentType,
+      from: 7,
+      to: 9,
+      params: ['ζ∈ℬℬ(X1)', 'Z']
     });
   });
 

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

@@ -17,9 +17,10 @@ import {
   EmptySetT,
   type ExpressionType,
   IntegerT,
-  isRadical,
+  isTemplateRadical,
   isTypification,
   LogicT,
+  mangleRadicalId,
   type Parametrized,
   tuple,
   type TypeContext,
@@ -29,6 +30,7 @@ import {
 import {
   checkCompatibility,
   checkEquality,
+  cloneTypification,
   compareTemplated,
   hasGenerics,
   mergeTypifications,
@@ -1018,8 +1020,12 @@ export class TypeAuditor {
       }
       const argType = mangleRadicals(alias, type.args[child - 1].type);
       if (!compareTemplated(substitutes, argType, childType)) {
+        const expectedType = cloneTypification(argType);
+        if (substitutes.size > 0) {
+          substituteBase(expectedType, substitutes);
+        }
         this.onError(RSErrorCode.invalidArgumentType, node.children[child], [
-          `${type.args[child - 1].alias}∈${labelType(argType)}`,
+          `${type.args[child - 1].alias}∈${labelType(expectedType)}`,
           labelType(childType)
         ]);
         return null;
@@ -1038,10 +1044,10 @@ function mangleRadicals(funcName: string, type: Typification): Typification {
     case TypeID.integer:
       return type;
     case TypeID.basic: {
-      if (isRadical(type.baseID)) {
+      if (isTemplateRadical(type.baseID)) {
         return {
           typeID: type.typeID,
-          baseID: type.baseID + funcName
+          baseID: mangleRadicalId(type.baseID, funcName)
         };
       }
       return type;
@@ -1157,10 +1163,7 @@ class LocalContext {
         return false;
       } else {
         this.onError(RSErrorCode.localDoubleDeclare, node, [alias]);
-        const index = this.data.indexOf(existing);
-        if (index !== -1) {
-          this.data.splice(index, 1);
-        }
+        return false;
       }
     }
     this.data.push({ alias, type, level: 1, useCount: 0 });
@@ -1171,8 +1174,7 @@ class LocalContext {
     const alias = getNodeText(node);
     const local = this.data.find(data => data.alias === alias);
     if (local === undefined) {
-      this.onError(RSErrorCode.localUndeclared, node, [alias]);
-      return null;
+      return this.onError(RSErrorCode.localUndeclared, node, [alias]);
     } else if (local.level < 1) {
       const subexprRoot = findRightLogicOperandRoot(node);
       if (subexprRoot !== null) {
@@ -1181,8 +1183,7 @@ class LocalContext {
         }
         return this.onError(RSErrorCode.localOutOfScopeParentheses, node, [alias]);
       }
-      this.onError(RSErrorCode.localOutOfScope, node, [alias]);
-      return null;
+      return this.onError(RSErrorCode.localOutOfScope, node, [alias]);
     } else {
       local.useCount++;
       return local.type;

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

@@ -1,8 +1,8 @@
 import { describe, expect, it } from 'vitest';
 
 import type { TypePath } from './typification';
-import { AnyTypificationT, basic, bool, IntegerT, tuple, type Typification } from './typification';
-import { applyPath, compareTemplated } from './typification-api';
+import { AnyTypificationT, basic, bool, IntegerT, mangleRadicalId, tuple, type Typification } from './typification';
+import { applyPath, cloneTypification, compareTemplated, substituteBase } from './typification-api';
 
 describe('applyPath', () => {
   function typePath(path: number[]): TypePath {
@@ -53,3 +53,20 @@ describe('compareTemplated', () => {
     expect(compareTemplated(substitutes, AnyTypificationT, AnyTypificationT)).toBe(true);
   });
 });
+
+describe('mangleRadicalId', () => {
+  it('qualifies template radical with function name', () => {
+    expect(mangleRadicalId('R1', 'P2')).toBe('R1<P2>');
+    expect(mangleRadicalId('R2', 'F10')).toBe('R2<F10>');
+  });
+});
+
+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 expectedType = cloneTypification(argType);
+    substituteBase(expectedType, substitutes);
+    expect(expectedType).toEqual(bool(basic('X1')));
+  });
+});

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

@@ -227,6 +227,21 @@ export function compareTemplated(
   }
 }
 
+/** Clone typification tree. */
+export function cloneTypification(type: Typification): Typification {
+  switch (type.typeID) {
+    case TypeID.anyTypification:
+    case TypeID.integer:
+      return type;
+    case TypeID.basic:
+      return { ...type };
+    case TypeID.collection:
+      return { typeID: type.typeID, base: cloneTypification(type.base) };
+    case TypeID.tuple:
+      return { typeID: type.typeID, factors: type.factors.map(cloneTypification) };
+  }
+}
+
 /** Apply substitutions to typification. */
 export function substituteBase(target: Typification, substitutes: Map<string, Typification>): void {
   switch (target.typeID) {

package/src/rslang/semantic/typification.ts

@@ -174,7 +174,17 @@ export function isTypification(type: ExpressionType | null): boolean {
   );
 }
 
-/** Checks if given type is radical. */
+/** Checks if given alias is a template or mangled radical. */
 export function isRadical(alias: string): boolean {
-  return alias.length > 0 && alias.startsWith('R') && alias[1] !== '0';
+  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);
+}
+
+/** Mangle template radical with calling function name. */
+export function mangleRadicalId(radical: string, funcName: string): string {
+  return `${radical}<${funcName}>`;
 }