simplified code, improved comments, more test cases, renamings, some …

…more little refactorings

examples/lox/src/language/type-system/lox-type-checking.ts

@@ -211,24 +211,17 @@ export class LoxTypeCreator extends AbstractLangiumTypeCreator {
 
         // TODO support lambda (type references)!
 
-        /**
-         * TODO Delayed:
-         * - (classType: Type) => Type(for output)
-         * - WANN werden sie aufgelöst? bei erster Verwendung?
-         * - WO wird das verwaltet? im Kind? im Type? im TypeGraph?
-         */
-
         // class types (nominal typing):
         if (isClass(node)) {
             const className = node.name;
             const classType = this.classKind.createClassType({
                 className,
-                superClasses: node.superClass?.ref, // note that type inference is used here; TODO delayed
+                superClasses: node.superClass?.ref, // note that type inference is used here
                 fields: node.members
                     .filter(isFieldMember) // only Fields, no Methods
                     .map(f => <CreateFieldDetails>{
                         name: f.name,
-                        type: f.type, // note that type inference is used here; TODO delayed
+                        type: f.type, // note that type inference is used here
                     }),
                 methods: node.members
                     .filter(isMethodMember) // only Methods, no Fields

examples/lox/test/lox-type-checking.test.ts

@@ -11,6 +11,7 @@ import type { Diagnostic } from 'vscode-languageserver-types';
 import { DiagnosticSeverity } from 'vscode-languageserver-types';
 import { createLoxServices } from '../src/language/lox-module.js';
 import { deleteAllDocuments } from 'typir-langium';
+import { isClassType } from '../../../packages/typir/lib/kinds/class-kind.js';
 
 const loxServices = createLoxServices(EmptyFileSystem).Lox;
 
@@ -311,11 +312,53 @@ describe('Cyclic type definitions where a Class is declared and already used', (
         }
     `, []));
 
+    test('Two Classes with fields with the other Class as type', async () => await validate(`
+        class A {
+            prop1: B
+        }
+        class B {
+            prop2: A
+        }
+    `, []));
+
+    test.todo('Three Classes with fields with the other Class as type', async () => await validate(`
+        class A {
+            prop1: B
+        }
+        class B {
+            prop2: C
+        }
+        class C {
+            prop3: A
+        }
+    `, []));
+
     test.todo('Class with method', async () => await validate(`
         class Node {
             myMethod(input: number): Class {}
         }
     `, []));
+
+    test('Having two declarations for the delayed class A, but only one type A in the type system', async () => {
+        await validate(`
+            class A {
+                property1: B // needs to wait for B, since B is defined below
+            }
+            class A {
+                property2: B // needs to wait for B, since B is defined below
+            }
+            class B { }
+        `, [ // Typir works with this, but for LOX these validation errors are produced:
+            'Declared classes need to be unique (A).',
+            'Declared classes need to be unique (A).',
+        ]);
+        // check, that there is only one class type A in the type graph:
+        const classes = loxServices.graph.getAllRegisteredTypes().filter(t => isClassType(t)).map(t => t.getName());
+        expect(classes).toHaveLength(2);
+        expect(classes).includes('A');
+        expect(classes).includes('B');
+    });
+
 });
 
 describe('Test internal validation of Typir for cycles in the class inheritance hierarchy', () => {

packages/typir/src/features/inference.ts

@@ -49,6 +49,9 @@ type TypeInferenceResultWithInferringChildren =
  * i.e. only a single type (or no type at all) can be inferred for a given domain element.
  * There are inference rules which dependent on types of children of the given domain element (e.g. calls of overloaded functions depend on the types of the current arguments)
  * and there are inference rules without this need.
+ *
+ * Within inference rules, don't take the initialization state of the inferred type into account,
+ * since such inferrence rules might not work for cyclic type definitions.
  */
 export type TypeInferenceRule = TypeInferenceRuleWithoutInferringChildren | TypeInferenceRuleWithInferringChildren;
 

packages/typir/src/graph/type-node.ts

@@ -5,7 +5,7 @@
  ******************************************************************************/
 
 import { Kind, isKind } from '../kinds/kind.js';
-import { TypeReference, TypirProblem, WaitingForInvalidTypeReferences, WaitingForResolvedTypeReferences } from '../utils/utils-definitions.js';
+import { TypeReference, TypirProblem, WaitingForInvalidTypeReferences, WaitingForIdentifiableAndCompletedTypeReferences } from '../utils/utils-definitions.js';
 import { assertTrue, assertUnreachable } from '../utils/utils.js';
 import { TypeEdge } from './type-edge.js';
 
@@ -72,64 +72,67 @@ export abstract class Type {
 
 
 
-    protected initialization: TypeInitializationState = 'Invalid'; // TODO or Identifiable
+    // store the state of the initialization process of this type
+
+    protected initializationState: TypeInitializationState = 'Invalid';
 
     getInitializationState(): TypeInitializationState {
-        return this.initialization;
+        return this.initializationState;
     }
 
     protected assertState(expectedState: TypeInitializationState): void {
         if (this.isInState(expectedState) === false) {
-            throw new Error(`The current state of type '${this.identifier}' is ${this.initialization}, but ${expectedState} is expected.`);
+            throw new Error(`The current state of type '${this.identifier}' is ${this.initializationState}, but ${expectedState} is expected.`);
         }
     }
     protected assertNotState(expectedState: TypeInitializationState): void {
         if (this.isNotInState(expectedState) === false) {
-            throw new Error(`The current state of type '${this.identifier}' is ${this.initialization}, but this state is not expected.`);
+            throw new Error(`The current state of type '${this.identifier}' is ${this.initializationState}, but this state is not expected.`);
         }
     }
     protected assertStateOrLater(expectedState: TypeInitializationState): void {
         if (this.isInStateOrLater(expectedState) === false) {
-            throw new Error(`The current state of type '${this.identifier}' is ${this.initialization}, but this state is not expected.`);
+            throw new Error(`The current state of type '${this.identifier}' is ${this.initializationState}, but this state is not expected.`);
         }
     }
 
     isInState(state: TypeInitializationState): boolean {
-        return this.initialization === state;
+        return this.initializationState === state;
     }
     isNotInState(state: TypeInitializationState): boolean {
-        return this.initialization !== state;
+        return this.initializationState !== state;
     }
     isInStateOrLater(state: TypeInitializationState): boolean {
         switch (state) {
             case 'Invalid':
                 return true;
             case 'Identifiable':
-                return this.initialization !== 'Invalid';
+                return this.initializationState !== 'Invalid';
             case 'Completed':
-                return this.initialization === 'Completed';
+                return this.initializationState === 'Completed';
             default:
                 assertUnreachable(state);
         }
     }
 
-    // manage listeners for updated state of the current type
+
+    // manage listeners for updates of the initialization state
 
     protected stateListeners: TypeStateListener[] = [];
 
-    addListener(listener: TypeStateListener, informIfAlreadyFulfilled: boolean): void {
+    addListener(listener: TypeStateListener, informIfNotInvalidAnymore: boolean): void {
         this.stateListeners.push(listener);
-        if (informIfAlreadyFulfilled) {
+        if (informIfNotInvalidAnymore) {
             const currentState = this.getInitializationState();
             switch (currentState) {
                 case 'Invalid':
-                    // TODO?
+                    // don't inform about the Invalid state!
                     break;
                 case 'Identifiable':
                     listener.switchedToIdentifiable(this);
                     break;
                 case 'Completed':
-                    listener.switchedToIdentifiable(this);
+                    listener.switchedToIdentifiable(this); // inform about both Identifiable and Completed!
                     listener.switchedToCompleted(this);
                     break;
                 default:
@@ -145,16 +148,32 @@ export abstract class Type {
         }
     }
 
-    protected waitForIdentifiable: WaitingForResolvedTypeReferences;
-    protected waitForCompleted: WaitingForResolvedTypeReferences;
+    // initialization logic which is specific for the type to initialize
+    protected onIdentification: () => void;
+    protected onCompletion: () => void;
+    protected onInvalidation: () => void;
+
+    // internal helpers
+    protected waitForIdentifiable: WaitingForIdentifiableAndCompletedTypeReferences;
+    protected waitForCompleted: WaitingForIdentifiableAndCompletedTypeReferences;
     protected waitForInvalid: WaitingForInvalidTypeReferences;
 
-    // to be called at the end of the constructor of each specific Type implementation!
-    protected completeInitialization(preconditions: {
+    /**
+     * Use this method to specify, how THIS new type should be initialized.
+     *
+     * This method has(!) to be called at the end(!) of the constructor of each specific Type implementation, even if nothing has to be specified,
+     * since calling this method starts the initialization process!
+     * If you forget the call this method, the new type remains invalid and invisible for Typir and you will not be informed about this problem!
+     *
+     * @param preconditions all possible options for the initialization process
+     */
+    protected defineTheInitializationProcessOfThisType(preconditions: {
         preconditionsForInitialization?: PreconditionsForInitializationState,
         preconditionsForCompletion?: PreconditionsForInitializationState,
         referencesRelevantForInvalidation?: TypeReference[],
+        /** typical use cases: calculate the identifier, register inference rules for the type object already now! */
         onIdentification?: () => void,
+        /** typical use cases: do some internal checks for the completed properties */
         onCompletion?: () => void,
         onInvalidation?: () => void,
     }): void {
@@ -167,13 +186,13 @@ export abstract class Type {
             console.log('');
         }
         // preconditions for Identifiable
-        this.waitForIdentifiable = new WaitingForResolvedTypeReferences(
+        this.waitForIdentifiable = new WaitingForIdentifiableAndCompletedTypeReferences(
             preconditions.preconditionsForInitialization?.refsToBeIdentified,
             preconditions.preconditionsForInitialization?.refsToBeCompleted,
             this,
         );
         // preconditions for Completed
-        this.waitForCompleted = new WaitingForResolvedTypeReferences(
+        this.waitForCompleted = new WaitingForIdentifiableAndCompletedTypeReferences(
             preconditions.preconditionsForCompletion?.refsToBeIdentified,
             preconditions.preconditionsForCompletion?.refsToBeCompleted,
             this,
@@ -187,53 +206,54 @@ export abstract class Type {
         this.waitForIdentifiable.addListener(() => {
             this.switchFromInvalidToIdentifiable();
             if (this.waitForCompleted.isFulfilled()) {
-                // this is required to ensure the stric order Identifiable --> Completed, since 'init2' might already be triggered
+                // this is required to ensure the stric order Identifiable --> Completed, since 'waitForCompleted' might already be triggered
                 this.switchFromIdentifiableToCompleted();
             }
-        }, true);
+        }, true); // 'true' triggers the initialization process!
         // identifiable --> completed
         this.waitForCompleted.addListener(() => {
             if (this.waitForIdentifiable.isFulfilled()) {
                 this.switchFromIdentifiableToCompleted();
             } else {
-                // switching will be done later by 'init1' in order to conform to the stric order Identifiable --> Completed
+                // switching will be done later by 'waitForIdentifiable' in order to conform to the stric order Identifiable --> Completed
             }
-        }, false); // not required, since init1 will switch to Completed as well!
+        }, false); // not required, since 'waitForIdentifiable' will switch to Completed as well!
         // identifiable/completed --> invalid
         this.waitForInvalid.addListener(() => {
             if (this.isNotInState('Invalid')) {
                 this.switchFromCompleteOrIdentifiableToInvalid();
             }
-        }, false); // no initial trigger!
+        }, false); // no initial trigger, since 'Invalid' is the initial state
     }
 
+    /**
+     * This is an internal method to ignore some types during the initialization process in order to prevent dependency cycles.
+     * Usually there is no need to call this method on your own.
+     * @param additionalTypesToIgnore the new types to ignore during
+     */
     ignoreDependingTypesDuringInitialization(additionalTypesToIgnore: Set<Type>): void {
         this.waitForIdentifiable.addTypesToIgnoreForCycles(additionalTypesToIgnore);
         this.waitForCompleted.addTypesToIgnoreForCycles(additionalTypesToIgnore);
     }
 
-    protected onIdentification: () => void; // typical use cases: calculate the identifier
-    protected onCompletion: () => void; // typical use cases: determine all properties which depend on other types to be created
-    protected onInvalidation: () => void; // TODO ist jetzt anders; typical use cases: register inference rules for the type object already now!
-
     protected switchFromInvalidToIdentifiable(): void {
         this.assertState('Invalid');
         this.onIdentification();
-        this.initialization = 'Identifiable';
+        this.initializationState = 'Identifiable';
         this.stateListeners.slice().forEach(listener => listener.switchedToIdentifiable(this)); // slice() prevents issues with removal of listeners during notifications
     }
 
     protected switchFromIdentifiableToCompleted(): void {
         this.assertState('Identifiable');
         this.onCompletion();
-        this.initialization = 'Completed';
+        this.initializationState = 'Completed';
         this.stateListeners.slice().forEach(listener => listener.switchedToCompleted(this)); // slice() prevents issues with removal of listeners during notifications
     }
 
     protected switchFromCompleteOrIdentifiableToInvalid(): void {
         this.assertNotState('Invalid');
         this.onInvalidation();
-        this.initialization = 'Invalid';
+        this.initializationState = 'Invalid';
         this.stateListeners.slice().forEach(listener => listener.switchedToInvalid(this)); // slice() prevents issues with removal of listeners during notifications
     }
 
@@ -355,4 +375,3 @@ export interface TypeStateListener {
     switchedToIdentifiable(type: Type): void;
     switchedToCompleted(type: Type): void;
 }
-// TODO brauchen wir das überhaupt? stattdessen in TypeReference direkt realisieren?

packages/typir/src/kinds/bottom-kind.ts

@@ -20,7 +20,7 @@ export class BottomType extends Type {
     constructor(kind: BottomKind, identifier: string) {
         super(identifier);
         this.kind = kind;
-        this.completeInitialization({}); // no preconditions
+        this.defineTheInitializationProcessOfThisType({}); // no preconditions
     }
 
     override getName(): string {

packages/typir/src/kinds/class-kind.ts

@@ -20,7 +20,6 @@ import { TypeInitializer } from '../utils/type-initialization.js';
 
 // TODO irgendwann die Dateien auseinander ziehen und Packages einführen!
 
-// TODO wenn die Initialisierung von ClassType abgeschlossen ist, sollte darüber aktiv benachrichtigt werden!
 export class ClassType extends Type {
     override readonly kind: ClassKind;
     readonly className: string;
@@ -79,12 +78,12 @@ export class ClassType extends Type {
         fieldsAndMethods.push(...(refMethods as unknown as Array<TypeReference<Type>>)); // TODO dirty hack?!
         // all.push(...refMethods); // does not work
 
-        this.completeInitialization({
+        this.defineTheInitializationProcessOfThisType({
             preconditionsForInitialization: {
                 refsToBeIdentified: fieldsAndMethods,
             },
             preconditionsForCompletion: {
-                refsToBeCompleted: this.superClasses as unknown as Array<TypeReference<Type>>, // TODO here we are waiting for the same/current (identifiable) ClassType!!
+                refsToBeCompleted: this.superClasses as unknown as Array<TypeReference<Type>>,
             },
             referencesRelevantForInvalidation: [...fieldsAndMethods, ...(this.superClasses as unknown as Array<TypeReference<Type>>)],
             onIdentification: () => {
@@ -554,7 +553,6 @@ export class ClassTypeInitializer<T = unknown, T1 = unknown, T2 = unknown> exten
         if (kind.options.typing === 'Structural') {
             // TODO Vorsicht Inference rules werden by default an den Identifier gebunden (ebenso Validations)!
             this.services.graph.addNode(classType, kind.getIdentifierPrefix() + typeDetails.className);
-            // TODO hinterher wieder abmelden, wenn Type invalid geworden ist bzw. ein anderer Type gewonnen hat? bzw. gewinnt immer der erste Type?
         }
 
         classType.addListener(this, true); // trigger directly, if some initialization states are already reached!
@@ -568,6 +566,13 @@ export class ClassTypeInitializer<T = unknown, T1 = unknown, T2 = unknown> exten
          */
         const readyClassType = this.producedType(classType as ClassType);
 
+        // remove/invalidate the duplicated and skipped class type now
+        if (readyClassType !== classType) {
+            if (this.kind.options.typing === 'Structural') {
+                this.services.graph.removeNode(classType, this.kind.getIdentifierPrefix() + this.typeDetails.className);
+            }
+        }
+
         // register inference rules
         registerInferenceRules<T, T1, T2>(this.services, this.typeDetails, this.kind, readyClassType);
 

packages/typir/src/kinds/fixed-parameters-kind.ts

@@ -49,7 +49,7 @@ export class FixedParameterType extends Type {
                 type: typeValues[i],
             });
         }
-        this.completeInitialization({}); // TODO preconditions
+        this.defineTheInitializationProcessOfThisType({}); // TODO preconditions
     }
 
     getParameterTypes(): Type[] {

packages/typir/src/kinds/function-kind.ts

@@ -52,7 +52,7 @@ export class FunctionType extends Type {
             };
         });
 
-        this.completeInitialization({}); // TODO preconditions
+        this.defineTheInitializationProcessOfThisType({}); // TODO preconditions
     }
 
     override getName(): string {

packages/typir/src/kinds/multiplicity-kind.ts

@@ -26,7 +26,7 @@ export class MultiplicityType extends Type {
         this.constrainedType = constrainedType;
         this.lowerBound = lowerBound;
         this.upperBound = upperBound;
-        this.completeInitialization({}); // TODO preconditions
+        this.defineTheInitializationProcessOfThisType({}); // TODO preconditions
     }
 
     override getName(): string {