diff --git a/arkoala-arkts/arkui/src/sts/arkui.after.check.sts b/arkoala-arkts/arkui/src/sts/arkui.after.check.sts new file mode 100644 index 0000000000000000000000000000000000000000..58b510fa3562f3bda799cd10033fa6385d97dab4 --- /dev/null +++ b/arkoala-arkts/arkui/src/sts/arkui.after.check.sts @@ -0,0 +1,117 @@ +// Annotations + +export @interface BuilderLambda { + value: string +} + +export @interface Component {} + +export @interface State {} + +export @interface memo {} + +export abstract class StructBase { + + static instantiateImpl, OptionsS>( + builder: ((instance: S)=>S)|undefined, + factory: () => S, + options?: OptionsS, + content?: () => void + ) { + console.log("Struct instantiate redirected") + const instance = factory() + if (builder !== undefined) builder(instance) + instance._build(builder, content, options) + } + build() { + throw new Error("The struct build() should never be executed directly") + } + + protected _build(style: ((instance: T)=>T)|undefined, content: (() => void)|undefined, options: OptionsT|undefined) { + throw new Error("The struct _build() must have a valid override") + } +} + +export enum Color { + White, + Red +} + +export interface ColumnOptions { + space: number +} + +export class CommonMethod { + onClick(callback: () => void): this { + console.log("registered Button.onClick()") + return this + } + width(value: number): this { + console.log(`.width(${value})`) + return this + } + height(value: number): this { + console.log(`.height(${value})`) + return this + } +} + +// An attempt to put down a component +export class Column extends CommonMethod { + + static instantiateImpl( + style: (instance: Column) => Column, + factory: () => Column, + options: ColumnOptions, + content: () => void + ): void { + console.log("Column({space:", options.space, "})") + const instance = factory() + style(instance) + content() + } +} + + +export interface ButtonOptions {} + +// An attempt to put down a component +export class Button extends CommonMethod { + + static instantiateImpl( + style: (instance: Button) => Button, + factory: () => Button, + options?: ButtonOptions|string, + //content?: () => void + ): void { + console.log("Button(", options, ")") + const instance = factory() + style(instance) + //content() + + } +} + +export interface TextOptions {} + +// An attempt to put down a component +export class Text extends CommonMethod { + + // TODO: the second argument will be gone after hte plugin is improved + static instantiateImpl( + style: (instance: Text) => Text, + factory: () => Text, + options?: TextOptions|string, + //content?: () => void + ): void { + console.log("Text(", options, ")") + const instance = factory() + style(instance) + //content() + } + + fontColor(value: Color): this { + console.log("\.fontColor(", Color[value], ")") + return this + } +} diff --git a/arkoala-arkts/libarkts/arktsconfig.json b/arkoala-arkts/libarkts/arktsconfig.json index 85e9e51f6d825c201ca549ce35952deed24d1685..e59ddeb1131bf9a2c5f8ebabd2d817d9c24193c8 100644 --- a/arkoala-arkts/libarkts/arktsconfig.json +++ b/arkoala-arkts/libarkts/arktsconfig.json @@ -2,6 +2,17 @@ "compilerOptions": { "outDir": "./abc", "baseUrl": ".", + "paths": { + "@koalaui/runtime": [ + "../memo-plugin/runtime-api" + ], + "@koalaui/compat": [ + "../../incremental/compat/src/arkts" + ], + "@koalaui/common": [ + "../../incremental/common/src" + ] + }, "plugins": [ { "transform": "./plugins/build/src/printer-plugin.js", @@ -10,7 +21,7 @@ { "transform": "./plugins/build/src/parsed-stage-plugin.js", "stage": "parsed", - "arkui": "../../../arkui/src/sts" + "arkui": "../../../arkui/src/sts/arkui.after.check.sts" }, { diff --git a/arkoala-arkts/libarkts/native/src/bridges.cc b/arkoala-arkts/libarkts/native/src/bridges.cc index 1ee0b055df23f48b29912c48c27c2e2a3b9db7d2..b9e088b9c12477dee075db3e602c6385b4388a19 100644 --- a/arkoala-arkts/libarkts/native/src/bridges.cc +++ b/arkoala-arkts/libarkts/native/src/bridges.cc @@ -284,3 +284,9 @@ KNativePointer impl_DeclarationFromIdentifier(KNativePointer context, KNativePoi return result; } KOALA_INTEROP_2(DeclarationFromIdentifier, KNativePointer, KNativePointer, KNativePointer) + +KBoolean impl_IsETSImportDeclaration(KNativePointer nodePtr) { + auto node = reinterpret_cast(nodePtr); + return GetImpl()->IsETSImportDeclaration(node); +} +KOALA_INTEROP_1(IsETSImportDeclaration, KBoolean, KNativePointer) \ No newline at end of file diff --git a/arkoala-arkts/libarkts/native/src/es2panda_lib.cc b/arkoala-arkts/libarkts/native/src/es2panda_lib.cc new file mode 100644 index 0000000000000000000000000000000000000000..2febc81b10d13e9d77c8fe1e3508acfaa7d193eb --- /dev/null +++ b/arkoala-arkts/libarkts/native/src/es2panda_lib.cc @@ -0,0 +1,1651 @@ +/* + * 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. + */ + + #include + #include + #include + + #include "dynamic-loader.h" + #include "es2panda_lib.h" + #include "common-interop.h" + #include "stdexcept" + + using std::string, std::cout, std::endl, std::vector; + + static es2panda_Impl *impl = nullptr; + + #ifdef KOALA_WINDOWS + #include + #define PLUGIN_DIR "windows_host_tools" + #define LIB_PREFIX "" + #define LIB_SUFFIX ".dll" + #endif + + #ifdef KOALA_LINUX + #include + + #ifdef __x86_64__ + #define PLUGIN_DIR "linux_host_tools" + #else + #define PLUGIN_DIR "linux_arm64_host_tools" + #endif + + #define LIB_PREFIX "lib" + #define LIB_SUFFIX ".so" + #endif + + const char* libpath = "../node_modules/@panda/sdk/" PLUGIN_DIR "/lib/" LIB_PREFIX "es2panda-public" LIB_SUFFIX; + + es2panda_Impl *GetImpl() { + if (impl) { + return impl; + } + auto library = loadLibrary(libpath); + if (!library) { + throw std::runtime_error("No library (es2panda_lib.cc)"); + } + auto symbol = findSymbol(library, "es2panda_GetImpl"); + if (!symbol) { + throw std::runtime_error("No entry point"); + } + impl = reinterpret_cast(symbol)(ES2PANDA_LIB_VERSION); + return impl; + } + + es2panda_ContextState intToState(KInt state) { + return es2panda_ContextState(state); + } + + string getString(KStringPtr ptr) { + return ptr.data(); + } + + char* getStringCopy(KStringPtr& ptr) { + return strdup(ptr.c_str()); + } + + inline KUInt unpackUInt(const KByte* bytes) { + return (bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24)); + } + + KInt impl_ContextState(KNativePointer contextPtr) { + auto context = reinterpret_cast(contextPtr); + + return static_cast(GetImpl()->ContextState(context)); + } + KOALA_INTEROP_1(ContextState, KInt, KNativePointer) + + KNativePointer impl_ContextErrorMessage(KNativePointer contextPtr) { + auto context = reinterpret_cast(contextPtr); + + return new string(GetImpl()->ContextErrorMessage(context)); + } + KOALA_INTEROP_1(ContextErrorMessage, KNativePointer, KNativePointer) + + KNativePointer impl_CreateConfig(KInt argc, KStringArray argvPtr) { + const std::size_t HEADER_LEN = 4; + + const char** argv = new const char*[argc]; + std::size_t position = HEADER_LEN; + std::size_t str_len; + for (std::size_t i = 0; i < static_cast(argc); ++i) { + str_len = unpackUInt(argvPtr + position); + position += HEADER_LEN; + argv[i] = strdup(std::string(reinterpret_cast(argvPtr + position), str_len).c_str()); + position += str_len; + } + return GetImpl()->CreateConfig(argc, argv); + } + KOALA_INTEROP_2(CreateConfig, KNativePointer, KInt, KStringArray) + + KNativePointer impl_DestroyConfig(KNativePointer configPtr) { + auto config = reinterpret_cast(configPtr); + GetImpl()->DestroyConfig(config); + return nullptr; + } + KOALA_INTEROP_1(DestroyConfig, KNativePointer, KNativePointer) + + KNativePointer impl_CreateContextFromString(KNativePointer configPtr, KStringPtr& sourcePtr, KStringPtr& filenamePtr) { + auto config = reinterpret_cast(configPtr); + return GetImpl()->CreateContextFromString(config, sourcePtr.data(), filenamePtr.data()); + } + KOALA_INTEROP_3(CreateContextFromString, KNativePointer, KNativePointer, KStringPtr, KStringPtr) + + KNativePointer impl_CreateContextFromFile(KNativePointer configPtr, KStringPtr& filenamePtr) { + auto config = reinterpret_cast(configPtr); + return GetImpl()->CreateContextFromFile(config, getStringCopy(filenamePtr)); + } + KOALA_INTEROP_2(CreateContextFromFile, KNativePointer, KNativePointer, KStringPtr) + + KNativePointer impl_DestroyContext(KNativePointer contextPtr) { + auto context = reinterpret_cast(contextPtr); + GetImpl()->DestroyContext(context); + return nullptr; + } + KOALA_INTEROP_1(DestroyContext, KNativePointer, KNativePointer) + + KNativePointer impl_ProceedToState(KNativePointer contextPtr, KInt state) { + auto context = reinterpret_cast(contextPtr); + return GetImpl()->ProceedToState(context, intToState(state)); + } + KOALA_INTEROP_2(ProceedToState, KNativePointer, KNativePointer, KInt) + + KNativePointer impl_ContextProgram(KNativePointer contextPtr) { + auto context = reinterpret_cast(contextPtr); + return GetImpl()->ContextProgram(context); + } + KOALA_INTEROP_1(ContextProgram, KNativePointer, KNativePointer) + + KBoolean impl_CheckerStartChecker(KNativePointer contextPtr) { + auto context = reinterpret_cast(contextPtr); + return GetImpl()->CheckerStartChecker(context); + } + KOALA_INTEROP_1(CheckerStartChecker, KBoolean, KNativePointer) + + KNativePointer impl_VarBinderIdentifierAnalysis(KNativePointer contextPtr) { + auto context = reinterpret_cast(contextPtr); + GetImpl()->VarBinderIdentifierAnalysis(context); + return context; + } + KOALA_INTEROP_1(VarBinderIdentifierAnalysis, KNativePointer, KNativePointer) + + KNativePointer impl_VarBinderInitTopScope(KNativePointer contextPtr) { + auto context = reinterpret_cast(contextPtr); + GetImpl()->VarBinderInitTopScope(context); + return context; + } + KOALA_INTEROP_1(VarBinderInitTopScope, KNativePointer, KNativePointer) + + KNativePointer impl_ProgramAst(KNativePointer programPtr) { + auto program = reinterpret_cast(programPtr); + return GetImpl()->ProgramAst(program); + } + KOALA_INTEROP_1(ProgramAst, KNativePointer, KNativePointer) + + KBoolean impl_IsIdentifier(KNativePointer nodePtr) { + auto node = reinterpret_cast(nodePtr); + return GetImpl()->IsIdentifier(node); + } + KOALA_INTEROP_1(IsIdentifier, KBoolean, KNativePointer) + + KNativePointer impl_IdentifierName(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + return new string(GetImpl()->IdentifierName(context, node)); + } + KOALA_INTEROP_2(IdentifierName, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CreateIdentifier1(KNativePointer contextPtr, KStringPtr& namePtr) { + auto context = reinterpret_cast(contextPtr); + return GetImpl()->CreateIdentifier1(context, getStringCopy(namePtr)); + } + KOALA_INTEROP_2(CreateIdentifier1, KNativePointer, KNativePointer, KStringPtr) + + KNativePointer impl_IdentifierSetName(KNativePointer contextPtr, KNativePointer nodePtr, KStringPtr& namePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + GetImpl()->IdentifierSetName(context, node, getStringCopy(namePtr)); + return node; + } + KOALA_INTEROP_3(IdentifierSetName, KNativePointer, KNativePointer, KNativePointer, KStringPtr) + + KNativePointer impl_CreateIdentifier2(KNativePointer contextPtr, KStringPtr& namePtr, KNativePointer typeAnnotationPtr) { + auto context = reinterpret_cast(contextPtr); + auto typeAnnotation = reinterpret_cast(typeAnnotationPtr); + return GetImpl()->CreateIdentifier2(context, getStringCopy(namePtr), typeAnnotation); + } + KOALA_INTEROP_3(CreateIdentifier2, KNativePointer, KNativePointer, KStringPtr, KNativePointer) + + KNativePointer impl_CreateETSPrimitiveType(KNativePointer contextPtr, KInt type) { + auto context = reinterpret_cast(contextPtr); + return GetImpl()->CreateETSPrimitiveType(context, static_cast(type)); + } + KOALA_INTEROP_2(CreateETSPrimitiveType, KNativePointer, KNativePointer, KInt) + + KInt impl_ETSPrimitiveTypeGetPrimitiveTypeConst(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->ETSPrimitiveTypeGetPrimitiveTypeConst(context, node); + } + KOALA_INTEROP_2(ETSPrimitiveTypeGetPrimitiveTypeConst, KInt, KNativePointer, KNativePointer) + + KNativePointer impl_CreateETSFunctionTypeIr(KNativePointer contextPtr, KNativePointer signaturePtr, KInt funcFlagsT) { + auto context = reinterpret_cast(contextPtr); + auto signature = reinterpret_cast(signaturePtr); + auto funcFlags = Es2pandaScriptFunctionFlags(funcFlagsT); + + return GetImpl()->CreateETSFunctionTypeIr(context, signature, funcFlags); + } + KOALA_INTEROP_3(CreateETSFunctionTypeIr, KNativePointer, KNativePointer, KNativePointer, KInt) + + KNativePointer impl_CreateNumberLiteral(KNativePointer contextPtr, KStringPtr& strPtr) { + auto context = reinterpret_cast(contextPtr); + + return GetImpl()->CreateNumberLiteral(context, getStringCopy(strPtr)); + } + KOALA_INTEROP_2(CreateNumberLiteral, KNativePointer, KNativePointer, KStringPtr) + + KNativePointer impl_CreateStringLiteral(KNativePointer contextPtr, KStringPtr& stringPtr) { + auto context = reinterpret_cast(contextPtr); + return GetImpl()->CreateStringLiteral1(context, getStringCopy(stringPtr)); + } + KOALA_INTEROP_2(CreateStringLiteral, KNativePointer, KNativePointer, KStringPtr) + + KNativePointer impl_StringLiteralStrConst(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + return new string(GetImpl()->StringLiteralStrConst(context, node)); + } + KOALA_INTEROP_2(StringLiteralStrConst, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_NumberLiteralStrConst(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + return new string(GetImpl()->NumberLiteralStrConst(context, node)); + } + KOALA_INTEROP_2(NumberLiteralStrConst, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CreateMethodDefinition( + KNativePointer contextPtr, + KInt kindT, + KNativePointer keyPtr, + KNativePointer valuePtr, + KInt modifiersT, + KBoolean isComputedT + ) { + auto context = reinterpret_cast(contextPtr); + auto kind = static_cast(kindT); + auto key = reinterpret_cast(keyPtr); + auto value = reinterpret_cast(valuePtr); + auto modifiers = static_cast(modifiersT); + auto isComputed = static_cast(isComputedT); + + return GetImpl()->CreateMethodDefinition(context, kind, key, value, modifiers, isComputed); + } + KOALA_INTEROP_6(CreateMethodDefinition, KNativePointer, KNativePointer, KInt, KNativePointer, KNativePointer, KInt, KBoolean) + + KNativePointer impl_CreateClassProperty( + KNativePointer contextPtr, + KNativePointer keyPtr, + KNativePointer valuePtr, + KNativePointer typeAnnotationPtr, + KInt modifiersT, + KBoolean isComputedT + ) { + auto context = reinterpret_cast(contextPtr); + auto key = reinterpret_cast(keyPtr); + auto value = reinterpret_cast(valuePtr); + auto typeAnnotation = reinterpret_cast(typeAnnotationPtr); + auto modifiers = static_cast(modifiersT); + auto isComputed = static_cast(isComputedT); + + return GetImpl()->CreateClassProperty(context, key, value, typeAnnotation, modifiers, isComputed); + } + KOALA_INTEROP_6(CreateClassProperty, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KBoolean) + + KNativePointer impl_AstNodeDumpJsonConst(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + return new string(GetImpl()->AstNodeDumpJSONConst(context, node)); + } + KOALA_INTEROP_2(AstNodeDumpJsonConst, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_AstNodeDumpEtsSrcConst(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + return new string(GetImpl()->AstNodeDumpEtsSrcConst(context, node)); + } + KOALA_INTEROP_2(AstNodeDumpEtsSrcConst, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ETSParserCreateExpression(KNativePointer contextPtr, KStringPtr& sourceCodePtr, KInt flagsT) { + auto context = reinterpret_cast(contextPtr); + auto flags = static_cast(flagsT); + + return GetImpl()->ETSParserCreateExpression(context, getStringCopy(sourceCodePtr), flags); + } + KOALA_INTEROP_3(ETSParserCreateExpression, KNativePointer, KNativePointer, KStringPtr, KInt) + + KBoolean impl_IsProgram(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + return GetImpl()->AstNodeIsProgramConst(context, node); + } + KOALA_INTEROP_2(IsProgram, KBoolean, KNativePointer, KNativePointer) + + KBoolean impl_IsBlockStatement(KNativePointer nodePtr) { + auto node = reinterpret_cast(nodePtr); + return GetImpl()->IsBlockStatement(node); + } + KOALA_INTEROP_1(IsBlockStatement, KBoolean, KNativePointer) + + KNativePointer impl_BlockStatementStatements(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + size_t n; + auto statements = GetImpl()->BlockStatementStatements(context, node, &n); + return new vector(statements, statements + n); + } + KOALA_INTEROP_2(BlockStatementStatements, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_VariableDeclarationDeclaratorsConst(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + size_t n; + auto declarators = GetImpl()->VariableDeclarationDeclaratorsConst(context, node, &n); + return new vector(declarators, declarators + n); + } + KOALA_INTEROP_2(VariableDeclarationDeclaratorsConst, KNativePointer, KNativePointer, KNativePointer) + + KInt impl_VariableDeclarationKindConst(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->VariableDeclarationKindConst(context, node); + } + KOALA_INTEROP_2(VariableDeclarationKindConst, KInt, KNativePointer, KNativePointer) + + KNativePointer impl_ClassDeclarationDefinition(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + return GetImpl()->ClassDeclarationDefinition(context, node); + } + KOALA_INTEROP_2(ClassDeclarationDefinition, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ClassDefinitionBody(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + size_t n; + auto body = GetImpl()->ClassDefinitionBody(context, node, &n); + return new std::vector(body, body + n); + } + KOALA_INTEROP_2(ClassDefinitionBody, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ClassDefinitionTypeParamsConst(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return const_cast(GetImpl()->ClassDefinitionTypeParamsConst(context, node)); + } + KOALA_INTEROP_2(ClassDefinitionTypeParamsConst, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_FunctionDeclarationFunction(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + return GetImpl()->FunctionDeclarationFunction(context, node); + } + KOALA_INTEROP_2(FunctionDeclarationFunction, KNativePointer, KNativePointer, KNativePointer) + + KBoolean impl_FunctionDeclarationIsAnonymousConst(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->FunctionDeclarationIsAnonymousConst(context, node); + } + KOALA_INTEROP_2(FunctionDeclarationIsAnonymousConst, KBoolean, KNativePointer, KNativePointer) + + KNativePointer impl_ScriptFunctionAddFlag(KNativePointer contextPtr, KNativePointer nodePtr, KInt flagsT) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + auto flags = static_cast(flagsT); + + GetImpl()->ScriptFunctionAddFlag(context, node, flags); + return node; + } + KOALA_INTEROP_3(ScriptFunctionAddFlag, KNativePointer, KNativePointer, KNativePointer, KInt) + + KNativePointer impl_ScriptFunctionParams(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + std::size_t params_len = 0; + auto params = GetImpl()->ScriptFunctionParams(context, node, ¶ms_len); + return new std::vector(params, params + params_len); + } + KOALA_INTEROP_2(ScriptFunctionParams, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ScriptFunctionTypeParams(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->ScriptFunctionTypeParams(context, node); + } + KOALA_INTEROP_2(ScriptFunctionTypeParams, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ScriptFunctionReturnTypeAnnotation(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->ScriptFunctionReturnTypeAnnotation(context, node); + } + KOALA_INTEROP_2(ScriptFunctionReturnTypeAnnotation, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ScriptFunctionId(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + return GetImpl()->ScriptFunctionId(context, node); + } + KOALA_INTEROP_2(ScriptFunctionId, KNativePointer, KNativePointer, KNativePointer) + + KBoolean impl_ScriptFunctionDeclareConst(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + return GetImpl()->ScriptFunctionDeclareConst(context, node); + } + KOALA_INTEROP_2(ScriptFunctionDeclareConst, KBoolean, KNativePointer, KNativePointer) + + KNativePointer impl_CreateFunctionDeclaration( + KNativePointer contextPtr, + KNativePointer funcPtr, + KNativePointerArray annotationsPtr, + KInt annotationsLen, + KBoolean isAnonK + ) { + auto context = reinterpret_cast(contextPtr); + auto func = reinterpret_cast(funcPtr); + auto annotations = reinterpret_cast(annotationsPtr); + auto isAnon = static_cast(isAnonK); + + return GetImpl()->CreateFunctionDeclaration(context, func, annotations, annotationsLen, isAnon); + } + KOALA_INTEROP_5(CreateFunctionDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt, KBoolean) + + KNativePointer impl_UpdateFunctionDeclaration( + KNativePointer contextPtr, + KNativePointer nodePtr, + KNativePointer funcPtr, + KNativePointerArray annotationsPtr, + KInt annotationsLen, + KBoolean isAnonK + ) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + auto func = reinterpret_cast(funcPtr); + auto annotations = reinterpret_cast(annotationsPtr); + auto isAnon = static_cast(isAnonK); + + return GetImpl()->UpdateFunctionDeclaration(context, node, func, annotations, annotationsLen, isAnon); + } + KOALA_INTEROP_6(UpdateFunctionDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt, KBoolean) + + // TODO: add param initializer + KNativePointer impl_CreateETSParameterExpression(KNativePointer contextPtr, KNativePointer identifierPtr, KNativePointer initializerPtr) { + auto context = reinterpret_cast(contextPtr); + auto identifier = reinterpret_cast(identifierPtr); + auto initializer = reinterpret_cast(initializerPtr); + + return GetImpl()->CreateETSParameterExpression(context, identifier, initializer); + } + KOALA_INTEROP_3(CreateETSParameterExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CreateTSTypeParameterDeclaration( + KNativePointer contextPtr, + KNativePointerArray paramsPtr, + KInt paramsLen, + KInt requiredParams + ) { + auto context = reinterpret_cast(contextPtr); + auto params = reinterpret_cast(paramsPtr); + + return GetImpl()->CreateTSTypeParameterDeclaration(context, params, paramsLen, requiredParams); + } + KOALA_INTEROP_4(CreateTSTypeParameterDeclaration, KNativePointer, KNativePointer, KNativePointerArray, KInt, KInt) + + KNativePointer impl_TSTypeParameterDeclarationParamsConst(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer returnLen) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + std::size_t params_len = 0; + auto params = GetImpl()->TSTypeParameterDeclarationParamsConst(context, node, ¶ms_len); + return new std::vector(params, params + params_len); + } + KOALA_INTEROP_3(TSTypeParameterDeclarationParamsConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CreateVariableDeclaration( + KNativePointer contextPtr, + KInt kindT, + KNativePointerArray declaratorsPtr, + KInt declaratorsLen, + KBoolean declareT + ) { + auto context = reinterpret_cast(contextPtr); + auto kind = static_cast(kindT); + auto declarators = reinterpret_cast(declaratorsPtr); + auto declare = static_cast(declareT); + + return GetImpl()->CreateVariableDeclaration(context, kind, declarators, declaratorsLen, declare); + } + KOALA_INTEROP_5(CreateVariableDeclaration, KNativePointer, KNativePointer, KInt, KNativePointerArray, KInt, KBoolean) + + KNativePointer impl_UpdateVariableDeclaration( + KNativePointer contextPtr, + KNativePointer originalPtr, + KInt kindT, + KNativePointerArray declaratorsPtr, + KInt declaratorsLen, + KBoolean declareT + ) { + auto context = reinterpret_cast(contextPtr); + auto original = reinterpret_cast(originalPtr); + auto kind = static_cast(kindT); + auto declarators = reinterpret_cast(declaratorsPtr); + auto declare = static_cast(declareT); + + return GetImpl()->UpdateVariableDeclaration(context, original, kind, declarators, declaratorsLen, declare); + } + KOALA_INTEROP_6(UpdateVariableDeclaration, KNativePointer, KNativePointer, KNativePointer, KInt, KNativePointerArray, KInt, KBoolean) + + KNativePointer impl_CreateVariableDeclarator( + KNativePointer contextPtr, + KInt flagT, + KNativePointer identPtr + ) { + auto context = reinterpret_cast(contextPtr); + auto flag = static_cast(flagT); + auto ident = reinterpret_cast(identPtr); + + return GetImpl()->CreateVariableDeclarator(context, flag, ident); + } + KOALA_INTEROP_3(CreateVariableDeclarator, KNativePointer, KNativePointer, KInt, KNativePointer) + + KNativePointer impl_VariableDeclaratorSetInit(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer initPtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + auto init = reinterpret_cast(initPtr); + + GetImpl()->VariableDeclaratorSetInit(context, node, init); + return node; + } + KOALA_INTEROP_3(VariableDeclaratorSetInit, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_VariableDeclaratorId(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->VariableDeclaratorId(context, node); + } + KOALA_INTEROP_2(VariableDeclaratorId, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CreateTSTypeParameter( + KNativePointer contextPtr, + KNativePointer namePtr, + KNativePointer constraintPtr, + KNativePointer defaultTypePtr + ) { + auto context = reinterpret_cast(contextPtr); + auto name = reinterpret_cast(namePtr); + auto constraint = reinterpret_cast(constraintPtr); + auto defaultType = reinterpret_cast(defaultTypePtr); + + return GetImpl()->CreateTSTypeParameter(context, name, constraint, defaultType); + } + KOALA_INTEROP_4(CreateTSTypeParameter, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_TSTypeParameterName(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->TSTypeParameterName(context, node); + } + KOALA_INTEROP_2(TSTypeParameterName, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ETSParameterExpressionIdent(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->ETSParameterExpressionIdent(context, node); + } + KOALA_INTEROP_2(ETSParameterExpressionIdent, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CreateETSTypeReference(KNativePointer contextPtr, KNativePointer partPtr) { + auto context = reinterpret_cast(contextPtr); + auto part = reinterpret_cast(partPtr); + + return GetImpl()->CreateETSTypeReference(context, part); + } + KOALA_INTEROP_2(CreateETSTypeReference, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CreateETSTypeReferencePart1(KNativePointer contextPtr, KNativePointer namePtr) { + auto context = reinterpret_cast(contextPtr); + auto name = reinterpret_cast(namePtr); + + return GetImpl()->CreateETSTypeReferencePart1(context, name); + } + KOALA_INTEROP_2(CreateETSTypeReferencePart1, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CreateETSTypeReferencePart(KNativePointer contextPtr, KNativePointer namePtr, KNativePointer typeParamsPtr, KNativePointer prevPtr) { + auto context = reinterpret_cast(contextPtr); + auto name = reinterpret_cast(namePtr); + auto typeParams = reinterpret_cast(typeParamsPtr); + auto prev = reinterpret_cast(prevPtr); + + return GetImpl()->CreateETSTypeReferencePart(context, name, typeParams, prev); + } + KOALA_INTEROP_4(CreateETSTypeReferencePart, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_UpdateBlockStatement(KNativePointer contextPtr, KNativePointer originalPtr, KNativePointerArray statementListPtr, KInt statementListLen) { + auto context = reinterpret_cast(contextPtr); + auto statementList = reinterpret_cast(statementListPtr); + auto original = reinterpret_cast(originalPtr); + + // tmp solution while waiting fix for UpdateBlockStatement + GetImpl()->BlockStatementSetStatements(context, original, statementList, static_cast(statementListLen)); + return original; + } + KOALA_INTEROP_4(UpdateBlockStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt) + + KNativePointer impl_CreateReturnStatement1(KNativePointer contextPtr, KNativePointer argumentPtr) { + auto context = reinterpret_cast(contextPtr); + auto argument = reinterpret_cast(argumentPtr); + + return GetImpl()->CreateReturnStatement1(context, argument); + } + KOALA_INTEROP_2(CreateReturnStatement1, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ReturnStatementArgument(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->ReturnStatementArgument(context, node); + } + KOALA_INTEROP_2(ReturnStatementArgument, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CreateIfStatement(KNativePointer contextPtr, KNativePointer testPtr, KNativePointer consequentPtr, KNativePointer alternatePtr) { + auto context = reinterpret_cast(contextPtr); + auto test = reinterpret_cast(testPtr); + auto consequent = reinterpret_cast(consequentPtr); + auto alternate = reinterpret_cast(alternatePtr); + + return GetImpl()->CreateIfStatement(context, test, consequent, alternate); + } + KOALA_INTEROP_4(CreateIfStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CreateMemberExpression( + KNativePointer contextPtr, + KNativePointer objectPtr, + KNativePointer propertyPtr, + KInt kindT, + KBoolean computedT, + KBoolean optionalT + ) { + auto context = reinterpret_cast(contextPtr); + auto object = reinterpret_cast(objectPtr); + auto property = reinterpret_cast(propertyPtr); + auto computed = static_cast(computedT); + auto optional = static_cast(optionalT); + auto kind = static_cast(kindT); + + return GetImpl()->CreateMemberExpression(context, object, property, kind, computed, optional); + } + KOALA_INTEROP_6(CreateMemberExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KBoolean, KBoolean) + + KNativePointer impl_UpdateMemberExpression( + KNativePointer contextPtr, + KNativePointer nodePtr, + KNativePointer objectPtr, + KNativePointer propertyPtr, + KInt kindT, + KBoolean computedT, + KBoolean optionalT + ) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + auto object = reinterpret_cast(objectPtr); + auto property = reinterpret_cast(propertyPtr); + auto computed = static_cast(computedT); + auto optional = static_cast(optionalT); + auto kind = static_cast(kindT); + + return GetImpl()->UpdateMemberExpression(context, node, object, property, kind, computed, optional); + } + KOALA_INTEROP_7(UpdateMemberExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KBoolean, KBoolean) + + KNativePointer impl_UpdateMethodDefinition( + KNativePointer contextPtr, + KNativePointer nodePtr, + KInt kindT, + KNativePointer keyPtr, + KNativePointer valuePtr, + KInt modifiersT, + KBoolean isComputedT + ) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + auto kind = static_cast(kindT); + auto key = reinterpret_cast(keyPtr); + auto value = reinterpret_cast(valuePtr); + auto modifiers = static_cast(modifiersT); + auto isComputed = static_cast(isComputedT); + + return GetImpl()->UpdateMethodDefinition(context, node, kind, key, value, modifiers, isComputed); + } + KOALA_INTEROP_7(UpdateMethodDefinition, KNativePointer, KNativePointer, KNativePointer, KInt, KNativePointer, KNativePointer, KInt, KBoolean) + + KNativePointer impl_MemberExpressionObject( + KNativePointer contextPtr, + KNativePointer nodePtr + ) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->MemberExpressionObject(context, node); + } + KOALA_INTEROP_2(MemberExpressionObject, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_MemberExpressionProperty( + KNativePointer contextPtr, + KNativePointer nodePtr + ) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->MemberExpressionProperty(context, node); + } + KOALA_INTEROP_2(MemberExpressionProperty, KNativePointer, KNativePointer, KNativePointer) + + KInt impl_MemberExpressionKindConst( + KNativePointer contextPtr, + KNativePointer nodePtr + ) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->MemberExpressionKindConst(context, node); + } + KOALA_INTEROP_2(MemberExpressionKindConst, KInt, KNativePointer, KNativePointer) + + KNativePointer impl_CreateCallExpression( + KNativePointer contextPtr, + KNativePointer calleePtr, + KNativePointerArray argumentsPtr, + KInt argumentsLen, + KNativePointer typeParamsPtr, + KBoolean optionalT, + KBoolean trailingCommaT + ) { + auto context = reinterpret_cast(contextPtr); + auto callee = reinterpret_cast(calleePtr); + auto arguments = reinterpret_cast(argumentsPtr); + auto typeParams = reinterpret_cast(typeParamsPtr); + auto optional = static_cast(optionalT); + auto trailingComma = static_cast(trailingCommaT); + + return GetImpl()->CreateCallExpression(context, callee, arguments, argumentsLen, typeParams, optional, trailingComma); + } + KOALA_INTEROP_7(CreateCallExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt, KNativePointer, KBoolean, KBoolean) + + KNativePointer impl_UpdateCallExpression( + KNativePointer contextPtr, + KNativePointer nodePtr, + KNativePointer calleePtr, + KNativePointerArray argumentsPtr, + KInt argumentsLen, + KNativePointer typeParamsPtr, + KBoolean optionalT, + KBoolean trailingCommaT + ) { + auto node = reinterpret_cast(nodePtr); + auto context = reinterpret_cast(contextPtr); + auto callee = reinterpret_cast(calleePtr); + auto arguments = reinterpret_cast(argumentsPtr); + auto typeParams = reinterpret_cast(typeParamsPtr); + auto optional = static_cast(optionalT); + auto trailingComma = static_cast(trailingCommaT); + + // auto nn = GetImpl()->UpdateCallExpression(context, node, callee, arguments, argumentsLen, typeParams, optional, trailingComma); + auto nn = GetImpl()->CreateCallExpression(context, callee, arguments, argumentsLen, typeParams, optional, trailingComma); + GetImpl()->AstNodeSetOriginalNode(context, nn, node); + return nn; + } + KOALA_INTEROP_8(UpdateCallExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt, KNativePointer, KBoolean, KBoolean) + + KNativePointer impl_CreateExpressionStatement(KNativePointer contextPtr, KNativePointer exprPtr) { + auto context = reinterpret_cast(contextPtr); + auto expr = reinterpret_cast(exprPtr); + + return GetImpl()->CreateExpressionStatement(context, expr); + } + KOALA_INTEROP_2(CreateExpressionStatement, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_UpdateExpressionStatement(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer exprPtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + auto expr = reinterpret_cast(exprPtr); + + return GetImpl()->UpdateExpressionStatement(context, node, expr); + } + KOALA_INTEROP_3(UpdateExpressionStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ScriptFunctionBody(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->ScriptFunctionBody(context, node); + } + KOALA_INTEROP_2(ScriptFunctionBody, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CreateBinaryExpression(KNativePointer contextPtr, KNativePointer leftPtr, KNativePointer rightPtr, KInt tokenKind) { + auto context = reinterpret_cast(contextPtr); + auto left = reinterpret_cast(leftPtr); + auto right = reinterpret_cast(rightPtr); + + return GetImpl()->CreateBinaryExpression(context, left, right, Es2pandaTokenType(tokenKind)); + } + KOALA_INTEROP_4(CreateBinaryExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt) + + KNativePointer impl_CreateAssignmentExpression(KNativePointer contextPtr, KNativePointer leftPtr, KNativePointer rightPtr, KInt assignmentOperator) { + auto context = reinterpret_cast(contextPtr); + auto left = reinterpret_cast(leftPtr); + auto right = reinterpret_cast(rightPtr); + + return GetImpl()->CreateAssignmentExpression(context, left, right, Es2pandaTokenType(assignmentOperator)); + } + KOALA_INTEROP_4(CreateAssignmentExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt) + + KNativePointer impl_CreateFunctionSignature( + KNativePointer contextPtr, + KNativePointer typeParamsPtr, + KNativePointerArray paramsPtr, + KInt paramsLen, + KNativePointer returnTypeAnnotationPtr + ) { + auto context = reinterpret_cast(contextPtr); + auto typeParams = reinterpret_cast(typeParamsPtr); + auto params = reinterpret_cast(paramsPtr); + auto returnTypeAnnotation = reinterpret_cast(returnTypeAnnotationPtr); + + return GetImpl()->CreateFunctionSignature(context, typeParams, params, paramsLen, returnTypeAnnotation); + } + KOALA_INTEROP_5(CreateFunctionSignature, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt, KNativePointer) + + KNativePointer impl_CreateTSUnionType( + KNativePointer contextPtr, + KNativePointerArray typesPtr, + KInt typesLen + ) { + auto context = reinterpret_cast(contextPtr); + auto types = reinterpret_cast(typesPtr); + + return GetImpl()->CreateTSUnionType(context, types, typesLen); + } + KOALA_INTEROP_3(CreateTSUnionType, KNativePointer, KNativePointer, KNativePointerArray, KInt) + + KNativePointer impl_TSUnionTypeTypesConst(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer returnLen) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + std::size_t params_len = 0; + auto params = GetImpl()->TSUnionTypeTypesConst(context, node, ¶ms_len); + + return new std::vector(params, params + params_len); + } + KOALA_INTEROP_3(TSUnionTypeTypesConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CreateETSUnionTypeIr( + KNativePointer contextPtr, + KNativePointerArray typesPtr, + KInt typesLen + ) { + auto context = reinterpret_cast(contextPtr); + auto types = reinterpret_cast(typesPtr); + + return GetImpl()->CreateETSUnionTypeIr(context, types, typesLen); + } + KOALA_INTEROP_3(CreateETSUnionTypeIr, KNativePointer, KNativePointer, KNativePointerArray, KInt) + + KNativePointer impl_ETSUnionTypeIrTypesConst(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer returnLen) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + std::size_t params_len = 0; + auto params = GetImpl()->ETSUnionTypeIrTypesConst(context, node, ¶ms_len); + + return new std::vector(params, params + params_len); + } + KOALA_INTEROP_3(ETSUnionTypeIrTypesConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CreateScriptFunction( + KNativePointer contextPtr, + KNativePointer databodyPtr, + KNativePointer datasignaturePtr, + KInt datafuncFlags, + KInt dataFlags, + KBoolean datadeclare + ) { + auto context = reinterpret_cast(contextPtr); + auto databody = reinterpret_cast(databodyPtr); + auto datasignature = reinterpret_cast(datasignaturePtr); + + return GetImpl()->CreateScriptFunction(context, databody, datasignature, datafuncFlags, dataFlags, datadeclare); + } + KOALA_INTEROP_6(CreateScriptFunction, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KInt, KBoolean) + + KNativePointer impl_UpdateScriptFunction( + KNativePointer contextPtr, + KNativePointer nodePtr, + KNativePointer databodyPtr, + KNativePointer datasignaturePtr, + KInt datafuncFlags, + KInt dataFlags, + KBoolean datadeclare + ) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + auto databody = reinterpret_cast(databodyPtr); + auto datasignature = reinterpret_cast(datasignaturePtr); + + return GetImpl()->UpdateScriptFunction(context, node, databody, datasignature, datafuncFlags, dataFlags, datadeclare); + } + KOALA_INTEROP_7(UpdateScriptFunction, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KInt, KBoolean) + + KNativePointer impl_CreateBlockStatement( + KNativePointer contextPtr, + KNativePointerArray statementListPtr, + KInt statementListLen + ) { + auto context = reinterpret_cast(contextPtr); + auto statementList = reinterpret_cast(statementListPtr); + + return GetImpl()->CreateBlockStatement(context, statementList, statementListLen); + } + KOALA_INTEROP_3(CreateBlockStatement, KNativePointer, KNativePointer, KNativePointerArray, KInt) + + KNativePointer impl_CreateAstDumper( + KNativePointer contextPtr, + KNativePointer nodePtr, + KStringPtr& sourcePtr + ) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->CreateAstDumper(context, node, getStringCopy(sourcePtr)); + } + KOALA_INTEROP_3(CreateAstDumper, KNativePointer, KNativePointer, KNativePointer, KStringPtr) + + KNativePointer impl_AstDumperModifierToString( + KNativePointer contextPtr, + KNativePointer dumperPtr, + KInt flagsT + ) { + auto context = reinterpret_cast(contextPtr); + auto dumper = reinterpret_cast(dumperPtr); + auto flags = static_cast(flagsT); + + return new std::string(GetImpl()->AstDumperModifierToString(context, dumper, flags)); + } + KOALA_INTEROP_3(AstDumperModifierToString, KNativePointer, KNativePointer, KNativePointer, KInt) + + KNativePointer impl_MethodDefinitionFunction( + KNativePointer contextPtr, + KNativePointer nodePtr + ) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->MethodDefinitionFunction(context, node); + } + KOALA_INTEROP_2(MethodDefinitionFunction, KNativePointer, KNativePointer, KNativePointer) + + KInt impl_MethodDefinitionKindConst( + KNativePointer contextPtr, + KNativePointer nodePtr + ) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->MethodDefinitionKindConst(context, node); + } + KOALA_INTEROP_2(MethodDefinitionKindConst, KInt, KNativePointer, KNativePointer) + + + KNativePointer impl_AstNodeSetParent( + KNativePointer contextPtr, + KNativePointer astPtr, + KNativePointer parentPtr + ) { + auto context = reinterpret_cast(contextPtr); + auto ast = reinterpret_cast(astPtr); + auto parent = reinterpret_cast(parentPtr); + + GetImpl()->AstNodeSetParent(context, ast, parent); + return ast; + } + KOALA_INTEROP_3(AstNodeSetParent, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_AstNodeSetOriginalNode( + KNativePointer contextPtr, + KNativePointer astPtr, + KNativePointer originalNodePtr + ) { + auto context = reinterpret_cast(contextPtr); + auto ast = reinterpret_cast(astPtr); + auto originalNode = reinterpret_cast(originalNodePtr); + + GetImpl()->AstNodeSetOriginalNode(context, ast, originalNode); + return ast; + } + KOALA_INTEROP_3(AstNodeSetOriginalNode, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_AstNodeOriginalNodeConst( + KNativePointer contextPtr, + KNativePointer astPtr + ) { + auto context = reinterpret_cast(contextPtr); + auto ast = reinterpret_cast(astPtr); + + return GetImpl()->AstNodeOriginalNodeConst(context, ast); + } + KOALA_INTEROP_2(AstNodeOriginalNodeConst, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_AstNodeClone( + KNativePointer contextPtr, + KNativePointer astPtr, + KNativePointer parentPtr + ) { + auto context = reinterpret_cast(contextPtr); + auto ast = reinterpret_cast(astPtr); + auto parent = reinterpret_cast(parentPtr); + + return GetImpl()->AstNodeClone(context, ast, parent); + } + KOALA_INTEROP_3(AstNodeClone, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ScriptFunctionSetIdent( + KNativePointer contextPtr, + KNativePointer astPtr, + KNativePointer idPtr + ) { + auto context = reinterpret_cast(contextPtr); + auto ast = reinterpret_cast(astPtr); + auto id = reinterpret_cast(idPtr); + + GetImpl()->ScriptFunctionSetIdent(context, ast, id); + return ast; + } + KOALA_INTEROP_3(ScriptFunctionSetIdent, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ScriptFunctionSetSignature( + KNativePointer contextPtr, + KNativePointer astPtr, + KNativePointer signaturePtr + ) { + auto context = reinterpret_cast(contextPtr); + auto ast = reinterpret_cast(astPtr); + auto signature = reinterpret_cast(signaturePtr); + + GetImpl()->ScriptFunctionSetSignature(context, ast, signature); + return ast; + } + KOALA_INTEROP_3(ScriptFunctionSetSignature, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ScriptFunctionSetBody( + KNativePointer contextPtr, + KNativePointer astPtr, + KNativePointer bodyPtr + ) { + auto context = reinterpret_cast(contextPtr); + auto ast = reinterpret_cast(astPtr); + auto body = reinterpret_cast(bodyPtr); + + GetImpl()->ScriptFunctionSetBody(context, ast, body); + return ast; + } + KOALA_INTEROP_3(ScriptFunctionSetBody, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ScriptFunctionSetScope( + KNativePointer contextPtr, + KNativePointer astPtr, + KNativePointer scopePtr + ) { + auto context = reinterpret_cast(contextPtr); + auto ast = reinterpret_cast(astPtr); + auto scope = reinterpret_cast(scopePtr); + + GetImpl()->ScriptFunctionSetScope(context, ast, scope); + return ast; + } + KOALA_INTEROP_3(ScriptFunctionSetScope, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ScriptFunctionSignature(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->ScriptFunctionSignature(context, node); + } + KOALA_INTEROP_2(ScriptFunctionSignature, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ScriptFunctionIrSignature(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->ScriptFunctionIrSignature(context, node); + } + KOALA_INTEROP_2(ScriptFunctionIrSignature, KNativePointer, KNativePointer, KNativePointer) + + KInt impl_ScriptFunctionFlagsConst(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->ScriptFunctionFlagsConst(context, node); + } + KOALA_INTEROP_2(ScriptFunctionFlagsConst, KInt, KNativePointer, KNativePointer) + + KInt impl_AstNodeModifiers(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->AstNodeModifiers(context, node); + } + KOALA_INTEROP_2(AstNodeModifiers, KInt, KNativePointer, KNativePointer) + + KNativePointer impl_AstNodeAddModifier(KNativePointer contextPtr, KNativePointer nodePtr, KInt flagsT) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + auto flags = static_cast(flagsT); + + GetImpl()->AstNodeAddModifier(context, node, flags); + return node; + } + KOALA_INTEROP_3(AstNodeAddModifier, KNativePointer, KNativePointer, KNativePointer, KInt) + + KNativePointer impl_AstNodeClearModifier(KNativePointer contextPtr, KNativePointer nodePtr, KInt flagsT) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + auto flags = static_cast(flagsT); + + GetImpl()->AstNodeClearModifier(context, node, flags); + return node; + } + KOALA_INTEROP_3(AstNodeClearModifier, KNativePointer, KNativePointer, KNativePointer, KInt) + + KNativePointer impl_FunctionSignatureParamsConst(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer returnTypeLen) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + std::size_t params_len = 0; + auto params = GetImpl()->FunctionSignatureParamsConst(context, node, ¶ms_len); + return new std::vector(params, params + params_len); + } + KOALA_INTEROP_3(FunctionSignatureParamsConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_FunctionSignatureTypeParams(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->FunctionSignatureTypeParams(context, node); + } + KOALA_INTEROP_2(FunctionSignatureTypeParams, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_FunctionSignatureReturnType(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->FunctionSignatureReturnType(context, node); + } + KOALA_INTEROP_2(FunctionSignatureReturnType, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_UpdateIdentifier1(KNativePointer contextPtr, KNativePointer nodePtr, KStringPtr& namePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->UpdateIdentifier1(context, node, getStringCopy(namePtr)); + } + KOALA_INTEROP_3(UpdateIdentifier1, KNativePointer, KNativePointer, KNativePointer, KStringPtr) + + KNativePointer impl_UpdateIdentifier2(KNativePointer contextPtr, KNativePointer nodePtr, KStringPtr& namePtr, KNativePointer typeAnnotationPtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + auto typeAnnotation = reinterpret_cast(typeAnnotationPtr); + + return GetImpl()->UpdateIdentifier2(context, node, getStringCopy(namePtr), typeAnnotation); + } + KOALA_INTEROP_4(UpdateIdentifier2, KNativePointer, KNativePointer, KNativePointer, KStringPtr, KNativePointer) + + KBoolean impl_IdentifierIsPrivateIdentConst(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->IdentifierIsPrivateIdentConst(context, node); + } + KOALA_INTEROP_2(IdentifierIsPrivateIdentConst, KBoolean, KNativePointer, KNativePointer) + + KInt impl_IdentifierIdentifierFlags(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return + (GetImpl()->IdentifierIsOptionalConst(context, node) ? (1 << 0) : 0) | + (GetImpl()->IdentifierIsReferenceConst(context, node, Es2pandaScriptExtension::SCRIPT_EXTENSION_TS) ? (1 << 1) : 0) | + (GetImpl()->IdentifierIsTdzConst(context, node) ? (1 << 2) : 0); + } + KOALA_INTEROP_2(IdentifierIdentifierFlags, KInt, KNativePointer, KNativePointer) + + KNativePointer impl_CreateFunctionExpression(KNativePointer contextPtr, KNativePointer funcPtr) { + auto context = reinterpret_cast(contextPtr); + auto func = reinterpret_cast(funcPtr); + + return GetImpl()->CreateFunctionExpression(context, func); + } + KOALA_INTEROP_2(CreateFunctionExpression, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_UpdateFunctionExpression(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer funcPtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + auto func = reinterpret_cast(funcPtr); + + return GetImpl()->UpdateFunctionExpression(context, node, func); + } + KOALA_INTEROP_3(UpdateFunctionExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CreateArrowFunctionExpression(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->CreateArrowFunctionExpression(context, node); + } + KOALA_INTEROP_2(CreateArrowFunctionExpression, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ArrowFunctionExpressionFunction(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->ArrowFunctionExpressionFunction(context, node); + } + KOALA_INTEROP_2(ArrowFunctionExpressionFunction, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ArrowFunctionExpressionCreateTypeAnnotation(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->ArrowFunctionExpressionCreateTypeAnnotation(context, node); + } + KOALA_INTEROP_2(ArrowFunctionExpressionCreateTypeAnnotation, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_FunctionExpressionFunction(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->FunctionExpressionFunction(context, node); + } + KOALA_INTEROP_2(FunctionExpressionFunction, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ExpressionStatementGetExpression(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->ExpressionStatementGetExpression(context, node); + } + KOALA_INTEROP_2(ExpressionStatementGetExpression, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CallExpressionArguments(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer returnLen) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + std::size_t params_len = 0; + auto params = GetImpl()->CallExpressionArguments(context, node, ¶ms_len); + return new std::vector(params, params + params_len); + } + KOALA_INTEROP_3(CallExpressionArguments, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CallExpressionCallee(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + return GetImpl()->CallExpressionCallee(context, node); + } + KOALA_INTEROP_2(CallExpressionCallee, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_AstNodeParent(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + return GetImpl()->AstNodeParent(context, node); + } + KOALA_INTEROP_2(AstNodeParent, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_AstNodeVariableConst(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->AstNodeVariableConst(context, node); + } + KOALA_INTEROP_2(AstNodeVariableConst, KNativePointer, KNativePointer, KNativePointer) + + KInt impl_AstNodeTypeConst(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->AstNodeTypeConst(context, node); + } + KOALA_INTEROP_2(AstNodeTypeConst, KInt, KNativePointer, KNativePointer) + + KNativePointer impl_VariableDeclaration(KNativePointer contextPtr, KNativePointer variablePtr) { + auto context = reinterpret_cast(contextPtr); + auto variable = reinterpret_cast(variablePtr); + + return GetImpl()->VariableDeclaration(context, variable); + } + KOALA_INTEROP_2(VariableDeclaration, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_DeclNode(KNativePointer contextPtr, KNativePointer declPtr) { + auto context = reinterpret_cast(contextPtr); + auto decl = reinterpret_cast(declPtr); + + return GetImpl()->DeclNode(context, decl); + } + KOALA_INTEROP_2(DeclNode, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_AstNodeScopeConst(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + return GetImpl()->AstNodeScopeConst(context, node); + } + KOALA_INTEROP_2(AstNodeScopeConst, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ScopeSetParent(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer parentPtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + auto parent = reinterpret_cast(parentPtr); + GetImpl()->ScopeSetParent(context, node, parent); + return node; + } + KOALA_INTEROP_3(ScopeSetParent, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_BlockStatementSetStatements( + KNativePointer contextPtr, + KNativePointer nodePtr, + KNativePointerArray statementsPtr, + KInt statementsLen + ) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + auto statements = reinterpret_cast(statementsPtr); + + GetImpl()->BlockStatementSetStatements(context, node, statements, statementsLen); + return node; + } + KOALA_INTEROP_4(BlockStatementSetStatements, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt) + + KNativePointer impl_VarBinderSetProgram(KNativePointer contextPtr) { + auto context = reinterpret_cast(contextPtr); + + GetImpl()->VarBinderSetProgram(context); + return nullptr; + } + KOALA_INTEROP_1(VarBinderSetProgram, KNativePointer, KNativePointer) + + KNativePointer impl_VarBinderSetContext(KNativePointer contextPtr) { + auto context = reinterpret_cast(contextPtr); + + GetImpl()->VarBinderSetContext(context); + return nullptr; + } + KOALA_INTEROP_1(VarBinderSetContext, KNativePointer, KNativePointer) + + KNativePointer impl_VarBinderSetGenStdLib(KNativePointer contextPtr, KBoolean genStdLibT) { + auto context = reinterpret_cast(contextPtr); + auto genStdLib = static_cast(genStdLibT); + + GetImpl()->VarBinderSetGenStdLib(context, genStdLib); + return nullptr; + } + KOALA_INTEROP_2(VarBinderSetGenStdLib, KNativePointer, KNativePointer, KBoolean) + + KNativePointer impl_CreateClassDeclaration(KNativePointer contextPtr, KNativePointer defPtr) { + auto context = reinterpret_cast(contextPtr); + auto def = reinterpret_cast(defPtr); + + return GetImpl()->CreateClassDeclaration(context, def); + } + KOALA_INTEROP_2(CreateClassDeclaration, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_UpdateClassDeclaration(KNativePointer contextPtr, KNativePointer originalPtr, KNativePointer defPtr) { + auto context = reinterpret_cast(contextPtr); + auto original = reinterpret_cast(originalPtr); + auto def = reinterpret_cast(defPtr); + + return GetImpl()->UpdateClassDeclaration(context, original, def); + } + KOALA_INTEROP_3(UpdateClassDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ClassDefinitionSetTypeParams( + KNativePointer contextPtr, + KNativePointer nodePtr, + KNativePointer typeParamsPtr + ) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + auto typeParams = reinterpret_cast(typeParamsPtr); + + GetImpl()->ClassDefinitionSetTypeParams(context, node, typeParams); + return node; + } + KOALA_INTEROP_3(ClassDefinitionSetTypeParams, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ClassDefinitionSetSuper( + KNativePointer contextPtr, + KNativePointer astPtr, + KNativePointer superClassPtr + ) { + auto context = reinterpret_cast(contextPtr); + auto ast = reinterpret_cast(astPtr); + auto superClass = reinterpret_cast(superClassPtr); + + GetImpl()->ClassDefinitionSetSuper(context, ast, superClass); + return ast; + } + KOALA_INTEROP_3(ClassDefinitionSetSuper, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ClassDefinitionIdent( + KNativePointer contextPtr, + KNativePointer nodePtr + ) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->ClassDefinitionIdent(context, node); + } + KOALA_INTEROP_2(ClassDefinitionIdent, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CreateClassDefinition1( + KNativePointer contextPtr, + KNativePointer identPtr, + KNativePointerArray bodyPtr, + KInt bodyLenT, + KInt modifiersT, + KInt flagsT + ) { + auto context = reinterpret_cast(contextPtr); + auto ident = reinterpret_cast(identPtr); + auto body = reinterpret_cast(bodyPtr); + auto bodyLen = static_cast(bodyLenT); + auto modifiers = Es2pandaClassDefinitionModifiers(modifiersT); + auto flags = Es2pandaModifierFlags(flagsT); + + return GetImpl()->CreateClassDefinition1(context, ident, body, bodyLen, modifiers, flags); + } + KOALA_INTEROP_6(CreateClassDefinition1, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt, KInt, KInt) + + KNativePointer impl_UpdateClassDefinition1( + KNativePointer contextPtr, + KNativePointer originalPtr, + KNativePointer identPtr, + KNativePointerArray bodyPtr, + KInt bodyLenT, + KInt modifiersT, + KInt flagsT + ) { + auto context = reinterpret_cast(contextPtr); + auto original = reinterpret_cast(originalPtr); + auto ident = reinterpret_cast(identPtr); + auto body = reinterpret_cast(bodyPtr); + auto bodyLen = static_cast(bodyLenT); + auto modifiers = Es2pandaClassDefinitionModifiers(modifiersT); + auto flags = Es2pandaModifierFlags(flagsT); + + return GetImpl()->UpdateClassDefinition1(context, original, ident, body, bodyLen, modifiers, flags); + } + KOALA_INTEROP_7(UpdateClassDefinition1, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt, KInt, KInt) + + KNativePointer impl_CreateSuperExpression(KNativePointer contextPtr) { + auto context = reinterpret_cast(contextPtr); + + return GetImpl()->CreateSuperExpression(context); + } + KOALA_INTEROP_1(CreateSuperExpression, KNativePointer, KNativePointer) + + KNativePointer impl_UpdateSuperExpression(KNativePointer contextPtr, KNativePointer originalPtr) { + auto context = reinterpret_cast(contextPtr); + auto original = reinterpret_cast(originalPtr); + + return GetImpl()->UpdateSuperExpression(context, original); + } + KOALA_INTEROP_2(UpdateSuperExpression, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_CreateETSImportDeclaration( + KNativePointer contextPtr, + KNativePointer sourcePtr, + KNativePointerArray specifiersPtr, + KInt specifiersLen, + KInt importKindT + ) { + auto context = reinterpret_cast(contextPtr); + auto source = reinterpret_cast(sourcePtr); + auto specifiers = reinterpret_cast(specifiersPtr); + auto importKind = static_cast(importKindT); + + return GetImpl()->CreateETSImportDeclaration(context, source, specifiers, specifiersLen, importKind); + } + KOALA_INTEROP_5(CreateETSImportDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KInt, KInt) + + KNativePointer impl_ETSImportDeclarationSourceConst( + KNativePointer contextPtr, + KNativePointer nodePtr + ) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->ETSImportDeclarationSourceConst(context, node); + } + KOALA_INTEROP_2(ETSImportDeclarationSourceConst, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_ETSImportDeclarationResolvedSource( + KNativePointer contextPtr, + KNativePointer nodePtr + ) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->ETSImportDeclarationResolvedSource(context, node); + } + KOALA_INTEROP_2(ETSImportDeclarationResolvedSource, KNativePointer, KNativePointer, KNativePointer) + + KBoolean impl_ETSImportDeclarationHasDeclConst( + KNativePointer contextPtr, + KNativePointer nodePtr + ) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + + return GetImpl()->ETSImportDeclarationHasDeclConst(context, node); + } + KOALA_INTEROP_2(ETSImportDeclarationHasDeclConst, KBoolean, KNativePointer, KNativePointer) + + KNativePointer impl_CreateImportSource( + KNativePointer contextPtr, + KNativePointer sourcePtr, + KNativePointer resolvedSourcePtr, + KBoolean hasDeclT + ) { + auto context = reinterpret_cast(contextPtr); + auto source = reinterpret_cast(sourcePtr); + auto resolvedSource = reinterpret_cast(resolvedSourcePtr); + auto hasDecl = static_cast(hasDeclT); + + return GetImpl()->CreateImportSource(context, source, resolvedSource, hasDecl); + } + KOALA_INTEROP_4(CreateImportSource, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean) + + KNativePointer impl_CreateImportSpecifier( + KNativePointer contextPtr, + KNativePointer importedPtr, + KNativePointer localPtr + ) { + auto context = reinterpret_cast(contextPtr); + auto imported = reinterpret_cast(importedPtr); + auto local = reinterpret_cast(localPtr); + + return GetImpl()->CreateImportSpecifier(context, imported, local); + } + KOALA_INTEROP_3(CreateImportSpecifier, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + + + /* + TODO: NOT FROM API (shouldn't be there) + ----------------------------------------------------------------------------------------------------------------------------- + */ + + es2panda_AstNode * __parentNode; + es2panda_Context * __context; + + static void changeParent(es2panda_AstNode *child) + { + GetImpl()->AstNodeSetParent(__context, child, __parentNode); + } + + static void SetRightParent(es2panda_AstNode *node, void *arg) + { + es2panda_Context *ctx = static_cast(arg); + __context = ctx; + __parentNode = node; + + GetImpl()->AstNodeIterateConst(ctx, node, changeParent); + } + + KNativePointer impl_AstNodeUpdateAll(KNativePointer contextPtr, KNativePointer programPtr) { + auto context = reinterpret_cast(contextPtr); + auto program = reinterpret_cast(programPtr); + + GetImpl()->AstNodeForEach(program, SetRightParent, context); + return program; + } + KOALA_INTEROP_2(AstNodeUpdateAll, KNativePointer, KNativePointer, KNativePointer) + + KNativePointer impl_AstNodeUpdateChildren(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + __parentNode = node; + + GetImpl()->AstNodeIterateConst(context, node, changeParent); + return node; + } + KOALA_INTEROP_2(AstNodeUpdateChildren, KNativePointer, KNativePointer, KNativePointer) + + std::vector __children; + + static void visitChild(es2panda_AstNode *node) { + __children.emplace_back(node); + } + + KNativePointer impl_AstNodeChildren( + KNativePointer contextPtr, + KNativePointer nodePtr + ) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + __context = context; + __children.clear(); + + GetImpl()->AstNodeIterateConst(context, node, visitChild); + return new std::vector(__children); + } + KOALA_INTEROP_2(AstNodeChildren, KNativePointer, KNativePointer, KNativePointer) + + /* + ----------------------------------------------------------------------------------------------------------------------------- + */ + \ No newline at end of file diff --git a/arkoala-arkts/libarkts/plugins/src/checked-stage-plugin.ts b/arkoala-arkts/libarkts/plugins/src/checked-stage-plugin.ts index c7b9f14634019ca286b7452a70577082e3a213c2..d162d1f3f4606018a88101373aa97511c4d458d1 100644 --- a/arkoala-arkts/libarkts/plugins/src/checked-stage-plugin.ts +++ b/arkoala-arkts/libarkts/plugins/src/checked-stage-plugin.ts @@ -1,8 +1,10 @@ import * as ts from "@koalaui/libarkts" -import { PrintVisitor } from './print-visitor' import { BuilderLambdaTransformer } from './builder-lambda-transformer' -import { ComponentTransformer } from './component-transformer' import { StructTransformer } from './struct-transformer' +import { PositionalIdTracker } from "./utils" +import { ImportTransformer } from "./import-transformer" +import { FunctionTransformer } from "./function-transformer" +import { TestTransformer } from "./only-test-transformer" export interface TransformerOptions { trace?: boolean, @@ -19,6 +21,16 @@ export default function exampleTransformer( script = builderLambdaTransformer.visitor(script) as ts.EtsScript; script = structTransformer.visitor(script) as ts.EtsScript; + const positionalIdTracker = new PositionalIdTracker(ts.getFileName(), false); + const importTransformer = new ImportTransformer(); + const functionTransformer = new FunctionTransformer(positionalIdTracker); + importTransformer.visitor(script); + script = functionTransformer.visitor(script) as ts.EtsScript; + + // TODO: remove this when the .d.ets transformation is ready + const testTransformer = new TestTransformer(); + script = testTransformer.visitor(script) as ts.EtsScript; + return script; } } diff --git a/arkoala-arkts/libarkts/plugins/src/function-transformer.ts b/arkoala-arkts/libarkts/plugins/src/function-transformer.ts index b6b77810be3f77abd7c388875e6e87d9c2dbe14b..45f2cd112b2c6330377111484568628c4fe91cf6 100644 --- a/arkoala-arkts/libarkts/plugins/src/function-transformer.ts +++ b/arkoala-arkts/libarkts/plugins/src/function-transformer.ts @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 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 @@ -13,85 +13,152 @@ * limitations under the License. */ -import * as ts from "@koalaui/libarkts" -import { AbstractVisitor } from "./AbstractVisitor"; +import * as arkts from "@koalaui/libarkts" +import { AbstractVisitor } from "./AbstractVisitor" +import { createContextParameter, createIdParameter, createContextArgument, createIdArgument, RuntimeNames, PositionalIdTracker } from "./utils" -const ANNOTATION = "_REWRITE_" +function isMemoAnnotation(anno: arkts.AnnotationUsage): boolean { + return !!anno.expr && arkts.isIdentifier(anno.expr) && anno.expr.name === RuntimeNames.ANNOTATION; +} -function isAnnotatedCallExpression(node: ts.Node): boolean { - return ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text.startsWith(ANNOTATION) +function hasMemoAnnotation(node: arkts.ScriptFunction) { + return node.annotations.some(isMemoAnnotation); } -function isAnnotatedMethodDeclaration(node: ts.Node): boolean { - return ts.isMethodDeclaration(node) && node.name.text.startsWith(ANNOTATION) +function removeMemoAnnotationInParam(param: arkts.ETSParameterExpression): arkts.ETSParameterExpression { + param.annotations = param.annotations.filter((it) => !isMemoAnnotation(it)); + return param; } -function transformCallExpression(node: ts.CallExpression): ts.Node { - const decl = ts.getDecl(node.expression) - if (decl === undefined) { - throw new Error('memo function for call not found') - } - if (!ts.isIdentifier(node.expression)) { - throw new Error('expression should be Identifier') - } +function createHiddenParameters(): arkts.ETSParameterExpression[] { + return [createContextParameter(), createIdParameter()] +} - return ts.factory.updateCallExpression( - node, - ts.factory.createIdentifier( - node.expression.text.slice(ANNOTATION.length) - ), - undefined, +function createHiddenArguments(hash: arkts.NumberLiteral | arkts.StringLiteral): arkts.AstNode[] { + return [createContextArgument(), createIdArgument(hash)] +} + +function updateFunctionBody(node: arkts.BlockStatement | undefined, hash: arkts.NumberLiteral | arkts.StringLiteral): arkts.BlockStatement | undefined { + if (node === undefined) + return node + const scopeDeclaraion = arkts.factory.createVariableDeclaration( + 0, + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_CONST, [ - ts.factory.createStringLiteral("SAMPLE"), - ...node.arguments + arkts.factory.createVariableDeclarator( + arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_CONST, + arkts.factory.createIdentifier(RuntimeNames.SCOPE), + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(RuntimeNames.CONTEXT), + arkts.factory.createIdentifier(RuntimeNames.INTERNAL_SCOPE), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + arkts.factory.createTSTypeParameterInstantiation( + [ + arkts.factory.createTypeReferenceFromId( + arkts.factory.createIdentifier("void") + ) + ] + ), + [ + createIdArgument(hash) + ] + ) + ) ] ) -} - -function transformMethodDeclaration(node: ts.MethodDeclaration): ts.Node { - const stringParam = - ts.factory.createParameterDeclaration( - undefined, - undefined, - ts.factory.createIdentifier("x"), + const unchangedCheck = arkts.factory.createIfStatement( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(RuntimeNames.SCOPE), + arkts.factory.createIdentifier(RuntimeNames.INTERNAL_VALUE_OK), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_NONE, + false, + false + ), + arkts.factory.createReturnStatement( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(RuntimeNames.SCOPE), + arkts.factory.createIdentifier(RuntimeNames.INTERNAL_VALUE), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_NONE, + false, + false + ) + ) + ) + const recache = arkts.factory.createReturnStatement( + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(RuntimeNames.SCOPE), + arkts.factory.createIdentifier(RuntimeNames.INTERNAL_VALUE_NEW), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), undefined, - ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), - undefined + [] ) - return ts.factory.updateMethodDeclaration( + ) + return arkts.factory.updateBlock( node, - undefined, - undefined, - ts.factory.createIdentifier( - node.name.text.slice(ANNOTATION.length) - ), - undefined, - undefined, [ - stringParam, - ...node.parameters - ], - undefined, - node.body, + scopeDeclaraion, + unchangedCheck, + ...node.statements, + recache + ] ) } +function transformMemoMethod(method: arkts.MethodDefinition, positionalIdTracker: PositionalIdTracker): arkts.MethodDefinition { + const key: arkts.Identifier = method.name; + const scriptFunction: arkts.ScriptFunction = method.scriptFunction; + + const updateScriptFunction = arkts.factory.createScriptFunction( + updateFunctionBody(scriptFunction.body, positionalIdTracker.id(key.name)), + scriptFunction.scriptFunctionFlags, + scriptFunction.modifiers, + false, + scriptFunction.ident, + [...createHiddenParameters(), ...scriptFunction.parameters.map(removeMemoAnnotationInParam)], + scriptFunction.typeParamsDecl, + scriptFunction.returnTypeAnnotation + ); + + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD, + key, + arkts.factory.createFunctionExpression(updateScriptFunction), + method.modifiers, + false + ); +} + export class FunctionTransformer extends AbstractVisitor { - constructor( - ctx?: ts.TransformationContext - ) { - super(ctx) + constructor(private positionalIdTracker: PositionalIdTracker) { + super() } - visitor(beforeChildren: ts.Node): ts.Node { - const node: ts.Node = this.visitEachChild(beforeChildren) + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + const node = this.visitEachChild(beforeChildren); - if (isAnnotatedMethodDeclaration(node) && ts.isMethodDeclaration(node)) { - return transformMethodDeclaration(node) - } else if (isAnnotatedCallExpression(node) && ts.isCallExpression(node) && ts.isIdentifier(node.expression)) { - return transformCallExpression(node) + if (arkts.isMethodDefinition(node) && hasMemoAnnotation(node.scriptFunction)) { + return transformMemoMethod(node, this.positionalIdTracker); + } + if (node instanceof arkts.CallExpression) { + const expr = node.expression + const decl = arkts.getDecl(expr) + if (decl instanceof arkts.MethodDefinition && hasMemoAnnotation(decl.scriptFunction)) { + return arkts.factory.updateCallExpression( + node, + node.expression, + undefined, + [...createHiddenArguments(this.positionalIdTracker.id(decl.name.name)), ...node.arguments] + ) + } } - return node } } diff --git a/arkoala-arkts/libarkts/plugins/src/import-transformer.ts b/arkoala-arkts/libarkts/plugins/src/import-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..4037bcf65925b2c390206004259a29a62b21840b --- /dev/null +++ b/arkoala-arkts/libarkts/plugins/src/import-transformer.ts @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2022-2025 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 * as arkts from "@koalaui/libarkts" +import { AbstractVisitor } from "./AbstractVisitor" +import { createContextTypeImportSpecifier, createIdTypeImportSpecifier, RuntimeNames } from "./utils" + +function createContextTypesImportDeclaration(): arkts.EtsImportDeclaration { + return arkts.factory.createImportDeclaration( + arkts.factory.createStringLiteral(RuntimeNames.CONTEXT_TYPE_DEFAULT_IMPORT), + [createContextTypeImportSpecifier(), createIdTypeImportSpecifier()], + arkts.Es2pandaImportKinds.IMPORT_KINDS_TYPE, + true, + ) +} + +export class ImportTransformer extends AbstractVisitor { + visitor(node: arkts.AstNode): arkts.AstNode { + if (node instanceof arkts.EtsScript) { + return arkts.factory.updateEtsScript( + node, + [ + ...node.getChildren().filter(it => it instanceof arkts.EtsImportDeclaration), + createContextTypesImportDeclaration(), + ...node.getChildren().filter(it => !(it instanceof arkts.EtsImportDeclaration)), + ] + ) + } + return node + } +} diff --git a/arkoala-arkts/libarkts/plugins/src/index.ts b/arkoala-arkts/libarkts/plugins/src/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..975098dcf845209e9604f567cc283f30aeb9aac9 --- /dev/null +++ b/arkoala-arkts/libarkts/plugins/src/index.ts @@ -0,0 +1,71 @@ +import * as ts from "@koalaui/libarkts" +import { ComponentTransformer, ComponentTransformerOptions } from './component-transformer' +import { BuilderLambdaTransformer } from './builder-lambda-transformer' +import { StructTransformer } from './struct-transformer' +import { PositionalIdTracker } from "./utils"; +import { ImportTransformer } from "./import-transformer"; +import { FunctionTransformer } from "./function-transformer"; +import { TestTransformer } from "./only-test-transformer"; + +// TODO: move this to arkts-api +class PluginContext { + private ast: ts.EtsScript | undefined; + + constructor() { + this.ast = undefined; + } + + public setArkTSAst(ast: ts.EtsScript): void { + this.ast = ast; + } + + public getArkTSAst(): ts.EtsScript | undefined { + return this.ast; + } +} + +export function koalaUITransform() { + return { + name: 'ArkUI', + parsed(this: PluginContext) { + console.log("In ArkUI afterParsed") + const node = this.getArkTSAst(); + if (node) { + let script: ts.EtsScript = node; + script = new ComponentTransformer({ arkui: "@ohos.arkui" }).visitor(node) as ts.EtsScript; + ts.setAllParents(script); + this.setArkTSAst(script); + return script; + } + }, + checked(this: PluginContext) { + console.log("In ArkUI afterChecked") + const node = this.getArkTSAst(); + if (node) { + const builderLambdaTransformer = new BuilderLambdaTransformer(); + const structTransformer = new StructTransformer(); + const importTransformer = new ImportTransformer(); + + let script: ts.EtsScript = node; + importTransformer.visitor(script); + script = builderLambdaTransformer.visitor(script) as ts.EtsScript; + script = structTransformer.visitor(script) as ts.EtsScript; + + const positionalIdTracker = new PositionalIdTracker(ts.getFileName(), false); + const functionTransformer = new FunctionTransformer(positionalIdTracker); + script = functionTransformer.visitor(script) as ts.EtsScript; + + // TODO: remove this when the .d.ets transformation is ready + const testTransformer = new TestTransformer(); + script = testTransformer.visitor(script) as ts.EtsScript; + + ts.setAllParents(script); + this.setArkTSAst(script); + return script; + } + }, + clean(this: PluginContext) { + console.log("In ArkUI clean") + } + } +} \ No newline at end of file diff --git a/arkoala-arkts/libarkts/plugins/src/memo-transformer.ts b/arkoala-arkts/libarkts/plugins/src/memo-transformer.ts index 01a2451714fb1bf7e0a7678d59f92c6bda34a877..02c8d3a6a3f180f0db03d055e47bad7c981cd236 100644 --- a/arkoala-arkts/libarkts/plugins/src/memo-transformer.ts +++ b/arkoala-arkts/libarkts/plugins/src/memo-transformer.ts @@ -1,5 +1,5 @@ /* - * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Copyright (c) 2022-2025 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 @@ -13,143 +13,23 @@ * limitations under the License. */ -import * as ts from "@koalaui/libarkts" -import { AbstractVisitor } from "./AbstractVisitor"; +import * as arkts from "@koalaui/libarkts" +import { FunctionTransformer } from "./function-transformer" +import { ImportTransformer } from "./import-transformer" +import { PositionalIdTracker } from "./utils" -const ANNOTATION = "_MEMO_" - -function isAnnotatedCallExpression(node: ts.Node): boolean { - return ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text.startsWith(ANNOTATION) -} - -function isAnnotatedMethodDeclaration(node: ts.Node): boolean { - return ts.isMethodDeclaration(node) && node.name.text.startsWith(ANNOTATION) -} - -function transformCallExpression(node: ts.CallExpression): ts.Node { - const decl = ts.getDecl(node.expression) - if (decl === undefined) { - throw new Error('memo function not found') - } - if (!ts.isIdentifier(node.expression)) { - throw new Error('expression should be Identifier') - } - - return ts.factory.updateCallExpression( - node, - ts.factory.createIdentifier( - node.expression.text.slice(ANNOTATION.length) - ), - undefined, - [ - ts.factory.createIdentifier("__memo_context"), - ts.factory.createIdentifier("__memo_id"), - ...node.arguments - ] - ) -} - -function transformMethodDeclaration(node: ts.MethodDeclaration): ts.Node { - const memoContextParam = - ts.factory.createParameterDeclaration( - undefined, - undefined, - ts.factory.createIdentifier("__memo_context"), - undefined, - ts.factory.createTypeReferenceNode( - ts.factory.createIdentifier("__memo_context_type") - ), - undefined - ) - const memoIdParam = - ts.factory.createParameterDeclaration( - undefined, - undefined, - ts.factory.createIdentifier("__memo_id"), - undefined, - ts.factory.createTypeReferenceNode( - ts.factory.createIdentifier("__memo_id_type") - ), - undefined - ) - const bodyStatements = [ - ts.factory.createIfStatement( - ts.factory.createPropertyAccessExpression( - ts.factory.createIdentifier("__memo_scope"), - ts.factory.createIdentifier("unchanged") - ), - ts.factory.createReturnStatement( - ts.factory.createPropertyAccessExpression( - ts.factory.createIdentifier("__memo_scope"), - ts.factory.createIdentifier("cached") - ) - ), - undefined - ), - ts.factory.createExpressionStatement( - ts.factory.createCallExpression( - ts.factory.createIdentifier("content"), - undefined, - [ - ts.factory.createIdentifier("__memo_context"), - ts.factory.createBinaryExpression( - ts.factory.createIdentifier("__memo_id"), - ts.factory.createToken(ts.SyntaxKind.PlusToken), - ts.factory.createStringLiteral("key_id_main.ts") - ) - ] - )), - ...(node.body?.statements ?? []), - ts.factory.createReturnStatement( - ts.factory.createCallExpression( - ts.factory.createPropertyAccessExpression( - ts.factory.createIdentifier("__memo_scope"), - ts.factory.createIdentifier("recache") - ), - undefined, - undefined - ) - ), - ] - return ts.factory.updateMethodDeclaration( - node, - undefined, - undefined, - ts.factory.createIdentifier( - node.name.text.slice(ANNOTATION.length) - ), - undefined, - undefined, - [ - memoContextParam, - memoIdParam, - ...node.parameters - ], - undefined, - node.body ? - ts.factory.updateBlock( - node.body, - bodyStatements - ) : undefined - ) +export interface TransformerOptions { + trace?: boolean, } -export class MemoTransformer extends AbstractVisitor { - constructor( - ctx?: ts.TransformationContext - ) { - super(ctx) - } - - visitor(beforeChildren: ts.Node): ts.Node { - const node: ts.Node = this.visitEachChild(beforeChildren) - - if (isAnnotatedMethodDeclaration(node) && ts.isMethodDeclaration(node)) { - return transformMethodDeclaration(node) - } else if (isAnnotatedCallExpression(node) && ts.isCallExpression(node) && ts.isIdentifier(node.expression)) { - return transformCallExpression(node) - } - - return node +export default function memoTransformer( + userPluginOptions?: TransformerOptions +) { + return (node: arkts.EtsScript) => { + const positionalIdTracker = new PositionalIdTracker(arkts.getFileName(), false) + const importTransformer = new ImportTransformer() + const functionTransformer = new FunctionTransformer(positionalIdTracker) + importTransformer.visitor(node) + return functionTransformer.visitor(node) } } diff --git a/arkoala-arkts/libarkts/plugins/src/only-test-transformer.ts b/arkoala-arkts/libarkts/plugins/src/only-test-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..9b6c67e7068c862eb7e206739a98cb1cbfd3559f --- /dev/null +++ b/arkoala-arkts/libarkts/plugins/src/only-test-transformer.ts @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2022-2025 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 * as arkts from "@koalaui/libarkts" +import { AbstractVisitor } from "./AbstractVisitor" + +export class TestTransformer extends AbstractVisitor { + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + const node = this.visitEachChild(beforeChildren); + + // This is only for testing purpose. Now the .d.ets transformation is not ready, + // there are @ohos.arkui and @ohos.arkui.after.check, the former one is for transformation before checked, + // the later one is for transformation after checked. + if (arkts.isEtsImportDeclaration(node) && node.importSource.str === "@ohos.arkui") { + const source = node.importSource; + return arkts.factory.updateImportDeclaration( + node, + arkts.factory.updateStringLiteral( + source, + "@ohos.arkui.after.check" + ), + node.importSpecifiers, + node.importKind, + node.hasDecl + ); + } + + return node + } +} diff --git a/arkoala-arkts/libarkts/plugins/src/struct-transformer.ts b/arkoala-arkts/libarkts/plugins/src/struct-transformer.ts index 826e0b1938e42a065889ecc93b6e93ef45dd6e64..bd5b42ab68c71deecebddab0ef6bd8dc1c082164 100644 --- a/arkoala-arkts/libarkts/plugins/src/struct-transformer.ts +++ b/arkoala-arkts/libarkts/plugins/src/struct-transformer.ts @@ -117,15 +117,14 @@ function transformBuildMethod( scriptFunction.scriptFunctionFlags, scriptFunction.modifiers, false, - undefined, + updateKey, params, - undefined, - undefined + scriptFunction.typeParamsDecl, + scriptFunction.returnTypeAnnotation ); updateScriptFunction.annotations = [annotation("memo")]; - // TODO: Currently, just return method itself. Remove this once createMethodDefinition is ready. return arkts.factory.createMethodDefinition( arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD, updateKey, diff --git a/arkoala-arkts/libarkts/plugins/src/util.ts b/arkoala-arkts/libarkts/plugins/src/util.ts deleted file mode 100644 index 3bbd8f63962a6728f6738e686a97037364034ba1..0000000000000000000000000000000000000000 --- a/arkoala-arkts/libarkts/plugins/src/util.ts +++ /dev/null @@ -1,163 +0,0 @@ -/* - * Copyright (c) 2022-2024 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 * as ts from "@koalaui/libarkts" -import * as fs from 'fs' - -export enum FunctionKind { - REGULAR, - MEMO, - MEMO_INTRINSIC, -} - -export type FunctionTable = Map -export type CallTable = Map -export type EntryTable = Set -export type VariableTable = Map - -export function isNamedDeclaration(node: ts.Node): node is ts.NamedDeclaration { - return ("name" in node ) -} - -export function asString(node: ts.Node | undefined): string { - if (node === undefined) { - return "undefined node" - } - if (ts.isIdentifier(node)) { - return node.text - } - if (isNamedDeclaration(node)) { - if (node.name === undefined) { - return `${ts.SyntaxKind[node.kind]}(undefined name)` - } else { - return `${ts.SyntaxKind[node.kind]}(${asString(node.name)})` - } - } else { - return `${ts.SyntaxKind[node.kind]}` - } -} - -export function isFunctionOrMethod(node: ts.Node): node is ts.FunctionLikeDeclaration { - return ts.isFunctionDeclaration(node) || - ts.isMethodDeclaration(node) || - ts.isFunctionExpression(node) || - ts.isArrowFunction(node) -} - -export interface TransformerOptions { - // Emit transformed functions to the console. - trace?: boolean, - // Store the transformed functions to this directory. - keepTransformed?: string, - // Use human readable call site IDs without directory paths. - stableForTest?: boolean, - // Import context and id types from alternative source - contextImport?: string, - // Dump sources with resolved memo annotations to unmemoized directory - only_unmemoize?: boolean, - // Replace extension for output TS files - extension?: string, -} - -function baseName(path: string): string { - return path.replace(/^.*\/(.*)$/, "$1") -} - -export class Tracer { - constructor ( - public options: TransformerOptions, - // TODO: implement ts.Printer - // public printer: arkts.Printer - ) {} - - trace(msg: any) { - if (!this.options.trace) return - console.log(msg) - } - - writeTextToFile(text: string, file: string) { - fs.writeFileSync(file, text, 'utf8') - this.trace("DUMP TO: " + file) - } - - createDirs(dirs: string) { - fs.mkdirSync(dirs, { recursive: true }); - } - - dumpFileName(sourceFile: ts.SourceFile, transformed: ts.FunctionLikeDeclarationBase): string | undefined { - if (!this.options.keepTransformed) { - return undefined - } - - const outDir = (this.options.keepTransformed[0] == "/") ? - this.options.keepTransformed : - `${__dirname}/${this.options.keepTransformed}` - - this.createDirs(outDir) - - const sourceBaseName = baseName(sourceFile.fileName) - if (!transformed.name) return - if (!ts.isIdentifier(transformed.name)) return - const fileName = `${transformed.name.text}_${sourceBaseName}` - return `${outDir}/${fileName}_dump` - } - - keepTransformedFunction(transformed: ts.FunctionLikeDeclarationBase, sourceFile: ts.SourceFile) { - const fileName = this.dumpFileName(sourceFile, transformed) - if (!fileName) return - - // TODO: implement ts.Printer - // const content = this.printer.printNode(arkts.EmitHint.Unspecified, transformed, sourceFile) - // this.writeTextToFile(content+"\n", fileName) - } -} - -export enum RuntimeNames { - // COMPUTE = "compute", - // CONTEXT = "__memo_context", - // ID = "__memo_id", - // SCOPE = "__memo_scope", - // INTERNAL_PARAMETER_STATE = "param", - // INTERNAL_VALUE = "cached", - // INTERNAL_VALUE_NEW = "recache", - // INTERNAL_SCOPE = "scope", - // INTERNAL_VALUE_OK = "unchanged", - // CONTENT = "content", - // VALUE = "value", - // __CONTEXT = "__context", - // __ID = "__id", - // __KEY = "__key", - // __STATE = "__state", - // CONTEXT_TYPE = "__memo_context_type", - // ID_TYPE = "__memo_id_type", - // TRANSFORMED_TYPE = "__memo_transformed", - // SYNTHETIC_RETURN_MARK = "__synthetic_return_value", - // CONTEXT_TYPE_DEFAULT_IMPORT = "@koalaui/runtime", - ANNOTATION = "_memo", - ANNOTATION_INTRINSIC = "_memo:intrinsic", - ANNOTATION_ENTRY = "_memo:entry", - ANNOTATION_SKIP = "_skip:memo", // skip binding to parameter changes - ANNOTATION_STABLE = "_memo:stable", // assume this should not be tracked -} - -export function findFunctionDeclaration(node: ts.Node): ts.FunctionDeclaration | undefined { - while (node.kind !== ts.SyntaxKind.SourceFile) { - if (ts.isFunctionDeclaration(node)) { - return node - } - node = node.parent - } - return undefined -} diff --git a/arkoala-arkts/libarkts/plugins/src/utils.ts b/arkoala-arkts/libarkts/plugins/src/utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..e3746e9253bb323b196ee4da822b8a723e8bedd3 --- /dev/null +++ b/arkoala-arkts/libarkts/plugins/src/utils.ts @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2022-2025 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 { UniqueId } from "@koalaui/common" +import * as arkts from "@koalaui/libarkts" + +export enum RuntimeNames { + __CONTEXT = "__context", + __ID = "__id", + ANNOTATION = "memo", + CONTEXT = "__memo_context", + CONTEXT_TYPE = "__memo_context_type", + CONTEXT_TYPE_DEFAULT_IMPORT = "@koalaui/runtime", + ID = "__memo_id", + ID_TYPE = "__memo_id_type", + INTERNAL_SCOPE = "scope", + INTERNAL_VALUE = "cached", + INTERNAL_VALUE_NEW = "recache", + INTERNAL_VALUE_OK = "unchanged", + SCOPE = "__memo_scope", +} + +export function createContextTypeImportSpecifier(): arkts.ImportSpecifier { + return arkts.factory.createImportSpecifier( + arkts.factory.createIdentifier(RuntimeNames.CONTEXT_TYPE), + arkts.factory.createIdentifier(RuntimeNames.CONTEXT_TYPE), + ) +} + +export function createIdTypeImportSpecifier(): arkts.ImportSpecifier { + return arkts.factory.createImportSpecifier( + arkts.factory.createIdentifier(RuntimeNames.ID_TYPE), + arkts.factory.createIdentifier(RuntimeNames.ID_TYPE), + ) +} + +export function createContextParameter(): arkts.ETSParameterExpression { + return arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier(RuntimeNames.CONTEXT, + arkts.factory.createIdentifier(RuntimeNames.CONTEXT_TYPE) + ), + undefined + ) +} + +export function createIdParameter(): arkts.ETSParameterExpression { + return arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier(RuntimeNames.ID, + arkts.factory.createIdentifier(RuntimeNames.ID_TYPE) + ), + undefined + ) +} + +export function createContextArgument(): arkts.AstNode { + return arkts.factory.createIdentifier(RuntimeNames.CONTEXT) +} + +export function createIdArgument(hash: arkts.NumberLiteral | arkts.StringLiteral): arkts.AstNode { + return arkts.factory.createBinaryExpression( + arkts.factory.createIdentifier(RuntimeNames.ID), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_PLUS, + hash + ) +} + +function baseName(path: string): string { + return path.replace(/^.*\/(.*)$/, "$1") +} + +export class PositionalIdTracker { + // Global for the whole program. + static callCount: number = 0 + + // Set `stable` to true if you want to have more predictable values. + // For example for tests. + // Don't use it in production! + constructor(public filename: string, public stableForTests: boolean = false) { + if (stableForTests) PositionalIdTracker.callCount = 0 + } + + sha1Id(callName: string, fileName: string): string { + const uniqId = new UniqueId() + uniqId.addString("memo call uniqid") + uniqId.addString(fileName) + uniqId.addString(callName) + uniqId.addI32(PositionalIdTracker.callCount++) + return uniqId.compute().substring(0, 7) + } + + stringId(callName: string, fileName: string): string { + return `${PositionalIdTracker.callCount++}_${callName}_id_DIRNAME/${fileName}` + } + + id(callName: string): arkts.NumberLiteral | arkts.StringLiteral { + + const fileName = this.stableForTests ? + baseName(this.filename) : + this.filename + + const positionId = (this.stableForTests) ? + this.stringId(callName, fileName) : + this.sha1Id(callName, fileName) + + + return this.stableForTests + ? arkts.factory.createStringLiteral(positionId) + : arkts.factory.createNumericLiteral(parseInt(positionId, 16)) + } +} diff --git a/arkoala-arkts/libarkts/plugins/tsconfig.json b/arkoala-arkts/libarkts/plugins/tsconfig.json index a460c9048c088fdb8c876ec39edb9be7214c9c71..8f86fc2ea37fed27d3bc6294a7917489ee5d5fdb 100644 --- a/arkoala-arkts/libarkts/plugins/tsconfig.json +++ b/arkoala-arkts/libarkts/plugins/tsconfig.json @@ -16,5 +16,11 @@ "./src/component-transformer.ts", "./src/struct-transformer.ts", "./src/arkts-utils.ts", + "./src/index.ts", + "./src/utils.ts", + "./src/function-transformer.ts", + "./src/import-transformer.ts", + "./src/memo-transformer.ts", + "./src/only-test-transformer.ts", ] } diff --git a/arkoala-arkts/libarkts/src/Es2pandaNativeModule.ts b/arkoala-arkts/libarkts/src/Es2pandaNativeModule.ts index f3fe48606fcdec90e0d1406ceee7f92707b8e280..ab11cd9de419983c3c177cc5c9cbda1dde17fa22 100644 --- a/arkoala-arkts/libarkts/src/Es2pandaNativeModule.ts +++ b/arkoala-arkts/libarkts/src/Es2pandaNativeModule.ts @@ -591,6 +591,10 @@ export class Es2pandaNativeModule { _CreateAnnotationUsageIr(context: KPtr, ast: KPtr): KPtr { throw new Error("Not implemented") } + + _IsETSImportDeclaration(ast: KNativePointer): KBoolean { + throw new Error("Not implemented") + } } export function initEs2panda(): Es2pandaNativeModule { diff --git a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts index eb99b8552f94b38f3023d8e0a8ad20f103678ec6..1dea0832fdd7da00eaface98ccc576f33d59ccac 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeFactory.ts @@ -288,16 +288,16 @@ export const factory = { get updateInterfaceBody() { return compose(TSInterfaceBody.createTSInterfaceBody) }, + get createAnnotationUsage() { + return AnnotationUsage.createAnnotationUsage + }, + get updateAnnotationUsage() { + return AnnotationUsage.updateAnnotationUsage + }, get createUndefinedLiteral() { return UndefinedLiteral.create }, get updateUndefinedLiteral() { return compose(UndefinedLiteral.create) }, - get createAnnotationUsage() { - return AnnotationUsage.createAnnotationUsage - }, - get updateAnnotationUsageIr() { - return compose(UndefinedLiteral.create) - }, } diff --git a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts index bcb493faa23372ffdd130d39b904d16576173a56..8676d85faf7ec6f768aa85eae20767fe0938e2e1 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/factory/nodeTests.ts @@ -17,15 +17,29 @@ import { StringLiteral, StructDeclaration, VariableDeclaration, - ClassProperty + ClassProperty, + EtsImportDeclaration, + TSInterfaceDeclaration } from "../types" import { MemberExpression } from "../to-be-generated/MemberExpression" import { AstNode } from "../peers/AstNode" +export function isEtsImportDeclaration(node: AstNode): node is EtsImportDeclaration { + return global.es2panda._IsETSImportDeclaration(node.peer); +} + +export function isClassProperty(node: AstNode): node is ClassProperty { + return global.es2panda._IsClassProperty(node.peer); +} + export function isAnnotationDeclaration(node: AstNode): node is AnnotationDeclaration { return global.es2panda._IsAnnotationDeclaration(node.peer); } +export function isTSInterfaceDeclaration(node: AstNode): node is TSInterfaceDeclaration { + return global.es2panda._IsTSInterfaceDeclaration(node.peer); +} + export function isIdentifier(node: AstNode): node is Identifier { return node instanceof Identifier } @@ -93,7 +107,3 @@ export function isStringLiteral(node: AstNode): node is StringLiteral { export function isClassDefinition(node: AstNode): node is ClassDefinition { return node instanceof ClassDefinition } - -export function isClassProperty(node: AstNode): node is ClassProperty { - return node instanceof ClassProperty -} \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts b/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts index e6ee16f0b1f705725e1efcd60310da806aee762e..32ff603f4fddf5c80778bfc9f298e7714d59f5d9 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/peers/Context.ts @@ -15,9 +15,10 @@ import { ArktsObject } from "./ArktsObject" import { global } from "../static/global" -import { throwError } from "../../utils" +import { throwError, filterSource } from "../../utils" import { passString } from "../utilities/private" import { KNativePointer } from "@koalaui/interop" +import { AstNode } from "./AstNode" export class Context extends ArktsObject { constructor(peer: KNativePointer) { @@ -38,4 +39,14 @@ export class Context extends ArktsObject { ) ) } + + static destroyAndRecreate( + ast: AstNode + ): Context { + const source = filterSource(ast.dumpSrc()) + global.es2panda._DestroyContext(global.context) + global.context = Context.createFromString(source).peer + + return new Context(global.context); + } } \ No newline at end of file diff --git a/arkoala-arkts/libarkts/src/arkts-api/static/global.ts b/arkoala-arkts/libarkts/src/arkts-api/static/global.ts index 97d82523d6fe7a32dc6944f6e953452eedfd803f..bdbd0582e7765628b1df24916c063f0fc9c39909 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/static/global.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/static/global.ts @@ -65,4 +65,8 @@ export class global { if (this._interop === undefined) this._interop = initInterop() return this._interop } + + public static resetConfig() { + global._config = undefined; + } } diff --git a/arkoala-arkts/libarkts/src/arkts-api/types.ts b/arkoala-arkts/libarkts/src/arkts-api/types.ts index ce18131e8f162eed716acf86324d225b60fe8bce..ade019608deaf439ce9eb13fbfd2f882d2f9c783 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/types.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/types.ts @@ -134,6 +134,7 @@ export class CallExpression extends AstNode { super(peer) this.expression = unpackNonNullableNode( global.generatedEs2panda._CallExpressionCallee(global.context, this.peer)) + this.typeParamsDecl = unpackNode(global.generatedEs2panda._CallExpressionTypeParams(global.context, this.peer)) this.arguments = unpackNodeArray( global.generatedEs2panda._CallExpressionArguments(global.context, this.peer)) this.trailingBlock = unpackNode( @@ -142,7 +143,7 @@ export class CallExpression extends AstNode { static create( expression: AstNode, - typeParamsDecl: TSTypeParameterDeclaration | undefined, + typeParamsDecl: TSTypeParameterInstantiation | TSTypeParameterDeclaration | undefined, args: readonly AstNode[] | undefined, trailingBlock: AstNode | undefined = undefined ): CallExpression { @@ -164,6 +165,7 @@ export class CallExpression extends AstNode { return call } + readonly typeParamsDecl: TSTypeParameterInstantiation | TSTypeParameterDeclaration | undefined; readonly expression: AstNode // Expression readonly arguments: readonly AstNode[] readonly trailingBlock: AstNode|undefined // BlockStatement @@ -371,10 +373,25 @@ export class Identifier extends Expression { static create( name: string, typeAnnotation?: AstNode, + isAnnotation?: boolean ): Identifier { - return new Identifier( - global.es2panda._CreateIdentifier2(global.context, passString(name), passNode(typeAnnotation)) - ) + if (isAnnotation) { + return new Identifier( + global.es2panda._ETSParserCreateExpression( + global.context, + passString(name), + Es2pandaExpressionParseFlags.EXPRESSION_PARSE_FLAGS_ACCEPT_COMMA + ) + ) + } else if (typeAnnotation === undefined) { + return new Identifier( + global.es2panda._CreateIdentifier1(global.context, passString(name)) + ) + } else { + return new Identifier( + global.es2panda._CreateIdentifier2(global.context, passString(name), typeAnnotation.peer) + ) + } } setOptional(optional: boolean): Identifier { @@ -586,16 +603,16 @@ export class ScriptFunction extends AstNode { get annotations(): AnnotationUsage[] { return unpackNodeArray(global.es2panda._ScriptFunctionAnnotations( - global.context, - this.peer, + global.context, + this.peer, nullptr - )) + )); } set annotations(newAnnotations: AnnotationUsage[]) { global.es2panda._ScriptFunctionSetAnnotations( - global.context, - this.peer, + global.context, + this.peer, passNodeArray(newAnnotations), newAnnotations.length ); @@ -728,16 +745,16 @@ export class ETSParameterExpression extends AstNode { get annotations(): AnnotationUsage[] { return unpackNodeArray(global.es2panda._ETSParameterExpressionAnnotations( - global.context, - this.peer, + global.context, + this.peer, nullptr - )) + )); } set annotations(newAnnotations: AnnotationUsage[]) { global.es2panda._ETSParameterExpressionSetAnnotations( - global.context, - this.peer, + global.context, + this.peer, passNodeArray(newAnnotations), newAnnotations.length ); @@ -969,7 +986,6 @@ export class MethodDefinition extends AstNode { } this.name = unpackNonNullableNode(global.generatedEs2panda._ScriptFunctionId(global.context, this.scriptFunction.peer)) - this.kind = global.generatedEs2panda._MethodDefinitionKindConst(global.context, this.peer) } static create( @@ -1040,19 +1056,17 @@ export class ClassProperty extends ClassElement { } get annotations(): AnnotationUsage[] { - return unpackNodeArray( - global.es2panda._ScriptFunctionAnnotations( - global.context, - this.peer, - nullptr - ) - ) + return unpackNodeArray(global.es2panda._ClassPropertyAnnotations( + global.context, + this.peer, + nullptr + )); } set annotations(newAnnotations: AnnotationUsage[]) { - global.es2panda._ScriptFunctionSetAnnotations( - global.context, - this.peer, + global.es2panda._ClassPropertySetAnnotations( + global.context, + this.peer, passNodeArray(newAnnotations), newAnnotations.length ); @@ -1240,6 +1254,35 @@ export class TSTypeParameterInstantiation extends AstNode { } } +export class TSInterfaceDeclaration extends AstNode { + constructor(peer: KPtr) { + assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION) + super(peer) + } + + static create( + extendsParams: readonly AstNode[], + id: AstNode, + typeParams: AstNode, + body: AstNode, + isStatic: KBoolean, + isExternal: KBoolean, + ): TSInterfaceDeclaration { + return new TSInterfaceDeclaration( + global.generatedEs2panda._CreateTSInterfaceDeclaration( + global.context, + passNodeArray(extendsParams), + extendsParams.length, + passNode(id), + passNode(typeParams), + passNode(body), + isStatic, + isExternal, + ) + ) + } +} + export class UndefinedLiteral extends AstNode { constructor(peer: KPtr) { assertValidPeer(peer, Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL) diff --git a/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts b/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts index de723054eecd7cb658e4770a6acfbc4efbe6879e..60aff8f60111d4bfc350602c6ffdc259ae1f42fe 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/utilities/public.ts @@ -15,7 +15,7 @@ import { global } from "../static/global" import { throwError } from "../../utils" -import { nullptr, withStringResult } from "@koalaui/interop" +import { KNativePointer, nullptr, withStringResult } from "@koalaui/interop" import { passNode, unpackNodeArray, unpackNonNullableNode } from "./private" import { isClassDefinition, isFunctionDeclaration, isScriptFunction } from "../factory/nodeTests" import { Es2pandaContextState } from "../../generated/Es2pandaEnums" @@ -88,3 +88,12 @@ export function getOriginalNode(node: AstNode): AstNode { export function getFileName(): string { return global.filePath } + +export function destroyConfig(config: KNativePointer): void { + global.es2panda._DestroyConfig(config); + global.resetConfig(); +} + +export function setAllParents(ast: AstNode): void { + global.es2panda._AstNodeUpdateAll(global.context, ast.peer) +} diff --git a/arkoala-arkts/libarkts/src/arkts-api/visitor.ts b/arkoala-arkts/libarkts/src/arkts-api/visitor.ts index 2b000c8e0c5b45370f6e1c5fd2cf8ed6b24a6191..b1acda46e94bb3aac5b0905a1a16003c319a6c39 100644 --- a/arkoala-arkts/libarkts/src/arkts-api/visitor.ts +++ b/arkoala-arkts/libarkts/src/arkts-api/visitor.ts @@ -31,6 +31,7 @@ import { import { Es2pandaClassDefinitionModifiers, Es2pandaModifierFlags } from "../generated/Es2pandaEnums" import { nullptr } from "@koalaui/interop" import { AstNode } from "./peers/AstNode" +import { isClassDefinition, isMethodDefinition, isScriptFunction } from "./factory/nodeTests" import { MemberExpression } from "./to-be-generated/MemberExpression" import { TSInterfaceBody, TSInterfaceDeclaration } from "../generated" @@ -149,7 +150,7 @@ export function visitEachChild( nodeVisitor(node.definition, visitor) ) } - if (node instanceof ClassDefinition) { + if (isClassDefinition(node)) { // TODO: fix return factory.updateClassDefinition( node, @@ -164,9 +165,9 @@ export function visitEachChild( nodeVisitor(node.superClass, visitor), ) } - if (node instanceof MethodDefinition) { + if (isMethodDefinition(node)) { // TODO: fix - return factory.updateMethodDefinition( + const _node = factory.updateMethodDefinition( node, node.kind, node.name, @@ -187,19 +188,18 @@ export function visitEachChild( node.modifiers, false ) + + // TODO: something need to fix with annotation assignments + try { + _node.scriptFunction.annotations = node.scriptFunction.annotations; + } catch (e) { + + } + + return _node; } - if (node instanceof ScriptFunction) { - return factory.updateScriptFunction( - node, - nodeVisitor(node.body, visitor), - node.scriptFunctionFlags, - Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, - false, - nodeVisitor(node.ident, visitor), - nodesVisitor(node.parameters, visitor), - nodeVisitor(node.typeParamsDecl, visitor), - nodeVisitor(node.returnTypeAnnotation, visitor) - ) + if (isScriptFunction(node)) { + return node; } if (node instanceof EtsImportDeclaration) { return factory.updateImportDeclaration( diff --git a/arkoala-arkts/libarkts/src/es2panda.ts b/arkoala-arkts/libarkts/src/es2panda.ts index 46ba9309be52164319da72f3f2df3933d8e0b2da..19dfe55c513bb2a92f3735aad2b2ba55a0700a0d 100644 --- a/arkoala-arkts/libarkts/src/es2panda.ts +++ b/arkoala-arkts/libarkts/src/es2panda.ts @@ -194,3 +194,6 @@ export function main() { } main() + +// import * as arkts from "./arkts-api" +// export { arkts, global as arktsGlobal }; \ No newline at end of file diff --git a/arkoala-arkts/trivial/user/arktsconfig-pure-sts.json b/arkoala-arkts/trivial/user/arktsconfig-pure-sts.json index 551fb7ed8776980bbc9bca07f17a1f373fae2bea..32be4a65b56362b5b86b63886d5357efadfd6de7 100644 --- a/arkoala-arkts/trivial/user/arktsconfig-pure-sts.json +++ b/arkoala-arkts/trivial/user/arktsconfig-pure-sts.json @@ -4,7 +4,17 @@ "outDir": "build/sts/abc", "baseUrl": ".", "paths": { - "@ohos.arkui": ["../../arkui/src/sts"] + "@ohos.arkui": ["../../arkui/src/sts/arkui.sts"], + "@ohos.arkui.after.check": ["../../arkui/src/sts/arkui.after.check.sts"], + "@koalaui/runtime": [ + "../../memo-plugin/runtime-api" + ], + "@koalaui/compat": [ + "../../../incremental/compat/src/arkts" + ], + "@koalaui/common": [ + "../../../incremental/common/src" + ] }, "plugins": [ { @@ -14,7 +24,7 @@ { "transform": "@koalaui/libarkts/plugins/parsed-stage-plugin", "stage": "parsed", - "arkui": "../../../../arkui/src/sts" + "arkui": "@ohos.arkui" }, { "transform": "@koalaui/libarkts/plugins/checked-stage-plugin",