added name as identifier for nominally typed classes earlier, refacto…

…ring

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

@@ -576,7 +576,7 @@ describe('Cyclic type definitions where a Class is declared and already used', (
         expectTypirTypes(loxServices, isFunctionType, 'myMethod', ...operatorNames);
     });
 
-    test.todo('Mix of dependencies in classes: 1 method and 2 fields (order 2)', async () => {
+    test('Mix of dependencies in classes: 1 method and 2 fields (order 2)', async () => {
         await validate(`
             class A {
                 myMethod(input: number): B1 {}
@@ -592,7 +592,7 @@ describe('Cyclic type definitions where a Class is declared and already used', (
         expectTypirTypes(loxServices, isFunctionType, 'myMethod', ...operatorNames);
     });
 
-    test.todo('The same class is involved into two dependency cycles', async () => {
+    test('The same class is involved into two dependency cycles', async () => {
         await validate(`
             class A {
                 probA: C1
@@ -605,10 +605,10 @@ describe('Cyclic type definitions where a Class is declared and already used', (
                 propB1: A
             }
             class C1 {
-                methodC1(p: C2) {}
+                methodC1(p: C2): void {}
             }
             class C2 {
-                methodC2(p: A) {}
+                methodC2(p: A): void {}
             }
         `, []);
         expectTypirTypes(loxServices, isClassType, 'A', 'B1', 'B2', 'C1', 'C2');

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

@@ -61,7 +61,7 @@ export abstract class Type {
      * Identifiers might have a naming schema for calculatable values.
      */
     getIdentifier(): string {
-        this.assertStateOrLater('Identifiable');
+        // an Identifier must be available; note that the state might be 'Invalid' nevertheless, which is required to handle cyclic type definitions
         assertTrue(this.identifier !== undefined);
         return this.identifier;
     }

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

@@ -30,7 +30,9 @@ export class ClassType extends Type {
     protected methods: MethodDetails[]; // unordered
 
     constructor(kind: ClassKind, typeDetails: ClassTypeDetails) {
-        super(undefined);
+        super(kind.options.typing === 'Nominal'
+            ? kind.calculateNominalIdentifier(typeDetails) // use the name of the class as identifier already now
+            : undefined); // the identifier for structurally typed classes will be set later after resolving all fields and methods
         this.kind = kind;
         this.className = typeDetails.className;
 
@@ -527,6 +529,10 @@ export class ClassKind implements Kind {
         }
     }
 
+    calculateNominalIdentifier<T>(typeDetails: ClassTypeDetails<T>): string {
+        return this.getIdentifierPrefix() + typeDetails.className;
+    }
+
     getMethodKind(): FunctionKind {
         // ensure, that Typir uses the predefined 'function' kind for methods
         const kind = this.services.kinds.get(FunctionKindName);
@@ -565,7 +571,7 @@ export class ClassTypeInitializer<T = unknown, T1 = unknown, T2 = unknown> exten
         this.initialClassType = new ClassType(kind, typeDetails as CreateClassTypeDetails);
         if (kind.options.typing === 'Structural') {
             // register structural classes also by their names, since these names are usually used for reference in the DSL/AST!
-            this.services.graph.addNode(this.initialClassType, kind.getIdentifierPrefix() + typeDetails.className);
+            this.services.graph.addNode(this.initialClassType, kind.calculateNominalIdentifier(typeDetails));
         }
 
         this.inferenceRules = createInferenceRules<T, T1, T2>(this.typeDetails, this.kind, this.initialClassType);
@@ -591,8 +597,9 @@ export class ClassTypeInitializer<T = unknown, T1 = unknown, T2 = unknown> exten
 
             if (this.kind.options.typing === 'Structural') {
                 // replace the type in the type graph
-                this.services.graph.removeNode(classType, this.kind.getIdentifierPrefix() + this.typeDetails.className);
-                this.services.graph.addNode(readyClassType, this.kind.getIdentifierPrefix() + this.typeDetails.className);
+                const nominalIdentifier = this.kind.calculateNominalIdentifier(this.typeDetails);
+                this.services.graph.removeNode(classType, nominalIdentifier);
+                this.services.graph.addNode(readyClassType, nominalIdentifier);
             }
 
             // remove the inference rules for the invalid type