diff --git a/ui2abc/libarkts/native/src/bridges.cc b/ui2abc/libarkts/native/src/bridges.cc index a4c887e115b344f4d3cce49fb4a40901aa7841d0..50134211aa3ec3107e984d7a86a632732eaa524d 100644 --- a/ui2abc/libarkts/native/src/bridges.cc +++ b/ui2abc/libarkts/native/src/bridges.cc @@ -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 @@ -57,7 +57,6 @@ KNativePointer impl_AnnotationAllowedAnnotationsConst(KNativePointer contextPtr, } KOALA_INTEROP_3(AnnotationAllowedAnnotationsConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer) -/* KNativePointer impl_AstNodeVariableConst(KNativePointer contextPtr, KNativePointer nodePtr) { auto context = reinterpret_cast(contextPtr); @@ -66,7 +65,6 @@ KNativePointer impl_AstNodeVariableConst(KNativePointer contextPtr, KNativePoint return GetImpl()->AstNodeVariableConst(context, node); } KOALA_INTEROP_2(AstNodeVariableConst, KNativePointer, KNativePointer, KNativePointer) -*/ KNativePointer impl_VariableDeclaration(KNativePointer contextPtr, KNativePointer variablePtr) { @@ -86,7 +84,6 @@ KNativePointer impl_DeclNode(KNativePointer contextPtr, KNativePointer declPtr) } KOALA_INTEROP_2(DeclNode, KNativePointer, KNativePointer, KNativePointer) -/* KNativePointer impl_AstNodeScopeConst(KNativePointer contextPtr, KNativePointer nodePtr) { auto context = reinterpret_cast(contextPtr); @@ -94,7 +91,7 @@ KNativePointer impl_AstNodeScopeConst(KNativePointer contextPtr, KNativePointer 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); @@ -105,16 +102,6 @@ KNativePointer impl_ScopeSetParent(KNativePointer contextPtr, KNativePointer nod } KOALA_INTEROP_3(ScopeSetParent, KNativePointer, KNativePointer, KNativePointer, KNativePointer) -/* -KNativePointer impl_CreateNumberLiteral(KNativePointer contextPtr, KDouble value) -{ - auto context = reinterpret_cast(contextPtr); - - return GetImpl()->CreateNumberLiteral(context, value); -} -KOALA_INTEROP_2(CreateNumberLiteral, KNativePointer, KNativePointer, KDouble) -*/ - KNativePointer impl_ETSParserCreateExpression(KNativePointer contextPtr, KStringPtr& sourceCodePtr, KInt flagsT) { auto context = reinterpret_cast(contextPtr); @@ -190,7 +177,6 @@ KNativePointer impl_ContextErrorMessage(KNativePointer contextPtr) } KOALA_INTEROP_1(ContextErrorMessage, KNativePointer, KNativePointer) -/* KNativePointer impl_CallExpressionSignature(KNativePointer context, KNativePointer classInstance) { const auto _context = reinterpret_cast(context); @@ -199,7 +185,7 @@ KNativePointer impl_CallExpressionSignature(KNativePointer context, KNativePoint return result; } KOALA_INTEROP_2(CallExpressionSignature, KNativePointer, KNativePointer, KNativePointer) -*/ + KNativePointer impl_SignatureFunction(KNativePointer context, KNativePointer classInstance) { const auto _context = reinterpret_cast(context); @@ -285,19 +271,31 @@ KBoolean impl_IsETSFunctionType(KNativePointer nodePtr) } KOALA_INTEROP_1(IsETSFunctionType, KBoolean, KNativePointer) -KNativePointer impl_ETSParserBuildImportDeclaration(KNativePointer context, KInt importKinds, KNativePointerArray specifiers, KUInt specifiersSequenceLength, KNativePointer source, KNativePointer program, KInt importFlag) +KNativePointer impl_ETSParserBuildImportDeclaration(KNativePointer context, KNativePointer source, + KNativePointerArray specifiers, KUInt specifiersSequenceLength, + KInt importKind, KNativePointer programPtr, KInt flags) { const auto _context = reinterpret_cast(context); - const auto _kinds = static_cast(importKinds); - const auto _specifiers = reinterpret_cast(specifiers); - const auto _specifiersSequenceLength = static_cast(specifiersSequenceLength); const auto _source = reinterpret_cast(source); - const auto _program = reinterpret_cast(program); - const auto _importFlag = static_cast(importFlag); + const auto _specifiers = reinterpret_cast(specifiers); + const auto _specifiersSequenceLength = static_cast(specifiersSequenceLength); + const auto _importKind = static_cast(importKind); + const auto _program = reinterpret_cast(programPtr); + const auto _flags = static_cast(flags); + auto result = GetImpl()->ETSParserBuildImportDeclaration(_context, _importKind, _specifiers, + _specifiersSequenceLength, _source, _program, _flags); + return result; +} +KOALA_INTEROP_7(ETSParserBuildImportDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, + KUInt, KInt, KNativePointer, KInt) - return GetImpl()->ETSParserBuildImportDeclaration(_context, _kinds, _specifiers, _specifiersSequenceLength, _source, _program, _importFlag); +KInt impl_GenerateTsDeclarationsFromContext(KNativePointer contextPtr, KStringPtr &outputDeclEts, KStringPtr &outputEts, + KBoolean exportAll) +{ + auto context = reinterpret_cast(contextPtr); + return GetImpl()->GenerateTsDeclarationsFromContext(context, outputDeclEts.data(), outputEts.data(), exportAll); } -KOALA_INTEROP_7(ETSParserBuildImportDeclaration, KNativePointer, KNativePointer, KInt, KNativePointerArray, KUInt, KNativePointer, KNativePointer, KInt) +KOALA_INTEROP_4(GenerateTsDeclarationsFromContext, KInt, KNativePointer, KStringPtr, KStringPtr, KBoolean) void impl_InsertETSImportDeclarationAndParse(KNativePointer context, KNativePointer program, KNativePointer importDeclaration) { @@ -355,14 +353,15 @@ KNativePointer impl_ConfigGetOptions(KNativePointer config) } KOALA_INTEROP_1(ConfigGetOptions, KNativePointer, KNativePointer) -KNativePointer impl_OptionsArkTsConfig(KNativePointer context, KNativePointer options) -{ - const auto _context = reinterpret_cast(context); - const auto _options = reinterpret_cast(options); - auto result = GetImpl()->OptionsUtilArkTSConfigConst(_context, _options); - return (void*)result; -} -KOALA_INTEROP_2(OptionsArkTsConfig, KNativePointer, KNativePointer, KNativePointer) +// no OptionsUtilArkTSConfigConst +// KNativePointer impl_OptionsArkTsConfig(KNativePointer context, KNativePointer options) +// { +// const auto _context = reinterpret_cast(context); +// const auto _options = reinterpret_cast(options); +// auto result = GetImpl()->OptionsUtilArkTSConfigConst(_context, _options); +// return (void*)result; +// } +// KOALA_INTEROP_2(OptionsArkTsConfig, KNativePointer, KNativePointer, KNativePointer) KNativePointer impl_CreateCacheContextFromFile(KNativePointer configPtr, KStringPtr& source_file_namePtr, KNativePointer globalContextPtr, KBoolean isExternal) { auto config = reinterpret_cast(configPtr); @@ -388,15 +387,15 @@ KNativePointer impl_CreateGlobalContext(KNativePointer configPtr, KStringArray e } KOALA_INTEROP_4(CreateGlobalContext, KNativePointer, KNativePointer, KStringArray, KUInt, KBoolean) +// From koala-wrapper +// TODO check if some code should be generated + void impl_DestroyGlobalContext(KNativePointer contextPtr) { auto context = reinterpret_cast(contextPtr); GetImpl()->DestroyGlobalContext(context); } KOALA_INTEROP_V1(DestroyGlobalContext, KNativePointer) -// From koala-wrapper -// TODO check if some code should be generated - std::set globalStructInfo; std::mutex g_structMutex; @@ -440,8 +439,28 @@ KBoolean impl_IsMethodDefinition(KNativePointer nodePtr) return GetImpl()->IsMethodDefinition(node); } KOALA_INTEROP_1(IsMethodDefinition, KBoolean, KNativePointer) +KNativePointer impl_TSInterfaceBodyBodyPtr(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSInterfaceBodyBodyPtr(_context, _receiver, &length); + return new std::vector(result, result + length); +} +KOALA_INTEROP_2(TSInterfaceBodyBodyPtr, KNativePointer, KNativePointer, KNativePointer); -KNativePointer impl_SourceRangeStart(KNativePointer context, KNativePointer range) { +KNativePointer impl_AnnotationDeclarationPropertiesPtrConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->AnnotationDeclarationPropertiesPtrConst(_context, _receiver, &length); + return (void*)new std::vector(result, result + length); +} +KOALA_INTEROP_2(AnnotationDeclarationPropertiesPtrConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_SourceRangeStart(KNativePointer context, KNativePointer range) +{ const auto _context = reinterpret_cast(context); const auto _range = reinterpret_cast(range); auto result = GetImpl()->SourceRangeStart(_context, _range); @@ -449,7 +468,8 @@ KNativePointer impl_SourceRangeStart(KNativePointer context, KNativePointer rang } KOALA_INTEROP_2(SourceRangeStart, KNativePointer, KNativePointer, KNativePointer) -KNativePointer impl_SourceRangeEnd(KNativePointer context, KNativePointer range) { +KNativePointer impl_SourceRangeEnd(KNativePointer context, KNativePointer range) +{ const auto _context = reinterpret_cast(context); const auto _range = reinterpret_cast(range); auto result = GetImpl()->SourceRangeEnd(_context, _range); @@ -479,7 +499,7 @@ KNativePointer impl_CreateDiagnosticKind(KNativePointer context, KStringPtr& mes const auto _type = static_cast(type); return const_cast(GetImpl()->CreateDiagnosticKind(_context, _message, _type)); } -KOALA_INTEROP_3(CreateDiagnosticKind, KNativePointer, KNativePointer, KStringPtr, KInt) +KOALA_INTEROP_3(CreateDiagnosticKind, KNativePointer, KNativePointer, KStringPtr, KInt); KNativePointer impl_CreateDiagnosticInfo(KNativePointer context, KNativePointer kind, KStringArray argsPtr, KInt argc) { @@ -497,7 +517,7 @@ KNativePointer impl_CreateDiagnosticInfo(KNativePointer context, KNativePointer } return GetImpl()->CreateDiagnosticInfo(_context, _kind, _args, argc); } -KOALA_INTEROP_4(CreateDiagnosticInfo, KNativePointer, KNativePointer, KNativePointer, KStringArray, KInt) +KOALA_INTEROP_4(CreateDiagnosticInfo, KNativePointer, KNativePointer, KNativePointer, KStringArray, KInt); KNativePointer impl_CreateSuggestionInfo(KNativePointer context, KNativePointer kind, KStringArray argsPtr, KInt argc, KStringPtr& substitutionCode) @@ -517,7 +537,8 @@ KNativePointer impl_CreateSuggestionInfo(KNativePointer context, KNativePointer const auto _substitutionCode = getStringCopy(substitutionCode); return GetImpl()->CreateSuggestionInfo(_context, _kind, _args, argc, _substitutionCode); } -KOALA_INTEROP_5(CreateSuggestionInfo, KNativePointer, KNativePointer, KNativePointer, KStringArray, KInt, KStringPtr) +KOALA_INTEROP_5(CreateSuggestionInfo, KNativePointer, KNativePointer, KNativePointer, + KStringArray, KInt, KStringPtr); void impl_LogDiagnostic(KNativePointer context, KNativePointer kind, KStringArray argvPtr, KInt argc, KNativePointer pos) @@ -537,7 +558,7 @@ void impl_LogDiagnostic(KNativePointer context, KNativePointer kind, KStringArra } GetImpl()->LogDiagnostic(_context_, _kind_, argv, argc, _pos_); } -KOALA_INTEROP_V5(LogDiagnostic, KNativePointer, KNativePointer, KStringArray, KInt, KNativePointer) +KOALA_INTEROP_V5(LogDiagnostic, KNativePointer, KNativePointer, KStringArray, KInt, KNativePointer); void impl_LogDiagnosticWithSuggestion(KNativePointer context, KNativePointer diagnosticInfo, KNativePointer suggestionInfo, KNativePointer range) @@ -548,7 +569,7 @@ void impl_LogDiagnosticWithSuggestion(KNativePointer context, KNativePointer dia const auto _range = reinterpret_cast(range); GetImpl()->LogDiagnosticWithSuggestion(_context, _diagnosticInfo, _suggestionInfo, _range); } -KOALA_INTEROP_V4(LogDiagnosticWithSuggestion, KNativePointer, KNativePointer, KNativePointer, KNativePointer) +KOALA_INTEROP_V4(LogDiagnosticWithSuggestion, KNativePointer, KNativePointer, KNativePointer, KNativePointer); KInt impl_GenerateStaticDeclarationsFromContext(KNativePointer contextPtr, KStringPtr &outputPath) { diff --git a/ui2abc/libarkts/native/src/common.cc b/ui2abc/libarkts/native/src/common.cc index 78e565aec2523da5c3ca84d8369bb48a7562cb2f..d336199375d1ee84a2e6135171df20716b29a9fc 100644 --- a/ui2abc/libarkts/native/src/common.cc +++ b/ui2abc/libarkts/native/src/common.cc @@ -103,6 +103,19 @@ const char *LIB_DIR = "lib"; static std::string ES2PANDA_LIB_PATH = ""; +std::string joinPath(vector &paths) +{ + std::string res; + for (int i = 0; i < paths.size(); ++i) { + if (i == 0) { + res = paths[i]; + } else { + res += SEPARATOR + paths[i]; + } + } + return res; +} + void impl_SetUpSoPath(KStringPtr &soPath) { ES2PANDA_LIB_PATH = std::string(soPath.c_str()); @@ -231,8 +244,20 @@ TODO: NOT FROM API (shouldn't be there) ----------------------------------------------------------------------------------------------------------------------------- */ -es2panda_AstNode * cachedParentNode; -es2panda_Context * cachedContext; +KNativePointer impl_AstNodeProgram(KNativePointer contextPtr, KNativePointer instancePtr) +{ + auto _context = reinterpret_cast(contextPtr); + auto _receiver = reinterpret_cast(instancePtr); + + if (GetImpl()->AstNodeIsProgramConst(_context, _receiver)) { + return GetImpl()->ETSModuleProgram(_context, _receiver); + } + return impl_AstNodeProgram(_context, GetImpl()->AstNodeParent(_context, _receiver)); +} +KOALA_INTEROP_2(AstNodeProgram, KNativePointer, KNativePointer, KNativePointer) + +thread_local es2panda_AstNode *cachedParentNode; +thread_local es2panda_Context *cachedContext; static void changeParent(es2panda_AstNode *child) { @@ -267,7 +292,7 @@ KNativePointer impl_AstNodeUpdateChildren(KNativePointer contextPtr, KNativePoin } KOALA_INTEROP_2(AstNodeUpdateChildren, KNativePointer, KNativePointer, KNativePointer) -std::vector cachedChildren; +thread_local std::vector cachedChildren; static void visitChild(es2panda_AstNode *node) { @@ -306,3 +331,44 @@ void impl_MemFinalize() GetImpl()->MemFinalize(); } KOALA_INTEROP_V0(MemFinalize) + +static bool isUIHeaderFile(es2panda_Context* context, es2panda_Program* program) +{ + auto result = GetImpl()->ProgramFileNameWithExtensionConst(context, program); + string fileNameWithExtension(result); + result = GetImpl()->ProgramModuleNameConst(context, program); + string moduleName(result); + + return fileNameWithExtension.length() >= MODULE_SUFFIX.length() + && fileNameWithExtension.substr(fileNameWithExtension.length() - MODULE_SUFFIX.length()) == MODULE_SUFFIX + && moduleName.find(ARKUI) != std::string::npos; +} + +KBoolean impl_ProgramCanSkipPhases(KNativePointer context, KNativePointer program) +{ + KStringPtr isUiFlag(IS_UI_FLAG); + KStringPtr notUiFlag(NOT_UI_FLAG); + const auto _context = reinterpret_cast(context); + const auto _program = reinterpret_cast(program); + if (isUIHeaderFile(_context, _program)) { + return false; + } + std::size_t sourceLen; + const auto externalSources = reinterpret_cast + (GetImpl()->ProgramExternalSources(_context, _program, &sourceLen)); + for (std::size_t i = 0; i < sourceLen; ++i) { + std::size_t programLen; + auto programs = GetImpl()->ExternalSourcePrograms(externalSources[i], &programLen); + for (std::size_t j = 0; j < programLen; ++j) { + if (isUIHeaderFile(_context, programs[j])) { + return false; + } + } + } + return true; +} +KOALA_INTEROP_2(ProgramCanSkipPhases, KBoolean, KNativePointer, KNativePointer) + +/* +----------------------------------------------------------------------------------------------------------------------------- +*/ diff --git a/ui2abc/libarkts/native/src/common.h b/ui2abc/libarkts/native/src/common.h index 7b57d89a16f1dd760456a233f6ef923e29e37b00..2c19a75b2524beb423e988c49a1de56fd5128c5c 100644 --- a/ui2abc/libarkts/native/src/common.h +++ b/ui2abc/libarkts/native/src/common.h @@ -16,21 +16,6 @@ #ifndef COMMON_H #define COMMON_H -/* - * 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 "dynamic-loader.h" #include "es2panda_lib.h" #include "common-interop.h" diff --git a/ui2abc/libarkts/native/src/generated/bridges.cc b/ui2abc/libarkts/native/src/generated/bridges.cc index d8d866576f0aab32c1d2e68332a43f90d3753534..0c2fcf6554adca513d31417e1ccc3e6c7b64a5ad 100644 --- a/ui2abc/libarkts/native/src/generated/bridges.cc +++ b/ui2abc/libarkts/native/src/generated/bridges.cc @@ -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 @@ -4881,15 +4881,16 @@ KNativePointer impl_ClassDefinitionFunctionalReferenceReferencedMethodConst(KNat } KOALA_INTEROP_2(ClassDefinitionFunctionalReferenceReferencedMethodConst, KNativePointer, KNativePointer, KNativePointer); -void impl_ClassDefinitionSetFunctionalReferenceReferencedMethod(KNativePointer context, KNativePointer receiver, KNativePointer functionalReferenceReferencedMethod) -{ - const auto _context = reinterpret_cast(context); - const auto _receiver = reinterpret_cast(receiver); - const auto _functionalReferenceReferencedMethod = reinterpret_cast(functionalReferenceReferencedMethod); - GetImpl()->ClassDefinitionSetFunctionalReferenceReferencedMethod(_context, _receiver, _functionalReferenceReferencedMethod); - return ; -} -KOALA_INTEROP_V3(ClassDefinitionSetFunctionalReferenceReferencedMethod, KNativePointer, KNativePointer, KNativePointer); +// compile failed +// void impl_ClassDefinitionSetFunctionalReferenceReferencedMethod(KNativePointer context, KNativePointer receiver, KNativePointer functionalReferenceReferencedMethod) +// { +// const auto _context = reinterpret_cast(context); +// const auto _receiver = reinterpret_cast(receiver); +// const auto _functionalReferenceReferencedMethod = reinterpret_cast(functionalReferenceReferencedMethod); +// GetImpl()->ClassDefinitionSetFunctionalReferenceReferencedMethod(_context, _receiver, _functionalReferenceReferencedMethod); +// return ; +// } +// KOALA_INTEROP_V3(ClassDefinitionSetFunctionalReferenceReferencedMethod, KNativePointer, KNativePointer, KNativePointer); KNativePointer impl_ClassDefinitionLocalPrefixConst(KNativePointer context, KNativePointer receiver) { @@ -14723,94 +14724,98 @@ void impl_ProgramAddFileDependencies(KNativePointer context, KNativePointer rece } KOALA_INTEROP_V4(ProgramAddFileDependencies, KNativePointer, KNativePointer, KStringPtr, KStringPtr); -KNativePointer impl_CreateArkTsConfig(KNativePointer context, KStringPtr& configPath, KNativePointer de) -{ - const auto _context = reinterpret_cast(context); - const auto _configPath = getStringCopy(configPath); - const auto _de = reinterpret_cast(de); - auto result = GetImpl()->CreateArkTsConfig(_context, _configPath, _de); - return result; -} -KOALA_INTEROP_3(CreateArkTsConfig, KNativePointer, KNativePointer, KStringPtr, KNativePointer); - -void impl_ArkTsConfigResolveAllDependenciesInArkTsConfig(KNativePointer context, KNativePointer receiver) -{ - const auto _context = reinterpret_cast(context); - const auto _receiver = reinterpret_cast(receiver); - GetImpl()->ArkTsConfigResolveAllDependenciesInArkTsConfig(_context, _receiver); - return ; -} -KOALA_INTEROP_V2(ArkTsConfigResolveAllDependenciesInArkTsConfig, KNativePointer, KNativePointer); - -KNativePointer impl_ArkTsConfigConfigPathConst(KNativePointer context, KNativePointer receiver) -{ - const auto _context = reinterpret_cast(context); - const auto _receiver = reinterpret_cast(receiver); - auto result = GetImpl()->ArkTsConfigConfigPathConst(_context, _receiver); - return StageArena::strdup(result); -} -KOALA_INTEROP_2(ArkTsConfigConfigPathConst, KNativePointer, KNativePointer, KNativePointer); - -KNativePointer impl_ArkTsConfigPackageConst(KNativePointer context, KNativePointer receiver) -{ - const auto _context = reinterpret_cast(context); - const auto _receiver = reinterpret_cast(receiver); - auto result = GetImpl()->ArkTsConfigPackageConst(_context, _receiver); - return StageArena::strdup(result); -} -KOALA_INTEROP_2(ArkTsConfigPackageConst, KNativePointer, KNativePointer, KNativePointer); - -KNativePointer impl_ArkTsConfigBaseUrlConst(KNativePointer context, KNativePointer receiver) -{ - const auto _context = reinterpret_cast(context); - const auto _receiver = reinterpret_cast(receiver); - auto result = GetImpl()->ArkTsConfigBaseUrlConst(_context, _receiver); - return StageArena::strdup(result); -} -KOALA_INTEROP_2(ArkTsConfigBaseUrlConst, KNativePointer, KNativePointer, KNativePointer); - -KNativePointer impl_ArkTsConfigRootDirConst(KNativePointer context, KNativePointer receiver) -{ - const auto _context = reinterpret_cast(context); - const auto _receiver = reinterpret_cast(receiver); - auto result = GetImpl()->ArkTsConfigRootDirConst(_context, _receiver); - return StageArena::strdup(result); -} -KOALA_INTEROP_2(ArkTsConfigRootDirConst, KNativePointer, KNativePointer, KNativePointer); - -KNativePointer impl_ArkTsConfigOutDirConst(KNativePointer context, KNativePointer receiver) -{ - const auto _context = reinterpret_cast(context); - const auto _receiver = reinterpret_cast(receiver); - auto result = GetImpl()->ArkTsConfigOutDirConst(_context, _receiver); - return StageArena::strdup(result); -} -KOALA_INTEROP_2(ArkTsConfigOutDirConst, KNativePointer, KNativePointer, KNativePointer); - -void impl_ArkTsConfigResetDependencies(KNativePointer context, KNativePointer receiver) -{ - const auto _context = reinterpret_cast(context); - const auto _receiver = reinterpret_cast(receiver); - GetImpl()->ArkTsConfigResetDependencies(_context, _receiver); - return ; -} -KOALA_INTEROP_V2(ArkTsConfigResetDependencies, KNativePointer, KNativePointer); - -KNativePointer impl_ArkTsConfigEntryConst(KNativePointer context, KNativePointer receiver) -{ - const auto _context = reinterpret_cast(context); - const auto _receiver = reinterpret_cast(receiver); - auto result = GetImpl()->ArkTsConfigEntryConst(_context, _receiver); - return StageArena::strdup(result); -} -KOALA_INTEROP_2(ArkTsConfigEntryConst, KNativePointer, KNativePointer, KNativePointer); - -KBoolean impl_ArkTsConfigUseUrlConst(KNativePointer context, KNativePointer receiver) -{ - const auto _context = reinterpret_cast(context); - const auto _receiver = reinterpret_cast(receiver); - auto result = GetImpl()->ArkTsConfigUseUrlConst(_context, _receiver); - return result; -} -KOALA_INTEROP_2(ArkTsConfigUseUrlConst, KBoolean, KNativePointer, KNativePointer); +// should remove all of below +// no CreateArkTsConfig +// KNativePointer impl_CreateArkTsConfig(KNativePointer context, KStringPtr& configPath, KNativePointer de) +// { +// const auto _context = reinterpret_cast(context); +// const auto _configPath = getStringCopy(configPath); +// const auto _de = reinterpret_cast(de); +// auto result = GetImpl()->CreateArkTsConfig(_context, _configPath, _de); +// return result; +// } +// KOALA_INTEROP_3(CreateArkTsConfig, KNativePointer, KNativePointer, KStringPtr, KNativePointer); + +// no ArkTsConfigResolveAllDependenciesInArkTsConfig +// void impl_ArkTsConfigResolveAllDependenciesInArkTsConfig(KNativePointer context, KNativePointer receiver) +// { +// const auto _context = reinterpret_cast(context); +// const auto _receiver = reinterpret_cast(receiver); +// GetImpl()->ArkTsConfigResolveAllDependenciesInArkTsConfig(_context, _receiver); +// return ; +// } +// KOALA_INTEROP_V2(ArkTsConfigResolveAllDependenciesInArkTsConfig, KNativePointer, KNativePointer); + +// no ArkTsConfigConfigPathConst +// KNativePointer impl_ArkTsConfigConfigPathConst(KNativePointer context, KNativePointer receiver) +// { +// const auto _context = reinterpret_cast(context); +// const auto _receiver = reinterpret_cast(receiver); +// auto result = GetImpl()->ArkTsConfigConfigPathConst(_context, _receiver); +// return StageArena::strdup(result); +// } +// KOALA_INTEROP_2(ArkTsConfigConfigPathConst, KNativePointer, KNativePointer, KNativePointer); + +// KNativePointer impl_ArkTsConfigPackageConst(KNativePointer context, KNativePointer receiver) +// { +// const auto _context = reinterpret_cast(context); +// const auto _receiver = reinterpret_cast(receiver); +// auto result = GetImpl()->ArkTsConfigPackageConst(_context, _receiver); +// return StageArena::strdup(result); +// } +// KOALA_INTEROP_2(ArkTsConfigPackageConst, KNativePointer, KNativePointer, KNativePointer); + +// KNativePointer impl_ArkTsConfigBaseUrlConst(KNativePointer context, KNativePointer receiver) +// { +// const auto _context = reinterpret_cast(context); +// const auto _receiver = reinterpret_cast(receiver); +// auto result = GetImpl()->ArkTsConfigBaseUrlConst(_context, _receiver); +// return StageArena::strdup(result); +// } +// KOALA_INTEROP_2(ArkTsConfigBaseUrlConst, KNativePointer, KNativePointer, KNativePointer); + +// KNativePointer impl_ArkTsConfigRootDirConst(KNativePointer context, KNativePointer receiver) +// { +// const auto _context = reinterpret_cast(context); +// const auto _receiver = reinterpret_cast(receiver); +// auto result = GetImpl()->ArkTsConfigRootDirConst(_context, _receiver); +// return StageArena::strdup(result); +// } +// KOALA_INTEROP_2(ArkTsConfigRootDirConst, KNativePointer, KNativePointer, KNativePointer); + +// KNativePointer impl_ArkTsConfigOutDirConst(KNativePointer context, KNativePointer receiver) +// { +// const auto _context = reinterpret_cast(context); +// const auto _receiver = reinterpret_cast(receiver); +// auto result = GetImpl()->ArkTsConfigOutDirConst(_context, _receiver); +// return StageArena::strdup(result); +// } +// KOALA_INTEROP_2(ArkTsConfigOutDirConst, KNativePointer, KNativePointer, KNativePointer); + +// void impl_ArkTsConfigResetDependencies(KNativePointer context, KNativePointer receiver) +// { +// const auto _context = reinterpret_cast(context); +// const auto _receiver = reinterpret_cast(receiver); +// GetImpl()->ArkTsConfigResetDependencies(_context, _receiver); +// return ; +// } +// KOALA_INTEROP_V2(ArkTsConfigResetDependencies, KNativePointer, KNativePointer); + +// KNativePointer impl_ArkTsConfigEntryConst(KNativePointer context, KNativePointer receiver) +// { +// const auto _context = reinterpret_cast(context); +// const auto _receiver = reinterpret_cast(receiver); +// auto result = GetImpl()->ArkTsConfigEntryConst(_context, _receiver); +// return StageArena::strdup(result); +// } +// KOALA_INTEROP_2(ArkTsConfigEntryConst, KNativePointer, KNativePointer, KNativePointer); + +// KBoolean impl_ArkTsConfigUseUrlConst(KNativePointer context, KNativePointer receiver) +// { +// const auto _context = reinterpret_cast(context); +// const auto _receiver = reinterpret_cast(receiver); +// auto result = GetImpl()->ArkTsConfigUseUrlConst(_context, _receiver); +// return result; +// } +// KOALA_INTEROP_2(ArkTsConfigUseUrlConst, KBoolean, KNativePointer, KNativePointer); diff --git a/ui2abc/libarkts/src/Es2pandaNativeModule.ts b/ui2abc/libarkts/src/Es2pandaNativeModule.ts index db7cffb801c0618aac4b453f5d4f0cfd8ebd9290..d57a7c3c944edd10ab68ad605dcd4888a526e8e0 100644 --- a/ui2abc/libarkts/src/Es2pandaNativeModule.ts +++ b/ui2abc/libarkts/src/Es2pandaNativeModule.ts @@ -30,41 +30,41 @@ import * as fs from "fs" import { Es2pandaPluginDiagnosticType } from "./generated/Es2pandaEnums" // TODO: this type should be in interop -export type KPtrArray = BigUint64Array +export type KPtrArray = BigUint64Array; export class Es2pandaNativeModule { _AnnotationAllowedAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _AstNodeRebind(context: KPtr, node: KPtr): void { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _AstNodeRecheck(context: KPtr, node: KPtr): void { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _ContextState(context: KPtr): KInt { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _ContextErrorMessage(context: KPtr): KPtr { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _AstNodeChildren(context: KPtr, node: KPtr): KPtr { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _AstNodeDumpModifiers(context: KPtr, node: KPtr): KPtr { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _CreateConfig(argc: number, argv: string[]): KPtr { - throw new Error("Not implemented") + throw new Error('Not implemented'); } - _DestroyConfig(peer: KNativePointer): void { - throw new Error("Not implemented") + _DestroyConfig(config: KNativePointer): void { + throw new Error('Not implemented'); } _CreateContextFromString(config: KPtr, source: String, filename: String): KPtr { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _CreateContextFromFile(config: KPtr, filename: String): KPtr { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _CreateCacheContextFromFile(config: KNativePointer, sourceFileName: String, globalContext: KNativePointer, isExternal: KBoolean): KNativePointer { throw new Error("Not implemented"); @@ -82,25 +82,25 @@ export class Es2pandaNativeModule { throw new Error("Not implemented"); } _DestroyContext(context: KPtr): void { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _ProceedToState(context: KPtr, state: number): void { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _ContextProgram(context: KPtr): KPtr { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _ProgramAst(context: KPtr, program: KPtr): KPtr { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _CheckerStartChecker(context: KPtr): KBoolean { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _AstNodeVariableConst(context: KPtr, ast: KPtr): KPtr { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _CreateNumberLiteral(context: KPtr, value: KDouble): KPtr { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _AstNodeUpdateChildren(context: KPtr, node: KPtr): void { throw new Error("Not implemented") @@ -109,31 +109,39 @@ export class Es2pandaNativeModule { throw new Error("Not implemented") } _VariableDeclaration(context: KPtr, variable: KPtr): KPtr { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _DeclNode(context: KPtr, decl: KPtr): KPtr { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _DeclarationFromIdentifier(context: KPtr, identifier: KPtr): KPtr { throw new Error("Not implemented") } _ProgramSourceFilePath(context: KNativePointer, instance: KNativePointer): KNativePointer { - throw new Error("Not implemented"); + throw new Error('Not implemented'); } _ProgramExternalSources(context: KNativePointer, instance: KNativePointer): KNativePointer { - throw new Error("Not implemented"); + throw new Error('Not implemented'); } _ProgramDirectExternalSources(context: KNativePointer, instance: KNativePointer): KNativePointer { - throw new Error("Not implemented") + throw new Error('Not implemented'); } _ExternalSourceName(instance: KNativePointer): KNativePointer { - throw new Error("Not implemented"); + throw new Error('Not implemented'); } _ExternalSourcePrograms(instance: KNativePointer): KNativePointer { - throw new Error("Not implemented"); - } - _ETSParserBuildImportDeclaration(context: KNativePointer, importKinds: KInt, specifiers: KNativePointerArray, specifiersSequenceLength: KUInt, source: KNativePointer, program: KNativePointer, flags: KInt): KNativePointer { - throw new Error("Not implemented"); + throw new Error('Not implemented'); + } + _ETSParserBuildImportDeclaration( + context: KNativePointer, + importPath: KNativePointer, + specifiers: BigUint64Array, + specifiersSequenceLength: KInt, + importKind: KInt, + programPtr: KNativePointer, + flags: KInt + ): KNativePointer { + throw new Error('Not implemented'); } _InsertETSImportDeclarationAndParse(context: KNativePointer, program: KNativePointer, importDeclaration: KNativePointer): void { throw new Error("Not implemented"); @@ -142,65 +150,789 @@ export class Es2pandaNativeModule { throw new Error("Not implemented"); } _ETSParserGetImportPathManager(context: KNativePointer): KPtr { - throw new Error("Not implemented"); + throw new Error('Not implemented'); } + _CreateSourcePosition(context: KNativePointer, index: KInt, line: KInt): KNativePointer { - throw new Error("Not implemented"); + throw new Error('Not implemented'); } _SourcePositionIndex(context: KNativePointer, instance: KNativePointer): KInt { - throw new Error("Not implemented"); + throw new Error('Not implemented'); } _SourcePositionLine(context: KNativePointer, instance: KNativePointer): KInt { - throw new Error("Not implemented"); + throw new Error('Not implemented'); } _ConfigGetOptions(config: KNativePointer): KNativePointer { throw new Error("Not implemented"); } - _OptionsArkTsConfig(context: KNativePointer, options: KNativePointer): KNativePointer { - throw new Error("Not implemented"); - } // From koala-wrapper + _VarBinderIdentifierAnalysis(context: KPtr): void { + throw new Error('Not implemented'); + } + _VarBinderInitTopScope(context: KPtr): void { + throw new Error('Not implemented'); + } + _VarBinderSetGenStdLib(context: KPtr, genStdLibT: KBoolean): void { + throw new Error('Not implemented'); + } + _SourceFileGetChildren(node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _BlockGetStatements(node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _FunctionDeclarationIsAnonymousConst(context: KPtr, node: KPtr): KBoolean { + throw new Error('Not implemented'); + } + _ExpressionStatementGetExpression(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _CallExpressionArguments(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { + throw new Error('Not implemented'); + } + _CallExpressionCallee(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _IdentifierGetText(node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _IdentifierIsPrivateIdentConst(context: KPtr, node: KPtr): KBoolean { + throw new Error('Not implemented'); + } + _PropertyAccessExpressionGetExpression(node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _PropertyAccessExpressionGetName(node: KPtr): KPtr { + throw new Error('Not implemented'); + } + + _FunctionDeclarationFunction(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ScriptFunctionSignature(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ScriptFunctionParams(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ScriptFunctionId(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ScriptFunctionBody(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ScriptFunctionAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ScriptFunctionSetIdent(context: KPtr, ast: KPtr, id: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ScriptFunctionSetSignature(context: KPtr, ast: KPtr, signature: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ScriptFunctionSetBody(context: KPtr, ast: KPtr, body: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ScriptFunctionSetScope(context: KPtr, ast: KPtr, scope: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ScriptFunctionSetAnnotations(context: KPtr, ast: KPtr, annotations: KPtrArray, annotationsLen: KInt): KPtr { + throw new Error('Not implemented'); + } + _ScriptFunctionDeclareConst(context: KPtr, node: KPtr): KBoolean { + throw new Error('Not implemented'); + } + _ScriptFunctionFlagsConst(context: KPtr, node: KPtr): KInt { + throw new Error('Not implemented'); + } + _ScriptFunctionTypeParams(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ScriptFunctionReturnTypeAnnotation(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ScriptFunctionAddFlag(context: KPtr, node: KPtr, flags: KInt): void { + throw new Error('Not implemented'); + } + _ClassPropertyAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ClassPropertySetAnnotations(context: KPtr, ast: KPtr, annotations: KPtrArray, annotationsLen: KInt): KPtr { + throw new Error('Not implemented'); + } + _UpdateBlockStatement(context: KPtr, original: KPtr, statementList: KPtrArray, statementListLen: KInt): KPtr { + throw new Error('Not implemented'); + } + _BlockStatementSetScope(context: KPtr, node: KPtr, scope: KPtrArray): void { + throw new Error('Not implemented'); + } + _CreateIdentifier1(context: KPtr, name: String): KPtr { + throw new Error('Not implemented'); + } + _CreateIdentifier2(context: KPtr, name: String, type_annotation: KPtr): KPtr { + throw new Error('Not implemented'); + } + _IdentifierSetName(context: KPtr, node: KPtr, name: String): void { + throw new Error('Not implemented'); + } + _IdentifierIdentifierFlags(context: KPtr, node: KPtr): KInt { + throw new Error('Not implemented'); + } + _CreateFunctionDeclaration( + context: KPtr, + func: KPtr, + annotations: KPtrArray, + annotationsLen: KInt, + isAnon: KBoolean + ): KPtr { + throw new Error('Not implemented'); + } + _UpdateFunctionDeclaration( + context: KPtr, + node: KPtr, + annotations: KPtrArray, + annotationsLen: KInt, + func: KPtr, + isAnon: KBoolean + ): KPtr { + throw new Error('Not implemented'); + } + _CreateReturnStatement1(context: KPtr, argument: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ReturnStatementArgument(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _CreateIfStatement(context: KPtr, test: KPtr, consequent: KPtr, alternate: KPtr): KPtr { + throw new Error('Not implemented'); + } + _CreateBinaryExpression(context: KPtr, left: KPtr, right: KPtr, operatorType: KInt): KPtr { + throw new Error('Not implemented'); + } + _CreateAssignmentExpression(context: KPtr, left: KPtr, right: KPtr, assignmentOperator: KInt): KPtr { + throw new Error('Not implemented'); + } + _CreateMethodDefinition( + context: KPtr, + kind: KInt, + key: KPtr, + value: KPtr, + modifiers: KInt, + isComputed: KBoolean + ): KPtr { + throw new Error('Not implemented'); + } + _CreateClassProperty( + context: KPtr, + key: KPtr, + value: KPtr, + typeAnnotation: KPtr, + modifiers: KInt, + isComputed: KBoolean + ): KPtr { + throw new Error('Not implemented'); + } + + _ETSImportDeclarationSourceConst(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ETSImportDeclarationResolvedSource(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ETSImportDeclarationHasDeclConst(context: KPtr, node: KPtr): KBoolean { + throw new Error('Not implemented'); + } + _CreateImportSource(context: KPtr, source: KPtr, resolvedSource: KPtr, hasDecl: KBoolean): KNativePointer { + throw new Error('Not implemented'); + } + _CreateImportSpecifier(context: KPtr, imported: KPtr, local: KPtr): KNativePointer { + throw new Error('Not implemented'); + } + + _CreateFunctionSignature( + context: KPtr, + typeParams: KPtr, + params: KPtrArray, + paramsLen: KInt, + returnTypeAnnotation: KPtr, + hasReceiver: KBoolean + ): KPtr { + throw new Error('Not implemented'); + } + _CreateScriptFunction( + context: KPtr, + databody: KPtr, + datasignature: KPtr, + datafuncFlags: KInt, + dataflags: KInt + ): KPtr { + throw new Error('Not implemented'); + } + _UpdateScriptFunction( + context: KPtr, + original: KPtr, + databody: KPtr, + datasignature: KPtr, + datafuncFlags: KInt, + dataflags: KInt, + datadeclare: KBoolean + ): KPtr { + throw new Error('Not implemented'); + } + _CreateBlockStatement(context: KPtr, statementList: KPtrArray, statementListLen: KInt): KPtr { + throw new Error('Not implemented'); + } + _AstNodeScopeConst(context: KPtr, ast: KPtr): KPtr { + throw new Error('Not implemented'); + } + _AstNodeParent(context: KPtr, ast: KPtr): KPtr { + throw new Error('Not implemented'); + } + _AstNodeSetParent(context: KPtr, ast: KPtr, parent: KPtr): KPtr { + throw new Error('Not implemented'); + } + _AstNodeClone(context: KPtr, ast: KPtr, parent: KPtr): KPtr { + throw new Error('Not implemented'); + } + _AstNodeModifiers(context: KPtr, ast: KPtr): KInt { + throw new Error('Not implemented'); + } + _AstNodeAddModifier(context: KPtr, ast: KPtr, flags: KInt): void { + throw new Error('Not implemented'); + } + _AstNodeClearModifier(context: KPtr, ast: KPtr, flags: KInt): void { + throw new Error('Not implemented'); + } + _AstNodeTypeConst(context: KPtr, ast: KPtr): KInt { + throw new Error('Not implemented'); + } + _FunctionSignatureTypeParams(context: KPtr, ast: KPtr): KPtr { + throw new Error('Not implemented'); + } + _FunctionSignatureReturnType(context: KPtr, ast: KPtr): KPtr { + throw new Error('Not implemented'); + } + _FunctionSignatureParamsConst(context: KPtr, ast: KPtr, returnTypeLen: KPtr): KPtr { + throw new Error('Not implemented'); + } + _UpdateIdentifier1(context: KPtr, ast: KPtr, name: string): KPtr { + throw new Error('Not implemented'); + } + _UpdateIdentifier2(context: KPtr, ast: KPtr, name: string, typeAnnotation: KPtr): KPtr { + throw new Error('Not implemented'); + } + _UpdateMethodDefinition( + context: KPtr, + node: KPtr, + kind: KInt, + key: KPtr, + value: KPtr, + modifiers: KInt, + isComputed: KBoolean + ): KPtr { + throw new Error('Not implemented'); + } + _MethodDefinitionFunction(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _MethodDefinitionKindConst(context: KPtr, node: KPtr): KInt { + throw new Error('Not implemented'); + } + + _CreateMemberExpression( + context: KPtr, + object: KPtr, + property: KPtr, + kind: KInt, + computed: KBoolean, + optional: KBoolean + ): KPtr { + throw new Error('Not implemented'); + } + _UpdateMemberExpression( + context: KPtr, + node: KPtr, + object: KPtr, + property: KPtr, + kind: KInt, + computed: KBoolean, + optional: KBoolean + ): KPtr { + throw new Error('Not implemented'); + } + _MemberExpressionObject(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _MemberExpressionProperty(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _MemberExpressionKindConst(context: KPtr, node: KPtr): KInt { + throw new Error('Not implemented'); + } + _CreateCallExpression( + context: KPtr, + callee: KPtr, + args: KPtrArray, + argsLen: KInt, + typeParams: KPtr, + optional: KBoolean, + trailingComma: KBoolean + ): KPtr { + throw new Error('Not implemented'); + } + _UpdateCallExpression( + context: KPtr, + node: KPtr, + callee: KPtr, + args: KPtrArray, + argsLen: KInt, + typeParams: KPtr, + optional: KBoolean, + trailingComma: KBoolean + ): KPtr { + throw new Error('Not implemented'); + } + _CreateArrowFunctionExpression(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _FunctionExpressionFunction(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ArrowFunctionExpressionFunction(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ArrowFunctionExpressionCreateTypeAnnotation(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _CreateFunctionExpression(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _UpdateFunctionExpression(context: KPtr, original: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + + _CreateExpressionStatement(context: KPtr, expr: KPtr): KPtr { + throw new Error('Not implemented'); + } + _UpdateExpressionStatement(context: KPtr, node: KPtr, expr: KPtr): KPtr { + throw new Error('Not implemented'); + } + _CreateETSParameterExpression(context: KPtr, identifier: KPtr, initializer: KPtr): KPtr { + throw new Error('Not implemented'); + } + _CreateETSPrimitiveType(context: KPtr, type: KInt): KPtr { + throw new Error('Not implemented'); + } + _ETSPrimitiveTypeGetPrimitiveTypeConst(context: KPtr, node: KNativePointer): KInt { + throw new Error('Not implemented'); + } + _CreateETSTypeReference(context: KPtr, part: KPtr): KPtr { + throw new Error('Not implemented'); + } + _CreateETSTypeReferencePart(context: KPtr, name: KPtr, typeParams: KPtr, prev: KPtr): KPtr { + throw new Error('Not implemented'); + } + _CreateETSTypeReferencePart1(context: KPtr, name: KPtr): KPtr { + throw new Error('Not implemented'); + } + _IsIdentifier(node: KPtr): KBoolean { + throw new Error('Not implemented'); + } + _IdentifierName(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ETSParameterExpressionIdent(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ETSParameterExpressionAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ETSParameterExpressionSetAnnotations( + context: KPtr, + ast: KPtr, + annotations: KPtrArray, + annotationsLen: KInt + ): KPtr { + throw new Error('Not implemented'); + } + _CreateTSTypeParameterDeclaration(context: KPtr, params: KPtrArray, paramsLen: KInt, requiredParams: KInt): KPtr { + throw new Error('Not implemented'); + } + _TSTypeParameterDeclarationParamsConst(context: KPtr, node: KPtr, returnTypeLen: KPtr): KPtr { + throw new Error('Not implemented'); + } + _CreateTSTypeParameter(context: KPtr, name: KPtr, constraint: KPtr, defaultType: KPtr): KPtr { + throw new Error('Not implemented'); + } + _TSTypeParameterName(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + + _CreateTSUnionType(context: KPtr, types: KPtrArray, typesLen: KInt): KPtr { + throw new Error('Not implemented'); + } + _TSUnionTypeTypesConst(context: KPtr, node: KPtr, returnTypeLen: KPtr): KPtr { + throw new Error('Not implemented'); + } + _CreateETSUnionType(context: KPtr, types: KPtrArray, typesLen: KInt): KPtr { + throw new Error('Not implemented'); + } + _ETSUnionTypeTypesConst(context: KPtr, node: KPtr, returnTypeLen: KPtr): KPtr { + throw new Error('Not implemented'); + } + + _CreateVariableDeclaration(context: KPtr, kind: KInt, declarators: KPtrArray, declaratorsLen: KInt): KPtr { + throw new Error('Not implemented'); + } + _UpdateVariableDeclaration( + context: KPtr, + original: KPtr, + kind: KInt, + declarators: KPtrArray, + declaratorsLen: KInt, + declare: KBoolean + ): KPtr { + throw new Error('Not implemented'); + } + _CreateVariableDeclarator(context: KPtr, flag: KInt, ident: KPtr): KPtr { + throw new Error('Not implemented'); + } + _VariableDeclarationDeclaratorsConst(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _VariableDeclarationKindConst(context: KPtr, node: KPtr): KInt { + throw new Error('Not implemented'); + } + _VariableDeclaratorId(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _VariableDeclaratorSetInit(context: KPtr, node: KPtr, init: KPtr): void { + throw new Error('Not implemented'); + } + + _CreateStringLiteral(context: KPtr, string: string): KPtr { + throw new Error('Not implemented'); + } + _NumberLiteralStrConst(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _StringLiteralStrConst(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + + _BlockStatementStatements(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _BlockStatementSetStatements(context: KPtr, node: KPtr, statements: KPtrArray, statementsLen: KInt): void { + throw new Error('Not implemented'); + } + _ClassDeclarationDefinition(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ClassDefinitionBody(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ClassDefinitionIdent(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ClassDefinitionTypeParamsConst(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _CreateETSStructDeclaration(context: KPtr, def: KPtr): KPtr { + throw new Error('Not implemented'); + } + _CreateClassDeclaration(context: KPtr, def: KPtr): KPtr { + throw new Error('Not implemented'); + } + _UpdateClassDeclaration(context: KPtr, original: KPtr, def: KPtr): KPtr { + throw new Error('Not implemented'); + } + _CreateClassDefinition1( + context: KPtr, + ident: KPtr, + body: KPtrArray, + bodyLen: KInt, + modifiers: KInt, + flags: KInt + ): KPtr { + throw new Error('Not implemented'); + } + _ClassDefinitionSetTypeParams(context: KPtr, ast: KPtr, typeParams: KPtr): void { + throw new Error('Not implemented'); + } + _ClassDefinitionSetSuper(context: KPtr, ast: KPtr, superClass: KPtr): void { + throw new Error('Not implemented'); + } + _UpdateClassDefinition1( + context: KPtr, + original: KPtr, + ident: KPtr, + body: KPtrArray, + bodyLen: KInt, + modifiers: KInt, + flags: KInt + ): KPtr { + throw new Error('Not implemented'); + } + _CreateETSFunctionType(context: KPtr, signature: KPtr, funcFlags: KInt): KPtr { + throw new Error('Not implemented'); + } + _CreateSuperExpression(context: KPtr): KPtr { + throw new Error('Not implemented'); + } + _UpdateSuperExpression(context: KPtr, original: KPtr): KPtr { + throw new Error('Not implemented'); + } + + _IsProgram(context: KPtr, node: KPtr): KBoolean { + throw new Error('Not implemented'); + } + _AstNodeDumpJSONConst(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _AstNodeDumpEtsSrcConst(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _AstNodeSetOriginalNode(context: KPtr, ast: KPtr, originalNode: KPtr): void { + throw new Error('Not implemented'); + } + _AstNodeOriginalNodeConst(context: KPtr, ast: KPtr): KPtr { + throw new Error('Not implemented'); + } + + _VarBinderSetProgram(context: KPtr): void { + throw new Error('Not implemented'); + } + _VarBinderSetContext(context: KPtr): void { + throw new Error('Not implemented'); + } + + + _ScopeSetParent(context: KPtr, ast: KPtr, scope: KPtr): void { + throw new Error('Not implemented'); + } + + _CallExpressionSignature(context: KPtr, classInstance: KPtr): KPtr { + throw new Error('Not implemented'); + } + _SignatureFunction(context: KPtr, classInstance: KPtr): KPtr { + throw new Error('Not implemented'); + } + _IsTSInterfaceDeclaration(ast: KNativePointer): KBoolean { + throw new Error('Not implemented'); + } + + _IsAnnotationDeclaration(ast: KNativePointer): KBoolean { + throw new Error('Not implemented'); + } + + _IsAnnotationUsage(ast: KNativePointer): KBoolean { + throw new Error('Not implemented'); + } + + _IsClassProperty(ast: KNativePointer): KBoolean { + throw new Error('Not implemented'); + } + + _CreateAnnotationUsage(context: KPtr, ast: KPtr): KPtr { + throw new Error('Not implemented'); + } + + _IsETSUnionType(ast: KPtr): KBoolean { + throw new Error('Not implemented'); + } + + _IsETSFunctionType(ast: KPtr): KBoolean { + throw new Error('Not implemented'); + } + _AstNodeProgram(context: KNativePointer, instance: KNativePointer): KNativePointer { + throw new Error('Not implemented'); + } + + + _ProgramCanSkipPhases(context: KNativePointer, program: KNativePointer): boolean { + throw new Error('Not implemented'); + } + + _GenerateTsDeclarationsFromContext( + config: KPtr, + outputDeclEts: String, + outputEts: String, + exportAll: KBoolean + ): KPtr { + throw new Error('Not implemented'); + } + + _GenerateStaticDeclarationsFromContext( + config: KPtr, + outputPath: String + ): KPtr { + throw new Error('Not implemented'); + } + + _CreateETSStringLiteralType(context: KNativePointer, str: String): KNativePointer { + throw new Error('Not implemented'); + } + + _ClassDefinitionIsFromStructConst(context: KNativePointer, instance: KNativePointer): KBoolean { + throw new Error('Not implemented'); + } + + _ClassDefinitionSetFromStructModifier(context: KNativePointer, instance: KNativePointer): void { + throw new Error('Not implemented'); + } + + _ProgramFileNameConst(context: KPtr, program: KPtr): KNativePointer { + throw new Error('Not implemented'); + } + + _ProgramFileNameWithExtensionConst(context: KPtr, program: KPtr): KNativePointer { + throw new Error('Not implemented'); + } + + _ProgramIsASTLoweredConst(context: KPtr, program: KPtr): KBoolean { + throw new Error('Not implemented'); + } + + _ETSParserGetGlobalProgramAbsName(context: KNativePointer): KNativePointer { + throw new Error('Not implemented'); + } + + _ImportSpecifierIsRemovableConst(context: KNativePointer, instance: KNativePointer): KBoolean { + throw new Error('Not implemented'); + } + + _ImportSpecifierSetRemovable(context: KNativePointer, instance: KNativePointer): void { + throw new Error('Not implemented'); + } + + _ClassPropertyIsDefaultAccessModifierConst(context: KNativePointer, receiver: KNativePointer): boolean { + throw new Error('Not implemented'); + } + + _AstNodeStartConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error('Not implemented'); + } + + _AstNodeSetStart(context: KNativePointer, receiver: KNativePointer, start: KNativePointer): void { + throw new Error('Not implemented'); + } + + _AstNodeEndConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error('Not implemented'); + } + + _AstNodeSetEnd(context: KNativePointer, receiver: KNativePointer, end: KNativePointer): void { + throw new Error('Not implemented'); + } + _ClassVariableDeclaration(context: KNativePointer, classInstance: KNativePointer): KNativePointer { - throw new Error("Not implemented") + throw new Error('Not implemented'); } + _IsMethodDefinition(node: KPtr): KBoolean { - throw new Error("Not implemented") + throw new Error('Not implemented'); } + + _ProgramModuleNameConst(context: KPtr, program: KPtr): KNativePointer { + throw new Error('Not implemented'); + } + + _AstNodeRangeConst(context: KNativePointer, node: KNativePointer): KNativePointer { + throw new Error('CreateFunctionDecl was not overloaded by native module initialization'); + } + _SourceRangeStart(context: KNativePointer, range: KNativePointer): KNativePointer { - throw new Error("Not implemented") + throw new Error('CreateFunctionDecl was not overloaded by native module initialization'); } + _SourceRangeEnd(context: KNativePointer, range: KNativePointer): KNativePointer { - throw new Error("Not implemented") + throw new Error('CreateFunctionDecl was not overloaded by native module initialization'); } + _CreateSourceRange(context: KNativePointer, start: KNativePointer, end: KNativePointer): KNativePointer { - throw new Error("Not implemented") + throw new Error('CreateFunctionDecl was not overloaded by native module initialization'); } + _IsArrayExpression(node: KPtr): KBoolean { - throw new Error("Not implemented") + throw new Error('IsArrayExpression was not overloaded by native module initialization'); } - _ETSParserGetGlobalProgramAbsName(context: KNativePointer): KNativePointer { - throw new Error("Not implemented") + + _MemInitialize(): void { + throw new Error('MemInitialize was not overloaded by native module initialization'); } - _CreateDiagnosticKind(context: KNativePointer, message: string, type: Es2pandaPluginDiagnosticType): KNativePointer { - throw new Error("Not implemented") + + _MemFinalize(): void { + throw new Error('MemFinalize was not overloaded by native module initialization'); } + + _CreateDiagnosticKind(context: KNativePointer, message: string, type: PluginDiagnosticType): KNativePointer { + throw new Error('Not implemented'); + } + _CreateDiagnosticInfo(context: KNativePointer, kind: KNativePointer, args: string[], argc: number): KNativePointer { - throw new Error("Not implemented") + throw new Error('Not implemented'); } + _CreateSuggestionInfo(context: KNativePointer, kind: KNativePointer, args: string[], argc: number, substitutionCode: string): KNativePointer { - throw new Error("Not implemented") + throw new Error('Not implemented'); } + _LogDiagnostic(context: KNativePointer, kind: KNativePointer, argv: string[], argc: number, pos: KNativePointer): void { - throw new Error("Not implemented") + throw new Error('Not implemented'); } + _LogDiagnosticWithSuggestion(context: KNativePointer, diagnosticInfo: KNativePointer, suggestionInfo?: KNativePointer, range?: KNativePointer): void { - throw new Error("Not implemented") + throw new Error('Not implemented'); } + _SetUpSoPath(soPath: string): void { - throw new Error("Not implemented") + throw new Error('Not implemented'); + } + _ClassDefinitionSuper(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _CreateTSInterfaceDeclaration( + _context: KPtr, + _extends: KPtrArray, + _extendsLen: KInt, + _id: KPtr, + _typeParams: KPtr, + _body: KPtr, + _isStatic: KBoolean, + _isExternal: KBoolean + ): KPtr { + throw new Error('Not implemented'); + } + _CreateTSTypeParameterInstantiation(context: KPtr, params: KPtrArray, paramsLen: KInt): KPtr { + throw new Error('Not implemented'); + } + _ClassElementKey(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ClassElementValue(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _AnnotationUsageExpr(context: KPtr, node: KPtr): KPtr { + throw new Error('Not implemented'); + } + _AnnotationUsagePropertiesConst(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { + throw new Error('Not implemented'); + } + _AnnotationAllowedAnnotationsConst(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { + throw new Error('Not implemented'); + } + _ETSParserCreateExpression(context: KPtr, sourceCode: String, flags: KInt): KPtr { + throw new Error('Not implemented'); + } + _CreateAstDumper(context: KPtr, node: KPtr, source: String): KPtr { + throw new Error('Not implemented'); + } + _AstDumperModifierToString(context: KPtr, dumper: KPtr, flags: KInt): KPtr { + throw new Error('Not implemented'); } } diff --git a/ui2abc/libarkts/src/arkts-api/static/global.ts b/ui2abc/libarkts/src/arkts-api/static/global.ts index a8bc02825b6a88d7fe691c51be75d81671beee4f..a810d8b9980a093886bc4c31ff5f0eb544c909af 100644 --- a/ui2abc/libarkts/src/arkts-api/static/global.ts +++ b/ui2abc/libarkts/src/arkts-api/static/global.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 @@ -48,6 +48,12 @@ export class global { // TODO: rename to context when the pointer valued one is eliminated public static compilerContext: Context + // unsafe - could be undefined + public static compilerContext: Context | undefined + + public static clearContext(): void { + this.compilerContext = undefined; + } private static _es2panda: Es2pandaNativeModule | undefined = undefined public static get es2panda(): Es2pandaNativeModule { diff --git a/ui2abc/libarkts/src/arkts-api/static/globalUtils.ts b/ui2abc/libarkts/src/arkts-api/static/globalUtils.ts new file mode 100644 index 0000000000000000000000000000000000000000..8e3a91074a38775262fbb0523b9afad98482083d --- /dev/null +++ b/ui2abc/libarkts/src/arkts-api/static/globalUtils.ts @@ -0,0 +1,27 @@ +/* + * Copyright (c) 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 { KNativePointer } from "@koalaui/interop"; +import { Context } from "../peers/Context"; +import { global } from "./global"; +import { clearNodeCache } from "../class-by-peer"; + +export function getOrUpdateGlobalContext(peer: KNativePointer): Context { + if (!global.compilerContext || global.context !== peer) { + clearNodeCache(); + global.compilerContext = new Context(peer); + } + return global.compilerContext; +} \ No newline at end of file diff --git a/ui2abc/libarkts/src/utils.ts b/ui2abc/libarkts/src/utils.ts index d97470bcea6b46c041dae560d4898f6f01139468..5e08a9ba050fbf10431fd789282154ce15c4eab2 100644 --- a/ui2abc/libarkts/src/utils.ts +++ b/ui2abc/libarkts/src/utils.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 @@ -364,3 +364,8 @@ export function filterSource(text: string): string { // console.error(dumperUnwrappers.reduceRight((code, f) => f(code), text).split('\n').map((it, index) => `${`${index + 1}`.padStart(4)} |${it}`).join('\n')) return dumperUnwrappers.reduceRight((code, f) => f(code), text) } + +// From koala wrapper +export function getEnumName(enumType: any, value: number): string | undefined { + return enumType[value]; +}