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

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

@@ -13,17 +13,22 @@
  * limitations under the License.
  */
 
-import { KNativePointer } from "@koalaui/interop"
+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 } from "../static/global"
-import { acceptNativeObjectArrayResult } from "./private"
+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)
@@ -43,10 +48,7 @@ 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)
@@ -71,6 +73,15 @@ export function extension_ScriptFunctionSetPreferredReturnTypePointer(this: Scri
     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>(
@@ -78,3 +89,32 @@ export function extension_ProgramGetExternalSources(this: Program): ExternalSour
         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, Es2pandaScriptFunctionFlags } 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
     }
@@ -246,7 +263,7 @@ export function getFileName(): string {
 }
 
 export function getJsDoc(node: AstNode): string | undefined {
-    const result = unpackString(global.es2panda._JsdocStringFromDeclaration(global.context, node.peer))
+    const result = unpackString(global.generatedEs2panda._JsdocStringFromDeclaration(global.context, node.peer))
     return result === 'Empty Jsdoc' ? undefined : result
 }
 
@@ -313,18 +330,6 @@ 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,
@@ -351,7 +356,7 @@ 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 signatureReturnType(signature: KNativePointer): KNativePointer {
@@ -361,69 +366,32 @@ export function signatureReturnType(signature: KNativePointer): KNativePointer {
     return global.es2panda._Checker_SignatureReturnType(global.context, signature)
 }
 
-export function tryConvertCheckerTypeToTypeNode(typePeer: KNativePointer | undefined): TypeNode | undefined {
+export function convertCheckerTypeToTypeNode(typePeer: KNativePointer | undefined): TypeNode | undefined {
     if (!typePeer) {
         return undefined
     }
-    const str = unpackString(global.es2panda._Checker_TypeToString(global.context, typePeer))
-    // Primitive types
-    if (str == "void") {
-        return factory.createETSPrimitiveType(Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID)
-    }
-    if (str == "Byte") {
-        return factory.createETSPrimitiveType(Es2pandaPrimitiveType.PRIMITIVE_TYPE_BYTE)
-    }
-    if (str == "Int") {
-        return factory.createETSPrimitiveType(Es2pandaPrimitiveType.PRIMITIVE_TYPE_INT)
-    }
-    if (str == "Long") {
-        return factory.createETSPrimitiveType(Es2pandaPrimitiveType.PRIMITIVE_TYPE_LONG)
-    }
-    if (str == "Short") {
-        return factory.createETSPrimitiveType(Es2pandaPrimitiveType.PRIMITIVE_TYPE_SHORT)
-    }
-    if (str == "Float") {
-        return factory.createETSPrimitiveType(Es2pandaPrimitiveType.PRIMITIVE_TYPE_FLOAT)
-    }
-    if (str == "Double") {
-        return factory.createETSPrimitiveType(Es2pandaPrimitiveType.PRIMITIVE_TYPE_DOUBLE)
-    }
-    if (str == "Boolean") {
-        return factory.createETSPrimitiveType(Es2pandaPrimitiveType.PRIMITIVE_TYPE_BOOLEAN)
-    }
-    if (str == "Char") {
-        return factory.createETSPrimitiveType(Es2pandaPrimitiveType.PRIMITIVE_TYPE_CHAR)
-    }
-    // Special types
-    if (str == "undefined") {
-        return factory.createETSUndefinedType()
-    }
-    // Stdlib types
-    if (str == "String" || str == "Object" || str == "Any") {
-        return factory.createETSTypeReference(
-            factory.createETSTypeReferencePart(
-                factory.createIdentifier(str)
-            )
-        )
-    }
-    // Basic arrow type
-    if (str == "() => void") {
-        return factory.createETSFunctionType(
-            undefined,
-            [],
-            factory.createETSPrimitiveType(Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID),
-            false,
-            Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_NONE,
-            undefined,
-        )
+    return factory.createOpaqueTypeNode(
+        global.es2panda._Checker_TypeClone(global.context, typePeer)
+    )
+}
+
+export function originalSourcePositionString(node: AstNode | undefined) {
+    if (!node) {
+        return `[undefined]`
     }
-    // Only used in samples code
-    if (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)
+    );
 }