@idlizer/arktscgen 2.1.9-arktscgen-8 → 2.1.10-arktscgen-2

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

@@ -34,4 +34,8 @@ export class ExternalSource extends ArktsObject {
             (instance: KNativePointer) => new Program(instance)
         )
     }
+
+    static instantiate(peer: KNativePointer) {
+        return new ExternalSource(peer)
+    }
 }

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

@@ -16,13 +16,12 @@
 import { Es2pandaContextState } from "../generated/Es2pandaEnums"
 import { Program } from "../generated"
 import { ExternalSource } from "./peers/ExternalSource"
-import { programGetExternalSources } from "./node-utilities/Program"
 import { KNativePointer } from "@koalaui/interop"
 import { global } from "./static/global"
 import { RunTransformerHooks } from "../plugin-utils"
 
 export interface CompilationOptions {
-    readonly isMainProgram: boolean,
+    readonly isProgramForCodegeneration: boolean,
     readonly state: Es2pandaContextState,
 }
 
@@ -49,10 +48,10 @@ export function defaultFilter(name: string) {
     return true
 }
 
-export function listPrograms(program: Program, filter: (name: string) => boolean = defaultFilter, context: KNativePointer = global.context): Program[] {
+export function listPrograms(program: Program, filter: (name: string) => boolean = defaultFilter): Program[] {
     return [
         program,
-        ...programGetExternalSources(program, context).flatMap((it: ExternalSource) => {
+        ...program.getExternalSources().flatMap((it: ExternalSource) => {
             if (filter(it.getName())) {
                 return it.programs
             }

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

@@ -21,15 +21,34 @@ import { initInterop, InteropNativeModule } from "../../InteropNativeModule"
 import { Context } from "../peers/Context"
 import { Profiler } from "./profiler"
 import { ArkTsConfig } from "../../generated"
+import { Config } from '../peers/Config';
+
+export class UpdateTracker {
+    stack: boolean[] = []
+
+    push() {
+        this.stack.push(false)
+    }
+
+    update() {
+        this.stack[this.stack.length - 1] = true
+    }
+
+    check() {
+        return this.stack.pop()
+    }
+}
 
 export class global {
     public static filePath: string = "./plugins/input/main.ets"
 
     public static arktsconfig?: ArkTsConfig
+    public static configObj?: Config;
 
     private static _config?: KNativePointer
     public static set config(config: KNativePointer) {
         global._config = config
+        global.configObj = new Config(global._config);
     }
     public static get config(): KNativePointer {
         return global._config ?? throwError('Global.config not initialized')
@@ -39,6 +58,7 @@ export class global {
     }
     public static resetConfig(): void {
         global._config = undefined
+        global.configObj = undefined;
     }
 
     // Improve: rename to contextPeer
@@ -47,7 +67,8 @@ export class global {
     }
 
     // Improve: rename to context when the pointer valued one is eliminated
-    public static compilerContext: Context
+    public static compilerContext: Context | undefined
+    public static isContextGenerateAbcForExternalSourceFiles: boolean = false
 
     private static _es2panda: Es2pandaNativeModule | undefined = undefined
     public static get es2panda(): Es2pandaNativeModule {
@@ -76,4 +97,11 @@ export class global {
 
     // Check node type values during node creation
     public static validatePeerTypes = false
+
+    public static clearContext(): void {
+        global.compilerContext = undefined
+    }
+
+    // Keep track of update info to optimize performance
+    public static updateTracker: UpdateTracker = new UpdateTracker()
 }

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

@@ -13,13 +13,22 @@
  * limitations under the License.
  */
 
+import { KInt, KNativePointer } from "@koalaui/interop"
 import type {
+    ClassDefinition,
     ETSModule,
+    Expression,
     MethodDefinition,
+    NumberLiteral,
+    Program,
     ScriptFunction,
+    SourcePosition,
 } from "../../generated"
+import { ExternalSource } from "../peers/ExternalSource"
 import { Es2pandaModuleFlag } from "../../generated/Es2pandaEnums"
-import { global, KNativePointer } from "../../reexport-for-generated"
+import { global } from "../static/global"
+import { acceptNativeObjectArrayResult, passNodeArray } from "./private"
+import type { AstNode } from "../peers/AstNode"
 
 export function extension_ETSModuleGetNamespaceFlag(this: ETSModule): Es2pandaModuleFlag {
     return (this.isETSScript ? Es2pandaModuleFlag.MODULE_FLAG_ETSSCRIPT : 0)
@@ -27,6 +36,7 @@ export function extension_ETSModuleGetNamespaceFlag(this: ETSModule): Es2pandaMo
         + (this.isNamespaceChainLastNode ? Es2pandaModuleFlag.MODULE_FLAG_NAMESPACE_CHAIN_LAST_NODE : 0)
 }
 
+// this is a workaround for overloads not included in children list
 export function extension_MethodDefinitionSetChildrenParentPtr(this: MethodDefinition) {
     global.es2panda._AstNodeSetChildrenParentPtr(global.context, this.peer)
     const overloads = this.overloads
@@ -38,16 +48,23 @@ export function extension_MethodDefinitionSetChildrenParentPtr(this: MethodDefin
 
 export function extension_MethodDefinitionOnUpdate(this: MethodDefinition, original: MethodDefinition): void {
     this.setChildrenParentPtr()
-    // Improve: Update modifiers only for specific AST nodes in the generated factory code
-    this.modifierFlags = original.modifierFlags
-    global.generatedEs2panda._AstNodeSetOriginalNode(global.context, this.peer, original.originalPeer)
-    global.generatedEs2panda._AstNodeSetParent(global.context, this.peer, global.generatedEs2panda._AstNodeParent(global.context, original.peer))
+    global.es2panda._AstNodeOnUpdate(global.context, this.peer, original.peer)
     const originalBase = original.baseOverloadMethod
     if (originalBase) {
         this.setBaseOverloadMethod(originalBase)
     }
 }
 
+// Improve: generate checker related stuff
+export function extension_ScriptFunctionGetSignaturePointer(this: ScriptFunction): KNativePointer {
+    return global.es2panda._Checker_ScriptFunctionSignature(global.context, this.peer)
+}
+
+export function extension_ScriptFunctionSetSignaturePointer(this: ScriptFunction, signaturePointer: KNativePointer): void {
+    global.es2panda._Checker_ScriptFunctionSetSignature(global.context, this.peer, signaturePointer)
+}
+
+// Improve: perhaps "preferredReturnType" stuff can be removed later if "signature" is always enough
 export function extension_ScriptFunctionGetPreferredReturnTypePointer(this: ScriptFunction): KNativePointer {
     return global.es2panda._Checker_ScriptFunctionGetPreferredReturnType(global.context, this.peer)
 }
@@ -55,3 +72,49 @@ export function extension_ScriptFunctionGetPreferredReturnTypePointer(this: Scri
 export function extension_ScriptFunctionSetPreferredReturnTypePointer(this: ScriptFunction, typePointer: KNativePointer): void {
     global.es2panda._Checker_ScriptFunctionSetPreferredReturnType(global.context, this.peer, typePointer)
 }
+
+// Improve: generate checker related stuff
+export function extension_ExpressionGetPreferredTypePointer(this: Expression): KNativePointer {
+    return global.es2panda._Checker_ExpressionGetPreferredType(global.context, this.peer)
+}
+
+export function extension_ExpressionSetPreferredTypePointer(this: Expression, typePointer: KNativePointer): void {
+    global.es2panda._Checker_ExpressionSetPreferredType(global.context, this.peer, typePointer)
+}
+
+// Improve: generate methods with string[] args or return type
+export function extension_ProgramGetExternalSources(this: Program): ExternalSource[] {
+    return acceptNativeObjectArrayResult<ExternalSource>(
+        global.es2panda._ProgramExternalSources(global.context, this.peer),
+        ExternalSource.instantiate,
+    )
+}
+
+// Improve: SourcePositionLine is global in idl
+export function extension_SourcePositionGetLine(this: SourcePosition): KInt {
+    return global.generatedEs2panda._SourcePositionLine(global.context, this.peer)
+}
+
+// Improve: SourcePositionCol is not described in idl
+export function extension_SourcePositionGetCol(this: SourcePosition): KInt {
+    return global.es2panda._SourcePositionCol(global.context, this.peer)
+}
+
+export function extension_SourcePositionToString(this: SourcePosition): string {
+    return `:${this.getLine() + 1}:${this.getCol()}`
+}
+
+// Improve: weird API
+export function extension_NumberLiteralValue(this: NumberLiteral): number {
+    return +this.dumpSrc()
+}
+
+// Improve: weird API
+export function extension_ScriptFunctionSetParams(this: ScriptFunction, params: readonly Expression[]): void {
+    global.es2panda._ScriptFunctionSetParams(global.context, this.peer, passNodeArray(params), params.length)
+}
+
+// Improve: weird API
+export function extension_ClassDefinitionSetBody(this: ClassDefinition, body: readonly AstNode[]): void {
+    global.es2panda._ClassDefinitionSetBody(global.context, this.peer, passNodeArray(body), body.length)
+}

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

@@ -25,7 +25,7 @@ import {
 } from "@koalaui/interop"
 import { NativePtrDecoder } from "./nativePtrDecoder"
 import { Es2pandaAstNodeType, Es2pandaModifierFlags, Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums"
-import { classByPeer } from "../class-by-peer"
+import { nodeFrom } from "../class-by-peer"
 import { AstNode } from "../peers/AstNode"
 import { ArktsObject } from "../peers/ArktsObject"
 
@@ -72,14 +72,14 @@ export function unpackNonNullableNode<T extends AstNode>(peer: KNativePointer):
     if (peer === nullptr) {
         throwError('peer is NULLPTR (maybe you should use unpackNode)')
     }
-    return classByPeer(peer)
+    return nodeFrom(peer)
 }
 
 export function unpackNode<T extends AstNode>(peer: KNativePointer): T | undefined {
     if (peer === nullptr) {
         return undefined
     }
-    return classByPeer<T>(peer)
+    return nodeFrom<T>(peer)
 }
 
 export function passNode(node: ArktsObject | undefined): KNativePointer {

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

@@ -16,9 +16,10 @@
 import { global } from "../static/global"
 import { isNumber, throwError, withWarning } from "../../utils"
 import { KNativePointer, nullptr, KInt} from "@koalaui/interop"
-import { passNode, passNodeArray, unpackNodeArray, unpackNonNullableNode, passString, unpackString } from "./private"
-import { Es2pandaContextState, Es2pandaModifierFlags, Es2pandaMethodDefinitionKind, Es2pandaPrimitiveType } from "../../generated/Es2pandaEnums"
+import { passNode, passNodeArray, unpackNodeArray, unpackNonNullableNode, passString, unpackString, nodeType } from "./private"
+import { Es2pandaContextState, Es2pandaModifierFlags, Es2pandaMethodDefinitionKind, Es2pandaPrimitiveType, Es2pandaScriptFunctionFlags, Es2pandaAstNodeType } from "../../generated/Es2pandaEnums"
 import type { AstNode } from "../peers/AstNode"
+import { SourcePosition } from "../../generated"
 import { isSameNativeObject } from "../peers/ArktsObject"
 import {
     type AnnotationUsage,
@@ -48,6 +49,7 @@ import { Context } from "../peers/Context"
 import { NodeCache } from "../node-cache"
 import { listPrograms } from "../plugins"
 import { factory } from "../factory/nodeFactory"
+import { traceGlobal } from "../../tracer"
 
 /**
  * Improve: Replace or remove with better naming
@@ -55,16 +57,16 @@ import { factory } from "../factory/nodeFactory"
  * @deprecated
  */
 export function createETSModuleFromContext(): ETSModule {
-    let program = global.es2panda._ContextProgram(global.context)
+    let program = global.generatedEs2panda._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)
+    const ast = global.generatedEs2panda._ProgramAst(global.context, program)
     if (ast == nullptr) {
         throw new Error(`AST is null for program ${program.toString(16)}`)
 
     }
-    return new ETSModule(ast)
+    return new ETSModule(ast, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE)
 }
 
 /**
@@ -82,10 +84,10 @@ export function createETSModuleFromSource(
     }
     global.compilerContext = Context.createFromString(source)
     proceedToState(state)
-    let program = global.es2panda._ContextProgram(global.compilerContext.peer)
+    let program = global.generatedEs2panda._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))
+    return new ETSModule(global.generatedEs2panda._ProgramAst(global.context, program), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE)
 }
 
 export function metaDatabase(fileName: string): string {
@@ -95,7 +97,8 @@ export function metaDatabase(fileName: string): string {
 
 export function checkErrors() {
     if (global.es2panda._ContextState(global.context) === Es2pandaContextState.ES2PANDA_STATE_ERROR) {
-        console.log(unpackString(global.es2panda._GetAllErrorMessages(global.context)))
+        traceGlobal(() => `Terminated due to compilation errors occured`)
+        console.log(unpackString(global.generatedEs2panda._GetAllErrorMessages(global.context)))
         // global.es2panda._DestroyConfig(global.config)
         process.exit(1)
     }
@@ -105,49 +108,63 @@ export function proceedToState(state: Es2pandaContextState): void {
     if (state <= global.es2panda._ContextState(global.context)) {
         return
     }
+    NodeCache.clear()
     const before = Date.now()
+    traceGlobal(() => `Proceeding to state ${Es2pandaContextState[state]}: start`)
     global.es2panda._ProceedToState(global.context, state)
+    traceGlobal(() => `Proceeding to state ${Es2pandaContextState[state]}: done`)
     const after = Date.now()
     global.profiler.proceededToState(after-before)
-    NodeCache.clear()
     checkErrors()
 }
 
 /** @deprecated Use {@link rebindContext} instead */
 export function rebindSubtree(node: AstNode): void {
+    NodeCache.clear()
+    traceGlobal(() => `Rebind: start`)
     global.es2panda._AstNodeRebind(global.context, node.peer)
+    traceGlobal(() => `Rebind: done`)
     checkErrors()
 }
 
 /** @deprecated Use {@link recheckSubtree} instead */
 export function recheckSubtree(node: AstNode): void {
-    global.es2panda._AstNodeRecheck(global.context, node.peer)
+    NodeCache.clear()
+    traceGlobal(() => `Recheck: start`)
+    global.generatedEs2panda._AstNodeRecheck(global.context, node.peer)
+    traceGlobal(() => `Recheck: done`)
     checkErrors()
 }
 
 export function rebindContext(context: KNativePointer = global.context): void {
+    NodeCache.clear()
+    traceGlobal(() => `Rebind: start`)
     global.es2panda._AstNodeRebind(
         context,
-        global.es2panda._ProgramAst(
+        global.generatedEs2panda._ProgramAst(
             context,
-            global.es2panda._ContextProgram(
+            global.generatedEs2panda._ContextProgram(
                 context
             )
         )
     )
+    traceGlobal(() => `Rebind: done`)
     checkErrors()
 }
 
 export function recheckContext(context: KNativePointer = global.context): void {
-    global.es2panda._AstNodeRecheck(
+    NodeCache.clear()
+    traceGlobal(() => `Recheck: start`)
+    global.generatedEs2panda._AstNodeRecheck(
         context,
-        global.es2panda._ProgramAst(
+        global.generatedEs2panda._ProgramAst(
             context,
-            global.es2panda._ContextProgram(
+            global.generatedEs2panda._ContextProgram(
                 context,
             )
         )
     )
+    traceGlobal(() => `Recheck: done`)
     checkErrors()
 }
 
@@ -208,7 +225,7 @@ function getDeclFromArrayOrObjectMember(node: MemberExpression): AstNode | undef
 }
 
 export function getPeerDecl(peer: KNativePointer): AstNode | undefined {
-    const decl = global.es2panda._DeclarationFromIdentifier(global.context, peer)
+    const decl = global.generatedEs2panda._DeclarationFromIdentifier(global.context, peer)
     if (decl === nullptr) {
         return undefined
     }
@@ -245,6 +262,12 @@ export function getFileName(): string {
     return global.filePath
 }
 
+export function getJsDoc(node: AstNode): string | undefined {
+    const result = unpackString(global.generatedEs2panda._JsdocStringFromDeclaration(global.context, node.peer))
+    return result === 'Empty Jsdoc' ? undefined : result
+}
+
+
 // Improve: 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
@@ -307,30 +330,20 @@ export function findStdlib(): string {
     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)
-}
-
 export function generateTsDeclarationsFromContext(
   outputDeclEts: string,
   outputEts: string,
   exportAll: boolean,
-  isolated: boolean
+  isolated: boolean,
+  recordFile: string
 ): KInt {
   return global.es2panda._GenerateTsDeclarationsFromContext(
     global.context,
     passString(outputDeclEts),
     passString(outputEts),
     exportAll,
-    isolated
+    isolated,
+    recordFile
   );
 }
 
@@ -343,23 +356,42 @@ export function getProgramFromAstNode(node: AstNode): Program {
 }
 
 export function importDeclarationInsert(node: ETSImportDeclaration, program: Program): void {
-    global.es2panda._InsertETSImportDeclarationAndParse(global.context, program.peer, node.peer)
+    global.generatedEs2panda._InsertETSImportDeclarationAndParse(global.context, program.peer, node.peer)
 }
 
-export function tryConvertCheckerTypeToTypeNode(typePeer: KNativePointer | undefined): TypeNode | undefined {
+export function signatureReturnType(signature: KNativePointer): KNativePointer {
+    if (!signature) {
+        return nullptr
+    }
+    return global.es2panda._Checker_SignatureReturnType(global.context, signature)
+}
+
+export function convertCheckerTypeToTypeNode(typePeer: KNativePointer | undefined): TypeNode | undefined {
     if (!typePeer) {
         return undefined
     }
-    const str = unpackString(global.es2panda._Checker_TypeToString(global.context, typePeer))
-    if (str == "void") {
-        return factory.createETSPrimitiveType(Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID)
+    return factory.createOpaqueTypeNode(
+        global.es2panda._Checker_TypeClone(global.context, typePeer)
+    )
+}
+
+export function originalSourcePositionString(node: AstNode | undefined) {
+    if (!node) {
+        return `[undefined]`
     }
-    if (str == "String" || str == "StringerNode") {
-        return factory.createETSTypeReference(
-            factory.createETSTypeReferencePart(
-                factory.createIdentifier(str)
-            )
-        )
+    const originalPeer = node.originalPeer
+    const sourcePosition = new SourcePosition(global.generatedEs2panda._AstNodeStartConst(global.context, originalPeer))
+    const program = new Program(global.es2panda._AstNodeProgram(global.context, originalPeer))
+    if (!program.peer) {
+        // This can happen if we are calling this method on node that is in update now and parent chain does not lead to program
+        return `[${global.filePath}${sourcePosition.toString()}]`
     }
-    return undefined
+    return `[${program.absoluteName}${sourcePosition.toString()}]`
+}
+
+export function generateStaticDeclarationsFromContext(outputPath: string): KInt {
+    return global.generatedEs2panda._GenerateStaticDeclarationsFromContext(
+        global.context,
+        passString(outputPath)
+    );
 }