Refactored fixed LCETypeNotIdentified types to constants

Author: SebastianWendorf

typescript/src/core/concepts/type.concept.ts

@@ -195,8 +195,15 @@ export class LCETypeNotIdentified extends LCEType {
     public static override conceptId = "not-identified-type";
     public static readonly typeId = "not-identified";
 
+    public static readonly COMPLEX_VALUE = new this("Complex Value");
+    public static readonly CLASS_EXPRESSION = new this("Class Expression");
+    public static readonly CONSTRUCTOR = new this("Constructor");
+    public static readonly SETTER = new this("Setter");
+    public static readonly INDEXED_ACCESS_TYPE = new this("Type containing a (potentially recursive) indexed access type");
+    public static readonly DEEP_PARTIAL_OBJECT = new this("Type containing DeepPartialObject (not supported)");
+
     /**
-     * @param identifier string representation of type that could not successfully parsed
+     * @param identifier string representation of type that could not successfully be parsed
      */
     constructor(public identifier: string) {
         super(LCETypeNotIdentified.typeId);

typescript/src/core/concepts/value.concept.ts

@@ -171,7 +171,7 @@ export class LCEValueClass extends LCEValue {
     public static readonly valueTypeId = "class";
 
     constructor() {
-        super(LCEValueClass.valueTypeId, new LCETypeNotIdentified("class expression"));
+        super(LCEValueClass.valueTypeId, LCETypeNotIdentified.CLASS_EXPRESSION);
     }
 }
 
@@ -186,7 +186,7 @@ export class LCEValueComplex extends LCEValue {
      * @param expression string representation of the value's expression
      */
     constructor(public expression: string) {
-        super(LCEValueComplex.valueTypeId, new LCETypeNotIdentified("complex"));
+        super(LCEValueComplex.valueTypeId, LCETypeNotIdentified.COMPLEX_VALUE);
     }
 }
 

typescript/src/core/processors/class-like-declaration.processor.ts

@@ -320,7 +320,7 @@ export class PropertyProcessor extends Processor {
             // indexed access type check to prevent infinite recursion on native type parsing
             const isIndexedAccessType = getAndDeleteChildConcepts<LCEIndexAccessTypeAnnotation>(PropertyTraverser.TYPE_ANNOTATION_PROP, LCEIndexAccessTypeAnnotation.conceptId, childConcepts).length > 0;
             const type = isIndexedAccessType ?
-                new LCETypeNotIdentified("Type contains indexed access type (potentially recursive)") :
+                LCETypeNotIdentified.INDEXED_ACCESS_TYPE :
                 parseClassPropertyType({ globalContext, localContexts, node, ...unusedProcessingContext }, node.key);
 
             return mergeConceptMaps(

typescript/src/core/processors/type.utils.ts

@@ -129,7 +129,7 @@ export function parseMethodType(
                     )
                 );
             }
-            return new LCETypeFunction(new LCETypeNotIdentified("constructor"), parameters, false, []);
+            return new LCETypeFunction(LCETypeNotIdentified.CONSTRUCTOR, parameters, false, []);
         } else if (esMethodDecl.kind === "get") {
             // getter
             return new LCETypeFunction(parseType(processingContext, methodType, methodNode), [], false, []);
@@ -140,7 +140,7 @@ export function parseMethodType(
             const paramNode = globalContext.services.esTreeNodeToTSNodeMap.get(param);
             const paramType = tc.getTypeAtLocation(paramNode);
             return new LCETypeFunction(
-                new LCETypeNotIdentified("setter"),
+                LCETypeNotIdentified.SETTER,
                 [new LCETypeFunctionParameter(0, paramName, false, parseType(processingContext, paramType, methodNode))],
                 false,
                 []
@@ -337,7 +337,7 @@ function parseType(processingContext: ProcessingContext, type: Type, node: Node,
         ) {
             // TODO: handle recursive types like `_DeepPartialObject`
             if (type.aliasSymbol?.getName() === "_DeepPartialObject") {
-                return new LCETypeNotIdentified("DeepPartialObject is not supported");
+                return LCETypeNotIdentified.DEEP_PARTIAL_OBJECT;
             }
 
             // anonymous type

typescript/test/core/integration/interface-declarations.test.ts

@@ -521,7 +521,7 @@ describe("interface declarations test", () => {
             );
             expect(propA.type).toBeDefined();
             expect(propA.type.type).toBe(LCETypeNotIdentified.typeId);
-            expect((propA.type as LCETypeNotIdentified).identifier).toBe("Type contains indexed access type (potentially recursive)");
+            expect((propA.type as LCETypeNotIdentified).identifier).toBe(LCETypeNotIdentified.INDEXED_ACCESS_TYPE.identifier);
 
             // The following would represent a correct check with full type tracing: (TODO: implement fine-grained indexed access type resolution)
             // const propAObjType = expectObjectType(propA.type, 3);
@@ -556,7 +556,7 @@ describe("interface declarations test", () => {
             );
             expect(propB.type).toBeDefined();
             expect(propB.type.type).toBe(LCETypeNotIdentified.typeId);
-            expect((propB.type as LCETypeNotIdentified).identifier).toBe("Type contains indexed access type (potentially recursive)");
+            expect((propB.type as LCETypeNotIdentified).identifier).toBe(LCETypeNotIdentified.INDEXED_ACCESS_TYPE.identifier);
 
             // The following would represent a correct check with full type tracing:
             // const propBObjType = expectObjectType(propB.type, 3);

typescript/test/core/integration/variable-declarations.test.ts

@@ -463,7 +463,7 @@ describe("variable declarations test", () => {
 
                 expect(decl.initValue.type).toBeDefined();
                 expect(decl.initValue.type.type).toBe(LCETypeNotIdentified.typeId);
-                expect((decl.initValue.type as LCETypeNotIdentified).identifier).toBe("class expression");
+                expect((decl.initValue.type as LCETypeNotIdentified).identifier).toBe(LCETypeNotIdentified.CLASS_EXPRESSION.identifier);
             }
         }
     });
@@ -555,7 +555,7 @@ describe("variable declarations test", () => {
 
                 expect(decl.initValue.type).toBeDefined();
                 expect(decl.initValue.type.type).toBe(LCETypeNotIdentified.typeId);
-                expect((decl.initValue.type as LCETypeNotIdentified).identifier).toBe("complex");
+                expect((decl.initValue.type as LCETypeNotIdentified).identifier).toBe(LCETypeNotIdentified.COMPLEX_VALUE.identifier);
             }
         }
     });
@@ -736,7 +736,7 @@ describe("variable declarations test", () => {
 
                 expect(decl.initValue.type).toBeDefined();
                 expect(decl.initValue.type.type).toBe(LCETypeNotIdentified.typeId);
-                expect((decl.initValue.type as LCETypeNotIdentified).identifier).toBe("complex");
+                expect((decl.initValue.type as LCETypeNotIdentified).identifier).toBe(LCETypeNotIdentified.COMPLEX_VALUE.identifier);
             }
         }
 
@@ -874,7 +874,7 @@ describe("variable declarations test", () => {
 
                 expect(decl.initValue.type).toBeDefined();
                 expect(decl.initValue.type.type).toBe(LCETypeNotIdentified.typeId);
-                expect((decl.initValue.type as LCETypeNotIdentified).identifier).toBe("complex");
+                expect((decl.initValue.type as LCETypeNotIdentified).identifier).toBe(LCETypeNotIdentified.COMPLEX_VALUE.identifier);
             }
         }