improved test cases to explicitly check the resulting path

Author: JohannesMeierSE

packages/typir/test/kinds/function/operator-overloaded.test.ts

@@ -7,12 +7,12 @@
 /* eslint-disable @typescript-eslint/parameter-properties */
 
 import { beforeAll, describe, expect, test } from 'vitest';
-import { AssignmentStatement, BinaryExpression, BooleanLiteral, DoubleLiteral, InferenceRuleBinaryExpression, IntegerLiteral, StringLiteral, TestExpressionNode, Variable } from '../../../src/test/predefined-language-nodes.js';
-import { createTypirServicesForTesting, expectToBeType } from '../../../src/utils/test-utils.js';
-import { InferenceRuleNotApplicable} from '../../../src/services/inference.js';
+import { assertTrue, ConversionEdge, isAssignabilitySuccess, isPrimitiveType, isType, SubTypeEdge } from '../../../src/index.js';
+import { InferenceRuleNotApplicable } from '../../../src/services/inference.js';
 import { ValidationMessageDetails } from '../../../src/services/validation.js';
+import { AssignmentStatement, BinaryExpression, BooleanLiteral, DoubleLiteral, InferenceRuleBinaryExpression, IntegerLiteral, StringLiteral, TestExpressionNode, Variable } from '../../../src/test/predefined-language-nodes.js';
 import { TypirServices } from '../../../src/typir.js';
-import { isPrimitiveType } from '../../../src/index.js';
+import { createTypirServicesForTesting, expectToBeType } from '../../../src/utils/test-utils.js';
 
 describe('Multiple best matches for overloaded operators', () => {
     let typir: TypirServices;
@@ -35,9 +35,9 @@ describe('Multiple best matches for overloaded operators', () => {
         ], inferenceRule: InferenceRuleBinaryExpression });
 
         // define relationships between types
-        typir.Conversion.markAsConvertible(doubleType, stringType, 'IMPLICIT_EXPLICIT'); // stringVariable := doubleValue;
         typir.Conversion.markAsConvertible(booleanType, integerType, 'IMPLICIT_EXPLICIT'); // integerVariable := booleanValue;
         typir.Subtype.markAsSubType(integerType, doubleType); // double <|--- integer
+        typir.Conversion.markAsConvertible(doubleType, stringType, 'IMPLICIT_EXPLICIT'); // stringVariable := doubleValue;
 
         // specify, how Typir can detect the type of a variable
         typir.Inference.addInferenceRule(node => {
@@ -58,7 +58,7 @@ describe('Multiple best matches for overloaded operators', () => {
     });
 
 
-    describe('tests all cases for assignability', () => {
+    describe('tests all cases for assignability and the checks the found assignability paths', () => {
         test('integer to integer', () => {
             expectAssignmentValid(new IntegerLiteral(123), new IntegerLiteral(456));
         });
@@ -69,11 +69,11 @@ describe('Multiple best matches for overloaded operators', () => {
             expectAssignmentError(new StringLiteral('123'), new IntegerLiteral(456));
         });
         test('boolean to integer', () => {
-            expectAssignmentValid(new BooleanLiteral(true), new IntegerLiteral(456));
+            expectAssignmentValid(new BooleanLiteral(true), new IntegerLiteral(456), 'ConversionEdge');
         });
 
         test('integer to double', () => {
-            expectAssignmentValid(new IntegerLiteral(123), new DoubleLiteral(456.0));
+            expectAssignmentValid(new IntegerLiteral(123), new DoubleLiteral(456.0), 'SubTypeEdge');
         });
         test('double to double', () => {
             expectAssignmentValid(new DoubleLiteral(123.0), new DoubleLiteral(456.0));
@@ -82,20 +82,20 @@ describe('Multiple best matches for overloaded operators', () => {
             expectAssignmentError(new StringLiteral('123'), new DoubleLiteral(456.0));
         });
         test('boolean to double', () => {
-            expectAssignmentValid(new BooleanLiteral(true), new DoubleLiteral(456.0));
+            expectAssignmentValid(new BooleanLiteral(true), new DoubleLiteral(456.0), 'ConversionEdge', 'SubTypeEdge');
         });
 
         test('integer to string', () => {
-            expectAssignmentValid(new IntegerLiteral(123), new StringLiteral('456'));
+            expectAssignmentValid(new IntegerLiteral(123), new StringLiteral('456'), 'SubTypeEdge', 'ConversionEdge');
         });
         test('double to string', () => {
-            expectAssignmentValid(new DoubleLiteral(123.0), new StringLiteral('456'));
+            expectAssignmentValid(new DoubleLiteral(123.0), new StringLiteral('456'), 'ConversionEdge');
         });
         test('string to string', () => {
             expectAssignmentValid(new StringLiteral('123'), new StringLiteral('456'));
         });
         test('boolean to string', () => {
-            expectAssignmentValid(new BooleanLiteral(true), new StringLiteral('456'));
+            expectAssignmentValid(new BooleanLiteral(true), new StringLiteral('456'), 'ConversionEdge', 'SubTypeEdge', 'ConversionEdge');
         });
 
         test('integer to boolean', () => {
@@ -112,10 +112,34 @@ describe('Multiple best matches for overloaded operators', () => {
         });
 
 
-        function expectAssignmentValid(value: TestExpressionNode, variableInitType: TestExpressionNode): void {
+        function expectAssignmentValid(value: TestExpressionNode, variableInitType: TestExpressionNode, ...expectedPath: Array<SubTypeEdge['$relation']|ConversionEdge['$relation']>): void {
             const variable = new Variable('v1', variableInitType);
             const assignment = new AssignmentStatement(variable, value);
             expect(typir.validation.Collector.validate(assignment)).toHaveLength(0);
+
+            // do type inference
+            const valueType = typir.Inference.inferType(value);
+            assertTrue(isType(valueType));
+            const variableType = typir.Inference.inferType(variable);
+            assertTrue(isType(variableType));
+            // check the resulting assignability path
+            const assignabilityResult = typir.Assignability.getAssignabilityResult(valueType, variableType);
+            assertTrue(isAssignabilitySuccess(assignabilityResult));
+            const actualPath = assignabilityResult.path;
+            const msg = `Actual assignability path is ${actualPath.map(e => e.$relation).join(' --> ')}.`;
+            expect(actualPath.length, msg).toBe(expectedPath.length);
+            for (let i = 0; i < actualPath.length; i++) {
+                expect(actualPath[i].$relation, msg).toBe(expectedPath[i]);
+                if (i >= 1) {
+                    // the edges are connected with each other
+                    expect(actualPath[i - 1].to).toBe(actualPath[i].from);
+                }
+            }
+            // check beginning and end of the path
+            if (actualPath.length >= 1) {
+                expect(actualPath[0].from).toBe(valueType);
+                expect(actualPath[actualPath.length - 1].to).toBe(variableType);
+            }
         }
 
         function expectAssignmentError(value: TestExpressionNode, variableInitType: TestExpressionNode): void {
@@ -128,7 +152,7 @@ describe('Multiple best matches for overloaded operators', () => {
     });
 
 
-    describe('Test multiple matches for overloaded operators', () => {
+    describe('Test multiple matches for overloaded operators and ensures that the best match is chosen', () => {
         test('2 + 3 => both are integers', () => {
             expectOverload(new IntegerLiteral(2), new IntegerLiteral(3), 'integer');
         });