@idlizer/arktscgen 2.1.9-arktscgen-6 → 2.1.9-arktscgen-9

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

@@ -17,18 +17,17 @@ import { ArktsObject } from "./ArktsObject"
 import { Program } from "../../generated"
 import { global } from "../static/global"
 import { passString, passStringArray } from "../utilities/private"
-import { KNativePointer, KInt, nullptr } from "@koalaui/interop"
+import { KNativePointer, nullptr, KBoolean } from "@koalaui/interop"
 import { Config } from "./Config"
-import { throwError } from "../../utils"
+import { filterSource, throwError } from "../../utils"
+import { AstNode } from "./AstNode"
 
 export class Context extends ArktsObject {
     constructor(peer: KNativePointer) {
         super(peer)
     }
 
-    static createFromString(
-        source: string
-    ): Context {
+    static createFromString(source: string): Context {
         if (!global.configIsInitialized()) {
             throw new Error(`Config not initialized`)
         }
@@ -40,6 +39,18 @@ export class Context extends ArktsObject {
             )
         )
     }
+    
+    /** @deprecated Use {@link createCacheFromFile} instead */
+    static createCacheContextFromFile(
+        configPtr: KNativePointer,
+        fileName: string,
+        globalContextPtr: KNativePointer,
+        isExternal: KBoolean
+    ): Context {
+        return new Context(
+            global.es2panda._CreateCacheContextFromFile(configPtr, passString(fileName), globalContextPtr, isExternal)
+        );
+    }
 
     static createFromFile(filePath: string, configPath: string, stdlibPath: string, outputPath: string): Context | undefined {
         const config = Config.create([
@@ -89,6 +100,16 @@ export class Context extends ArktsObject {
             this.peer = nullptr
         }
     }
+    
+    /** @deprecated */
+    static destroyAndRecreate(ast: AstNode): Context {
+        console.log('[TS WRAPPER] DESTROY AND RECREATE');
+        const source = filterSource(ast.dumpSrc());
+        global.es2panda._DestroyContext(global.context);
+        global.compilerContext = Context.createFromString(source) as any; // Improve: commonize Context
+
+        return new Context(global.context);
+    }
 
     get program(): Program {
         return new Program(global.es2panda._ContextProgram(this.peer));

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,21 +16,20 @@
 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 stage: Es2pandaContextState,
-    readonly restart: boolean,
+    readonly isProgramForCodegeneration: boolean,
+    readonly state: Es2pandaContextState,
 }
 
 export interface PluginContext {
     setParameter<V>(name: string, value: V): void
     parameter<V>(name: string) : V | undefined
-
 }
+
 export class PluginContextImpl implements PluginContext {
     map = new Map<String, Object|undefined>()
     parameter<V>(name: string): V|undefined {
@@ -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
             }
@@ -60,3 +59,12 @@ export function listPrograms(program: Program, filter: (name: string) => boolean
         })
     ]
 }
+
+export interface PluginEntry {
+    name?: string
+    parsed?: (hooks?: RunTransformerHooks) => void
+    checked?: (hooks?: RunTransformerHooks) => void
+    clean?: (hooks?: RunTransformerHooks) => void
+}
+
+export type PluginInitializer = (parsedJson?: Object, checkedJson?: Object) => PluginEntry

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

@@ -41,13 +41,14 @@ export class global {
         global._config = undefined
     }
 
-    // TODO: rename to contextPeer
+    // Improve: rename to contextPeer
     public static get context(): KNativePointer {
         return global.compilerContext?.peer ?? throwError('Global.context not initialized')
     }
 
-    // TODO: rename to context when the pointer valued one is eliminated
+    // Improve: rename to context when the pointer valued one is eliminated
     public static compilerContext: Context
+    public static isContextGenerateAbcForExternalSourceFiles: boolean = false
 
     private static _es2panda: Es2pandaNativeModule | undefined = undefined
     public static get es2panda(): Es2pandaNativeModule {

package/build/libarkts-copy/src/{wrapper-compat/arkts-api → arkts-api}/static/globalUtils.ts

@@ -16,12 +16,12 @@
 import { KNativePointer } from "@koalaui/interop";
 import { Context } from "../peers/Context";
 import { global } from "./global";
-import { clearNodeCache } from "../class-by-peer";
+import { NodeCache } from "../node-cache"
 
 export function getOrUpdateGlobalContext(peer: KNativePointer): Context {
     if (!global.compilerContext || global.context !== peer) {
-        clearNodeCache();
-        global.compilerContext = new Context(peer) as any; // TODO commize Context
+        NodeCache.clear();
+        global.compilerContext = new Context(peer);
     }
-    return global.compilerContext as any;
+    return global.compilerContext;
 }

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

@@ -43,7 +43,6 @@ interface PerformanceData {
 
     visitedNodes: number
     createdNodes: number
-    restartTime: number
     proceedTime: number
     totalTime: number
 
@@ -67,7 +66,6 @@ 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> = {}
@@ -115,10 +113,6 @@ export class Profiler implements PerformanceData {
         this.getPluginData(pluginName, state).transformTimeDeps += consumedTime
     }
 
-    restarted(consumedTime: number) {
-        this.restartTime += consumedTime
-    }
-
     proceededToState(consumedTime: number) {
         this.proceedTime += consumedTime
     }
@@ -129,7 +123,6 @@ export class Profiler implements PerformanceData {
 
         this.visitedNodes = 0
         this.createdNodes = 0
-        this.restartTime = 0
         this.proceedTime = 0
         this.totalTime = 0
         this.pluginsByName = {}
@@ -168,7 +161,6 @@ export class Profiler implements 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: {}

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

@@ -0,0 +1,80 @@
+/*
+ * 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 { KNativePointer } from "@koalaui/interop"
+import type {
+    ETSModule,
+    MethodDefinition,
+    Program,
+    ScriptFunction,
+} from "../../generated"
+import { ExternalSource } from "../peers/ExternalSource"
+import { Es2pandaModuleFlag } from "../../generated/Es2pandaEnums"
+import { global } from "../static/global"
+import { acceptNativeObjectArrayResult } from "./private"
+
+export function extension_ETSModuleGetNamespaceFlag(this: ETSModule): Es2pandaModuleFlag {
+    return (this.isETSScript ? Es2pandaModuleFlag.MODULE_FLAG_ETSSCRIPT : 0)
+        + (this.isNamespace ? Es2pandaModuleFlag.MODULE_FLAG_NAMESPACE : 0)
+        + (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
+    for (const overload of overloads) {
+        overload.setBaseOverloadMethod(this)
+        overload.parent = this // overloads are not listed as children in native
+    }
+}
+
+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))
+    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)
+}
+
+export function extension_ScriptFunctionSetPreferredReturnTypePointer(this: ScriptFunction, typePointer: KNativePointer): void {
+    global.es2panda._Checker_ScriptFunctionSetPreferredReturnType(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,
+    )
+}

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

@@ -61,7 +61,7 @@ export class NativePtrDecoder extends ArrayDecoder<pointer> {
         return global.interop._GetPtrVectorSize(blob)
     }
     disposeArray(blob: pointer): void {
-        // TODO
+        // Improve:
     }
     getArrayElement(blob: pointer, index: int32): pointer {
         return global.interop._GetPtrVectorElement(blob, index)

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

@@ -47,15 +47,15 @@ export function assertValidPeer(peer: KPtr, expectedKind: Es2pandaAstNodeType):
     if (global.validatePeerTypes) {
         const peerType = global.generatedEs2panda._AstNodeTypeConst(global.context, peer)
         if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION) {
-            // TODO: Struct is a child class of Class
+            // Improve: Struct is a child class of Class
             return
         }
         if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION) {
-            // TODO: ETSImportDeclaration is a child of a ImportDeclaration
+            // Improve: ETSImportDeclaration is a child of a ImportDeclaration
             return
         }
         if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT) {
-            // TODO: ETSModule is a child of a BlockStatement
+            // Improve: ETSModule is a child of a BlockStatement
             return
         }
         if (peerType !== expectedKind) {
@@ -122,12 +122,12 @@ export function unpackString(peer: KNativePointer): string {
     return global.interop._RawUtf8ToString(peer)
 }
 
-// TODO: use direct string arguments instead.
+// Improve: use direct string arguments instead.
 export function passString(str: string | undefined): string {
     return str ?? ""
 }
 
-// TODO: use direct string arguments instead.
+// Improve: use direct string arguments instead.
 export function passStringArray(strings: readonly string[]): string[] {
     return withStringArray(strings, (it: string[]) => it)
 }

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

@@ -15,9 +15,9 @@
 
 import { global } from "../static/global"
 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 { 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 type { AstNode } from "../peers/AstNode"
 import { isSameNativeObject } from "../peers/ArktsObject"
 import {
@@ -30,13 +30,30 @@ import {
     isMemberExpression,
     isScriptFunction,
     isIdentifier,
-    isETSModule
+    isETSModule,
+    ImportSpecifier,
+    Program,
+    isObjectExpression,
+    ETSImportDeclaration,
+    isProperty,
+    isTSInterfaceDeclaration,
+    isNumberLiteral,
+    Property,
+    MemberExpression,
+    isMethodDefinition,
+    TypeNode,
 } from "../../generated"
 import { Config } from "../peers/Config"
 import { Context } from "../peers/Context"
 import { NodeCache } from "../node-cache"
 import { listPrograms } from "../plugins"
+import { factory } from "../factory/nodeFactory"
 
+/**
+ * Improve: Replace or remove with better naming
+ * 
+ * @deprecated
+ */
 export function createETSModuleFromContext(): ETSModule {
     let program = global.es2panda._ContextProgram(global.context)
     if (program == nullptr) {
@@ -50,6 +67,12 @@ export function createETSModuleFromContext(): ETSModule {
     return new ETSModule(ast)
 }
 
+/**
+ * Now used only in tests
+ * Improve: Remove or replace with better method
+ * 
+ * @deprecated
+ */
 export function createETSModuleFromSource(
     source: string,
     state: Es2pandaContextState = Es2pandaContextState.ES2PANDA_STATE_PARSED,
@@ -70,22 +93,10 @@ export function metaDatabase(fileName: string): string {
     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
-}
-
 export function checkErrors() {
     if (global.es2panda._ContextState(global.context) === Es2pandaContextState.ES2PANDA_STATE_ERROR) {
-        console.log()
-        global.es2panda._DestroyConfig(global.config)
-        console.log()
+        console.log(unpackString(global.es2panda._GetAllErrorMessages(global.context)))
+        // global.es2panda._DestroyConfig(global.config)
         process.exit(1)
     }
 }
@@ -102,27 +113,38 @@ export function proceedToState(state: Es2pandaContextState): void {
     checkErrors()
 }
 
-export function startChecker(): boolean {
-    return global.es2panda._CheckerStartChecker(global.context)
+/** @deprecated Use {@link rebindContext} instead */
+export function rebindSubtree(node: AstNode): void {
+    global.es2panda._AstNodeRebind(global.context, node.peer)
+    checkErrors()
 }
 
+/** @deprecated Use {@link recheckSubtree} instead */
 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)
+export function rebindContext(context: KNativePointer = global.context): void {
+    global.es2panda._AstNodeRebind(
+        context,
+        global.es2panda._ProgramAst(
+            context,
+            global.es2panda._ContextProgram(
+                context
+            )
+        )
+    )
     checkErrors()
 }
 
-export function recheckContext(context: KNativePointer): void {
+export function recheckContext(context: KNativePointer = global.context): void {
     global.es2panda._AstNodeRecheck(
         context,
         global.es2panda._ProgramAst(
             context,
             global.es2panda._ContextProgram(
-                context
+                context,
             )
         )
     )
@@ -131,9 +153,58 @@ export function recheckContext(context: KNativePointer): void {
 
 export function getDecl(node: AstNode): AstNode | undefined {
     if (isMemberExpression(node)) {
-        return getDecl(node.property!)
+        return getDeclFromArrayOrObjectMember(node)
+    }
+    if (isObjectExpression(node)) {
+        return getPeerObjectDecl(passNode(node))
+    }
+    const decl = getPeerDecl(passNode(node))
+    if (!!decl) {
+        return decl
+    }
+    if (!!node.parent && isProperty(node.parent)) {
+        return getDeclFromProperty(node.parent)
+    }
+    return undefined
+}
+
+function getDeclFromProperty(node: Property): AstNode | undefined {
+    if (!node.key) {
+        return undefined
+    }
+    if (!!node.parent && !isObjectExpression(node.parent)) {
+        return getPeerDecl(passNode(node.key))
+    }
+    return getDeclFromObjectExpressionProperty(node)
+}
+
+function getDeclFromObjectExpressionProperty(node: Property): AstNode | undefined {
+    const declNode = getPeerObjectDecl(passNode(node.parent))
+    if (!declNode || !node.key || !isIdentifier(node.key)) {
+        return undefined
+    }
+    let body: readonly AstNode[] = []
+    if (isClassDefinition(declNode)) {
+        body = declNode.body
+    } else if (isTSInterfaceDeclaration(declNode)) {
+        body = declNode.body?.body ?? []
+    }
+    return body.find(
+        (statement) =>
+            isMethodDefinition(statement) &&
+            statement.kind === Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_GET &&
+            !!statement.id &&
+            !!node.key &&
+            isIdentifier(node.key) &&
+            statement.id.name === node.key.name
+    )
+}
+
+function getDeclFromArrayOrObjectMember(node: MemberExpression): AstNode | undefined {
+    if (isNumberLiteral(node.property)) {
+        return node.object ? getDecl(node.object) : undefined
     }
-    return getPeerDecl(passNode(node))
+    return node.property ? getDecl(node.property) : undefined
 }
 
 export function getPeerDecl(peer: KNativePointer): AstNode | undefined {
@@ -144,6 +215,14 @@ export function getPeerDecl(peer: KNativePointer): AstNode | undefined {
     return unpackNonNullableNode(decl)
 }
 
+export function getPeerObjectDecl(peer: KNativePointer): AstNode | undefined {
+    const decl = global.es2panda._ClassVariableDeclaration(global.context, peer);
+    if (decl === nullptr) {
+        return undefined;
+    }
+    return unpackNonNullableNode(decl)
+}
+
 export function getAnnotations(node: AstNode): readonly AnnotationUsage[] {
     if (!isFunctionDeclaration(node) && !isScriptFunction(node) && !isClassDefinition(node)) {
         throwError('for now annotations allowed only for: functionDeclaration, scriptFunction, classDefinition')
@@ -153,7 +232,7 @@ export function getAnnotations(node: AstNode): readonly AnnotationUsage[] {
 
 export function getOriginalNode(node: AstNode): AstNode {
     if (node === undefined) {
-        // TODO: fix this
+        // Improve: fix this
         throwError('there is no arkts pair of ts node (unable to getOriginalNode)')
     }
     if (node.originalPeer === nullptr) {
@@ -166,7 +245,13 @@ export function getFileName(): string {
     return global.filePath
 }
 
-// TODO: It seems like Definition overrides AstNode  modifiers
+export function getJsDoc(node: AstNode): string | undefined {
+    const result = unpackString(global.es2panda._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
 // the language level modifiers: public, declare, export, etc.
@@ -174,7 +259,7 @@ 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.
+// Improve: 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;
@@ -239,3 +324,106 @@ export function collectDependencies(files: string[], configPath: string): string
     }
     return Array.from(result)
 }
+
+export function generateTsDeclarationsFromContext(
+  outputDeclEts: string,
+  outputEts: string,
+  exportAll: boolean,
+  isolated: boolean,
+  recordFile: string
+): KInt {
+  return global.es2panda._GenerateTsDeclarationsFromContext(
+    global.context,
+    passString(outputDeclEts),
+    passString(outputEts),
+    exportAll,
+    isolated,
+    recordFile
+  );
+}
+
+export function setAllParents(ast: AstNode): void {
+    global.es2panda._AstNodeUpdateAll(global.context, ast.peer);
+}
+
+export function getProgramFromAstNode(node: AstNode): Program {
+    return new Program(global.es2panda._AstNodeProgram(global.context, node.peer))
+}
+
+export function importDeclarationInsert(node: ETSImportDeclaration, program: Program): void {
+    global.es2panda._InsertETSImportDeclarationAndParse(global.context, program.peer, node.peer)
+}
+
+export function signatureReturnType(signature: KNativePointer): KNativePointer {
+    if (!signature) {
+        return nullptr
+    }
+    return global.es2panda._Checker_SignatureReturnType(global.context, signature)
+}
+
+export function tryConvertCheckerTypeToTypeNode(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,
+        )
+    }
+    // Only used in samples code
+    if (str == "StringerNode") {
+        return factory.createETSTypeReference(
+            factory.createETSTypeReferencePart(
+                factory.createIdentifier(str)
+            )
+        )
+    }
+    return undefined
+}