@idlizer/arktscgen 2.1.10-arktscgen-5 → 2.1.10-arktscgen-7

package/build/libarkts-copy/src/arkts-api/peers/AstNode.ts

@@ -97,22 +97,6 @@ export abstract class AstNode extends ArktsObject {
         return unpackString(global.es2panda._AstNodeDumpModifiers(global.context, this.peer));
     }
 
-    // public clone(): this {
-    //     return unpackNonNullableNode(global.generatedEs2panda._AstNodeClone(global.context, this.peer, this.parent.peer));
-    // }
-
-    // public get parent(): AstNode {
-    //     const parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer)
-    //     if (parent === nullptr) {
-    //         throwError(`no parent`)
-    //     }
-    //     return unpackNonNullableNode(parent)
-    // }
-
-    // public set parent(node: AstNode) {
-    //     global.generatedEs2panda._AstNodeSetParent(global.context, this.peer, node.peer)
-    // }
-
     public clone(): this {
         const clonedNode = unpackNonNullableNode(
             global.generatedEs2panda._AstNodeClone(global.context, this.peer, this.parent?.peer ?? nullptr)

package/build/libarkts-copy/src/arkts-api/peers/Config.ts

@@ -44,7 +44,7 @@ export class Config extends ArktsObject {
     }
 
     destroy() {
-        if (this.peer != nullptr) {
+        if (this.peer !== nullptr) {
             global.es2panda._DestroyConfig(this.peer);
             this.peer = nullptr;
         }

package/build/libarkts-copy/src/arkts-api/peers/Context.ts

@@ -32,7 +32,7 @@ export class Context extends ArktsObject {
             throw new Error(`Config not initialized`);
         }
         return new Context(
-            global.es2panda._CreateContextFromString(global.config, passString(source), passString(global.filePath))
+            global.generatedEs2panda._CreateContextFromString(global.config, passString(source), passString(global.filePath))
         );
     }
 
@@ -44,17 +44,17 @@ export class Context extends ArktsObject {
         isExternal: KBoolean
     ): Context {
         return new Context(
-            global.es2panda._CreateCacheContextFromFile(configPtr, passString(fileName), globalContextPtr, isExternal)
+            global.generatedEs2panda._CreateCacheContextFromFile(configPtr, passString(fileName), globalContextPtr, isExternal)
         );
     }
 
     static createFromFile(filePath: string): Context {
-        return new Context(global.es2panda._CreateContextFromFile(global.config, passString(filePath)));
+        return new Context(global.generatedEs2panda._CreateContextFromFile(global.config, passString(filePath)));
     }
 
     static createCacheFromFile(filePath: string, config: Config, globalContext: GlobalContext, isExternal: boolean) {
         return new Context(
-            global.es2panda._CreateCacheContextFromFile(
+            global.generatedEs2panda._CreateCacheContextFromFile(
                 config.peer,
                 passString(filePath),
                 globalContext.peer,
@@ -68,7 +68,7 @@ export class Context extends ArktsObject {
             throwError(`Config not initialized`);
         }
         return new Context(
-            global.es2panda._CreateContextGenerateAbcForExternalSourceFiles(
+            global.generatedEs2panda._CreateContextGenerateAbcForExternalSourceFiles(
                 global.config,
                 filenames.length,
                 passStringArray(filenames)
@@ -77,7 +77,7 @@ export class Context extends ArktsObject {
     }
 
     destroy() {
-        if (this.peer != nullptr) {
+        if (this.peer !== nullptr) {
             global.es2panda._DestroyContext(this.peer);
             this.peer = nullptr;
         }
@@ -101,7 +101,7 @@ export class Context extends ArktsObject {
 export class GlobalContext extends ArktsObject {
     static create(config: Config, externalFileList: string[]): GlobalContext {
         return new GlobalContext(
-            global.es2panda._CreateGlobalContext(
+            global.generatedEs2panda._CreateGlobalContext(
                 config.peer,
                 passStringArray(externalFileList),
                 externalFileList.length,
@@ -115,8 +115,8 @@ export class GlobalContext extends ArktsObject {
     }
 
     destroy() {
-        if (this.peer != nullptr) {
-            global.es2panda._DestroyGlobalContext(this.peer);
+        if (this.peer !== nullptr) {
+            global.generatedEs2panda._DestroyGlobalContext(this.peer);
             this.peer = nullptr;
         }
     }

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

@@ -18,7 +18,7 @@ import { ETSModule, Program } from '../../generated';
 import { ExternalSource } from './peers/ExternalSource';
 import { KNativePointer, nullptr } from '@koalaui/interop';
 import { global } from './static/global';
-import { RunTransformerHooks } from '../plugin-utils';
+import { Context } from './peers/Context';
 
 export interface CompilationOptions {
     readonly isProgramForCodegeneration: boolean;
@@ -60,18 +60,37 @@ export interface ProjectConfig {
     integratedHsp: boolean;
     frameworkMode?: string;
     isUi2abc?: boolean;
+    memoPluginOptions?: Object;
 }
 
-export interface PluginContext {
+export interface PluginContextBase {
     setParameter<V>(name: string, value: V): void;
     parameter<V>(name: string): V | undefined;
 }
 
-export class PluginContextImpl implements PluginContext {
-    map = new Map<string, object | undefined>();
+export interface PluginContext extends PluginContextBase {
+    /**
+     * @deprecated
+     */
+    setArkTSProgram(program: Program): void
+
+    /**
+     * @deprecated
+     */
+    getArkTSProgram(): Program | undefined
+
+    setCodingFilePath(codingFilePath: string): void
 
-    private ast: ETSModule | undefined = undefined;
-    private projectConfig: ProjectConfig | undefined = undefined;
+    getCodingFilePath(): string | undefined
+
+    isCoding(): boolean
+
+    getProjectConfig(): ProjectConfig | undefined 
+}
+
+
+export class PluginContextBaseImpl implements PluginContextBase {
+    map = new Map<string, object | undefined>();
 
     parameter<V>(name: string): V | undefined {
         return this.map.get(name) as V | undefined;
@@ -79,9 +98,38 @@ export class PluginContextImpl implements PluginContext {
     setParameter<V>(name: string, value: V): void {
         this.map.set(name, value as object);
     }
+}
+
+// Temporary hack to use plugin context's parameters when compiling with driver
+export function extendPluginContext(context: PluginContextImpl) {
+    if (typeof context.setParameter == "function") {
+        return
+    }
+    const pluginContextBaseImpl = new PluginContextBaseImpl()
+    context.map = pluginContextBaseImpl.map
+    context.setParameter = pluginContextBaseImpl.setParameter
+    context.parameter = pluginContextBaseImpl.parameter
+}
+
+export class PluginContextImpl extends PluginContextBaseImpl implements PluginContext {
+    private ast: ETSModule | undefined;
+    private projectConfig: ProjectConfig | undefined;
+
+    private program: Program | undefined;
+    private codingFilePath: string | undefined;
+
+    setContextPtr(ptr: KNativePointer): void {
+        if (!global.compilerContext) {
+            global.compilerContext = new Context(ptr);
+        } else {
+            global.compilerContext.peer = ptr;
+        }
+    }
+
     getContextPtr(): KNativePointer {
         return global.compilerContext?.peer ?? nullptr;
     }
+
     public setProjectConfig(projectConfig: ProjectConfig): void {
         this.projectConfig = projectConfig;
     }
@@ -102,14 +150,73 @@ export class PluginContextImpl implements PluginContext {
     public getArkTSAst(): ETSModule | undefined {
         return this.ast;
     }
+
+    /**
+     * @deprecated
+     */
+    public setArkTSProgram(program: Program): void {
+        this.program = program;
+    }
+
+    /**ProjectConfig
+     * @deprecated
+     */
+    public getArkTSProgram(): Program | undefined {
+        return this.program;
+    }
+
+    public setCodingFilePath(codingFilePath: string): void {
+        this.codingFilePath = codingFilePath;
+    }
+
+    public getCodingFilePath(): string | undefined {
+        return this.codingFilePath;
+    }
+
+    public isCoding(): boolean {
+        return this.codingFilePath !== undefined;
+    }
 }
 
+export type PluginHandlerFunction = () => void;
+
+export type PluginHandlerObject = {
+    order: 'pre' | 'post' | undefined;
+    handler: PluginHandlerFunction;
+};
+
+export type PluginHandler = PluginHandlerFunction | PluginHandlerObject;
+
 export type ProgramTransformer = (
     program: Program,
     compilationOptions: CompilationOptions,
     context: PluginContext
 ) => void;
 
+export interface Plugins {
+    name: string;
+    afterNew?: PluginHandler;
+    parsed?: PluginHandler;
+    scopeInited?: PluginHandler;
+    checked?: PluginHandler;
+    lowered?: PluginHandler;
+    asmGenerated?: PluginHandler;
+    binGenerated?: PluginHandler;
+    clean?: PluginHandler;
+}
+
+export type PluginState = keyof Omit<Plugins, 'name'>;
+
+export type PluginExecutor = {
+    name: string;
+    handler: PluginHandlerFunction;
+};
+
+export interface BuildConfig {
+    compileFiles: string[];
+}
+
+
 export function defaultFilter(name: string): boolean {
     if (name.startsWith('std.')) return false;
     if (name.startsWith('escompat')) return false;
@@ -127,12 +234,3 @@ export function listPrograms(program: Program, filter: (name: string) => boolean
         }),
     ];
 }
-
-export interface PluginEntry {
-    name?: string;
-    parsed?: (hooks?: RunTransformerHooks) => void;
-    checked?: (hooks?: RunTransformerHooks) => void;
-    clean?: (hooks?: RunTransformerHooks) => void;
-}
-
-export type PluginInitializer = (parsedJson?: object, checkedJson?: object) => PluginEntry;

package/build/libarkts-copy/src/arkts-api/static/global.ts

@@ -54,7 +54,7 @@ export class global {
         return global._config ?? throwError('Global.config not initialized');
     }
     public static configIsInitialized(): boolean {
-        return global._config !== undefined && global._config !== nullptr;
+        return !!global._config && global._config !== nullptr;
     }
     public static resetConfig(): void {
         global._config = undefined;
@@ -94,9 +94,6 @@ export class global {
 
     public static profiler = new Profiler();
 
-    // Check node type values during node creation
-    public static validatePeerTypes = false;
-
     public static clearContext(): void {
         global.compilerContext = undefined;
     }

package/build/libarkts-copy/src/arkts-api/static/profiler.ts

@@ -80,7 +80,7 @@ export class Profiler implements PerformanceData {
         return this.pluginsByName[pluginName];
     }
 
-    disableReport = false;
+    disableReport = true;
 
     nodeCreated() {
         this.createdNodes++;
@@ -101,16 +101,16 @@ export class Profiler implements PerformanceData {
         this.transformDepStartTime = Date.now();
     }
 
-    transformEnded(state: Es2pandaContextState, pluginName: string): void {
+    transformEnded(): void {
         const transformEndTime = Date.now();
         const consumedTime = transformEndTime - this.transformStartTime;
-        this.getPluginData(pluginName, state).transformTime += consumedTime;
+        this.getPluginData(this.curPlugin, this.curContextState).transformTime += consumedTime;
     }
 
-    transformDepEnded(state: Es2pandaContextState, pluginName: string): void {
+    transformDepEnded(): void {
         const transformEndTime = Date.now();
         const consumedTime = transformEndTime - this.transformDepStartTime;
-        this.getPluginData(pluginName, state).transformTimeDeps += consumedTime;
+        this.getPluginData(this.curPlugin, this.curContextState).transformTimeDeps += consumedTime;
     }
 
     proceededToState(consumedTime: number) {

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

@@ -13,6 +13,7 @@
  * limitations under the License.
  */
 
+const { performance } = require('perf_hooks');
 import * as process from 'process';
 import { global as localGlobal } from '../static/global';
 
@@ -286,7 +287,7 @@ export class Performance {
             '[PERFORMANCE]',
             `External       | ${context.startMemory.external.toFixed(2)}    | ${(endMemory.external / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)).toFixed(2)}    | ${memoryDiff.external.toFixed(2)}`
         );
-        if (endMemory.arrayBuffers !== undefined) {
+        if (!!endMemory.arrayBuffers) {
             console.log(
                 `Array Buffers  | ${context.startMemory.arrayBuffers.toFixed(2)}    | ${((endMemory.arrayBuffers || 0) / (BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE)).toFixed(2)}    | ${memoryDiff.arrayBuffers.toFixed(2)}`
             );

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

@@ -17,7 +17,6 @@ import { global } from '../static/global';
 import { isNumber, throwError } from '../../utils';
 import { KInt, KNativePointer as KPtr, KNativePointer, nullptr, withString, withStringArray } from '@koalaui/interop';
 import { NativePtrDecoder } from './nativePtrDecoder';
-//import { OptimizedNativePtrDecoder as NativePtrDecoder } from "./nativePtrDecoder"
 import {
     Es2pandaAstNodeType,
     Es2pandaModifierFlags,
@@ -33,51 +32,13 @@ export const allFlags = Object.values(Es2pandaModifierFlags)
     .filter(isNumber)
     .reduce((prev, next) => prev | next, 0);
 
-export function assertValidPeer(peer: KPtr, expectedKind: Es2pandaAstNodeType): void {
-    if (peer === nullptr) {
-        throwError(`invalid peer`);
-    }
-
-    if (global.validatePeerTypes) {
-        const peerType = global.generatedEs2panda._AstNodeTypeConst(global.context, peer);
-        if (
-            peerType === Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION &&
-            expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION
-        ) {
-            // Improve: Struct is a child class of Class
-            return;
-        }
-        if (
-            peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION &&
-            expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION
-        ) {
-            // Improve: ETSImportDeclaration is a child of a ImportDeclaration
-            return;
-        }
-        if (
-            peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE &&
-            expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT
-        ) {
-            // Improve: ETSModule is a child of a BlockStatement
-            return;
-        }
-        if (peerType !== expectedKind) {
-            throwError(`expected: ${Es2pandaAstNodeType[expectedKind]}, got: ${Es2pandaAstNodeType[peerType]}`);
-        }
-    }
-}
-
 export function acceptNativeObjectArrayResult<T extends ArktsObject>(
     arrayObject: KNativePointer,
     factory: (instance: KNativePointer) => T
 ): T[] {
-    // For OptimizedNativePtrDecoder
-    //const decoded = new NativePtrDecoder().decode(arrayObject)
-    //return decoded.reduce((prev, curr) => {
-    //    prev.push(factory(curr))
-    //    return prev
-    //}, [] as T[])
-    return new NativePtrDecoder().decode(arrayObject).map(factory);
+    // OptimizedNativePtrDecoder:return decoded.reduce((prev, curr)=>{prev.push(factory(curr));return prev},[] as T[])
+    const decoded = new NativePtrDecoder().decode(arrayObject)
+    return decoded.map(factory);
 }
 
 export function unpackNonNullableNode<T extends AstNode>(peer: KNativePointer, typeHint?: Es2pandaAstNodeType): T {
@@ -111,8 +72,15 @@ export function unpackNodeArray<T extends AstNode>(nodesPtr: KNativePointer, typ
     return new NativePtrDecoder().decode(nodesPtr).map((peer: KNativePointer) => unpackNonNullableNode(peer, typeHint));
 }
 
+export function unpackNativeObjectArray<T extends ArktsObject>(
+    arrayObject: KNativePointer,
+    factory: (instance: KNativePointer) => T
+): T[] {
+    return acceptNativeObjectArrayResult(arrayObject, factory);
+}
+
 export function passNodeArray(nodes: readonly ArktsObject[] | undefined): BigUint64Array {
-    return new BigUint64Array(nodes?.filter((it) => it.peer != undefined)?.map((node) => BigInt(node.peer)) ?? []);
+    return new BigUint64Array(nodes?.filter((it) => (!!it.peer))?.map((node) => BigInt(node.peer)) ?? []);
 }
 
 export function unpackString(peer: KNativePointer): string {

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

@@ -63,13 +63,13 @@ import {
     MemberExpression,
     isMethodDefinition,
     TypeNode,
+    DiagnosticKind
 } from '../../../generated';
 import { Config } from '../peers/Config';
 import { Context } from '../peers/Context';
 import { NodeCache } from '../node-cache';
 import { factory } from '../factory/nodeFactory';
 import { traceGlobal } from '../../tracer';
-import { DiagnosticKind } from '../peers/DiagnosticKind';
 
 /**
  * Improve: Replace or remove with better naming
@@ -78,11 +78,11 @@ import { DiagnosticKind } from '../peers/DiagnosticKind';
  */
 export function createETSModuleFromContext(): ETSModule {
     let program = global.generatedEs2panda._ContextProgram(global.context);
-    if (program == nullptr) {
+    if (program === nullptr || program === null) {
         throw new Error(`Program is null for context ${global.context.toString(16)}`);
     }
     const ast = global.generatedEs2panda._ProgramAst(global.context, program);
-    if (ast == nullptr) {
+    if (ast === nullptr || ast === null) {
         throw new Error(`AST is null for program ${program.toString(16)}`);
     }
     return new ETSModule(ast, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE);
@@ -122,10 +122,19 @@ export function checkErrors() {
         traceGlobal(() => `Terminated due to compilation errors occured`);
         console.log(unpackString(global.generatedEs2panda._GetAllErrorMessages(global.context)));
         // global.es2panda._DestroyConfig(global.config)
-        process.exit(1);
+        throw new Error(`Compilation error`)
     }
 }
 
+function format(value: number): string {
+    return `${(value / 1024 / 1024 / 1024).toFixed(4)} GB`
+}
+
+// Improve: move to profiler
+function dumpMemoryProfilerInfo(str: string) {
+    console.log(str, format(process.memoryUsage().rss));
+}
+
 export function proceedToState(state: Es2pandaContextState): void {
     if (state <= global.es2panda._ContextState(global.context)) {
         return;
@@ -137,6 +146,9 @@ export function proceedToState(state: Es2pandaContextState): void {
     traceGlobal(() => `Proceeding to state ${Es2pandaContextState[state]}: done`);
     const after = Date.now();
     global.profiler.proceededToState(after - before);
+    if (state == Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED) {
+        dumpMemoryProfilerInfo("Memory usage (rss) after proceed to bin:")
+    }
     checkErrors();
 }
 
@@ -372,7 +384,7 @@ export function generateTsDeclarationsFromContext(
     recordFile: string,
     genAnnotations: boolean
 ): KInt {
-    return global.es2panda._GenerateTsDeclarationsFromContext(
+    return global.generatedEs2panda._GenerateTsDeclarationsFromContext(
         global.context,
         passString(outputDeclEts),
         passString(outputEts),
@@ -451,7 +463,7 @@ export function createDiagnosticInfo(
     ...args: string[]
 ): DiagnosticInfo {
     return new DiagnosticInfo(
-        global.es2panda._CreateDiagnosticInfo(
+        global.generatedEs2panda._CreateDiagnosticInfo(
             global.context,
             kind.peer,
             passStringArray(args),
@@ -469,7 +481,7 @@ export function createSuggestionInfo(
     ...args: string[]
 ): SuggestionInfo {
     return new SuggestionInfo(
-        global.es2panda._CreateSuggestionInfo(
+        global.generatedEs2panda._CreateSuggestionInfo(
             global.context,
             kind.peer,
             passStringArray(args),
@@ -493,6 +505,26 @@ export function logDiagnosticWithSuggestion(diagnosticInfo: DiagnosticInfo, sugg
     global.generatedEs2panda._LogDiagnosticWithSuggestion(global.context, diagnosticInfo.peer, suggestionInfo.peer);
 }
 
-export function filterNodes(node: AstNode, filter: string): AstNode[] {
-    return unpackNodeArray(global.es2panda._FilterNodes(global.context, passNode(node), filter));
+export function filterNodes(node: AstNode, filter: string, deeperAfterMatch: boolean): AstNode[] {
+    return unpackNodeArray(global.es2panda._FilterNodes(global.context, passNode(node), filter, deeperAfterMatch));
+}
+
+export function filterNodesByType<T extends AstNode = AstNode>(node: AstNode, type: Es2pandaAstNodeType): T[] {
+    return unpackNodeArray(global.es2panda._FilterNodes2(global.context, passNode(node), type), type);
+}
+
+export function filterNodesByTypes(node: AstNode, types: Es2pandaAstNodeType[]): AstNode[] {
+    const typesArray = new Int32Array(types.length)
+    for (let i = 0; i < types.length; i++) {
+        typesArray[i] = types[i]
+    }
+    return unpackNodeArray(global.es2panda._FilterNodes3(global.context, passNode(node), typesArray, types.length));
+}
+
+export function MemInitialize() {
+    global.es2panda._MemInitialize()
+}
+
+export function MemFinalize() {
+    global.es2panda._MemFinalize()
 }

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

@@ -258,34 +258,17 @@ function visitETSTypeReferencePart(node: ETSTypeReferencePart, visitor: Visitor)
 function visitScriptFunction(node: ScriptFunction, visitor: Visitor): ScriptFunction {
     global.updateTracker.push();
     const newBody = nodeVisitor(node.body, visitor);
-    const oldTypeParams = node.typeParams;
-    const newTypeParams = nodeVisitor(oldTypeParams, visitor);
+    const newTypeParams = nodeVisitor(node.typeParams, visitor);
     const newParams: readonly Expression[] = nodesVisitor(node.params, visitor);
     const newReturnTypeAnnotation = nodeVisitor(node.returnTypeAnnotation, visitor);
     const newId = nodeVisitor(node.id, visitor);
     const newAnnotations: readonly AnnotationUsage[] = nodesVisitor(node.annotations, visitor);
     if (global.updateTracker.check()) {
-        if (!isSameNativeObject(newTypeParams, oldTypeParams)) {
-            const result = factory.createScriptFunction(
-                newBody,
-                newTypeParams,
-                newParams,
-                newReturnTypeAnnotation,
-                node.hasReceiver,
-                node.flags,
-                node.modifierFlags,
-                newId,
-                newAnnotations,
-                node.getSignaturePointer(),
-                node.getPreferredReturnTypePointer()
-            );
-            result.onUpdate(node);
-            return result;
-        }
         node.setBody(newBody);
         node.setParams(newParams);
+        node.setTypeParams(newTypeParams);
         node.setReturnTypeAnnotation(newReturnTypeAnnotation);
-        if (newId) node.setIdent(newId);
+        node.setIdent(newId);
         node.setAnnotations(newAnnotations);
     }
     return node;
@@ -314,7 +297,6 @@ function visitMethodDefinition(node: MethodDefinition, visitor: Visitor): Method
         node.setOverloads(newOverloads);
         newOverloads.forEach((it): void => {
             it.setBaseOverloadMethod(node);
-            it.parent = node;
         });
     }
     return node;
@@ -538,7 +520,6 @@ function visitIfStatement(node: IfStatement, visitor: Visitor): IfStatement {
             return result;
         }
         node.setTest(newTest);
-        if (newTest) newTest.parent = node;
         node.setAlternate(newAlternate);
     }
     return node;
@@ -828,7 +809,6 @@ function visitETSNewClassInstanceExpression(
             return result;
         }
         node.setArguments(newArguments);
-        newArguments.forEach((it) => (it.parent = node));
     }
     return node;
 }
@@ -865,7 +845,7 @@ function visitForUpdateStatement(node: ForUpdateStatement, visitor: Visitor): Fo
     global.updateTracker.push();
     const newInit = nodeVisitor(node.init, visitor);
     const newTest = nodeVisitor(node.test, visitor);
-    const newUpdate = nodeVisitor(node.update, visitor);
+    const newUpdate = nodeVisitor(node.updateExpression, visitor);
     const newBody = nodeVisitor(node.body, visitor);
     if (global.updateTracker.check()) {
         const result = factory.createForUpdateStatement(newInit, newTest, newUpdate, newBody);
@@ -922,7 +902,6 @@ function visitTSNonNullExpression(node: TSNonNullExpression, visitor: Visitor):
     const newExpr = nodeVisitor(node.expr, visitor);
     if (global.updateTracker.check()) {
         node.setExpr(newExpr);
-        if (newExpr) newExpr.parent = node;
     }
     return node;
 }

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

@@ -31,7 +31,7 @@ export function checkSDK() {
     if (!version) reportErrorAndExit(`version is unknown`);
     const packageJsonOur = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json')).toString());
     const expectedVersion = packageJsonOur.config.panda_sdk_version;
-    if (expectedVersion && expectedVersion != 'next' && version != expectedVersion)
+    if (expectedVersion && expectedVersion !== 'next' && version !== expectedVersion)
         console.log(`WARNING: Panda SDK version "${version}" doesn't match expected "${expectedVersion}"`);
     else console.log(`Using Panda ${version}`);
 }

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

@@ -28,7 +28,6 @@ export * from './arkts-api/AbstractVisitor';
 export * from './arkts-api/plugins';
 export * from './arkts-api/ImportStorage';
 export * from './arkts-api/ProgramProvider';
-export * from './arkts-api/node-utilities/Program';
 export * from './arkts-api/node-utilities/ArkTsConfig';
 
 export * from './arkts-api/peers/AstNode';
@@ -38,10 +37,10 @@ export { GlobalContext } from './arkts-api/peers/Context';
 export * from './arkts-api/peers/ExternalSource';
 export * from './arkts-api/peers/ImportPathManager';
 export * from './arkts-api/peers/Options';
-export * from './arkts-api/peers/DiagnosticKind';
 export { global as arktsGlobal } from './arkts-api/static/global';
 export * from './arkts-api/static/globalUtils';
 export * as arkts from './arkts-api';
 
 export * from './plugin-utils';
 export * from './tracer';
+export * from './memo-node-cache';