@idlizer/arktscgen 2.1.9-arktscgen-9 → 2.1.10-arktscgen-3

package/build/libarkts-copy/src/generated/peers/YieldExpression.ts

@@ -24,7 +24,6 @@ import {
     unpackNonNullableNode,
     unpackNode,
     unpackNodeArray,
-    assertValidPeer,
     AstNode,
     KNativePointer,
     nodeByType,
@@ -36,17 +35,16 @@ import { Es2pandaAstNodeType } from "./../Es2pandaEnums"
 import { Expression } from "./Expression"
 
 export class YieldExpression extends Expression {
-    constructor(pointer: KNativePointer) {
-        assertValidPeer(pointer, 155)
-        super(pointer)
+    constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) {
+        super(pointer, astNodeType)
     }
     static createYieldExpression(argument: Expression | undefined, isDelegate: boolean): YieldExpression {
-        const result: YieldExpression = new YieldExpression(global.generatedEs2panda._CreateYieldExpression(global.context, passNode(argument), isDelegate))
+        const result: YieldExpression = new YieldExpression(global.generatedEs2panda._CreateYieldExpression(global.context, passNode(argument), isDelegate), Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
     static updateYieldExpression(original: YieldExpression | undefined, argument: Expression | undefined, isDelegate: boolean): YieldExpression {
-        const result: YieldExpression = new YieldExpression(global.generatedEs2panda._UpdateYieldExpression(global.context, passNode(original), passNode(argument), isDelegate))
+        const result: YieldExpression = new YieldExpression(global.generatedEs2panda._UpdateYieldExpression(global.context, passNode(original), passNode(argument), isDelegate), Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION)
         result.setChildrenParentPtr()
         return result
     }
@@ -62,5 +60,5 @@ export function isYieldExpression(node: object | undefined): node is YieldExpres
     return node instanceof YieldExpression
 }
 if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION)) {
-    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION, (peer: KNativePointer) => new YieldExpression(peer))
+    nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION, (peer: KNativePointer) => new YieldExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION))
 }

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

@@ -19,12 +19,12 @@ export * from "./reexport-for-generated"
 export * from "./generated/Es2pandaEnums"
 export * from "./generated"
 
+export * from "./arkts-api/utilities/performance"
 export * from "./arkts-api/utilities/private"
 export * from "./arkts-api/utilities/public"
 export * from "./arkts-api/factory/nodeFactory"
 export * from "./arkts-api/visitor"
 export * from "./arkts-api/AbstractVisitor"
-export * from "./arkts-api/ChainExpressionFilter"
 export * from "./arkts-api/plugins"
 export * from "./arkts-api/ImportStorage"
 export * from "./arkts-api/ProgramProvider"
@@ -38,7 +38,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"

package/build/libarkts-copy/src/plugin-utils.ts

@@ -18,13 +18,13 @@ import {
     PluginContext,
     ImportStorage,
     arktsGlobal,
-    ChainExpressionFilter,
     ProgramTransformer,
     Program,
     ProgramProvider,
     CompilationOptions,
-    dumpProgramSrcFormatted
+    dumpProgramSrcFormatted,
 } from "./arkts-api"
