@idlizer/arktscgen 2.1.2 → 2.1.5

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

@@ -25,11 +25,10 @@ import {
     withStringResult
 } from "@koalaui/interop"
 import { NativePtrDecoder } from "./nativePtrDecoder"
-import { Es2pandaModifierFlags, Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums"
+import { Es2pandaAstNodeType, Es2pandaModifierFlags, Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums"
 import { classByPeer } from "../class-by-peer"
-import type { AstNode } from "../peers/AstNode"
+import { AstNode } from "../peers/AstNode"
 import { ArktsObject } from "../peers/ArktsObject"
-import { Es2pandaAstNodeType } from "../../Es2pandaEnums"
 
 export const arrayOfNullptr = new BigUint64Array([nullptr])
 
@@ -39,7 +38,6 @@ export const allFlags =
         .reduce(
             (prev, next) => prev | next,
             0
-
         )
 
 export function assertValidPeer(peer: KPtr, expectedKind: Es2pandaAstNodeType): void {
@@ -72,21 +70,20 @@ export function unpackNonNullableNode<T extends AstNode>(peer: KNativePointer):
     if (peer === nullptr) {
         throwError('peer is NULLPTR (maybe you should use unpackNode)')
     }
-    return classByPeer(peer) as T
+    return classByPeer(peer)
 }
 
 export function unpackNode<T extends AstNode>(peer: KNativePointer): T | undefined {
     if (peer === nullptr) {
         return undefined
     }
-    return classByPeer(peer) as T
+    return classByPeer<T>(peer)
 }
 
 export function passNode(node: ArktsObject | undefined): KNativePointer {
     return node?.peer ?? nullptr
 }
 
-// meaning unpackNonNullableNodeArray
 export function unpackNodeArray<T extends AstNode>(nodesPtr: KNativePointer): T[] {
     if (nodesPtr === nullptr) {
         throwError('nodesPtr is NULLPTR (maybe you should use unpackNodeArray)')
@@ -96,9 +93,12 @@ export function unpackNodeArray<T extends AstNode>(nodesPtr: KNativePointer): T[
         .map((peer: KNativePointer) => unpackNonNullableNode(peer))
 }
 
-export function passNodeArray(nodes: readonly AstNode[] | undefined): BigUint64Array {
+export function passNodeArray(nodes: readonly ArktsObject[] | undefined): BigUint64Array {
     return new BigUint64Array(
-        nodes?.map(node => BigInt(node.peer)) ?? []
+        nodes
+            ?.filter(it => it.peer != undefined)
+            ?.map(node => BigInt(node.peer))
+        ?? []
     )
 }
 
@@ -132,7 +132,7 @@ export function passStringArray(strings: readonly string[]): string[] {
 }
 
 export function passNodeWithNewModifiers<T extends AstNode>(node: T, modifiers: KInt): T {
-    return (unpackNonNullableNode(node.peer) as T).updateModifiers(modifiers)
+    return unpackNonNullableNode<T>(node.peer).updateModifiers(modifiers)
 }
 
 export function scriptFunctionHasBody(peer: KNativePointer): boolean {
@@ -145,7 +145,9 @@ export function updateNodeByNode<T extends ArktsObject>(node: T, original: T): T
     if (original.peer === nullptr) {
         throwError('update called on NULLPTR')
     }
-    global.generatedEs2panda._AstNodeSetOriginalNode(global.context, node.peer, original.peer)
+    if (original instanceof AstNode) {
+        global.generatedEs2panda._AstNodeSetOriginalNode(global.context, node.peer, original.originalPeer)
+    }
     global.generatedEs2panda._AstNodeSetParent(global.context, node.peer, global.generatedEs2panda._AstNodeParent(global.context, original.peer))
     global.es2panda._AstNodeUpdateChildren(global.context, node.peer)
     return node

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

@@ -15,23 +15,27 @@
 
 import { global } from "../static/global"
 import { isNumber, throwError } from "../../utils"
-import { nullptr, withStringResult } from "@koalaui/interop"
+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 {
     type AnnotationUsage,
     ClassDefinition,
+    ClassProperty,
+    ETSImportDeclaration,
     ETSModule,
     isClassDefinition,
+    isFunctionDeclaration,
     isMemberExpression,
     isScriptFunction,
-    isFunctionDeclaration
+    isIdentifier
 } from "../../generated"
 import { Config } from "../peers/Config"
 import { Context } from "../peers/Context"
+import { NodeCache } from "../node-cache"
 
-export function createETSModulefromContext(): ETSModule {
+export function createETSModuleFromContext(): ETSModule {
     return new ETSModule(global.es2panda._ProgramAst(global.context, global.es2panda._ContextProgram(global.context)))
 }
 
@@ -55,11 +59,7 @@ export function updateETSModuleByStatements(
     return node
 }
 
-export function proceedToState(state: Es2pandaContextState): void {
-    if (state <= global.es2panda._ContextState(global.context)) {
-        return
-    }
-    global.es2panda._ProceedToState(global.context, state)
+export function checkErrors() {
     if (global.es2panda._ContextState(global.context) === Es2pandaContextState.ES2PANDA_STATE_ERROR) {
         console.log()
         global.es2panda._DestroyConfig(global.config)
@@ -68,23 +68,41 @@ export function proceedToState(state: Es2pandaContextState): void {
     }
 }
 
+export function proceedToState(state: Es2pandaContextState): void {
+    if (state <= global.es2panda._ContextState(global.context)) {
+        return
+    }
+    const before = Date.now()
+    global.es2panda._ProceedToState(global.context, state)
+    const after = Date.now()
+    global.profiler.proceedTime += after-before
+    NodeCache.clear()
+    checkErrors()
+}
+
 export function startChecker(): boolean {
     return global.es2panda._CheckerStartChecker(global.context)
 }
 
 export function recheckSubtree(node: AstNode): void {
     global.es2panda._AstNodeRecheck(global.context, node.peer)
+    checkErrors()
 }
 
 export function rebindSubtree(node: AstNode): void {
     global.es2panda._AstNodeRebind(global.context, node.peer)
+    checkErrors()
 }
 
 export function getDecl(node: AstNode): AstNode | undefined {
     if (isMemberExpression(node)) {
-        return getDecl(node.property)
+        return getDecl(node.property!)
     }
-    const decl = global.es2panda._DeclarationFromIdentifier(global.context, passNode(node))
+    return getPeerDecl(passNode(node))
+}
+
+export function getPeerDecl(peer: KNativePointer): AstNode | undefined {
+    const decl = global.es2panda._DeclarationFromIdentifier(global.context, peer)
     if (decl === nullptr) {
         return undefined
     }
@@ -113,6 +131,10 @@ export function getFileName(): string {
     return global.filePath
 }
 
+export function getPackageName(): string {
+    return global.packageName
+}
+
 export function getFilePathFromPackageRoot(): string {
     return global.filePathFromPackageRoot
 }
@@ -125,6 +147,34 @@ export function classDefinitionFlags(node: ClassDefinition): Es2pandaModifierFla
     return global.generatedEs2panda._AstNodeModifiers(global.context, node.peer)
 }
 
+// TODO: ClassProperty's optional flag is set by AstNode's modifiers flags.
+export function classPropertySetOptional(node: ClassProperty, value: boolean): ClassProperty {
+    if (value) {
+        node.modifierFlags |= Es2pandaModifierFlags.MODIFIER_FLAGS_OPTIONAL;
+    } else {
+        node.modifierFlags &= Es2pandaModifierFlags.MODIFIER_FLAGS_OPTIONAL;
+    }
+    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;
+
+    let modifiers;
+    if (isClassDefinition(node)) {
+        modifiers = classDefinitionFlags(node);
+    } else {
+        modifiers = node.modifierFlags
+    }
+    return (modifiers & flag) === flag;
+}
+
 export function modifiersToString(modifiers: Es2pandaModifierFlags): string {
      return Object.values(Es2pandaModifierFlags)
             .filter(isNumber)
@@ -133,3 +183,11 @@ export function modifiersToString(modifiers: Es2pandaModifierFlags): string {
                 return ((modifiers.valueOf() & it) === it) ? Es2pandaModifierFlags[it] : ""
             }).join(" ")
 }
+
+export function nameIfIdentifier(node: AstNode): string {
+    return isIdentifier(node) ? `'${node.name}'` : ""
+}
+
+export function asString(node: AstNode|undefined): string {
+    return `${node?.constructor.name} ${node ? nameIfIdentifier(node) : undefined}`
+}

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

@@ -14,34 +14,50 @@
  */
 
 import { factory } from "./factory/nodeFactory"
-import { Es2pandaVariableDeclaratorFlag } from "../generated/Es2pandaEnums"
 import { AstNode } from "./peers/AstNode"
 import {
+    isArrayExpression,
     isArrowFunctionExpression,
+    isAssignmentExpression,
+    isBlockExpression,
     isBlockStatement,
     isCallExpression,
+    isChainExpression,
     isClassDeclaration,
     isClassDefinition,
     isConditionalExpression,
-    isETSImportDeclaration,
+    isETSModule,
     isETSStructDeclaration,
+    isETSTuple,
     isExpressionStatement,
     isFunctionDeclaration,
+    isFunctionExpression,
     isIfStatement,
     isMemberExpression,
+    isMethodDefinition,
+    isObjectExpression,
     isReturnStatement,
     isScriptFunction,
+    isTemplateLiteral,
+    isTryStatement,
     isTSAsExpression,
     isTSInterfaceBody,
     isTSInterfaceDeclaration,
+    isTSTypeAliasDeclaration,
     isVariableDeclaration,
     isVariableDeclarator,
-    isETSModule,
-    isMethodDefinition,
+    isClassProperty,
+    isIdentifier,
+    isETSParameterExpression,
+    isETSUnionType,
+    isETSFunctionType,
+    isWhileStatement,
 } from "../generated"
-import { classDefinitionFlags, updateETSModuleByStatements } from "./utilities/public"
+import { updateETSModuleByStatements } from "./utilities/public"
+import { global } from "./static/global"
+import { Es2pandaScriptFunctionFlags } from "../generated/Es2pandaEnums"
 
-type Visitor = (node: AstNode) => AstNode
+type Visitor = (node: AstNode, options?: object) => AstNode
 
 export interface DoubleNode {
     originNode: AstNode;
@@ -50,6 +66,8 @@ export interface DoubleNode {
 
 export class StructInfo {
     stateVariables: Set<DoubleNode> = new Set();
+    initializeBody: AstNode[] = [];
+    updateBody: AstNode[] = [];
 }
 
 export class GlobalInfo {
@@ -110,6 +128,7 @@ export function visitEachChild(
     node: AstNode,
     visitor: Visitor
 ): AstNode {
+    global.profiler.visitedNodes ++
     if (isETSModule(node)) {
         return updateETSModuleByStatements(
             node,
@@ -131,7 +150,7 @@ export function visitEachChild(
         return factory.updateFunctionDeclaration(
             node,
             nodeVisitor(node.function, visitor),
-            node.annotations,
+            nodesVisitor(node.annotations, visitor),
             node.isAnonymous,
         )
     }
@@ -141,6 +160,18 @@ export function visitEachChild(
             nodesVisitor(node.statements, visitor),
         )
     }
+    if (isBlockExpression(node)) {
+        return factory.updateBlockExpression(
+            node,
+            nodesVisitor(node.statements, visitor),
+        )
+    }
+    if (isChainExpression(node)) {
+        return factory.updateChainExpression(
+            node,
+            nodeVisitor(node.expression, visitor),
+        )
+    }
     if (isExpressionStatement(node)) {
         return factory.updateExpressionStatement(
             node,
@@ -154,63 +185,64 @@ export function visitEachChild(
         )
     }
     if (isClassDeclaration(node)) {
-        return factory.updateClassDeclaration(
+        const _node = factory.updateClassDeclaration(
             node,
             nodeVisitor(node.definition, visitor)
         )
+        _node.modifierFlags = node.modifierFlags
+        return _node
     }
     if (isClassDefinition(node)) {
-        // TODO: fix
         return factory.updateClassDefinition(
             node,
-            node.ident,
-            node.typeParams,
-            node.superTypeParams,
-            node.implements,
-            undefined,
-            node.super,
+            nodeVisitor(node.ident, visitor),
+            nodeVisitor(node.typeParams, visitor),
+            nodeVisitor(node.superTypeParams, visitor),
+            nodesVisitor(node.implements, visitor),
+            undefined, /* can not pass node.ctor here because of mismatching types */
+            nodeVisitor(node.super, visitor),
             nodesVisitor(node.body, visitor),
             node.modifiers,
-            classDefinitionFlags(node)
+            node.modifierFlags
         )
     }
     if (isMethodDefinition(node)) {
         return factory.updateMethodDefinition(
             node,
             node.kind,
-            node.id,
-            factory.createFunctionExpression(
-                node.id,
-                nodeVisitor(node.function, visitor)
-            ),
-            node.modifiers,
-            node.isComputed
+            nodeVisitor(node.id, visitor),
+            nodeVisitor(node.value, visitor),
+            node.modifierFlags,
+            node.isComputed,
+            nodesVisitor(node.overloads, visitor)
         )
     }
     if (isScriptFunction(node)) {
         return factory.updateScriptFunction(
             node,
             nodeVisitor(node.body, visitor),
-            node.typeParams,
-            node.params,
-            node.returnTypeAnnotation,
+            nodeVisitor(node.typeParams, visitor),
+            nodesVisitor(node.params, visitor),
+            nodeVisitor(node.returnTypeAnnotation, visitor),
             node.hasReceiver,
             node.flags,
-            node.modifiers,
-            node.id,
-            node.annotations,
+            node.modifierFlags,
+            nodeVisitor(node.id, visitor),
+            nodesVisitor(node.annotations, visitor)
         )
     }
-    if (isETSImportDeclaration(node)) {
-        return factory.updateETSImportDeclaration(
+    if (isETSParameterExpression(node)) {
+        if (node.isRestParameter) {
+            /** there is no RestParameter node at .idl */
+            return node
+        }
+        return factory.updateETSParameterExpression(
             node,
-            factory.createImportSource(
-                node.source,
-                node.resolvedSource,
-                node.hasDecl
-            ),
-            nodesVisitor(node.specifiers, visitor),
-            +node.isTypeKind,
+            nodeVisitor(node.ident, visitor),
+            node.isOptional,
+            nodeVisitor(node.initializer, visitor),
+            nodeVisitor(node.typeAnnotation, visitor),
+            nodesVisitor(node.annotations, visitor),
         )
     }
     if (isMemberExpression(node)) {
@@ -231,8 +263,7 @@ export function visitEachChild(
             nodeVisitor(node.typeParams, visitor),
             nodeVisitor(node.body, visitor),
             node.isStatic,
-            // TODO: how do I get it?
-            true
+            node.isFromExternal
         )
     }
     if (isTSInterfaceBody(node)) {
@@ -262,12 +293,13 @@ export function visitEachChild(
             node,
             node.kind,
             nodesVisitor(node.declarators, visitor),
+            nodesVisitor(node.annotations, visitor)
         )
     }
     if (isVariableDeclarator(node)) {
         return factory.updateVariableDeclarator(
             node,
-            Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_UNKNOWN,
+            node.flag,
             nodeVisitor(node.id, visitor),
             nodeVisitor(node.init, visitor),
         )
@@ -276,6 +308,7 @@ export function visitEachChild(
         return factory.updateArrowFunctionExpression(
             node,
             nodeVisitor(node.function, visitor),
+            nodesVisitor(node.annotations, visitor)
         )
     }
     if (isReturnStatement(node)) {
@@ -292,6 +325,106 @@ export function visitEachChild(
             node.isConst
         )
     }
-    // TODO
+    if (isTemplateLiteral(node)) {
+        return factory.updateTemplateLiteral(
+            node,
+            nodesVisitor(node.quasis, visitor),
+            nodesVisitor(node.expressions, visitor),
+            node.multilineString
+        )
+    }
+    if (isTSTypeAliasDeclaration(node)) {
+        return factory.updateTSTypeAliasDeclaration(
+            node,
+            nodeVisitor(node.id, visitor),
+            nodeVisitor(node.typeParams, visitor),
+            nodeVisitor(node.typeAnnotation, visitor),
+            nodesVisitor(node.annotations, visitor),
+        )
+    }
+    if (isTryStatement(node)) {
+        return factory.updateTryStatement(
+            node,
+            nodeVisitor(node.block, visitor),
+            nodesVisitor(node.catchClauses, visitor),
+            nodeVisitor(node.finallyBlock, visitor),
+            [],
+            []
+        )
+    }
+    if (isObjectExpression(node)) {
+        return factory.updateObjectExpression(
+            node,
+            nodesVisitor(node.properties, visitor)
+        )
+    }
+    if (isFunctionExpression(node)) {
+        return factory.updateFunctionExpression(
+            node,
+            nodeVisitor(node.id, visitor),
+            nodeVisitor(node.function, visitor)
+        )
+    }
+    if (isArrayExpression(node)) {
+        return factory.updateArrayExpression(
+            node,
+            nodesVisitor(node.elements, visitor)
+        )
+    }
+    if (isAssignmentExpression(node)) {
+        return factory.updateAssignmentExpression(
+            node,
+            nodeVisitor(node.left, visitor),
+            nodeVisitor(node.right, visitor),
+            node.operatorType,
+        )
+    }
+    if (isETSTuple(node)) {
+        return factory.updateETSTuple(
+            node,
+            nodesVisitor(node.tupleTypeAnnotationsList, visitor)
+        )
+    }
+    if (isETSUnionType(node)) {
+        return factory.updateETSUnionType(
+            node,
+            nodesVisitor(node.types, visitor),
+        )
+    }
+    if (isETSFunctionType(node)) {
+        return factory.updateETSFunctionType(
+            node,
+            nodeVisitor(node.typeParams, visitor),
+            nodesVisitor(node.params, visitor),
+            nodeVisitor(node.returnType, visitor),
+            false, // TODO: how to get it?
+            Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW,
+            nodesVisitor(node.annotations, visitor),
+        )
+    }
+    if (isClassProperty(node)) {
+        return factory.updateClassProperty(
+            node,
+            nodeVisitor(node.key, visitor),
+            nodeVisitor(node.value, visitor),
+            nodeVisitor(node.typeAnnotation, visitor),
+            node.modifierFlags,
+            node.isComputed
+        )
+    }
+    if (isIdentifier(node)) {
+        return factory.updateIdentifier(
+            node,
+            node.name,
+            nodeVisitor(node.typeAnnotation, visitor)
+        )
+    }
+    if (isWhileStatement(node)) {
+        return factory.updateWhileStatement(
+            node,
+            nodeVisitor(node.test, visitor),
+            nodeVisitor(node.body, visitor),
+        )
+    }
     return node
 }