add DeepPartialAstNode utility (#1875)

Author: ydaveluy

packages/langium/src/utils/ast-utils.ts

@@ -301,3 +301,30 @@ export function copyAstNode<T extends AstNode = AstNode>(node: T, buildReference
     linkContentToContainer(copy);
     return copy as unknown as T;
 }
+
+/**
+ * Recursively makes all properties of an AstNode optional, except for those
+ * that start with a dollar sign ($) or are of type boolean or are of type array.
+ * If the type is a Reference or an Array, it applies the transformation recursively
+ * to the inner type.
+ * Otherwise the type is returned as is.
+ *
+ * @template T - The type to be transformed.
+*/
+export type DeepPartialAstNode<T> =
+    // if T is a Reference<U> transform it to Reference<DeepPartialAstNode<U>>
+    T extends Reference<infer U extends AstNode> ? Reference<DeepPartialAstNode<U>> :
+        // if T is an AstNode
+        T extends AstNode ? {
+            // transform the type of each property starting with '$' or with a boolean or array type
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            [K in keyof T as K extends `$${string}` | (T[K] extends (boolean | any[]) ? K : never) ? K : never]: DeepPartialAstNode<T[K]>;
+        } & {
+            // force the property as optional and transform its type for each property not starting with '$' or with a type different from boolean or array type
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            [K in keyof T as K extends `$${string}` ? never: T[K] extends (boolean | any[]) ? never : K]?: DeepPartialAstNode<T[K]>;
+        } :
+            // if T is an Array<U> convert to Array<DeepPartialAstNode<U>>
+            T extends Array<infer U> ? Array<DeepPartialAstNode<U>> :
+                // otherwise keep T as is
+                T;

packages/langium/test/utils/ast-utils.test.ts

@@ -5,9 +5,61 @@
  ******************************************************************************/
 
 import { describe, expect, test } from 'vitest';
+import type { AstNode, Reference } from 'langium';
 import { AstUtils, EmptyFileSystem, GrammarAST } from 'langium';
 import { createLangiumGrammarServices } from 'langium/grammar';
 
+interface TestNode extends AstNode {
+    readonly $type: 'MyType';
+    readonly $container?: TestNode;
+    str: string;
+    strArr: string[]
+    optStr?: string;
+    optStrArr?: string[];
+    bool: boolean;
+    boolArr: boolean[];
+    optBool?: boolean;
+    optBoolArr?: boolean[];
+    int: number;
+    intArr: number[];
+    optInt?: number;
+    optIntArr?: number[];
+    ref: Reference<TestNode>;
+    refArr: Array<Reference<TestNode>>;
+    optRef?: Reference<TestNode>;
+    optRefArr?: Array<Reference<TestNode>>;
+    ctn: TestNode;
+    ctnArr: TestNode[];
+    optCtn?: TestNode;
+    optCtnArr?: PartialTestNode[];
+}
+
+interface PartialTestNode extends AstNode {
+    readonly $type: 'MyType';
+    readonly $container?: PartialTestNode;
+    str?: string;
+    strArr: string[]
+    optStr?: string;
+    optStrArr?: string[];
+    bool: boolean;
+    boolArr: boolean[];
+    optBool?: boolean;
+    optBoolArr?: boolean[];
+    int?: number;
+    intArr: number[];
+    optInt?: number;
+    optIntArr?: number[];
+    ref?: Reference<PartialTestNode>;
+    refArr: Array<Reference<PartialTestNode>>;
+    optRef?: Reference<PartialTestNode>;
+    optRefArr?: Array<Reference<PartialTestNode>>;
+    ctn?: PartialTestNode;
+    ctnArr: PartialTestNode[];
+    optCtn?: PartialTestNode;
+    optCtnArr?: PartialTestNode[];
+}
+export const expectType = <Type>(_: Type): void => void 0;
+
 describe('AST Utils', () => {
 
     test('Streaming ast works with range', () => {
@@ -41,4 +93,9 @@ describe('AST Utils', () => {
         expect(names).toEqual(['OverlapBefore', 'Inside', 'OverlapAfter']);
     });
 
+    test('should transform DeepPartialAstNode<TestNode> to PartialTestNode', () => {
+        type ResultType = AstUtils.DeepPartialAstNode<TestNode>;
+        expectType<PartialTestNode>((null as unknown) as ResultType);
+        expectType<ResultType>((null as unknown) as PartialTestNode);
+    });
 });