+import { Tracer } from "./tracer"
 
 export interface RunTransformerHooks {
     onProgramTransformStart?(options: CompilationOptions, program: Program): void
@@ -66,6 +66,10 @@ export class DumpingHooks implements RunTransformerHooks {
 
 
 export function runTransformerOnProgram(program: Program, options: CompilationOptions, transform: ProgramTransformer | undefined, pluginContext: PluginContext, hooks: RunTransformerHooks = {}) {
+    arktsGlobal.filePath = program.absoluteName
+
+    Tracer.startProgramTracing(program)
+
     // Perform some additional actions before the transformation start
     hooks.onProgramTransformStart?.(options, program)
 
@@ -75,14 +79,13 @@ export function runTransformerOnProgram(program: Program, options: CompilationOp
     // Run the plugin itself
     transform?.(program, options, pluginContext)
 
-    // Run some common plugins that should be run after plugin usage and depends on the current state
-    stateSpecificPostFilters(program, options.state)
-
     // Update internal import information based on import modification by plugin
     importStorage.update()
 
     // Perform some additional actions after the transformation end
     hooks.onProgramTransformEnd?.(options, program)
+
+    Tracer.stopProgramTracing()
 }
 
 export function runTransformer(prog: Program, state: Es2pandaContextState, transform: ProgramTransformer | undefined, pluginContext: PluginContext, hooks: RunTransformerHooks = {}) {
@@ -110,12 +113,6 @@ export function runTransformer(prog: Program, state: Es2pandaContextState, trans
     }
 }
 
-function stateSpecificPostFilters(program: Program, state: Es2pandaContextState) {
-    if (state == Es2pandaContextState.ES2PANDA_STATE_CHECKED) {
-        program.setAst(new ChainExpressionFilter().visitor(program.ast))
-    }
-}
-
 function isProgramForCodegeneration(
     program: Program,
     isMainProgram: boolean,

package/build/libarkts-copy/src/reexport-for-generated.ts

@@ -22,22 +22,11 @@ export {
     unpackNodeArray,
     passNodeArray,
     unpackNode,
-    unpackNonNullableObject,
     unpackString,
-    unpackObject,
     assertValidPeer,
     updateNodeByNode
 } from "./arkts-api/utilities/private"
 export { nodeByType } from "./arkts-api/class-by-peer"
 export { global } from "./arkts-api/static/global"
 export { Es2pandaMemberExpressionKind } from "./generated/Es2pandaEnums"
-export {
-    extension_ETSModuleGetNamespaceFlag,
-    extension_MethodDefinitionOnUpdate,
-    extension_MethodDefinitionSetChildrenParentPtr,
-    extension_ScriptFunctionGetSignaturePointer,
-    extension_ScriptFunctionSetSignaturePointer,
-    extension_ScriptFunctionGetPreferredReturnTypePointer,
-    extension_ScriptFunctionSetPreferredReturnTypePointer,
-    extension_ProgramGetExternalSources,
-} from "./arkts-api/utilities/extensions"
+export * from "./arkts-api/utilities/extensions"

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

@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as fs from "node:fs"
+import * as path from "node:path"
+import { Program } from "./generated"
+import { global } from "./arkts-api/static/global"
+
+export class Tracer {
+    static traceDir: string
+    static GlobalTracer: Tracer
+    static Tracers: Map<string, Tracer>
+    static LRUTracer: Tracer | undefined
+
+    static startGlobalTracing(outDir: string) {
+        Tracer.traceDir = path.join(outDir, 'trace')
+        fs.rmSync(Tracer.traceDir, { force: true, recursive: true })
+        const globalTraceFile = path.join(Tracer.traceDir, '.global.txt')
+        
+        Tracer.GlobalTracer = new Tracer(globalTraceFile)
+        Tracer.pushContext('tracer')
+        traceGlobal(() => `Trace file created at ${globalTraceFile}`, true)
+
+        Tracer.Tracers = new Map<string, Tracer>()
+    }
+
+    static startProgramTracing(program: Program) {
+        if (!Tracer.GlobalTracer) {
+            return
+        }
+        const programPath = program.absoluteName
+        if (programPath == "") {
+            return
+        }
+        const suggestedTracer = Tracer.Tracers.get(programPath)
+        if (suggestedTracer) {
+            Tracer.LRUTracer = suggestedTracer
+            return
+        }
+        if (!global.arktsconfig) {
+            throw new Error("global.arktsconfig should be set for tracer usage")
+        }
+        const relative = path.relative(global.arktsconfig?.baseUrl, programPath)
+        const traceFileSuggestedPath = relative.startsWith('..')
+            ? path.join(this.traceDir, 'external', program.absoluteName.slice(1))
+            : path.join(this.traceDir, relative)
+        Tracer.LRUTracer = new Tracer(
+            path.join(path.dirname(traceFileSuggestedPath), path.basename(traceFileSuggestedPath, path.extname(traceFileSuggestedPath)) + '.txt'),
+            programPath
+        )
+    }
+
+    static stopProgramTracing() {
+        Tracer.LRUTracer = undefined
+    }
+
+    static stopGlobalTracing() {
+        Tracer.GlobalTracer.traceEventsStats()
+    }
+
+    private constructor(private traceFilePath: string, inputFilePath?: string) {
+        if (!fs.existsSync(path.dirname(traceFilePath))) {
+            fs.mkdirSync(path.dirname(traceFilePath), { recursive: true })
+        }
+        if (inputFilePath) {
+            Tracer.Tracers.set(inputFilePath, this)
+        }
+    }
+
+    trace(traceLog: string | undefined | void) {
+        if (!traceLog) {
+            return
+        }
+        const lastContext = Tracer.lastContext()
+        fs.appendFileSync(this.traceFilePath, `[${lastContext.padStart(12)}] ${traceLog}\n`, 'utf-8')
+    }
+
+    events: Map<string, number> | undefined
+    eventsPerContext: Map<string, Map<string, number> > | undefined
+
+    recordEvent(event: string) {
+        if (!this.events) {
+            this.events = new Map<string, number>()
+        }
+        this.events.set(event, (this.events.get(event) ?? 0) + 1)
+
+        if (!this.eventsPerContext) {
+            this.eventsPerContext = new Map<string, Map<string, number> >()
+        }
+        if (!this.eventsPerContext.has(Tracer.lastContext())) {
+            this.eventsPerContext.set(Tracer.lastContext(), new Map<string, number>())
+        }
+        const eventsPerContext = this.eventsPerContext.get(Tracer.lastContext())
+        eventsPerContext?.set(event, (eventsPerContext.get(event) ?? 0) + 1)
+    }
+
+    traceEventsStats() {
+        if (this.events && this.eventsPerContext) {
+            const maxLength = Math.max(
+                ...[...this.events.keys()].map(it => `Event "${it}"`.length),
+                ...[...this.eventsPerContext?.keys()].map(it => `  in context [${it}]`.length),
+            )
+            this.trace(`Events stats:`)
+            this.events.forEach((eventCnt: number, event: string) => {
+                this.trace(`${`Event "${event}"`.padEnd(maxLength)}: ${eventCnt}`)
+                this.eventsPerContext?.forEach((localizedEventsMap: Map<string, number>, context: string) => {
+                    localizedEventsMap.forEach((localizedEventCnt: number, localizedEvent: string) => {
+                        if (localizedEvent == event) {
+                            this.trace(`${`  in context [${context}]`.padEnd(maxLength)}: ${localizedEventCnt}`)
+                        }
+                    })
+                })
+            })
+        } else {
+            this.trace('No events recorded')
+        }
+        Tracer.popContext()
+    }
+
+    private static contexts: string[] = []
+
+    static lastContext() {
+        return Tracer.contexts[Tracer.contexts.length - 1]
+    }
+
+    static pushContext(newContext: string) {
+        Tracer.contexts.push(newContext)
+    }
+
+    static popContext() {
+        Tracer.contexts.pop()
+    }
+}
+
+export function traceGlobal(traceLog: () => string | undefined | void, forceLogToConsole: boolean = false) {
+    if (forceLogToConsole) {
+        const result = traceLog()
+        if (result) {
+            console.log(`[${Tracer.lastContext()}] ${result}`)
+        }
+    }
+    if (!Tracer.GlobalTracer) {
+        return
+    }
+    Tracer.GlobalTracer.trace(traceLog())
+}
+
+export function trace(event: string, traceLog: () => string | undefined | void, forceLogToConsole: boolean = false) {
+    if (forceLogToConsole) {
+        const result = traceLog()
+        if (result) {
+            console.log(`[${Tracer.lastContext()}] ${result}`)
+        }
+    }
+    if (!Tracer.GlobalTracer) {
+        return
+    }
+    Tracer.LRUTracer?.trace(traceLog())
+    Tracer.GlobalTracer.recordEvent(event)
+}

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

@@ -13,6 +13,9 @@
  * limitations under the License.
  */
 
+export class Es2pandaError extends Error { }
+export class EarlyExitError extends Error { }
+
 export function throwError(error: string): never {
     throw new Error(error)
 }