@idlizer/arktscgen 2.1.5 → 2.1.9-arktscgen-4

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

@@ -1,25 +1,197 @@
-export class Profiler {
-    totalTime = 0
-    transformTime = 0
-    proceedTime = 0
-    restartTime = 0
-    visitedNodes = 0
-    createdNodes = 0
+/*
+ * Copyright (c) 2022-2023 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 "fs"
+import * as path from "path"
+import { Es2pandaContextState } from "../../generated/Es2pandaEnums"
+import { global } from "./global"
+
+const PERFORMANCE_DATA_DIR = "./performance-results/"
+
+interface PluginData {
+    transformTime: number
+    transformTimeDeps: number
+    visitedNodes: number
+    createdNodes: number
+    contextState?: Es2pandaContextState
+}
+
+function emptyPluginData(contextState?: Es2pandaContextState): PluginData {
+    return {
+        transformTime: 0,
+        transformTimeDeps: 0,
+        visitedNodes: 0,
+        createdNodes: 0,
+        contextState: contextState
+    }
+}
+
+interface PerformanceData {
+    filePath: string
+
+    visitedNodes: number
+    createdNodes: number
+    restartTime: number
+    proceedTime: number
+    totalTime: number
+
+    pluginsByName: Record<string, PluginData>
+}
+
+interface PerformanceDataFile {
+    data: PerformanceData[]
+    summary?: PerformanceData
+}
+
+function parseFile(performanceFile: string): PerformanceDataFile | undefined {
+    if (!fs.existsSync(performanceFile)) return undefined
+
+    const data = fs.readFileSync(path.resolve(performanceFile)).toString()
+    if (!data.length) return undefined
+    return JSON.parse(data) as PerformanceDataFile
+}
+
+export class Profiler implements PerformanceData {
+    filePath: string = ""
+    visitedNodes: number = 0
+    createdNodes: number = 0
+    restartTime: number = 0
+    proceedTime: number = 0
+    totalTime: number = 0
+    pluginsByName: Record<string, PluginData> = {}
+
+    curPlugin: string = ""
+    curContextState?: Es2pandaContextState
+
+    private getPluginData(pluginName: string, contextState?: Es2pandaContextState): PluginData {
+        if (!(pluginName in this.pluginsByName)) {
+            this.pluginsByName[pluginName] = emptyPluginData(contextState)
+        }
+        return this.pluginsByName[pluginName]
+    }
+
+    disableReport = false
+
+    nodeCreated() {
+        this.createdNodes++
+        if (this.curPlugin) this.getPluginData(this.curPlugin, this.curContextState).createdNodes++
+    }
+
+    nodeVisited() {
+        this.visitedNodes++
+        if (this.curPlugin) this.getPluginData(this.curPlugin, this.curContextState).visitedNodes++
+    }
+
+    private transformStartTime = 0
+    transformStarted() {
+        this.transformStartTime = Date.now()
+    }
+    private transformDepStartTime = 0
+    transformDepStarted() {
+        this.transformDepStartTime = Date.now()
+    }
+
+    transformEnded(state: Es2pandaContextState, pluginName: string) {
+        const transformEndTime = Date.now()
+        const consumedTime = transformEndTime - this.transformStartTime
+        this.getPluginData(pluginName, state).transformTime += consumedTime
+    }
+
+    transformDepEnded(state: Es2pandaContextState, pluginName: string) {
+        const transformEndTime = Date.now()
+        const consumedTime = transformEndTime - this.transformDepStartTime
+        this.getPluginData(pluginName, state).transformTimeDeps += consumedTime
+    }
+
+    restarted(consumedTime: number) {
+        this.restartTime += consumedTime
+    }
+
+    proceededToState(consumedTime: number) {
+        this.proceedTime += consumedTime
+    }
+
+    private compilationStartTime = 0
+    compilationStarted(filePath: string) {
+        this.filePath = filePath
+
+        this.visitedNodes = 0
+        this.createdNodes = 0
+        this.restartTime = 0
+        this.proceedTime = 0
+        this.totalTime = 0
+        this.pluginsByName = {}
+
+        this.curPlugin = ""
+        this.compilationStartTime = Date.now()
+    }
+
+    compilationEnded() {
+        const consumedTime: number = Date.now() - this.compilationStartTime
+        this.totalTime = consumedTime
+    }
 
     report() {
-        console.log(
-            "total compiler:",
-            this.totalTime,
-            " proceeds:",
-            this.proceedTime,
-            " restarts",
-            this.restartTime,
-            " transforms:",
-            this.transformTime,
-            " visited:",
-            this.visitedNodes,
-            " created:",
-            this.createdNodes
-        )
-    }
-}
+        Object.entries(this.pluginsByName).forEach((data, key) => {
+            console.log(data[0], "totalTransformTime =", data[1].transformTime, "ms")
+            console.log(data[0], "totalDepsTransformTime =", data[1].transformTimeDeps, "ms")
+        })
+    }
+
+    reportToFile(withSummary: boolean = false) {
+        if (this.disableReport) return
+        const outDir = path.resolve(global.arktsconfig!.outDir, PERFORMANCE_DATA_DIR)
+        fs.mkdirSync(outDir, { recursive: true })
+        const outFilePath = path.resolve(outDir, path.basename(this.filePath)) + ".json"
+    
+        const data: PerformanceDataFile = { data: [this as PerformanceData] }
+        if (!fs.existsSync(outFilePath)) {
+            fs.writeFileSync(outFilePath, JSON.stringify(data))
+        } else {
+            const savedData: PerformanceDataFile | undefined = parseFile(outFilePath) ?? data
+            savedData.data.push(this as PerformanceData)
+
+            if (withSummary) {
+                const summary: PerformanceData = {
+                    filePath: this.filePath,
+                    visitedNodes: savedData.data.map(it => it.visitedNodes).reduce((sum, it) => sum + it),
+                    createdNodes: savedData.data.map(it => it.createdNodes).reduce((sum, it) => sum + it),
+                    restartTime: savedData.data.map(it => it.restartTime).reduce((sum, it) => sum + it),
+                    proceedTime: savedData.data.map(it => it.proceedTime).reduce((sum, it) => sum + it),
+                    totalTime: savedData.data.map(it => it.totalTime).reduce((sum, it) => sum + it),
+                    pluginsByName: {}
+                }
+                const pluginNames = new Set(savedData.data.flatMap(it => Object.keys(it.pluginsByName)))
+                for (const pluginName of pluginNames) {
+                    const sumTransformTime = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].transformTime).reduce((sum, it) => sum+it)
+                    const sumTransformTimeDeps = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].transformTimeDeps).reduce((sum, it) => sum+it)
+                    const sumCreatedNodes = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].createdNodes).reduce((sum, it) => sum+it)
+                    const sumVisitedNodes = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].visitedNodes).reduce((sum, it) => sum+it)
+
+                    summary.pluginsByName[pluginName] = {
+                        transformTime: sumTransformTime,
+                        transformTimeDeps: sumTransformTimeDeps,
+                        createdNodes: sumCreatedNodes,
+                        visitedNodes: sumVisitedNodes,
+                    }
+                }
+
+                savedData.summary = summary
+            }
+
+            fs.writeFileSync(outFilePath, JSON.stringify(savedData))
+        }
+    }
+}

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

@@ -21,8 +21,7 @@ import {
     KNativePointer,
     nullptr,
     withString,
-    withStringArray,
-    withStringResult
+    withStringArray
 } from "@koalaui/interop"
 import { NativePtrDecoder } from "./nativePtrDecoder"
 import { Es2pandaAstNodeType, Es2pandaModifierFlags, Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums"
@@ -117,16 +116,15 @@ export function unpackObject<T extends ArktsObject>(type: { new (peer: KNativePo
 }
 
 export function unpackString(peer: KNativePointer): string {
-    return withStringResult(peer) ?? throwError(`failed to unpack (peer shouldn't be NULLPTR)`)
+    return global.interop._RawUtf8ToString(peer)
 }
 
+// TODO: use direct string arguments instead.
 export function passString(str: string | undefined): string {
-    if (str === undefined) {
-        return ""
-    }
-    return withString(str, (it: string) => it)
+    return str ?? ""
 }
 
+// TODO: use direct string arguments instead.
 export function passStringArray(strings: readonly string[]): string[] {
     return withStringArray(strings, (it: string[]) => it)
 }
@@ -145,9 +143,7 @@ export function updateNodeByNode<T extends ArktsObject>(node: T, original: T): T
     if (original.peer === nullptr) {
         throwError('update called on NULLPTR')
     }
-    if (original instanceof AstNode) {
-        global.generatedEs2panda._AstNodeSetOriginalNode(global.context, node.peer, original.originalPeer)
-    }
+    original.onUpdate(node)
     global.generatedEs2panda._AstNodeSetParent(global.context, node.peer, global.generatedEs2panda._AstNodeParent(global.context, original.peer))
     global.es2panda._AstNodeUpdateChildren(global.context, node.peer)
     return node
@@ -156,3 +152,33 @@ export function updateNodeByNode<T extends ArktsObject>(node: T, original: T): T
 export function nodeType(node: AstNode): Es2pandaAstNodeType {
     return global.generatedEs2panda._AstNodeTypeConst(global.context, passNode(node))
 }
+
+/**
+ * @deprecated
+ */
+export function compose<T extends ArktsObject, ARGS extends any[]>(
+    create: (...args: ARGS) => T,
+    update: (node: T, original: T) => T = updateNodeByNode
+): (node: T, ...args: ARGS) => T {
+    return (node: T, ...args: ARGS) => update(create(...args), node);
+}
+
+export function updateThenAttach<T extends ArktsObject, ARGS extends any[]>(
+    update: (original: T, ...args: ARGS) => T,
+    ...attachFuncs: ((node: T, original: T) => T)[]
+): (node: T, ...args: ARGS) => T {
+    return (node: T, ...args: ARGS) => {
+        let _node: T = update(node, ...args);
+        attachFuncs.forEach((attach) => {
+            _node = attach(_node, node);
+        });
+        return _node;
+    };
+}
+
+export function attachModifiers<T extends ArktsObject>(node: T, original: T): T {
+    if (node instanceof AstNode && original instanceof AstNode) {
+        node.modifiers = original.modifiers;
+    }
+    return node;
+}

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

@@ -14,29 +14,40 @@
  */
 
 import { global } from "../static/global"
-import { isNumber, throwError } from "../../utils"
+import { isNumber, throwError, withWarning } from "../../utils"
 import { KNativePointer, nullptr } from "@koalaui/interop"
 import { passNode, passNodeArray, unpackNodeArray, unpackNonNullableNode } from "./private"
 import { Es2pandaContextState, Es2pandaModifierFlags } from "../../generated/Es2pandaEnums"
 import type { AstNode } from "../peers/AstNode"
+import { isSameNativeObject } from "../peers/ArktsObject"
 import {
     type AnnotationUsage,
     ClassDefinition,
     ClassProperty,
-    ETSImportDeclaration,
     ETSModule,
     isClassDefinition,
     isFunctionDeclaration,
     isMemberExpression,
     isScriptFunction,
-    isIdentifier
+    isIdentifier,
+    isETSModule
 } from "../../generated"
 import { Config } from "../peers/Config"
 import { Context } from "../peers/Context"
 import { NodeCache } from "../node-cache"
+import { listPrograms } from "../plugins"
 
 export function createETSModuleFromContext(): ETSModule {
-    return new ETSModule(global.es2panda._ProgramAst(global.context, global.es2panda._ContextProgram(global.context)))
+    let program = global.es2panda._ContextProgram(global.context)
+    if (program == nullptr) {
+        throw new Error(`Program is null for context ${global.context.toString(16)}`)
+    }
+    const ast = global.es2panda._ProgramAst(global.context, program)
+    if (ast == nullptr) {
+        throw new Error(`AST is null for program ${program.toString(16)}`)
+
+    }
+    return new ETSModule(ast)
 }
 
 export function createETSModuleFromSource(
@@ -48,13 +59,24 @@ export function createETSModuleFromSource(
     }
     global.compilerContext = Context.createFromString(source)
     proceedToState(state)
-    return new ETSModule(global.es2panda._ProgramAst(global.context, global.es2panda._ContextProgram(global.context)))
+    let program = global.es2panda._ContextProgram(global.compilerContext.peer)
+    if (program == nullptr)
+        throw new Error(`Program is null for ${source} 0x${global.compilerContext.peer.toString(16)}`)
+    return new ETSModule(global.es2panda._ProgramAst(global.context, program))
+}
+
+export function metaDatabase(fileName: string): string {
+    if (fileName.endsWith(".meta.json")) throw new Error(`Must pass source, not database: ${fileName}`)
+    return `${fileName}.meta.json`
 }
 
 export function updateETSModuleByStatements(
     node: ETSModule,
     statements: readonly AstNode[],
 ): ETSModule {
+    if (isSameNativeObject(statements, node.statements)) {
+        return node
+    }
     global.generatedEs2panda._BlockStatementSetStatements(global.context, node.peer, passNodeArray(statements), statements.length)
     return node
 }
@@ -75,7 +97,7 @@ export function proceedToState(state: Es2pandaContextState): void {
     const before = Date.now()
     global.es2panda._ProceedToState(global.context, state)
     const after = Date.now()
-    global.profiler.proceedTime += after-before
+    global.profiler.proceededToState(after-before)
     NodeCache.clear()
     checkErrors()
 }
@@ -94,6 +116,19 @@ export function rebindSubtree(node: AstNode): void {
     checkErrors()
 }
 
+export function recheckContext(context: KNativePointer): void {
+    global.es2panda._AstNodeRecheck(
+        context,
+        global.es2panda._ProgramAst(
+            context,
+            global.es2panda._ContextProgram(
+                context
+            )
+        )
+    )
+    checkErrors()
+}
+
 export function getDecl(node: AstNode): AstNode | undefined {
     if (isMemberExpression(node)) {
         return getDecl(node.property!)
@@ -131,14 +166,6 @@ export function getFileName(): string {
     return global.filePath
 }
 
-export function getPackageName(): string {
-    return global.packageName
-}
-
-export function getFilePathFromPackageRoot(): string {
-    return global.filePathFromPackageRoot
-}
-
 // TODO: It seems like Definition overrides AstNode  modifiers
 // with it's own modifiers which is completely unrelated set of flags.
 // Use this function if you need
@@ -157,12 +184,6 @@ export function classPropertySetOptional(node: ClassProperty, value: boolean): C
     return node;
 }
 
-// TODO: Import statements should be inserted to the statements.
-export function importDeclarationInsert(node: ETSImportDeclaration): void {
-    const program = global.compilerContext.program; // TODO: external source has different program. Currently not considered.
-    global.es2panda._InsertETSImportDeclarationAndParse(global.context, program.peer, node.peer)
-}
-
 export function hasModifierFlag(node: AstNode, flag: Es2pandaModifierFlags): boolean {
     if (!node) return false;
 
@@ -188,6 +209,33 @@ export function nameIfIdentifier(node: AstNode): string {
     return isIdentifier(node) ? `'${node.name}'` : ""
 }
 
+export function nameIfETSModule(node: AstNode): string {
+    return isETSModule(node) ? `'${node.ident?.name}'` : ""
+}
+
 export function asString(node: AstNode|undefined): string {
     return `${node?.constructor.name} ${node ? nameIfIdentifier(node) : undefined}`
 }
+
+const defaultPandaSdk = "../../../incremental/tools/panda/node_modules/@panda/sdk"
+
+
+export function findStdlib(): string {
+    const sdk = process.env.PANDA_SDK_PATH ?? withWarning(
+        defaultPandaSdk,
+        `PANDA_SDK_PATH not set, assuming ${defaultPandaSdk}`
+    )
+    return `${sdk}/ets/stdlib`
+}
+
+export function collectDependencies(files: string[], configPath: string): string[] {
+    const result = new Set<string>()
+    for (let file of files) {
+        const context = Context.createFromFile(file, configPath, findStdlib(), "/tmp/foo.abc")!
+        global.compilerContext = context
+        proceedToState(Es2pandaContextState.ES2PANDA_STATE_PARSED)
+        listPrograms(context.program).forEach(it => result.add(it.absoluteName))
+        context.destroy()
+    }
+    return Array.from(result)
+}