refactor: move nesting logic into a method

Author: jrentlez

libs/language-server/src/lib/ast/expressions/type-inference.ts

@@ -347,26 +347,14 @@ function inferTypeFromReferenceLiteral(
     isBlockTypeProperty(referenced) ||
     isValueTypeProperty(referenced)
   ) {
-    const valueType = referenced.valueType;
-
-    if (valueType === undefined) {
-      return undefined;
-    }
-    let wrappedValueType = wrapperFactories.ValueType.wrap(valueType);
-
-    if (isNestedPropertyAccess(expression)) {
-      wrappedValueType = expression.nestedAccesses.reduce(
-        (valueType, access) => {
-          const accessedProperty = isAtomicValueType(valueType)
-            ? valueType.getProperty(access)?.valueType
-            : undefined;
-          return wrapperFactories.ValueType.wrap(accessedProperty);
-        },
-        wrappedValueType,
-      );
+    const valueType = wrapperFactories.ValueType.wrap(referenced.valueType);
+    if (!isNestedPropertyAccess(expression)) {
+      return valueType;
     }
 
-    return wrappedValueType;
+    assert(isAtomicValueType(valueType));
+    const accessedProperty = valueType.getProperty(expression);
+    return wrapperFactories.ValueType.wrap(accessedProperty?.valueType);
   }
   assertUnreachable(referenced);
 }

libs/language-server/src/lib/ast/wrappers/value-type/atomic-value-type.ts

@@ -13,6 +13,8 @@ import {
   type ValueTypeConstraintInlineDefinition,
   type ValuetypeDefinition,
   isValueTypeConstraintInlineDefinition,
+  type NestedPropertyAccess,
+  isNestedPropertyAccess,
 } from '../../generated/ast';
 import { type AstNodeWrapper } from '../ast-node-wrapper';
 import { type WrapperFactoryProvider } from '../wrapper-factory-provider';
@@ -44,21 +46,32 @@ export class AtomicValueType
     return this.astNode?.properties;
   }
 
-  getProperty(name: string): ValueTypeProperty | undefined;
-  getProperty(
-    reference: Reference<ValueTypeProperty>,
-    validationContext?: ValidationContext,
-  ): ValueTypeProperty | undefined;
-  getProperty(
-    reference: string | Reference<ValueTypeProperty>,
-    validationContext?: ValidationContext,
+  private getNestedProperty(
+    nestedPropertyAccess: NestedPropertyAccess,
   ): ValueTypeProperty | undefined {
-    let propertyName: string | undefined = undefined;
+    const property = this.getProperty(nestedPropertyAccess.value);
 
+    return nestedPropertyAccess.nestedAccesses.reduce(
+      (property, propertyName) => {
+        const valueType = this.wrapperFactories.ValueType.wrap(
+          property?.valueType,
+        );
+        return isAtomicValueType(valueType)
+          ? valueType.getProperty(propertyName)
+          : undefined;
+      },
+      property,
+    );
+  }
+
+  private resolvePropertyReference(
+    reference: string | Reference<ValueTypeProperty>,
+    validationContext?: ValidationContext,
+  ): string | undefined {
     if (typeof reference === 'string') {
-      propertyName = reference;
+      return reference;
     } else if (reference.ref !== undefined) {
-      propertyName = reference.ref.name;
+      return reference.ref.name;
     } else if (
       reference.error !== undefined &&
       validationContext !== undefined
@@ -72,7 +85,29 @@ export class AtomicValueType
       }
       validationContext.accept('error', reference.error.message, info);
     }
+    return undefined;
+  }
+
+  getProperty(name: string): ValueTypeProperty | undefined;
+  getProperty(
+    reference: Reference<ValueTypeProperty>,
+    validationContext?: ValidationContext,
+  ): ValueTypeProperty | undefined;
+  getProperty(
+    nestedPropertyAccess: NestedPropertyAccess,
+  ): ValueTypeProperty | undefined;
+  getProperty(
+    reference: string | Reference<ValueTypeProperty> | NestedPropertyAccess,
+    validationContext?: ValidationContext,
+  ): ValueTypeProperty | undefined {
+    if (isNestedPropertyAccess(reference)) {
+      return this.getNestedProperty(reference);
+    }
 
+    const propertyName = this.resolvePropertyReference(
+      reference,
+      validationContext,
+    );
     return this.astNode?.properties.find(
       (property) => property.name == propertyName,
     );