Merge pull request #674 from jvalue/no-structured-clone

[Refractor] Replace `structuredClone()` with a jayvee specific clone method

Author: jrentlez

libs/execution/src/lib/types/io-types/table.ts

@@ -10,6 +10,7 @@ import {
   type InternalValueRepresentation,
   type TextValuetype,
   type ValueType,
+  cloneInternalValue,
 } from '@jvalue/jayvee-language-server';
 
 import { SQLColumnTypeVisitor } from '../value-types/visitors/sql-column-type-visitor';
@@ -191,7 +192,7 @@ export class Table implements IOTypeImplementation<IOType.TABLE> {
     cloned.numberOfRows = this.numberOfRows;
     [...this.columns.entries()].forEach(([columnName, column]) => {
       cloned.addColumn(columnName, {
-        values: structuredClone(column.values),
+        values: cloneInternalValue(column.values),
         valueType: column.valueType,
       });
     });

libs/language-server/src/lib/ast/expressions/evaluators/in-operator-evaluator.ts

@@ -31,13 +31,13 @@ export class InOperatorEvaluator extends DefaultBinaryOperatorEvaluator<
 
 const isLeftOperandMatchingValueRepresentationTypeguard: InternalValueRepresentationTypeguard<
   string | number
-> = (value: InternalValueRepresentation): value is string | number => {
+> = (value) => {
   return STRING_TYPEGUARD(value) || NUMBER_TYPEGUARD(value);
 };
 
 const isRightOperandMatchingValueRepresentationTypeguard: InternalValueRepresentationTypeguard<
   (string | number)[]
-> = (value: InternalValueRepresentation): value is (string | number)[] => {
+> = (value) => {
   return (
     Array.isArray(value) &&
     value.every(isLeftOperandMatchingValueRepresentationTypeguard)

libs/language-server/src/lib/ast/expressions/internal-value-representation.ts

@@ -2,6 +2,8 @@
 //
 // SPDX-License-Identifier: AGPL-3.0-only
 
+import { assertUnreachable, isAstNode } from 'langium';
+
 import {
   type BlockTypeProperty,
   type CellRangeLiteral,
@@ -16,10 +18,11 @@ import {
 } from '../generated/ast';
 import type { WrapperFactoryProvider } from '../wrappers';
 
+import { COLLECTION_TYPEGUARD } from './typeguards';
+
 export type InternalValueRepresentation =
   | AtomicInternalValueRepresentation
-  | InternalValueRepresentation[]
-  | [];
+  | InternalValueRepresentation[];
 
 export type AtomicInternalValueRepresentation =
   | boolean
@@ -34,7 +37,7 @@ export type AtomicInternalValueRepresentation =
 
 export type InternalValueRepresentationTypeguard<
   T extends InternalValueRepresentation,
-> = (value: InternalValueRepresentation) => value is T;
+> = (value: unknown) => value is T;
 
 export function internalValueToString(
   valueRepresentation: InternalValueRepresentation,
@@ -87,7 +90,30 @@ export function internalValueToString(
   if (isBlockTypeProperty(valueRepresentation)) {
     return valueRepresentation.name;
   }
-  throw new Error(
-    'Convert of this InternalValueRepresentation is not implemented',
-  );
+  assertUnreachable(valueRepresentation);
+}
+
+export function cloneInternalValue<T extends InternalValueRepresentation>(
+  valueRepresentation: T,
+): T {
+  if (COLLECTION_TYPEGUARD(valueRepresentation)) {
+    return valueRepresentation.map(cloneInternalValue) as T;
+  }
+
+  if (
+    typeof valueRepresentation === 'boolean' ||
+    typeof valueRepresentation === 'number' ||
+    typeof valueRepresentation === 'string'
+  ) {
+    return structuredClone(valueRepresentation);
+  }
+  if (valueRepresentation instanceof RegExp) {
+    const cloned = structuredClone(valueRepresentation);
+    cloned.lastIndex = valueRepresentation.lastIndex;
+    return cloned;
+  }
+  if (isAstNode(valueRepresentation)) {
+    return valueRepresentation;
+  }
+  assertUnreachable(valueRepresentation);
 }

libs/language-server/src/lib/ast/expressions/typeguards.ts

@@ -3,57 +3,84 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 
 import {
+  type BlockTypeProperty,
+  type CellRangeLiteral,
+  type ConstraintDefinition,
+  type TransformDefinition,
   type ValuetypeAssignment,
+  isBlockTypeProperty,
+  isCellRangeLiteral,
+  isConstraintDefinition,
+  isTransformDefinition,
   isValuetypeAssignment,
 } from '../generated/ast';
 
 import {
+  type AtomicInternalValueRepresentation,
   type InternalValueRepresentation,
   type InternalValueRepresentationTypeguard,
 } from './internal-value-representation';
 
 export const INTERNAL_VALUE_REPRESENTATION_TYPEGUARD: InternalValueRepresentationTypeguard<
   InternalValueRepresentation
-> = (
-  value: InternalValueRepresentation,
-): value is InternalValueRepresentation => {
-  return true;
+> = (value): value is InternalValueRepresentation => {
+  return (
+    ATOMIC_INTERNAL_VALUE_REPRESENTATION_TYPEGUARD(value) ||
+    COLLECTION_TYPEGUARD(value)
+  );
 };
+
+export const ATOMIC_INTERNAL_VALUE_REPRESENTATION_TYPEGUARD: InternalValueRepresentationTypeguard<
+  AtomicInternalValueRepresentation
+> = (value): value is AtomicInternalValueRepresentation =>
+  BOOLEAN_TYPEGUARD(value) ||
+  NUMBER_TYPEGUARD(value) ||
+  STRING_TYPEGUARD(value) ||
+  CELLRANGELITERAL_TYPEGUARD(value) ||
+  CONSTRAINTDEFINITION_TYPEGUARD(value) ||
+  VALUETYPEASSIGNMENT_TYPEGUARD(value) ||
+  BLOCKTYPEPROPERTY_TYPEGUARD(value) ||
+  TRANSFORMDEFINITION_TYPEGUARD(value);
+
 export const NUMBER_TYPEGUARD: InternalValueRepresentationTypeguard<number> = (
-  value: InternalValueRepresentation,
-): value is number => {
-  return typeof value === 'number';
-};
+  value,
+) => typeof value === 'number';
 export const BOOLEAN_TYPEGUARD: InternalValueRepresentationTypeguard<
   boolean
-> = (value: InternalValueRepresentation): value is boolean => {
-  return typeof value === 'boolean';
-};
+> = (value) => typeof value === 'boolean';
 export const STRING_TYPEGUARD: InternalValueRepresentationTypeguard<string> = (
-  value: InternalValueRepresentation,
-): value is string => {
-  return typeof value === 'string';
-};
+  value,
+) => typeof value === 'string';
 
 export const REGEXP_TYPEGUARD: InternalValueRepresentationTypeguard<RegExp> = (
-  value: InternalValueRepresentation,
-): value is RegExp => {
-  return value instanceof RegExp;
-};
+  value,
+) => value instanceof RegExp;
+
+export const CELLRANGELITERAL_TYPEGUARD: InternalValueRepresentationTypeguard<
+  CellRangeLiteral
+> = (value) => isCellRangeLiteral(value);
+
+export const CONSTRAINTDEFINITION_TYPEGUARD: InternalValueRepresentationTypeguard<
+  ConstraintDefinition
+> = (value) => isConstraintDefinition(value);
 
 export const VALUETYPEASSIGNMENT_TYPEGUARD: InternalValueRepresentationTypeguard<
   ValuetypeAssignment
-> = (value: InternalValueRepresentation): value is ValuetypeAssignment => {
-  return isValuetypeAssignment(value);
-};
+> = (value) => isValuetypeAssignment(value);
+
+export const BLOCKTYPEPROPERTY_TYPEGUARD: InternalValueRepresentationTypeguard<
+  BlockTypeProperty
+> = (value) => isBlockTypeProperty(value);
+
+export const TRANSFORMDEFINITION_TYPEGUARD: InternalValueRepresentationTypeguard<
+  TransformDefinition
+> = (value) => isTransformDefinition(value);
 
 export const COLLECTION_TYPEGUARD: InternalValueRepresentationTypeguard<
   InternalValueRepresentation[]
-> = (
-  value: InternalValueRepresentation,
-): value is InternalValueRepresentation[] => {
-  return Array.isArray(value);
-};
+> = (value) =>
+  Array.isArray(value) &&
+  value.every((v) => INTERNAL_VALUE_REPRESENTATION_TYPEGUARD(v));
 
 export function isEveryValueDefined<T>(array: (T | undefined)[]): array is T[] {
   return array.every((value) => value !== undefined);