Refactored LCEType and LCEValue types to constants

Author: SebastianWendorf

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

@@ -15,12 +15,13 @@ export abstract class LCEType extends LCEConcept {
  */
 export class LCETypePrimitive extends LCEType {
     public static override conceptId = "primitive-type";
+    public static readonly typeId = "primitive";
 
-    /**
+        /**
      * @param name identifier of the primitive type
      */
     constructor(public name: string) {
-        super("primitive");
+        super(LCETypePrimitive.typeId);
     }
 }
 
@@ -29,13 +30,14 @@ export class LCETypePrimitive extends LCEType {
  */
 export class LCETypeDeclared extends LCEType {
     public static override conceptId = "declared-type";
+    public static readonly typeId = "declared";
 
     /**
      * @param fqn fully qualified name of a class/interface/type alias (only uses global FQN)
      * @param typeArguments list of type arguments provided for generics
      */
     constructor(public fqn: FQN, public typeArguments: LCEType[]) {
-        super("declared");
+        super(LCETypeDeclared.typeId);
     }
 }
 
@@ -44,12 +46,13 @@ export class LCETypeDeclared extends LCEType {
  */
 export class LCETypeUnion extends LCEType {
     public static override conceptId = "union-type";
+    public static readonly typeId = "union";
 
     /**
      * @param types constituents of the union type
      */
     constructor(public types: LCEType[]) {
-        super("union");
+        super(LCETypeUnion.typeId);
     }
 }
 
@@ -58,12 +61,13 @@ export class LCETypeUnion extends LCEType {
  */
 export class LCETypeIntersection extends LCEType {
     public static override conceptId = "intersection-type";
+    public static readonly typeId = "intersection";
 
     /**
      * @param types constituents of the intersection type
      */
     constructor(public types: LCEType[]) {
-        super("intersection");
+        super(LCETypeIntersection.typeId);
     }
 }
 
@@ -72,12 +76,13 @@ export class LCETypeIntersection extends LCEType {
  */
 export class LCETypeObject extends LCEType {
     public static override conceptId = "object-type";
+    public static readonly typeId = "object";
 
     /**
      * @param members members of the object type
      */
     constructor(public members: LCETypeObjectMember[]) {
-        super("object");
+        super(LCETypeObject.typeId);
     }
 }
 
@@ -106,6 +111,7 @@ export class LCETypeObjectMember extends LCEConcept {
  */
 export class LCETypeFunction extends LCEType {
     public static override conceptId = "function-type";
+    public static readonly typeId = "function";
 
     /**
      * @param returnType return type of the function
@@ -116,7 +122,7 @@ export class LCETypeFunction extends LCEType {
                 public parameters: LCETypeFunctionParameter[],
                 public async: boolean,
                 public typeParameters: LCETypeParameterDeclaration[]) {
-        super("function");
+        super(LCETypeFunction.typeId);
     }
 }
 
@@ -142,12 +148,13 @@ export class LCETypeFunctionParameter extends LCEConcept {
  */
 export class LCETypeParameterReference extends LCEType {
     public static override conceptId = "type-parameter";
+    public static readonly typeId = "type-parameter";
 
     /**
      * @param name name of the type parameter
      */
     constructor(public name: string) {
-        super("type-parameter");
+        super(LCETypeParameterReference.typeId);
     }
 }
 
@@ -156,12 +163,13 @@ export class LCETypeParameterReference extends LCEType {
  */
 export class LCETypeLiteral extends LCEType {
     public static override conceptId = "literal-type";
+    public static readonly typeId = "literal";
 
     /**
      * @param value content of the type literal
      */
     constructor(public value: string | number | boolean) {
-        super("literal");
+        super(LCETypeLiteral.typeId);
     }
 }
 
@@ -170,12 +178,13 @@ export class LCETypeLiteral extends LCEType {
  */
 export class LCETypeTuple extends LCEType {
     public static override conceptId = "tuple-type";
+    public static readonly typeId = "tuple";
 
     /**
      * @param types types of the tuple
      */
     constructor(public types: LCEType[]) {
-        super("tuple");
+        super(LCETypeTuple.typeId);
     }
 }
 
@@ -184,11 +193,12 @@ export class LCETypeTuple extends LCEType {
  */
 export class LCETypeNotIdentified extends LCEType {
     public static override conceptId = "not-identified-type";
+    public static readonly typeId = "not-identified";
 
     /**
      * @param identifier string representation of type that could not successfully parsed
      */
     constructor(public identifier: string) {
-        super("not-identified");
+        super(LCETypeNotIdentified.typeId);
     }
 }

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

@@ -22,12 +22,14 @@ export abstract class LCEValue extends LCEConcept {
  */
 export class LCEValueNull extends LCEValue {
     public static override conceptId = "null-value";
+    public static readonly valueTypeId = "null";
+
 
     /**
      * @param kind indicates whether value is `undefined` or `null`
      */
     constructor(public kind: "undefined" | "null") {
-        super("null", new LCETypePrimitive(kind));
+        super(LCEValueNull.valueTypeId, new LCETypePrimitive(kind));
     }
 }
 
@@ -36,13 +38,14 @@ export class LCEValueNull extends LCEValue {
  */
 export class LCEValueLiteral extends LCEValue {
     public static override conceptId = "literal-value";
+    public static readonly valueTypeId = "literal";
 
     /**
      * @param value the value of the literal
      */
     constructor(public value: string | number | bigint | boolean | RegExp) {
         super(
-            "literal",
+            LCEValueLiteral.valueTypeId,
             typeof value === "object" ? new LCETypeDeclared(new FQN("RegExp"), []) : new LCETypePrimitive(typeof value)
         );
     }
@@ -53,12 +56,13 @@ export class LCEValueLiteral extends LCEValue {
  */
 export class LCEValueDeclared extends LCEValue {
     public static override conceptId = "declared-value";
+    public static readonly valueTypeId = "declared";
 
     /**
      * @param fqn fully qualified name of the referenced variable/function/class (only global Fqn is used)
      */
     constructor(type: LCEType, public fqn: FQN) {
-        super("declared", type);
+        super(LCEValueDeclared.valueTypeId, type);
     }
 }
 
@@ -67,13 +71,14 @@ export class LCEValueDeclared extends LCEValue {
  */
 export class LCEValueMember extends LCEValue {
     public static override conceptId = "member-value";
+    public static readonly valueTypeId = "member";
 
     /**
      * @param parent parent value of which a member is accessed
      * @param member member value which is accessed
      */
     constructor(type: LCEType, public parent: LCEValue, public member: LCEValue) {
-        super("member", type);
+        super(LCEValueMember.valueTypeId, type);
     }
 }
 
@@ -82,12 +87,13 @@ export class LCEValueMember extends LCEValue {
  */
 export class LCEValueObject extends LCEValue {
     public static override conceptId = "object-value";
+    public static readonly valueTypeId = "object";
 
     /**
      * @param members map of the object member's names to their respective values
      */
     constructor(type: LCEType, public members: Map<string, LCEValue>) {
-        super("object", type);
+        super(LCEValueObject.valueTypeId, type);
     }
 }
 
@@ -97,13 +103,14 @@ export class LCEValueObject extends LCEValue {
  */
 export class LCEValueObjectProperty extends LCEValue {
     public static override conceptId = "object-value-property";
+    public static readonly valueTypeId = "object-property";
 
     /**
      * @param name name of the property
      * @param value value of the property
      */
     constructor(public name: string, public value: LCEValue) {
-        super("object-property", value.type);
+        super(LCEValueObjectProperty.valueTypeId, value.type);
     }
 }
 
@@ -112,12 +119,13 @@ export class LCEValueObjectProperty extends LCEValue {
  */
 export class LCEValueArray extends LCEValue {
     public static override conceptId = "array-value";
+    public static readonly valueTypeId = "array";
 
     /**
      * @param items item values of the array
      */
     constructor(type: LCEType, public items: LCEValue[]) {
-        super("array", type);
+        super(LCEValueArray.valueTypeId, type);
     }
 }
 
@@ -126,6 +134,7 @@ export class LCEValueArray extends LCEValue {
  */
 export class LCEValueCall extends LCEValue {
     public static override conceptId = "call-value";
+    public static readonly valueTypeId = "call";
 
     /**
      * @param type return type of the call
@@ -134,7 +143,7 @@ export class LCEValueCall extends LCEValue {
      * @param typeArgs type arguments specified for call
      */
     constructor(type: LCEType, public callee: LCEValue, public args: LCEValue[], public typeArgs: LCEType[]) {
-        super("call", type);
+        super(LCEValueCall.valueTypeId, type);
     }
 }
 
@@ -143,13 +152,14 @@ export class LCEValueCall extends LCEValue {
  */
 export class LCEValueFunction extends LCEValue {
     public static override conceptId = "function-value";
+    public static readonly valueTypeId = "function";
 
     /**
      * @param type return type of the function
      * @param arrowFunction indicates whether the function is an arrow function
      */
     constructor(type: LCEType, public arrowFunction: boolean) {
-        super("function", type);
+        super(LCEValueFunction.valueTypeId, type);
     }
 }
 
@@ -158,9 +168,10 @@ export class LCEValueFunction extends LCEValue {
  */
 export class LCEValueClass extends LCEValue {
     public static override conceptId = "class-value";
+    public static readonly valueTypeId = "class";
 
     constructor() {
-        super("class", new LCETypeNotIdentified("class expression"));
+        super(LCEValueClass.valueTypeId, new LCETypeNotIdentified("class expression"));
     }
 }
 
@@ -169,12 +180,13 @@ export class LCEValueClass extends LCEValue {
  */
 export class LCEValueComplex extends LCEValue {
     public static override conceptId = "complex-value";
+    public static readonly valueTypeId = "complex";
 
     /**
      * @param expression string representation of the value's expression
      */
     constructor(public expression: string) {
-        super("complex", new LCETypeNotIdentified("complex"));
+        super(LCEValueComplex.valueTypeId, new LCETypeNotIdentified("complex"));
     }
 }