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

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

@@ -15,11 +15,11 @@
 
 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 { KNativePointer, nullptr, KInt, KUInt} from "@koalaui/interop"
+import { passNode, unpackNodeArray, unpackNonNullableNode, passString, unpackString, passStringArray } from "./private"
+import { Es2pandaContextState, Es2pandaModifierFlags, Es2pandaMethodDefinitionKind, Es2pandaAstNodeType, Es2pandaPluginDiagnosticType } from "../../generated/Es2pandaEnums"
 import type { AstNode } from "../peers/AstNode"
-import { isSameNativeObject } from "../peers/ArktsObject"
+import { DiagnosticInfo, SourcePosition, SourceRange, SuggestionInfo } from "../../generated"
 import {
     type AnnotationUsage,
     ClassDefinition,
@@ -31,7 +31,6 @@ import {
     isScriptFunction,
     isIdentifier,
     isETSModule,
-    ImportSpecifier,
     Program,
     isObjectExpression,
     ETSImportDeclaration,
@@ -46,8 +45,9 @@ import {
 import { Config } from "../peers/Config"
 import { Context } from "../peers/Context"
 import { NodeCache } from "../node-cache"
-import { listPrograms } from "../plugins"
 import { factory } from "../factory/nodeFactory"
+import { traceGlobal } from "../../tracer"
+import { DiagnosticKind } from "../peers/DiagnosticKind"
 
 /**
  * Improve: Replace or remove with better naming
@@ -55,16 +55,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 +82,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 +95,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 +106,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 +223,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 +261,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 +328,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 +354,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 +364,68 @@ 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()
+    return factory.createOpaqueTypeNode(
+        global.es2panda._Checker_TypeClone(global.context, typePeer)
+    )
+}
+
+export function originalSourcePositionString(node: AstNode | undefined) {
+    if (!node) {
+        return `[undefined]`
     }
-    // Stdlib types
-    if (str == "String" || str == "Object" || str == "Any") {
-        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()}]`
     }
-    // Basic arrow type
-    if (str == "() => void") {
-        return factory.createETSFunctionType(
-            undefined,
-            [],
-            factory.createETSPrimitiveType(Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID),
-            false,
-            Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_NONE,
-            undefined,
-        )
-    }
-    // Only used in samples code
-    if (str == "StringerNode") {
-        return factory.createETSTypeReference(
-            factory.createETSTypeReferencePart(
-                factory.createIdentifier(str)
-            )
-        )
+    return `[${program.absoluteName}${sourcePosition.toString()}]`
+}
+
+export function generateStaticDeclarationsFromContext(outputPath: string): KInt {
+    return global.generatedEs2panda._GenerateStaticDeclarationsFromContext(
+        global.context,
+        passString(outputPath)
+    );
+}
+
+export function createTypeNodeFromTsType(node: AstNode): AstNode | undefined {
+    const typeAnnotation = global.es2panda._CreateTypeNodeFromTsType(global.context, node.peer);
+    if (typeAnnotation === nullptr) {
+        return undefined;
     }
-    return undefined
+    return unpackNonNullableNode(typeAnnotation);
+}
+
+export function createSourcePosition(index: KUInt, line: KUInt): SourcePosition {
+    return new SourcePosition(global.generatedEs2panda._CreateSourcePosition(global.context, index, line))
+}
+
+export function createSourceRange(start: SourcePosition, end: SourcePosition): SourceRange {
+    return new SourceRange(global.generatedEs2panda._CreateSourceRange(global.context, start.peer, end.peer))
+}
+
+export function createDiagnosticInfo(kind: DiagnosticKind, position: SourcePosition, ...args: string[]): DiagnosticInfo {
+    return new DiagnosticInfo(global.es2panda._CreateDiagnosticInfo(global.context, kind.peer, passStringArray(args), args.length, position.peer))
+}
+
+export function createSuggestionInfo(kind: DiagnosticKind, substitutionCode: string, title: string, range: SourceRange, ...args: string[]): SuggestionInfo {
+    return new SuggestionInfo(global.es2panda._CreateSuggestionInfo(global.context, kind.peer, passStringArray(args), args.length, substitutionCode, title, range.peer))
+}
+
+export function createDiagnosticKind(message: string, type: Es2pandaPluginDiagnosticType): DiagnosticKind {
+    return new DiagnosticKind(global.es2panda._CreateDiagnosticKind(global.context, message, type));
+}
+
+export function logDiagnostic(kind: DiagnosticKind, pos: SourcePosition, ...args: string[]): void {
+    global.es2panda._LogDiagnostic(global.context, kind.peer, passStringArray(args), args.length, pos.peer);
+}
+
+export function logDiagnosticWithSuggestion(diagnosticInfo: DiagnosticInfo, suggestionInfo: SuggestionInfo): void {
+    global.generatedEs2panda._LogDiagnosticWithSuggestion(global.context, diagnosticInfo.peer, suggestionInfo.peer);
 }