Merge pull request #681 from jvalue/rfc18-implementation

Multi attribute value types (Part 1)

Author: jrentlez

libs/execution/src/lib/constraints/constraint-executor.ts

@@ -11,7 +11,7 @@ import {
   ERROR_TYPEGUARD,
   type InternalErrorValueRepresentation,
   type InternalValidValueRepresentation,
-  type ValueTypeAttribute,
+  type ValueTypeProperty,
   type ValueTypeConstraintInlineDefinition,
   evaluateExpression,
 } from '@jvalue/jayvee-language-server';
@@ -27,16 +27,19 @@ export class ConstraintExecutor<
   isValid(
     value: InternalValidValueRepresentation | InternalErrorValueRepresentation,
     context: ExecutionContext,
-    attribute: T extends ValueTypeConstraintInlineDefinition
-      ? ValueTypeAttribute
+    properties: T extends ValueTypeConstraintInlineDefinition
+      ? ValueTypeProperty[]
       : void,
   ): boolean {
     const expression = this.astNode.expression;
 
-    if (attribute === undefined) {
+    if (properties === undefined) {
       context.evaluationContext.setValueForValueKeyword(value);
     } else {
-      context.evaluationContext.setValueForReference(attribute.name, value);
+      const assignmentForTypeSystem: ValueTypeProperty[] = properties;
+      for (const property of assignmentForTypeSystem) {
+        context.evaluationContext.setValueForReference(property.name, value);
+      }
     }
 
     const result = evaluateExpression(
@@ -54,10 +57,13 @@ export class ConstraintExecutor<
       ),
     );
 
-    if (attribute === undefined) {
+    if (properties === undefined) {
       context.evaluationContext.deleteValueForValueKeyword();
     } else {
-      context.evaluationContext.deleteValueForReference(attribute.name);
+      const assignment_for_type_system: ValueTypeProperty[] = properties;
+      for (const property of assignment_for_type_system) {
+        context.evaluationContext.deleteValueForReference(property.name);
+      }
     }
 
     return result;

libs/execution/src/lib/types/value-types/internal-representation-parsing.ts

@@ -17,6 +17,7 @@ import {
   type TextValuetype,
   type ValueType,
   ValueTypeVisitor,
+  onlyElementOrUndefined,
   internalValueToString,
   isCellRangeLiteral,
 } from '@jvalue/jayvee-language-server';
@@ -104,10 +105,15 @@ class InternalRepresentationParserVisitor extends ValueTypeVisitor<
   visitAtomicValueType(
     valueType: AtomicValueType,
   ): InternalValidValueRepresentation | InvalidValue {
-    const contained = valueType.getContainedType();
-    assert(contained !== undefined);
-
-    return contained.acceptVisitor(this);
+    const containedTypes = valueType.getContainedTypes();
+    assert(containedTypes !== undefined);
+    const containedType = onlyElementOrUndefined(containedTypes);
+    if (containedType === undefined) {
+      return new InvalidValue(
+        `Cannot parse value types with multiple properties`,
+      );
+    }
+    return containedType.acceptVisitor(this);
   }
 
   visitCellRange(): InvalidValue {

libs/execution/src/lib/types/value-types/value-representation-validity.ts

@@ -45,24 +45,24 @@ class ValueRepresentationValidityVisitor extends ValueTypeVisitor<boolean> {
   }
 
   override visitAtomicValueType(valueType: AtomicValueType): boolean {
-    const contained = valueType.getContainedType();
-    assert(contained !== undefined);
-    if (!contained.acceptVisitor(this)) {
+    const containedTypes = valueType.getContainedTypes();
+    assert(containedTypes !== undefined);
+    const allPropertiesValid = containedTypes.every((containedType) =>
+      containedType.acceptVisitor(this),
+    );
+    if (!allPropertiesValid) {
       return false;
     }
 
-    const attribute = valueType.getAttribute();
-    assert(attribute !== undefined);
-    const constraints = valueType.getConstraints();
-    for (const constraint of constraints) {
+    for (const constraint of valueType.getConstraints()) {
       this.context.enterNode(constraint);
 
       const valueFulfilledConstraint = isConstraintDefinition(constraint)
         ? new ConstraintExecutor(constraint).isValid(this.value, this.context)
         : new ConstraintExecutor(constraint).isValid(
             this.value,
             this.context,
-            attribute,
+            valueType.getProperties(),
           );
 
       this.context.exitNode(constraint);

libs/execution/src/lib/types/value-types/visitors/sql-column-type-visitor.ts

@@ -7,6 +7,7 @@ import { strict as assert } from 'assert';
 
 import {
   type AtomicValueType,
+  onlyElementOrUndefined,
   ValueTypeVisitor,
 } from '@jvalue/jayvee-language-server';
 
@@ -28,9 +29,15 @@ export class SQLColumnTypeVisitor extends ValueTypeVisitor<string> {
   }
 
   override visitAtomicValueType(valueType: AtomicValueType): string {
-    const contained = valueType.getContainedType();
-    assert(contained !== undefined);
-    return contained.acceptVisitor(this);
+    const containedTypes = valueType.getContainedTypes();
+    assert(containedTypes !== undefined);
+    const containedType = onlyElementOrUndefined(containedTypes);
+    if (containedType === undefined) {
+      throw new Error(
+        'Can only determine sql column type for value types with one property',
+      );
+    }
+    return containedType.acceptVisitor(this);
   }
 
   override visitRegex(): string {

libs/execution/src/lib/types/value-types/visitors/sql-value-representation-visitor.ts

@@ -8,6 +8,7 @@ import { strict as assert } from 'assert';
 import {
   type AtomicValueType,
   type BooleanValuetype,
+  onlyElementOrUndefined,
   type DecimalValuetype,
   ERROR_TYPEGUARD,
   type IntegerValuetype,
@@ -69,9 +70,16 @@ export class SQLValueRepresentationVisitor extends ValueTypeVisitor<
   ): (
     value: InternalValidValueRepresentation | InternalErrorValueRepresentation,
   ) => string {
-    const contained = valueType.getContainedType();
-    assert(contained !== undefined);
-    return contained.acceptVisitor(this);
+    const containedTypes = valueType.getContainedTypes();
+    assert(containedTypes !== undefined);
+    const containedType = onlyElementOrUndefined(containedTypes);
+    if (containedType === undefined) {
+      throw new Error(
+        'Can only determine sql value representation for value types with one' +
+          ' property',
+      );
+    }
+    return containedType.acceptVisitor(this);
   }
 
   override visitRegex(): (

libs/language-server/src/grammar/expression.langium

@@ -88,4 +88,4 @@ Referencable:
   | BlockTypeProperty
   | TransformDefinition
   | TransformPortDefinition
-  | ValueTypeAttribute;
+  | ValueTypeProperty;

libs/language-server/src/grammar/value-type.langium

@@ -14,15 +14,18 @@ CustomValuetypeDefinition infers ValuetypeDefinition:
   'valuetype' name=ID 
     (genericDefinition=ValuetypeGenericsDefinition)?
   '{'
-    attribute=ValueTypeAttribute
-    (constraints+=ValueTypeConstraintReference | constraints+=ValueTypeConstraintInlineDefinition)*
+    properties+=ValueTypeProperty
+    (properties+=ValueTypeProperty
+    | constraints+=ValueTypeConstraintReference
+    | constraints+=ValueTypeConstraintInlineDefinition)*
   '}';
 
-ValueTypeAttribute:
+ValueTypeProperty:
   'property' name=ID 'oftype' valueType=ValueTypeReference ';';
 
 ValueTypeConstraintReference:
-  'constraint' name=ID ':' definition=[ConstraintDefinition] 'on' attribute=[ValueTypeAttribute] ';';
+  'constraint' name=ID ':' definition=[ConstraintDefinition] 'on'
+  property=[ValueTypeProperty] ';';
 
 ValueTypeConstraintInlineDefinition:
   'constraint' name=ID ':' expression=Expression ';';

libs/language-server/src/lib/ast/expressions/evaluation-context.ts

@@ -18,7 +18,7 @@ import {
   isTransformDefinition,
   isTransformPortDefinition,
   isValueKeywordLiteral,
-  isValueTypeAttribute,
+  isValueTypeProperty,
 } from '../generated/ast';
 import { type ValueTypeProvider } from '../wrappers';
 import { type ValueType } from '../wrappers/value-type/value-type';
@@ -103,11 +103,11 @@ export class EvaluationContext {
         )
       );
     }
-    if (isValueTypeAttribute(dereferenced)) {
+    if (isValueTypeProperty(dereferenced)) {
       return (
         this.variableValues.get(dereferenced.name) ??
         new MissingValue(
-          `Could not find value for value type attribute ${dereferenced.name}`,
+          `Could not find value for value type property ${dereferenced.name}`,
         )
       );
     }

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

@@ -4,6 +4,9 @@
 
 import { assertUnreachable } from 'langium';
 
+// eslint-disable-next-line unicorn/prefer-node-protocol
+import assert from 'assert';
+
 import { type ValidationContext } from '../../validation/validation-context';
 import {
   type CollectionLiteral,
@@ -31,7 +34,7 @@ import {
   isUnaryExpression,
   isValueKeywordLiteral,
   isValueLiteral,
-  isValueTypeAttribute,
+  isValueTypeProperty,
   isValuetypeAssignmentLiteral,
 } from '../generated/ast';
 import { getNextAstNodeContainer } from '../model-util';
@@ -41,10 +44,10 @@ import {
   type WrapperFactoryProvider,
 } from '../wrappers';
 import {
-  getValuetypeHierarchyStack,
   pickCommonAtomicValueType,
   pickCommonPrimitiveValuetype,
 } from '../wrappers/util/value-type-util';
+import { onlyElementOrUndefined } from '../../util';
 
 /**
  * @returns The inferred ValueType. `undefined` means that any type could be
@@ -233,23 +236,17 @@ function inferCollectionType(
     return undefined;
   }
 
-  const stacks = elementValuetypes.map(getValuetypeHierarchyStack);
-
-  if (stacks.length === 0) {
+  if (elementValuetypes.length === 0) {
     return valueTypeProvider.EmptyCollection;
   }
-  if (stacks.length === 1) {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const stack = stacks[0]!;
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const resultingInnerType = stack[stack.length - 1]!;
-    return valueTypeProvider.createCollectionValueTypeOf(resultingInnerType);
+  if (elementValuetypes.length === 1) {
+    const elementValueType = onlyElementOrUndefined(elementValuetypes);
+    assert(elementValueType !== undefined);
+    return valueTypeProvider.createCollectionValueTypeOf(elementValueType);
   }
 
-  const primitiveValuetypes = stacks.map((stack) => stack[0]);
-
   const commonPrimitiveValuetype =
-    pickCommonPrimitiveValuetype(primitiveValuetypes);
+    pickCommonPrimitiveValuetype(elementValuetypes);
 
   if (commonPrimitiveValuetype === undefined) {
     validationContext.accept(
@@ -262,7 +259,7 @@ function inferCollectionType(
     return undefined;
   }
 
-  const commonAtomicValueType = pickCommonAtomicValueType(stacks);
+  const commonAtomicValueType = pickCommonAtomicValueType(elementValuetypes);
   if (commonAtomicValueType === undefined) {
     return valueTypeProvider.createCollectionValueTypeOf(
       commonPrimitiveValuetype,
@@ -342,7 +339,7 @@ function inferTypeFromReferenceLiteral(
   if (
     isTransformPortDefinition(referenced) ||
     isBlockTypeProperty(referenced) ||
-    isValueTypeAttribute(referenced)
+    isValueTypeProperty(referenced)
   ) {
     const valueType = referenced.valueType;