@idlizer/arktscgen 2.1.10-arktscgen-4 → 2.1.10-arktscgen-6

package/build/libarkts-copy/src/InteropNativeModule.ts

@@ -17,37 +17,40 @@ import {
     KNativePointer as KPtr,
     KInt,
     registerNativeModuleLibraryName,
-    loadNativeModuleLibrary
-} from "@koalaui/interop"
-import { findNativeModule } from "./Es2pandaNativeModule"
+    loadNativeModuleLibrary,
+} from '@koalaui/interop';
+import { findNativeModule } from './Es2pandaNativeModule';
 
 export class InteropNativeModule {
     _StringLength(ptr: KPtr): KInt {
-        throw new Error("Not implemented")
+        throw new Error('Not implemented');
     }
     _StringData(ptr: KPtr, buffer: KPtr, length: KInt): void {
-        throw new Error("Not implemented")
+        throw new Error('Not implemented');
     }
     _GetStringFinalizer(): KPtr {
-        throw new Error("Not implemented")
+        throw new Error('Not implemented');
     }
-    _RawUtf8ToString(ptr: KPtr): string  {
-        throw new Error("Not implemented")
+    _RawUtf8ToString(ptr: KPtr): string {
+        throw new Error('Not implemented');
     }
     _InvokeFinalizer(ptr: KPtr, finalizer: KPtr): void {
-        throw new Error("Not implemented")
+        throw new Error('Not implemented');
+    }
+    _GetPtrVector(ptr: KPtr): BigUint64Array {
+        throw new Error('Not implemented');
     }
     _GetPtrVectorSize(ptr: KPtr): KInt {
-        throw new Error("Not implemented")
+        throw new Error('Not implemented');
     }
     _GetPtrVectorElement(ptr: KPtr, index: KInt): KPtr {
-        throw new Error("Not implemented")
+        throw new Error('Not implemented');
     }
 }
 
 export function initInterop(): InteropNativeModule {
-    registerNativeModuleLibraryName("InteropNativeModule", findNativeModule())
-    const instance = new InteropNativeModule()
-    loadNativeModuleLibrary("InteropNativeModule", instance)
-    return instance
+    registerNativeModuleLibraryName('InteropNativeModule', findNativeModule());
+    const instance = new InteropNativeModule();
+    loadNativeModuleLibrary('InteropNativeModule', instance);
+    return instance;
 }

package/build/libarkts-copy/src/arkts-api/AbstractVisitor.ts

@@ -13,38 +13,43 @@
  * limitations under the License.
  */
 
-import { AstNode } from "./peers/AstNode"
-import { visitEachChild } from "./visitor"
-import { Program } from "../generated"
+import { AstNode } from './peers/AstNode';
+import { visitEachChild } from './visitor';
+import { Program } from '../../generated';
 
 export interface VisitorOptions {
-    program?: Program
+    program?: Program;
 }
 
 export abstract class AbstractVisitor {
-    public program?: Program
+    public program?: Program;
 
     constructor(options?: VisitorOptions) {
         this.program = options?.program;
     }
 
-    indentation = 0
+    indentation = 0;
 
-    withIndentation<T>(exec: () => T) {
-        this.indentation++
-        const result = exec()
-        this.indentation--
-        return result
+    withIndentation<T>(exec: () => T): T {
+        this.indentation++;
+        const result = exec();
+        this.indentation--;
+        return result;
     }
 
-    abstract visitor(node: AstNode, options?: object): AstNode
+    process(node: AstNode, options?: any): AstNode {
+        return this.visitor(node, options);
+    }
+
+    init(): void {}
+
+    reset(): void {
+        this.indentation = 0;
+    }
+
+    abstract visitor(node: AstNode, options?: any): AstNode;
 
-    visitEachChild(node: AstNode, options?: object): AstNode {
-        return this.withIndentation(() =>
-            visitEachChild(
-                node,
-                it => this.visitor(it, options)
-            )
-        )
+    visitEachChild(node: AstNode, options?: any): AstNode {
+        return this.withIndentation((): AstNode => visitEachChild(node, (it): AstNode => this.visitor(it, options)));
     }
 }

package/build/libarkts-copy/src/arkts-api/ImportStorage.ts

@@ -13,41 +13,44 @@
  * limitations under the License.
  */
 
-import { KNativePointer } from "@koalaui/interop"
-import { ETSModule, ImportDeclaration, isETSImportDeclaration, Program, Statement } from "../generated"
-import { passNode, passNodeArray, unpackNonNullableNode } from "./utilities/private"
-import { global } from "./static/global"
-import { Es2pandaImportFlags, Es2pandaImportKinds } from "../generated/Es2pandaEnums"
-import { factory } from "./factory/nodeFactory"
+import { KNativePointer } from '@koalaui/interop';
+import { ETSModule, ImportDeclaration, isETSImportDeclaration, Program, Statement } from '../../generated';
+import { passNode, passNodeArray, unpackNonNullableNode } from './utilities/private';
+import { global } from './static/global';
+import { Es2pandaImportFlags, Es2pandaImportKinds } from '../../generated/Es2pandaEnums';
+import { factory } from './factory/nodeFactory';
 
 export class ImportStorage {
     // Improve: migrate to wrappers instead of pointers
-    private imports: Set<KNativePointer> = new Set<KNativePointer>()
-    private importSources: Set<string | undefined> = new Set<string | undefined>()
+    private imports: Set<KNativePointer> = new Set<KNativePointer>();
+    private importSources: Set<string | undefined> = new Set<string | undefined>();
 
-    constructor(private program: Program, private isParserState: boolean) {
+    constructor(
+        private program: Program,
+        private isParserState: boolean
+    ) {
         for (const statement of program.ast.statements) {
             if (isETSImportDeclaration(statement)) {
-                this.imports.add(statement.peer)
+                this.imports.add(statement.peer);
                 if (!isParserState) {
                     // Improve: is source non nullable?
-                    this.importSources.add(statement.source?.str)
+                    this.importSources.add(statement.source?.str);
                 }
             }
         }
     }
 
-    update() {
+    update(): void {
         // Save current statements
-        const statements = this.program.ast.statements
+        const statements = this.program.ast.statements;
 
         // Update parser information
-        const newStatements: Statement[] = []
+        const newStatements: Statement[] = [];
         for (const statement of statements) {
             if (isETSImportDeclaration(statement) && !this.imports.has(statement.peer)) {
                 if (!this.isParserState && !this.importSources.has(statement.source?.str)) {
-                    console.warn("Attempt to insert import from new source after parsed state:")
-                    console.warn(statement.dumpSrc())
+                    console.warn('Attempt to insert import from new source after parsed state:');
+                    console.warn(statement.dumpSrc());
                 }
 
                 const importDeclaration = unpackNonNullableNode<ImportDeclaration>(
@@ -59,26 +62,22 @@ export class ImportStorage {
                         statement.specifiers.length,
                         passNode(statement.source),
                         this.program.peer,
-                        Es2pandaImportFlags.IMPORT_FLAGS_NONE, // Improve: where to get it?
+                        Es2pandaImportFlags.IMPORT_FLAGS_NONE // Improve: where to get it?
                     )
-                )
-                global.generatedEs2panda._InsertETSImportDeclarationAndParse(global.context, this.program.peer, importDeclaration.peer)
-                newStatements.push(importDeclaration)
+                );
+                global.generatedEs2panda._InsertETSImportDeclarationAndParse(
+                    global.context,
+                    this.program.peer,
+                    importDeclaration.peer
+                );
+                newStatements.push(importDeclaration);
             } else {
-                newStatements.push(statement)
+                newStatements.push(statement);
             }
         }
 
         // Drop import statements generated by compiler in the beginning of the ETSModule
-        const module = this.program.ast as ETSModule
-        this.program.setAst(
-            factory.updateETSModule(
-                module,
-                newStatements,
-                module.ident,
-                module.getNamespaceFlag(),
-                module.program,
-            )
-        )
+        const module = this.program.getAstCasted()
+        module.setStatements(newStatements)
     }
 }

package/build/libarkts-copy/src/arkts-api/ProgramProvider.ts

@@ -13,38 +13,50 @@
  * limitations under the License.
  */
 
-import { KNativePointer } from "@koalaui/interop"
-import { defaultFilter, listPrograms } from "./plugins"
-import { Program } from "../generated"
+import { KNativePointer } from '@koalaui/interop';
+import { defaultFilter, listPrograms } from './plugins';
+import { Program } from '../../generated';
 
 export class ProgramProvider {
-    // Improve: migrate to wrappers instead of pointers
-    seenPrograms: Set<KNativePointer> = new Set<KNativePointer>()
-    queue: Program[] = []
+    static programListCache: Map<string, Program[]> = new Map();
+    programListFromCache?: Program[];
+    seenPrograms: Set<KNativePointer> = new Set<KNativePointer>();
+    queue: Program[] = [];
 
-    constructor(private mainProgram: Program, private readonly filter: (name: string) => boolean = defaultFilter) {
-        this.seenPrograms.add(mainProgram.peer)
-        this.queue = [mainProgram]
+    constructor(
+        private readonly mainProgram: Program,
+        private readonly stableDeps: boolean = false,
+        private readonly filter: (name: string) => boolean = defaultFilter,
+    ) {
+        this.seenPrograms.add(mainProgram.peer);
+        if (!stableDeps || !ProgramProvider.programListCache.has(mainProgram.absoluteName)) {
+            this.programListFromCache = [mainProgram]
+            ProgramProvider.programListCache.set(mainProgram.absoluteName, this.programListFromCache)
+        } else {
+            this.programListFromCache = ProgramProvider.programListCache.get(mainProgram.absoluteName)
+        }
+        this.queue = [...this.programListFromCache!]
     }
 
-    updateQueue() {
-        const listed = listPrograms(this.mainProgram, this.filter)
+    updateQueue(): void {
+        const listed = listPrograms(this.mainProgram, this.filter);
         for (const program of listed) {
             if (!this.seenPrograms.has(program.peer)) {
-                this.seenPrograms.add(program.peer)
-                this.queue.push(program)
+                this.seenPrograms.add(program.peer);
+                this.programListFromCache?.push(program)
+                this.queue.push(program);
             }
         }
     }
 
     next(): Program | undefined {
-        if (this.queue.length == 0) {
-            this.updateQueue()
-            if (this.queue.length == 0) {
+        if (this.queue.length === 0 && (!this.stableDeps || this.programListFromCache?.length == 1)) {
+            this.updateQueue();
+            if (this.queue.length === 0) {
                 // console.log("PROGRAMS:", this.seenPrograms.size)
-                return undefined
+                return undefined;
             }
         }
-        return this.queue.shift()
+        return this.queue.shift();
     }
 }

package/build/libarkts-copy/src/arkts-api/class-by-peer.ts

@@ -13,21 +13,39 @@
  * limitations under the License.
  */
 
-import { Es2pandaAstNodeType } from "../generated/Es2pandaEnums"
-import { throwError } from "../utils"
-import { global } from "./static/global"
-import { KNativePointer } from "@koalaui/interop"
-import { AstNode } from "./peers/AstNode"
-import { NodeCache } from "./node-cache"
+import { Es2pandaAstNodeType } from '../../generated/Es2pandaEnums';
+import { throwError } from '../utils';
+import { global } from './static/global';
+import { KNativePointer } from '@koalaui/interop';
+import { AstNode } from './peers/AstNode';
+import { NodeCache } from './node-cache';
 
-export const nodeByType = new Map<Es2pandaAstNodeType, (peer: KNativePointer) => AstNode>([])
+export const nodeByType = new Map<Es2pandaAstNodeType, (peer: KNativePointer) => AstNode>([]);
+
+// TODO: These node types are "specially mapped" in the compiler, they don't have C++ classes
+// See AST_NODE_REINTERPRET_MAPPING in the compiler source
+// Do we need managed wrappers for them? Need to investigate.
+export function nodeTypeFilter(type: Es2pandaAstNodeType): Es2pandaAstNodeType {
+    switch (type) {
+        case Es2pandaAstNodeType.AST_NODE_TYPE_REST_ELEMENT:
+            return Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT
+        case Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_PATTERN:
+            return Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION
+        case Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_PATTERN:
+            return Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION
+        case Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_PATTERN:
+            return Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION
+    }
+    return type
+}
 
 export function nodeFrom<T extends AstNode>(peer: KNativePointer, typeHint?: Es2pandaAstNodeType): T {
-    const fromCache = NodeCache.get<T>(peer)
+    const fromCache = NodeCache.get<T>(peer);
     if (fromCache) {
-        return fromCache
+        return fromCache;
     }
-    const type = typeHint ?? global.generatedEs2panda._AstNodeTypeConst(global.context, peer)
-    const create = nodeByType.get(type) ?? throwError(`unknown node type: ${type}`)
-    return create(peer) as T
+
+    const type = nodeTypeFilter(typeHint ?? global.generatedEs2panda._AstNodeTypeConst(global.context, peer))
+    const create = nodeByType.get(type) ?? throwError(`unknown node type: ${type}`);
+    return create(peer) as T;
 }

package/build/libarkts-copy/src/arkts-api/factory/nodeFactory.ts

@@ -24,41 +24,49 @@ import {
     ETSStructDeclaration,
     ETSTuple,
     ETSTypeReferencePart,
+    Identifier,
     MemberExpression,
     ObjectExpression,
     TryStatement,
     TSTypeParameter,
     VariableDeclarator,
-} from "../../generated"
-import { factory as generatedFactory } from "../../generated/factory"
-import { createScriptFunction, inplaceUpdateScriptFunction, updateScriptFunction } from "../node-utilities/ScriptFunction"
-import { inplaceUpdateCallExpression, updateCallExpression } from "../node-utilities/CallExpression"
-import { createNumberLiteral, updateNumberLiteral } from "../node-utilities/NumberLiteral"
-import { updateMemberExpression } from "../node-utilities/MemberExpression"
-import { createETSParameterExpression, updateETSParameterExpression } from "../node-utilities/ETSParameterExpression"
-import { updateTSTypeParameter } from "../node-utilities/TSTypeParameter"
-import { updateETSTypeReferencePart } from "../node-utilities/TSTypeReferencePart"
-import { updateETSImportDeclaration } from "../node-utilities/ETSImportDeclaration"
-import { updateVariableDeclarator } from "../node-utilities/VariableDeclarator"
-import { updateClassDefinition } from "../node-utilities/ClassDefinition"
-import { updateETSStructDeclaration } from "../node-utilities/ETSStructDeclaration"
-import { updateClassProperty } from "../node-utilities/ClassProperty"
-import { createETSFunctionType, updateETSFunctionType } from "../node-utilities/ETSFunctionType"
-import { createMethodDefinition, updateMethodDefinition } from "../node-utilities/MethodDefinition"
-import { createTSInterfaceDeclaration, updateTSInterfaceDeclaration } from "../node-utilities/TSInterfaceDeclaration"
-import { updateTryStatement } from "../node-utilities/TryStatement"
-import { createAssignmentExpression, updateAssignmentExpression } from "../node-utilities/AssignmentExpression"
-import { createObjectExpression, updateObjectExpression } from "../node-utilities/ObjectExpression"
-import { updateETSTuple } from "../node-utilities/ETSTuple"
-import { createArrayExpression, updateArrayExpression } from "../node-utilities/ArrayExpression"
-import { updateBlockStatement } from "../node-utilities/BlockStatement"
-import { updateETSModule } from "../node-utilities/ETSModule"
-import { createOpaqueTypeNode } from "../node-utilities/OpaqueTypeNode"
+} from '../../../generated';
+import { factory as generatedFactory } from '../../../generated/factory';
+import {
+    createScriptFunction,
+    inplaceUpdateScriptFunction,
+    updateScriptFunction,
+} from '../node-utilities/ScriptFunction';
+import { inplaceUpdateCallExpression, updateCallExpression } from '../node-utilities/CallExpression';
+import { createNumberLiteral, updateNumberLiteral } from '../node-utilities/NumberLiteral';
+import { updateMemberExpression } from '../node-utilities/MemberExpression';
+import { createETSParameterExpression, updateETSParameterExpression } from '../node-utilities/ETSParameterExpression';
+import { updateTSTypeParameter } from '../node-utilities/TSTypeParameter';
+import { updateETSTypeReferencePart } from '../node-utilities/TSTypeReferencePart';
+import { updateETSImportDeclaration } from '../node-utilities/ETSImportDeclaration';
+import { updateVariableDeclarator } from '../node-utilities/VariableDeclarator';
+import { createClassDefinition, updateClassDefinition } from '../node-utilities/ClassDefinition';
+import { updateETSStructDeclaration } from '../node-utilities/ETSStructDeclaration';
+import { updateClassProperty } from '../node-utilities/ClassProperty';
+import { createETSFunctionType, updateETSFunctionType } from '../node-utilities/ETSFunctionType';
+import { createMethodDefinition, updateMethodDefinition } from '../node-utilities/MethodDefinition';
+import { createTSInterfaceDeclaration, updateTSInterfaceDeclaration } from '../node-utilities/TSInterfaceDeclaration';
+import { updateTryStatement } from '../node-utilities/TryStatement';
+import { createAssignmentExpression, updateAssignmentExpression } from '../node-utilities/AssignmentExpression';
+import { createObjectExpression, updateObjectExpression } from '../node-utilities/ObjectExpression';
+import { updateETSTuple } from '../node-utilities/ETSTuple';
+import { createArrayExpression, updateArrayExpression } from '../node-utilities/ArrayExpression';
+import { updateBlockStatement } from '../node-utilities/BlockStatement';
+import { updateETSModule } from '../node-utilities/ETSModule';
+import { createOpaqueTypeNode } from '../node-utilities/OpaqueTypeNode';
 
 export const factory = {
     ...generatedFactory,
 
-    createETSModule: ETSModule.createETSModule,
+    createIdentifier: Identifier.create2Identifier,
+    updateIdentifier: Identifier.update2Identifier,
+
+    createETSModule: ETSModule.create1ETSModule,
     updateETSModule,
 
     createCallExpression: CallExpression.createCallExpression,
@@ -93,8 +101,9 @@ export const factory = {
     createETSStructDeclaration: ETSStructDeclaration.createETSStructDeclaration,
     updateETSStructDeclaration,
 
-    createClassDefinition: ClassDefinition.createClassDefinition,
+    createClassDefinition,
     updateClassDefinition,
+    update3ClassDefinition: ClassDefinition.update3ClassDefinition,
 
     createClassProperty: ClassProperty.createClassProperty,
     updateClassProperty,
@@ -126,10 +135,10 @@ export const factory = {
     createBlockStatement: BlockStatement.createBlockStatement,
     updateBlockStatement,
 
-    updateInterfaceBody : generatedFactory.updateTSInterfaceBody,
+    updateInterfaceBody: generatedFactory.updateTSInterfaceBody,
 
     createClassStaticBlock: ClassStaticBlock.createClassStaticBlock,
     updateClassStaticBlock: ClassStaticBlock.updateClassStaticBlock,
 
     createOpaqueTypeNode,
-}
+};

package/build/libarkts-copy/src/arkts-api/index.ts

@@ -13,29 +13,28 @@
  * limitations under the License.
  */
 
-export * from "../generated/Es2pandaEnums"
-export * from "../generated"
+export * from '../../generated/Es2pandaEnums';
+export * from '../../generated';
 
-export * from "./utilities/performance"
-export * from "./utilities/private"
-export * from "./utilities/public"
-export * from "./factory/nodeFactory"
-export * from "./visitor"
-export * from "./AbstractVisitor"
-export * from "./plugins"
-export * from "./ImportStorage"
-export * from "./ProgramProvider"
+export * from './utilities/performance';
+export * from './utilities/private';
+export * from './utilities/public';
+export * from './factory/nodeFactory';
+export * from './visitor';
+export * from './AbstractVisitor';
+export * from './plugins';
+export * from './ImportStorage';
+export * from './ProgramProvider';
 
-export * from "./peers/AstNode"
-export * from "./peers/Config"
-export * from "./peers/Context"
-export { GlobalContext } from "./peers/Context"
-export * from "./peers/ExternalSource"
-export * from "./peers/Options"
-export * from "./peers/DiagnosticKind"
-export * from "./node-utilities/ArkTsConfig"
-export * from "./node-utilities/Program"
-export * from "./peers/ImportPathManager"
-export * from "./static/globalUtils"
-export { global as arktsGlobal } from "./static/global"
-export * from "./wrapper-compat"
+export * from './peers/AstNode';
+export * from './peers/Config';
+export * from './peers/Context';
+export { GlobalContext } from './peers/Context';
+export * from './peers/ExternalSource';
+export * from './peers/Options';
+export * from './node-utilities/ArkTsConfig';
+export * from './node-utilities/Program';
+export * from './peers/ImportPathManager';
+export * from './static/globalUtils';
+export { global as arktsGlobal } from './static/global';
+export * from './wrapper-compat';

package/build/libarkts-copy/src/arkts-api/node-cache.ts

@@ -13,31 +13,40 @@
  * limitations under the License.
  */
 
-import { KNativePointer } from "@koalaui/interop"
-import { AstNode } from "./peers/AstNode"
+import { KNativePointer } from '@koalaui/interop';
+import { AstNode } from './peers/AstNode';
+
+const useCache = false;
 
 export class NodeCache {
-    private static cache = new Map<KNativePointer, AstNode>()
+    private static cache = new Map<KNativePointer, AstNode>();
 
     static cached<T extends AstNode>(pointer: KNativePointer, factory: (pointer: KNativePointer) => AstNode): T {
-        const cached = NodeCache.cache.get(pointer)
-        if (cached !== undefined) {
-            return cached as T
+        if (!useCache) {
+            return factory(pointer) as T;
+        }
+        const cached = NodeCache.cache.get(pointer);
+        if (!!cached) {
+            return cached as T;
         }
-        const node = factory(pointer)
-        NodeCache.addToCache(pointer, node)
-        return node as T
+        const node = factory(pointer);
+        NodeCache.addToCache(pointer, node);
+        return node as T;
     }
 
     static get<T extends AstNode>(pointer: KNativePointer): T | undefined {
-        return NodeCache.cache.get(pointer) as T | undefined
+        return NodeCache.cache.get(pointer) as T | undefined;
     }
 
-    public static addToCache(pointer: KNativePointer, node: AstNode) {
-        NodeCache.cache.set(pointer, node)
+    public static addToCache(pointer: KNativePointer, node: AstNode): void {
+        if (useCache) {
+            NodeCache.cache.set(pointer, node);
+        }
     }
 
     public static clear(): void {
-        NodeCache.cache.clear()
+        if (useCache) {
+            NodeCache.cache.clear();
+        }
     }
 }

package/build/libarkts-copy/src/arkts-api/node-utilities/ArkTsConfig.ts

@@ -13,14 +13,14 @@
  * limitations under the License.
  */
 
-import { ArkTsConfig } from "../../generated"
-import { traceGlobal } from "../../tracer"
+import { ArkTsConfig } from '../../../generated';
+import { traceGlobal } from '../../tracer';
 
 export function dumpArkTsConfigInfo(arkTsConfig: ArkTsConfig) {
-    traceGlobal(() => `ArkTsConfig info:`)
-    traceGlobal(() => `\tBaseUrl:          ${arkTsConfig.baseUrl}`)
-    traceGlobal(() => `\tConfigPath:       ${arkTsConfig.configPath}`)
-    traceGlobal(() => `\tOutDir:           ${arkTsConfig.outDir}`)
-    traceGlobal(() => `\tPackage:          ${arkTsConfig.package}`)
-    traceGlobal(() => `\tRootDir:          ${arkTsConfig.rootDir}`)
+    traceGlobal(() => `ArkTsConfig info:`);
+    traceGlobal(() => `\tBaseUrl:          ${arkTsConfig.baseUrl}`);
+    traceGlobal(() => `\tConfigPath:       ${arkTsConfig.configPath}`);
+    traceGlobal(() => `\tOutDir:           ${arkTsConfig.outDir}`);
+    traceGlobal(() => `\tPackage:          ${arkTsConfig.package}`);
+    traceGlobal(() => `\tRootDir:          ${arkTsConfig.rootDir}`);
 }

package/build/libarkts-copy/src/arkts-api/node-utilities/ArrayExpression.ts

@@ -13,30 +13,18 @@
  * limitations under the License.
  */
 
-import { Es2pandaAstNodeType } from "../../generated/Es2pandaEnums"
-import { ArrayExpression, Expression } from "../../generated"
-import { isSameNativeObject } from "../peers/ArktsObject"
-import { updateNodeByNode } from "../utilities/private"
+import { Es2pandaAstNodeType } from '../../../generated/Es2pandaEnums';
+import { ArrayExpression, Expression } from '../../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { updateNodeByNode } from '../utilities/private';
 
-export function createArrayExpression(
-    elements: readonly Expression[]
-): ArrayExpression {
-    return ArrayExpression.create1ArrayExpression(
-        Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION,
-        elements,
-        false
-    )
+export function createArrayExpression(elements: readonly Expression[]): ArrayExpression {
+    return ArrayExpression.create1ArrayExpression(Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION, elements, false);
 }
 
-export function updateArrayExpression(
-    original: ArrayExpression,
-    elements: readonly Expression[]
-): ArrayExpression {
+export function updateArrayExpression(original: ArrayExpression, elements: readonly Expression[]): ArrayExpression {
     if (isSameNativeObject(original.elements, elements)) {
-        return original
+        return original;
     }
-    return updateNodeByNode(
-        createArrayExpression(elements),
-        original
-    )
+    return updateNodeByNode(createArrayExpression(elements), original);
 }