diff --git a/ets1.2/.gitignore b/ets1.2/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..de29e615ac1b19120100561353585fe0ce9c0183 --- /dev/null +++ b/ets1.2/.gitignore @@ -0,0 +1,40 @@ +**/node_modules +build +build-m3* +arkoala-arkts/arkui/build-recheck +dist +arkoala/tools/peer-generator/arkoala +**/package-lock.json +.vscode +**.code-workspace +.idea +**/target +**/cjpm.lock +**/CallsiteKey.o +interface_sdk-js +.ninja_log +**/.hvigor +**/js_output +**/command-line-tools +**/libs +**/lib +!incremental/tools/ets-tsc/lib +**/*.abc +cachegrind.out.* +perf.data* +/ui2abc/memo-plugin/tests/out +*.tsbuildinfo +ui2abc/libarkts/lib +ui2abc/memo-plugin/lib +ui2abc/ui-plugins/lib +incremetal-cj/runtime/ck +.rollup.cache +tsconfig.tsbuildinfo +*.meta.json +.cache +incremental/benchmarks/memo-benchmark/ets +koala_mirror +koala_tools +out +sdk +koala_build.log diff --git a/ets1.2/arkui-plugins/.gitignore b/ets1.2/arkui-plugins/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..98f9b3e907e12eb5eaac00e962654cb76f9091a0 --- /dev/null +++ b/ets1.2/arkui-plugins/.gitignore @@ -0,0 +1,19 @@ +node_modules/ +**/*/node_modules/ + +**/*/dist/ +**/*/build/ +dist/ +build/ +lib/ + +*.tgz + +package-lock.json +/**/*/package-lock.json + +coverage/ +**/*/generated +**/*/report + +test/demo/localtest/build_config.json diff --git a/ets1.2/arkui-plugins/.prettierrc b/ets1.2/arkui-plugins/.prettierrc new file mode 100644 index 0000000000000000000000000000000000000000..e9e9c6fdb49bbeff983dca7cf4474097cf81de5d --- /dev/null +++ b/ets1.2/arkui-plugins/.prettierrc @@ -0,0 +1,8 @@ +{ + "semi": true, + "singleQuote": true, + "tabWidth": 4, + "trailingComma": "es5", + "bracketSpacing": true, + "printWidth": 120 +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/BUILD.gn b/ets1.2/arkui-plugins/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..ef13162864136c57f0fb51401eef178cc116ed92 --- /dev/null +++ b/ets1.2/arkui-plugins/BUILD.gn @@ -0,0 +1,52 @@ +# Copyright (c) 2021-2022 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("//build/ohos.gni") +import("//build/config/components/ets_frontend/ets2abc_config.gni") + +npm_path = "//prebuilts/build-tools/common/nodejs/current/bin/npm" + +action("gen_ui_plugins") { + script = "build_ui_plugins.py" + args = [ + "--source_path", + rebase_path(get_path_info(".", "abspath")), + "--output_path", + rebase_path("$target_gen_dir"), + "--npm", + rebase_path(npm_path), + "--current_os", + "$current_os", + "--root_out_dir", + rebase_path(root_out_dir), + ] + outputs = [ "$target_gen_dir" ] +} + +ohos_copy("ui_plugin") { + deps = [ ":gen_ui_plugins" ] + sources = [ rebase_path("$target_gen_dir") ] + outputs = [ target_out_dir + "/$target_name" ] + module_source_dir = target_out_dir + "/$target_name" + module_install_name = "" + subsystem_name = "developtools" + part_name = "ace_ets2bundle" +} + +ohos_copy("ohos_ets_ui_plugins") { + deps = [ ":gen_ui_plugins" ] + sources = [ rebase_path("$target_gen_dir") ] + outputs = [ ohos_ets_ui_plugins_path ] + subsystem_name = "developtools" + part_name = "ace_ets2bundle" +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/babel.config.js b/ets1.2/arkui-plugins/babel.config.js new file mode 100644 index 0000000000000000000000000000000000000000..fe3d51b87c5dafb9ae733659c30a7984fd289d48 --- /dev/null +++ b/ets1.2/arkui-plugins/babel.config.js @@ -0,0 +1,42 @@ +/* + * 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. + */ + +module.exports = function(api) { + api.cache(true); + + const presets = ['@babel/typescript']; + const plugins = [ + '@babel/plugin-transform-modules-commonjs', + '@babel/plugin-proposal-class-properties', + [ + '@babel/plugin-transform-arrow-functions', + { + spec: true + } + ], + './custom-import-plugin' + ]; + const ignore = [ + '**/test/**', + '**/node_modules/**', + 'jest-test.config.ts' + ]; + + return { + presets, + plugins, + ignore + }; +}; diff --git a/ets1.2/arkui-plugins/build_ui_plugins.py b/ets1.2/arkui-plugins/build_ui_plugins.py new file mode 100755 index 0000000000000000000000000000000000000000..6ae5d669e05bb65f03fa3825e81dd7da2ac49eff --- /dev/null +++ b/ets1.2/arkui-plugins/build_ui_plugins.py @@ -0,0 +1,83 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# 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 argparse +import os +import shutil +import subprocess +import sys +import tarfile + + +def copy_files(source_path, dest_path, is_file=False): + try: + if is_file: + os.makedirs(os.path.dirname(dest_path), exist_ok=True) + shutil.copy(source_path, dest_path) + else: + shutil.copytree(source_path, dest_path, dirs_exist_ok=True, + symlinks=True) + except Exception as err: + raise Exception("Copy files failed. Error: " + str(err)) from err + + +def run_cmd(cmd, execution_path=None): + proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, + stdin=subprocess.PIPE, + stderr=subprocess.PIPE, + cwd=execution_path) + stdout, stderr = proc.communicate(timeout=1000) + if proc.returncode != 0: + raise Exception(stderr.decode()) + + +def build(options): + build_cmd = [options.npm, 'run', 'compile:plugins'] + run_cmd(build_cmd, options.source_path) + + +def copy_output(options): + run_cmd(['rm', '-rf', options.output_path]) + copy_files(os.path.join(options.source_path, 'lib'), + os.path.join(options.output_path, 'lib')) + + copy_files(os.path.join(options.source_path, '../compiler/components'), + os.path.join(options.output_path, 'lib/components')) + + copy_files(os.path.join(options.source_path, 'package.json'), + os.path.join(options.output_path, 'package.json'), True) + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument('--npm', help='path to a npm exetuable') + parser.add_argument('--source_path', help='path to build system source') + parser.add_argument('--output_path', help='path to output') + parser.add_argument('--root_out_dir', help='path to root out') + parser.add_argument('--current_os', help='current_os') + + options = parser.parse_args() + return options + + +def main(): + options = parse_args() + + build(options) + copy_output(options) + + +if __name__ == '__main__': + sys.exit(main()) \ No newline at end of file diff --git a/ets1.2/arkui-plugins/common/abstract-visitor.ts b/ets1.2/arkui-plugins/common/abstract-visitor.ts new file mode 100644 index 0000000000000000000000000000000000000000..2c7a307da160e41671fa8d0aca5586a38d30ef8e --- /dev/null +++ b/ets1.2/arkui-plugins/common/abstract-visitor.ts @@ -0,0 +1,53 @@ +/* + * 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'; + +export interface VisitorOptions { + isExternal?: boolean; + externalSourceName?: string; + program?: arkts.Program; +} + +export abstract class AbstractVisitor implements VisitorOptions { + public isExternal: boolean; + public externalSourceName?: string; + public program?: arkts.Program; + + constructor(options?: VisitorOptions) { + this.isExternal = options?.isExternal ?? false; + this.externalSourceName = options?.externalSourceName; + this.program = options?.program; + } + + indentation = 0; + + withIndentation(exec: () => T) { + this.indentation++; + const result = exec(); + this.indentation--; + return result; + } + + abstract visitor(node: arkts.AstNode): arkts.AstNode; + + reset(): void { + this.indentation = 0; + } + + visitEachChild(node: arkts.AstNode): arkts.AstNode { + return this.withIndentation(() => arkts.visitEachChild(node, (it) => this.visitor(it))); + } +} diff --git a/ets1.2/arkui-plugins/common/arkts-utils.ts b/ets1.2/arkui-plugins/common/arkts-utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..e62d9c99169db550168ef7368d2233af08ccdc9e --- /dev/null +++ b/ets1.2/arkui-plugins/common/arkts-utils.ts @@ -0,0 +1,109 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +export function annotation(name: string): arkts.AnnotationUsage { + const ident: arkts.Identifier = arkts.factory.createIdentifier(name).setAnnotationUsage(); + const annotation: arkts.AnnotationUsage = arkts.factory.createAnnotationUsage(ident); + + annotation.modifiers = arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_ANNOTATION_USAGE; + ident.parent = annotation; + + return annotation; +} + +export function isAnnotation(node: arkts.AnnotationUsage, annoName: string) { + return node.expr !== undefined && arkts.isIdentifier(node.expr) && node.expr.name === annoName; +} + +export function removeAnnotationByName( + annotations: readonly arkts.AnnotationUsage[], + annoName: string +): arkts.AnnotationUsage[] { + return annotations.filter((it) => !isAnnotation(it, annoName)); +} + +export function expectName(node: arkts.AstNode | undefined): string { + if (!node) { + throw new Error('Expected an identifier, got empty node'); + } + if (!arkts.isIdentifier(node)) { + throw new Error('Expected an identifier, got: ' + arkts.nodeType(node).toString()); + } + return node.name; +} + +export function mangle(value: string): string { + return `__${value}`; +} + +export function backingField(originalName: string): string { + return mangle(`backing_${originalName}`); +} + +export function filterDefined(value: (T | undefined)[]): T[] { + return value.filter((it: T | undefined): it is T => it != undefined); +} + +export function collect(...value: (ReadonlyArray | T | undefined)[]): T[] { + const empty: (T | undefined)[] = []; + return filterDefined(empty.concat(...value)); +} + +export function matchPrefix(prefixCollection: (string | RegExp)[], name: string): boolean { + for (const prefix of prefixCollection) { + let regex: RegExp; + + if (typeof prefix === 'string') { + regex = new RegExp('^' + prefix); + } else { + regex = new RegExp('^' + prefix.source); + } + + if (regex.test(name)) { + return true; + } + } + return false; +} + +export function updateStructMetadata( + structInfo: arkts.StructInfo, + propertyName: string, + properties: string[], + modifiers: arkts.Es2pandaModifierFlags, + hasStateManagementType?: boolean +): arkts.StructInfo { + const metadata: Record = structInfo.metadata ?? {}; + metadata[propertyName] = { + name: propertyName, + properties, + modifiers, + hasStateManagementType, + }; + structInfo.metadata = metadata; + return structInfo; +} + +export function moveToFront(arr: T[], idx: number): T[] { + if (idx < 0 || idx >= arr.length) { + throw new Error(`Index ${idx} is out of bounds for array of length ${arr.length}`); + } + + const copy = [...arr]; + const [item] = copy.splice(idx, 1); + return [item, ...copy]; +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/common/debug.ts b/ets1.2/arkui-plugins/common/debug.ts new file mode 100644 index 0000000000000000000000000000000000000000..f39940e8f7508e4286c59d687e42c1a4873a9b10 --- /dev/null +++ b/ets1.2/arkui-plugins/common/debug.ts @@ -0,0 +1,76 @@ +/* + * 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 * as fs from 'fs'; +import * as path from 'path'; +import * as arkts from '@koalaui/libarkts'; + +const isDebugLog: boolean = false; +const isDebugDump: boolean = false; +const isPerformance: boolean = false; +arkts.Performance.getInstance().skip(!isPerformance); + +export function getEnumName(enumType: any, value: number): string | undefined { + return enumType[value]; +} + +function mkDir(filePath: string): void { + const parent = path.join(filePath, '..'); + if (!(fs.existsSync(parent) && !fs.statSync(parent).isFile())) { + mkDir(parent); + } + fs.mkdirSync(filePath); +} + +export function debugDump( + content: string, + fileName: string, + isInit: boolean, + cachePath: string | undefined, + programFileName: string +): void { + if (!isDebugDump) return; + const currentDirectory = process.cwd(); + const modifiedFileName = programFileName.replaceAll('.', '_'); + const outputDir: string = cachePath + ? path.resolve(currentDirectory, cachePath, modifiedFileName) + : path.resolve(currentDirectory, 'dist', 'cache', modifiedFileName); + const filePath: string = path.resolve(outputDir, fileName); + if (!fs.existsSync(outputDir)) { + mkDir(outputDir); + } + try { + if (!isInit && fs.existsSync(filePath)) { + const existingContent = fs.readFileSync(filePath, 'utf8'); + const newContent = + existingContent && !existingContent.endsWith('\n') + ? existingContent + '\n' + content + : existingContent + content; + fs.writeFileSync(filePath, newContent, 'utf8'); + } else { + fs.writeFileSync(filePath, content, 'utf8'); + } + } catch (error) { + console.error('文件操作失败:', error); + } +} + +export function debugLog(message?: any, ...optionalParams: any[]): void { + if (!isDebugLog) return; + console.log(message, ...optionalParams); +} + +export function getDumpFileName(state: number, prefix: string, index: number | undefined, suffix: string): string { + return `${state}_${prefix}_${index ?? ''}_${suffix}.sts`; +} diff --git a/ets1.2/arkui-plugins/common/etsglobal-remover.ts b/ets1.2/arkui-plugins/common/etsglobal-remover.ts new file mode 100644 index 0000000000000000000000000000000000000000..3d9711799c01b776e626fea84429fae186a05e3b --- /dev/null +++ b/ets1.2/arkui-plugins/common/etsglobal-remover.ts @@ -0,0 +1,31 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { AbstractVisitor } from './abstract-visitor'; + +const ETSGLOBAL = 'ETSGLOBAL'; + +export class EtsglobalRemover extends AbstractVisitor { + visitor(node: arkts.AstNode): arkts.AstNode { + if (arkts.isEtsScript(node)) { + const keep = node.statements.filter((it) => { + return !(arkts.isClassDeclaration(it) && it.definition?.ident?.name == ETSGLOBAL); + }); + return arkts.factory.updateEtsScript(node, keep); + } + return node; + } +} diff --git a/ets1.2/arkui-plugins/common/gensym-generator.ts b/ets1.2/arkui-plugins/common/gensym-generator.ts new file mode 100644 index 0000000000000000000000000000000000000000..6e05f109d44c8bbc69932857b18e4583b9fb0f2b --- /dev/null +++ b/ets1.2/arkui-plugins/common/gensym-generator.ts @@ -0,0 +1,60 @@ +/* + * 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 { getCommonPath } from '../path'; +const common = require(getCommonPath()); +const UniqueId = common.UniqueId; + +export class GenSymGenerator { + // Global for the whole program. + private static callCount: number = 0; + static instance: GenSymGenerator; + + // Set `stable` to true if you want to have more predictable values. + // For example for tests. + // Don't use it in production! + private constructor(public stableForTests: boolean = false) { + if (stableForTests) GenSymGenerator.callCount = 0; + } + + static getInstance(stableForTests: boolean = false): GenSymGenerator { + if (!this.instance) { + this.instance = new GenSymGenerator(stableForTests); + } + + return this.instance; + } + + sha1Id(callName: string): string { + const uniqId = new UniqueId(); + uniqId.addString('gensym uniqid'); + uniqId.addString(callName); + uniqId.addI32(GenSymGenerator.callCount++); + return uniqId.compute().substring(0, 7); + } + + stringId(callName: string): string { + return `${GenSymGenerator.callCount++}_${callName}_id`; + } + + id(callName: string = ''): string { + const positionId = this.stableForTests ? this.stringId(callName) : this.sha1Id(callName); + + const coreceToStr = parseInt(positionId, 16).toString(); + + // compiler use gensym%%_ but % is illegal before after-check phase + return `gensym___${coreceToStr}`; + } +} diff --git a/ets1.2/arkui-plugins/common/plugin-context.ts b/ets1.2/arkui-plugins/common/plugin-context.ts new file mode 100644 index 0000000000000000000000000000000000000000..95cce91523cab960aa06117adfc26166097a9857 --- /dev/null +++ b/ets1.2/arkui-plugins/common/plugin-context.ts @@ -0,0 +1,110 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +// This is the same plugin-context in the build-system. +export class PluginContext { + private ast: arkts.EtsScript | undefined; + private program: arkts.Program | undefined; + private projectConfig: ProjectConfig | undefined; + private contextPtr: number | undefined; + + constructor() { + this.ast = undefined; + this.program = undefined; + this.projectConfig = undefined; + this.contextPtr = undefined; + } + + /** + * @deprecated + */ + public setArkTSAst(ast: arkts.EtsScript): void { + this.ast = ast; + } + + /** + * @deprecated + */ + public getArkTSAst(): arkts.EtsScript | undefined { + return this.ast; + } + + /** + * @deprecated + */ + public setArkTSProgram(program: arkts.Program): void { + this.program = program; + } + + /** + * @deprecated + */ + public getArkTSProgram(): arkts.Program | undefined { + return this.program; + } + + public setProjectConfig(projectConfig: ProjectConfig): void { + throw new Error('do not set projectConfig!'); + } + + public getProjectConfig(): ProjectConfig | undefined { + return this.projectConfig; + } + + public setContextPtr(ptr: number): void { + this.contextPtr = ptr; + } + + public getContextPtr(): number | undefined { + return this.contextPtr; + } +} + +export interface ProjectConfig { + bundleName: string; + moduleName: string; + cachePath: string; + frameworkMode?: string; +} + +export type PluginHandlerFunction = () => void; + +export type PluginHandlerObject = { + order: 'pre' | 'post' | undefined; + handler: PluginHandlerFunction; +}; + +export type PluginHandler = PluginHandlerFunction | PluginHandlerObject; + +export interface Plugins { + name: string; + afterNew?: PluginHandler; + parsed?: PluginHandler; + scopeInited?: PluginHandler; + checked?: PluginHandler; + lowered?: PluginHandler; + asmGenerated?: PluginHandler; + binGenerated?: PluginHandler; + clean?: PluginHandler; +} + +export type PluginState = keyof Omit; + +export type PluginExecutor = { + name: string; + handler: PluginHandlerFunction; +}; diff --git a/ets1.2/arkui-plugins/common/predefines.ts b/ets1.2/arkui-plugins/common/predefines.ts new file mode 100644 index 0000000000000000000000000000000000000000..64b90a29b526260b820c4a94cf2b7910485cac7a --- /dev/null +++ b/ets1.2/arkui-plugins/common/predefines.ts @@ -0,0 +1,94 @@ +/* + * 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. + */ + +export const EXTERNAL_SOURCE_PREFIX_NAMES: (string | RegExp)[] = [ + 'std', + 'escompat', + 'security', + 'application', + 'permissions', + 'bundleManager', + 'commonEvent', + /@arkts\..*/, + /@ohos\.(?!arkui).*/, + /@system\..*/, + /ability\..*/, +]; + +export const EXTERNAL_SOURCE_PREFIX_NAMES_FOR_FRAMEWORK: (string | RegExp)[] = [ + 'std', + 'escompat', + /@arkts\..*/ +]; + +export const ARKUI_COMPONENT_IMPORT_NAME: string = '@ohos.arkui.component'; +export const ARKUI_STATEMANAGEMENT_IMPORT_NAME: string = '@ohos.arkui.stateManagement'; +export const KIT_ARKUI_NAME: string = '@kit.ArkUI'; + +export const EXTERNAL_SOURCE_ALLOWED_IMPORT_INSERT_NAMES: string[] = [ + ARKUI_COMPONENT_IMPORT_NAME, + ARKUI_STATEMANAGEMENT_IMPORT_NAME, +]; + +export const IMPORT_SOURCE_MAP: Map> = new Map>([ + ['arkui.stateManagement.runtime', new Set(['memo', '__memo_context_type', '__memo_id_type'])] +]); + +export const OUTPUT_DEPENDENCY_MAP: Map = new Map([ + ['$r', ['_r']], + ['$rawfile', ['_rawfile']], + ['State', ['StateDecoratedVariable']], + ['Link', ['LinkDecoratedVariable', 'DecoratedV1VariableBase']], + ['Prop', ['PropDecoratedVariable']], + ['Provide', ['ProvideDecoratedVariable']], + ['Consume', ['ConsumeDecoratedVariable']], + ['StorageProp', ['StoragePropDecoratedVariable']], + ['StorageLink', ['StorageLinkDecoratedVariable']], + ['LocalStorageLink', ['StorageLinkState', 'MutableState', 'observableProxy']], + ['LocalStorageProp', ['StorageLinkState', 'SyncedProperty', 'observableProxy', 'propState']], + ['ObjectLink', ['ObjectLinkDecoratedVariable']], + ['Observed', ['MutableStateMeta', 'BackingValue', 'setObservationDepth', 'IObservedObject', 'int32', 'WatchIdType', 'SubscribedWatches']], + ['Track', ['MutableStateMeta', 'BackingValue', 'setObservationDepth', 'IObservedObject', 'int32', 'WatchIdType', 'SubscribedWatches']], + ['$$', ['Bindable']], +]); + + +export enum InteroperAbilityNames { + ARKTS_1_1 = '1.1', + ARKTS_1_2 = '1.2', + ARKUICOMPATIBLE = 'ArkUICompatible', + ESVALUE = 'ESValue', + ELMTID = 'elmtId', + INITEMPTYOBJECT = 'instantiateEmptyObject', + SETPROPERTY = 'setProperty', + NUMBER = 'number', + PARENT = 'parent', + INSTANCE = 'instance', + PARAM = 'param', + EXTRAINFO = 'extraInfo', + COMPONENT = 'component', + GETPROPERTY = 'getProperty', + CONSTRUCTOR = 'constructor', + MODULE = 'module', + LOAD = 'load', + STRUCTOBJECT = 'structObject', + INSTANTIATE = 'instantiate', + WRAP = 'wrap', + WRAPINT = 'wrapInt', + WRAPSTRING = 'wrapString', + PARAMSLAMBDA = 'paramsLambda', + INTEROPCOMPONENT = 'interopComponent', + OHMURL = '@normalized:N&entry&com.example.Interop2use1&har1/src/main/ets/components/MainPage&1.0.0', +} diff --git a/ets1.2/arkui-plugins/common/print-visitor.ts b/ets1.2/arkui-plugins/common/print-visitor.ts new file mode 100644 index 0000000000000000000000000000000000000000..9f69e250d952ad572047cdc90874c9d95eadd992 --- /dev/null +++ b/ets1.2/arkui-plugins/common/print-visitor.ts @@ -0,0 +1,34 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { AbstractVisitor } from '../common/abstract-visitor'; + +export class PrintVisitor extends AbstractVisitor { + private result = ''; + + private printNode(node: arkts.AstNode) { + return `${' '.repeat(4 * this.indentation) + node.constructor.name} ${this.nameIfIdentifier(node)}`; + } + + private nameIfIdentifier(node: arkts.AstNode): string { + return arkts.isIdentifier(node) ? `'${node.name}'` : ''; + } + + visitor(node: arkts.AstNode): arkts.AstNode { + console.log(this.printNode(node)); + return this.visitEachChild(node); + } +} diff --git a/ets1.2/arkui-plugins/common/program-visitor.ts b/ets1.2/arkui-plugins/common/program-visitor.ts new file mode 100644 index 0000000000000000000000000000000000000000..9281c0b7808e368fcb14ef63429bc0321f0d1dc1 --- /dev/null +++ b/ets1.2/arkui-plugins/common/program-visitor.ts @@ -0,0 +1,295 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { AbstractVisitor, VisitorOptions } from './abstract-visitor'; +import { matchPrefix } from './arkts-utils'; +import { debugDump, getDumpFileName } from './debug'; +import { InteroperAbilityNames, ARKUI_COMPONENT_IMPORT_NAME, KIT_ARKUI_NAME } from './predefines'; +import { PluginContext } from './plugin-context'; +import { LegacyTransformer } from '../ui-plugins/legacy-transformer'; +import { ComponentTransformer } from '../ui-plugins/component-transformer'; + +export interface ProgramVisitorOptions extends VisitorOptions { + pluginName: string; + state: arkts.Es2pandaContextState; + visitors: AbstractVisitor[]; + skipPrefixNames: (string | RegExp)[]; + hooks?: ProgramHooks; + pluginContext?: PluginContext; +} + +export interface ProgramHookConfig { + visitors: AbstractVisitor[]; + resetAfter?: arkts.Es2pandaContextState; +} + +export type ProgramHookLifeCycle = Partial>; + +export interface ProgramHooks { + external?: ProgramHookLifeCycle; + source?: ProgramHookLifeCycle; +} + +function flattenVisitorsInHooks( + programHooks?: ProgramHooks, + resetAfterValue?: arkts.Es2pandaContextState +): AbstractVisitor[] { + if (!programHooks) return []; + const flatMapInHook = (config: ProgramHookConfig): AbstractVisitor[] => { + if (!resetAfterValue) return []; + if (!config.resetAfter || resetAfterValue !== config.resetAfter) return []; + return config.visitors; + }; + return [ + ...Object.values(programHooks.external || {}).flatMap(flatMapInHook), + ...Object.values(programHooks.source || {}).flatMap(flatMapInHook), + ]; +} + +function sortExternalSources(externalSources: arkts.ExternalSource[]): arkts.ExternalSource[] { + return externalSources.sort((a, b) => { + const prefix = ARKUI_COMPONENT_IMPORT_NAME || KIT_ARKUI_NAME; + const hasPrefixA = a.getName().startsWith(prefix); + const hasPrefixB = b.getName().startsWith(prefix); + + // If both have the prefix, maintain their original order + if (hasPrefixA && hasPrefixB) { + return 0; + } + // If neither has the prefix, maintain their original order + if (!hasPrefixA && !hasPrefixB) { + return 0; + } + // If only one has the prefix, the one with the prefix comes first + return hasPrefixA ? -1 : 1; + }); +} + +export interface StructMap { + [key: string]: string; +} + +export class ProgramVisitor extends AbstractVisitor { + private readonly pluginName: string; + private readonly state: arkts.Es2pandaContextState; + private readonly visitors: AbstractVisitor[]; + private readonly skipPrefixNames: (string | RegExp)[]; + private readonly hooks?: ProgramHooks; + private filenames: Map; + private pluginContext?: PluginContext; + private legacyModuleList: string[] = []; + private legacyStructMap: Map; + + constructor(options: ProgramVisitorOptions) { + super(options); + this.pluginName = options.pluginName; + this.state = options.state; + this.visitors = options.visitors; + this.skipPrefixNames = options.skipPrefixNames ?? []; + this.hooks = options.hooks; + this.filenames = new Map(); + this.pluginContext = options.pluginContext; + this.legacyModuleList = []; + this.legacyStructMap = new Map(); + } + + reset(): void { + super.reset(); + this.filenames = new Map(); + this.legacyStructMap = new Map(); + this.legacyModuleList = []; + } + + getLegacyModule(): void { + const moduleList = this.pluginContext?.getProjectConfig()?.dependentModuleList; + if (moduleList === undefined) { + return; + } + for (const module of moduleList) { + const language = module.language; + const moduleName = module.moduleName; + if (language !== InteroperAbilityNames.ARKTS_1_1) { + continue; + } + if (!this.legacyStructMap.has(moduleName)) { + this.legacyStructMap.set(moduleName, {}); + this.legacyModuleList.push(moduleName); + } + } + } + + dumpHeaders( + currProgram: arkts.Program, + name: string, + cachePath: string | undefined, + prefixName: string, + extensionName: string + ): void { + debugDump( + currProgram.astNode.dumpSrc(), + getDumpFileName(this.state, prefixName, undefined, name), + true, + cachePath, + extensionName + ); + } + + programVisitor(program: arkts.Program): arkts.Program { + const skipPrefixes: (string | RegExp)[] = this.skipPrefixNames; + const visited = new Set(); + const queue: arkts.Program[] = [program]; + this.getLegacyModule(); + while (queue.length > 0) { + const currProgram = queue.shift()!; + if (visited.has(currProgram.peer)) { + continue; + } + if (currProgram.peer !== program.peer) { + const name: string = this.filenames.get(currProgram.peer)!; + const cachePath: string | undefined = this.pluginContext?.getProjectConfig()?.cachePath; + if (this.legacyModuleList && matchPrefix(this.legacyModuleList, name)) { + if (this.state === arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED) { + const structList = this.visitorLegacy(currProgram.astNode, currProgram, name); + const moduleName = name.split('/')[0]; + const structMap = this.legacyStructMap.get(moduleName)!; + for (const struct of structList) { + structMap[struct] = name; + } + } + } else { + this.dumpHeaders(currProgram, name, cachePath, 'Ori', program.programFileNameWithExtension); + const script = this.visitor(currProgram.astNode, currProgram, name); + if (script) { + this.dumpHeaders(currProgram, name, cachePath, this.pluginName, program.programFileNameWithExtension); + } + } + } + visited.add(currProgram.peer); + for (const externalSource of sortExternalSources(currProgram.externalSources)) { + if (matchPrefix(skipPrefixes, externalSource.getName())) { + continue; + } + const nextProgramArr: arkts.Program[] = externalSource.programs ?? []; + for (const nextProgram of nextProgramArr) { + this.filenames.set(nextProgram.peer, externalSource.getName()); + if (!visited.has(nextProgram.peer)) { + queue.push(nextProgram); + } + } + } + } + const hasLegacy = this.legacyStructMap.size ? true : false; + let programScript = program.astNode; + programScript = this.visitor(programScript, program, this.externalSourceName, hasLegacy); + const visitorsToReset = flattenVisitorsInHooks(this.hooks, this.state); + visitorsToReset.forEach((visitor) => visitor.reset()); + return program; + } + + preVisitor( + node: arkts.AstNode, + program?: arkts.Program, + externalSourceName?: string + ): void { + const isExternal: boolean = !!externalSourceName; + let hook: ProgramHookLifeCycle | undefined = isExternal ? this.hooks?.external : this.hooks?.source; + let script: arkts.EtsScript = node as arkts.EtsScript; + + const preVisitors = hook?.pre?.visitors ?? []; + for (const transformer of preVisitors) { + transformer.isExternal = isExternal; + transformer.externalSourceName = externalSourceName; + transformer.program = program; + transformer.visitor(script); + if (!this.hooks?.external?.pre?.resetAfter) { + transformer.reset(); + } + } + } + + postVisitor( + node: arkts.AstNode, + program?: arkts.Program, + externalSourceName?: string + ): void { + const isExternal: boolean = !!externalSourceName; + let hook: ProgramHookLifeCycle | undefined = isExternal ? this.hooks?.external : this.hooks?.source; + let script: arkts.EtsScript = node as arkts.EtsScript; + + const postVisitors = hook?.post?.visitors ?? []; + for (const transformer of postVisitors) { + transformer.isExternal = isExternal; + transformer.externalSourceName = externalSourceName; + transformer.program = program; + transformer.visitor(script); + if (!this.hooks?.external?.pre?.resetAfter) { + transformer.reset(); + } + } + } + + visitor( + node: arkts.AstNode, + program?: arkts.Program, + externalSourceName?: string, + hasLegacy: boolean = false + ): arkts.EtsScript { + let script: arkts.EtsScript = node as arkts.EtsScript; + let count: number = 0; + const isExternal: boolean = !!externalSourceName; + + // pre-run visitors + this.preVisitor(node, program, externalSourceName); + + for (const transformer of this.visitors) { + transformer.isExternal = isExternal; + transformer.externalSourceName = externalSourceName; + transformer.program = program; + if (hasLegacy && transformer instanceof ComponentTransformer) { + transformer.registerMap(this.legacyStructMap); + } + script = transformer.visitor(script) as arkts.EtsScript; + transformer.reset(); + arkts.setAllParents(script); + if (!transformer.isExternal) { + debugDump( + script.dumpSrc(), + getDumpFileName(this.state, this.pluginName, count, transformer.constructor.name), + true, + this.pluginContext?.getProjectConfig()?.cachePath, + program!.programFileNameWithExtension + ); + count += 1; + } + } + + // post-run visitors + this.postVisitor(node, program, externalSourceName); + + return script; + } + + visitorLegacy( + node: arkts.AstNode, + program?: arkts.Program, + externalSourceName?: string, + ): string[] { + const visitor = new LegacyTransformer(); + const script = visitor.visitor(node) as arkts.EtsScript; + const structList = visitor.getList(); + return structList; + } +} diff --git a/ets1.2/arkui-plugins/custom-import-plugin.js b/ets1.2/arkui-plugins/custom-import-plugin.js new file mode 100644 index 0000000000000000000000000000000000000000..84b8a6bd5847b908683c89111b4447e2b3ac87b3 --- /dev/null +++ b/ets1.2/arkui-plugins/custom-import-plugin.js @@ -0,0 +1,48 @@ +/* + * 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. + */ + + +const path = require('path'); + +module.exports = function (babel) { + const { types: t } = babel; + + return { + name: 'custom-import-plugin', + visitor: { + ImportDeclaration(pathNode) { + const sourceValue = pathNode.node.source.value; + if (sourceValue === '@koalaui/libarkts' && pathNode.node.specifiers.length === 1 && t.isImportNamespaceSpecifier(pathNode.node.specifiers[0])) { + const currentFileDir = path.dirname(pathNode.hub.file.opts.filename); + const configDir = process.cwd(); + const relativePath = path.relative(currentFileDir, configDir); + const importPath = relativePath ? path.join(relativePath, 'path') : './path'; + + const newImport = t.importDeclaration( + [t.importSpecifier(t.identifier('getArktsPath'), t.identifier('getArktsPath'))], + t.stringLiteral(importPath) + ); + + const requireCall = t.callExpression(t.identifier('require'), [t.callExpression(t.identifier('getArktsPath'), [])]); + const arkts = t.variableDeclaration('const', [ + t.variableDeclarator(t.identifier('arkts'), requireCall) + ]); + + pathNode.replaceWithMultiple([newImport, arkts]); + } + } + } + }; +}; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/interop-plugins/arkuiImportList.ts b/ets1.2/arkui-plugins/interop-plugins/arkuiImportList.ts new file mode 100644 index 0000000000000000000000000000000000000000..ddc19b2bd98bf3d005f43c654945be7fbc640c2f --- /dev/null +++ b/ets1.2/arkui-plugins/interop-plugins/arkuiImportList.ts @@ -0,0 +1,176 @@ +/* + * 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. + */ + +export const ARKUI_DECLARE_LIST: Set = new Set([ + 'AbilityComponent', + 'AlphabetIndexer', + 'AnalogClock', + 'Animator', + 'Badge', + 'Blank', + 'Button', + 'Calendar', + 'CalendarPicker', + 'Camera', + 'Canvas', + 'Checkbox', + 'CheckboxGroup', + 'Circle', + 'ColorPicker', + 'ColorPickerDialog', + 'Column', + 'ColumnSplit', + 'ContentSlot', + 'Counter', + 'DataPanel', + 'DatePicker', + 'Divider', + 'EffectComponent', + 'Ellipse', + 'EmbeddedComponent', + 'Flex', + 'FolderStack', + 'FormComponent', + 'FormLink', + 'Gauge', + 'GeometryView', + 'Grid', + 'GridItem', + 'GridContainer', + 'Hyperlink', + 'Image', + 'ImageAnimator', + 'Line', + 'LinearIndicator', + 'List', + 'ListItem', + 'ListItemGroup', + 'LoadingProgress', + 'Marquee', + 'MediaCachedImage', + 'Menu', + 'MenuItem', + 'MenuItemGroup', + 'MovingPhotoView', + 'NavDestination', + 'NavRouter', + 'Navigation', + 'Navigator', + 'NodeContainer', + 'Option', + 'PageTransitionEnter', + 'PageTransitionExit', + 'Panel', + 'Particle', + 'Path', + 'PatternLock', + 'Piece', + 'PlatformView', + 'PluginComponent', + 'Polygon', + 'Polyline', + 'Progress', + 'QRCode', + 'Radio', + 'Rating', + 'Rect', + 'Refresh', + 'RelativeContainer', + 'RemoteWindow', + 'RootScene', + 'Row', + 'RowSplit', + 'RichText', + 'Screen', + 'Scroll', + 'ScrollBar', + 'Search', + 'Section', + 'Select', + 'Shape', + 'Sheet', + 'SideBarContainer', + 'Slider', + 'Span', + 'Stack', + 'Stepper', + 'StepperItem', + 'Swiper', + 'SymbolGlyph', + 'SymbolSpan', + 'TabContent', + 'Tabs', + 'Text', + 'TextPicker', + 'TextClock', + 'TextArea', + 'TextInput', + 'TextTimer', + 'TimePicker', + 'Toggle', + 'Video', + 'Web', + 'WindowScene', + 'WithTheme', + 'XComponent', + 'GridRow', + 'GridCol', + 'WaterFlow', + 'FlowItem', + 'ImageSpan', + 'LocationButton', + 'PasteButton', + 'SaveButton', + 'UIExtensionComponent', + 'IsolatedComponent', + 'RichEditor', + 'Component3D', + 'ContainerSpan', + 'Require', + 'BuilderParam', + 'Local', + 'Param', + 'Once', + 'Event', + 'State', + 'Track', + 'Trace', + 'Prop', + 'Link', + 'ObjectLink', + 'Provide', + 'Provider', + 'Consume', + 'Consumer', + 'StorageProp', + 'StorageLink', + 'Watch', + 'LocalStorageLink', + 'LocalStorageProp', + 'Component', + 'ComponentV2', + 'Entry', + 'Observed', + 'ObservedV2', + 'Preview', + 'CustomDialog', + 'Reusable', + 'Computed', + 'Builder', + 'LocalBuilder', + 'Styles', + 'Extend', + 'AnimatableExtend' +]); \ No newline at end of file diff --git a/ets1.2/arkui-plugins/interop-plugins/decl_transformer.ts b/ets1.2/arkui-plugins/interop-plugins/decl_transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..58d5a6a6dcad76f8c71bb8cdd6aa3ea2aafcdade --- /dev/null +++ b/ets1.2/arkui-plugins/interop-plugins/decl_transformer.ts @@ -0,0 +1,134 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { AbstractVisitor } from '../common/abstract-visitor'; +import { ARKUI_DECLARE_LIST } from './arkuiImportList'; +import { debugLog } from '../common/debug'; + +export class DeclTransformer extends AbstractVisitor { + constructor(private options?: interop.DeclTransformerOptions) { + super(); + } + + processComponent(node: arkts.StructDeclaration): arkts.ClassDeclaration { + const className = node.definition?.ident?.name; + if (!className) { + throw 'Non Empty className expected for Component'; + } + + let newDec: arkts.ClassDeclaration = arkts.factory.createClassDeclaration(node.definition); + + const newDefinition = arkts.factory.updateClassDefinition( + newDec.definition!, + newDec.definition?.ident, + undefined, + undefined, + newDec.definition?.implements!, + undefined, + undefined, + node.definition?.body, + newDec.definition?.modifiers!, + arkts.classDefinitionFlags(newDec.definition!) | arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE + ); + + arkts.factory.updateClassDeclaration(newDec, newDefinition); + newDec.modifiers = node.modifiers; + return newDec; + } + + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + let astNode: arkts.AstNode = beforeChildren; + if (arkts.isEtsScript(astNode)) { + astNode = this.transformImportDecl(astNode); + } + const node = this.visitEachChild(astNode); + if (arkts.isStructDeclaration(node)) { + debugLog(`DeclTransformer:before:flag:${arkts.classDefinitionIsFromStructConst(node.definition!)}`); + arkts.classDefinitionSetFromStructModifier(node.definition!); + let newnode = this.processComponent(node); + debugLog(`DeclTransformer:after:flag:${arkts.classDefinitionIsFromStructConst(newnode.definition!)}`); + return newnode; + } else if (arkts.isETSImportDeclaration(astNode)) { + return this.updateImportDeclaration(astNode); + } else if (arkts.isMethodDefinition(astNode)) { + if (astNode.name?.name === 'build' ) { + return this.transformMethodDefinition(astNode); + } + return astNode; + } + return node; + } + + transformImportDecl(astNode: arkts.AstNode):arkts.AstNode { + if (!arkts.isEtsScript(astNode)) { + return astNode; + } + let statements = astNode.statements.filter(node => this.isImportDeclarationNeedFilter(node)); + return arkts.factory.updateEtsScript(astNode, statements); + } + + transformMethodDefinition(node: arkts.MethodDefinition): arkts.AstNode { + const func: arkts.ScriptFunction = node.scriptFunction; + const isFunctionCall: boolean = false; + const typeNode: arkts.TypeNode | undefined = node.scriptFunction?.returnTypeAnnotation; + const updateFunc = arkts.factory.updateScriptFunction( + func, + !!func.body && arkts.isBlockStatement(func.body) + ? arkts.factory.updateBlock( + func.body, + func.body.statements.filter((st) => false) + ) + : undefined, + arkts.FunctionSignature.createFunctionSignature(func.typeParams, func.params, func.returnTypeAnnotation, false), + func?.flags, + func?.modifiers + ); + + return arkts.factory.updateMethodDefinition( + node, + node.kind, + arkts.factory.updateIdentifier( + node.name, + node.name?.name + ), + updateFunc, + node.modifiers, + false + ); + } + + isImportDeclarationNeedFilter(astNode: arkts.AstNode):boolean { + if (!arkts.isETSImportDeclaration(astNode)) { + return true; + } + return astNode?.source?.str !== '@global.arkui'; + } + + updateImportDeclaration(astNode: arkts.AstNode):arkts.AstNode { + if (!arkts.isETSImportDeclaration(astNode) || astNode?.source?.str !== '@ohos.arkui.component') { + return astNode; + } + astNode.specifiers.forEach((element) => { + if (arkts.isImportSpecifier(element)) { + if (ARKUI_DECLARE_LIST.has(element.imported?.name as string)) { + arkts.ImportSpecifierSetRemovable(element); + } + } + }); + return astNode; + } +} diff --git a/ets1.2/arkui-plugins/interop-plugins/emit_transformer.ts b/ets1.2/arkui-plugins/interop-plugins/emit_transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..d68dfbc2fb39522b05e6c352a0bc55af8d30e35c --- /dev/null +++ b/ets1.2/arkui-plugins/interop-plugins/emit_transformer.ts @@ -0,0 +1,60 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { AbstractVisitor } from '../common/abstract-visitor'; + +import { debugLog } from '../common/debug'; + +export class EmitTransformer extends AbstractVisitor { + constructor(private options?: interop.EmitTransformerOptions) { + super(); + } + + processComponent(node: arkts.ClassDeclaration): arkts.ClassDeclaration { + const className = node.definition?.ident?.name; + if (!className) { + throw 'Non Empty className expected for Component'; + } + + const newDefinition = arkts.factory.updateClassDefinition( + node.definition, + node.definition?.ident, + undefined, + undefined, + node.definition?.implements, + undefined, + undefined, + node.definition?.body, + node.definition?.modifiers, + arkts.classDefinitionFlags(node.definition) | arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE + ); + + let newDec: arkts.ClassDeclaration = arkts.factory.updateClassDeclaration(node, newDefinition); + + debugLog(`DeclTransformer:checked:struct_ast:${newDefinition.dumpJson()}`); + newDec.modifiers = node.modifiers; + return newDec; + } + + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + const node = this.visitEachChild(beforeChildren); + if (arkts.isClassDeclaration(node) && arkts.classDefinitionIsFromStructConst(node.definition!)) { + return this.processComponent(node); + } + return node; + } +} diff --git a/ets1.2/arkui-plugins/interop-plugins/index.ts b/ets1.2/arkui-plugins/interop-plugins/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..841f74e11e37f16fd0a9e451c04a578d3ca4309f --- /dev/null +++ b/ets1.2/arkui-plugins/interop-plugins/index.ts @@ -0,0 +1,100 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { DeclTransformer } from './decl_transformer'; +import { EmitTransformer } from './emit_transformer'; + +import { ProgramVisitor } from '../common/program-visitor'; +import { EXTERNAL_SOURCE_PREFIX_NAMES } from '../common/predefines'; +import { debugLog } from '../common/debug'; +import { PluginContext, Plugins } from 'common/plugin-context'; + +export function interopTransform():Plugins { + return { + name: 'interop-plugin', + parsed: parsedTransform, + checked: checkedTransform, + clean(): void { + arkts.arktsGlobal.clearContext(); + }, + }; +} + +function parsedTransform(this: PluginContext): arkts.EtsScript | undefined { + let script: arkts.EtsScript | undefined; + debugLog('interopTransform:parsed'); + const contextPtr = arkts.arktsGlobal.compilerContext?.peer ?? this.getContextPtr(); + if (!!contextPtr) { + let program = arkts.getOrUpdateGlobalContext(contextPtr).program; + script = program.astNode; + + if (script) { + const declTransformer = new DeclTransformer({ + arkui: '@koalaui.arkts-arkui.StructParse' as interop.TransfromerName + }); + + const programVisitor = new ProgramVisitor({ + pluginName: interopTransform().name, + state: arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED, + visitors: [declTransformer], + skipPrefixNames: EXTERNAL_SOURCE_PREFIX_NAMES, + pluginContext: this as unknown as PluginContext + }); + + program = programVisitor.programVisitor(program); + script = program.astNode; + this.setArkTSAst(script); + debugLog('interopTransform:parsed exit'); + return script; + } + } + debugLog('interopTransform: parsed exit with no transform'); + return script; +} + +function checkedTransform(this: PluginContext): arkts.EtsScript | undefined { + let script: arkts.EtsScript | undefined; + debugLog('interopTransform:checked'); + const contextPtr = arkts.arktsGlobal.compilerContext?.peer ?? this.getContextPtr(); + if (!!contextPtr) { + let program = arkts.getOrUpdateGlobalContext(contextPtr).program; + script = program.astNode; + if (script) { + const emitTransformer = new EmitTransformer({ + arkui: '@koalaui.arkts-arkui.EmitBase' as interop.TransfromerName + }); + + const programVisitor = new ProgramVisitor({ + pluginName: interopTransform().name, + state: arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED, + visitors: [emitTransformer], + skipPrefixNames: EXTERNAL_SOURCE_PREFIX_NAMES, + pluginContext: this as unknown as PluginContext + }); + + program = programVisitor.programVisitor(program); + script = program.astNode; + arkts.GlobalInfo.getInfoInstance()?.reset(); + arkts.recheckSubtree(script); + this.setArkTSAst(script); + debugLog('interopTransform:checked exit'); + return script; + } + } + debugLog('interopTransform:checked exit with no transform'); + return script; +} diff --git a/ets1.2/arkui-plugins/interop-plugins/types.ts b/ets1.2/arkui-plugins/interop-plugins/types.ts new file mode 100644 index 0000000000000000000000000000000000000000..49b257dc5d1cfa4d3a57fa45ea9813487c11c525 --- /dev/null +++ b/ets1.2/arkui-plugins/interop-plugins/types.ts @@ -0,0 +1,56 @@ +/* + * 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. + */ + +namespace interop { + export type NativePointer = number; + + export interface PluginContext { + setArkTSAst(ast: Node): void; + getArkTSAst(): Node | undefined; + setArkTSProgram(program: Node): void; + getArkTSProgram(): Node | undefined; + setProjectConfig(projectConfig: Node): void; + getProjectConfig(): Node | undefined; + } + + export interface ArktsObject { + readonly peer: NativePointer; + } + + export interface Node extends ArktsObject { + get originalPeer(): NativePointer; + set originalPeer(peer: NativePointer); + dumpJson(): string; + dumpSrc(): string; + } + + export interface EtsScript extends Node {} + + export interface Plugin { + name: string; + parsed?(context: PluginContext): EtsScript | undefined; + checked?(context: PluginContext): EtsScript | undefined; + } + + export type TransfromerName = string & { __TransfromerNameBrand: any }; + + export interface EmitTransformerOptions { + arkui: TransfromerName; + } + + export interface DeclTransformerOptions { + arkui: TransfromerName; + } +} diff --git a/ets1.2/arkui-plugins/jest-test.config.js b/ets1.2/arkui-plugins/jest-test.config.js new file mode 100644 index 0000000000000000000000000000000000000000..541b1dc3913d9c2621eb0c0a6408447351f747d1 --- /dev/null +++ b/ets1.2/arkui-plugins/jest-test.config.js @@ -0,0 +1,56 @@ +/* + * 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. + */ + +const path = require('path'); + +const rootPath = path.resolve(__dirname, '../../../'); +const sdkPath = path.resolve(rootPath, './out/sdk/ohos-sdk/linux/ets/ets1.2'); +const pandaSdkPath = path.resolve(sdkPath, './build-tools/ets2panda'); +const apiPath = path.resolve(sdkPath, './api'); + +module.exports = { + testEnvironment: 'node', + transform: { + '^.+\\.ts$': ['ts-jest'], + }, + testRegex: './test/ut/.+\\.test\\.ts$', + moduleFileExtensions: ['ts', 'js', 'json', 'node'], + coverageDirectory: './test/report', + collectCoverageFrom: [ + 'common/**', + 'memo-plugins/**', + 'ui-plugins/**' + ], + coveragePathIgnorePatterns: [ + 'common/debug.ts', + 'common/etsglobal-remover.ts', + 'common/print-visitor.ts', + 'common/plugin-context.ts', + 'memo-plugins/index.ts', + 'memo-plugins/import-transformer.ts', + 'memo-plugins/memo-transformer.ts', + 'ui-plugins/index.ts', + 'ui-plugins/printer-transformer.ts', + 'ui-plugins/builder-lambda-translators/builder-lambda-transformer.ts', + 'ui-plugins/entry-translators/entry-transformer.ts', + 'ui-plugins/struct-translators/struct-transformer.ts' + ], + verbose: true, + globals: { + SDK_PATH: sdkPath, + PANDA_SDK_PATH: pandaSdkPath, + API_PATH: apiPath, + }, +}; diff --git a/ets1.2/arkui-plugins/memo-plugins/function-transformer.ts b/ets1.2/arkui-plugins/memo-plugins/function-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..68bc9083d22f33b37ad2155835e007497072497e --- /dev/null +++ b/ets1.2/arkui-plugins/memo-plugins/function-transformer.ts @@ -0,0 +1,716 @@ +/* + * 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 { factory } from './memo-factory'; +import { AbstractVisitor, VisitorOptions } from '../common/abstract-visitor'; +import { + MemoInfo, + PositionalIdTracker, + ReturnTypeInfo, + buildReturnTypeInfo, + castArrowFunctionExpression, + castIdentifier, + castOverloadsToMethods, + castParameters, + findMemoFromTypeAnnotation, + findThisAttribute, + getDeclResolveAlias, + hasMemoAnnotation, + hasMemoEntryAnnotation, + hasMemoIntrinsicAnnotation, + hasMemoStableAnnotation, + isDeclaredMethodWithMemoParams, + isFunctionProperty, + isMemoArrowFunction, + isMemoClassProperty, + isMemoDeclaredClassProperty, + isMemoDeclaredIdentifier, + isMemoDeclaredMethod, + isMemoETSParameterExpression, + isMemoMethodDefinition, + isMemoProperty, + isMemoTSTypeAliasDeclaration, + isMemoThisAttribute, + isMemoVariableDeclarator, + isStandaloneArrowFunction, + isThisAttributeAssignment, + removeMemoAnnotation, + parametrizedNodeHasReceiver +} from './utils'; +import { ParameterTransformer } from './parameter-transformer'; +import { ReturnTransformer } from './return-transformer'; +import { SignatureTransformer } from './signature-transformer'; +import { moveToFront } from '../common/arkts-utils'; +import { InternalsTransformer } from './internal-transformer'; + +interface ScopeInfo extends MemoInfo { + regardAsSameScope?: boolean; +} + +export interface FunctionTransformerOptions extends VisitorOptions { + positionalIdTracker: PositionalIdTracker; + parameterTransformer: ParameterTransformer; + returnTransformer: ReturnTransformer; + signatureTransformer: SignatureTransformer; + internalsTransformer?: InternalsTransformer; +} + +export class FunctionTransformer extends AbstractVisitor { + private readonly positionalIdTracker: PositionalIdTracker; + private readonly parameterTransformer: ParameterTransformer; + private readonly returnTransformer: ReturnTransformer; + private readonly signatureTransformer: SignatureTransformer; + private readonly internalsTransformer?: InternalsTransformer; + + /* Tracking whether should import `__memo_context_type` and `__memo_id_type` */ + private modified = false; + + constructor(options: FunctionTransformerOptions) { + super(options); + this.positionalIdTracker = options.positionalIdTracker; + this.parameterTransformer = options.parameterTransformer; + this.returnTransformer = options.returnTransformer; + this.signatureTransformer = options.signatureTransformer; + this.internalsTransformer = options.internalsTransformer; + } + + private scopes: ScopeInfo[] = []; + private stable: number = 0; + + reset() { + super.reset(); + this.scopes = []; + this.stable = 0; + this.modified = false; + this.parameterTransformer.reset(); + this.returnTransformer.reset(); + this.signatureTransformer.reset(); + } + + private enterMethod(node: arkts.MethodDefinition): void { + const name = node.name.name; + const isMemo = isMemoMethodDefinition(node); + this.scopes.push({ name, isMemo }); + } + + private enterClassPropety(node: arkts.ClassProperty): void { + const name = castIdentifier(node.key).name; + const isMemo = isMemoClassProperty(node); + this.scopes.push({ name, isMemo }); + } + + private enterStandaloneArrowFunction(node: arkts.ArrowFunctionExpression): void { + const name = undefined; + const isMemo = isMemoArrowFunction(node); + this.scopes.push({ name, isMemo }); + } + + private enterTSTypeAliasDeclaration(node: arkts.TSTypeAliasDeclaration): void { + const name = castIdentifier(node.id).name; + const isMemo = isMemoTSTypeAliasDeclaration(node); + this.scopes.push({ name, isMemo }); + } + + private enterVariableDeclarator(node: arkts.VariableDeclarator): void { + const name = node.name.name; + const isMemo = isMemoVariableDeclarator(node); + this.scopes.push({ name, isMemo, regardAsSameScope: !!node.initializer }); + } + + private enterTSAsExpression(node: arkts.TSAsExpression): void { + const isMemo = findMemoFromTypeAnnotation(node.typeAnnotation); + this.scopes.push({ isMemo }); + } + + private enterFunctionProperty(node: arkts.Property): void { + const name = castIdentifier(node.key).name; + const isMemo = isMemoProperty(node, castArrowFunctionExpression(node.value)); + this.scopes.push({ name, isMemo }); + } + + private enterThisAttributeAssignment(node: arkts.AssignmentExpression): void { + const thisAttribute = findThisAttribute(node.left!)!; + const name = thisAttribute.name; + const isMemo = isMemoThisAttribute(thisAttribute, castArrowFunctionExpression(node.right)); + this.scopes.push({ name, isMemo }); + } + + enter(node: arkts.AstNode): this { + if (arkts.isMethodDefinition(node)) { + this.enterMethod(node); + } + if (arkts.isClassProperty(node) && !!node.key && arkts.isIdentifier(node.key)) { + this.enterClassPropety(node); + } + if (isStandaloneArrowFunction(node)) { + this.enterStandaloneArrowFunction(node); + } + if (arkts.isTSTypeAliasDeclaration(node) && !!node.id && !!node.typeAnnotation) { + this.enterTSTypeAliasDeclaration(node); + } + if (arkts.isVariableDeclarator(node)) { + this.enterVariableDeclarator(node); + } + if (arkts.isTSAsExpression(node) && !!node.expr && arkts.isArrowFunctionExpression(node.expr)) { + this.enterTSAsExpression(node); + } + if (isFunctionProperty(node)) { + this.enterFunctionProperty(node); + } + if (isThisAttributeAssignment(node) && !!node.right && arkts.isArrowFunctionExpression(node.right)) { + this.enterThisAttributeAssignment(node); + } + if (arkts.isClassDefinition(node)) { + if (hasMemoStableAnnotation(node)) { + this.stable++; + } + } + return this; + } + + exit(node: arkts.AstNode) { + if (arkts.isMethodDefinition(node)) { + this.scopes.pop(); + } + if (arkts.isClassDefinition(node)) { + if (hasMemoStableAnnotation(node)) { + this.stable--; + } + } + return this; + } + + enterAnonymousScope(node: arkts.ScriptFunction) { + const name = undefined; + const isMemo = hasMemoAnnotation(node) || hasMemoIntrinsicAnnotation(node); + this.scopes.push({ name, isMemo }); + return this; + } + + exitAnonymousScope() { + this.scopes.pop(); + return this; + } + + checkMemoCallInMethod(decl: arkts.MethodDefinition) { + const scope = this.scopes[this.scopes.length - 1]; + if (scope?.regardAsSameScope === false && scope?.isMemo === false) { + if (scope.name) { + console.error(`Attempt to call @memo-method ${decl.name.name} from non-@memo-method ${scope.name}`); + throw 'Invalid @memo usage'; + } else { + console.error(`Attempt to call @memo-method ${decl.name.name} from anonymous non-@memo-method`); + throw 'Invalid @memo usage'; + } + } + return this; + } + + checkMemoCallInFunction() { + const scope = this.scopes[this.scopes.length - 1]; + if (scope?.regardAsSameScope === false && scope?.isMemo === false) { + console.error(`Attempt to call @memo-function`); + throw 'Invalid @memo usage'; + } + return this; + } + + updateInternalsInScriptFunction(scriptFunction: arkts.ScriptFunction): arkts.ScriptFunction { + if (!scriptFunction.body || !arkts.isBlockStatement(scriptFunction.body) || !this.internalsTransformer) { + return scriptFunction; + } + const afterInternalsTransformer = this.internalsTransformer.visitor( + scriptFunction.body + ) as arkts.BlockStatement; + return arkts.factory.updateScriptFunction( + scriptFunction, + afterInternalsTransformer, + arkts.factory.createFunctionSignature( + scriptFunction.typeParams, + scriptFunction.params, + scriptFunction.returnTypeAnnotation, + scriptFunction.hasReceiver + ), + scriptFunction.flags, + scriptFunction.modifiers + ); + } + + updateScriptFunction(scriptFunction: arkts.ScriptFunction, name: string = ''): arkts.ScriptFunction { + if (!scriptFunction.body || !arkts.isBlockStatement(scriptFunction.body)) { + return scriptFunction; + } + if (this.parameterTransformer.isTracked(scriptFunction.body)) { + return this.updateInternalsInScriptFunction(scriptFunction); + } + if (hasMemoIntrinsicAnnotation(scriptFunction) || hasMemoEntryAnnotation(scriptFunction)) { + return this.updateInternalsInScriptFunction(scriptFunction); + } + const returnType = scriptFunction.returnTypeAnnotation; + const isStableThis = this.stable > 0 && returnType !== undefined && arkts.isTSThisType(returnType); + const returnTypeInfo: ReturnTypeInfo = buildReturnTypeInfo( + returnType, + findMemoFromTypeAnnotation(returnType), + isStableThis + ); + const [body, parameterIdentifiers, memoParametersDeclaration, syntheticReturnStatement] = + factory.updateFunctionBody( + scriptFunction.body, + castParameters(scriptFunction.params), + returnTypeInfo, + this.positionalIdTracker.id(name) + ); + const afterParameterTransformer = this.parameterTransformer + .withParameters(parameterIdentifiers) + .skip(memoParametersDeclaration) + .visitor(body); + const afterReturnTransformer = this.returnTransformer + .skip(syntheticReturnStatement) + .registerReturnTypeInfo(returnTypeInfo) + .rewriteThis(this.stable > 0) + .visitor(afterParameterTransformer); + const updateScriptFunction = factory.updateScriptFunctionWithMemoParameters( + scriptFunction, + afterReturnTransformer, + returnTypeInfo.node + ); + this.modified = true; + this.parameterTransformer.track(updateScriptFunction.body); + return this.updateInternalsInScriptFunction(updateScriptFunction); + } + + private updateMethodDefinition(node: arkts.MethodDefinition): arkts.MethodDefinition { + let updateMethod: arkts.MethodDefinition; + const that = this; + const updateOverloads = node.overloads?.map((overload) => that.visitor(overload)) ?? undefined; + const isMemo = + hasMemoAnnotation(node.scriptFunction) || + hasMemoIntrinsicAnnotation(node.scriptFunction) || + hasMemoEntryAnnotation(node.scriptFunction); + if (isMemo && node.scriptFunction.body) { + const hasIntrinsic = hasMemoIntrinsicAnnotation(node.scriptFunction); + updateMethod = arkts.factory.updateMethodDefinition( + node, + node.kind, + node.name, + this.signatureTransformer.visitor( + removeMemoAnnotation(this.updateScriptFunction(node.scriptFunction, node.name.name)), + hasIntrinsic + ), + node.modifiers, + false + ); + } else { + updateMethod = arkts.factory.updateMethodDefinition( + node, + node.kind, + node.name, + this.signatureTransformer.visitor(node.scriptFunction), + node.modifiers, + false + ); + } + if (!!updateOverloads) { + updateMethod.setOverloads(castOverloadsToMethods(updateOverloads)); + } + this.modified ||= this.signatureTransformer.modified; + return updateMethod; + } + + private updateDeclaredMethodMemoCall( + node: arkts.CallExpression, + decl: arkts.MethodDefinition, + ignoreSelf: boolean = false + ): arkts.CallExpression { + let updatedArguments: arkts.AstNode[] = node.arguments.map((it, index) => { + const param = decl.scriptFunction.params.at(index); + if (!param || !arkts.isEtsParameterExpression(param)) { + return it; + } + if (isMemoETSParameterExpression(param) && arkts.isArrowFunctionExpression(it)) { + this.enterAnonymousScope(it.scriptFunction); + const res = this.updateScriptFunction(it.scriptFunction); + this.exitAnonymousScope(); + this.modified = true; + return arkts.factory.updateArrowFunction(it, res); + } + return it; + }); + if (!ignoreSelf) { + this.checkMemoCallInMethod(decl); + updatedArguments = [ + ...factory.createHiddenArguments(this.positionalIdTracker.id(decl.name.name)), + ...updatedArguments, + ]; + } + const isMemo = + hasMemoAnnotation(decl.scriptFunction) || + hasMemoIntrinsicAnnotation(decl.scriptFunction) || + hasMemoEntryAnnotation(decl.scriptFunction); + if (parametrizedNodeHasReceiver(decl.scriptFunction) && isMemo) { + updatedArguments = moveToFront(updatedArguments, 2); + } + this.modified = true; + return arkts.factory.updateCallExpression(node, node.expression, node.typeArguments, updatedArguments); + } + + private updateDeclaredCallWithName(node: arkts.CallExpression, name: string): arkts.CallExpression { + this.modified = true; + return factory.insertHiddenArgumentsToCall(node, this.positionalIdTracker.id(name)); + } + + private updateAnonymousCallWithMemoParams(node: arkts.CallExpression): arkts.CallExpression { + let newExpression: arkts.AstNode = node.expression; + if (isStandaloneArrowFunction(node.expression)) { + newExpression = arkts.factory.updateArrowFunction( + node.expression, + this.signatureTransformer.visitor(node.expression.scriptFunction) + ); + } + const updatedArguments: arkts.AstNode[] = node.arguments.map((it) => { + if (arkts.isArrowFunctionExpression(it) && isMemoArrowFunction(it)) { + this.enterAnonymousScope(it.scriptFunction); + const res = this.updateScriptFunction(it.scriptFunction); + this.exitAnonymousScope(); + this.modified = true; + return arkts.factory.updateArrowFunction(it, res); + } + return it; + }); + this.modified ||= this.signatureTransformer.modified; + return arkts.factory.updateCallExpression(node, newExpression, node.typeArguments, updatedArguments); + } + + private updateAnonymousMemoCall( + node: arkts.CallExpression, + expression: arkts.ArrowFunctionExpression + ): arkts.CallExpression { + const scope = this.scopes[this.scopes.length - 1]; + const isValidScope = !!scope && scope.name === expression.scriptFunction.id?.name; + if (!isValidScope) { + return node; + } + this.exitAnonymousScope(); + if (!scope.isMemo) { + return this.updateAnonymousCallWithMemoParams(node); + } + this.checkMemoCallInFunction(); + + this.enterAnonymousScope(expression.scriptFunction); + const res = this.updateScriptFunction(expression.scriptFunction, expression.scriptFunction.id?.name); + this.exitAnonymousScope(); + + const newNode = this.updateAnonymousCallWithMemoParams(node); + this.modified = true; + return arkts.factory.updateCallExpression( + node, + arkts.factory.updateArrowFunction(expression, res), + newNode.typeArguments, + [...factory.createHiddenArguments(this.positionalIdTracker.id()), ...newNode.arguments] + ); + } + + private updateCallExpressionWithNoDecl(node: arkts.CallExpression): arkts.CallExpression { + if (isStandaloneArrowFunction(node.expression)) { + return this.updateAnonymousMemoCall(node, node.expression); + } + return this.updateAnonymousCallWithMemoParams(node); + } + + private updateCallExpression(node: arkts.CallExpression): arkts.CallExpression { + const expr = node.expression; + const decl = getDeclResolveAlias(expr); + if (!decl) { + return this.updateCallExpressionWithNoDecl(node); + } + if (arkts.isMethodDefinition(decl) && isMemoDeclaredMethod(decl)) { + return this.updateDeclaredMethodMemoCall(node, decl); + } + if (arkts.isMethodDefinition(decl) && isDeclaredMethodWithMemoParams(decl)) { + return this.updateDeclaredMethodMemoCall(node, decl, true); + } + if (arkts.isIdentifier(decl) && isMemoDeclaredIdentifier(decl)) { + return this.updateDeclaredCallWithName(node, decl.name); + } + if ( + arkts.isClassProperty(decl) && + isMemoDeclaredClassProperty(decl) && + !!decl.key && + arkts.isIdentifier(decl.key) + ) { + return this.updateDeclaredCallWithName(node, decl.key.name); + } + if (arkts.isEtsParameterExpression(decl) && isMemoETSParameterExpression(decl)) { + return this.updateDeclaredCallWithName(node, decl.identifier.name); + } + return this.updateCallExpressionWithNoDecl(node); + } + + private updateClassProperty(node: arkts.ClassProperty, key: arkts.Identifier): arkts.ClassProperty { + const scope = this.scopes[this.scopes.length - 1]; + const isValidScope = !!scope && scope.name === key.name; + if (!isValidScope) { + return node; + } + this.exitAnonymousScope(); + if (!scope.isMemo) { + return node; + } + + let res: arkts.ScriptFunction | undefined; + if (!!node.value && arkts.isArrowFunctionExpression(node.value)) { + this.enterAnonymousScope(node.value.scriptFunction); + res = this.updateScriptFunction(node.value.scriptFunction, key.name); + this.exitAnonymousScope(); + } + + let typeAnnotation: arkts.TypeNode | undefined; + if (!!node.typeAnnotation && !(typeAnnotation = factory.updateMemoTypeAnnotation(node.typeAnnotation))) { + console.error(`ETSFunctionType or ETSUnionType expected for @memo-property ${key.name}`); + throw 'Invalid @memo usage'; + } + + this.modified = true; + return arkts.factory.updateClassProperty( + node, + node.key, + res ? arkts.factory.updateArrowFunction(castArrowFunctionExpression(node.value), res) : undefined, + typeAnnotation, + node.modifiers, + node.isComputed + ); + } + + private updateTSTypeAliasDeclaration(node: arkts.TSTypeAliasDeclaration): arkts.TSTypeAliasDeclaration { + const scope = this.scopes[this.scopes.length - 1]; + const isValidScope = !!scope && scope.name === node.id?.name; + if (!isValidScope) { + return node; + } + this.exitAnonymousScope(); + if (!scope.isMemo) { + if (!!node.typeAnnotation) { + const newNode = arkts.factory.updateTSTypeAliasDeclaration( + node, + node.id, + node.typeParams, + this.signatureTransformer.visitor(node.typeAnnotation) + ); + this.modified ||= this.signatureTransformer.modified; + return newNode; + } + return node; + } + + let typeAnnotation: arkts.TypeNode | undefined; + if (!(typeAnnotation = factory.updateMemoTypeAnnotation(node.typeAnnotation))) { + console.error(`ETSFunctionType or ETSUnionType expected for @memo-type ${node.id!.name}`); + throw 'Invalid @memo usage'; + } + + this.modified = true; + return arkts.factory.updateTSTypeAliasDeclaration(node, node.id, node.typeParams, typeAnnotation); + } + + private updateStandaloneArrowFunction(node: arkts.ArrowFunctionExpression): arkts.ArrowFunctionExpression { + const scope = this.scopes[this.scopes.length - 1]; + const isValidScope = !!scope && scope.name === node.scriptFunction.id?.name; + if (!isValidScope) { + return node; + } + this.exitAnonymousScope(); + if (!scope.isMemo) { + return arkts.factory.updateArrowFunction(node, this.signatureTransformer.visitor(node.scriptFunction)); + } + + this.enterAnonymousScope(node.scriptFunction); + const res = this.updateScriptFunction(node.scriptFunction, node.scriptFunction.id?.name); + this.exitAnonymousScope(); + + this.modified = true; + return arkts.factory.updateArrowFunction(node, this.signatureTransformer.visitor(res)); + } + + private updateVariableDeclarator(node: arkts.VariableDeclarator): arkts.VariableDeclarator { + const scope = this.scopes[this.scopes.length - 1]; + const isValidScope = !!scope && scope.name === node.name.name; + if (!isValidScope) { + return node; + } + this.exitAnonymousScope(); + if (!scope.isMemo) { + if (!!node.initializer && arkts.isArrowFunctionExpression(node.initializer)) { + return arkts.factory.updateVariableDeclarator( + node, + node.flag, + node.name, + arkts.factory.updateArrowFunction( + node.initializer, + this.signatureTransformer.visitor(node.initializer.scriptFunction) + ) + ); + } + return node; + } + + let typeAnnotation: arkts.TypeNode | undefined; + if ( + !!node.name.typeAnnotation && + !(typeAnnotation = factory.updateMemoTypeAnnotation(node.name.typeAnnotation)) + ) { + console.error(`ETSFunctionType or ETSUnionType expected for @memo-variable-type ${node.name.name}`); + throw 'Invalid @memo usage'; + } + + let initializer: arkts.AstNode | undefined = node.initializer; + if (!!initializer && arkts.isArrowFunctionExpression(initializer)) { + this.enterAnonymousScope(initializer.scriptFunction); + const res = this.updateScriptFunction(initializer.scriptFunction, initializer.scriptFunction.id?.name); + this.exitAnonymousScope(); + initializer = arkts.factory.updateArrowFunction(initializer, res); + } + + this.modified = true; + return arkts.factory.updateVariableDeclarator( + node, + node.flag, + arkts.factory.updateIdentifier(node.name, node.name.name, typeAnnotation), + initializer + ); + } + + private updateTSAsExpression( + node: arkts.TSAsExpression, + expr: arkts.ArrowFunctionExpression + ): arkts.TSAsExpression { + const scope = this.scopes[this.scopes.length - 1]; + const isValidScope = !!scope; + if (!isValidScope) { + return node; + } + this.exitAnonymousScope(); + if (!scope.isMemo) { + return node; + } + + this.enterAnonymousScope(expr.scriptFunction); + const res = this.updateScriptFunction(expr.scriptFunction, expr.scriptFunction.id?.name); + this.exitAnonymousScope(); + + let typeAnnotation: arkts.TypeNode | undefined; + if (!(typeAnnotation = factory.updateMemoTypeAnnotation(node.typeAnnotation))) { + console.error(`ETSFunctionType or ETSUnionType expected for @memo-as-type`); + throw 'Invalid @memo usage'; + } + + this.modified = true; + return arkts.factory.updateTSAsExpression( + node, + arkts.factory.updateArrowFunction(expr, res), + typeAnnotation, + node.isConst + ); + } + + private updateProperty( + node: arkts.Property, + key: arkts.Identifier, + value: arkts.ArrowFunctionExpression + ): arkts.Property { + const scope = this.scopes[this.scopes.length - 1]; + const isValidScope = !!scope && scope.name === key.name; + if (!isValidScope) { + return node; + } + this.exitAnonymousScope(); + if (!scope.isMemo) { + return node; + } + + this.enterAnonymousScope(value.scriptFunction); + const res = this.updateScriptFunction(value.scriptFunction, value.scriptFunction.id?.name); + this.exitAnonymousScope(); + + this.modified = true; + return arkts.factory.updateProperty(node, key, arkts.factory.updateArrowFunction(value, res)); + } + + private updateThisAttributeAssignment( + node: arkts.AssignmentExpression, + thisAttribute: arkts.Identifier, + right: arkts.ArrowFunctionExpression + ): arkts.AssignmentExpression { + const scope = this.scopes[this.scopes.length - 1]; + const isValidScope = !!scope && scope.name === thisAttribute.name; + if (!isValidScope) { + return node; + } + this.exitAnonymousScope(); + if (!scope.isMemo) { + return node; + } + + this.enterAnonymousScope(right.scriptFunction); + const res = this.updateScriptFunction(right.scriptFunction, right.scriptFunction.id?.name); + this.exitAnonymousScope(); + + this.modified = true; + return arkts.factory.updateAssignmentExpression( + node, + node.left!, + node.operatorType, + arkts.factory.updateArrowFunction(right, res) + ); + } + + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + this.enter(beforeChildren); + const node = this.visitEachChild(beforeChildren); + this.exit(beforeChildren); + if (arkts.isMethodDefinition(node)) { + return this.updateMethodDefinition(node); + } + if (arkts.isCallExpression(node)) { + return this.updateCallExpression(node); + } + if (arkts.isClassProperty(node) && !!node.key && arkts.isIdentifier(node.key)) { + return this.updateClassProperty(node, node.key); + } + if (arkts.isTSTypeAliasDeclaration(node)) { + return this.updateTSTypeAliasDeclaration(node); + } + if (isStandaloneArrowFunction(node)) { + return this.updateStandaloneArrowFunction(node); + } + if (arkts.isVariableDeclarator(node)) { + return this.updateVariableDeclarator(node); + } + if (arkts.isTSAsExpression(node) && node.expr && arkts.isArrowFunctionExpression(node.expr)) { + return this.updateTSAsExpression(node, node.expr); + } + if (isFunctionProperty(node)) { + return this.updateProperty(node, castIdentifier(node.key), castArrowFunctionExpression(node.value)); + } + if (isThisAttributeAssignment(node) && !!node.right && arkts.isArrowFunctionExpression(node.right)) { + const thisAttribute = findThisAttribute(node.left!)!; + return this.updateThisAttributeAssignment(node, thisAttribute, node.right); + } + if (arkts.isEtsScript(node) && this.modified) { + factory.createContextTypesImportDeclaration(this.program); + } + return node; + } +} diff --git a/ets1.2/arkui-plugins/memo-plugins/import-transformer.ts b/ets1.2/arkui-plugins/memo-plugins/import-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..ac8adfaf0c7966288dbb5a8e5f86d63980a6fdd5 --- /dev/null +++ b/ets1.2/arkui-plugins/memo-plugins/import-transformer.ts @@ -0,0 +1,28 @@ +/* + * 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 '../common/abstract-visitor'; +import { factory } from './memo-factory'; + +export class ImportTransformer extends AbstractVisitor { + visitor(node: arkts.AstNode): arkts.AstNode { + if (node instanceof arkts.EtsScript) { + factory.createContextTypesImportDeclaration(arkts.arktsGlobal.compilerContext?.program); + return arkts.factory.updateEtsScript(node, node.statements); + } + return node; + } +} diff --git a/ets1.2/arkui-plugins/memo-plugins/index.ts b/ets1.2/arkui-plugins/memo-plugins/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..beb7edff90b4d6edc82e0fc0f20eeb6eb34d7488 --- /dev/null +++ b/ets1.2/arkui-plugins/memo-plugins/index.ts @@ -0,0 +1,116 @@ +/* + * 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 { Plugins, PluginContext } from '../common/plugin-context'; +import { FunctionTransformer } from './function-transformer'; +import { PositionalIdTracker } from './utils'; +import { ReturnTransformer } from './return-transformer'; +import { ParameterTransformer } from './parameter-transformer'; +import { ProgramVisitor } from '../common/program-visitor'; +import { EXTERNAL_SOURCE_PREFIX_NAMES, EXTERNAL_SOURCE_PREFIX_NAMES_FOR_FRAMEWORK } from '../common/predefines'; +import { debugDump, debugLog, getDumpFileName } from '../common/debug'; +import { SignatureTransformer } from './signature-transformer'; +import { InternalsTransformer } from './internal-transformer'; + +export function unmemoizeTransform(): Plugins { + return { + name: 'memo-plugin', + checked: checkedTransform, + clean() { + arkts.arktsGlobal.clearContext(); + }, + }; +} + +function checkedTransform(this: PluginContext): arkts.EtsScript | undefined { + console.log('[MEMO PLUGIN] AFTER CHECKED ENTER'); + const contextPtr = arkts.arktsGlobal.compilerContext?.peer ?? this.getContextPtr(); + if (!!contextPtr) { + let program = arkts.getOrUpdateGlobalContext(contextPtr).program; + let script = program.astNode; + debugLog('[BEFORE MEMO SCRIPT] script: ', script.dumpSrc()); + const cachePath: string | undefined = this.getProjectConfig()?.cachePath; + const isFrameworkMode = !!this.getProjectConfig()?.frameworkMode; + const canSkipPhases = false; + debugDump( + script.dumpSrc(), + getDumpFileName(0, 'SRC', 5, 'MEMO_AfterCheck_Begin'), + true, + cachePath, + program.programFileNameWithExtension + ); + arkts.Performance.getInstance().createEvent('memo-checked'); + program = checkedProgramVisit(program, this, canSkipPhases, isFrameworkMode); + script = program.astNode; + arkts.Performance.getInstance().stopEvent('memo-checked', true); + debugLog('[AFTER MEMO SCRIPT] script: ', script.dumpSrc()); + debugDump( + script.dumpSrc(), + getDumpFileName(0, 'SRC', 6, 'MEMO_AfterCheck_End'), + true, + cachePath, + program.programFileNameWithExtension + ); + arkts.Performance.getInstance().createEvent('memo-recheck'); + arkts.recheckSubtree(script); + arkts.Performance.getInstance().stopEvent('memo-recheck', true); + arkts.Performance.getInstance().clearAllEvents(); + this.setArkTSAst(script); + console.log('[MEMO PLUGIN] AFTER CHECKED EXIT'); + return script; + } + console.log('[MEMO PLUGIN] AFTER CHECKED EXIT WITH NO TRANSFORM'); + return undefined; +} + +function checkedProgramVisit( + program: arkts.Program, + pluginContext: PluginContext, + canSkipPhases: boolean = false, + isFrameworkMode: boolean = false +): arkts.Program { + if (canSkipPhases) { + debugLog('[SKIP PHASE] phase: memo-checked, moduleName: ', program?.moduleName); + } else { + debugLog('[CANT SKIP PHASE] phase: memo-checked, moduleName: ', program?.moduleName); + const positionalIdTracker = new PositionalIdTracker(arkts.getFileName(), false); + const parameterTransformer = new ParameterTransformer({ + positionalIdTracker, + }); + const returnTransformer = new ReturnTransformer(); + const signatureTransformer = new SignatureTransformer(); + const internalsTransformer = new InternalsTransformer({ positionalIdTracker }); + const functionTransformer = new FunctionTransformer({ + positionalIdTracker, + parameterTransformer, + returnTransformer, + signatureTransformer, + internalsTransformer + }); + const skipPrefixNames = isFrameworkMode + ? EXTERNAL_SOURCE_PREFIX_NAMES_FOR_FRAMEWORK + : EXTERNAL_SOURCE_PREFIX_NAMES; + const programVisitor = new ProgramVisitor({ + pluginName: unmemoizeTransform.name, + state: arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED, + visitors: [functionTransformer], + skipPrefixNames, + pluginContext, + }); + program = programVisitor.programVisitor(program); + } + return program; +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/memo-plugins/internal-transformer.ts b/ets1.2/arkui-plugins/memo-plugins/internal-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..7419778b2b8c3acd75aba8708335ecc942ec2385 --- /dev/null +++ b/ets1.2/arkui-plugins/memo-plugins/internal-transformer.ts @@ -0,0 +1,49 @@ +/* + * 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 { RuntimeNames, PositionalIdTracker } from './utils'; +import { AbstractVisitor, VisitorOptions } from '../common/abstract-visitor'; + +export interface InternalsTransformerOptions extends VisitorOptions { + positionalIdTracker: PositionalIdTracker; +} + +export class InternalsTransformer extends AbstractVisitor { + private readonly positionalIdTracker: PositionalIdTracker; + + constructor(options: InternalsTransformerOptions) { + super(options); + this.positionalIdTracker = options.positionalIdTracker; + } + + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + const node = this.visitEachChild(beforeChildren); + if (arkts.isCallExpression(node)) { + if (arkts.isIdentifier(node.expression)) { + if (node.expression.name === RuntimeNames.__CONTEXT) { + return arkts.factory.createIdentifier(RuntimeNames.CONTEXT, undefined); + } + if (node.expression.name === RuntimeNames.__ID) { + return arkts.factory.createIdentifier(RuntimeNames.ID, undefined); + } + if (node.expression.name === RuntimeNames.__KEY) { + return this.positionalIdTracker.id(RuntimeNames.__KEY); + } + } + } + return node; + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/memo-plugins/memo-factory.ts b/ets1.2/arkui-plugins/memo-plugins/memo-factory.ts new file mode 100644 index 0000000000000000000000000000000000000000..dac88684374e48b3817e50afb24106ae8218d262 --- /dev/null +++ b/ets1.2/arkui-plugins/memo-plugins/memo-factory.ts @@ -0,0 +1,400 @@ +/* + * 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 { + fixGensymParams, + buildeParamInfos, + isUnmemoizedInFunction, + mayAddLastReturn, + ParamInfo, + ReturnTypeInfo, + RuntimeNames, + parametrizedNodeHasReceiver +} from './utils'; +import { moveToFront } from '../common/arkts-utils'; + +export class factory { + // Importing + static createContextTypeImportSpecifier(): arkts.ImportSpecifier { + return arkts.factory.createImportSpecifier( + arkts.factory.createIdentifier(RuntimeNames.CONTEXT_TYPE), + arkts.factory.createIdentifier(RuntimeNames.CONTEXT_TYPE) + ); + } + static createIdTypeImportSpecifier(): arkts.ImportSpecifier { + return arkts.factory.createImportSpecifier( + arkts.factory.createIdentifier(RuntimeNames.ID_TYPE), + arkts.factory.createIdentifier(RuntimeNames.ID_TYPE) + ); + } + + static createContextTypesImportDeclaration(program?: arkts.Program): void { + const source: arkts.StringLiteral = arkts.factory.createStringLiteral(RuntimeNames.MEMO_IMPORT_NAME); + const importDecl: arkts.ETSImportDeclaration = arkts.factory.createImportDeclaration( + source, + [factory.createContextTypeImportSpecifier(), factory.createIdTypeImportSpecifier()], + arkts.Es2pandaImportKinds.IMPORT_KINDS_TYPE, + program!, + arkts.Es2pandaImportFlags.IMPORT_FLAGS_NONE + ); + // Insert this import at the top of the script's statements. + if (!program) { + throw Error('Failed to insert import: Transformer has no program'); + } + arkts.importDeclarationInsert(importDecl, program); + return; + } + + // Parameters + static createContextParameter(): arkts.ETSParameterExpression { + return arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier( + RuntimeNames.CONTEXT, + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier(RuntimeNames.CONTEXT_TYPE)) + ) + ), + undefined + ); + } + static createIdParameter(): arkts.ETSParameterExpression { + return arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier( + RuntimeNames.ID, + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier(RuntimeNames.ID_TYPE)) + ) + ), + undefined + ); + } + static createHiddenParameters(): arkts.ETSParameterExpression[] { + return [factory.createContextParameter(), factory.createIdParameter()]; + } + static createHiddenParameterIfNotAdded( + params: readonly arkts.Expression[], + hasReceiver: boolean = false + ): readonly arkts.Expression[] { + const _params = params ?? []; + if (isUnmemoizedInFunction(_params)) { + return _params; + } + let newParams: arkts.Expression[] = [...factory.createHiddenParameters(), ..._params]; + if (hasReceiver) { + newParams = moveToFront(newParams, 2); + } + return newParams; + } + static updateFunctionTypeWithMemoParameters(type: arkts.ETSFunctionType): arkts.ETSFunctionType { + return arkts.factory.updateFunctionType( + type, + arkts.factory.createFunctionSignature( + undefined, + factory.createHiddenParameterIfNotAdded(type.params), + type.returnType, + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW + ); + } + static updateScriptFunctionWithMemoParameters( + func: arkts.ScriptFunction, + newBody?: arkts.AstNode | undefined, + returnType?: arkts.TypeNode | undefined + ): arkts.ScriptFunction { + return arkts.factory.updateScriptFunction( + func, + newBody ?? func.body, + arkts.factory.createFunctionSignature( + func.typeParams, + factory.createHiddenParameterIfNotAdded(func.params, parametrizedNodeHasReceiver(func)), + returnType ?? func.returnTypeAnnotation, + func.hasReceiver + ), + func.flags, + func.modifiers + ); + } + + // Arguments + static createContextArgument(): arkts.AstNode { + return arkts.factory.createIdentifier(RuntimeNames.CONTEXT); + } + static createIdArgument(hash: arkts.NumberLiteral | arkts.StringLiteral): arkts.AstNode { + return arkts.factory.createBinaryExpression( + arkts.factory.createIdentifier(RuntimeNames.ID), + hash, + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_PLUS + ); + } + static createHiddenArguments(hash: arkts.NumberLiteral | arkts.StringLiteral): arkts.AstNode[] { + return [factory.createContextArgument(), factory.createIdArgument(hash)]; + } + + // Memo parameters + static createMemoParameterIdentifier(name: string): arkts.Identifier { + if (name === RuntimeNames.EQUAL_T) { + return arkts.factory.createIdentifier(`${RuntimeNames.PARAMETER}_${RuntimeNames.THIS}`, undefined); + } + return arkts.factory.createIdentifier(`${RuntimeNames.PARAMETER}_${name}`); + } + static createMemoParameterDeclarator(id: number, name: string): arkts.VariableDeclarator { + const originalIdent = + name === RuntimeNames.THIS || name === RuntimeNames.EQUAL_T + ? arkts.factory.createThisExpression() + : arkts.factory.createIdentifier(name, undefined); + return arkts.factory.createVariableDeclarator( + arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_CONST, + factory.createMemoParameterIdentifier(name), + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(RuntimeNames.SCOPE), + arkts.factory.createIdentifier(RuntimeNames.INTERNAL_PARAMETER_STATE), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + [arkts.factory.createNumericLiteral(id), originalIdent] + ) + ); + } + static createMemoParameterDeclaration(parameters: string[]): arkts.VariableDeclaration { + return arkts.factory.createVariableDeclaration( + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_CONST, + parameters.map((name, id) => { + return factory.createMemoParameterDeclarator(id, name); + }) + ); + } + static createMemoParameterAccess(name: string): arkts.MemberExpression { + return arkts.factory.createMemberExpression( + factory.createMemoParameterIdentifier(name), + arkts.factory.createIdentifier(RuntimeNames.VALUE), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_GETTER, + false, + false + ); + } + static createMemoParameterAccessCall(name: string, passArgs?: arkts.AstNode[]): arkts.CallExpression { + const updatedArgs = passArgs ? passArgs : []; + return arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + factory.createMemoParameterIdentifier(name), + arkts.factory.createIdentifier(RuntimeNames.VALUE), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_GETTER, + false, + false + ), + undefined, + [...updatedArgs] + ); + } + + // Recache + static createScopeDeclaration( + returnTypeAnnotation: arkts.TypeNode | undefined, + hash: arkts.NumberLiteral | arkts.StringLiteral, + cnt: number + ): arkts.VariableDeclaration { + return arkts.factory.createVariableDeclaration( + 0, + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_CONST, + [ + 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 + ), + returnTypeAnnotation + ? [returnTypeAnnotation] + : [arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID)], + [factory.createIdArgument(hash), arkts.factory.createNumericLiteral(cnt)] + ) + ), + ] + ); + } + static createRecacheCall(arg?: arkts.AstNode): arkts.CallExpression { + return 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, + arg ? [arg] : undefined + ); + } + static createReturnThis(): arkts.BlockStatement { + return arkts.factory.createBlock([ + arkts.factory.createExpressionStatement(factory.createRecacheCall()), + arkts.factory.createReturnStatement(arkts.factory.createThisExpression()), + ]); + } + static createSyntheticReturnStatement(stableThis: boolean): arkts.ReturnStatement | arkts.BlockStatement { + if (!stableThis) { + return 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 + ) + ); + } + return arkts.factory.createBlock([ + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(RuntimeNames.SCOPE), + arkts.factory.createIdentifier(RuntimeNames.INTERNAL_VALUE), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_NONE, + false, + false + ), + arkts.factory.createReturnStatement(arkts.factory.createThisExpression()), + ]); + } + static createIfStatementWithSyntheticReturnStatement( + syntheticReturnStatement: arkts.ReturnStatement | arkts.BlockStatement, + isVoidValue: boolean + ): arkts.IfStatement { + let returnStatement = syntheticReturnStatement; + if (isVoidValue && arkts.isReturnStatement(syntheticReturnStatement)) { + returnStatement = arkts.factory.createBlock([ + arkts.factory.createExpressionStatement(syntheticReturnStatement.argument!), + arkts.factory.createReturnStatement(), + ]); + } + return 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 + ), + returnStatement + ); + } + + // Compute + static createLambdaWrapper(node: arkts.Expression): arkts.ArrowFunctionExpression { + return arkts.factory.createArrowFunction( + arkts.factory.createScriptFunction( + arkts.factory.createBlock([arkts.factory.createReturnStatement(node)]), + arkts.factory.createFunctionSignature(undefined, [], undefined, false), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE + ) + ); + } + static createComputeExpression( + hash: arkts.NumberLiteral | arkts.StringLiteral, + node: arkts.Expression + ): arkts.CallExpression { + return arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(RuntimeNames.CONTEXT), + arkts.factory.createIdentifier(RuntimeNames.COMPUTE), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + [factory.createIdArgument(hash), factory.createLambdaWrapper(node)] + ); + } + + static updateFunctionBody( + node: arkts.BlockStatement, + parameters: arkts.ETSParameterExpression[], + returnTypeInfo: ReturnTypeInfo, + hash: arkts.NumberLiteral | arkts.StringLiteral + ): [ + arkts.BlockStatement, + ParamInfo[], + arkts.VariableDeclaration | undefined, + arkts.ReturnStatement | arkts.BlockStatement | undefined + ] { + const paramInfos = buildeParamInfos(parameters); + const gensymParamsCount = fixGensymParams(paramInfos, node); + const parameterNames = paramInfos.map((it) => it.ident.name); + const scopeDeclaration = factory.createScopeDeclaration(returnTypeInfo.node, hash, parameterNames.length); + const memoParametersDeclaration = parameterNames.length + ? factory.createMemoParameterDeclaration(parameterNames) + : undefined; + const syntheticReturnStatement = factory.createSyntheticReturnStatement(!!returnTypeInfo.isStableThis); + const isVoidValue = !!returnTypeInfo.isVoid; + const unchangedCheck = factory.createIfStatementWithSyntheticReturnStatement( + syntheticReturnStatement, + isVoidValue + ); + return [ + arkts.factory.updateBlock(node, [ + ...node.statements.slice(0, gensymParamsCount), + scopeDeclaration, + ...(memoParametersDeclaration ? [memoParametersDeclaration] : []), + unchangedCheck, + ...node.statements.slice(gensymParamsCount), + ...(mayAddLastReturn(node) ? [arkts.factory.createReturnStatement()] : []), + ]), + paramInfos, + memoParametersDeclaration, + syntheticReturnStatement, + ]; + } + + static updateMemoTypeAnnotation(typeAnnotation: arkts.AstNode | undefined): arkts.TypeNode | undefined { + if (!typeAnnotation || !arkts.isTypeNode(typeAnnotation)) { + return undefined; + } + + if (arkts.isETSFunctionType(typeAnnotation)) { + return factory.updateFunctionTypeWithMemoParameters(typeAnnotation); + } else if (arkts.isETSUnionType(typeAnnotation)) { + return arkts.factory.updateUnionType( + typeAnnotation, + typeAnnotation.types.map((it) => { + if (arkts.isETSFunctionType(it)) { + return factory.updateFunctionTypeWithMemoParameters(it); + } + return it; + }) + ); + } + return typeAnnotation; + } + + static insertHiddenArgumentsToCall( + node: arkts.CallExpression, + hash: arkts.NumberLiteral | arkts.StringLiteral + ): arkts.CallExpression { + return arkts.factory.updateCallExpression(node, node.expression, node.typeArguments, [ + ...factory.createHiddenArguments(hash), + ...node.arguments, + ]); + } +} diff --git a/ets1.2/arkui-plugins/memo-plugins/memo-transformer.ts b/ets1.2/arkui-plugins/memo-plugins/memo-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..430148fc230277aa308876ed0f3b0ad16e67a63f --- /dev/null +++ b/ets1.2/arkui-plugins/memo-plugins/memo-transformer.ts @@ -0,0 +1,50 @@ +/* + * 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 { FunctionTransformer } from './function-transformer'; +import { PositionalIdTracker } from './utils'; +import { factory } from './memo-factory'; +import { ReturnTransformer } from './return-transformer'; +import { ParameterTransformer } from './parameter-transformer'; +import { EtsglobalRemover } from '../common/etsglobal-remover'; +import { SignatureTransformer } from './signature-transformer'; + +export interface TransformerOptions { + trace?: boolean; + removeEtsglobal?: boolean; +} + +export default function memoTransformer(userPluginOptions?: TransformerOptions) { + return (node0: arkts.EtsScript) => { + const node = ( + userPluginOptions?.removeEtsglobal ? new EtsglobalRemover().visitor(node0) : node0 + ) as arkts.EtsScript; + const positionalIdTracker = new PositionalIdTracker(arkts.getFileName(), false); + const parameterTransformer = new ParameterTransformer({ + positionalIdTracker, + }); + const returnTransformer = new ReturnTransformer(); + const signatureTransformer = new SignatureTransformer(); + const functionTransformer = new FunctionTransformer({ + positionalIdTracker, + parameterTransformer, + returnTransformer, + signatureTransformer, + }); + factory.createContextTypesImportDeclaration(arkts.arktsGlobal.compilerContext?.program); + return functionTransformer.visitor(arkts.factory.updateEtsScript(node, node.statements)); + }; +} diff --git a/ets1.2/arkui-plugins/memo-plugins/parameter-transformer.ts b/ets1.2/arkui-plugins/memo-plugins/parameter-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..050333da7749d6da1d5fb8aca1a31c7f47fc85e8 --- /dev/null +++ b/ets1.2/arkui-plugins/memo-plugins/parameter-transformer.ts @@ -0,0 +1,309 @@ +/* + * 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 { factory } from './memo-factory'; +import { AbstractVisitor, VisitorOptions } from '../common/abstract-visitor'; +import { + buildReturnTypeInfo, + castParameters, + findReturnTypeFromTypeAnnotation, + isMemoETSParameterExpression, + isMemoParametersDeclaration, + isUnmemoizedInFunction, + isVoidType, + MemoInfo, + ParamInfo, + PositionalIdTracker, + ReturnTypeInfo, + RuntimeNames, +} from './utils'; +import { ReturnTransformer } from './return-transformer'; + +export interface ParameterTransformerOptions extends VisitorOptions { + positionalIdTracker: PositionalIdTracker; +} + +interface RewriteMemoInfo extends MemoInfo { + rewritePeer: number; +} + +export class ParameterTransformer extends AbstractVisitor { + private rewriteIdentifiers?: Map arkts.MemberExpression | arkts.Identifier>; + private rewriteCalls?: Map arkts.CallExpression>; + private rewriteMemoInfos?: Map; + private rewriteThis?: boolean; + private skipNode?: arkts.VariableDeclaration; + private visited: Set; + + private positionalIdTracker: PositionalIdTracker; + + constructor(options: ParameterTransformerOptions) { + super(options); + this.positionalIdTracker = options.positionalIdTracker; + this.visited = new Set(); + } + + reset(): void { + super.reset(); + this.rewriteIdentifiers = undefined; + this.rewriteCalls = undefined; + this.rewriteMemoInfos = undefined; + this.skipNode = undefined; + this.visited.clear(); + } + + withThis(flag: boolean): ParameterTransformer { + this.rewriteThis = flag; + return this; + } + + withParameters(parameters: ParamInfo[]): ParameterTransformer { + this.rewriteCalls = new Map( + parameters + .filter( + (it) => + it.param.type && (arkts.isETSFunctionType(it.param.type) || arkts.isETSUnionType(it.param.type)) + ) + .map((it) => { + return [ + it.param.identifier.name.startsWith(RuntimeNames.GENSYM) + ? it.ident.originalPeer + : it.param.originalPeer, + (passArgs: arkts.Expression[]): arkts.CallExpression => { + return factory.createMemoParameterAccessCall(it.ident.name, passArgs); + }, + ]; + }) + ); + this.rewriteIdentifiers = new Map( + parameters.map((it) => { + return [ + it.param.identifier.name.startsWith(RuntimeNames.GENSYM) + ? it.ident.originalPeer + : it.param.originalPeer, + (): arkts.MemberExpression => { + return factory.createMemoParameterAccess(it.ident.name); + }, + ]; + }) + ); + this.rewriteMemoInfos = new Map( + parameters.map((it) => { + return [ + it.param.identifier.name.startsWith(RuntimeNames.GENSYM) + ? it.ident.originalPeer + : it.param.originalPeer, + { + name: it.param.identifier.name, + rewritePeer: it.param.identifier.originalPeer, + isMemo: isMemoETSParameterExpression(it.param), + }, + ]; + }) + ); + return this; + } + + skip(memoParametersDeclaration?: arkts.VariableDeclaration): ParameterTransformer { + this.skipNode = memoParametersDeclaration; + return this; + } + + track(node: arkts.AstNode | undefined): void { + if (!!node?.peer) { + this.visited.add(node.peer); + } + } + + isTracked(node: arkts.AstNode | undefined): boolean { + return !!node?.peer && this.visited.has(node.peer); + } + + private updateArrowFunctionFromVariableDeclareInit( + initializer: arkts.ArrowFunctionExpression, + returnType: arkts.TypeNode | undefined + ): arkts.ArrowFunctionExpression { + const scriptFunction = initializer.scriptFunction; + if (!scriptFunction.body || !arkts.isBlockStatement(scriptFunction.body)) { + return initializer; + } + if (isUnmemoizedInFunction(scriptFunction.params)) { + return initializer; + } + const returnTypeInfo: ReturnTypeInfo = buildReturnTypeInfo( + returnType ?? scriptFunction.returnTypeAnnotation, + true + ); + const [body, parameterIdentifiers, memoParametersDeclaration, syntheticReturnStatement] = + factory.updateFunctionBody( + scriptFunction.body, + castParameters(scriptFunction.params), + returnTypeInfo, + this.positionalIdTracker.id() + ); + const paramaterTransformer = new ParameterTransformer({ + positionalIdTracker: this.positionalIdTracker, + }); + const returnTransformer = new ReturnTransformer(); + const afterParameterTransformer = paramaterTransformer + .withParameters(parameterIdentifiers) + .skip(memoParametersDeclaration) + .visitor(body); + const afterReturnTransformer = returnTransformer + .skip(syntheticReturnStatement) + .registerReturnTypeInfo(returnTypeInfo) + .visitor(afterParameterTransformer); + const updateScriptFunction = factory.updateScriptFunctionWithMemoParameters( + scriptFunction, + afterReturnTransformer, + returnTypeInfo.node + ); + paramaterTransformer.reset(); + returnTransformer.reset(); + this.track(updateScriptFunction.body); + return arkts.factory.updateArrowFunction(initializer, updateScriptFunction); + } + + private updateVariableDeclareInit( + initializer: T | undefined, + returnType: arkts.TypeNode | undefined + ): T | undefined { + if (!initializer) { + return undefined; + } + if (arkts.isConditionalExpression(initializer)) { + return arkts.factory.updateConditionalExpression( + initializer, + initializer.test, + this.updateVariableDeclareInit(initializer.consequent, returnType), + this.updateVariableDeclareInit(initializer.alternate, returnType) + ) as unknown as T; + } + if (arkts.isTSAsExpression(initializer)) { + return arkts.factory.updateTSAsExpression( + initializer, + this.updateVariableDeclareInit(initializer.expr, returnType), + factory.updateMemoTypeAnnotation(initializer.typeAnnotation), + initializer.isConst + ) as unknown as T; + } + if (arkts.isArrowFunctionExpression(initializer)) { + return this.updateArrowFunctionFromVariableDeclareInit(initializer, returnType) as unknown as T; + } + return initializer; + } + + private updateParamReDeclare(node: arkts.VariableDeclarator, memoInfo: RewriteMemoInfo): arkts.VariableDeclarator { + const shouldUpdate: boolean = node.name.name !== memoInfo.name && memoInfo.isMemo; + if (!shouldUpdate) { + return node; + } + const decl = arkts.getPeerDecl(memoInfo.rewritePeer); + if (!decl || !arkts.isEtsParameterExpression(decl)) { + return node; + } + + let typeAnnotation: arkts.TypeNode | undefined; + if ( + !!node.name.typeAnnotation && + !(typeAnnotation = factory.updateMemoTypeAnnotation(node.name.typeAnnotation)) + ) { + console.error(`ETSFunctionType or ETSUnionType expected for @memo-variable-type ${node.name.name}`); + throw 'Invalid @memo usage'; + } + + const returnType = findReturnTypeFromTypeAnnotation(decl.type); + return arkts.factory.updateVariableDeclarator( + node, + node.flag, + arkts.factory.updateIdentifier(node.name, node.name.name, typeAnnotation), + this.updateVariableDeclareInit(node.initializer, returnType) + ); + } + + private updateVariableReDeclarationFromParam(node: arkts.VariableDeclaration): arkts.VariableDeclaration { + return arkts.factory.updateVariableDeclaration( + node, + node.modifiers, + node.declarationKind, + node.declarators.map((declarator) => { + if (this.rewriteMemoInfos?.has(declarator.name.originalPeer)) { + const memoInfo = this.rewriteMemoInfos.get(declarator.name.originalPeer)!; + return this.updateParamReDeclare(declarator, memoInfo); + } + if (!!declarator.initializer && arkts.isIdentifier(declarator.initializer)) { + const decl = arkts.getPeerDecl(declarator.initializer.originalPeer); + if (decl && this.rewriteIdentifiers?.has(decl.peer)) { + return arkts.factory.updateVariableDeclarator( + declarator, + declarator.flag, + declarator.name, + this.rewriteIdentifiers.get(decl.peer)!() + ); + } + } + return declarator; + }) + ); + } + + private updateCallReDeclare( + node: arkts.CallExpression, + oriName: arkts.Identifier, + memoInfo: RewriteMemoInfo + ): arkts.CallExpression { + const shouldUpdate: boolean = oriName.name !== memoInfo.name && memoInfo.isMemo; + if (!shouldUpdate) { + return node; + } + return factory.insertHiddenArgumentsToCall(node, this.positionalIdTracker.id(oriName.name)); + } + + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + // TODO: temporary checking skip nodes by comparison with expected skip nodes + // Should be fixed when update procedure implemented properly + if (/* beforeChildren === this.skipNode */ isMemoParametersDeclaration(beforeChildren)) { + return beforeChildren; + } + if (arkts.isVariableDeclaration(beforeChildren)) { + return this.updateVariableReDeclarationFromParam(beforeChildren); + } + if (arkts.isCallExpression(beforeChildren) && arkts.isIdentifier(beforeChildren.expression)) { + const decl = arkts.getPeerDecl(beforeChildren.expression.originalPeer); + if (decl && this.rewriteCalls?.has(decl.peer)) { + const updateCall = this.rewriteCalls.get(decl.peer)!( + beforeChildren.arguments.map((it) => this.visitor(it) as arkts.Expression) + ); + if (this.rewriteMemoInfos?.has(decl.peer)) { + const memoInfo = this.rewriteMemoInfos.get(decl.peer)!; + return this.updateCallReDeclare(updateCall, beforeChildren.expression, memoInfo); + } + return updateCall; + } + } + const node = this.visitEachChild(beforeChildren); + if (arkts.isIdentifier(node)) { + const decl = arkts.getPeerDecl(node.originalPeer); + if (decl && this.rewriteIdentifiers?.has(decl.peer)) { + return this.rewriteIdentifiers.get(decl.peer)!(); + } + } + if (arkts.isThisExpression(node) && this.rewriteThis) { + return factory.createMemoParameterAccess(RuntimeNames.THIS); + } + return node; + } +} diff --git a/ets1.2/arkui-plugins/memo-plugins/return-transformer.ts b/ets1.2/arkui-plugins/memo-plugins/return-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..c2c0fac2e6033aca90d5fce9060020b0286a4ebb --- /dev/null +++ b/ets1.2/arkui-plugins/memo-plugins/return-transformer.ts @@ -0,0 +1,85 @@ +/* + * 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 { factory } from './memo-factory'; +import { AbstractVisitor } from '../common/abstract-visitor'; +import { isSyntheticReturnStatement, ReturnTypeInfo } from './utils'; + +export class ReturnTransformer extends AbstractVisitor { + private skipNode?: arkts.ReturnStatement | arkts.BlockStatement; + private stableThis: boolean = false; + private returnTypeInfo: ReturnTypeInfo | undefined; + + reset() { + super.reset(); + this.skipNode = undefined; + this.stableThis = false; + this.returnTypeInfo = undefined; + } + + skip(syntheticReturnStatement?: arkts.ReturnStatement | arkts.BlockStatement): ReturnTransformer { + this.skipNode = syntheticReturnStatement; + return this; + } + + rewriteThis(stableThis: boolean): ReturnTransformer { + this.stableThis = stableThis; + return this; + } + + registerReturnTypeInfo(returnTypeInfo: ReturnTypeInfo): ReturnTransformer { + this.returnTypeInfo = returnTypeInfo; + return this; + } + + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + // TODO: temporary checking skip nodes by comparison with expected skip nodes + // Should be fixed when update procedure implemented properly + if (/* beforeChildren === this.skipNode */ isSyntheticReturnStatement(beforeChildren)) { + return beforeChildren; + } + if (arkts.isScriptFunction(beforeChildren)) { + return beforeChildren; + } + const node = this.visitEachChild(beforeChildren); + if (arkts.isReturnStatement(node)) { + if (this.stableThis && node.argument && arkts.isThisExpression(node.argument)) { + return factory.createReturnThis(); + } + if (node.argument === undefined) { + return arkts.factory.createBlock([ + arkts.factory.createExpressionStatement(factory.createRecacheCall()), + node, + ]); + } + + let argument = node.argument; + if ( + !!this.returnTypeInfo?.node && + this.returnTypeInfo.isMemo && + arkts.isArrowFunctionExpression(argument) + ) { + argument = arkts.factory.updateArrowFunction( + argument, + factory.updateScriptFunctionWithMemoParameters(argument.scriptFunction) + ); + } + + return arkts.factory.updateReturnStatement(node, factory.createRecacheCall(argument)); + } + return node; + } +} diff --git a/ets1.2/arkui-plugins/memo-plugins/signature-transformer.ts b/ets1.2/arkui-plugins/memo-plugins/signature-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..b7fa8a62d37b9500e7e334a9cf66ee816279e993 --- /dev/null +++ b/ets1.2/arkui-plugins/memo-plugins/signature-transformer.ts @@ -0,0 +1,148 @@ +/* + * 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 { factory } from './memo-factory'; +import { + hasMemoAnnotation, + hasMemoIntrinsicAnnotation, + parametrizedNodeHasReceiver, + isMemoTSTypeAliasDeclaration, +} from './utils'; +import { AbstractVisitor } from '../common/abstract-visitor'; + +function isScriptFunctionFromGetter(node: arkts.ScriptFunction): boolean { + return ( + !!node.parent && + !!node.parent.parent && + arkts.isFunctionExpression(node.parent) && + arkts.isMethodDefinition(node.parent.parent) && + node.parent.parent.kind === arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_GET + ); +} + +function isScriptFunctionFromSetter(node: arkts.ScriptFunction): boolean { + return ( + !!node.parent && + !!node.parent.parent && + arkts.isFunctionExpression(node.parent) && + arkts.isMethodDefinition(node.parent.parent) && + node.parent.parent.kind === arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_SET + ); +} + +export class SignatureTransformer extends AbstractVisitor { + /* Tracking whether should import `__memo_context_type` and `__memo_id_type` */ + public modified = false; + + reset(): void { + super.reset(); + this.modified = false; + } + + visitor(node: T, applyMemo: boolean = false): T { + if (arkts.isScriptFunction(node)) { + const memo = hasMemoAnnotation(node) || hasMemoIntrinsicAnnotation(node) || applyMemo; + if (memo) { + this.modified = true; + } + const isFromGetter = isScriptFunctionFromGetter(node); + const isFromSetter = isScriptFunctionFromSetter(node); + const shouldAddMemoParam = memo && !isFromGetter && !isFromSetter; + const shouldApplyMemoToParamExpr = memo && isFromSetter; + const shouldApplyMemoToReturnType = memo && isFromGetter; + const newParams = node.params.map((it) => this.visitor(it, shouldApplyMemoToParamExpr)); + return arkts.factory.updateScriptFunction( + node, + node.body, + arkts.factory.createFunctionSignature( + node.typeParams, + shouldAddMemoParam + ? factory.createHiddenParameterIfNotAdded(newParams, parametrizedNodeHasReceiver(node)) + : newParams, + node.returnTypeAnnotation + ? this.visitor(node.returnTypeAnnotation, shouldApplyMemoToReturnType) + : memo + ? arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID) + : undefined, + node.hasReceiver + ), + node.flags, + node.modifiers + ) as any as T; + } + if (arkts.isEtsParameterExpression(node)) { + const memo = hasMemoAnnotation(node) || hasMemoIntrinsicAnnotation(node) || applyMemo; + if (!node.type) { + if (memo) { + console.error(`@memo parameter ${node.identifier.name} without type annotatation`); + throw 'Invalid @memo usage'; + } + return node; + } + node.type = this.visitor(node.type, memo); + return node as any as T; + } + if (arkts.isETSFunctionType(node)) { + const memo = hasMemoAnnotation(node) || hasMemoIntrinsicAnnotation(node) || applyMemo; + if (memo) { + this.modified = true; + } + const newParams = node.params.map((it) => this.visitor(it)); + return arkts.factory.updateFunctionType( + node, + arkts.factory.createFunctionSignature( + undefined, + memo ? factory.createHiddenParameterIfNotAdded(newParams) : newParams, + this.visitor(node.returnType!), + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW + ) as any as T; + } + if (arkts.isETSUnionType(node)) { + return arkts.factory.updateUnionType( + node, + node.types.map((it) => this.visitor(it, applyMemo)) + ) as any as T; + } + if (arkts.isETSUndefinedType(node)) { + return node as any as T; + } + if (arkts.isETSTypeReference(node) && applyMemo) { + if (!node.part || !node.part.name) { + console.error(`@memo parameter has no type reference`); + throw 'Invalid @memo usage'; + } + const expr = node.part.name; + const decl = arkts.getDecl(expr); + if (!decl || !arkts.isTSTypeAliasDeclaration(decl)) { + console.error(`@memo parameter's type has not been declared`); + throw 'Invalid @memo usage'; + } + const memoDecl = isMemoTSTypeAliasDeclaration(decl); + if (memoDecl) { + return node as any as T; + } + console.error(`@memo parameter type reference has no @memo type declaration`); + throw 'Invalid @memo usage'; + } + if (applyMemo) { + console.error(`@memo parameter's signature has invalid type`); + throw 'Invalid @memo usage'; + } + return node; + } +} diff --git a/ets1.2/arkui-plugins/memo-plugins/utils.ts b/ets1.2/arkui-plugins/memo-plugins/utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..2e193d099085ca1e0cf1c7c70a3cbca44bebfc5b --- /dev/null +++ b/ets1.2/arkui-plugins/memo-plugins/utils.ts @@ -0,0 +1,591 @@ +/* + * 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 { getCommonPath } from '../path'; +const common = require(getCommonPath()); +const UniqueId = common.UniqueId; + +export enum RuntimeNames { + __CONTEXT = '__context', + __ID = '__id', + __KEY = '__key', + ANNOTATION_BUILDER = 'Builder', + ANNOTATION = 'memo', + ANNOTATION_ENTRY = 'memo_entry', + ANNOTATION_INTRINSIC = 'memo_intrinsic', + ANNOTATION_STABLE = 'memo_stable', + ANNOTATION_SKIP = 'memo_skip', + COMPUTE = 'compute', + CONTEXT = '__memo_context', + CONTEXT_TYPE = '__memo_context_type', + MEMO_IMPORT_NAME = 'arkui.stateManagement.runtime', + GENSYM = 'gensym%%_', + ID = '__memo_id', + ID_TYPE = '__memo_id_type', + INTERNAL_PARAMETER_STATE = 'param', + INTERNAL_SCOPE = 'scope', + INTERNAL_VALUE = 'cached', + INTERNAL_VALUE_NEW = 'recache', + INTERNAL_VALUE_OK = 'unchanged', + PARAMETER = '__memo_parameter', + SCOPE = '__memo_scope', + THIS = 'this', + VALUE = 'value', + EQUAL_T = '=t', +} + +export interface ReturnTypeInfo { + node: arkts.TypeNode | undefined; + isMemo?: boolean; + isVoid?: boolean; + isStableThis?: boolean; +} + +export interface ParamInfo { + ident: arkts.Identifier; + param: arkts.ETSParameterExpression; +} + +export interface MemoInfo { + name?: string; + isMemo: boolean; +} + +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)); + } +} + +export function isMemoAnnotation(node: arkts.AnnotationUsage, memoName: RuntimeNames): boolean { + return node.expr !== undefined && arkts.isIdentifier(node.expr) && node.expr.name === memoName; +} + +export type MemoAstNode = + | arkts.ScriptFunction + | arkts.ETSParameterExpression + | arkts.ClassProperty + | arkts.TSTypeAliasDeclaration + | arkts.ETSFunctionType + | arkts.ArrowFunctionExpression + | arkts.ETSTypeReference + | arkts.VariableDeclaration; + +export function hasMemoAnnotation(node: T): boolean { + return node.annotations.some( + (it) => isMemoAnnotation(it, RuntimeNames.ANNOTATION) || isMemoAnnotation(it, RuntimeNames.ANNOTATION_BUILDER) + ); +} + +export function hasMemoIntrinsicAnnotation(node: T): boolean { + return node.annotations.some((it) => isMemoAnnotation(it, RuntimeNames.ANNOTATION_INTRINSIC)); +} + +export function hasMemoEntryAnnotation(node: T): boolean { + return node.annotations.some((it) => isMemoAnnotation(it, RuntimeNames.ANNOTATION_ENTRY)); +} + +export function hasMemoStableAnnotation(node: arkts.ClassDefinition): boolean { + return node.annotations.some((it) => isMemoAnnotation(it, RuntimeNames.ANNOTATION_STABLE)); +} + +export function hasMemoSkipAnnotation(node: arkts.ETSParameterExpression): boolean { + return node.annotations.some((it) => isMemoAnnotation(it, RuntimeNames.ANNOTATION_SKIP)); +} + +export function removeMemoAnnotation(node: T): T { + const newAnnotations: arkts.AnnotationUsage[] = node.annotations.filter( + (it) => !isMemoAnnotation(it, RuntimeNames.ANNOTATION) && !isMemoAnnotation(it, RuntimeNames.ANNOTATION_STABLE) + ); + if (arkts.isEtsParameterExpression(node)) { + node.annotations = newAnnotations; + return node; + } + return node.setAnnotations(newAnnotations) as T; +} + +/** + * TODO: + * @deprecated + */ +export function isSyntheticReturnStatement(node: arkts.AstNode): boolean { + return isIfStatementWithSyntheticReturn(node) || isSimpleSyntheticReturn(node) || isSyntheticReturnInBlock(node); +} + +function isIfStatementWithSyntheticReturn(node: arkts.AstNode): boolean { + return ( + arkts.isIfStatement(node) && + !!node.test && + arkts.isMemberExpression(node.test) && + arkts.isIdentifier(node.test.object) && + node.test.object.name === RuntimeNames.SCOPE && + arkts.isIdentifier(node.test.property) && + node.test.property.name === RuntimeNames.INTERNAL_VALUE_OK && + (arkts.isBlockStatement(node.consequent) || arkts.isReturnStatement(node.consequent)) + ); +} + +function isSimpleSyntheticReturn(node: arkts.AstNode): boolean { + return ( + arkts.isReturnStatement(node) && + !!node.argument && + arkts.isMemberExpression(node.argument) && + arkts.isIdentifier(node.argument.object) && + node.argument.object.name === RuntimeNames.SCOPE && + arkts.isIdentifier(node.argument.property) && + node.argument.property.name === RuntimeNames.INTERNAL_VALUE + ); +} + +function isSyntheticReturnInBlock(node: arkts.AstNode): boolean { + if (!arkts.isBlockStatement(node) || node.statements.length !== 2) { + return false; + } + if (!arkts.isReturnStatement(node.statements[1])) { + return false; + } + const isReturnThis: boolean = !!node.statements[1].argument && arkts.isThisExpression(node.statements[1].argument); + const isReturnVoid: boolean = node.statements[1].argument === undefined; + + return ( + arkts.isMemberExpression(node.statements[0]) && + arkts.isIdentifier(node.statements[0].object) && + node.statements[0].object.name === RuntimeNames.SCOPE && + arkts.isIdentifier(node.statements[0].property) && + node.statements[0].property.name === RuntimeNames.INTERNAL_VALUE && + (isReturnThis || isReturnVoid) + ); +} + +/** + * TODO: + * @deprecated + */ +export function isMemoParametersDeclaration(node: arkts.AstNode): boolean { + return ( + arkts.isVariableDeclaration(node) && + node.declarators.every((it) => it.name.name.startsWith(RuntimeNames.PARAMETER)) + ); +} + +/** + * TODO: change this to TypeNodeGetType to check void type + */ +export function isVoidType(typeNode: arkts.TypeNode | undefined): boolean { + return typeNode?.dumpSrc() === 'void'; +} + +/** + * es2panda API is weird here + * + * @deprecated + */ +export function castParameters(params: readonly arkts.Expression[]): arkts.ETSParameterExpression[] { + return params as arkts.ETSParameterExpression[]; +} + +/** + * es2panda API is weird here + * + * @deprecated + */ +export function castFunctionExpression(value: arkts.Expression | undefined): arkts.FunctionExpression { + return value as unknown as arkts.FunctionExpression; +} + +/** + * es2panda API is weird here + * + * @deprecated + */ +export function castArrowFunctionExpression(value: arkts.Expression | undefined): arkts.ArrowFunctionExpression { + return value as unknown as arkts.ArrowFunctionExpression; +} + +/** + * es2panda API is weird here + * + * @deprecated + */ +export function castIdentifier(value: arkts.AstNode | undefined): arkts.Identifier { + return value as unknown as arkts.Identifier; +} + +/** + * es2panda API is weird here + * + * @deprecated + */ +export function castOverloadsToMethods(overloads: arkts.AstNode[]): readonly arkts.MethodDefinition[] { + return overloads as unknown as readonly arkts.MethodDefinition[]; +} + +export function isStandaloneArrowFunction(node: arkts.AstNode): node is arkts.ArrowFunctionExpression { + if (!arkts.isArrowFunctionExpression(node)) return false; + + // handling anonymous arrow function call + if (!!node.parent && arkts.isCallExpression(node.parent) && node.parent.expression.peer === node.peer) { + return true; + } + + return ( + !!node.parent && + !arkts.isVariableDeclarator(node.parent) && + !arkts.isClassProperty(node.parent) && + !(arkts.isCallExpression(node.parent) && node.parent.expression) + ); +} + +export function isFunctionProperty(node: arkts.AstNode): node is arkts.Property { + return ( + arkts.isProperty(node) && + !!node.key && + arkts.isIdentifier(node.key) && + !!node.value && + arkts.isArrowFunctionExpression(node.value) + ); +} + +export function isThisAttributeAssignment(node: arkts.AstNode): node is arkts.AssignmentExpression { + if (!arkts.isAssignmentExpression(node)) { + return false; + } + if (!node.left || !node.right) { + return false; + } + const isAssignOperator = node.operatorType === arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION; + const isThisAttribute = + arkts.isMemberExpression(node.left) && + arkts.isThisExpression(node.left.object) && + arkts.isIdentifier(node.left.property); + return isAssignOperator && isThisAttribute; +} + +export function findThisAttribute(node: arkts.AstNode): arkts.Identifier | undefined { + if (!arkts.isMemberExpression(node) || !arkts.isIdentifier(node.property)) { + return undefined; + } + return node.property; +} + +export function isMemoThisAttribute(node: arkts.Identifier, value: arkts.ArrowFunctionExpression): boolean { + let isMemo: boolean = isMemoArrowFunction(value); + if (isMemo) { + return true; + } + const decl: arkts.AstNode | undefined = getDeclResolveAlias(node); + if (!decl) { + return false; + } + if (arkts.isClassProperty(decl)) { + isMemo ||= isMemoClassProperty(decl); + } else if (arkts.isMethodDefinition(decl)) { + isMemo ||= isMemoDeclaredMethod(decl); + } + return isMemo; +} + +export function isMemoClassProperty(node: arkts.ClassProperty): boolean { + let isMemo = findMemoFromTypeAnnotation(node.typeAnnotation); + if (node.value) { + isMemo ||= + arkts.isArrowFunctionExpression(node.value) && + (hasMemoAnnotation(node.value) || hasMemoIntrinsicAnnotation(node.value)); + } + isMemo ||= hasMemoAnnotation(node) || hasMemoIntrinsicAnnotation(node); + return isMemo; +} + +export function isMemoMethodDefinition(node: arkts.MethodDefinition): boolean { + return ( + hasMemoAnnotation(node.scriptFunction) || + hasMemoIntrinsicAnnotation(node.scriptFunction) || + hasMemoEntryAnnotation(node.scriptFunction) + ); +} + +export function isMemoArrowFunction(node: arkts.ArrowFunctionExpression): boolean { + return hasMemoAnnotation(node) || hasMemoIntrinsicAnnotation(node); +} + +export function isMemoTSTypeAliasDeclaration(node: arkts.TSTypeAliasDeclaration): boolean { + let isMemo = findMemoFromTypeAnnotation(node.typeAnnotation); + isMemo ||= hasMemoAnnotation(node) || hasMemoIntrinsicAnnotation(node); + return isMemo; +} + +export function isMemoETSParameterExpression(param: arkts.ETSParameterExpression): boolean { + const type = param.identifier.typeAnnotation; + if (!type) { + return false; + } + let isMemo: boolean = hasMemoAnnotation(param) || hasMemoIntrinsicAnnotation(param); + isMemo ||= findMemoFromTypeAnnotation(type); + let decl: arkts.AstNode | undefined; + if ( + arkts.isETSTypeReference(type) && + !!type.part && + !!type.part.name && + !!(decl = getDeclResolveAlias(type.part.name)) + ) { + if (arkts.isTSTypeAliasDeclaration(decl)) { + isMemo ||= hasMemoAnnotation(decl) || hasMemoIntrinsicAnnotation(decl); + isMemo ||= findMemoFromTypeAnnotation(decl.typeAnnotation); + return isMemo; + } + } + return isMemo; +} + +export function isMemoVariableDeclaration(node: arkts.VariableDeclaration): boolean { + return hasMemoAnnotation(node) || hasMemoIntrinsicAnnotation(node); +} + +export function isMemoVariableDeclarator(node: arkts.VariableDeclarator): boolean { + let isMemo: boolean = false; + if (!!node.name.typeAnnotation) { + isMemo ||= findMemoFromTypeAnnotation(node.name.typeAnnotation); + } + if (!!node.initializer && arkts.isArrowFunctionExpression(node.initializer)) { + isMemo ||= isMemoArrowFunction(node.initializer); + } + if (!!node.parent && arkts.isVariableDeclaration(node.parent)) { + isMemo ||= isMemoVariableDeclaration(node.parent); + } + return isMemo; +} + +export function isMemoProperty(node: arkts.Property, value: arkts.ArrowFunctionExpression): boolean { + let isMemo: boolean = isMemoArrowFunction(value); + if (isMemo) { + return true; + } + let decl: arkts.AstNode | undefined; + if (!node.key || !(decl = getDeclResolveAlias(node.key))) { + return false; + } + if (arkts.isMethodDefinition(decl)) { + isMemo ||= isMemoDeclaredMethod(decl); + } + return isMemo; +} + +export function isMemoDeclaredMethod(decl: arkts.MethodDefinition): boolean { + if ( + decl.kind === arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_GET && + findMemoFromTypeAnnotation(decl.scriptFunction.returnTypeAnnotation) + ) { + return true; + } + return !hasMemoEntryAnnotation(decl.scriptFunction) && isMemoMethodDefinition(decl); +} + +export function isDeclaredMethodWithMemoParams(decl: arkts.MethodDefinition): boolean { + if (decl.kind === arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_GET) { + return false; + } + return decl.scriptFunction.params.some((param) => { + return arkts.isEtsParameterExpression(param) && isMemoETSParameterExpression(param); + }); +} + +export function isMemoDeclaredIdentifier(decl: arkts.Identifier): boolean { + if (findMemoFromTypeAnnotation(decl.typeAnnotation)) { + return true; + } + if (!!decl.parent && arkts.isVariableDeclarator(decl.parent)) { + return isMemoVariableDeclarator(decl.parent); + } + return false; +} + +export function isMemoDeclaredClassProperty(decl: arkts.ClassProperty): boolean { + return isMemoClassProperty(decl); +} + +export function findMemoFromTypeAnnotation(typeAnnotation: arkts.AstNode | undefined): boolean { + if (!typeAnnotation) { + return false; + } + if (arkts.isETSTypeReference(typeAnnotation) && !!typeAnnotation.part && !!typeAnnotation.part.name) { + let decl: arkts.AstNode | undefined = arkts.getDecl(typeAnnotation.part.name); + if (!decl || !arkts.isTSTypeAliasDeclaration(decl)) { + return false; + } + let isMemo: boolean = hasMemoAnnotation(decl) || hasMemoIntrinsicAnnotation(decl); + if (!isMemo && !!decl.typeAnnotation) { + isMemo = findMemoFromTypeAnnotation(decl.typeAnnotation); + } + return isMemo; + } else if (arkts.isETSFunctionType(typeAnnotation)) { + return hasMemoAnnotation(typeAnnotation) || hasMemoIntrinsicAnnotation(typeAnnotation); + } else if (arkts.isETSUnionType(typeAnnotation)) { + return typeAnnotation.types.some( + (type) => arkts.isETSFunctionType(type) && (hasMemoAnnotation(type) || hasMemoIntrinsicAnnotation(type)) + ); + } + return false; +} + +export function findReturnTypeFromTypeAnnotation( + typeAnnotation: arkts.AstNode | undefined +): arkts.TypeNode | undefined { + if (!typeAnnotation) { + return undefined; + } + if (arkts.isETSTypeReference(typeAnnotation) && !!typeAnnotation.part && !!typeAnnotation.part.name) { + let decl: arkts.AstNode | undefined = arkts.getDecl(typeAnnotation.part.name); + if (!!decl && arkts.isTSTypeAliasDeclaration(decl)) { + return findReturnTypeFromTypeAnnotation(decl.typeAnnotation); + } + return undefined; + } + if (arkts.isETSFunctionType(typeAnnotation)) { + return typeAnnotation.returnType; + } + if (arkts.isETSUnionType(typeAnnotation)) { + return typeAnnotation.types.find((type) => arkts.isETSFunctionType(type))?.returnType; + } + return undefined; +} + +export function getDeclResolveAlias(node: arkts.AstNode): arkts.AstNode | undefined { + const decl = arkts.getDecl(node); + if (!!decl && !!decl.parent && arkts.isIdentifier(decl) && arkts.isVariableDeclarator(decl.parent)) { + if (!!decl.parent.initializer && arkts.isIdentifier(decl.parent.initializer)) { + return getDeclResolveAlias(decl.parent.initializer); + } + if (!!decl.parent.initializer && arkts.isMemberExpression(decl.parent.initializer)) { + return getDeclResolveAlias(decl.parent.initializer.property); + } + } + return decl; +} + +export function mayAddLastReturn(node: arkts.BlockStatement): boolean { + return ( + node.statements.length === 0 || + (!arkts.isReturnStatement(node.statements[node.statements.length - 1]) && + !arkts.isThrowStatement(node.statements[node.statements.length - 1])) + ); +} + +export function fixGensymParams(params: ParamInfo[], body: arkts.BlockStatement): number { + let gensymParamsCount = 0; + for (let i = 0; i < params.length; i++) { + if (params[i].ident.name.startsWith(RuntimeNames.GENSYM)) { + if (gensymParamsCount >= body.statements.length) { + throw new Error(`Expected ${params[i].ident.name} replacement to original parameter`); + } + const declaration = body.statements[gensymParamsCount]; + if (!arkts.isVariableDeclaration(declaration)) { + throw new Error(`Expected ${params[i].ident.name} replacement to original parameter`); + } + if (!arkts.isIdentifier(declaration.declarators[0].name)) { + throw new Error(`Expected ${params[i].ident.name} replacement to original parameter`); + } + params[i].ident = declaration.declarators[0].name; + gensymParamsCount++; + } + } + return gensymParamsCount; +} + +export function isUnmemoizedInFunction(params?: readonly arkts.Expression[]): boolean { + const _params = params ?? []; + const first = _params.at(0); + const isContextAdded = + !!first && arkts.isEtsParameterExpression(first) && first.identifier.name === RuntimeNames.CONTEXT; + const second = _params.at(1); + const isIdAdded = !!second && arkts.isEtsParameterExpression(second) && second.identifier.name === RuntimeNames.ID; + return isContextAdded && isIdAdded; +} + +export function buildReturnTypeInfo( + returnType: arkts.TypeNode | undefined, + isMemo?: boolean, + isStableThis?: boolean +): ReturnTypeInfo { + const newReturnType = !!returnType + ? returnType.clone() + : arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID); + return { + node: newReturnType, + isMemo, + isVoid: isVoidType(newReturnType), + isStableThis, + }; +} + +export function buildeParamInfos(parameters: readonly arkts.ETSParameterExpression[]): ParamInfo[] { + return [ + ...parameters + .filter((it) => !hasMemoSkipAnnotation(it)) + .map((it) => { + return { ident: it.identifier, param: it }; + }), + ]; +} + +export function parametersBlockHasReceiver(params: readonly arkts.Expression[]): boolean { + return params.length > 0 && arkts.isEtsParameterExpression(params[0]) && isThisParam(params[0]); +} + +export function parametrizedNodeHasReceiver(node: arkts.ScriptFunction | arkts.ETSFunctionType | undefined): boolean { + if (node === undefined) { + return false; + } + return parametersBlockHasReceiver(node.params); +} + +function isThisParam(node: arkts.Expression | undefined): boolean { + if (node === undefined || !arkts.isEtsParameterExpression(node)) { + return false; + } + return node.identifier?.isReceiver ?? false; +} diff --git a/ets1.2/arkui-plugins/npm_preinstall.sh b/ets1.2/arkui-plugins/npm_preinstall.sh new file mode 100755 index 0000000000000000000000000000000000000000..478471ab0ddcfcec949a6753fc1dfd15dda9394b --- /dev/null +++ b/ets1.2/arkui-plugins/npm_preinstall.sh @@ -0,0 +1,30 @@ +#!/bin/bash +# coding: utf-8 +# 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. + +if [ "$1" == "--init" ]; then + cd ../koala-wrapper + npm install + npm run compile + npm link + + cd ../ts_wrapper + npm install + npm run compile + npm link + + cd ../arkui-plugins + mkdir node_modules + npm link @koalaui/libarkts +fi \ No newline at end of file diff --git a/ets1.2/arkui-plugins/package.json b/ets1.2/arkui-plugins/package.json new file mode 100644 index 0000000000000000000000000000000000000000..0267fb00dffdd82d8637dfb6471e70e6b883f042 --- /dev/null +++ b/ets1.2/arkui-plugins/package.json @@ -0,0 +1,35 @@ +{ + "name": "arkui-plugin", + "version": "1.0.0", + "description": "", + "private": true, + "workspaces": [ + "./test" + ], + "scripts": { + "local:install": "chmod 777 ./npm_preinstall.sh && ./npm_preinstall.sh --init", + "compile:plugins": "./node_modules/.bin/babel . --out-dir lib --extensions .ts", + "compile:clean": "rm -rf lib", + "clean:test": "rm -rf dist && rm -rf coverage", + "prepare:test": "cp -rf $INIT_CWD/../../../out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/koala-wrapper/build/native/ ../koala-wrapper/build/", + "test": "npm run clean:test && npm run prepare:test && LD_LIBRARY_PATH=$INIT_CWD/../../../out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/ets2panda/lib jest --coverage --logHeapUsage --config ./jest-test.config.js --silent", + "compile": "npm run compile:clean && npm run compile:plugins && cp -rf ./lib $INIT_CWD/../../../../out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/ui-plugins/" + }, + "devDependencies": { + "@babel/cli": "7.20.7", + "@babel/core": "7.20.12", + "@babel/plugin-proposal-class-properties": "7.18.6", + "@babel/preset-env": "7.20.2", + "@babel/preset-typescript": "7.18.6", + "@babel/runtime": "7.20.13", + "@types/jest": "^29.5.14", + "@types/node": "^22.13.9", + "jest": "^29.7.0", + "ts-jest": "^29.2.0", + "ts-node": "^10.9.0", + "typescript": "^5.0.0" + }, + "dependencies": { + "@koalaui/libarkts": "../koala-wrapper" + } +} diff --git a/ets1.2/arkui-plugins/path.ts b/ets1.2/arkui-plugins/path.ts new file mode 100644 index 0000000000000000000000000000000000000000..a8646fcbf9f1a0b882082eca9843bd5441c171d9 --- /dev/null +++ b/ets1.2/arkui-plugins/path.ts @@ -0,0 +1,61 @@ +/* + * 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 { error } from 'console'; +import * as path from 'path'; + +const UI_PLUGINS = 'ui-plugins'; +const ARKUI_PLUGINS = 'arkui-plugins'; + +function findMatchingFile(currentPath: string, targetFileName1: string, targetFileName2: string): string | null { + let current = currentPath; + while (true) { + // 获取当前路径的文件名 + const baseName = path.basename(current); + if (baseName === targetFileName1 || baseName === targetFileName2) { + return path.dirname(current); + } + + const parentPath = path.dirname(current); + if (parentPath === current) { + break; + } + current = parentPath; + } + throw new Error('ui-plugins not found.'); +} + +function findRootDir() { + const plugins = findMatchingFile(__dirname, UI_PLUGINS, ARKUI_PLUGINS); + if (plugins === null) { + throw 'error'; + } + return plugins; +} + +export function getArktsPath() { + return path.join(findRootDir(), 'koala-wrapper', './build/lib/arkts-api/index.js'); +} + +export function getInteropPath() { + return path.join(findRootDir(), 'koala-wrapper/koalaui/interop', './dist/lib/src/interop/index.js'); +} + +export function getCommonPath() { + return path.join(findRootDir(), 'koala-wrapper/koalaui/common', './dist/lib/src/index.js'); +} + +export function getCompatPath() { + return path.join(findRootDir(), 'koala-wrapper/koalaui/compat', './dist/src/index.js'); +} diff --git a/ets1.2/arkui-plugins/test/arktsconfig_gen.js b/ets1.2/arkui-plugins/test/arktsconfig_gen.js new file mode 100644 index 0000000000000000000000000000000000000000..bd8b94608f2c4529b089562a12a7cab008464a46 --- /dev/null +++ b/ets1.2/arkui-plugins/test/arktsconfig_gen.js @@ -0,0 +1,57 @@ +/* + * 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. + */ + +const fs = require('fs'); +const path = require('path'); + +// 获取当前目录 +const currentDirectory = process.cwd(); +let workSpace = currentDirectory; +for (let i = 0; i < 4; i++) { + workSpace = path.dirname(workSpace); +} +// JSON 文件路径 +const jsonFilePath = path.join(__dirname, 'arktsconfig_template.json'); +const outJsonFilePath = path.join(__dirname, 'dist/cache/arktsconfig.json'); + +try { + // 读取 JSON 文件内容 + const data = fs.readFileSync(jsonFilePath, 'utf8'); + const jsonData = JSON.parse(data); + + // 处理 baseUrl 字段 + if (jsonData.compilerOptions.baseUrl) { + jsonData.compilerOptions.baseUrl = jsonData.compilerOptions.baseUrl.replace(/workspace/g, workSpace); + } + + // 处理 Paths 字段 + if (jsonData.compilerOptions.paths) { + for (const key in jsonData.compilerOptions.paths) { + const values = jsonData.compilerOptions.paths[key]; + for (let i = 0; i < values.length; i++) { + if (key.startsWith('@ohos.arkui.')) { + values[i] = currentDirectory + "/dist/cache/" + key; + } else { + values[i] = values[i].replace(/workspace/g, workSpace); + } + } + } + } + + // 将修改后的内容写回 JSON 文件 + fs.writeFileSync(outJsonFilePath, JSON.stringify(jsonData, null, 2), 'utf8'); +} catch (error) { + console.error('处理 JSON 文件时出错:', error); +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/arktsconfig_template.json b/ets1.2/arkui-plugins/test/arktsconfig_template.json new file mode 100644 index 0000000000000000000000000000000000000000..1353fee749d190171066c383a713f7792aa28807 --- /dev/null +++ b/ets1.2/arkui-plugins/test/arktsconfig_template.json @@ -0,0 +1,2797 @@ +{ + "compilerOptions": { + "package": "entry", + "baseUrl": "workspace/developtools/ace_ets2bundle/arkui-plugins/test/dist/cache/", + "include": [ + "./0_SRC_Memo_2_FunctionTransformer.ets" + ], + "paths": { + "std": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/ets2panda/lib/stdlib/std" + ], + "escompat": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/ets2panda/lib/stdlib/escompat" + ], + "@ohos.InputMethodExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.InputMethodExtensionAbility" + ], + "@ohos.InputMethodExtensionContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.InputMethodExtensionContext" + ], + "@ohos.InputMethodSubtype": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.InputMethodSubtype" + ], + "@ohos.PiPWindow": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.PiPWindow" + ], + "@ohos.UiTest": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.UiTest" + ], + "@ohos.WallpaperExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.WallpaperExtensionAbility" + ], + "@ohos.WorkSchedulerExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.WorkSchedulerExtensionAbility" + ], + "@ohos.ability.ability": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.ability.ability" + ], + "@ohos.ability.dataUriUtils": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.ability.dataUriUtils" + ], + "@ohos.ability.errorCode": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.ability.errorCode" + ], + "@ohos.ability.featureAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.ability.featureAbility" + ], + "@ohos.ability.particleAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.ability.particleAbility" + ], + "@ohos.ability.screenLockFileManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.ability.screenLockFileManager" + ], + "@ohos.ability.wantConstant": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.ability.wantConstant" + ], + "@ohos.abilityAccessCtrl": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.abilityAccessCtrl" + ], + "@ohos.accessibility.GesturePath": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.accessibility.GesturePath" + ], + "@ohos.accessibility.GesturePoint": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.accessibility.GesturePoint" + ], + "@ohos.accessibility.config": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.accessibility.config" + ], + "@ohos.accessibility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.accessibility" + ], + "@ohos.account.appAccount": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.account.appAccount" + ], + "@ohos.account.distributedAccount": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.account.distributedAccount" + ], + "@ohos.account.osAccount": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.account.osAccount" + ], + "@ohos.advertising.AdComponent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.advertising.AdComponent" + ], + "@ohos.advertising.AdsServiceExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.advertising.AdsServiceExtensionAbility" + ], + "@ohos.advertising.AutoAdComponent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.advertising.AutoAdComponent" + ], + "@ohos.advertising": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.advertising" + ], + "@ohos.ai.intelligentVoice": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.ai.intelligentVoice" + ], + "@ohos.ai.mindSporeLite": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.ai.mindSporeLite" + ], + "@ohos.animation.windowAnimationManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.animation.windowAnimationManager" + ], + "@ohos.animator": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.animator" + ], + "@ohos.app.ability.Ability": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.Ability" + ], + "@ohos.app.ability.AbilityConstant": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.AbilityConstant" + ], + "@ohos.app.ability.AbilityLifecycleCallback": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.AbilityLifecycleCallback" + ], + "@ohos.app.ability.AbilityStage": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.AbilityStage" + ], + "@ohos.app.ability.ActionExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.ActionExtensionAbility" + ], + "@ohos.app.ability.ApplicationStateChangeCallback": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.ApplicationStateChangeCallback" + ], + "@ohos.app.ability.AtomicServiceOptions": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.AtomicServiceOptions" + ], + "@ohos.app.ability.AutoFillExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.AutoFillExtensionAbility" + ], + "@ohos.app.ability.ChildProcess": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.ChildProcess" + ], + "@ohos.app.ability.ChildProcessArgs": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.ChildProcessArgs" + ], + "@ohos.app.ability.ChildProcessOptions": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.ChildProcessOptions" + ], + "@ohos.app.ability.Configuration": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.Configuration" + ], + "@ohos.app.ability.ConfigurationConstant": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.ConfigurationConstant" + ], + "@ohos.app.ability.DriverExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.DriverExtensionAbility" + ], + "@ohos.app.ability.EmbeddableUIAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.EmbeddableUIAbility" + ], + "@ohos.app.ability.EmbeddedUIExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.EmbeddedUIExtensionAbility" + ], + "@ohos.app.ability.EnvironmentCallback": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.EnvironmentCallback" + ], + "@ohos.app.ability.ExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.ExtensionAbility" + ], + "@ohos.app.ability.FenceExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.FenceExtensionAbility" + ], + "@ohos.app.ability.FenceExtensionContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.FenceExtensionContext" + ], + "@ohos.app.ability.InsightIntentContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.InsightIntentContext" + ], + "@ohos.app.ability.InsightIntentExecutor": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.InsightIntentExecutor" + ], + "@ohos.app.ability.MediaControlExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.MediaControlExtensionAbility" + ], + "@ohos.app.ability.OpenLinkOptions": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.OpenLinkOptions" + ], + "@ohos.app.ability.PhotoEditorExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.PhotoEditorExtensionAbility" + ], + "@ohos.app.ability.PrintExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.PrintExtensionAbility" + ], + "@ohos.app.ability.ServiceExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.ServiceExtensionAbility" + ], + "@ohos.app.ability.ShareExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.ShareExtensionAbility" + ], + "@ohos.app.ability.StartOptions": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.StartOptions" + ], + "@ohos.app.ability.UIAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.UIAbility" + ], + "@ohos.app.ability.UIExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.UIExtensionAbility" + ], + "@ohos.app.ability.UIExtensionContentSession": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.UIExtensionContentSession" + ], + "@ohos.app.ability.UIServiceExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.UIServiceExtensionAbility" + ], + "@ohos.app.ability.UserAuthExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.UserAuthExtensionAbility" + ], + "@ohos.app.ability.VpnExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.VpnExtensionAbility" + ], + "@ohos.app.ability.Want": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.Want" + ], + "@ohos.app.ability.abilityDelegatorRegistry": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.abilityDelegatorRegistry" + ], + "@ohos.app.ability.abilityManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.abilityManager" + ], + "@ohos.app.ability.appManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.appManager" + ], + "@ohos.app.ability.appRecovery": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.appRecovery" + ], + "@ohos.app.ability.application": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.application" + ], + "@ohos.app.ability.autoFillManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.autoFillManager" + ], + "@ohos.app.ability.autoStartupManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.autoStartupManager" + ], + "@ohos.app.ability.childProcessManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.childProcessManager" + ], + "@ohos.app.ability.common": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.common" + ], + "@ohos.app.ability.contextConstant": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.contextConstant" + ], + "@ohos.app.ability.dataUriUtils": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.dataUriUtils" + ], + "@ohos.app.ability.dialogRequest": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.dialogRequest" + ], + "@ohos.app.ability.dialogSession": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.dialogSession" + ], + "@ohos.app.ability.errorManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.errorManager" + ], + "@ohos.app.ability.insightIntent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.insightIntent" + ], + "@ohos.app.ability.insightIntentDriver": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.insightIntentDriver" + ], + "@ohos.app.ability.missionManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.missionManager" + ], + "@ohos.app.ability.quickFixManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.quickFixManager" + ], + "@ohos.app.ability.sendableContextManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.sendableContextManager" + ], + "@ohos.app.ability.wantAgent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.wantAgent" + ], + "@ohos.app.ability.wantConstant": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.ability.wantConstant" + ], + "@ohos.app.appstartup.StartupConfig": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.appstartup.StartupConfig" + ], + "@ohos.app.appstartup.StartupConfigEntry": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.appstartup.StartupConfigEntry" + ], + "@ohos.app.appstartup.StartupListener": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.appstartup.StartupListener" + ], + "@ohos.app.appstartup.StartupTask": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.appstartup.StartupTask" + ], + "@ohos.app.appstartup.startupManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.appstartup.startupManager" + ], + "@ohos.app.businessAbilityRouter": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.businessAbilityRouter" + ], + "@ohos.app.form.FormExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.form.FormExtensionAbility" + ], + "@ohos.app.form.formAgent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.form.formAgent" + ], + "@ohos.app.form.formBindingData": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.form.formBindingData" + ], + "@ohos.app.form.formHost": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.form.formHost" + ], + "@ohos.app.form.formInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.form.formInfo" + ], + "@ohos.app.form.formObserver": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.form.formObserver" + ], + "@ohos.app.form.formProvider": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.app.form.formProvider" + ], + "@ohos.application.AccessibilityExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.AccessibilityExtensionAbility" + ], + "@ohos.application.BackupExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.BackupExtensionAbility" + ], + "@ohos.application.Configuration": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.Configuration" + ], + "@ohos.application.ConfigurationConstant": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.ConfigurationConstant" + ], + "@ohos.application.DataShareExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.DataShareExtensionAbility" + ], + "@ohos.application.StaticSubscriberExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.StaticSubscriberExtensionAbility" + ], + "@ohos.application.StaticSubscriberExtensionContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.StaticSubscriberExtensionContext" + ], + "@ohos.application.Want": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.Want" + ], + "@ohos.application.WindowExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.WindowExtensionAbility" + ], + "@ohos.application.abilityDelegatorRegistry": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.abilityDelegatorRegistry" + ], + "@ohos.application.abilityManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.abilityManager" + ], + "@ohos.application.appManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.appManager" + ], + "@ohos.application.formBindingData": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.formBindingData" + ], + "@ohos.application.formError": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.formError" + ], + "@ohos.application.formHost": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.formHost" + ], + "@ohos.application.formInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.formInfo" + ], + "@ohos.application.formProvider": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.formProvider" + ], + "@ohos.application.missionManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.missionManager" + ], + "@ohos.application.testRunner": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.testRunner" + ], + "@ohos.application.uriPermissionManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.application.uriPermissionManager" + ], + "@ohos.arkui.Prefetcher": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.Prefetcher" + ], + "@ohos.arkui.StateManagement": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.StateManagement" + ], + "@ohos.arkui.StateManagement.runtime": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.StateManagement.runtime" + ], + "@ohos.arkui.UIContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.UIContext" + ], + "@ohos.arkui.advanced.Chip": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.Chip" + ], + "@ohos.arkui.advanced.ChipGroup": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.ChipGroup" + ], + "@ohos.arkui.advanced.ComposeListItem": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.ComposeListItem" + ], + "@ohos.arkui.advanced.ComposeTitleBar": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.ComposeTitleBar" + ], + "@ohos.arkui.advanced.Counter": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.Counter" + ], + "@ohos.arkui.advanced.Dialog": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.Dialog" + ], + "@ohos.arkui.advanced.DownloadFileButton": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.DownloadFileButton" + ], + "@ohos.arkui.advanced.EditableTitleBar": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.EditableTitleBar" + ], + "@ohos.arkui.advanced.ExceptionPrompt": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.ExceptionPrompt" + ], + "@ohos.arkui.advanced.Filter": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.Filter" + ], + "@ohos.arkui.advanced.FoldSplitContainer": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.FoldSplitContainer" + ], + "@ohos.arkui.advanced.FormMenu": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.FormMenu" + ], + "@ohos.arkui.advanced.FullScreenLaunchComponent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.FullScreenLaunchComponent" + ], + "@ohos.arkui.advanced.GridObjectSortComponent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.GridObjectSortComponent" + ], + "@ohos.arkui.advanced.InnerFullScreenLaunchComponent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.InnerFullScreenLaunchComponent" + ], + "@ohos.arkui.advanced.Popup": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.Popup" + ], + "@ohos.arkui.advanced.ProgressButton": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.ProgressButton" + ], + "@ohos.arkui.advanced.SegmentButton": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.SegmentButton" + ], + "@ohos.arkui.advanced.SelectTitleBar": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.SelectTitleBar" + ], + "@ohos.arkui.advanced.SelectionMenu": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.SelectionMenu" + ], + "@ohos.arkui.advanced.SplitLayout": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.SplitLayout" + ], + "@ohos.arkui.advanced.SubHeader": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.SubHeader" + ], + "@ohos.arkui.advanced.SwipeRefresher": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.SwipeRefresher" + ], + "@ohos.arkui.advanced.TabTitleBar": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.TabTitleBar" + ], + "@ohos.arkui.advanced.ToolBar": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.ToolBar" + ], + "@ohos.arkui.advanced.TreeView": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.advanced.TreeView" + ], + "@ohos.arkui.component.AbilityComponent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.AbilityComponent" + ], + "@ohos.arkui.component.ActionSheet": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.ActionSheet" + ], + "@ohos.arkui.component.AlertDialog": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.AlertDialog" + ], + "@ohos.arkui.component.AlphabetIndexer": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.AlphabetIndexer" + ], + "@ohos.arkui.component.Animator": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Animator" + ], + "@ohos.arkui.component.Badge": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Badge" + ], + "@ohos.arkui.component.Blank": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Blank" + ], + "@ohos.arkui.component.Button": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Button" + ], + "@ohos.arkui.component.Calendar": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Calendar" + ], + "@ohos.arkui.component.CalendarPicker": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.CalendarPicker" + ], + "@ohos.arkui.component.Canvas": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Canvas" + ], + "@ohos.arkui.component.Checkbox": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Checkbox" + ], + "@ohos.arkui.component.CheckboxGroup": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.CheckboxGroup" + ], + "@ohos.arkui.component.Circle": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Circle" + ], + "@ohos.arkui.component.Column": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Column" + ], + "@ohos.arkui.component.ColumnSplit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.ColumnSplit" + ], + "@ohos.arkui.component.Common": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Common" + ], + "@ohos.arkui.component.CommonTsEtsApi": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.CommonTsEtsApi" + ], + "@ohos.arkui.component.Component3d": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Component3d" + ], + "@ohos.arkui.component.ContainerSpan": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.ContainerSpan" + ], + "@ohos.arkui.component.ContentSlot": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.ContentSlot" + ], + "@ohos.arkui.component.ContextMenu": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.ContextMenu" + ], + "@ohos.arkui.component.Counter": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Counter" + ], + "@ohos.arkui.component.CustomDialogController": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.CustomDialogController" + ], + "@ohos.arkui.component.DataPanel": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.DataPanel" + ], + "@ohos.arkui.component.DatePicker": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.DatePicker" + ], + "@ohos.arkui.component.Divider": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Divider" + ], + "@ohos.arkui.component.EffectComponent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.EffectComponent" + ], + "@ohos.arkui.component.Ellipse": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Ellipse" + ], + "@ohos.arkui.component.EmbeddedComponent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.EmbeddedComponent" + ], + "@ohos.arkui.component.Enums": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Enums" + ], + "@ohos.arkui.component.Flex": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Flex" + ], + "@ohos.arkui.component.FlowItem": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.FlowItem" + ], + "@ohos.arkui.component.Focus": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Focus" + ], + "@ohos.arkui.component.FolderStack": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.FolderStack" + ], + "@ohos.arkui.component.ForEach": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.ForEach" + ], + "@ohos.arkui.component.FormComponent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.FormComponent" + ], + "@ohos.arkui.component.FormLink": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.FormLink" + ], + "@ohos.arkui.component.Gauge": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Gauge" + ], + "@ohos.arkui.component.Gesture": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Gesture" + ], + "@ohos.arkui.component.Grid": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Grid" + ], + "@ohos.arkui.component.GridCol": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.GridCol" + ], + "@ohos.arkui.component.GridContainer": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.GridContainer" + ], + "@ohos.arkui.component.GridItem": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.GridItem" + ], + "@ohos.arkui.component.GridRow": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.GridRow" + ], + "@ohos.arkui.component.Hyperlink": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Hyperlink" + ], + "@ohos.arkui.component.Image": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Image" + ], + "@ohos.arkui.component.ImageAnimator": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.ImageAnimator" + ], + "@ohos.arkui.component.ImageCommon": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.ImageCommon" + ], + "@ohos.arkui.component.ImageSpan": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.ImageSpan" + ], + "@ohos.arkui.component.IndicatorComponent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.IndicatorComponent" + ], + "@ohos.arkui.component.Inspector": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Inspector" + ], + "@ohos.arkui.component.IsolatedComponent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.IsolatedComponent" + ], + "@ohos.arkui.component.LazyForEach": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.LazyForEach" + ], + "@ohos.arkui.component.Line": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Line" + ], + "@ohos.arkui.component.Linearindicator": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Linearindicator" + ], + "@ohos.arkui.component.List": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.List" + ], + "@ohos.arkui.component.ListItem": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.ListItem" + ], + "@ohos.arkui.component.ListItemGroup": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.ListItemGroup" + ], + "@ohos.arkui.component.LoadingProgress": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.LoadingProgress" + ], + "@ohos.arkui.component.Marquee": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Marquee" + ], + "@ohos.arkui.component.Matrix2d": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Matrix2d" + ], + "@ohos.arkui.component.MediaCachedImage": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.MediaCachedImage" + ], + "@ohos.arkui.component.Menu": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Menu" + ], + "@ohos.arkui.component.MenuItem": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.MenuItem" + ], + "@ohos.arkui.component.MenuItemGroup": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.MenuItemGroup" + ], + "@ohos.arkui.component.NavDestination": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.NavDestination" + ], + "@ohos.arkui.component.NavRouter": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.NavRouter" + ], + "@ohos.arkui.component.Navigation": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Navigation" + ], + "@ohos.arkui.component.Navigator": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Navigator" + ], + "@ohos.arkui.component.NodeContainer": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.NodeContainer" + ], + "@ohos.arkui.component.PageTransition": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.PageTransition" + ], + "@ohos.arkui.component.Panel": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Panel" + ], + "@ohos.arkui.component.Particle": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Particle" + ], + "@ohos.arkui.component.Path": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Path" + ], + "@ohos.arkui.component.PatternLock": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.PatternLock" + ], + "@ohos.arkui.component.Polygon": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Polygon" + ], + "@ohos.arkui.component.Polyline": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Polyline" + ], + "@ohos.arkui.component.Progress": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Progress" + ], + "@ohos.arkui.component.QRCode": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.QRCode" + ], + "@ohos.arkui.component.Radio": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Radio" + ], + "@ohos.arkui.component.Rating": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Rating" + ], + "@ohos.arkui.component.Rect": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Rect" + ], + "@ohos.arkui.component.Refresh": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Refresh" + ], + "@ohos.arkui.component.RelativeContainer": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.RelativeContainer" + ], + "@ohos.arkui.component.RichEditor": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.RichEditor" + ], + "@ohos.arkui.component.RichText": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.RichText" + ], + "@ohos.arkui.component.Row": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Row" + ], + "@ohos.arkui.component.RowSplit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.RowSplit" + ], + "@ohos.arkui.component.Scroll": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Scroll" + ], + "@ohos.arkui.component.ScrollBar": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.ScrollBar" + ], + "@ohos.arkui.component.Search": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Search" + ], + "@ohos.arkui.component.Select": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Select" + ], + "@ohos.arkui.component.Shape": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Shape" + ], + "@ohos.arkui.component.Sidebar": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Sidebar" + ], + "@ohos.arkui.component.Slider": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Slider" + ], + "@ohos.arkui.component.Span": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Span" + ], + "@ohos.arkui.component.Stack": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Stack" + ], + "@ohos.arkui.component.StateManagement": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.StateManagement" + ], + "@ohos.arkui.component.StepperItem": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.StepperItem" + ], + "@ohos.arkui.component.StyledString": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.StyledString" + ], + "@ohos.arkui.component.Swiper": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Swiper" + ], + "@ohos.arkui.component.SymbolGlyph": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.SymbolGlyph" + ], + "@ohos.arkui.component.SymbolSpan": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.SymbolSpan" + ], + "@ohos.arkui.component.TabContent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.TabContent" + ], + "@ohos.arkui.component.Tabs": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Tabs" + ], + "@ohos.arkui.component.Text": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Text" + ], + "@ohos.arkui.component.TextArea": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.TextArea" + ], + "@ohos.arkui.component.TextClock": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.TextClock" + ], + "@ohos.arkui.component.TextCommon": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.TextCommon" + ], + "@ohos.arkui.component.TextInput": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.TextInput" + ], + "@ohos.arkui.component.TextPicker": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.TextPicker" + ], + "@ohos.arkui.component.TextTimer": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.TextTimer" + ], + "@ohos.arkui.component.TimePicker": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.TimePicker" + ], + "@ohos.arkui.component.Toggle": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Toggle" + ], + "@ohos.arkui.component.Units": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Units" + ], + "@ohos.arkui.component.Video": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.Video" + ], + "@ohos.arkui.component.WaterFlow": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.WaterFlow" + ], + "@ohos.arkui.component.WithTheme": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.WithTheme" + ], + "@ohos.arkui.component.XComponent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component.XComponent" + ], + "@ohos.arkui.component": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.component" + ], + "@ohos.arkui.componentSnapshot": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.componentSnapshot" + ], + "@ohos.arkui.componentUtils": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.componentUtils" + ], + "@ohos.arkui.dragController": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.dragController" + ], + "@ohos.arkui.drawableDescriptor": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.drawableDescriptor" + ], + "@ohos.arkui.inspector": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.inspector" + ], + "@ohos.arkui.modifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.modifier" + ], + "@ohos.arkui.node": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.node" + ], + "@ohos.arkui.observer": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.observer" + ], + "@ohos.arkui.performanceMonitor": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.performanceMonitor" + ], + "@ohos.arkui.shape": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.shape" + ], + "@ohos.arkui.stateManagement": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.stateManagement" + ], + "@ohos.arkui.theme": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.theme" + ], + "@ohos.arkui.uiExtension": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.arkui.uiExtension" + ], + "@ohos.atomicservice.AtomicServiceNavigation": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.atomicservice.AtomicServiceNavigation" + ], + "@ohos.atomicservice.AtomicServiceTabs": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.atomicservice.AtomicServiceTabs" + ], + "@ohos.atomicservice.AtomicServiceWeb": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.atomicservice.AtomicServiceWeb" + ], + "@ohos.atomicservice.InterstitialDialogAction": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.atomicservice.InterstitialDialogAction" + ], + "@ohos.atomicservice.NavPushPathHelper": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.atomicservice.NavPushPathHelper" + ], + "@ohos.backgroundTaskManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.backgroundTaskManager" + ], + "@ohos.base": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.base" + ], + "@ohos.batteryInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.batteryInfo" + ], + "@ohos.batteryStatistics": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.batteryStatistics" + ], + "@ohos.bluetooth.a2dp": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bluetooth.a2dp" + ], + "@ohos.bluetooth.access": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bluetooth.access" + ], + "@ohos.bluetooth.baseProfile": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bluetooth.baseProfile" + ], + "@ohos.bluetooth.ble": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bluetooth.ble" + ], + "@ohos.bluetooth.connection": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bluetooth.connection" + ], + "@ohos.bluetooth.constant": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bluetooth.constant" + ], + "@ohos.bluetooth": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bluetooth" + ], + "@ohos.bluetooth.hfp": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bluetooth.hfp" + ], + "@ohos.bluetooth.hid": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bluetooth.hid" + ], + "@ohos.bluetooth.map": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bluetooth.map" + ], + "@ohos.bluetooth.pan": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bluetooth.pan" + ], + "@ohos.bluetooth.pbap": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bluetooth.pbap" + ], + "@ohos.bluetooth.socket": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bluetooth.socket" + ], + "@ohos.bluetooth.wearDetection": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bluetooth.wearDetection" + ], + "@ohos.bluetoothManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bluetoothManager" + ], + "@ohos.brightness": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.brightness" + ], + "@ohos.buffer": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.buffer" + ], + "@ohos.bundle.appControl": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bundle.appControl" + ], + "@ohos.bundle.appDomainVerify": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bundle.appDomainVerify" + ], + "@ohos.bundle.bundleManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bundle.bundleManager" + ], + "@ohos.bundle.bundleMonitor": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bundle.bundleMonitor" + ], + "@ohos.bundle.bundleResourceManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bundle.bundleResourceManager" + ], + "@ohos.bundle": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bundle" + ], + "@ohos.bundle.defaultAppManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bundle.defaultAppManager" + ], + "@ohos.bundle.distributedBundleManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bundle.distributedBundleManager" + ], + "@ohos.bundle.freeInstall": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bundle.freeInstall" + ], + "@ohos.bundle.innerBundleManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bundle.innerBundleManager" + ], + "@ohos.bundle.installer": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bundle.installer" + ], + "@ohos.bundle.launcherBundleManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bundle.launcherBundleManager" + ], + "@ohos.bundle.overlay": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bundle.overlay" + ], + "@ohos.bundle.shortcutManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bundle.shortcutManager" + ], + "@ohos.bundleState": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bundleState" + ], + "@ohos.bytrace": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.bytrace" + ], + "@ohos.calendarManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.calendarManager" + ], + "@ohos.charger": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.charger" + ], + "@ohos.commonEvent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.commonEvent" + ], + "@ohos.commonEventManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.commonEventManager" + ], + "@ohos.configPolicy": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.configPolicy" + ], + "@ohos.connectedTag": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.connectedTag" + ], + "@ohos.contact": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.contact" + ], + "@ohos.continuation.continuationManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.continuation.continuationManager" + ], + "@ohos.cooperate": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.cooperate" + ], + "@ohos.curves": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.curves" + ], + "@ohos.customization.customConfig": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.customization.customConfig" + ], + "@ohos.data.DataShareResultSet": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.DataShareResultSet" + ], + "@ohos.data.ValuesBucket": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.ValuesBucket" + ], + "@ohos.data.cloudData": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.cloudData" + ], + "@ohos.data.cloudExtension": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.cloudExtension" + ], + "@ohos.data.commonType": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.commonType" + ], + "@ohos.data.dataAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.dataAbility" + ], + "@ohos.data.dataShare": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.dataShare" + ], + "@ohos.data.dataSharePredicates": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.dataSharePredicates" + ], + "@ohos.data.distributedData": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.distributedData" + ], + "@ohos.data.distributedDataObject": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.distributedDataObject" + ], + "@ohos.data.distributedKVStore": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.distributedKVStore" + ], + "@ohos.data.preferences": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.preferences" + ], + "@ohos.data.rdb": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.rdb" + ], + "@ohos.data.relationalStore": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.relationalStore" + ], + "@ohos.data.sendablePreferences": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.sendablePreferences" + ], + "@ohos.data.sendableRelationalStore": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.sendableRelationalStore" + ], + "@ohos.data.storage": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.storage" + ], + "@ohos.data.unifiedDataChannel": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.unifiedDataChannel" + ], + "@ohos.data.uniformDataStruct": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.uniformDataStruct" + ], + "@ohos.data.uniformTypeDescriptor": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.data.uniformTypeDescriptor" + ], + "@ohos.deviceAttest": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.deviceAttest" + ], + "@ohos.deviceInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.deviceInfo" + ], + "@ohos.deviceStatus.dragInteraction": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.deviceStatus.dragInteraction" + ], + "@ohos.display": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.display" + ], + "@ohos.distributedBundle": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.distributedBundle" + ], + "@ohos.distributedDeviceManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.distributedDeviceManager" + ], + "@ohos.distributedHardware.deviceManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.distributedHardware.deviceManager" + ], + "@ohos.distributedHardware.hardwareManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.distributedHardware.hardwareManager" + ], + "@ohos.distributedMissionManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.distributedMissionManager" + ], + "@ohos.dlpPermission": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.dlpPermission" + ], + "@ohos.document": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.document" + ], + "@ohos.driver.deviceManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.driver.deviceManager" + ], + "@ohos.effectKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.effectKit" + ], + "@ohos.enterprise.EnterpriseAdminExtensionAbility": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.EnterpriseAdminExtensionAbility" + ], + "@ohos.enterprise.accountManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.accountManager" + ], + "@ohos.enterprise.adminManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.adminManager" + ], + "@ohos.enterprise.applicationManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.applicationManager" + ], + "@ohos.enterprise.bluetoothManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.bluetoothManager" + ], + "@ohos.enterprise.browser": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.browser" + ], + "@ohos.enterprise.bundleManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.bundleManager" + ], + "@ohos.enterprise.dateTimeManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.dateTimeManager" + ], + "@ohos.enterprise.deviceControl": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.deviceControl" + ], + "@ohos.enterprise.deviceInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.deviceInfo" + ], + "@ohos.enterprise.deviceSettings": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.deviceSettings" + ], + "@ohos.enterprise.locationManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.locationManager" + ], + "@ohos.enterprise.networkManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.networkManager" + ], + "@ohos.enterprise.restrictions": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.restrictions" + ], + "@ohos.enterprise.securityManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.securityManager" + ], + "@ohos.enterprise.systemManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.systemManager" + ], + "@ohos.enterprise.usbManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.usbManager" + ], + "@ohos.enterprise.wifiManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.enterprise.wifiManager" + ], + "@ohos.events.emitter": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.events.emitter" + ], + "@ohos.faultLogger": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.faultLogger" + ], + "@ohos.file.AlbumPickerComponent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.AlbumPickerComponent" + ], + "@ohos.file.BackupExtensionContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.BackupExtensionContext" + ], + "@ohos.file.PhotoPickerComponent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.PhotoPickerComponent" + ], + "@ohos.file.RecentPhotoComponent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.RecentPhotoComponent" + ], + "@ohos.file.backup": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.backup" + ], + "@ohos.file.cloudSync": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.cloudSync" + ], + "@ohos.file.cloudSyncManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.cloudSyncManager" + ], + "@ohos.file.environment": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.environment" + ], + "@ohos.file.fileAccess": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.fileAccess" + ], + "@ohos.file.fileExtensionInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.fileExtensionInfo" + ], + "@ohos.file.fileuri": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.fileuri" + ], + "@ohos.file.fs": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.fs" + ], + "@ohos.file.hash": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.hash" + ], + "@ohos.file.photoAccessHelper": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.photoAccessHelper" + ], + "@ohos.file.picker": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.picker" + ], + "@ohos.file.recent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.recent" + ], + "@ohos.file.securityLabel": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.securityLabel" + ], + "@ohos.file.sendablePhotoAccessHelper": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.sendablePhotoAccessHelper" + ], + "@ohos.file.statvfs": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.statvfs" + ], + "@ohos.file.storageStatistics": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.storageStatistics" + ], + "@ohos.file.trash": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.trash" + ], + "@ohos.file.volumeManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.file.volumeManager" + ], + "@ohos.fileio": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.fileio" + ], + "@ohos.filemanagement.userFileManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.filemanagement.userFileManager" + ], + "@ohos.fileshare": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.fileshare" + ], + "@ohos.font": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.font" + ], + "@ohos.geoLocationManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.geoLocationManager" + ], + "@ohos.geolocation": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.geolocation" + ], + "@ohos.graphics.colorSpaceManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.graphics.colorSpaceManager" + ], + "@ohos.graphics.common2D": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.graphics.common2D" + ], + "@ohos.graphics.displaySync": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.graphics.displaySync" + ], + "@ohos.graphics.drawing": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.graphics.drawing" + ], + "@ohos.graphics.hdrCapability": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.graphics.hdrCapability" + ], + "@ohos.graphics.scene": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.graphics.scene" + ], + "@ohos.graphics.sendableColorSpaceManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.graphics.sendableColorSpaceManager" + ], + "@ohos.graphics.text": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.graphics.text" + ], + "@ohos.graphics.uiEffect": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.graphics.uiEffect" + ], + "@ohos.hiAppEvent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.hiAppEvent" + ], + "@ohos.hiSysEvent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.hiSysEvent" + ], + "@ohos.hiTraceChain": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.hiTraceChain" + ], + "@ohos.hiTraceMeter": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.hiTraceMeter" + ], + "@ohos.hichecker": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.hichecker" + ], + "@ohos.hidebug": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.hidebug" + ], + "@ohos.hilog": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.hilog" + ], + "@ohos.hiviewdfx.hiAppEvent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.hiviewdfx.hiAppEvent" + ], + "@ohos.hiviewdfx.jsLeakWatcher": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.hiviewdfx.jsLeakWatcher" + ], + "@ohos.i18n": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.i18n" + ], + "@ohos.identifier.oaid": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.identifier.oaid" + ], + "@ohos.inputMethod.Panel": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.inputMethod.Panel" + ], + "@ohos.inputMethod": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.inputMethod" + ], + "@ohos.inputMethodEngine": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.inputMethodEngine" + ], + "@ohos.inputMethodList": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.inputMethodList" + ], + "@ohos.intl": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.intl" + ], + "@ohos.logLibrary": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.logLibrary" + ], + "@ohos.matrix4": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.matrix4" + ], + "@ohos.measure": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.measure" + ], + "@ohos.mediaquery": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.mediaquery" + ], + "@ohos.multimedia.audio": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimedia.audio" + ], + "@ohos.multimedia.audioHaptic": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimedia.audioHaptic" + ], + "@ohos.multimedia.avCastPicker": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimedia.avCastPicker" + ], + "@ohos.multimedia.avCastPickerParam": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimedia.avCastPickerParam" + ], + "@ohos.multimedia.avVolumePanel": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimedia.avVolumePanel" + ], + "@ohos.multimedia.avsession": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimedia.avsession" + ], + "@ohos.multimedia.camera": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimedia.camera" + ], + "@ohos.multimedia.cameraPicker": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimedia.cameraPicker" + ], + "@ohos.multimedia.drm": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimedia.drm" + ], + "@ohos.multimedia.image": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimedia.image" + ], + "@ohos.multimedia.media": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimedia.media" + ], + "@ohos.multimedia.movingphotoview": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimedia.movingphotoview" + ], + "@ohos.multimedia.sendableImage": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimedia.sendableImage" + ], + "@ohos.multimedia.systemSoundManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimedia.systemSoundManager" + ], + "@ohos.multimodalInput.gestureEvent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimodalInput.gestureEvent" + ], + "@ohos.multimodalInput.infraredEmitter": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimodalInput.infraredEmitter" + ], + "@ohos.multimodalInput.inputConsumer": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimodalInput.inputConsumer" + ], + "@ohos.multimodalInput.inputDevice": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimodalInput.inputDevice" + ], + "@ohos.multimodalInput.inputDeviceCooperate": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimodalInput.inputDeviceCooperate" + ], + "@ohos.multimodalInput.inputEvent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimodalInput.inputEvent" + ], + "@ohos.multimodalInput.inputEventClient": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimodalInput.inputEventClient" + ], + "@ohos.multimodalInput.inputMonitor": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimodalInput.inputMonitor" + ], + "@ohos.multimodalInput.intentionCode": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimodalInput.intentionCode" + ], + "@ohos.multimodalInput.keyCode": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimodalInput.keyCode" + ], + "@ohos.multimodalInput.keyEvent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimodalInput.keyEvent" + ], + "@ohos.multimodalInput.mouseEvent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimodalInput.mouseEvent" + ], + "@ohos.multimodalInput.pointer": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimodalInput.pointer" + ], + "@ohos.multimodalInput.shortKey": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimodalInput.shortKey" + ], + "@ohos.multimodalInput.touchEvent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.multimodalInput.touchEvent" + ], + "@ohos.net.connection": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.net.connection" + ], + "@ohos.net.ethernet": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.net.ethernet" + ], + "@ohos.net.http": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.net.http" + ], + "@ohos.net.mdns": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.net.mdns" + ], + "@ohos.net.netFirewall": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.net.netFirewall" + ], + "@ohos.net.networkSecurity": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.net.networkSecurity" + ], + "@ohos.net.policy": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.net.policy" + ], + "@ohos.net.sharing": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.net.sharing" + ], + "@ohos.net.socket": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.net.socket" + ], + "@ohos.net.statistics": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.net.statistics" + ], + "@ohos.net.vpn": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.net.vpn" + ], + "@ohos.net.vpnExtension": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.net.vpnExtension" + ], + "@ohos.net.webSocket": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.net.webSocket" + ], + "@ohos.nfc.cardEmulation": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.nfc.cardEmulation" + ], + "@ohos.nfc.controller": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.nfc.controller" + ], + "@ohos.nfc.tag": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.nfc.tag" + ], + "@ohos.notification": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.notification" + ], + "@ohos.notificationManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.notificationManager" + ], + "@ohos.notificationSubscribe": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.notificationSubscribe" + ], + "@ohos.pasteboard": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.pasteboard" + ], + "@ohos.pluginComponent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.pluginComponent" + ], + "@ohos.power": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.power" + ], + "@ohos.print": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.print" + ], + "@ohos.privacyManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.privacyManager" + ], + "@ohos.prompt": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.prompt" + ], + "@ohos.promptAction": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.promptAction" + ], + "@ohos.reminderAgent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.reminderAgent" + ], + "@ohos.reminderAgentManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.reminderAgentManager" + ], + "@ohos.request": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.request" + ], + "@ohos.resourceManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.resourceManager" + ], + "@ohos.resourceschedule.backgroundTaskManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.resourceschedule.backgroundTaskManager" + ], + "@ohos.resourceschedule.deviceStandby": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.resourceschedule.deviceStandby" + ], + "@ohos.resourceschedule.systemload": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.resourceschedule.systemload" + ], + "@ohos.resourceschedule.usageStatistics": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.resourceschedule.usageStatistics" + ], + "@ohos.resourceschedule.workScheduler": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.resourceschedule.workScheduler" + ], + "@ohos.router": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.router" + ], + "@ohos.rpc": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.rpc" + ], + "@ohos.runningLock": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.runningLock" + ], + "@ohos.screen": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.screen" + ], + "@ohos.screenLock": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.screenLock" + ], + "@ohos.screenshot": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.screenshot" + ], + "@ohos.secureElement": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.secureElement" + ], + "@ohos.security.asset": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.security.asset" + ], + "@ohos.security.cert": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.security.cert" + ], + "@ohos.security.certManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.security.certManager" + ], + "@ohos.security.certManagerDialog": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.security.certManagerDialog" + ], + "@ohos.security.cryptoFramework": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.security.cryptoFramework" + ], + "@ohos.security.huks": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.security.huks" + ], + "@ohos.security.securityGuard": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.security.securityGuard" + ], + "@ohos.sendableResourceManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.sendableResourceManager" + ], + "@ohos.sensor": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.sensor" + ], + "@ohos.settings": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.settings" + ], + "@ohos.statfs": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.statfs" + ], + "@ohos.stationary": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.stationary" + ], + "@ohos.systemCapability": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.systemCapability" + ], + "@ohos.systemDateTime": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.systemDateTime" + ], + "@ohos.systemParameterEnhance": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.systemParameterEnhance" + ], + "@ohos.systemTime": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.systemTime" + ], + "@ohos.systemTimer": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.systemTimer" + ], + "@ohos.systemparameter": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.systemparameter" + ], + "@ohos.telephony.call": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.telephony.call" + ], + "@ohos.telephony.data": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.telephony.data" + ], + "@ohos.telephony.observer": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.telephony.observer" + ], + "@ohos.telephony.radio": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.telephony.radio" + ], + "@ohos.telephony.sim": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.telephony.sim" + ], + "@ohos.telephony.sms": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.telephony.sms" + ], + "@ohos.telephony.vcard": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.telephony.vcard" + ], + "@ohos.thermal": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.thermal" + ], + "@ohos.uiAppearance": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.uiAppearance" + ], + "@ohos.uiExtensionHost": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.uiExtensionHost" + ], + "@ohos.update": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.update" + ], + "@ohos.uri": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.uri" + ], + "@ohos.url": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.url" + ], + "@ohos.usb": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.usb" + ], + "@ohos.usbManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.usbManager" + ], + "@ohos.userIAM.faceAuth": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.userIAM.faceAuth" + ], + "@ohos.userIAM.userAuth": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.userIAM.userAuth" + ], + "@ohos.userIAM.userAuthIcon": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.userIAM.userAuthIcon" + ], + "@ohos.util.ArrayList": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.util.ArrayList" + ], + "@ohos.util.Deque": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.util.Deque" + ], + "@ohos.util.HashMap": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.util.HashMap" + ], + "@ohos.util.HashSet": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.util.HashSet" + ], + "@ohos.util.LightWeightMap": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.util.LightWeightMap" + ], + "@ohos.util.LightWeightSet": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.util.LightWeightSet" + ], + "@ohos.util.LinkedList": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.util.LinkedList" + ], + "@ohos.util.List": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.util.List" + ], + "@ohos.util.PlainArray": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.util.PlainArray" + ], + "@ohos.util.Queue": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.util.Queue" + ], + "@ohos.util.Stack": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.util.Stack" + ], + "@ohos.util.TreeMap": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.util.TreeMap" + ], + "@ohos.util.TreeSet": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.util.TreeSet" + ], + "@ohos.util": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.util" + ], + "@ohos.util.json": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.util.json" + ], + "@ohos.util.stream": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.util.stream" + ], + "@ohos.vibrator": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.vibrator" + ], + "@ohos.wallpaper": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.wallpaper" + ], + "@ohos.wantAgent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.wantAgent" + ], + "@ohos.web.netErrorList": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.web.netErrorList" + ], + "@ohos.web.webview": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.web.webview" + ], + "@ohos.wifi": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.wifi" + ], + "@ohos.wifiManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.wifiManager" + ], + "@ohos.wifiManagerExt": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.wifiManagerExt" + ], + "@ohos.wifiext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.wifiext" + ], + "@ohos.window": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.window" + ], + "@ohos.worker": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.worker" + ], + "@ohos.zlib": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@ohos.zlib" + ], + "@ohos.@system.app": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.app" + ], + "@ohos.@system.battery": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.battery" + ], + "@ohos.@system.bluetooth": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.bluetooth" + ], + "@ohos.@system.brightness": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.brightness" + ], + "@ohos.@system.cipher": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.cipher" + ], + "@ohos.@system.configuration": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.configuration" + ], + "@ohos.@system.device": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.device" + ], + "@ohos.@system.fetch": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.fetch" + ], + "@ohos.@system.file": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.file" + ], + "@ohos.@system.geolocation": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.geolocation" + ], + "@ohos.@system.mediaquery": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.mediaquery" + ], + "@ohos.@system.network": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.network" + ], + "@ohos.@system.notification": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.notification" + ], + "@ohos.@system.package": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.package" + ], + "@ohos.@system.prompt": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.prompt" + ], + "@ohos.@system.request": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.request" + ], + "@ohos.@system.router": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.router" + ], + "@ohos.@system.sensor": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.sensor" + ], + "@ohos.@system.storage": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.storage" + ], + "@ohos.@system.vibrator": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/@system.vibrator" + ], + "@ohos.ability.abilityResult": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/ability/abilityResult" + ], + "@ohos.ability.connectOptions": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/ability/connectOptions" + ], + "@ohos.ability.dataAbilityHelper": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/ability/dataAbilityHelper" + ], + "@ohos.ability.dataAbilityOperation": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/ability/dataAbilityOperation" + ], + "@ohos.ability.dataAbilityResult": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/ability/dataAbilityResult" + ], + "@ohos.ability.startAbilityParameter": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/ability/startAbilityParameter" + ], + "@ohos.ability.want": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/ability/want" + ], + "@ohos.advertising.advertisement": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/advertising/advertisement" + ], + "@ohos.app.appVersionInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/app/appVersionInfo" + ], + "@ohos.app.context": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/app/context" + ], + "@ohos.app.processInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/app/processInfo" + ], + "@ohos.application.AbilityDelegator": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AbilityDelegator" + ], + "@ohos.application.AbilityFirstFrameStateData": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AbilityFirstFrameStateData" + ], + "@ohos.application.AbilityFirstFrameStateObserver": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AbilityFirstFrameStateObserver" + ], + "@ohos.application.AbilityForegroundStateObserver": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AbilityForegroundStateObserver" + ], + "@ohos.application.AbilityMonitor": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AbilityMonitor" + ], + "@ohos.application.AbilityRunningInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AbilityRunningInfo" + ], + "@ohos.application.AbilityStageContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AbilityStageContext" + ], + "@ohos.application.AbilityStageMonitor": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AbilityStageMonitor" + ], + "@ohos.application.AbilityStartCallback": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AbilityStartCallback" + ], + "@ohos.application.AbilityStateData": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AbilityStateData" + ], + "@ohos.application.AccessibilityExtensionContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AccessibilityExtensionContext" + ], + "@ohos.application.AppForegroundStateObserver": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AppForegroundStateObserver" + ], + "@ohos.application.AppStateData": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AppStateData" + ], + "@ohos.application.ApplicationContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/ApplicationContext" + ], + "@ohos.application.ApplicationStateObserver": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/ApplicationStateObserver" + ], + "@ohos.application.AutoFillExtensionContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AutoFillExtensionContext" + ], + "@ohos.application.AutoFillPopupConfig": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AutoFillPopupConfig" + ], + "@ohos.application.AutoFillRect": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AutoFillRect" + ], + "@ohos.application.AutoFillRequest": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AutoFillRequest" + ], + "@ohos.application.AutoFillType": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AutoFillType" + ], + "@ohos.application.AutoStartupCallback": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AutoStartupCallback" + ], + "@ohos.application.AutoStartupInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/AutoStartupInfo" + ], + "@ohos.application.BaseContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/BaseContext" + ], + "@ohos.application.BusinessAbilityInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/BusinessAbilityInfo" + ], + "@ohos.application.Context": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/Context" + ], + "@ohos.application.ContinuableInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/ContinuableInfo" + ], + "@ohos.application.ContinueCallback": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/ContinueCallback" + ], + "@ohos.application.ContinueDeviceInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/ContinueDeviceInfo" + ], + "@ohos.application.ContinueMissionInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/ContinueMissionInfo" + ], + "@ohos.application.CustomData": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/CustomData" + ], + "@ohos.application.DriverExtensionContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/DriverExtensionContext" + ], + "@ohos.application.EmbeddableUIAbilityContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/EmbeddableUIAbilityContext" + ], + "@ohos.application.ErrorObserver": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/ErrorObserver" + ], + "@ohos.application.EventHub": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/EventHub" + ], + "@ohos.application.ExtensionContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/ExtensionContext" + ], + "@ohos.application.ExtensionRunningInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/ExtensionRunningInfo" + ], + "@ohos.application.FormExtensionContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/FormExtensionContext" + ], + "@ohos.application.LoopObserver": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/LoopObserver" + ], + "@ohos.application.MediaControlExtensionContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/MediaControlExtensionContext" + ], + "@ohos.application.MissionCallbacks": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/MissionCallbacks" + ], + "@ohos.application.MissionDeviceInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/MissionDeviceInfo" + ], + "@ohos.application.MissionInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/MissionInfo" + ], + "@ohos.application.MissionListener": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/MissionListener" + ], + "@ohos.application.MissionParameter": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/MissionParameter" + ], + "@ohos.application.MissionSnapshot": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/MissionSnapshot" + ], + "@ohos.application.MultiAppMode": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/MultiAppMode" + ], + "@ohos.application.PageNodeInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/PageNodeInfo" + ], + "@ohos.application.PhotoEditorExtensionContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/PhotoEditorExtensionContext" + ], + "@ohos.application.ProcessData": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/ProcessData" + ], + "@ohos.application.ProcessInformation": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/ProcessInformation" + ], + "@ohos.application.ProcessRunningInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/ProcessRunningInfo" + ], + "@ohos.application.RunningAppClone": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/RunningAppClone" + ], + "@ohos.application.RunningMultiAppInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/RunningMultiAppInfo" + ], + "@ohos.application.RunningMultiInstanceInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/RunningMultiInstanceInfo" + ], + "@ohos.application.SendableContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/SendableContext" + ], + "@ohos.application.ServiceExtensionContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/ServiceExtensionContext" + ], + "@ohos.application.UIAbilityContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/UIAbilityContext" + ], + "@ohos.application.UIExtensionContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/UIExtensionContext" + ], + "@ohos.application.UIServiceExtensionConnectCallback": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/UIServiceExtensionConnectCallback" + ], + "@ohos.application.UIServiceExtensionContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/UIServiceExtensionContext" + ], + "@ohos.application.UIServiceHostProxy": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/UIServiceHostProxy" + ], + "@ohos.application.UIServiceProxy": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/UIServiceProxy" + ], + "@ohos.application.ViewData": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/ViewData" + ], + "@ohos.application.VpnExtensionContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/VpnExtensionContext" + ], + "@ohos.application.WindowExtensionContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/WindowExtensionContext" + ], + "@ohos.application.WorkSchedulerExtensionContext": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/WorkSchedulerExtensionContext" + ], + "@ohos.application.abilityDelegatorArgs": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/abilityDelegatorArgs" + ], + "@ohos.application.shellCmdResult": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/application/shellCmdResult" + ], + "@ohos.arkui.AlphabetIndexerModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/AlphabetIndexerModifier" + ], + "@ohos.arkui.AttributeUpdater": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/AttributeUpdater" + ], + "@ohos.arkui.BlankModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/BlankModifier" + ], + "@ohos.arkui.BuilderNode": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/BuilderNode" + ], + "@ohos.arkui.ButtonModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/ButtonModifier" + ], + "@ohos.arkui.CalendarPickerModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/CalendarPickerModifier" + ], + "@ohos.arkui.CheckboxGroupModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/CheckboxGroupModifier" + ], + "@ohos.arkui.CheckboxModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/CheckboxModifier" + ], + "@ohos.arkui.ColumnModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/ColumnModifier" + ], + "@ohos.arkui.ColumnSplitModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/ColumnSplitModifier" + ], + "@ohos.arkui.CommonModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/CommonModifier" + ], + "@ohos.arkui.ComponentContent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/ComponentContent" + ], + "@ohos.arkui.ContainerSpanModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/ContainerSpanModifier" + ], + "@ohos.arkui.Content": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/Content" + ], + "@ohos.arkui.CounterModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/CounterModifier" + ], + "@ohos.arkui.DataPanelModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/DataPanelModifier" + ], + "@ohos.arkui.DatePickerModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/DatePickerModifier" + ], + "@ohos.arkui.DividerModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/DividerModifier" + ], + "@ohos.arkui.FormComponentModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/FormComponentModifier" + ], + "@ohos.arkui.FrameNode": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/FrameNode" + ], + "@ohos.arkui.GaugeModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/GaugeModifier" + ], + "@ohos.arkui.Graphics": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/Graphics" + ], + "@ohos.arkui.GridColModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/GridColModifier" + ], + "@ohos.arkui.GridItemModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/GridItemModifier" + ], + "@ohos.arkui.GridModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/GridModifier" + ], + "@ohos.arkui.GridRowModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/GridRowModifier" + ], + "@ohos.arkui.HyperlinkModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/HyperlinkModifier" + ], + "@ohos.arkui.ImageAnimatorModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/ImageAnimatorModifier" + ], + "@ohos.arkui.ImageModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/ImageModifier" + ], + "@ohos.arkui.ImageSpanModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/ImageSpanModifier" + ], + "@ohos.arkui.LineModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/LineModifier" + ], + "@ohos.arkui.ListItemGroupModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/ListItemGroupModifier" + ], + "@ohos.arkui.ListItemModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/ListItemModifier" + ], + "@ohos.arkui.ListModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/ListModifier" + ], + "@ohos.arkui.LoadingProgressModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/LoadingProgressModifier" + ], + "@ohos.arkui.MarqueeModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/MarqueeModifier" + ], + "@ohos.arkui.MenuItemModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/MenuItemModifier" + ], + "@ohos.arkui.MenuModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/MenuModifier" + ], + "@ohos.arkui.NavDestinationModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/NavDestinationModifier" + ], + "@ohos.arkui.NavRouterModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/NavRouterModifier" + ], + "@ohos.arkui.NavigationModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/NavigationModifier" + ], + "@ohos.arkui.NavigatorModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/NavigatorModifier" + ], + "@ohos.arkui.NodeContent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/NodeContent" + ], + "@ohos.arkui.NodeController": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/NodeController" + ], + "@ohos.arkui.PanelModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/PanelModifier" + ], + "@ohos.arkui.ParticleModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/ParticleModifier" + ], + "@ohos.arkui.PathModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/PathModifier" + ], + "@ohos.arkui.PatternLockModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/PatternLockModifier" + ], + "@ohos.arkui.PolygonModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/PolygonModifier" + ], + "@ohos.arkui.PolylineModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/PolylineModifier" + ], + "@ohos.arkui.ProgressModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/ProgressModifier" + ], + "@ohos.arkui.QRCodeModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/QRCodeModifier" + ], + "@ohos.arkui.RadioModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/RadioModifier" + ], + "@ohos.arkui.RatingModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/RatingModifier" + ], + "@ohos.arkui.RectModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/RectModifier" + ], + "@ohos.arkui.RefreshModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/RefreshModifier" + ], + "@ohos.arkui.RenderNode": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/RenderNode" + ], + "@ohos.arkui.RichEditorModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/RichEditorModifier" + ], + "@ohos.arkui.RowModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/RowModifier" + ], + "@ohos.arkui.RowSplitModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/RowSplitModifier" + ], + "@ohos.arkui.ScrollModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/ScrollModifier" + ], + "@ohos.arkui.SearchModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/SearchModifier" + ], + "@ohos.arkui.SelectModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/SelectModifier" + ], + "@ohos.arkui.ShapeModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/ShapeModifier" + ], + "@ohos.arkui.SideBarContainerModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/SideBarContainerModifier" + ], + "@ohos.arkui.SliderModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/SliderModifier" + ], + "@ohos.arkui.SpanModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/SpanModifier" + ], + "@ohos.arkui.StackModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/StackModifier" + ], + "@ohos.arkui.StepperItemModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/StepperItemModifier" + ], + "@ohos.arkui.SwiperModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/SwiperModifier" + ], + "@ohos.arkui.SymbolGlyphModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/SymbolGlyphModifier" + ], + "@ohos.arkui.SymbolSpanModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/SymbolSpanModifier" + ], + "@ohos.arkui.TabsModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/TabsModifier" + ], + "@ohos.arkui.TextAreaModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/TextAreaModifier" + ], + "@ohos.arkui.TextClockModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/TextClockModifier" + ], + "@ohos.arkui.TextInputModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/TextInputModifier" + ], + "@ohos.arkui.TextModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/TextModifier" + ], + "@ohos.arkui.TextPickerModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/TextPickerModifier" + ], + "@ohos.arkui.TextTimerModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/TextTimerModifier" + ], + "@ohos.arkui.TimePickerModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/TimePickerModifier" + ], + "@ohos.arkui.ToggleModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/ToggleModifier" + ], + "@ohos.arkui.VideoModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/VideoModifier" + ], + "@ohos.arkui.WaterFlowModifier": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/WaterFlowModifier" + ], + "@ohos.arkui.XComponentNode": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/XComponentNode" + ], + "@ohos.arkui.component.column": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/component/column" + ], + "@ohos.arkui.component.common": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/component/common" + ], + "@ohos.arkui.component.customComponent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/component/customComponent" + ], + "@ohos.arkui.component.enums": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/component/enums" + ], + "@ohos.arkui.component.styledString": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/component/styledString" + ], + "@ohos.arkui.component.text": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/component/text" + ], + "@ohos.arkui.component.units": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/component/units" + ], + "@ohos.arkui.external.resource": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/external/resource" + ], + "@koalaui.arkts-arkui.Button": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.arkts-arkui.Button" + ], + "@koalaui.arkts-arkui.Column": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.arkts-arkui.Column" + ], + "@koalaui.arkts-arkui.Common": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.arkts-arkui.Common" + ], + "@koalaui.arkts-arkui.StructBase": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.arkts-arkui.StructBase" + ], + "@koalaui.arkts-arkui.Text": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.arkts-arkui.Text" + ], + "@koalaui.arkts-arkui.UserView": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.arkts-arkui.UserView" + ], + "@koalaui.runtime.annotations": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.annotations" + ], + "@koalaui.runtime.common": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.common" + ], + "@koalaui.runtime.internals": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.internals" + ], + "@koalaui.runtime.memo.bind": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.memo.bind" + ], + "@koalaui.runtime.memo.changeListener": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.memo.changeListener" + ], + "@koalaui.runtime.memo.contextLocal": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.memo.contextLocal" + ], + "@koalaui.runtime.memo.entry": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.memo.entry" + ], + "@koalaui.runtime.memo.node": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.memo.node" + ], + "@koalaui.runtime.memo.remember": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.memo.remember" + ], + "@koalaui.runtime.memo.repeat": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.memo.repeat" + ], + "@koalaui.runtime.memo.testing": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.memo.testing" + ], + "@koalaui.runtime.states.Disposable": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.states.Disposable" + ], + "@koalaui.runtime.states.GlobalStateManager": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.states.GlobalStateManager" + ], + "@koalaui.runtime.states.State": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.states.State" + ], + "@koalaui.runtime.tree.IncrementalNode": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.tree.IncrementalNode" + ], + "@koalaui.runtime.tree.PrimeNumbers": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.tree.PrimeNumbers" + ], + "@koalaui.runtime.tree.ReadonlyTreeNode": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.tree.ReadonlyTreeNode" + ], + "@koalaui.runtime.tree.TreeNode": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.tree.TreeNode" + ], + "@koalaui.runtime.tree.TreePath": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/runtime-api/@koalaui.runtime.tree.TreePath" + ], + "@ohos.arkui.stateManagement.common": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/stateManagement/common" + ], + "@ohos.arkui.stateManagement.runtime": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/stateManagement/runtime" + ], + "@ohos.arkui.stateManagement.storage": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/arkui/stateManagement/storage" + ], + "@ohos.bundle.PermissionDef": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundle/PermissionDef" + ], + "@ohos.bundle.abilityInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundle/abilityInfo" + ], + "@ohos.bundle.applicationInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundle/applicationInfo" + ], + "@ohos.bundle.bundleInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundle/bundleInfo" + ], + "@ohos.bundle.bundleInstaller": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundle/bundleInstaller" + ], + "@ohos.bundle.bundleStatusCallback": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundle/bundleStatusCallback" + ], + "@ohos.bundle.customizeData": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundle/customizeData" + ], + "@ohos.bundle.elementName": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundle/elementName" + ], + "@ohos.bundle.hapModuleInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundle/hapModuleInfo" + ], + "@ohos.bundle.launcherAbilityInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundle/launcherAbilityInfo" + ], + "@ohos.bundle.moduleInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundle/moduleInfo" + ], + "@ohos.bundle.remoteAbilityInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundle/remoteAbilityInfo" + ], + "@ohos.bundle.shortcutInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundle/shortcutInfo" + ], + "@ohos.bundleManager.AbilityInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/AbilityInfo" + ], + "@ohos.bundleManager.AppProvisionInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/AppProvisionInfo" + ], + "@ohos.bundleManager.ApplicationInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/ApplicationInfo" + ], + "@ohos.bundleManager.BundleInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/BundleInfo" + ], + "@ohos.bundleManager.BundlePackInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/BundlePackInfo" + ], + "@ohos.bundleManager.BundleResourceInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/BundleResourceInfo" + ], + "@ohos.bundleManager.DispatchInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/DispatchInfo" + ], + "@ohos.bundleManager.ElementName": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/ElementName" + ], + "@ohos.bundleManager.ExtensionAbilityInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/ExtensionAbilityInfo" + ], + "@ohos.bundleManager.HapModuleInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/HapModuleInfo" + ], + "@ohos.bundleManager.LauncherAbilityInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/LauncherAbilityInfo" + ], + "@ohos.bundleManager.LauncherAbilityResourceInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/LauncherAbilityResourceInfo" + ], + "@ohos.bundleManager.Metadata": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/Metadata" + ], + "@ohos.bundleManager.OverlayModuleInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/OverlayModuleInfo" + ], + "@ohos.bundleManager.PermissionDef": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/PermissionDef" + ], + "@ohos.bundleManager.RecoverableApplicationInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/RecoverableApplicationInfo" + ], + "@ohos.bundleManager.RemoteAbilityInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/RemoteAbilityInfo" + ], + "@ohos.bundleManager.SharedBundleInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/SharedBundleInfo" + ], + "@ohos.bundleManager.ShortcutInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/ShortcutInfo" + ], + "@ohos.bundleManager.Skill": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/bundleManager/Skill" + ], + "@ohos.commonEvent.commonEventData": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/commonEvent/commonEventData" + ], + "@ohos.commonEvent.commonEventPublishData": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/commonEvent/commonEventPublishData" + ], + "@ohos.commonEvent.commonEventSubscribeInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/commonEvent/commonEventSubscribeInfo" + ], + "@ohos.commonEvent.commonEventSubscriber": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/commonEvent/commonEventSubscriber" + ], + "@ohos.continuation.continuationExtraParams": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/continuation/continuationExtraParams" + ], + "@ohos.continuation.continuationResult": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/continuation/continuationResult" + ], + "@ohos.data.rdb.resultSet": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/data/rdb/resultSet" + ], + "@ohos.device-define.default.json": [ + "" + ], + "@ohos.device-define.liteWearable.json": [ + "" + ], + "@ohos.device-define.tablet.json": [ + "" + ], + "@ohos.device-define.wearable.json": [ + "" + ], + "@ohos.global.rawFileDescriptor": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/global/rawFileDescriptor" + ], + "@ohos.global.resource": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/global/resource" + ], + "@ohos.global.sendableResource": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/global/sendableResource" + ], + "@ohos.graphics3d.Scene": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/graphics3d/Scene" + ], + "@ohos.graphics3d.SceneNodes": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/graphics3d/SceneNodes" + ], + "@ohos.graphics3d.ScenePostProcessSettings": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/graphics3d/ScenePostProcessSettings" + ], + "@ohos.graphics3d.SceneResources": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/graphics3d/SceneResources" + ], + "@ohos.graphics3d.SceneTypes": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/graphics3d/SceneTypes" + ], + "@ohos.multimedia.ringtonePlayer": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/multimedia/ringtonePlayer" + ], + "@ohos.multimedia.soundPool": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/multimedia/soundPool" + ], + "@ohos.multimedia.systemTonePlayer": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/multimedia/systemTonePlayer" + ], + "@ohos.notification.NotificationCommonDef": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/notification/NotificationCommonDef" + ], + "@ohos.notification.notificationActionButton": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/notification/notificationActionButton" + ], + "@ohos.notification.notificationContent": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/notification/notificationContent" + ], + "@ohos.notification.notificationFlags": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/notification/notificationFlags" + ], + "@ohos.notification.notificationRequest": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/notification/notificationRequest" + ], + "@ohos.notification.notificationSlot": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/notification/notificationSlot" + ], + "@ohos.notification.notificationSorting": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/notification/notificationSorting" + ], + "@ohos.notification.notificationSortingMap": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/notification/notificationSortingMap" + ], + "@ohos.notification.notificationSubscribeInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/notification/notificationSubscribeInfo" + ], + "@ohos.notification.notificationSubscriber": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/notification/notificationSubscriber" + ], + "@ohos.notification.notificationTemplate": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/notification/notificationTemplate" + ], + "@ohos.notification.notificationUserInput": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/notification/notificationUserInput" + ], + "@ohos.permissions": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/permissions" + ], + "@ohos.security.PermissionRequestResult": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/security/PermissionRequestResult" + ], + "@ohos.tag.nfctech": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/tag/nfctech" + ], + "@ohos.tag.tagSession": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/tag/tagSession" + ], + "@ohos.wantAgent.triggerInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/wantAgent/triggerInfo" + ], + "@ohos.wantAgent.wantAgentInfo": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/api/wantAgent/wantAgentInfo" + ], + "@ohos.@arkts.collections": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/arkts/@arkts.collections" + ], + "@ohos.@arkts.lang": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/arkts/@arkts.lang" + ], + "@ohos.@arkts.math.Decimal": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/arkts/@arkts.math.Decimal" + ], + "@ohos.@arkts.utils": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/arkts/@arkts.utils" + ], + "@ohos.@kit.AVSessionKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.AVSessionKit" + ], + "@ohos.@kit.AbilityKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.AbilityKit" + ], + "@ohos.@kit.AccessibilityKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.AccessibilityKit" + ], + "@ohos.@kit.AdsKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.AdsKit" + ], + "@ohos.@kit.ArkData": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.ArkData" + ], + "@ohos.@kit.ArkGraphics2D": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.ArkGraphics2D" + ], + "@ohos.@kit.ArkGraphics3D": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.ArkGraphics3D" + ], + "@ohos.@kit.ArkTS": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.ArkTS" + ], + "@ohos.@kit.ArkUI": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.ArkUI" + ], + "@ohos.@kit.ArkWeb": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.ArkWeb" + ], + "@ohos.@kit.AssetStoreKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.AssetStoreKit" + ], + "@ohos.@kit.AudioKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.AudioKit" + ], + "@ohos.@kit.BackgroundTasksKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.BackgroundTasksKit" + ], + "@ohos.@kit.BasicServicesKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.BasicServicesKit" + ], + "@ohos.@kit.CalendarKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.CalendarKit" + ], + "@ohos.@kit.CameraKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.CameraKit" + ], + "@ohos.@kit.ConnectivityKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.ConnectivityKit" + ], + "@ohos.@kit.ContactsKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.ContactsKit" + ], + "@ohos.@kit.CoreFileKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.CoreFileKit" + ], + "@ohos.@kit.CryptoArchitectureKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.CryptoArchitectureKit" + ], + "@ohos.@kit.DataLossPreventionKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.DataLossPreventionKit" + ], + "@ohos.@kit.DataProtectionKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.DataProtectionKit" + ], + "@ohos.@kit.DeviceCertificateKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.DeviceCertificateKit" + ], + "@ohos.@kit.DistributedServiceKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.DistributedServiceKit" + ], + "@ohos.@kit.DriverDevelopmentKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.DriverDevelopmentKit" + ], + "@ohos.@kit.DrmKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.DrmKit" + ], + "@ohos.@kit.FormKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.FormKit" + ], + "@ohos.@kit.IMEKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.IMEKit" + ], + "@ohos.@kit.IPCKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.IPCKit" + ], + "@ohos.@kit.ImageKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.ImageKit" + ], + "@ohos.@kit.InputKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.InputKit" + ], + "@ohos.@kit.LocalizationKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.LocalizationKit" + ], + "@ohos.@kit.LocationKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.LocationKit" + ], + "@ohos.@kit.MDMKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.MDMKit" + ], + "@ohos.@kit.MediaKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.MediaKit" + ], + "@ohos.@kit.MediaLibraryKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.MediaLibraryKit" + ], + "@ohos.@kit.MindSporeLiteKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.MindSporeLiteKit" + ], + "@ohos.@kit.MultimodalAwarenessKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.MultimodalAwarenessKit" + ], + "@ohos.@kit.NetworkKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.NetworkKit" + ], + "@ohos.@kit.NotificationKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.NotificationKit" + ], + "@ohos.@kit.PerformanceAnalysisKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.PerformanceAnalysisKit" + ], + "@ohos.@kit.SecurityGuardKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.SecurityGuardKit" + ], + "@ohos.@kit.SensorServiceKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.SensorServiceKit" + ], + "@ohos.@kit.TelephonyKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.TelephonyKit" + ], + "@ohos.@kit.TestKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.TestKit" + ], + "@ohos.@kit.UniversalKeystoreKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.UniversalKeystoreKit" + ], + "@ohos.@kit.UserAuthenticationKit": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.UserAuthenticationKit" + ], + "@ohos.@kit.network": [ + "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/kits/@kit.network" + ] + }, + "entry": "", + "dynamicPaths": {} + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/interop/1.2State-1.1Link-example.ets b/ets1.2/arkui-plugins/test/demo/interop/1.2State-1.1Link-example.ets new file mode 100644 index 0000000000000000000000000000000000000000..f11af005fc6f85e9e3a05e8f2f4cbd88a7f6f15c --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/interop/1.2State-1.1Link-example.ets @@ -0,0 +1,104 @@ +/* + * 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. + */ + + +// ArkTS1.2 +import { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" // should be insert by ui-plugins +import { ArkUICompatible, InteropComponent, Text, TextAttribute, Column, Component, Button, ButtonAttribute, ClickEvent, UserView, } from "@ohos.arkui.component" // TextAttribute should be insert by ui-plugins +import { State, StateDecoratedVariable, MutableState, stateOf, observableProxy, Observed, Track, Provide, Consume } from "@ohos.arkui.stateManagement" // should be insert by ui-plugins +import { MyText } from 'har2/src/main/ets/components/MainPage' +import { Child1 } from 'har1' + + +@Component +struct MyStateSample { + @State stateVar: new MyText(); + build() { + Column() { + Button(this.stateVar.text) + .onClick((e: ClickEvent) => { + this.stateVar.text += '~'; + }) + Child1({stateVar: this.stateVar, text: this.stateVar}) + } + } +} + +class MyText { + text: string = 'MyText'; +} + + +//ArkT1.1 +import { MyText } from 'har2/src/main/ets/components/MainPage' + +@Component +export struct Child1{ + @Link stateVar: MyText; + @Link text: MyText; + build() { + Column() { + Button(this.stateVar.text) + .onClick(() => { + this.stateVar.text += '~'; + }) + Button(this.text.text) + .onClick(() => { + this.text.text = 'ArkTS1.1'; + }) + } + } +} + + +//transform 1.1struct 'Child1' to ArkUICompatible + +ArkUICompatible(__memo_context, ((__memo_id) + (252133223)), (() => { + let global = ESValue.getGlobal(); + let param = ESValue.instantiateEmptyObject(); + let createState = global.getProperty("createStateVariable"); + let stateVar_SetSource = ((value: B) => { + (this).stateVar = value; + }); + let stateVar_ProxyState = createState.invoke(ESValue.wrap((this).stateVar), ESValue.wrap(stateVar_SetSource)); + (this).__backing_stateVar!.setProxy(stateVar_ProxyState); + let stateVar_SetProxy = ((value: B) => { + stateVar_ProxyState.invokeMethod("set", ESValue.wrap(value)); + }); + (this).__backing_stateVar!.setProxyValue = stateVar_SetProxy; + let stateVar_NotifyCallback = ((propertyName: string) => { + stateVar_ProxyState.invokeMethod("notifyPropertyHasChangedPU"); + }); + (this).__backing_stateVar!.setNotifyCallback(stateVar_NotifyCallback); + param.setProperty("stateVar", stateVar_ProxyState); + param.setProperty("text", stateVar_ProxyState); + let extraInfo = ESValue.instantiateEmptyObject(); + extraInfo.setProperty("page", "har1/src/main/ets/components/MainPage"); + let esundefined = ESValue.wrap(undefined); + let blank = (() => {}); + let esblank = ESValue.wrap((blank as object)); + let viewStackProcessor = global.getProperty("ViewStackProcessor"); + let createId = viewStackProcessor.getProperty("AllocateNewElmetIdForNextComponent"); + let elmtId = createId.invoke(); + let har1 = ESValue.load("@normalized:N&entry&com.example.Interop2use1&har1/src/main/ets/components/MainPage&1.0.0"); + let structObject = har1.getProperty("Child1"); + let component = structObject.instantiate(esundefined, param, esundefined, elmtId, esblank, extraInfo); + let create = structObject.getProperty("create"); + create.invoke(component); + return { + component: component, + name: "Child1", + }; +}), ((instance: ESValue) => {})); \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/localtest/build_config_template.json b/ets1.2/arkui-plugins/test/demo/localtest/build_config_template.json new file mode 100755 index 0000000000000000000000000000000000000000..3855891d1837393be886fb41105f72b95307f0df --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/localtest/build_config_template.json @@ -0,0 +1,25 @@ +{ + "plugins": { + "ui-syntax-plugin": "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/ui-plugins/lib/ui-syntax-plugins/index", + "ui_plugin": "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/ui-plugins/lib/ui-plugins/index", + "memo_plugin": "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/ui-plugins/lib/memo-plugins/index" + }, + + "compileFiles": [ + "./demo/localtest/entry/new.ets" + ], + + "packageName" : "entry", + + "buildType": "build", + "buildMode": "Debug", + "moduleRootPath": "./demo/localtest/entry/", + "sourceRoots": ["./"], + + "loaderOutPath": "./dist", + "cachePath": "./dist/cache", + + "buildSdkPath": "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/", + + "dependentModuleList": [] +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/localtest/build_decl_config_template.json b/ets1.2/arkui-plugins/test/demo/localtest/build_decl_config_template.json new file mode 100644 index 0000000000000000000000000000000000000000..fc58a0e00cabfba924d9cb7f873a3b14efd0358d --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/localtest/build_decl_config_template.json @@ -0,0 +1,29 @@ +{ + "plugins": { + "interop_plugin": "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/ui-plugins/lib/interop-plugins/index" + }, + + "compileFiles": [ + "./demo/localtest/entry/new.ets" + ], + + "packageName" : "entry", + + "buildType": "build", + "buildMode": "Debug", + "moduleRootPath": "./demo/localtest/entry/", + "sourceRoots": ["./"], + + "loaderOutPath": "./dist", + "cachePath": "./dist/cache", + + "buildSdkPath": "workspace/out/sdk/ohos-sdk/linux/ets/ets1.2/", + + "dependentModuleList": [], + + "isIDE": "false", + "enableDeclgenEts2Ts": true, + + "declgenV1OutPath": "workspace/developtools/ace_ets2bundle/arkui-plugins/test/demo/hello_world/declgenV1OutPath", + "declgenBridgeCodePath": "workspace/developtools/ace_ets2bundle/arkui-plugins/test/demo/hello_world/declgenBridgeCodePath" +} diff --git a/ets1.2/arkui-plugins/test/demo/localtest/entry/index.ets b/ets1.2/arkui-plugins/test/demo/localtest/entry/index.ets new file mode 100644 index 0000000000000000000000000000000000000000..c54a0d1535beb24b839528d630e01201cd4010fa --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/localtest/entry/index.ets @@ -0,0 +1,47 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement"; +import { Text, Column, Component, Button, ClickEvent } from "@ohos.arkui.component"; + +import hilog from '@ohos.hilog'; + +@Component +export struct MyStateSample { + message: string = "Click"; + + build() { + Column(undefined) { + Text("Hello World") + .fontSize(20) + Button(this.message) + .backgroundColor("#FFFF00FF") + .onClick((e: ClickEvent) => { + hilog.info(0x0000, 'testTag', 'On Click'); + }) + Child() + } + } +} + +@Component +export struct Child { + stateVar: string = "Child"; + + build() { + Text(this.stateVar) + .fontSize(50) + } +} diff --git a/ets1.2/arkui-plugins/test/demo/localtest/entry/new.ets b/ets1.2/arkui-plugins/test/demo/localtest/entry/new.ets new file mode 100755 index 0000000000000000000000000000000000000000..acdb7c3c36ccd065e27692e8c22b6389c1b4e15c --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/localtest/entry/new.ets @@ -0,0 +1,72 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" // should be insert by ui-plugins +import { Text, TextAttribute, Column, Component, Button, ButtonAttribute, ClickEvent, UserView } from "@ohos.arkui.component" // TextAttribute should be insert by ui-plugins +import { State, Link, StateDecoratedVariable, LinkDecoratedVariable,MutableState, stateOf, observableProxy } from "@ohos.arkui.stateManagement" // should be insert by ui-plugins +import hilog from '@ohos.hilog' + +function ArkUICompatible(init:(elmtId: number, instance: ESObject) => void, update: ((elmtId: number, instance: ESObject) => void)) { + +} + +@Component +struct MyStateSample { + @State stateVar: string = "Parent"; + message: string = "var"; + changeValue() { + this.stateVar+="~"; + } + build() { + Column(undefined) { + Button("ParentChange").backgroundColor("#FFFF00FF") + .onClick((e: ClickEvent) => { + hilog.info(0x0000, 'testTag', 'On Click'); + this.changeValue(); + }) + Text(this.stateVar).fontSize(20) + ChildLink({stateVar: this.stateVar, stateVar1: this.stateVar, stateVar2: ""} as __Options_ChildLink) + } + } +} + +@Component +struct ChildLink { + @Link stateVar: string = "Child"; + @State stateVar1: string = "Child"; + @Link stateVar2: string = "Child"; + changeValue() { + this.stateVar+="~"; + } + build() { + Button("ChildChange").backgroundColor("#FFFF00FF") + .onClick((e: ClickEvent) => { + hilog.info(0x0000, 'testTag', 'On Click'); + this.changeValue(); + }) + Text(this.stateVar).fontSize(50) + } +} + +export class ComExampleTrivialApplication extends UserView { + getBuilder() { + hilog.info(0x0000, 'testTag', 'getBuilder'); + let wrapper = @memo () => { + hilog.info(0x0000, 'testTag', 'MyStateSample'); + MyStateSample(undefined); + } + return wrapper; + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/animation/animation-basic.ets b/ets1.2/arkui-plugins/test/demo/mock/animation/animation-basic.ets new file mode 100644 index 0000000000000000000000000000000000000000..35c26e459a4c6afc5645652a62c0f063639a1703 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/animation/animation-basic.ets @@ -0,0 +1,17 @@ +import { Text, Column, Component, Color, Curve } from "@ohos.arkui.component" +import { Entry } from "@ohos.arkui.component" + +@Entry +@Component +struct AnimatablePropertyExample { + build() { + Column() { + Text("AnimatableProperty") + .backgroundColor(Color.Red) + .animation({ duration: 2000, curve: Curve.Ease }) + .fontSize(20) + .animation({ duration: 2000, curve: Curve.Ease }) + .width("100%") + } + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/builder-lambda/custom-component/custom-component-call.ets b/ets1.2/arkui-plugins/test/demo/mock/builder-lambda/custom-component/custom-component-call.ets new file mode 100644 index 0000000000000000000000000000000000000000..4da86661b7a4e9e51841d53188ccc2b2d09a7c70 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/builder-lambda/custom-component/custom-component-call.ets @@ -0,0 +1,43 @@ +/* + * 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 { Text, Column, Component, Builder, BuilderParam } from "@ohos.arkui.component" + +@Component +struct CustomContainer { + @Builder closerBuilder(){}; + @BuilderParam closer: () => void = this.closerBuilder; + + build() {} +} + +@Component +struct CustomContainerUser { + + build() { + Column() { + CustomContainer() { + Column() { + Text('hello') + } + } + CustomContainer({}) { + Column() {} + } + CustomContainer(undefined) {} + CustomContainer() + } + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/builder-lambda/instantiate-content.ets b/ets1.2/arkui-plugins/test/demo/mock/builder-lambda/instantiate-content.ets new file mode 100644 index 0000000000000000000000000000000000000000..f63cefd6722fe3ad3bf8d00045d458016a6ef0de --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/builder-lambda/instantiate-content.ets @@ -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 { Component } from "@koalaui.arkts-arkui.Common" +import { Column } from "@koalaui.arkts-arkui.Column" +import { Text } from "@koalaui.arkts-arkui.Text" + +@Component +struct MyStateSample { + build() { + Column() { + Text("Hello!") + } + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/builder-lambda/instantiate-multi-content.ets b/ets1.2/arkui-plugins/test/demo/mock/builder-lambda/instantiate-multi-content.ets new file mode 100644 index 0000000000000000000000000000000000000000..c5712c8599967e66a7f1688d72003fa971578828 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/builder-lambda/instantiate-multi-content.ets @@ -0,0 +1,29 @@ +/* + * 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 { Component } from "@koalaui.arkts-arkui.Common" +import { Column } from "@koalaui.arkts-arkui.Column" +import { Text } from "@koalaui.arkts-arkui.Text" +import { Button } from "@koalaui.arkts-arkui.Button" + +@Component +struct MyStateSample { + build() { + Column() { + Text("Hello!") + Button("click me") + } + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/builder-lambda/simple-component.ets b/ets1.2/arkui-plugins/test/demo/mock/builder-lambda/simple-component.ets new file mode 100644 index 0000000000000000000000000000000000000000..4f0f3b5cf901bfd71f97ab91e53d2e33eee28531 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/builder-lambda/simple-component.ets @@ -0,0 +1,23 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" +import { Column, UIColumnAttribute } from "arkui.component.column" + +class MyStateSample { + @memo build() { + Column(undefined) {} + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/builder-lambda/style-with-receiver.ets b/ets1.2/arkui-plugins/test/demo/mock/builder-lambda/style-with-receiver.ets new file mode 100644 index 0000000000000000000000000000000000000000..92d842ff54db1ec685cfce72da7df394bef82ecc --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/builder-lambda/style-with-receiver.ets @@ -0,0 +1,47 @@ +/* + * 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 { memo } from "@ohos.arkui.stateManagement" // should be insert by ui-plugins +import { Text, UITextAttribute, Column, Component} from "@ohos.arkui.component" +import hilog from '@ohos.hilog' + +@memo function cardStyle(this: UITextAttribute, num: number, str: string): this { + this.fontSize(num); + this.backgroundColor(num); + return this; +} + +@memo function style22(this: UITextAttribute): this { + this.fontWeight(700); + return this; +} + +@Component +struct MM { + build() { + Column() { + Text('hello world') + .height(200) + .fontColor('#000000') + .cardStyle(600, '#eeeeee') + .fontSize(60) + .fontWeight(400) + .style22() + .width(900) + Text('hello world') + .cardStyle(600, '#eeeeee') + } + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/builder-param/builder-param-passing.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/builder-param/builder-param-passing.ets new file mode 100644 index 0000000000000000000000000000000000000000..c679899b2e1009491fcf877e6b9bde97c0ca433b --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/builder-param/builder-param-passing.ets @@ -0,0 +1,41 @@ +/* + * 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 { Component, Entry, Builder, BuilderParam, Column, Text } from "@ohos.arkui.component" + +@Component +struct Child { + @Builder customBuilder() {}; + @BuilderParam customBuilderParam: () => void = this.customBuilder; + + build() { + this.customBuilderParam() + } +} + +@Component +struct Parent { + @Builder componentBuilder() { + Text('Parent builder') + } + + build() { + Column() { + Child({ customBuilderParam: this.componentBuilder }) + Child({ customBuilderParam: () => { this.componentBuilder() } }) + Child() { Text('Parent builder') } + } + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/builder-param/init-with-local-builder.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/builder-param/init-with-local-builder.ets new file mode 100644 index 0000000000000000000000000000000000000000..e1e2b46c94c01d62624e376aa3acd3fb2f740677 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/builder-param/init-with-local-builder.ets @@ -0,0 +1,29 @@ +/* + * 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 { Component, Builder, BuilderParam } from "@ohos.arkui.component" + +@Component +struct Child { + @Builder doNothingBuilder() {}; + @Builder doNothingBuilder2(str: string) {}; + @BuilderParam customBuilderParam: () => void = this.doNothingBuilder; + @BuilderParam customBuilderParam2: (str: string) => void = this.doNothingBuilder2; + + build(){ + this.customBuilderParam() + this.customBuilderParam2('hello') + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/builder/global-builder.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/builder/global-builder.ets new file mode 100644 index 0000000000000000000000000000000000000000..bba1e6ee0cd7da5ac40d1cefae611358c19e9138 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/builder/global-builder.ets @@ -0,0 +1,41 @@ +/* + * 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 { Component, Row, Builder, Text } from "@ohos.arkui.component" + +@Builder +function showTextBuilder() { + Text('Hello World') +} + +class Tmp { + paramA1: string = ''; +} + +@Builder function overBuilder(params: Tmp) { + Row() { + Text('UseStateVarByReference: ' + params.paramA1) + } +} + +@Component +struct BuilderDemo { + build() { + Row() { + showTextBuilder() + overBuilder({ paramA1: 'Hello' }) + } + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/builder/local-builder.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/builder/local-builder.ets new file mode 100644 index 0000000000000000000000000000000000000000..01da4671a674ee9df085abb3b4a1e9380d3a0936 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/builder/local-builder.ets @@ -0,0 +1,36 @@ +/* + * 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 { Component, Column, Builder, Text } from "@ohos.arkui.component" + +@Component +struct BuilderDemo { + @Builder + showTextBuilder() { + Text('Hello World') + .fontSize(30) + } + @Builder + showTextValueBuilder(param: string) { + Text(param) + .fontSize(30) + } + build() { + Column() { + this.showTextBuilder() + this.showTextValueBuilder('Hello @Builder') + } + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/link/link-basic-type.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/link/link-basic-type.ets new file mode 100644 index 0000000000000000000000000000000000000000..9c97005bc712f64f8cd00fec145de8fb436f2b4b --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/link/link-basic-type.ets @@ -0,0 +1,29 @@ +/* + * 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 { Component } from "@ohos.arkui.component" +import { Link } from "@ohos.arkui.stateManagement" + +@Component +struct LinkParent { + @Link linkVar1: string; + @Link linkVar2: number; + @Link linkVar3: boolean; + @Link linkVar4: undefined; + @Link linkVar5: null; + + build() { + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/link/link-complex-type.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/link/link-complex-type.ets new file mode 100644 index 0000000000000000000000000000000000000000..512968ab318240e491f9a6b673300786149ddeda --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/link/link-complex-type.ets @@ -0,0 +1,49 @@ +/* + * 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 { Component } from "@ohos.arkui.component" +import { Link } from "@ohos.arkui.stateManagement" + +class Per { + num: number; + constructor(num: number) { + this.num = num; + } +} + +enum LinkType { + TYPE1 = 0, + TYPE2 = 1, + TYPE3 = 3 +} + +@Component +struct Parent { + @Link linkVar1: Per; + @Link linkVar2: Array; + @Link linkVar3: LinkType; + @Link linkVar4: Set; + @Link linkVar5: boolean[]; + @Link linkVar6: Array; + @Link linkVar7: Per[]; + @Link linkVar8: (sr: string)=>void; + @Link linkVar9: Date; + @Link linkVar10: Map; + @Link linkVar11: string | number; + @Link linkVar12: Set | Per; + + build() { + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/link/link-to-link-prop-state.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/link/link-to-link-prop-state.ets new file mode 100644 index 0000000000000000000000000000000000000000..b04d84e93c8f0f6e83a0be4e0afb54c5704d60aa --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/link/link-to-link-prop-state.ets @@ -0,0 +1,41 @@ +/* + * 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 { Component, Column, TextInput } from "@ohos.arkui.component" +import { Link, State, Prop } from "@ohos.arkui.stateManagement" + +@Component +struct Parant { + @Link text1: string; + + build() { + Column() { + TextInput({ text: this.text1 }) + Child({ childText: this.text1, childText2: this.text1, childText3: this.text1, childText4: this.text1 }) + } + } +} + +@Component +struct Child { + @Link childText: string; + @State childText2: string = 'sss'; + @Prop childText3: string; + @Prop childText4: string = 'cc'; + + build() { + TextInput({ text: this.childText }) + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/link/state-to-link.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/link/state-to-link.ets new file mode 100644 index 0000000000000000000000000000000000000000..a3e02b8b7ee2f45b3a6654a6a8cfdfd99d3414c7 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/link/state-to-link.ets @@ -0,0 +1,70 @@ +/* + * 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 { Component, Entry, Column, Button, DatePicker, ClickEvent } from "@ohos.arkui.component" +import { Link, State } from "@ohos.arkui.stateManagement" + +@Component +struct DateComponent { + @Link selectedDate: Date; + + build() { + Column() { + Button('child increase the year by 1') + .onClick((e: ClickEvent) => { + this.selectedDate.setFullYear(this.selectedDate.getFullYear() + 1); + }) + Button('child update the new date') + .margin(10) + .onClick((e: ClickEvent) => { + this.selectedDate = new Date('2023-09-09'); + }) + DatePicker({ + start: new Date('1970-1-1'), + end: new Date('2100-1-1'), + selected: this.selectedDate + }) + } + + } +} + +@Entry +@Component +struct ParentComponent { + @State parentSelectedDate: Date = new Date('2021-08-08'); + + build() { + Column() { + Button('parent increase the month by 1') + .margin(10) + .onClick((e: ClickEvent) => { + this.parentSelectedDate.setMonth(this.parentSelectedDate.getMonth() + 1); + }) + Button('parent update the new date') + .margin(10) + .onClick((e: ClickEvent) => { + this.parentSelectedDate = new Date('2023-07-07'); + }) + DatePicker({ + start: new Date('1970-1-1'), + end: new Date('2100-1-1'), + selected: this.parentSelectedDate + }) + + DateComponent({ selectedDate:this.parentSelectedDate }) + } + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/objectlink/objectlink-basic.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/objectlink/objectlink-basic.ets new file mode 100644 index 0000000000000000000000000000000000000000..273a00f461eee3188e82f24de278f0e8e7873778 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/objectlink/objectlink-basic.ets @@ -0,0 +1,13 @@ +import { Component } from "@ohos.arkui.component" +import { Observed, ObjectLink } from "@ohos.arkui.stateManagement" + +@Observed +class A {} + +@Component +struct MyStateSample { + + @ObjectLink objectlinkvar: A; + + build() {} +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/objectlink/objectlink-observed.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/objectlink/objectlink-observed.ets new file mode 100644 index 0000000000000000000000000000000000000000..54dc8f89b6cf6e4dd5a660e4fe18b4f16835e154 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/objectlink/objectlink-observed.ets @@ -0,0 +1,54 @@ +import { Component, Entry, Column, Button, ClickEvent } from "@ohos.arkui.component" +import { State, ObjectLink, Observed } from "@ohos.arkui.stateManagement" + +@Observed +class DateClass extends Date { + constructor(args: number | string) { + super(args); + } +} + +@Observed +class NewDate { + public data: DateClass; + + constructor(data: DateClass) { + this.data = data; + } +} + +@Component +struct Child { + label: string = 'date'; + @ObjectLink data: DateClass; + + build() { + Column() { + Button(`child increase the day by 1`) + .onClick((e: ClickEvent) => { + this.data.setDate(this.data.getDate() + 1); + }) + } + } +} + +@Entry +@Component +struct Parent { + @State newData: NewDate = new NewDate(new DateClass('2023-1-1')); + + build() { + Column() { + Child({ label: 'date', data: this.newData.data }) + + Button(`parent update the new date`) + .onClick(() => { + this.newData.data = new DateClass('2023-07-07'); + }) + Button(`ViewB: this.newData = new NewDate(new DateClass('2023-08-20'))`) + .onClick(() => { + this.newData = new NewDate(new DateClass('2023-08-20')); + }) + } + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-only.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-only.ets new file mode 100644 index 0000000000000000000000000000000000000000..3890ea9ecab4eab9d52cbc7ab3c671cbd9c99a01 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-only.ets @@ -0,0 +1,13 @@ +import { Component } from "@ohos.arkui.component" +import { Observed } from "@ohos.arkui.stateManagement" + +@Observed +class A { + propA: number = 1 + trackA: number = 2 +} + +@Component +struct MyStateSample { + build() {} +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-track-class-property.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-track-class-property.ets new file mode 100644 index 0000000000000000000000000000000000000000..48a3cd405f001f8c617ea967feef02215bb56963 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-track-class-property.ets @@ -0,0 +1,19 @@ +import { Component } from "@ohos.arkui.component" +import { Observed, Track } from "@ohos.arkui.stateManagement" + +class Info{} +class E { + propE: Info = new Info() + @Track trackE: Info = new Info() +} + +@Observed +class E1 { + propE1: Info = new Info() + trackE1: Info = new Info() +} + +@Component +struct MyStateSample { + build() {} +} diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-track-complex-type.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-track-complex-type.ets new file mode 100644 index 0000000000000000000000000000000000000000..bf59d6d517a1b9afd425c9abed0bf66974e54bb6 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-track-complex-type.ets @@ -0,0 +1,76 @@ +import { Component, Entry } from "@ohos.arkui.component" +import { Observed, Track } from "@ohos.arkui.stateManagement" + +class Person{ +} + +enum Status { + Success = 200, + NotFound = 404, + ServerError = 500 +} + +@Observed +class mixed1 { + @Track numA: number = 33; + @Track stringA: string = 'AA'; + @Track booleanA: boolean = true; + @Track arrayA: number[] = [1,2,3]; + @Track objectA: Object = {}; + @Track dateA: Date = new Date('2021-08-08'); + @Track setA: Set = new Set(); + @Track mapA: Map = new Map(); + @Track unionA: string | undefined = ""; + @Track classA: Person = new Person(); + @Track enumA: Status = Status.NotFound; + + numB: number = 33; + stringB: string = 'AA'; + booleanB: boolean = true; + arrayB: number[] = [1,2,3]; + objectB: Object = {}; + dateB: Date = new Date('2021-08-08'); + setB: Set = new Set(); + mapB: Map = new Map(); + unionB: string | undefined = ""; + classB: Person = new Person(); + enumB: Status = Status.NotFound; +} + +@Observed +class mixed2 { + numA: number = 33; + stringA: string = 'AA'; + booleanA: boolean = true; + arrayA: number[] = [1,2,3]; + objectA: Object = {}; + dateA: Date = new Date('2021-08-08'); + setA: Set = new Set(); + mapA: Map = new Map(); + unionA: string | undefined = ""; + classA: Person = new Person(); + enumA: Status = Status.NotFound; +} + +class mixed3 { + @Track numA: number = 33; + @Track stringA: string = 'AA'; + @Track booleanA: boolean = true; + @Track arrayA: number[] = [1,2,3]; + @Track objectA: Object = {}; + @Track dateA: Date = new Date('2021-08-08'); + @Track setA: Set = new Set(); + @Track mapA: Map = new Map(); + @Track unionA: string | undefined = ""; + @Track classA: Person = new Person(); + @Track enumA: Status = Status.NotFound; +} + + +@Entry +@Component +struct MyStateSample { + build() { + + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-track-extends.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-track-extends.ets new file mode 100644 index 0000000000000000000000000000000000000000..66135926a24c14231dbfb442f8e3e3a2db1c8ce2 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-track-extends.ets @@ -0,0 +1,23 @@ +import { Component } from "@ohos.arkui.component" +import { Observed, Track } from "@ohos.arkui.stateManagement" + +@Observed +class A { + propA: number = 1 + trackA: number = 2 +} + + +class G extends A { + propG: number = 1; +} + +@Observed +class H extends G { + @Track propG: number = 1; +} + +@Component +struct MyStateSample { + build() {} +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-track-implements.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-track-implements.ets new file mode 100644 index 0000000000000000000000000000000000000000..5be8bd871c70edeba919e09727f2bd6428ff040b --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-track-implements.ets @@ -0,0 +1,20 @@ +import { Component } from "@ohos.arkui.component" +import { Observed } from "@ohos.arkui.stateManagement" + interface PropInterface { + propF: number +} + +interface trackInterface { + trackF: number +} + +@Observed +class F implements PropInterface, trackInterface { + propF: number = 1 + trackF: number = 2 +} + +@Component +struct MyStateSample { + build() {} +} diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-track.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-track.ets new file mode 100644 index 0000000000000000000000000000000000000000..3d15c071a043cde1cd20ab328133e032d0b9780a --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/observed-track.ets @@ -0,0 +1,13 @@ +import { Component } from "@ohos.arkui.component" +import { Observed, Track } from "@ohos.arkui.stateManagement" + +@Observed +class B { + propB: number = 1 + @Track trackB: number = 2 +} + +@Component +struct MyStateSample { + build() {} +} diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/track-only.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/track-only.ets new file mode 100644 index 0000000000000000000000000000000000000000..fea1df86e1bfd14eeb87a1c65eb24129337a935a --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/observed-track/track-only.ets @@ -0,0 +1,12 @@ +import { Component } from "@ohos.arkui.component" +import { Track } from "@ohos.arkui.stateManagement" + +class C { + propC: number = 1 + @Track trackC: number = 2 +} + +@Component +struct MyStateSample { + build() {} +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/prop/prop-basic-type.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/prop/prop-basic-type.ets new file mode 100644 index 0000000000000000000000000000000000000000..bcfff2d589ac24d532da6c04ddc2ca008acf5cf0 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/prop/prop-basic-type.ets @@ -0,0 +1,29 @@ +/* + * 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 { Component } from "@ohos.arkui.component" +import { Prop } from "@ohos.arkui.stateManagement" + +@Component +struct PropParent { + @Prop propVar1: string = 'propVar1'; + @Prop propVar2: number = 50; + @Prop propVar3: boolean = true; + @Prop propVar4: undefined = undefined; + @Prop propVar5: null = null; + + build() { + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/prop/prop-complex-type.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/prop/prop-complex-type.ets new file mode 100644 index 0000000000000000000000000000000000000000..a2fbdc9d2387657602f4edd681f64b82a737f645 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/prop/prop-complex-type.ets @@ -0,0 +1,49 @@ +/* + * 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 { Component } from "@ohos.arkui.component" +import { Prop } from "@ohos.arkui.stateManagement" + +class Per { + num: number; + constructor(num: number) { + this.num = num; + } +} + +enum PropType { + TYPE1 = 0, + TYPE2 = 1, + TYPE3 = 3 +} + +@Component +struct Parent { + @Prop propVar1: Per = new Per(6); + @Prop propVar2: Array = new Array(3,6,8); + @Prop propVar3: PropType = PropType.TYPE3; + @Prop propVar4: Set = new Set(new Array('aa', 'bb')); + @Prop propVar5: boolean[] = [true, false]; + @Prop propVar6: Array = new Array(new Per(7), new Per(11)); + @Prop propVar7: Per[] = [new Per(7), new Per(11)]; + @Prop propVar8: (sr: string)=>void = (sr: string)=>{}; + @Prop propVar9: Date = new Date('2025-4-23'); + @Prop propVar10: Map = new Map([[0, new Per(7)], [1, new Per(10)]]); + @Prop propVar11: string | number = 0.0; + @Prop propVar12: Set | Per = new Per(6); + + build() { + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/prop/state-to-prop.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/prop/state-to-prop.ets new file mode 100644 index 0000000000000000000000000000000000000000..38af709df0adab049df6551c806c570acaa01019 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/prop/state-to-prop.ets @@ -0,0 +1,54 @@ +/* + * 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 { Component, Text, Button, Column, ClickEvent } from "@ohos.arkui.component" +import { Prop, State } from "@ohos.arkui.stateManagement" + +@Component +struct CountDownComponent { + @Prop count: number = 0; + costOfOneAttempt: number = 1; + + build() { + Column() { + if (this.count > 0) { + Text('You have'+ this.count + 'Nuggets left') + } else { + Text('Game over!') + } + Button('Try again').onClick((e: ClickEvent) => { + this.count -= this.costOfOneAttempt; + }) + } + } +} + +@Component +struct ParentComponent { + @State countDownStartValue: number = 10; + + build() { + Column() { + Text('Grant' + this.countDownStartValue + 'nuggets to play.') + Button('+1 - Nuggets in New Game').onClick((e: ClickEvent) => { + this.countDownStartValue += 1; + }) + Button('-1 - Nuggets in New Game').onClick((e: ClickEvent) => { + this.countDownStartValue -= 1; + }) + CountDownComponent({ count: this.countDownStartValue, costOfOneAttempt: 2 }) + } + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/provide-and-consume/provide-annotation-usage.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/provide-and-consume/provide-annotation-usage.ets new file mode 100644 index 0000000000000000000000000000000000000000..74afaf8f9bad2eeac1424a9ceaa238fd9b3e6a3b --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/provide-and-consume/provide-annotation-usage.ets @@ -0,0 +1,32 @@ +/* + * 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 { Component } from "@ohos.arkui.component" +import { Provide } from "@ohos.arkui.stateManagement" + +@Component +struct Ancestors { + @Provide count: string | undefined = 'Child0'; + @Provide({ alias: 'prov1' }) count1: string | undefined = 'Child1'; + @Provide({ alias: 'prov2', allowOverride: false }) count2: string | undefined = 'Child2'; + @Provide({ alias: 'prov3', allowOverride: true }) count3: string | undefined = 'Child3'; + @Provide({ allowOverride: false }) count4: string | undefined = 'Child4'; + @Provide({ allowOverride: true }) count5: string | undefined = 'Child5'; + @Provide({ alias: "", allowOverride: true }) count6: string | undefined = 'Child6'; + @Provide({ alias: "" }) count7: string | undefined = 'Child7'; + + build() { + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/provide-and-consume/provide-basic-type.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/provide-and-consume/provide-basic-type.ets new file mode 100644 index 0000000000000000000000000000000000000000..06c9ddea34a229226d70a0386a8d27f84b66d881 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/provide-and-consume/provide-basic-type.ets @@ -0,0 +1,29 @@ +/* + * 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 { Component } from "@ohos.arkui.component" +import { Provide } from "@ohos.arkui.stateManagement" + +@Component +struct PropParent { + @Provide provideVar1: string = 'propVar1'; + @Provide provideVar2: number = 50; + @Provide provideVar3: boolean = true; + @Provide provideVar4: undefined = undefined; + @Provide provideVar5: null = null; + + build() { + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/provide-and-consume/provide-complex-type.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/provide-and-consume/provide-complex-type.ets new file mode 100644 index 0000000000000000000000000000000000000000..6395a981b8ff07f5626146189ae534a0840efeb9 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/provide-and-consume/provide-complex-type.ets @@ -0,0 +1,49 @@ +/* + * 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 { Component } from "@ohos.arkui.component" +import { Provide } from "@ohos.arkui.stateManagement" + +class Per { + num: number; + constructor(num: number) { + this.num = num; + } +} + +enum PropType { + TYPE1 = 0, + TYPE2 = 1, + TYPE3 = 3 +} + +@Component +struct Parent { + @Provide provideVar1: Per = new Per(6); + @Provide provideVar2: Array = new Array(3,6,8); + @Provide provideVar3: PropType = PropType.TYPE3; + @Provide provideVar4: Set = new Set(new Array('aa', 'bb')); + @Provide provideVar5: boolean[] = [true, false]; + @Provide provideVar6: Array = new Array(new Per(7), new Per(11)); + @Provide provideVar7: Per[] = [new Per(7), new Per(11)]; + @Provide provideVar8: (sr: string)=>void = (sr: string)=>{}; + @Provide provideVar9: Date = new Date('2025-4-23'); + @Provide provideVar10: Map = new Map([[0, new Per(7)], [1, new Per(10)]]); + @Provide provideVar11: string | number = 0.0; + @Provide provideVar12: Set | Per = new Per(6); + + build() { + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/resource/resource-in-build.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/resource/resource-in-build.ets new file mode 100644 index 0000000000000000000000000000000000000000..49331e647034ca169b243def6931cf493705f231 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/resource/resource-in-build.ets @@ -0,0 +1,50 @@ +/* + * 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 { Component, $r, $rawfile, Column, Text, Image, TextInput, Select, SelectOption, Margin, ImageAnimator } from "@ohos.arkui.component" + +@Component +struct ResourceComponent { + str1: string = 'app.media.ri' + str2: string = 'app.photo2.png' + build() { + Column() { + Text($r('app.string.app_name')) + Image($rawfile('app.photo.png')) + TextInput({ text: $r('app.string.input_content') }) + Text($r(this.str1)) + Text($r(this.str2)) + Select(new Array( + { value: 'aaa', icon: $r("app.media.selection") }, + { value: 'bbb', icon: $r("app.media.selection") }, + { value: 'ccc', icon: $r("app.media.selection") }, + { value: 'ddd', icon: $r("app.media.selection") } + )) + Image($r('app.media.app_icon')) + .margin({ + top: $r('app.float.elements_margin_horizontal_m'), + bottom: $r('app.float.elements_margin_horizontal_l') + } as Margin) + ImageAnimator().images([ + { + src: $r('app.media.aaa') + }, + { + src: $r('app.media.bbb') + }, + ]) + } + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/resource/resource-in-property.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/resource/resource-in-property.ets new file mode 100644 index 0000000000000000000000000000000000000000..591311c7dd671e824d0ea6e39561dc4b8f4990ae --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/resource/resource-in-property.ets @@ -0,0 +1,31 @@ +/* + * 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 { Component, $r, $rawfile, Column, Text, Image, Resource } from "@ohos.arkui.component" + +let i: Resource = $r('app.string.app_name'); + +@Component +struct ResourceComponent { + private str: Resource = $r('app.string.app_name'); + private icon: Resource = $rawfile('app.photo.png'); + build() { + Column() { + Text(this.str) + Text(i) + Image(this.icon) + } + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/reusable/reusable-basic.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/reusable/reusable-basic.ets new file mode 100644 index 0000000000000000000000000000000000000000..755a647b3260f375089b04a907d481ce03f82dde --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/reusable/reusable-basic.ets @@ -0,0 +1,19 @@ +import { Component, Reusable} from "@ohos.arkui.component" +import { State, Link } from "@ohos.arkui.stateManagement" + +@Component +struct MyStateSample { + build() { + Child({ num: 5 } ) + } +} + +@Component +@Reusable +struct Child { + @Link num: number = 1 + @State num1: number = 2 + build() { + + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/reusable/reusable-complex.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/reusable/reusable-complex.ets new file mode 100644 index 0000000000000000000000000000000000000000..d66fe54519af51ebe4bae06aa87eb4bf3ed6cbf6 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/reusable/reusable-complex.ets @@ -0,0 +1,53 @@ +import { Component, Entry, Reusable, Column, Text, Button, ClickEvent, FontWeight} from "@ohos.arkui.component" +import { State } from "@ohos.arkui.stateManagement" + +class Message { + value: string | undefined; + + constructor(value: string) { + this.value = value; + } +} + +@Entry +@Component +struct Index { + @State display: boolean = true; + + build() { + Column() { + Button('Hello') + .fontSize(30) + .fontWeight(FontWeight.Bold) + .onClick((e: ClickEvent) => { + this.display = !this.display; + }) + if (this.display) { + // 如果只有一个复用的组件，可以不用设置reuseId + Child({ message: new Message('Child') }) + } + } + .height("100%") + .width('100%') + } +} + +@Reusable +@Component +struct Child { + @State message: Message = new Message('AboutToReuse'); + + aboutToReuse(params: Record) { + console.info("Recycle ====Child=="); + //this.message = params.message as Message; + } + + build() { + Column() { + Text(this.message.value) + .fontSize(30) + } + .borderWidth(1) + .height(100) + } +} diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/state/state-basic-type.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/state/state-basic-type.ets new file mode 100644 index 0000000000000000000000000000000000000000..b7e039a774cfb91d4069786c69be741ced0e1387 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/state/state-basic-type.ets @@ -0,0 +1,29 @@ +/* + * 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 { Component } from "@ohos.arkui.component" +import { State} from "@ohos.arkui.stateManagement" + +@Component +struct Parent { + @State stateVar1: string = 'stateVar1'; + @State stateVar2: number = 50; + @State stateVar3: boolean = true; + @State stateVar4: undefined = undefined; + @State stateVar5: null = null; + + build() { + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/state/state-complex-type.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/state/state-complex-type.ets new file mode 100644 index 0000000000000000000000000000000000000000..5ffe6f50afc67bdfa63f3434e3a336541e19df20 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/state/state-complex-type.ets @@ -0,0 +1,49 @@ +/* + * 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 { Component } from "@ohos.arkui.component" +import { State} from "@ohos.arkui.stateManagement" + +class Per { + num: number; + constructor(num: number) { + this.num = num; + } +} + +enum StateType { + TYPE1 = 0, + TYPE2 = 1, + TYPE3 = 3 +} + +@Component +struct Parent { + @State stateVar1: Per = new Per(6); + @State stateVar2: Array = new Array(3,6,8); + @State stateVar3: StateType = StateType.TYPE3; + @State stateVar4: Set = new Set(new Array('aa', 'bb')); + @State stateVar5: boolean[] = [true, false]; + @State stateVar6: Array = new Array(new Per(7), new Per(11)); + @State stateVar7: Per[] = [new Per(7), new Per(11)]; + @State stateVar8: (sr: string)=>void = (sr: string)=>{}; + @State stateVar9: Date = new Date('2025-4-23'); + @State stateVar10: Map = new Map([[0, new Per(7)], [1, new Per(10)]]); + @State stateVar11: string | number = 0.0; + @State stateVar12: Set | Per = new Per(6); + + build() { + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/state/state-to-state.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/state/state-to-state.ets new file mode 100644 index 0000000000000000000000000000000000000000..8beb2e452478cc3acb574efd33c5ed242d295354 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/state/state-to-state.ets @@ -0,0 +1,42 @@ +/* + * 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 { Component, Column, Text } from "@ohos.arkui.component" +import { State } from "@ohos.arkui.stateManagement" + +class Per { + str: string; + constructor(str: string) { + this.str = str; + } +} + +@Component +struct Parent { + @State parentVar1: Per = new Per('hello'); + build() { + Column() { + Child({ childVar1: this.parentVar1 }) + } + } +} + +@Component +struct Child { + @State childVar1: Per = new Per('ccc'); + build() { + Text(this.childVar1.str) + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/storagelink/storagelink-appstorage.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/storagelink/storagelink-appstorage.ets new file mode 100644 index 0000000000000000000000000000000000000000..298dc89559f07bb094d7b5fc8a395c01ba619f62 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/storagelink/storagelink-appstorage.ets @@ -0,0 +1,35 @@ +import { Component, Entry, Column, Text, ClickEvent } from "@ohos.arkui.component" +import { StorageLink, AppStorage } from "@ohos.arkui.stateManagement" + +class Data { + code: number; + + constructor(code: number) { + this.code = code; + } +} + +AppStorage.setOrCreate('PropA', 47); +AppStorage.setOrCreate('PropB', new Data(50)); + + +@Entry +@Component +struct Index { + @StorageLink('PropA') storageLink: number = 1; + @StorageLink('PropB') storageLinkObject: Data = new Data(1); + + build() { + Column() { + Text(`From AppStorage ${this.storageLink}`) + .onClick((e: ClickEvent) => { + this.storageLink += 1; + }) + + Text(`From AppStorage ${this.storageLinkObject.code}`) + .onClick((e: ClickEvent) => { + this.storageLinkObject.code += 1; + }) + } + } +} diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/storagelink/storagelink-complex-type.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/storagelink/storagelink-complex-type.ets new file mode 100644 index 0000000000000000000000000000000000000000..9aed6364d9c83a3a6865d84ef559025e14fb4cb7 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/storagelink/storagelink-complex-type.ets @@ -0,0 +1,28 @@ +import { Component, Entry } from "@ohos.arkui.component" +import { StorageLink } from "@ohos.arkui.stateManagement" + +class Person{ + name: string = '' + constructor(name: string){} +} + +enum Status { + Success = 200, + NotFound = 404, + ServerError = 500 +} + +@Entry +@Component +struct MyStateSample { + @StorageLink('Prop1') arrayA: number[] = [1,2,3]; + @StorageLink('Prop2') objectA: Object = {}; + @StorageLink('Prop3') dateA: Date = new Date('2021-08-08'); + @StorageLink('Prop4') setA: Set = new Set(); + @StorageLink('Prop5') mapA: Map = new Map(); + @StorageLink('Prop6') unionA: string | undefined = ""; + @StorageLink('Prop7') classA: Person = new Person("John"); + @StorageLink('Prop8') enumA: Status = Status.NotFound; + + build() {} +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/storagelink/storagelink-primitive-type.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/storagelink/storagelink-primitive-type.ets new file mode 100644 index 0000000000000000000000000000000000000000..e5afb4d19714d7e4e84d3eefb381e24cd376e867 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/storagelink/storagelink-primitive-type.ets @@ -0,0 +1,12 @@ +import { Component, Entry } from "@ohos.arkui.component" +import { StorageLink } from "@ohos.arkui.stateManagement" + +@Entry +@Component +struct MyStateSample { + @StorageLink('Prop1') numA: number = 33; + @StorageLink('Prop2') stringA: string = 'AA'; + @StorageLink('Prop3') booleanA: boolean = true; + + build() {} +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/storageprop/storageprop-appstorage.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/storageprop/storageprop-appstorage.ets new file mode 100644 index 0000000000000000000000000000000000000000..bff353a175509fd8080dd3390ecb86ca3ec34831 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/storageprop/storageprop-appstorage.ets @@ -0,0 +1,34 @@ +import { Component, Entry, Column, Text, ClickEvent } from "@ohos.arkui.component" +import { StorageProp, AppStorage } from "@ohos.arkui.stateManagement" + +class Data { + code: number; + + constructor(code: number) { + this.code = code; + } +} + +AppStorage.setOrCreate('PropA', 47); +AppStorage.setOrCreate('PropB', new Data(50)); + +@Entry +@Component +struct Index { + @StorageProp('PropA') storageProp: number = 1; + @StorageProp('PropB') storagePropObject: Data = new Data(1); + + build() { + Column() { + Text(`From AppStorage ${this.storageProp}`) + .onClick((e: ClickEvent) => { + this.storageProp += 1; + }) + + Text(`From AppStorage ${this.storagePropObject.code}`) + .onClick((e: ClickEvent) => { + this.storagePropObject.code += 1; + }) + } + } +} diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/storageprop/storageprop-complex-type.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/storageprop/storageprop-complex-type.ets new file mode 100644 index 0000000000000000000000000000000000000000..5a770cf6ee43a829be0c528003838d4a61551ad3 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/storageprop/storageprop-complex-type.ets @@ -0,0 +1,28 @@ +import { Component, Entry } from "@ohos.arkui.component" // TextAttribute should be insert by ui-plugins +import { StorageProp } from "@ohos.arkui.stateManagement" + +class Person{ + name: string = '' + constructor(name: string){} +} + +enum Status { + Success = 200, + NotFound = 404, + ServerError = 500 +} + +@Entry +@Component +struct MyStateSample { + @StorageProp('Prop1') arrayB: number[] = [1,2,3]; + @StorageProp('Prop2') objectB: Object = {}; + @StorageProp('Prop3') dateB: Date = new Date('2021-09-09'); + @StorageProp('Prop4') setB: Set = new Set(); + @StorageProp('Prop5') mapB: Map = new Map(); + @StorageProp('Prop6') unionB: string | undefined = ""; + @StorageProp('Prop7') classB: Person = new Person("Kevin"); + @StorageProp('Prop8') enumB: Status = Status.NotFound; + + build() {} +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/storageprop/storageprop-primitive-type.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/storageprop/storageprop-primitive-type.ets new file mode 100644 index 0000000000000000000000000000000000000000..d82a28552453804ec2f268b84a7baca461dc95c2 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/storageprop/storageprop-primitive-type.ets @@ -0,0 +1,12 @@ +import { Component, Entry } from "@ohos.arkui.component" // TextAttribute should be insert by ui-plugins +import { StorageProp } from "@ohos.arkui.stateManagement" + +@Entry +@Component +struct MyStateSample { + @StorageProp('Prop1') numB: number = 43; + @StorageProp('Prop2') stringB: string = 'BB'; + @StorageProp('Prop3') booleanB: boolean = false; + + build() {} +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/decorators/watch/watch-basic.ets b/ets1.2/arkui-plugins/test/demo/mock/decorators/watch/watch-basic.ets new file mode 100644 index 0000000000000000000000000000000000000000..6a85ab00ac447f337857d612b451c03e22197273 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/decorators/watch/watch-basic.ets @@ -0,0 +1,41 @@ +import { Component, Entry } from "@ohos.arkui.component" +import { State, Prop, StorageLink, StorageProp, Link, Watch, ObjectLink, Observed, Track, Provide, Consume } from "@ohos.arkui.stateManagement" + +@Observed +class A { + propA: string = 'hello' + @Track trackA: string = 'world' +} + +@Entry +@Component +struct MyStateSample { + @State @Watch('stateOnChange') statevar: string = 'Hello World'; + @Prop @Watch('propOnChange') propvar: string = 'Hello World'; + // @Link @Watch('linkOnChange') linkvar: string; + @StorageLink('prop1') @Watch('storageLinkOnChange') storagelinkvar: string = 'Hello World'; + @StorageProp('prop2') @Watch('storagePropOnChange') storagepropvar: string = 'Hello World'; + // @ObjectLink @Watch('objectLinkOnChange') objectlinkvar: A; + @Provide @Watch('ProvideOnChange') providevar: string = 'Hello World'; + + stateOnChange(propName: string) {} + propOnChange(propName: string) {} + // linkOnChange(propName: string) {} + storageLinkOnChange(propName: string) {} + storagePropOnChange(propName: string) {} + // objectLinkOnChange(propName: string) {} + ProvideOnChange(propName: string) {} + + build() { + Child() + } +} + +@Component +struct Child { + // @Consume @Watch('ConsumeOnChange') providevar: string; + + // ConsumeOnChange(propName: string) {} + + build() {} +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/entry.ets b/ets1.2/arkui-plugins/test/demo/mock/entry.ets new file mode 100644 index 0000000000000000000000000000000000000000..1a0b18983e574643b716f95a5e678da596192ad0 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/entry.ets @@ -0,0 +1,16 @@ +/* + * 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. + */ + +class A {} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/functions/argument-call.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/functions/argument-call.ets new file mode 100644 index 0000000000000000000000000000000000000000..54263a55218737151cc173c8a8ef20ccddb6a699 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/functions/argument-call.ets @@ -0,0 +1,52 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +@memo function memo_arg_call( + arg1: number, + arg2: (x: number) => number, + @memo arg3: (x: number) => number, + arg4?: (x: number) => number, + @memo arg5?: (x: number) => number, +) { + arg2(arg1) + arg3(arg1) + arg4?.(arg1) + arg5?.(arg1) +} + +@memo +function memo_arg_call_with_lowering( + arg1: number, + arg4?: (x: number) => number, + @memo arg5?: (x: number) => number, +) { + {let gensym___1 = arg4; + ((gensym___1 == null) ? undefined : gensym___1(arg1))}; + {let gensym___2 = arg5; + ((gensym___2 == null) ? undefined : gensym___2(arg1))}; +} + +@memo +function args_with_default_values( + arg1: int = 10, + @memo arg2: () => int = () => { return 20 }, + arg3: int = arg1, + arg4?: int +): void { + console.log(arg1, arg2, arg3, arg4) + console.log(arg2()) +} diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/functions/declare-and-call.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/functions/declare-and-call.ets new file mode 100644 index 0000000000000000000000000000000000000000..ac8324d2211e079a3f6cbec9f2d1c26ceb53a123 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/functions/declare-and-call.ets @@ -0,0 +1,35 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +@memo +declare function funcA(): void; + +class A { + @memo foo() { + funcA(); + } +} + +@memo +function funcB(): void { + funcA(); +} + +@memo +() => { + funcA(); +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/functions/inner-functions.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/functions/inner-functions.ets new file mode 100644 index 0000000000000000000000000000000000000000..313164b28bbb3b45af10444c109993013ce7350a --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/functions/inner-functions.ets @@ -0,0 +1,37 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +@memo +function foo() { } + +@memo +function bar() { + const qux = @memo () => { + foo(); + } + + const other = () => {} +} + +class A { + @memo goo() { + let func = () => {}; + let func2 = @memo () => { + foo(); + } + } +} diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/functions/non-void-return-type.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/functions/non-void-return-type.ets new file mode 100644 index 0000000000000000000000000000000000000000..cc0f993ec1eb1bb3ee0cea0548a4ab2e8fd8985a --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/functions/non-void-return-type.ets @@ -0,0 +1,64 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +@memo +function funcNum(): number { + return 1; +} + +@memo +function funcStr(): string { + return "1"; +} + +@memo +function funcBool(): boolean { + return false; +} + +interface A { + str: string; +} + +@memo +function funcA(): A { + return { str: "1" }; +} + +type B = (str: string) => void; + +@memo +function funcB(): B { + return (str: string) => {}; +} + +class C { + str: string; + constructor(str: string) { + this.str = str; + } +} + +@memo +function funcC(): C { + return new C("1"); +} + +@memo +function funcD(): () => void { + return () => {}; +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/functions/type-reference.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/functions/type-reference.ets new file mode 100644 index 0000000000000000000000000000000000000000..be715df9520f12300b9ccab2938677caa7572720 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/functions/type-reference.ets @@ -0,0 +1,40 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +@memo type ItemBuilder = (item: Item) => void; + +interface Item { + item: T; +} + +interface Attribute { + @memo each(@memo itemGenerator: ItemBuilder): Attribute; +} + +@memo +export declare function A(): Attribute + +@memo +function func(): ItemBuilder { + return (item: Item): void => {}; +} + +class B { + @memo build() { + A().each((ri: Item) => {}) + } +} diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/functions/void-return-type.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/functions/void-return-type.ets new file mode 100644 index 0000000000000000000000000000000000000000..840c84aaf33c113cde341e668480a23f06dd6ed7 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/functions/void-return-type.ets @@ -0,0 +1,21 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +@memo +function func(): void { + return; +} diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/lambdas/argument-call.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/lambdas/argument-call.ets new file mode 100644 index 0000000000000000000000000000000000000000..def28807a683db299c935b25e938d18a68fa300b --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/lambdas/argument-call.ets @@ -0,0 +1,40 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +(arg: (()=>void)) => {}(() => {}); + +(arg: @memo (()=>void)) => {}(@memo () => {}); + +(arg: @memo (()=>void) = () => {}) => {}(@memo () => {}); + +@memo +() => { + (@memo (arg: @memo (()=>void) = () => {}) => {})(@memo () => {}); +} + +@memo +() => { + let goo = @memo (name: string = "old") => {} + + goo(); +} + +() => { + let foo = (arg: @memo (()=>void) = () => {}) => {} + + foo(@memo () => {}); +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/lambdas/function-with-receiver.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/lambdas/function-with-receiver.ets new file mode 100644 index 0000000000000000000000000000000000000000..36bc7d82fa0619651dfb6956a10d68e33b718a7d --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/lambdas/function-with-receiver.ets @@ -0,0 +1,32 @@ +/* + * 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 { memo } from "@ohos.arkui.stateManagement" + +class B { + @memo internal_call(): B { + this.foo1('morning'); + return this.foo2('afternoon') + } +} + +@memo function foo1(this: B, str: string): void { + console.log('Good', str); +} + +@memo function foo2(this: B, str: string): this { + console.log('Good', str); + return this; +} diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/lambdas/trailing-lambdas.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/lambdas/trailing-lambdas.ets new file mode 100644 index 0000000000000000000000000000000000000000..08d252f583d623b7ad40503313053a66f4254a9c --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/lambdas/trailing-lambdas.ets @@ -0,0 +1,44 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +class A { + @memo foo(p?: ()=>void): void {} + + goo(@memo p?: ()=>void): void {} + + @memo koo(@memo p?: ()=>void): void {} +} + +@memo +function bar(f?: ()=>void): void {} + +function par(f?: @memo ()=>void): void {} + +@memo +function kar(@memo f?: ()=>void): void {} + +@memo +() => { + let a = new A(); + a.foo() { console.log(); } + a.goo() { console.log(); } + a.koo() { console.log(); } + + bar() { console.log(); } + par() { console.log(); } + kar() { console.log(); } +} diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/lambdas/void-lambda.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/lambdas/void-lambda.ets new file mode 100644 index 0000000000000000000000000000000000000000..fb757d8b65bc190fb1d3a7e8eb24e76131d8dd86 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/lambdas/void-lambda.ets @@ -0,0 +1,26 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +@memo +(): void => { + return; +} + +@memo +(arg?: () => string): void => { + return; +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/lambdas/with-receiver.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/lambdas/with-receiver.ets new file mode 100644 index 0000000000000000000000000000000000000000..b54c9c6c215117441391ad22670444ff65e684ef --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/lambdas/with-receiver.ets @@ -0,0 +1,51 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +class Person { + constructor() {} +} + +function fullName(this: Person, @memo arg?: () => void): void { + return; +} + +class A {} + +type F1 = (this: A, @memo arg?: () => void) => void; +type F2 = (a: A, @memo arg?: () => void) => void; + +function foo(this: A, @memo arg?: () => void): void {} +function goo(a: A, @memo arg?: () => void): void {} + +@memo +() => { + let x = new Person(); + x.fullName(() => {}); + + let f1: F1 = foo; + f1 = goo; + + let f2: F2 = goo; + f2 = foo; + f1 = f2; + + let a = new A(); + a.f1(() => {}); + f1(a, () => {}); + + f2(a, () => {}); +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/methods/argument-call.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/methods/argument-call.ets new file mode 100644 index 0000000000000000000000000000000000000000..5f799140fdd1d8bfa485431799703a68446d6c88 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/methods/argument-call.ets @@ -0,0 +1,49 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +class Test { + @memo lambda_arg(@memo arg: () => void) { + + } + + @memo lambda_arg_with_arg(@memo arg: (value: string) => string) { + + } + + @memo memo_content(@memo content: () => void) { + content() + } + + @memo compute_test( + @memo arg1: (() => void) | undefined, + arg2: (() => void) | undefined, + content: (() => void) | undefined + ): void { + + } +} + +class Use { + @memo test() { + const test = new Test() + + test.lambda_arg((): void => {}) + test.lambda_arg_with_arg((value: string): string => value) + + test.compute_test(() => {}, () => {}, () => {}) + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/methods/callable.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/methods/callable.ets new file mode 100644 index 0000000000000000000000000000000000000000..2f4e2a401687e34c53dbd0c53e94a190edb6451f --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/methods/callable.ets @@ -0,0 +1,47 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +class A { + @memo + static $_invoke(): void {} +} + +class B { + static $_invoke(@memo p?: () => void): void {} +} + +class C { + @memo + static $_instantiate(factory: () => C): C { + return factory(); + } +} + +class D { + static $_instantiate(factory: () => D, @memo content?: () => void): D { + return factory(); + } +} + +@memo +() => { + A(); + B(() => {}); + + let x: C | D = C(); + x = D(); +} diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/methods/declare-and-call.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/methods/declare-and-call.ets new file mode 100644 index 0000000000000000000000000000000000000000..e28c853612e36b399f056c161e0d7a25842dd016 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/methods/declare-and-call.ets @@ -0,0 +1,41 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +declare abstract class A { + @memo + x(): void; + + test_signature( + @memo arg1: () => void, + @memo arg2: (() => void) | undefined, + @memo arg3: ((() => void) | undefined) | ((() => int) | undefined), + @memo x: (y: (z: @memo () => void) => void) => void, + ): @memo () => void; +} + +class AA extends A { + @memo x(): void {} +} + +@memo +() => { + new AA().x(); + + const a: A = new AA(); + a.x(); +} + diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/methods/internal-calls.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/methods/internal-calls.ets new file mode 100644 index 0000000000000000000000000000000000000000..7ef4cdb0e194404f46e81730e10ab61012bd81f2 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/methods/internal-calls.ets @@ -0,0 +1,81 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +export declare function __context(): __memo_context_type +export declare function __id(): __memo_id_type +type MemoType = @memo () => void + +class Test { + @memo void_method(): void { + } + + @memo internal_call() { + this.void_method() + } + + @memo method_with_internals() { + __context() + __id() + } + + memo_lambda() { + @memo () => { + + } + } + + @memo memo_variables() { + @memo const f = (): number => { + return 123 + }, g = (x: number): number => { + return 123 + x + } + + const h = @memo (): number => { + return 1 + } + + f() + g(1) + h() + } + + @memo args_with_default_values( + arg1: int = 10, + arg2: () => int = () => { return 20 }, + arg3: int = arg1, + arg4?: int + ): void { + console.log(arg1, arg2, arg3, arg4) + console.log(arg2()) + } + + @memo optional_args( + arg1?: int, + arg2?: () => int + ) { + console.log(arg1) + console.log(arg2) + console.log(arg2?.()) + } + + @memo type_alias( + arg: MemoType + ) { + arg() + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/methods/non-void-method.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/methods/non-void-method.ets new file mode 100644 index 0000000000000000000000000000000000000000..06df30297b35c8a7bc5d5f94fcabdcbef5457658 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/methods/non-void-method.ets @@ -0,0 +1,67 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +@Retention({policy:"SOURCE"}) @interface memo_intrinsic {} +@Retention({policy:"SOURCE"}) @interface memo_entry {} + +export declare function __context(): __memo_context_type +export declare function __id(): __memo_id_type + +class Test { + @memo void_method(): void { + } + + @memo string_method_with_return(arg: string): string { + return arg + } + + @memo method_with_type_parameter(arg: T): T { + return arg + } + + @memo_intrinsic intrinsic_method(): int { + return 0 + } + + @memo_intrinsic intrinsic_method_with_this(): int { + this.void_method() + return 0 + } + + @memo_entry memoEntry(__memo_context: __memo_context_type, __memo_id: __memo_id_type, @memo entry: () => R): R { + const getContext = () => { + return __context() + } + const getId = () => { + return __id() + } + { + const __memo_context = getContext() + const __memo_id = getId() + return entry() + } + } +} + +class Use { + @memo test() { + const test = new Test() + + test.string_method_with_return("a string") + test.method_with_type_parameter("I'm string") + } +} diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/methods/void-method.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/methods/void-method.ets new file mode 100644 index 0000000000000000000000000000000000000000..ed3339dd17a1768970424b8401936d2716d0d8a3 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/methods/void-method.ets @@ -0,0 +1,57 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +class A { + x: int + y: int +} + +class Test { + @memo void_method(): void { + } + + @memo a_method_with_implicit_return_type() { + } + + @memo void_method_with_arg(arg: string) { + } + + @memo void_method_with_return(arg: string) { + return + } + + @memo static static_method_with_type_parameter(arg: T): void { + return + } + + @memo obj_arg(arg: A) { + + } +} + +class Use { + @memo test() { + const test = new Test() + + test.void_method() + test.void_method_with_arg("an arg") + test.void_method_with_return("a value") + Test.static_method_with_type_parameter("I'm static") + + test.obj_arg({ x: 1, y: 2 }) + } +} diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/properties/class-constructor.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/properties/class-constructor.ets new file mode 100644 index 0000000000000000000000000000000000000000..725d2702b15a0360ac41262b23839816b65e4b1e --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/properties/class-constructor.ets @@ -0,0 +1,39 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +interface A { + @memo a: () => void +} + +class AA { + + @memo a: (() => void) | undefined + + constructor(arg?: A) { + this.a = arg?.a; + } + + @memo + build() { + this.a?.(); + } +} + +@memo +() => { + let a = new AA({ a: () => {} }) ; +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/properties/class-properties.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/properties/class-properties.ets new file mode 100644 index 0000000000000000000000000000000000000000..9fe1e5dc4ff19dfd5fd5ea76457b89863cbc6e5f --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/properties/class-properties.ets @@ -0,0 +1,39 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +class A { + arg: () => void + @memo memo_arg: () => void + @memo memo_optional_arg?: () => void + @memo memo_union_arg: (() => void) | undefined = () => {} + + arg_memo_type: @memo () => void + + constructor() { + this.arg = () => {}; + this.memo_arg = () => {}; + this.arg_memo_type = () => {}; + } + + @memo + build() { + this.arg(); + this.memo_arg(); + this.arg_memo_type(); + } + +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/properties/implements.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/properties/implements.ets new file mode 100644 index 0000000000000000000000000000000000000000..ad61b2a7a49d2877344e5b1aff901f3739279579 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/properties/implements.ets @@ -0,0 +1,24 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +interface A { + @memo prop: (() => void) | undefined +} + +class AA implements A { + @memo prop: (() => void) | undefined +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/memo/properties/interfaces.ets b/ets1.2/arkui-plugins/test/demo/mock/memo/properties/interfaces.ets new file mode 100644 index 0000000000000000000000000000000000000000..c46a181e573a7bb02bb8f85c126744ebd7361a48 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/memo/properties/interfaces.ets @@ -0,0 +1,34 @@ +/* + * 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 { memo, __memo_context_type, __memo_id_type } from "@ohos.arkui.stateManagement" + +interface A { + arg: () => void + @memo memo_arg: () => void + @memo memo_optional_arg?: () => void + @memo memo_union_arg: (() => void) | undefined + + arg_memo_type: @memo () => void +} + +@memo() (() => { + let a: A = { + arg: (() => {}), + memo_arg: (() => {}), + memo_union_arg: (() => {}), + arg_memo_type: (() => {}), + }; +}); \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/struct-to-class.ets b/ets1.2/arkui-plugins/test/demo/mock/struct-to-class.ets new file mode 100644 index 0000000000000000000000000000000000000000..85f67b07f753f3cf05ce0437e410f0ab39f5082f --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/struct-to-class.ets @@ -0,0 +1,22 @@ +/* + * 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 { Component } from "@koalaui.arkts-arkui.Common" + +@Component +struct MyStateSample { + build() {} +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/demo/mock/xcomponent/xcomponent-basic.ets b/ets1.2/arkui-plugins/test/demo/mock/xcomponent/xcomponent-basic.ets new file mode 100644 index 0000000000000000000000000000000000000000..aa644d5eddd01b0abdefc34aa0fc206c30e01d72 --- /dev/null +++ b/ets1.2/arkui-plugins/test/demo/mock/xcomponent/xcomponent-basic.ets @@ -0,0 +1,19 @@ +import {Component, Flex, XComponent, FlexDirection, XComponentType, Entry, XComponentController, ItemAlign, FlexAlign, XComponentParameter} from '@ohos.arkui.component' + +@Entry +@Component +struct Index { + myXComponentController: XComponentController = new XComponentController(); + build() { + Flex({ direction: FlexDirection.Column, alignItems: ItemAlign.Center, justifyContent: FlexAlign.Start }) { + XComponent({ + id: 'xComponentId', + type: XComponentType.TEXTURE, + libraryname: 'nativerender', + controller: this.myXComponentController + } as XComponentParameter) + } + .width('100%') + .height('100%') + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.column.d.ets b/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.column.d.ets new file mode 100644 index 0000000000000000000000000000000000000000..915dc5cebb40010bb552e9afc7e12b6b74ff64b6 --- /dev/null +++ b/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.column.d.ets @@ -0,0 +1,41 @@ +/* + * 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 { memo } from '../stateManagement/runtime'; +import { ComponentBuilder, CommonMethod, PointLightStyle } from './common'; +import { HorizontalAlign, FlexAlign } from './enums'; + +export declare interface ColumnOptions { + space?: string | number; +} + +export declare interface ColumnAttribute extends CommonMethod { + @memo + alignItems(value: HorizontalAlign): this; + @memo + justifyContent(value: FlexAlign): this; + @memo + pointLight(value: PointLightStyle): this; + @memo + reverse(isReversed?: boolean): this; +} + +@memo +@ComponentBuilder +export declare function Column ( + options?: ColumnOptions, + @memo + content?: () => void +): ColumnAttribute; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.common.d.ets b/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.common.d.ets new file mode 100644 index 0000000000000000000000000000000000000000..2ff6ea60ae0b042792ac8796396371e815a65a0e --- /dev/null +++ b/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.common.d.ets @@ -0,0 +1,55 @@ +/* + * 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 { Dimension, Length, ResourceColor } from "@ohos.arkui.component.units"; +import { IlluminatedType } from "@ohos.arkui.component.enums"; +import { memo } from '@ohos.arkui.stateManagement.runtime'; + +@Retention({policy: "SOURCE"}) +export @interface BuilderLambda { + value: string +} + +@Retention({policy: "SOURCE"}) +export declare @interface ComponentBuilder {}; + +@Retention({policy: "SOURCE"}) +export declare @interface BuilderParam {}; + +@Retention({policy: "SOURCE"}) +export declare @interface Builder {}; + +export declare interface LightSource { + positionX: Dimension; + positionY: Dimension; + positionZ: Dimension; + intensity: number; + color?: ResourceColor; +} + +export declare interface PointLightStyle { + lightSource?: LightSource; + illuminated?: IlluminatedType; + bloom?: number; +} + +export declare interface CommonMethod { + @memo + width(w: Length): this; + @memo + height(h: Length): this; + @memo + backgroundColor(color: ResourceColor): this; +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.customComponent.d.ets b/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.customComponent.d.ets new file mode 100644 index 0000000000000000000000000000000000000000..728c949e75b926d8782cb3bc3fbb3b05ca67d079 --- /dev/null +++ b/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.customComponent.d.ets @@ -0,0 +1,57 @@ +/* + * 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 { memo } from "@ohos.arkui.stateManagement.runtime"; +import { ComponentBuilder, CommonMethod } from "@ohos.arkui.component.common"; +import { Length, ResourceColor } from "@ohos.arkui.component.units"; + +@Retention({policy: "SOURCE"}) +export declare @interface Component {}; + +@Retention({policy: "SOURCE"}) +export declare @interface Entry { routeName: string }; + +@Retention({policy: "SOURCE"}) +export declare @interface Reusable {}; + +export declare abstract class CustomComponent, T_Options> implements + CommonMethod { + + @memo + @ComponentBuilder + static $_instantiate, S_Options>( + factory: () => S, + initializers?: S_Options, + @memo + content?: () => void + ): S; + + // Life cycle for custom component + aboutToAppear(): void; + aboutToDisappear(): void; + aboutToReuse(): void; + aboutToRecycle(): void; + + @memo + build(): void; + + // Implementation of common method + @memo + width(w: Length): this; + @memo + height(h: Length): this; + @memo + backgroundColor(color: ResourceColor): this; +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.d.ets b/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.d.ets new file mode 100644 index 0000000000000000000000000000000000000000..0f74a9db4523b49fbb41c6f94bf1ca39b66f1fba --- /dev/null +++ b/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.d.ets @@ -0,0 +1,22 @@ +/* + * 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. + */ + +export * from "@ohos.arkui.component.customComponent"; +export * from "@ohos.arkui.component.common"; +export * from "@ohos.arkui.component.column"; +export * from "@ohos.arkui.component.text"; +export * from "@ohos.arkui.component.styledString"; +export * from "@ohos.arkui.component.enums"; +export * from "@ohos.arkui.component.units"; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.enums.d.ets b/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.enums.d.ets new file mode 100644 index 0000000000000000000000000000000000000000..e72c21ace10322a6fb0fdef80711a7d34bb98173 --- /dev/null +++ b/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.enums.d.ets @@ -0,0 +1,53 @@ +/* + * 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. + */ + +export declare enum FlexAlign { + Start = 0, + Center = 1, + End = 2, + SpaceBetween = 3, + SpaceAround = 4, + SpaceEvenly = 5 +} + +export declare enum HorizontalAlign { + Start = 0, + Center = 1, + End = 2 +} + +export declare enum IlluminatedType { + NONE = 0, + BORDER = 1, + CONTENT = 2, + BORDER_CONTENT = 3, + BLOOM_BORDER = 4, + BLOOM_BORDER_CONTENT = 5 +} + +export declare enum Color { + White = 0, + Black = 1, + Blue = 2, + Brown = 3, + Gray = 4, + Green = 5, + Grey = 6, + Orange = 7, + Pink = 8, + Red = 9, + Yellow = 10, + Transparent = 11 +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.styledString.d.ets b/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.styledString.d.ets new file mode 100644 index 0000000000000000000000000000000000000000..4a0e94d6f089aab4442c94ca5d4f960aa70240af --- /dev/null +++ b/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.styledString.d.ets @@ -0,0 +1,32 @@ +/* + * 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. + */ + +export declare class StyledString { + constructor(value: string /*| ImageAttachment | CustomSpan, styles?: Array*/); + + readonly length: number; + + getString(): string; + // getStyles(start: number, length: number, styledKey?: StyledStringKey): Array; + equals(other: StyledString): boolean; + subStyledString(start: number, length?: number): StyledString; + + static fromHtml(html: string): Promise; + static toHtml(styledString: StyledString): string; + // static marshalling(styledString: StyledString, callback: StyledStringMarshallCallback): ArrayBuffer; + // static unmarshalling(buffer: ArrayBuffer, callback: StyledStringUnmarshallCallback): Promise; + // static marshalling(styledString: StyledString): ArrayBuffer; + // static unmarshalling(buffer: ArrayBuffer): Promise; +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.text.d.ets b/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.text.d.ets new file mode 100644 index 0000000000000000000000000000000000000000..5ba7ef75477458956a6042bd3a1b760903fcd89c --- /dev/null +++ b/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.text.d.ets @@ -0,0 +1,132 @@ +/* + * 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 { Resource } from "@ohos.arkui.external.resource"; +import { StyledString } from "@ohos.arkui.component.styledString"; +import { ComponentBuilder, CommonMethod } from "@ohos.arkui.component.common"; +import { ResourceColor, Length } from "@ohos.arkui.component.units"; +import { memo } from '@ohos.arkui.stateManagement.runtime'; + +export declare class TextController { + closeSelectionMenu(): void; + setStyledString(value: StyledString): void; + + // getLayoutManager(): LayoutManager; +} + +export declare interface TextOptions { + controller: TextController; +} + +export declare interface TextAttribute extends CommonMethod { + // @memo + // font(value: Font, options?: FontSettingOptions): this; + @memo + fontColor(value: ResourceColor): this; + @memo + fontSize(value: number | string | Resource): this; + @memo + minFontSize(value: number | string | Resource): this; + @memo + maxFontSize(value: number | string | Resource): this; + @memo + minFontScale(scale: number | Resource): this; + @memo + maxFontScale(scale: number | Resource): this; + // @memo + // fontStyle(value: FontStyle): this; + // @memo + // fontWeight(value: number | FontWeight | string): this; + // @memo + // fontWeight(weight: number | FontWeight | string, options?: FontSettingOptions): this; + // @memo + // lineSpacing(value: LengthMetrics): this; + // @memo + // textAlign(value: TextAlign): this; + @memo + lineHeight(value: number | string | Resource): this; + // @memo + // textOverflow(options: TextOverflowOptions): this; + @memo + fontFamily(value: string | Resource): this; + @memo + maxLines(value: number): this; + // @memo + // decoration(value: DecorationStyleInterface): this; + @memo + letterSpacing(value: number | string): this; + // @memo + // textCase(value: TextCase): this; + @memo + baselineOffset(value: number | string): this; + // @memo + // copyOption(value: CopyOptions): this; + @memo + draggable(value: boolean): this; + // @memo + // textShadow(value: ShadowOptions | Array): this; + // @memo + // heightAdaptivePolicy(value: TextHeightAdaptivePolicy): this; + @memo + textIndent(value: Length): this; + // @memo + // wordBreak(value: WordBreak): this; + // @memo + // lineBreakStrategy(strategy: LineBreakStrategy): this; + @memo + onCopy(callback: (value: string) => void): this; + @memo + selection(selectionStart: number, selectionEnd: number): this; + @memo + caretColor(color: ResourceColor): this; + @memo + selectedBackgroundColor(color: ResourceColor): this; + // @memo + // ellipsisMode(value: EllipsisMode): this; + @memo + enableDataDetector(enable: boolean): this; + // @memo + // dataDetectorConfig(config: TextDataDetectorConfig): this; + // @memo + // bindSelectionMenu(spanType: TextSpanType, content: CustomBuilder, responseType: TextResponseType, + // options?: SelectionMenuOptions): this; + @memo + onTextSelectionChange(callback: (selectionStart: number, selectionEnd: number) => void): this; + @memo + fontFeature(value: string): this; + // @memo + // marqueeOptions(options: Optional): this; + // @memo + // onMarqueeStateChange(callback: Callback): this; + @memo + privacySensitive(supported: boolean): this; + // @memo + // textSelectable(mode: TextSelectableMode): this; + // @memo + // editMenuOptions(editMenu: EditMenuOptions): this; + @memo + halfLeading(halfLeading: boolean): this; + @memo + enableHapticFeedback(isEnabled: boolean): this; +} + +@memo +@ComponentBuilder +export declare function Text ( + value?: string | Resource, + options?: TextOptions, + @memo + content?: () => void +): TextAttribute; diff --git a/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.units.d.ets b/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.units.d.ets new file mode 100644 index 0000000000000000000000000000000000000000..c6a98e6281f1f588c75fa2dabba57a1d9c904c7e --- /dev/null +++ b/ets1.2/arkui-plugins/test/local/@ohos.arkui.component.units.d.ets @@ -0,0 +1,29 @@ +/* + * 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 { Resource } from "@ohos.arkui.external.resource" +import { Color } from "@ohos.arkui.component.enums"; + +export type PX = string; +export type VP = string | number; +export type FP = string; +export type LPX = string; +export type Percentage = string; + +export type Dimension = PX | VP | FP | LPX | Percentage | Resource; + +export type Length = string | number | Resource; + +export type ResourceColor = Color | number | string | Resource; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/local/@ohos.arkui.external.resource.d.ets b/ets1.2/arkui-plugins/test/local/@ohos.arkui.external.resource.d.ets new file mode 100644 index 0000000000000000000000000000000000000000..9cc3b09e07de69770a6f394122713c2a0853a371 --- /dev/null +++ b/ets1.2/arkui-plugins/test/local/@ohos.arkui.external.resource.d.ets @@ -0,0 +1,16 @@ +/* + * 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. + */ + +export type Resource = boolean; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/local/@ohos.arkui.stateManagement.common.d.ets b/ets1.2/arkui-plugins/test/local/@ohos.arkui.stateManagement.common.d.ets new file mode 100644 index 0000000000000000000000000000000000000000..274947957808f9524d2fbf8746fffd2dd6934570 --- /dev/null +++ b/ets1.2/arkui-plugins/test/local/@ohos.arkui.stateManagement.common.d.ets @@ -0,0 +1,61 @@ +/* + * 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. + */ + +@Retention({policy: "SOURCE"}) +export declare @interface State {}; + +@Retention({policy: "SOURCE"}) +export declare @interface Prop {}; + +@Retention({policy: "SOURCE"}) +export declare @interface Link {}; + +@Retention({policy: "SOURCE"}) +export declare @interface Observed {}; + +@Retention({policy: "SOURCE"}) +export declare @interface Track {}; + +@Retention({policy: "SOURCE"}) +export declare @interface ObjectLink {}; + +@Retention({policy: "SOURCE"}) +export declare @interface StorageProp { value: string }; + +@Retention({policy: "SOURCE"}) +export declare @interface StorageLink { value: string }; + +@Retention({policy: "SOURCE"}) +export declare @interface LocalStorageProp { value: string }; + +@Retention({policy: "SOURCE"}) +export declare @interface LocalStorageLink { value: string }; + +@Retention({policy: "SOURCE"}) +export declare @interface Provide { value: string }; + +@Retention({policy: "SOURCE"}) +export declare @interface Consume { value: string }; + +@Retention({policy: "SOURCE"}) +export declare @interface Watch { value: string }; + +@Retention({policy: "SOURCE"}) +export declare @interface Require {}; + +export declare class UIUtils { + static getTarget(source: T): T; + static makeObserved(source: T): T; +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/local/@ohos.arkui.stateManagement.d.ets b/ets1.2/arkui-plugins/test/local/@ohos.arkui.stateManagement.d.ets new file mode 100644 index 0000000000000000000000000000000000000000..9cb01ec593ed40cc9c98940e4d1b8dcc9b7bdd33 --- /dev/null +++ b/ets1.2/arkui-plugins/test/local/@ohos.arkui.stateManagement.d.ets @@ -0,0 +1,18 @@ +/* + * 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. + */ + +export * from "@ohos.arkui.stateManagement.common"; +export * from "@ohos.arkui.stateManagement.runtime"; +export * from "@ohos.arkui.stateManagement.storage"; diff --git a/ets1.2/arkui-plugins/test/local/@ohos.arkui.stateManagement.runtime.d.ets b/ets1.2/arkui-plugins/test/local/@ohos.arkui.stateManagement.runtime.d.ets new file mode 100644 index 0000000000000000000000000000000000000000..f70c0cb7f5ec72d10ec63b245007a17403df611c --- /dev/null +++ b/ets1.2/arkui-plugins/test/local/@ohos.arkui.stateManagement.runtime.d.ets @@ -0,0 +1,62 @@ +/* + * 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 { LocalStorage } from "@ohos.arkui.stateManagement.storage" + +// From incremental engine +@Retention({policy: "SOURCE"}) +export declare @interface memo {}; + +export type __memo_context_type = StateContext; +export type __memo_id_type = MemoCallSiteKey; + +export type MemoCallSiteKey = int; + +export declare interface Disposable { + readonly disposed: boolean; + dispose(): void; +} + +export declare interface State { + readonly modified: boolean; + readonly value: T; +} + +export declare interface MutableState extends Disposable, State { + value: T; +} + +export type Equivalent = (oldV: T, newV: T) => boolean; + +export declare interface InternalScope { + readonly unchanged: boolean; + readonly cached: Value; + recache(newValue?: Value): Value; + param(index: int, value: T, equivalent?: Equivalent, name?: string, contextLocal?: boolean): State; +} + +export declare interface StateContext { + scope(id: MemoCallSiteKey, paramCount?: int): InternalScope; +} + +// From Arkoala +export declare function propState(value?: T): MutableState; +export declare function objectLinkState(value?: T): MutableState; +export declare function stateOf(value: T): MutableState; +export declare function contextLocalStateOf(value: T, key: () => T): MutableState; +export declare function contextLocal(value: T): MutableState; +export declare function observableProxy(value: T): T; +export declare function StorageLinkState(storage: LocalStorage, name: string, value: T): MutableState +export declare function AppStorageLinkState(name: string, value: T): MutableState; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/local/@ohos.arkui.stateManagement.storage.d.ets b/ets1.2/arkui-plugins/test/local/@ohos.arkui.stateManagement.storage.d.ets new file mode 100644 index 0000000000000000000000000000000000000000..a7257c839afaadfda0ce7c00942710078cb959aa --- /dev/null +++ b/ets1.2/arkui-plugins/test/local/@ohos.arkui.stateManagement.storage.d.ets @@ -0,0 +1,119 @@ +/* + * 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. + */ + +export declare interface StorageProperty { + key: string; + defaultValue: number | string | boolean | Object; +} + +export type PersistPropsOptions = StorageProperty; + +export declare interface AbstractProperty { + info(): string; + get(): T; + set(newValue: T): void; +} + +export declare interface SubscribedAbstractProperty extends AbstractProperty { + aboutToBeDeleted(): void; +} + +export declare class LocalStorage { + static getShared(): LocalStorage | undefined; + + constructor(initializingProperties?: StorageProperty[]); + + has(propName: string): boolean; + + keys(): IterableIterator; + + size(): int; + + get(propName: string): T | undefined; + + set(propName: string, newValue: T): boolean; + + setOrCreate(propName: string, newValue?: T): boolean; + + ref(propName: string): AbstractProperty | undefined; + + setAndRef(propName: string, defaultValue: T): AbstractProperty; + + link(propName: string): SubscribedAbstractProperty | undefined; + + setAndLink(propName: string, defaultValue: T): SubscribedAbstractProperty; + + prop(propName: string): SubscribedAbstractProperty | undefined; + + setAndProp(propName: string, defaultValue: T): SubscribedAbstractProperty; + + delete(propName: string): boolean; + + clear(): boolean; +} + +export declare class AppStorage { + static has(propName: string): boolean; + + static keys(): IterableIterator; + + static size(): int; + + static get(propName: string): T | undefined; + + static set(propName: string, newValue: T): boolean; + + static setOrCreate(propName: string, newValue?: T): boolean; + + static ref(propName: string): AbstractProperty | undefined; + + static setAndRef(propName: string, defaultValue: T): AbstractProperty; + + static link(propName: string): SubscribedAbstractProperty | undefined; + + static setAndLink(propName: string, defaultValue: T): SubscribedAbstractProperty; + + static prop(propName: string): SubscribedAbstractProperty | undefined; + + static setAndProp(propName: string, defaultValue: T): SubscribedAbstractProperty; + + static delete(propName: string): boolean; + + static clear(): boolean; +} + +export declare class PersistentStorage { + + static persistProp(key: string, defaultValue: T): void; + + static deleteProp(key: string): void; + + static persistProps(props: PersistPropsOptions[]): void; + + static keys(): Array; +} + +export declare interface EnvPropsOptions { + key: string; + defaultValue: number | string | boolean; +} + +export declare class Environment { + static envProp(key: string, value: S): boolean; + + static envProps(props: EnvPropsOptions[]): void; + + static keys(): Array; +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/localtest_config.js b/ets1.2/arkui-plugins/test/localtest_config.js new file mode 100644 index 0000000000000000000000000000000000000000..87fd2e7eec4599b2e9449a9913998b7bf3710527 --- /dev/null +++ b/ets1.2/arkui-plugins/test/localtest_config.js @@ -0,0 +1,51 @@ +/* + * 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. + */ + +const fs = require('fs'); +const path = require('path'); + +// 获取当前目录 +const currentDirectory = process.cwd(); +let workSpace = currentDirectory; +for (let i = 0; i < 4; i++) { + workSpace = path.dirname(workSpace); +} +// JSON 文件路径 +const jsonFilePath = path.join(__dirname, 'demo/localtest/build_config_template.json'); +const outJsonFilePath = path.join(__dirname, 'demo/localtest/build_config.json'); + +try { + // 读取 JSON 文件内容 + const data = fs.readFileSync(jsonFilePath, 'utf8'); + const jsonData = JSON.parse(data); + console.log(jsonData) + // 处理 baseUrl 字段 + if (jsonData.buildSdkPath) { + jsonData.buildSdkPath = jsonData.buildSdkPath.replace(/workspace/g, workSpace); + } + + // 处理 plugins 字段 + if (jsonData.plugins.ui_plugin) { + jsonData.plugins.ui_plugin = jsonData.plugins.ui_plugin.replace(/workspace/g, workSpace); + } + if (jsonData.plugins.memo_plugin) { + jsonData.plugins.memo_plugin = jsonData.plugins.memo_plugin.replace(/workspace/g, workSpace); + } + + // 将修改后的内容写回 JSON 文件 + fs.writeFileSync(outJsonFilePath, JSON.stringify(jsonData, null, 2), 'utf8'); +} catch (error) { + console.error('处理 JSON 文件时出错:', error); +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/test/localtest_decl_config.js b/ets1.2/arkui-plugins/test/localtest_decl_config.js new file mode 100644 index 0000000000000000000000000000000000000000..999494cffd0ee95b21b4a18130f9c064d599680d --- /dev/null +++ b/ets1.2/arkui-plugins/test/localtest_decl_config.js @@ -0,0 +1,51 @@ +/* + * 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. + */ + +const fs = require('fs'); +const path = require('path'); + +const currentDirectory = process.cwd(); +let workSpace = currentDirectory; +for (let i = 0; i < 4; i++) { + workSpace = path.dirname(workSpace); +} + +const jsonFilePath = path.join(__dirname, 'demo/localtest/build_decl_config_template.json'); +const outJsonFilePath = path.join(__dirname, 'demo/localtest/build_decl_config.json'); + +try { + const data = fs.readFileSync(jsonFilePath, 'utf8'); + const jsonData = JSON.parse(data); + + if (jsonData.buildSdkPath) { + jsonData.buildSdkPath = jsonData.buildSdkPath.replace(/workspace/g, workSpace); + } + + if (jsonData.plugins.interop_plugin) { + jsonData.plugins.interop_plugin = jsonData.plugins.interop_plugin.replace(/workspace/g, workSpace); + } + + if (jsonData.declgenV1OutPath) { + jsonData.declgenV1OutPath = jsonData.declgenV1OutPath.replace(/workspace/g, workSpace); + } + + if (jsonData.declgenBridgeCodePath) { + jsonData.declgenBridgeCodePath = jsonData.declgenBridgeCodePath.replace(/workspace/g, workSpace); + } + + fs.writeFileSync(outJsonFilePath, JSON.stringify(jsonData, null, 2), 'utf8'); +} catch (error) { + console.error('writeFile error:', error); +} diff --git a/ets1.2/arkui-plugins/test/package.json b/ets1.2/arkui-plugins/test/package.json new file mode 100644 index 0000000000000000000000000000000000000000..07123fbd761be13ee570397e4994ffff75d65231 --- /dev/null +++ b/ets1.2/arkui-plugins/test/package.json @@ -0,0 +1,21 @@ +{ + "name": "arkui-plugins-test", + "version": "1.0.0", + "description": "", + "private": true, + "scripts": { + "compile:ohos": "node $INIT_CWD/../../../../arkcompiler/ets_frontend/ets2panda/driver/build-system/dist/entry.js ./demo/hello_world/build_config.json", + "compile:gdb": "gdb --args node $INIT_CWD/../../../../out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/driver/build-system/dist/entry.js ./demo/hello_world/build_config.json", + "compile:plugins": "npm run compile --prefix ..", + "clean:localtest": "rm -rf dist", + "clean:test": "rm -rf generated", + "clean:all": "npm run clean:localtest && npm run clean:test", + "test": "npm run clean:all && npm run compile:plugins && cd .. && npm run test", + "localtest": "rm -rf dist && node localtest_config.js && npm run compile:plugins && LD_LIBRARY_PATH=$INIT_CWD/../../../../out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/ets2panda/lib node $INIT_CWD/../../../../out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/driver/build-system/dist/entry.js ./demo/localtest/build_config.json", + "localtest_gdb": "LD_LIBRARY_PATH=$INIT_CWD/../../../../out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/ets2panda/lib gdb --args node $INIT_CWD/../../../../out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/driver/build-system/dist/entry.js ./demo/localtest/build_config.json", + "localtest_decl": "rm -rf dist && node localtest_decl_config.js && npm run compile:plugins && LD_LIBRARY_PATH=$INIT_CWD/../../../../out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/ets2panda/lib node $INIT_CWD/../../../../out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/driver/build-system/dist/entry.js ./demo/localtest/build_decl_config.json", + "localtest_all": "npm run localtest_decl && npm run localtest", + "es2panda:compile": "node ./arktsconfig_gen.js && $INIT_CWD/../../../../out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/ets2panda/bin/es2panda --arktsconfig=./dist/cache/arktsconfig.json", + "es2panda:test": "$INIT_CWD/../../../../out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/ets2panda/bin/es2panda ./demo/localtest/entry/test.ets --output=test.abc" + } +} diff --git a/ets1.2/arkui-plugins/test/test.log b/ets1.2/arkui-plugins/test/test.log new file mode 100644 index 0000000000000000000000000000000000000000..984a29adfe735c5a5e2085b0494ad066ed1beadd --- /dev/null +++ b/ets1.2/arkui-plugins/test/test.log @@ -0,0 +1,372 @@ + +> build_system_test@1.0.0 compile:ohos_sdk +> node /home/wuhaibin/newcode/oh/out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/driver/build-system/dist/entry.js ./demo/hello_world/build_config.json + +[ + '/home/wuhaibin/.nvm/versions/node/v23.8.0/bin/node', + '/home/wuhaibin/newcode/oh/out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/driver/build-system/dist/entry.js', + './demo/hello_world/build_config.json' +] +Updated PATH: /home/wuhaibin/newcode/oh/developtools/ace_ets2bundle/arkui-plugins/test/node_modules/.bin:/home/wuhaibin/newcode/oh/developtools/ace_ets2bundle/arkui-plugins/node_modules/.bin:/home/wuhaibin/newcode/oh/developtools/ace_ets2bundle/node_modules/.bin:/home/wuhaibin/newcode/oh/developtools/node_modules/.bin:/home/wuhaibin/newcode/oh/node_modules/.bin:/home/wuhaibin/newcode/node_modules/.bin:/home/wuhaibin/node_modules/.bin:/home/node_modules/.bin:/node_modules/.bin:/home/wuhaibin/.nvm/versions/node/v23.8.0/lib/node_modules/npm/node_modules/@npmcli/run-script/lib/node-gyp-bin:/home/wuhaibin/.local/bin:/home/wuhaibin/bin:/home/wuhaibin/.nvm/versions/node/v23.8.0/bin:/home/wuhaibin/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/usr/lib/wsl/lib:/mnt/c/WINDOWS/system32:/mnt/c/WINDOWS:/mnt/c/WINDOWS/System32/Wbem:/mnt/c/WINDOWS/System32/WindowsPowerShell/v1.0/:/mnt/c/WINDOWS/System32/OpenSSH/:/mnt/c/Users/wuhaibin/AppData/Local/Microsoft/WindowsApps:/mnt/c/Users/wuhaibin/AppData/Local/Programs/Microsoft VS Code/bin:/snap/bin:/home/wuhaibin/newcode/oh/out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/ets2panda/lib +Loaded plugin: ui-plugin { uiTransform: [Function: uiTransform] } [Function: uiTransform] +Loaded plugin: memo-plugin { unmemoizeTransform: [Function: unmemoizeTransform] } [Function: unmemoizeTransform] +ets2pandaCmd: _ --extension ets --arktsconfig /home/wuhaibin/newcode/oh/developtools/ace_ets2bundle/arkui-plugins/test/dist/cache/entry/arktsconfig.json --output /home/wuhaibin/newcode/oh/developtools/ace_ets2bundle/arkui-plugins/test/dist/cache/entry/a.abc --debug-info ./demo/hello_world/entry/a.ets +[TS WRAPPER] CREATE CONFIG +InitModule: es2panda + +[TS WRAPPER] PROCEED TO STATE: 1 +es2panda proceedToState parsed +[TS WRAPPER] GET AST FROM CONTEXT +executing plugin: ui-plugin +[UI PLUGIN] AFTER PARSED ENTER +[AFTER PARSED SCRIPT]: +import { StructBase } from "@koalaui.arkts-arkui.StructBase"; + +import { Text as Text } from "@koalaui.arkts-arkui.Text"; + +import { Column as Column } from "@koalaui.arkts-arkui.Column"; + +import { Button as Button } from "@koalaui.arkts-arkui.Button"; + +import { Component as Component, StorageLink as StorageLink, State as State } from "@koalaui.arkts-arkui.Common"; + +import { UserView as UserView, UserViewBuilder as UserViewBuilder } from "@koalaui.arkts-arkui.UserView"; + +import { __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from "@ohos.arkui.StateManagement.runtime"; + +import { memo as memo } from "@ohos.arkui.StateManagement.runtime"; + +function isTrue(): string { + return "aa"; +} + +final class MyStateSample extends StructBase { + public aaa: string = isTrue(); + + public build() { + Column(){ + Text("Hello World!"); + Text((this).aaa); + Button("change"); + }; + } + + public constructor() {} + +} + +class ComExampleTrivialApplication extends UserView { + public getBuilder(): UserViewBuilder { + let wrapper = ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { + MyStateSample.instantiateImpl(undefined, ((): MyStateSample => new MyStateSample()), ({} as __Options_MyStateSample), undefined); + }); + return wrapper; + } + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + + +[UI PLUGIN] AFTER PARSED EXIT +plugin parsed finished +[TS WRAPPER] GET AST FROM CONTEXT +[TS WRAPPER] DESTROY AND RECREATE +[TS WRAPPER] PROCEED TO STATE: 4 +es2panda proceedToState checked +[TS WRAPPER] GET AST FROM CONTEXT +executing plugin: ui-plugin +[UI PLUGIN] AFTER CHECKED ENTER +[AFTER STRUCT SCRIPT] script: +import { StructBase as StructBase } from "@koalaui.arkts-arkui.StructBase"; + +import { Text as Text } from "@koalaui.arkts-arkui.Text"; + +import { Column as Column } from "@koalaui.arkts-arkui.Column"; + +import { Button as Button } from "@koalaui.arkts-arkui.Button"; + +import { Component as Component, StorageLink as StorageLink, State as State } from "@koalaui.arkts-arkui.Common"; + +import { UserView as UserView, UserViewBuilder as UserViewBuilder } from "@koalaui.arkts-arkui.UserView"; + +import { __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from "@ohos.arkui.StateManagement.runtime"; + +import { memo as memo } from "@ohos.arkui.StateManagement.runtime"; + +abstract class ETSGLOBAL { + public static main() {} + + public static _$init$_() {} + + public static isTrue(): string { + return "aa"; + } + + +} + +class MyStateSample extends StructBase { + @memo()public __initializeStruct(initializers?: __Options_MyStateSample, @memo()content?: (()=> void)): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + public aaa: string = ETSGLOBAL.isTrue(); + + @memo()protected _build(@memo()style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo()content: (()=> void) | undefined, initializers?: __Options_MyStateSample): void { + Column.instantiateImpl(((instance: Column): Column => { + return instance; + }), ((): Column => { + return new Column(); + }), (() => { + Text.instantiateImpl(((instance: Text): Text => { + return instance; + }), ((): Text => { + return new Text(); + }), "Hello World!") + Text.instantiateImpl(((instance: Text): Text => { + return instance; + }), ((): Text => { + return new Text(); + }), (this).aaa) + Button.instantiateImpl(((instance: Button): Button => { + return instance; + }), ((): Button => { + return new Button(); + }), "change") + })); + } + + public constructor() {} + +} + +class ComExampleTrivialApplication extends UserView { + public getBuilder(): UserViewBuilder { + let wrapper = ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { + MyStateSample.instantiateImpl(undefined, ((): MyStateSample => { + return new MyStateSample(); + }), ({} as __Options_MyStateSample), undefined); + }); + return wrapper; + } + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + + +[UI PLUGIN] AFTER CHECKED EXIT +executing plugin: memo-plugin +[MEMO PLUGIN] AFTER CHECKED ENTER +[BEFORE MEMO SCRIPT] script: +import { StructBase as StructBase } from "@koalaui.arkts-arkui.StructBase"; + +import { Text as Text } from "@koalaui.arkts-arkui.Text"; + +import { Column as Column } from "@koalaui.arkts-arkui.Column"; + +import { Button as Button } from "@koalaui.arkts-arkui.Button"; + +import { Component as Component, StorageLink as StorageLink, State as State } from "@koalaui.arkts-arkui.Common"; + +import { UserView as UserView, UserViewBuilder as UserViewBuilder } from "@koalaui.arkts-arkui.UserView"; + +import { __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from "@ohos.arkui.StateManagement.runtime"; + +import { memo as memo } from "@ohos.arkui.StateManagement.runtime"; + +abstract class ETSGLOBAL { + public static main() {} + + public static _$init$_() {} + + public static isTrue(): string { + return "aa"; + } + + +} + +class MyStateSample extends StructBase { + @memo()public __initializeStruct(initializers?: __Options_MyStateSample, @memo()content?: (()=> void)): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + public aaa: string = ETSGLOBAL.isTrue(); + + @memo()protected _build(@memo()style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo()content: (()=> void) | undefined, initializers?: __Options_MyStateSample): void { + Column.instantiateImpl(((instance: Column): Column => { + return instance; + }), ((): Column => { + return new Column(); + }), (() => { + Text.instantiateImpl(((instance: Text): Text => { + return instance; + }), ((): Text => { + return new Text(); + }), "Hello World!") + Text.instantiateImpl(((instance: Text): Text => { + return instance; + }), ((): Text => { + return new Text(); + }), (this).aaa) + Button.instantiateImpl(((instance: Button): Button => { + return instance; + }), ((): Button => { + return new Button(); + }), "change") + })); + } + + public constructor() {} + +} + +class ComExampleTrivialApplication extends UserView { + public getBuilder(): UserViewBuilder { + let wrapper = ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { + MyStateSample.instantiateImpl(undefined, ((): MyStateSample => { + return new MyStateSample(); + }), ({} as __Options_MyStateSample), undefined); + }); + return wrapper; + } + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + + +[AFTER MEMO SCRIPT] script: +import { StructBase as StructBase } from "@koalaui.arkts-arkui.StructBase"; + +import { Text as Text } from "@koalaui.arkts-arkui.Text"; + +import { Column as Column } from "@koalaui.arkts-arkui.Column"; + +import { Button as Button } from "@koalaui.arkts-arkui.Button"; + +import { Component as Component, StorageLink as StorageLink, State as State } from "@koalaui.arkts-arkui.Common"; + +import { UserView as UserView, UserViewBuilder as UserViewBuilder } from "@koalaui.arkts-arkui.UserView"; + +import { __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from "@ohos.arkui.StateManagement.runtime"; + +import { memo as memo } from "@ohos.arkui.StateManagement.runtime"; + +abstract class ETSGLOBAL { + public static main() {} + + public static _$init$_() {} + + public static isTrue(): string { + return "aa"; + } + + +} + +class MyStateSample extends StructBase { + public __initializeStruct(__memo_context: __memo_context_type, __memo_id: __memo_id_type, initializers?: __Options_MyStateSample, content?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + (168924120)), 2); + const __memo_parameter_initializers = __memo_scope.param(0, initializers), __memo_parameter_content = __memo_scope.param(1, content); + if (__memo_scope.unchanged) { + __memo_scope.recache(__memo_scope.cached) + return; + } + { + __memo_scope.recache() + return; + } + } + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + public aaa: string = ETSGLOBAL.isTrue(); + + protected _build(__memo_context: __memo_context_type, __memo_id: __memo_id_type, style: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: MyStateSample)=> MyStateSample) | undefined, content: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined, initializers?: __Options_MyStateSample): void { + const __memo_scope = __memo_context.scope(((__memo_id) + (168198604)), 3); + const __memo_parameter_style = __memo_scope.param(0, style), __memo_parameter_content = __memo_scope.param(1, content), __memo_parameter_initializers = __memo_scope.param(2, initializers); + if (__memo_scope.unchanged) { + __memo_scope.recache(__memo_scope.cached) + return; + } + Column.instantiateImpl(__memo_context, ((__memo_id) + (229216764)), ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: Column): Column => { + return instance; + }), ((): Column => { + return new Column(); + }), ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { + const __memo_scope = __memo_context.scope(((__memo_id) + (131080140)), 0); + if (__memo_scope.unchanged) { + __memo_scope.recache(__memo_scope.cached) + return; + } + Text.instantiateImpl(__memo_context, ((__memo_id) + (122349231)), ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: Text): Text => { + return instance; + }), ((): Text => { + return new Text(); + }), "Hello World!") + Text.instantiateImpl(__memo_context, ((__memo_id) + (259830593)), ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: Text): Text => { + return instance; + }), ((): Text => { + return new Text(); + }), (this).aaa) + Button.instantiateImpl(__memo_context, ((__memo_id) + (23671947)), ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, instance: Button): Button => { + return instance; + }), ((): Button => { + return new Button(); + }), "change") + { + __memo_scope.recache() + return; + } + })); + { + __memo_scope.recache() + return; + } + } + + public constructor() {} + +} + +class ComExampleTrivialApplication extends UserView { + public getBuilder(): UserViewBuilder { + let wrapper = ((__memo_context: __memo_context_type, __memo_id: __memo_id_type) => { + MyStateSample.instantiateImpl(__memo_context, ((__memo_id) + (44218244)), undefined, ((): MyStateSample => { + return new MyStateSample(); + }), ({} as __Options_MyStateSample), undefined); + }); + return wrapper; + } + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + + +[MEMO PLUGIN] AFTER CHECKED EXIT +plugin checked finished +[TS WRAPPER] GET AST FROM CONTEXT +[TS WRAPPER] DESTROY AND RECREATE +[TS WRAPPER] PROCEED TO STATE: 7 +es2panda bin generated +"/home/wuhaibin/newcode/oh/out/sdk/ohos-sdk/linux/ets/ets1.2/build-tools/ets2panda/bin/ark_link" --output "/home/wuhaibin/newcode/oh/developtools/ace_ets2bundle/arkui-plugins/test/dist/modules_static.abc" -- @"dist/cache/fileInfo.txt" diff --git a/ets1.2/arkui-plugins/test/ut/common/annotation.test.ts b/ets1.2/arkui-plugins/test/ut/common/annotation.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..cf9f7d191eab5ce015343fd51fb46337989f3bdc --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/common/annotation.test.ts @@ -0,0 +1,38 @@ +/* + * 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 { PluginTestContext, PluginTester } from '../../utils/plugin-tester'; +import { annotation } from '../../../common/arkts-utils'; +import * as arkts from '@koalaui/libarkts'; + +const pluginTester = new PluginTester('test arkts-utils'); + +function testAnnotation(this: PluginTestContext): void { + const anno: arkts.AnnotationUsage = annotation('State'); + expect(arkts.isAnnotationUsage(anno)).toBeTruthy(); + expect(anno.dumpSrc()).toBe('@State() '); +} + +pluginTester.run( + 'annotation', + [], + { + parsed: [testAnnotation], + checked: [testAnnotation], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/argument-call.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/argument-call.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..a3d7d2909665884324dfb5ca82cacde1f7be36f9 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/argument-call.test.ts @@ -0,0 +1,109 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const FUNCTION_DIR_PATH: string = 'memo/functions'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'argument-call.ets')]; + +const pluginTester = new PluginTester('test memo function', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@functions.OptionalParametersAnnotation({minArgCount:3}) function memo_arg_call(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg1: number, arg2: ((x: number)=> number), @memo() arg3: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, x: number)=> number), arg4?: ((x: number)=> number), @memo() arg5?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, x: number)=> number)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 5); + const __memo_parameter_arg1 = __memo_scope.param(0, arg1), __memo_parameter_arg2 = __memo_scope.param(1, arg2), __memo_parameter_arg3 = __memo_scope.param(2, arg3), __memo_parameter_arg4 = __memo_scope.param(3, arg4), __memo_parameter_arg5 = __memo_scope.param(4, arg5); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + __memo_parameter_arg2.value(__memo_parameter_arg1.value); + __memo_parameter_arg3.value(__memo_context, ((__memo_id) + ()), __memo_parameter_arg1.value); + ({let gensym%%_ = __memo_parameter_arg4.value; + (((gensym%%_) == (null)) ? undefined : gensym%%_(__memo_parameter_arg1.value))}); + ({let gensym%%_ = __memo_parameter_arg5.value; + (((gensym%%_) == (null)) ? undefined : gensym%%_(__memo_context, ((__memo_id) + ()), __memo_parameter_arg1.value))}); + { + __memo_scope.recache(); + return; + } +} +@functions.OptionalParametersAnnotation({minArgCount:1}) function memo_arg_call_with_lowering(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg1: number, arg4?: ((x: number)=> number), @memo() arg5?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, x: number)=> number)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 3); + const __memo_parameter_arg1 = __memo_scope.param(0, arg1), __memo_parameter_arg4 = __memo_scope.param(1, arg4), __memo_parameter_arg5 = __memo_scope.param(2, arg5); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + let gensym___ = __memo_parameter_arg4.value; + (((gensym___) == (null)) ? undefined : gensym___(__memo_parameter_arg1.value)); + } + { + let gensym___ = __memo_parameter_arg5.value; + (((gensym___) == (null)) ? undefined : gensym___(__memo_context, ((__memo_id) + ()), __memo_parameter_arg1.value)); + } + { + __memo_scope.recache(); + return; + } +} +@functions.OptionalParametersAnnotation({minArgCount:0}) function args_with_default_values(__memo_context: __memo_context_type, __memo_id: __memo_id_type, gensym%%_?: int, @memo() gensym%%_?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> int), gensym%%_?: int, arg4?: int): void { + let arg1: int = (((gensym%%_) !== (undefined)) ? gensym%%_ : (10 as int)); + let arg2: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> int) = (((gensym%%_) !== (undefined)) ? gensym%%_ : (((__memo_context: __memo_context_type, __memo_id: __memo_id_type): int => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(20); + }) as ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> int))); + let arg3: int = (((gensym%%_) !== (undefined)) ? gensym%%_ : (arg1 as int)); + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 4); + const __memo_parameter_arg1 = __memo_scope.param(0, arg1), __memo_parameter_arg2 = __memo_scope.param(1, arg2), __memo_parameter_arg3 = __memo_scope.param(2, arg3), __memo_parameter_arg4 = __memo_scope.param(3, arg4); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + console.log(__memo_parameter_arg1.value, __memo_parameter_arg2.value, __memo_parameter_arg3.value, __memo_parameter_arg4.value); + console.log(__memo_parameter_arg2.value(__memo_context, ((__memo_id) + ()))); + { + __memo_scope.recache(); + return; + } +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform argument calls in functions', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/declare-and-call.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/declare-and-call.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..db15946ae06df9c3a9bf9d0d1037a027fae86831 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/declare-and-call.test.ts @@ -0,0 +1,90 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const FUNCTION_DIR_PATH: string = 'memo/functions'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'declare-and-call.ets'), +]; + +const pluginTester = new PluginTester('test memo function', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + funcA(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } +}); +@memo() function funcA(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void +function funcB(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + funcA(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } +} +class A { + public foo(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + funcA(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform declare functions and calls', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/inner-functions.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/inner-functions.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..8e549464318354654d0303cbc1adda98572cd928 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/inner-functions.test.ts @@ -0,0 +1,112 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const FUNCTION_DIR_PATH: string = 'memo/functions'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'inner-functions.ets'), +]; + +const pluginTester = new PluginTester('test memo function', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +function foo(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } +} +function bar(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + const qux = @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + foo(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } + }); + const other = (() => {}); + { + __memo_scope.recache(); + return; + } +} +class A { + public goo(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + let func = (() => {}); + let func2 = @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + foo(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } + }); + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform inner functions', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/non-void-return-type.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/non-void-return-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..19b061ad6bc38ec118d84e479fc4e5404308b882 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/non-void-return-type.test.ts @@ -0,0 +1,112 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const FUNCTION_DIR_PATH: string = 'memo/functions'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'non-void-return-type.ets'), +]; + +const pluginTester = new PluginTester('test memo function', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +function funcNum(__memo_context: __memo_context_type, __memo_id: __memo_id_type): number { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(1); +} +function funcStr(__memo_context: __memo_context_type, __memo_id: __memo_id_type): string { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(\"1\"); +} +function funcBool(__memo_context: __memo_context_type, __memo_id: __memo_id_type): boolean { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(false); +} +function funcA(__memo_context: __memo_context_type, __memo_id: __memo_id_type): A { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache({ + str: \"1\", + }); +} +function funcB(__memo_context: __memo_context_type, __memo_id: __memo_id_type): B { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(((str: string) => {})); +} +function funcC(__memo_context: __memo_context_type, __memo_id: __memo_id_type): C { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(new C(\"1\")); +} +function funcD(__memo_context: __memo_context_type, __memo_id: __memo_id_type): (()=> void) { + const __memo_scope = __memo_context.scope<(()=> void)>(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache((() => {})); +} +interface A { + set str(str: string) + get str(): string +} +type B = ((str: string)=> void); +class C { + public str: string; + public constructor(str: string) { + this.str = str; + } +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform functions with non-void return type', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/type-reference.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/type-reference.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..7db7cd676d57630897af74cb9328c96c2d64e75d --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/type-reference.test.ts @@ -0,0 +1,92 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const FUNCTION_DIR_PATH: string = 'memo/functions'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'type-reference.ets'), +]; + +const pluginTester = new PluginTester('test memo function', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() function A(__memo_context: __memo_context_type, __memo_id: __memo_id_type): Attribute +function func(__memo_context: __memo_context_type, __memo_id: __memo_id_type): ItemBuilder { + const __memo_scope = __memo_context.scope>(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(((__memo_context: __memo_context_type, __memo_id: __memo_id_type, item: Item): void => {})); +} +@memo() type ItemBuilder = ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, item: Item)=> void); +interface Item { + set item(item: T) + get item(): T +} +interface Attribute { + @memo() each(__memo_context: __memo_context_type, __memo_id: __memo_id_type, @memo() itemGenerator: ItemBuilder): Attribute +} +class B { + public build(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + A(__memo_context, ((__memo_id) + ())).each(__memo_context, ((__memo_id) + ()), ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, ri: Item): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_ri = __memo_scope.param(0, ri); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform functions with type reference', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/void-return-type.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/void-return-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..08c0eb3bdde9bba0673ab6a0c22cf7af771eda8c --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/function-declarations/void-return-type.test.ts @@ -0,0 +1,61 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const FUNCTION_DIR_PATH: string = 'memo/functions'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'void-return-type.ets'), +]; + +const pluginTester = new PluginTester('test memo function', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +function func(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform functions with void return type', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/lambda-literals/argument-call.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/lambda-literals/argument-call.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..f23a8d2529875eded121b1b681d55546030393d1 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/lambda-literals/argument-call.test.ts @@ -0,0 +1,173 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const LAMBDA_DIR_PATH: string = 'memo/lambdas'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, LAMBDA_DIR_PATH, 'argument-call.ets')]; + +const pluginTester = new PluginTester('test memo lambda', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +((arg: (()=> void)) => {})((() => {})); + +((arg: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)) => {})(@memo() (() => {})); + +((gensym%%_1?: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)) => { + let arg: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) = (((gensym%%_1) !== (undefined)) ? gensym%%_1 : (((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + (201676739)), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }) as @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void))); +})(@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + (209782503)), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } +})); + +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, gensym%%_?: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void => { + let arg: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) = (((gensym%%_) !== (undefined)) ? gensym%%_ : (((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }) as @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void))); + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })(__memo_context, ((__memo_id) + ()), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + { + __memo_scope.recache(); + return; + } +}); + +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + let goo = @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, gensym%%_?: string): void => { + let name: string = (((gensym%%_) !== (undefined)) ? gensym%%_ : (\"old\" as string)); + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_name = __memo_scope.param(0, name); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }); + goo(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } +}); + +(() => { + let foo = ((gensym%%_?: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)) => { + let arg: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) = (((gensym%%_) !== (undefined)) ? gensym%%_ : (((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }) as @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void))); + }); + foo(@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); +}); +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform argument calls in lambdas', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/lambda-literals/function-with-receiver.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/lambda-literals/function-with-receiver.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..be488294a6ca913309fa32ba707384b588cf1857 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/lambda-literals/function-with-receiver.test.ts @@ -0,0 +1,97 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; +import { Plugins } from '../../../../common/plugin-context'; +import { uiTransform } from '../../../../ui-plugins'; + +const LAMBDA_DIR_PATH: string = 'memo/lambdas'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, LAMBDA_DIR_PATH, 'function-with-receiver.ets'), +]; + +const parsedTransform: Plugins = { + name: 'state-complex-type', + parsed: uiTransform().parsed +}; + +const pluginTester = new PluginTester('test memo lambda', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "@ohos.arkui.stateManagement"; + +function main() {} + +function foo1(this: B, __memo_context: __memo_context_type, __memo_id: __memo_id_type, str: string): void { + const __memo_scope = __memo_context.scope(((__memo_id) + (38567515)), 2); + const __memo_parameter_this = __memo_scope.param(0, this), __memo_parameter_str = __memo_scope.param(1, str); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + console.log("Good", __memo_parameter_str.value); + { + __memo_scope.recache(); + return; + } +} + +function foo2(this: B, __memo_context: __memo_context_type, __memo_id: __memo_id_type, str: string): B { + const __memo_scope = __memo_context.scope(((__memo_id) + (167482260)), 2); + const __memo_parameter_this = __memo_scope.param(0, this), __memo_parameter_str = __memo_scope.param(1, str); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + console.log("Good", __memo_parameter_str.value); + return __memo_scope.recache(this); +} + +class B { + public internal_call(__memo_context: __memo_context_type, __memo_id: __memo_id_type): B { + const __memo_scope = __memo_context.scope(((__memo_id) + (146437675)), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + foo1(this, __memo_context, ((__memo_id) + (119664703)), "morning"); + return __memo_scope.recache(foo2(this, __memo_context, ((__memo_id) + (181969214)), "afternoon")); + } + + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform lambdas about function with receiver feature', + [parsedTransform, memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/lambda-literals/trailing-lambdas.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/lambda-literals/trailing-lambdas.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..f023fef13b9f4a87a60269817fc05e53bd411580 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/lambda-literals/trailing-lambdas.test.ts @@ -0,0 +1,169 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const LAMBDA_DIR_PATH: string = 'memo/lambdas'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, LAMBDA_DIR_PATH, 'trailing-lambdas.ets'), +]; + +const pluginTester = new PluginTester('test memo lambda', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + let a = new A(); + a.foo(__memo_context, ((__memo_id) + ()), (() => { + console.log(); + })); + a.goo(((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + console.log(); + { + __memo_scope.recache(); + return; + } + })); + a.koo(__memo_context, ((__memo_id) + ()), ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + console.log(); + { + __memo_scope.recache(); + return; + } + })); + bar(__memo_context, ((__memo_id) + ()), (() => { + console.log(); + })); + par(((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + console.log(); + { + __memo_scope.recache(); + return; + } + })); + kar(__memo_context, ((__memo_id) + ()), ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + console.log(); + { + __memo_scope.recache(); + return; + } + })); + { + __memo_scope.recache(); + return; + } +}); +@functions.OptionalParametersAnnotation({minArgCount:0}) function bar(__memo_context: __memo_context_type, __memo_id: __memo_id_type, f?: (()=> void)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_f = __memo_scope.param(0, f); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } +} +@functions.OptionalParametersAnnotation({minArgCount:0}) function par(f?: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void {} +@functions.OptionalParametersAnnotation({minArgCount:0}) function kar(__memo_context: __memo_context_type, __memo_id: __memo_id_type, @memo() f?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_f = __memo_scope.param(0, f); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } +} +class A { + @functions.OptionalParametersAnnotation({minArgCount:0}) public foo(__memo_context: __memo_context_type, __memo_id: __memo_id_type, p?: (()=> void)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_p = __memo_scope.param(0, p); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + @functions.OptionalParametersAnnotation({minArgCount:0}) public goo(@memo() p?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void {} + @functions.OptionalParametersAnnotation({minArgCount:0}) public koo(__memo_context: __memo_context_type, __memo_id: __memo_id_type, @memo() p?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_p = __memo_scope.param(0, p); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform trailing lambdas', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/lambda-literals/void-lambda.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/lambda-literals/void-lambda.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..59b48a02458e04db484aca46c70396f2fca00a2d --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/lambda-literals/void-lambda.test.ts @@ -0,0 +1,73 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const LAMBDA_DIR_PATH: string = 'memo/lambdas'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, LAMBDA_DIR_PATH, 'void-lambda.ets'), +]; + +const pluginTester = new PluginTester('test memo lambda', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } +}); +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg?: (()=> string)): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } +}); +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform lambdas with void return type', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/lambda-literals/with-receiver.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/lambda-literals/with-receiver.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..4f6e3fa92a6c7d7c4056ab836055e662fa0aa522 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/lambda-literals/with-receiver.test.ts @@ -0,0 +1,125 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const LAMBDA_DIR_PATH: string = 'memo/lambdas'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, LAMBDA_DIR_PATH, 'with-receiver.ets'), +]; + +const pluginTester = new PluginTester('test memo lambda', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + let x = new Person(); + fullName(x, ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + let f1: F1 = foo; + f1 = goo; + let f2: F2 = goo; + f2 = foo; + f1 = f2; + let a = new A(); + f1(a, ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + f1(a, ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + f2(a, ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + { + __memo_scope.recache(); + return; + } +}); +@functions.OptionalParametersAnnotation({minArgCount:1}) function fullName(this: Person, @memo() arg?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void { + return; +} +@functions.OptionalParametersAnnotation({minArgCount:1}) function foo(this: A, @memo() arg?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void {} +@functions.OptionalParametersAnnotation({minArgCount:1}) function goo(a: A, @memo() arg?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void {} +class Person { + public constructor() {} +} +class A { + public constructor() {} +} +type F1 = ((this: A, @memo() arg?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void))=> void); +type F2 = ((a: A, @memo() arg?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void))=> void); +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform lambdas with receiver', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/argument-call.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/argument-call.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..de72519e74bbc1669122263ac6f136e10b4ce9fa --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/argument-call.test.ts @@ -0,0 +1,145 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const METHOD_DIR_PATH: string = 'memo/methods'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, METHOD_DIR_PATH, 'argument-call.ets')]; + +const pluginTester = new PluginTester('test memo method', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +class Test { + public lambda_arg(__memo_context: __memo_context_type, __memo_id: __memo_id_type, @memo() arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public lambda_arg_with_arg(__memo_context: __memo_context_type, __memo_id: __memo_id_type, @memo() arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, value: string)=> string)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public memo_content(__memo_context: __memo_context_type, __memo_id: __memo_id_type, @memo() content: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_content = __memo_scope.param(0, content); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + __memo_parameter_content.value(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } + } + public compute_test(__memo_context: __memo_context_type, __memo_id: __memo_id_type, @memo() arg1: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined, arg2: (()=> void) | undefined, content: (()=> void) | undefined): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 3); + const __memo_parameter_arg1 = __memo_scope.param(0, arg1), __memo_parameter_arg2 = __memo_scope.param(1, arg2), __memo_parameter_content = __memo_scope.param(2, content); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +class Use { + public test(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + const test = new Test(); + test.lambda_arg(__memo_context, ((__memo_id) + ()), ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + test.lambda_arg_with_arg(__memo_context, ((__memo_id) + ()), ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, value: string): string => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_value = __memo_scope.param(0, value); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(__memo_parameter_value.value); + })); + test.compute_test(__memo_context, ((__memo_id) + ()), ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }), (() => {}), (() => {})); + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform argument calls in methods', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/callable.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/callable.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..7657e1dd0ce878e17e8df46d82fec626e2754e57 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/callable.test.ts @@ -0,0 +1,112 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const METHOD_DIR_PATH: string = 'memo/methods'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, METHOD_DIR_PATH, 'callable.ets')]; + +const pluginTester = new PluginTester('test memo method', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + A.$_invoke(__memo_context, ((__memo_id) + ())); + B.$_invoke(((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + let x: C | D = C.$_instantiate(__memo_context, ((__memo_id) + ()), (() => { + return new C(); + })); + x = D.$_instantiate((() => { + return new D(); + })); + { + __memo_scope.recache(); + return; + } +}); +class A { + public static $_invoke(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +class B { + @functions.OptionalParametersAnnotation({minArgCount:0}) public static $_invoke(@memo() p?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void {} + public constructor() {} +} +class C { + public static $_instantiate(__memo_context: __memo_context_type, __memo_id: __memo_id_type, factory: (()=> C)): C { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_factory = __memo_scope.param(0, factory); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(__memo_parameter_factory.value()); + } + public constructor() {} +} +class D { + @functions.OptionalParametersAnnotation({minArgCount:1}) public static $_instantiate(factory: (()=> D), @memo() content?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): D { + return factory(); + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform callable class', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/declare-and-call.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/declare-and-call.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..0a669b4c085c2bf7abfc2c0cbd8e52c6bbaaf7b1 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/declare-and-call.test.ts @@ -0,0 +1,83 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const METHOD_DIR_PATH: string = 'memo/methods'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, METHOD_DIR_PATH, 'declare-and-call.ets'), +]; + +const pluginTester = new PluginTester('test memo method', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + new AA().x(__memo_context, ((__memo_id) + ())); + const a: A = new AA(); + a.x(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } +}); +declare abstract class A { + @memo() public x(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void + public test_signature(@memo() arg1: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void), @memo() arg2: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined, @memo() arg3: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined | ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> int) | undefined, @memo() x: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, y: ((z: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void))=> void))=> void)): @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) + public constructor() {} +} +class AA extends A { + public x(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform declare methods and calls', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/internal-calls.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/internal-calls.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..11dae0f7ed8a30c405812e53110d00d47ec5dd09 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/internal-calls.test.ts @@ -0,0 +1,186 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const METHOD_DIR_PATH: string = 'memo/methods'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, METHOD_DIR_PATH, 'internal-calls.ets')]; + +const pluginTester = new PluginTester('test memo method', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +function __context(): __memo_context_type +function __id(): __memo_id_type +type MemoType = @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void); +class Test { + public void_method(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public internal_call(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + this.void_method(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } + } + public method_with_internals(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + __context(); + __id(); + { + __memo_scope.recache(); + return; + } + } + public memo_lambda() { + @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }); + } + public memo_variables(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + @memo() const f = ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): number => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(123); + }), g = ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, x: number): number => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_x = __memo_scope.param(0, x); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(((123) + (__memo_parameter_x.value))); + }); + const h = @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): number => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(1); + }); + f(__memo_context, ((__memo_id) + ())); + g(__memo_context, ((__memo_id) + ()), 1); + h(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } + } + @functions.OptionalParametersAnnotation({minArgCount:0}) public args_with_default_values(__memo_context: __memo_context_type, __memo_id: __memo_id_type, gensym%%_1?: int, gensym%%_2?: (()=> int), gensym%%_3?: int, arg4?: int): void { + let arg1: int = (((gensym%%_1) !== (undefined)) ? gensym%%_1 : (10 as int)); + let arg2: (()=> int) = (((gensym%%_2) !== (undefined)) ? gensym%%_2 : ((() => { + return 20; + }) as (()=> int))); + let arg3: int = (((gensym%%_3) !== (undefined)) ? gensym%%_3 : (arg1 as int)); + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 4); + const __memo_parameter_arg1 = __memo_scope.param(0, arg1), __memo_parameter_arg2 = __memo_scope.param(1, arg2), __memo_parameter_arg3 = __memo_scope.param(2, arg3), __memo_parameter_arg4 = __memo_scope.param(3, arg4); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + console.log(__memo_parameter_arg1.value, __memo_parameter_arg2.value, __memo_parameter_arg3.value, __memo_parameter_arg4.value); + console.log(__memo_parameter_arg2.value()); + { + __memo_scope.recache(); + return; + } + } + @functions.OptionalParametersAnnotation({minArgCount:0}) public optional_args(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg1?: int, arg2?: (()=> int)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 2); + const __memo_parameter_arg1 = __memo_scope.param(0, arg1), __memo_parameter_arg2 = __memo_scope.param(1, arg2); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + console.log(__memo_parameter_arg1.value); + console.log(__memo_parameter_arg2.value); + console.log(({let gensym%%_166 = __memo_parameter_arg2.value; + (((gensym%%_166) == (null)) ? undefined : gensym%%_166())})); + { + __memo_scope.recache(); + return; + } + } + public type_alias(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg: MemoType): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + __memo_parameter_arg.value(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform inner calls in methods', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/non-void-method.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/non-void-method.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..a8ddef791a1367d4cb3575135fcfa52205e29514 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/non-void-method.test.ts @@ -0,0 +1,119 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const METHOD_DIR_PATH: string = 'memo/methods'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, METHOD_DIR_PATH, 'non-void-method.ets')]; + +const pluginTester = new PluginTester('test memo method', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +function __context(): __memo_context_type +function __id(): __memo_id_type +@Retention({policy:"SOURCE"}) @interface memo_intrinsic {} +@Retention({policy:"SOURCE"}) @interface memo_entry {} +class Test { + public void_method(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public string_method_with_return(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg: string): string { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(__memo_parameter_arg.value); + } + public method_with_type_parameter(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg: T): T { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(__memo_parameter_arg.value); + } + public intrinsic_method(): int { + return 0; + } + public intrinsic_method_with_this(): int { + this.void_method(__memo_context, ((__memo_id) + ())); + return 0; + } + public memoEntry(__memo_context: __memo_context_type, __memo_id: __memo_id_type, @memo() entry: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> R)): R { + const getContext = (() => { + return __context(); + }); + const getId = (() => { + return __id(); + }); + { + const __memo_context = getContext(); + const __memo_id = getId(); + return entry(__memo_context, ((__memo_id) + ())); + } + } + public constructor() {} +} +class Use { + public test(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + const test = new Test(); + test.string_method_with_return(__memo_context, ((__memo_id) + ()), "a string"); + test.method_with_type_parameter(__memo_context, ((__memo_id) + ()), "I'm string"); + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform methods with non-void return type', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/void-method.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/void-method.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..953742b8a28ebc4248b410680ccd4f4971dd75cb --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/method-declarations/void-method.test.ts @@ -0,0 +1,151 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const METHOD_DIR_PATH: string = 'memo/methods'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, METHOD_DIR_PATH, 'void-method.ets'), +]; + +const pluginTester = new PluginTester('test memo method', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +class A { + public x: int; + public y: int; + public constructor() {} +} +class Test { + public void_method(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public a_method_with_implicit_return_type(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public void_method_with_arg(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg: string): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public void_method_with_return(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg: string): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public static static_method_with_type_parameter(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg: T): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public obj_arg(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg: A): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +class Use { + public test(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + const test = new Test(); + test.void_method(__memo_context, ((__memo_id) + ())); + test.void_method_with_arg(__memo_context, ((__memo_id) + ()), "an arg"); + test.void_method_with_return(__memo_context, ((__memo_id) + ()), "a value"); + Test.static_method_with_type_parameter(__memo_context, ((__memo_id) + ()), "I'm static"); + test.obj_arg(__memo_context, ((__memo_id) + ()), { + x: 1, + y: 2, + }); + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform methods with void return type', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/property-declarations/class-constructor.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/property-declarations/class-constructor.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..28671e70099f78415a094cd6548f1f8b48adfdb6 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/property-declarations/class-constructor.test.ts @@ -0,0 +1,101 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const PROPERTY_DIR_PATH: string = 'memo/properties'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, PROPERTY_DIR_PATH, 'class-constructor.ets'), +]; + +const pluginTester = new PluginTester('test memo property', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + let a = new AA({ + a: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }), + }); + { + __memo_scope.recache(); + return; + } +}); +interface A { + @memo() set a(a: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void + @memo() get a(): ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) +} +class AA { + @memo() public a: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined; + constructor() { + this(undefined); + } + public constructor(arg: A | undefined) { + this.a = ({let gensym%%_ = arg; + (((gensym%%_) == (null)) ? undefined : gensym%%_.a)}); + } + public build(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + ({let gensym%%_ = this.a; + (((gensym%%_) == (null)) ? undefined : gensym%%_(__memo_context, ((__memo_id) + ())))}); + { + __memo_scope.recache(); + return; + } + } +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform properties in class constructor', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/property-declarations/class-properties.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/property-declarations/class-properties.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..c987200392947b7ce38ffd1d31dd1d034326a613 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/property-declarations/class-properties.test.ts @@ -0,0 +1,106 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const PROPERTY_DIR_PATH: string = 'memo/properties'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, PROPERTY_DIR_PATH, 'class-properties.ets'), +]; + +const pluginTester = new PluginTester('test memo property', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from "@ohos.arkui.stateManagement"; +function main() {} +class A { + public arg: (()=> void); + @memo() public memo_arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void); + @memo() public memo_optional_arg?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined; + @memo() public memo_union_arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined = ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }); + public arg_memo_type: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void); + public constructor() { + this.arg = (() => {}); + this.memo_arg = ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }); + this.arg_memo_type = ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }); + } + public build(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + this.arg(); + this.memo_arg(__memo_context, ((__memo_id) + ())); + this.arg_memo_type(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } + } +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform properties in class', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/memo-plugins/property-declarations/interfaces.test.ts b/ets1.2/arkui-plugins/test/ut/memo-plugins/property-declarations/interfaces.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..99053d0efc1ff8c0704aae5ef3e8a5bb7f94ba85 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/memo-plugins/property-declarations/interfaces.test.ts @@ -0,0 +1,107 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const PROPERTY_DIR_PATH: string = 'memo/properties'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, PROPERTY_DIR_PATH, 'interfaces.ets')]; + +const pluginTester = new PluginTester('test memo property', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + let a: A = { + arg: (() => {}), + memo_arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }), + memo_union_arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }), + arg_memo_type: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }), + }; + { + __memo_scope.recache(); + return; + } +}); +interface A { + set arg(arg: (()=> void)) + get arg(): (()=> void) + @memo() set memo_arg(memo_arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void + @memo() get memo_arg(): ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) + @memo() set memo_optional_arg(memo_optional_arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined): void + @memo() get memo_optional_arg(): ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined + @memo() set memo_union_arg(memo_union_arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined): void + @memo() get memo_union_arg(): ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined + set arg_memo_type(arg_memo_type: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)) + get arg_memo_type(): @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform interface properties', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/animation/animation-basic.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/animation/animation-basic.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..dd4678db61622b3ddf437dbce6fec4d19a40b103 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/animation/animation-basic.test.ts @@ -0,0 +1,121 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { uiNoRecheck } from '../../../utils/plugins'; +import { uiTransform } from '../../../../ui-plugins'; +import { Plugins } from '../../../../common/plugin-context'; + +const ANIMATION_DIR_PATH: string = 'animation'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, ANIMATION_DIR_PATH, 'animation-basic.ets'), +]; + +const animationTransform: Plugins = { + name: 'animation', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test basic animation transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; + +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Text as Text, Column as Column, Component as Component, Color as Color, Curve as Curve } from "@ohos.arkui.component"; + +import { Entry as Entry } from "@ohos.arkui.component"; + +function main() {} + + + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class AnimatablePropertyExample extends CustomComponent { + public __initializeStruct(initializers: __Options_AnimatablePropertyExample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_AnimatablePropertyExample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: AnimatablePropertyExample)=> AnimatablePropertyExample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_AnimatablePropertyExample | undefined): void { + Column(undefined, undefined, (() => { + Text(@memo() ((instance: UITextAttribute): void => { + instance.animationStart({ + duration: 2000, + curve: Curve.Ease, + }).backgroundColor(Color.Red).animationStop({ + duration: 2000, + curve: Curve.Ease, + }).animationStart({ + duration: 2000, + curve: Curve.Ease, + }).fontSize(20).animationStop({ + duration: 2000, + curve: Curve.Ease, + }).width("100%"); + return; + }), "AnimatableProperty", undefined, undefined); + })); + } + + public constructor() {} + +} + +interface __Options_AnimatablePropertyExample { + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + AnimatablePropertyExample._instantiateImpl(undefined, (() => { + return new AnimatablePropertyExample(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} +`; + +function testAnimationTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test basic animation transform', + [animationTransform, uiNoRecheck], + { + checked: [testAnimationTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/builder-lambda/custom-component/custom-component-call.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/builder-lambda/custom-component/custom-component-call.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..b9a0d5943b3976263962533eb7f9fc86253eb8a2 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/builder-lambda/custom-component/custom-component-call.test.ts @@ -0,0 +1,166 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { recheck, uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'builder-lambda'; +const CUSTOM_COMPONENT_DIR_PATH: string = 'custom-component'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, CUSTOM_COMPONENT_DIR_PATH, 'custom-component-call.ets'), +]; + +const pluginTester = new PluginTester('test custom component call transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'custom-component-call', + parsed: uiTransform().parsed +}; + +const expectedParsedScript: string = ` +import { __memo_id_type as __memo_id_type } from "@ohos.arkui.stateManagement"; +import { __memo_context_type as __memo_context_type } from "@ohos.arkui.stateManagement"; +import { memo as memo } from "@ohos.arkui.stateManagement"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "@ohos.arkui.component"; +import { Text as Text, Column as Column, Component as Component, Builder as Builder, BuilderParam as BuilderParam } from "@ohos.arkui.component"; + +@Component() final class CustomContainer extends CustomComponent { + @Builder() public closerBuilder() {} + @BuilderParam() public closer: (()=> void) = (this).closerBuilder; + public build() {} + public constructor() {} +} + +@Component() final class CustomContainerUser extends CustomComponent { + public build() { + Column(undefined){ + CustomContainer(undefined){ + Column(undefined){ + Text("hello", undefined); + }; + }; + CustomContainer(({} as __Options_CustomContainer)){ + Column(undefined){}; + }; + CustomContainer(undefined){}; + CustomContainer(); + }; + } + public constructor() {} +} + +interface __Options_CustomContainer { + closer?: @memo() (()=> void); +} + +interface __Options_CustomContainerUser { +} +`; + +function testParedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedParsedScript)); +} + +const expectedBuilderLambdaScript: string = ` +import { __memo_id_type as __memo_id_type } from "@ohos.arkui.stateManagement"; +import { __memo_context_type as __memo_context_type } from "@ohos.arkui.stateManagement"; +import { memo as memo } from "@ohos.arkui.stateManagement"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "@ohos.arkui.component"; +import { Text as Text, Column as Column, Component as Component, Builder as Builder, BuilderParam as BuilderParam } from "@ohos.arkui.component"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class CustomContainer extends CustomComponent { + public __initializeStruct(initializers: __Options_CustomContainer | undefined, @memo() content: (()=> void) | undefined): void { + (this).__backing_closer = ((((({let gensym___38813563 = initializers; + (((gensym___38813563) == (null)) ? undefined : gensym___38813563.closer)})) ?? (content))) ?? ((this).closerBuilder)) + } + public __updateStruct(initializers: __Options_CustomContainer | undefined): void {} + private __backing_closer?: @memo() (()=> void); + public get closer(): @memo() (()=> void) { + return (this).__backing_closer!; + } + public set closer(@memo() value: (()=> void)) { + (this).__backing_closer = value; + } + @memo() public closerBuilder() {} + @memo() public _build(@memo() style: ((instance: CustomContainer)=> CustomContainer) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_CustomContainer | undefined): void {} + public constructor() {} +} + +@Component({freezeWhenInactive:false}) final class CustomContainerUser extends CustomComponent { + public __initializeStruct(initializers: __Options_CustomContainerUser | undefined, @memo() content: (()=> void) | undefined): void {} + public __updateStruct(initializers: __Options_CustomContainerUser | undefined): void {} + @memo() public _build(@memo() style: ((instance: CustomContainerUser)=> CustomContainerUser) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_CustomContainerUser | undefined): void { + Column(undefined, undefined, (() => { + CustomContainer._instantiateImpl(undefined, (() => { + return new CustomContainer(); + }), undefined, (() => { + Column(undefined, undefined, (() => { + Text(undefined, "hello", undefined, undefined); + })); + }), undefined); + CustomContainer._instantiateImpl(undefined, (() => { + return new CustomContainer(); + }), ({} as __Options_CustomContainer), (() => { + Column(undefined, undefined, (() => {})); + }), undefined); + CustomContainer._instantiateImpl(undefined, (() => { + return new CustomContainer(); + }), undefined, (() => {}), undefined); + CustomContainer._instantiateImpl(undefined, (() => { + return new CustomContainer(); + }), undefined, undefined, undefined); + })); + } + public constructor() {} +} + +interface __Options_CustomContainer { + set closer(closer: @memo() (()=> void) | undefined) + get closer(): @memo() (()=> void) | undefined +} + +interface __Options_CustomContainerUser { +} +`; + +function testCustomComponentTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedBuilderLambdaScript)); +} + +pluginTester.run( + 'test custom component call transformation', + [parsedTransform, recheck, uiNoRecheck], + { + parsed: [testParedTransformer], + 'checked:builder-lambda-no-recheck': [testCustomComponentTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/builder-lambda/simple-component.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/builder-lambda/simple-component.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..37b4605ad3ed31255840b0017cae248b3f3258fb --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/builder-lambda/simple-component.test.ts @@ -0,0 +1,91 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { builderLambdaNoRecheck, memoNoRecheck, recheck } from '../../../utils/plugins'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'builder-lambda'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'simple-component.ets'), +]; + +const pluginTester = new PluginTester('test builder-lambda simple component', buildConfig); + +function testBuilderLambdaTransformer(this: PluginTestContext): void { + const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +import { Column as Column, UIColumnAttribute as UIColumnAttribute } from \"arkui.component.column\"; +function main() {} +class MyStateSample { + @memo() public build() { + Column(undefined, undefined, (() => {})); + } + public constructor() {} +} +`; + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +function testMemoTransformer(this: PluginTestContext): void { + const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +import { Column as Column, UIColumnAttribute as UIColumnAttribute } from \"arkui.component.column\"; +function main() {} +class MyStateSample { + public build(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + (263357132)), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + Column(__memo_context, ((__memo_id) + (65509320)), undefined, undefined, ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + (147296800)), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform simple component', + [builderLambdaNoRecheck, recheck, memoNoRecheck], + { + 'checked:builder-lambda-no-recheck': [testBuilderLambdaTransformer], + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/builder-lambda/style-with-receiver.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/builder-lambda/style-with-receiver.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..1c64f1cdb615ab39691453a1af0eea3b08742de5 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/builder-lambda/style-with-receiver.test.ts @@ -0,0 +1,102 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { builderLambdaNoRecheck, structNoRecheck, uiNoRecheck } from '../../../utils/plugins'; +import { uiTransform } from '../../../../ui-plugins'; +import { Plugins } from '../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'builder-lambda'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'style-with-receiver.ets'), +]; + +const pluginTester = new PluginTester('test function with receiver style transformstion', buildConfig); + +const parsedTransform: Plugins = { + name: 'style-with-receiver', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { memo as memo } from "@ohos.arkui.stateManagement"; +import { Text as Text, UITextAttribute as UITextAttribute, Column as Column, Component as Component } from "@ohos.arkui.component"; +import hilog from "@ohos.hilog"; + +function main() {} + +@memo() function cardStyle(this: UITextAttribute, num: number, str: string): UITextAttribute { + this.fontSize(num); + this.backgroundColor(num); + return this; +} + +@memo() function style22(this: UITextAttribute): UITextAttribute { + this.fontWeight(700); + return this; +} + +@Component({freezeWhenInactive:false}) final class MM extends CustomComponent { + public __initializeStruct(initializers: __Options_MM | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MM | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MM)=> MM) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MM | undefined): void { + Column(undefined, undefined, (() => { + Text(@memo() ((instance: UITextAttribute): void => { + style22(cardStyle(instance.height(200).fontColor("#000000"), 600, "#eeeeee").fontSize(60).fontWeight(400)).width(900); + return; + }), "hello world", undefined, undefined); + Text(@memo() ((instance: UITextAttribute): void => { + cardStyle(instance, 600, "#eeeeee"); + return; + }), "hello world", undefined, undefined); + })); + } + + public constructor() {} + +} + +interface __Options_MM { + +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test function with receiver style transformstion', + [parsedTransform, uiNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/builder-param-passing.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/builder-param-passing.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..ba63b9e2d3f79a811fb07922b3c14d811a15a9d8 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/builder-param-passing.test.ts @@ -0,0 +1,133 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const FUNCTION_DIR_PATH: string = 'decorators/builder-param'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'builder-param-passing.ets'), +]; + +const pluginTester = new PluginTester('test builder param variable passing', buildConfig); + +const parsedTransform: Plugins = { + name: 'builder-param-passing', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "@ohos.arkui.stateManagement"; +import { __memo_context_type as __memo_context_type } from "@ohos.arkui.stateManagement"; +import { memo as memo } from "@ohos.arkui.stateManagement"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "@ohos.arkui.component"; +import { Component as Component, Entry as Entry, Builder as Builder, BuilderParam as BuilderParam, Column as Column, Text as Text } from "@ohos.arkui.component"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class Child extends CustomComponent { + public __initializeStruct(initializers: __Options_Child | undefined, @memo() content: (()=> void) | undefined): void { + (this).__backing_customBuilderParam = ((((({let gensym___169376706 = initializers; + (((gensym___169376706) == (null)) ? undefined : gensym___169376706.customBuilderParam)})) ?? (content))) ?? ((this).customBuilder)) + } + + public __updateStruct(initializers: __Options_Child | undefined): void {} + + private __backing_customBuilderParam?: @memo() (()=> void); + + public get customBuilderParam(): @memo() (()=> void) { + return (this).__backing_customBuilderParam!; + } + + public set customBuilderParam(@memo() value: (()=> void)) { + (this).__backing_customBuilderParam = value; + } + + @memo() public customBuilder() {} + + @memo() public _build(@memo() style: ((instance: Child)=> Child) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Child | undefined): void { + (this).customBuilderParam(); + } + + public constructor() {} + +} + +@Component({freezeWhenInactive:false}) final class Parent extends CustomComponent { + public __initializeStruct(initializers: __Options_Parent | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_Parent | undefined): void {} + + @memo() public componentBuilder() { + Text(undefined, "Parent builder", undefined, undefined); + } + + @memo() public _build(@memo() style: ((instance: Parent)=> Parent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Parent | undefined): void { + Column(undefined, undefined, (() => { + Child._instantiateImpl(undefined, (() => { + return new Child(); + }), ({ + customBuilderParam: (this).componentBuilder, + } as __Options_Child), undefined, undefined); + Child._instantiateImpl(undefined, (() => { + return new Child(); + }), ({ + customBuilderParam: @memo() (() => { + (this).componentBuilder(); + }), + } as __Options_Child), undefined, undefined); + Child._instantiateImpl(undefined, (() => { + return new Child(); + }), undefined, (() => { + Text(undefined, "Parent builder", undefined, undefined); + }), undefined); + })); + } + public constructor() {} +} + +interface __Options_Child { + set customBuilderParam(customBuilderParam: @memo() (()=> void) | undefined) + get customBuilderParam(): @memo() (()=> void) | undefined +} + +interface __Options_Parent { +} +`; + +function testCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test builder param variable passing', + [parsedTransform, uiNoRecheck], + { + 'checked:ui-no-recheck': [testCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/init-with-local-builder.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/init-with-local-builder.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..21e7f2bb4fa8bba3df65ba934b73b5ace27df3c1 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/builder-param/init-with-local-builder.test.ts @@ -0,0 +1,100 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const FUNCTION_DIR_PATH: string = 'decorators/builder-param'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'init-with-local-builder.ets'), +]; + +const pluginTester = new PluginTester('test builder param init with local builder', buildConfig); + +const parsedTransform: Plugins = { + name: 'init-with-local-builder', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, Builder as Builder, BuilderParam as BuilderParam } from "@ohos.arkui.component"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class Child extends CustomComponent { + public __initializeStruct(initializers: __Options_Child | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_customBuilderParam = ((((({let gensym___169376706 = initializers; + (((gensym___169376706) == (null)) ? undefined : gensym___169376706.customBuilderParam)})) ?? (content))) ?? (this.doNothingBuilder)) + this.__backing_customBuilderParam2 = ((((({let gensym___14041256 = initializers; + (((gensym___14041256) == (null)) ? undefined : gensym___14041256.customBuilderParam2)})) ?? (content))) ?? (this.doNothingBuilder2)) + } + public __updateStruct(initializers: __Options_Child | undefined): void {} + private __backing_customBuilderParam?: @memo() (()=> void); + public get customBuilderParam(): @memo() (()=> void) { + return this.__backing_customBuilderParam!; + } + public set customBuilderParam(@memo() value: (()=> void)) { + this.__backing_customBuilderParam = value; + } + private __backing_customBuilderParam2?: @memo() ((str: string)=> void); + public get customBuilderParam2(): @memo() ((str: string)=> void) { + return this.__backing_customBuilderParam2!; + } + public set customBuilderParam2(@memo() value: ((str: string)=> void)) { + this.__backing_customBuilderParam2 = value; + } + @memo() public doNothingBuilder() {} + @memo() public doNothingBuilder2(str: string) {} + @memo() public _build(@memo() style: ((instance: Child)=> Child) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Child | undefined): void { + this.customBuilderParam(); + this.customBuilderParam2("hello"); + } + public constructor() {} +} + +interface __Options_Child { + set customBuilderParam(customBuilderParam: @memo() (()=> void) | undefined) + get customBuilderParam(): @memo() (()=> void) | undefined + set customBuilderParam2(customBuilderParam2: @memo() ((str: string)=> void) | undefined) + get customBuilderParam2(): @memo() ((str: string)=> void) | undefined +} +`; + +function testCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test builder param init with local builder', + [parsedTransform, uiNoRecheck], + { + 'checked:ui-no-recheck': [testCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/builder/global-builder.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/builder/global-builder.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..95740a1d5123337008002dcf8760639e48454ce0 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/builder/global-builder.test.ts @@ -0,0 +1,97 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const FUNCTION_DIR_PATH: string = 'decorators/builder'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'global-builder.ets'), +]; + +const pluginTester = new PluginTester('test global builder', buildConfig); + +const parsedTransform: Plugins = { + name: 'global-builder', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { UIRowAttribute as UIRowAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, Row as Row, Builder as Builder, Text as Text } from "@ohos.arkui.component"; + +function main() {} + +@memo() function showTextBuilder() { + Text(undefined, "Hello World", undefined, undefined); +} + +@memo() function overBuilder(params: Tmp) { + Row(undefined, undefined, (() => { + Text(undefined, (("UseStateVarByReference: ") + (params.paramA1)), undefined, undefined); + })); +} + +class Tmp { + public paramA1: string = ""; + public constructor() {} +} + +@Component({freezeWhenInactive:false}) final class BuilderDemo extends CustomComponent { + public __initializeStruct(initializers: __Options_BuilderDemo | undefined, @memo() content: (()=> void) | undefined): void {} + public __updateStruct(initializers: __Options_BuilderDemo | undefined): void {} + @memo() public _build(@memo() style: ((instance: BuilderDemo)=> BuilderDemo) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_BuilderDemo | undefined): void { + Row(undefined, undefined, @memo() (() => { + showTextBuilder(); + overBuilder({ + paramA1: "Hello", + }); + })); + } + public constructor() {} +} + +interface __Options_BuilderDemo { + +} +`; + +function testCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'global builder', + [parsedTransform, uiNoRecheck], + { + 'checked:ui-no-recheck': [testCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/builder/local-builder.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/builder/local-builder.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..9769285c5dff301ccb5500da9ed6655cd95f1c4d --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/builder/local-builder.test.ts @@ -0,0 +1,92 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const FUNCTION_DIR_PATH: string = 'decorators/builder'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'local-builder.ets'), +]; + +const pluginTester = new PluginTester('test local builder', buildConfig); + +const parsedTransform: Plugins = { + name: 'local-builder', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, Column as Column, Builder as Builder, Text as Text } from "@ohos.arkui.component"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class BuilderDemo extends CustomComponent { + public __initializeStruct(initializers: __Options_BuilderDemo | undefined, @memo() content: (()=> void) | undefined): void {} + public __updateStruct(initializers: __Options_BuilderDemo | undefined): void {} + @memo() public showTextBuilder() { + Text(@memo() ((instance: UITextAttribute): void => { + instance.fontSize(30); + return; + }), "Hello World", undefined, undefined); + } + @memo() public showTextValueBuilder(param: string) { + Text(@memo() ((instance: UITextAttribute): void => { + instance.fontSize(30); + return; + }), param, undefined, undefined); + } + @memo() public _build(@memo() style: ((instance: BuilderDemo)=> BuilderDemo) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_BuilderDemo | undefined): void { + Column(undefined, undefined, @memo() (() => { + this.showTextBuilder(); + this.showTextValueBuilder("Hello @Builder"); + })); + } + public constructor() {} +} + +interface __Options_BuilderDemo { + +} +`; + +function testCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'local builder', + [parsedTransform, uiNoRecheck], + { + 'checked:ui-no-recheck': [testCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/link/link-basic-type.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/link/link-basic-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..340db6a9eacac05ec71919e9af39810b6c26c7fc --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/link/link-basic-type.test.ts @@ -0,0 +1,151 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/link'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'link-basic-type.ets'), +]; + +const pluginTester = new PluginTester('test basic type @Link decorated variables transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'link-basic-type', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { DecoratedV1VariableBase as DecoratedV1VariableBase } from "@ohos.arkui.stateManagement"; +import { LinkDecoratedVariable as LinkDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { Link as Link } from "@ohos.arkui.stateManagement"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class LinkParent extends CustomComponent { + public __initializeStruct(initializers: __Options_LinkParent | undefined, @memo() content: (()=> void) | undefined): void { + if (({let gensym___11910109 = initializers; + (((gensym___11910109) == (null)) ? undefined : gensym___11910109.__backing_linkVar1)})) { + this.__backing_linkVar1 = new LinkDecoratedVariable("linkVar1", initializers!.__backing_linkVar1!); + }; + if (({let gensym___181684045 = initializers; + (((gensym___181684045) == (null)) ? undefined : gensym___181684045.__backing_linkVar2)})) { + this.__backing_linkVar2 = new LinkDecoratedVariable("linkVar2", initializers!.__backing_linkVar2!); + }; + if (({let gensym___24446313 = initializers; + (((gensym___24446313) == (null)) ? undefined : gensym___24446313.__backing_linkVar3)})) { + this.__backing_linkVar3 = new LinkDecoratedVariable("linkVar3", initializers!.__backing_linkVar3!); + }; + if (({let gensym___167989826 = initializers; + (((gensym___167989826) == (null)) ? undefined : gensym___167989826.__backing_linkVar4)})) { + this.__backing_linkVar4 = new LinkDecoratedVariable("linkVar4", initializers!.__backing_linkVar4!); + }; + if (({let gensym___157566097 = initializers; + (((gensym___157566097) == (null)) ? undefined : gensym___157566097.__backing_linkVar5)})) { + this.__backing_linkVar5 = new LinkDecoratedVariable("linkVar5", initializers!.__backing_linkVar5!); + }; + } + public __updateStruct(initializers: __Options_LinkParent | undefined): void {} + private __backing_linkVar1?: LinkDecoratedVariable; + public get linkVar1(): string { + return this.__backing_linkVar1!.get(); + } + public set linkVar1(value: string) { + this.__backing_linkVar1!.set(value); + } + private __backing_linkVar2?: LinkDecoratedVariable; + public get linkVar2(): number { + return this.__backing_linkVar2!.get(); + } + public set linkVar2(value: number) { + this.__backing_linkVar2!.set(value); + } + private __backing_linkVar3?: LinkDecoratedVariable; + public get linkVar3(): boolean { + return this.__backing_linkVar3!.get(); + } + public set linkVar3(value: boolean) { + this.__backing_linkVar3!.set(value); + } + private __backing_linkVar4?: LinkDecoratedVariable; + public get linkVar4(): undefined { + return this.__backing_linkVar4!.get(); + } + public set linkVar4(value: undefined) { + this.__backing_linkVar4!.set(value); + } + private __backing_linkVar5?: LinkDecoratedVariable; + public get linkVar5(): null { + return this.__backing_linkVar5!.get(); + } + public set linkVar5(value: null) { + this.__backing_linkVar5!.set(value); + } + @memo() public _build(@memo() style: ((instance: LinkParent)=> LinkParent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_LinkParent | undefined): void {} + public constructor() {} +} + +interface __Options_LinkParent { + set linkVar1(linkVar1: string | undefined) + get linkVar1(): string | undefined + set __backing_linkVar1(__backing_linkVar1: DecoratedV1VariableBase | undefined) + get __backing_linkVar1(): DecoratedV1VariableBase | undefined + set linkVar2(linkVar2: number | undefined) + get linkVar2(): number | undefined + set __backing_linkVar2(__backing_linkVar2: DecoratedV1VariableBase | undefined) + get __backing_linkVar2(): DecoratedV1VariableBase | undefined + set linkVar3(linkVar3: boolean | undefined) + get linkVar3(): boolean | undefined + set __backing_linkVar3(__backing_linkVar3: DecoratedV1VariableBase | undefined) + get __backing_linkVar3(): DecoratedV1VariableBase | undefined + set linkVar4(linkVar4: undefined | undefined) + get linkVar4(): undefined | undefined + set __backing_linkVar4(__backing_linkVar4: DecoratedV1VariableBase | undefined) + get __backing_linkVar4(): DecoratedV1VariableBase | undefined + set linkVar5(linkVar5: null | undefined) + get linkVar5(): null | undefined + set __backing_linkVar5(__backing_linkVar5: DecoratedV1VariableBase | undefined) + get __backing_linkVar5(): DecoratedV1VariableBase | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test basic type @Link decorated variables transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/link/link-complex-type.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/link/link-complex-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..486097a84761d4f03315d22735a709bfe1b4e7be --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/link/link-complex-type.test.ts @@ -0,0 +1,314 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/link'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'link-complex-type.ets'), +]; + +const pluginTester = new PluginTester('test complex type @Link decorated variables transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'link-complex-type', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { DecoratedV1VariableBase as DecoratedV1VariableBase } from "@ohos.arkui.stateManagement"; +import { LinkDecoratedVariable as LinkDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { Link as Link } from "@ohos.arkui.stateManagement"; + +function main() {} + +class Per { + public num: number; + public constructor(num: number) { + this.num = num; + } +} + +final class LinkType extends BaseEnum { + private readonly #ordinal: int; + private static () {} + public constructor(ordinal: int, value: int) { + super(value); + this.#ordinal = ordinal; + } + public static readonly TYPE1: LinkType = new LinkType(0, 0); + public static readonly TYPE2: LinkType = new LinkType(1, 1); + public static readonly TYPE3: LinkType = new LinkType(2, 3); + private static readonly #NamesArray: String[] = ["TYPE1", "TYPE2", "TYPE3"]; + private static readonly #ValuesArray: int[] = [0, 1, 3]; + private static readonly #StringValuesArray: String[] = ["0", "1", "3"]; + private static readonly #ItemsArray: LinkType[] = [LinkType.TYPE1, LinkType.TYPE2, LinkType.TYPE3]; + public getName(): String { + return LinkType.#NamesArray[this.#ordinal]; + } + public static getValueOf(name: String): LinkType { + for (let i = 0;((i) < (LinkType.#NamesArray.length));(++i)) { + if (((name) == (LinkType.#NamesArray[i]))) { + return LinkType.#ItemsArray[i]; + } + } + throw new Error((("No enum constant LinkType.") + (name))); + } + + public static fromValue(value: int): LinkType { + for (let i = 0;((i) < (LinkType.#ValuesArray.length));(++i)) { + if (((value) == (LinkType.#ValuesArray[i]))) { + return LinkType.#ItemsArray[i]; + } + } + throw new Error((("No enum LinkType with value ") + (value))); + } + public valueOf(): int { + return LinkType.#ValuesArray[this.#ordinal]; + } + public toString(): String { + return LinkType.#StringValuesArray[this.#ordinal]; + } + public static values(): LinkType[] { + return LinkType.#ItemsArray; + } + public getOrdinal(): int { + return this.#ordinal; + } + public static $_get(e: LinkType): String { + return e.getName(); + } +} + +@Component({freezeWhenInactive:false}) final class Parent extends CustomComponent { + public __initializeStruct(initializers: __Options_Parent | undefined, @memo() content: (()=> void) | undefined): void { + if (({let gensym___11910109 = initializers; + (((gensym___11910109) == (null)) ? undefined : gensym___11910109.__backing_linkVar1)})) { + this.__backing_linkVar1 = new LinkDecoratedVariable("linkVar1", initializers!.__backing_linkVar1!); + }; + if (({let gensym___181684045 = initializers; + (((gensym___181684045) == (null)) ? undefined : gensym___181684045.__backing_linkVar2)})) { + this.__backing_linkVar2 = new LinkDecoratedVariable>("linkVar2", initializers!.__backing_linkVar2!); + }; + if (({let gensym___24446313 = initializers; + (((gensym___24446313) == (null)) ? undefined : gensym___24446313.__backing_linkVar3)})) { + this.__backing_linkVar3 = new LinkDecoratedVariable("linkVar3", initializers!.__backing_linkVar3!); + }; + if (({let gensym___167989826 = initializers; + (((gensym___167989826) == (null)) ? undefined : gensym___167989826.__backing_linkVar4)})) { + this.__backing_linkVar4 = new LinkDecoratedVariable>("linkVar4", initializers!.__backing_linkVar4!); + }; + if (({let gensym___157566097 = initializers; + (((gensym___157566097) == (null)) ? undefined : gensym___157566097.__backing_linkVar5)})) { + this.__backing_linkVar5 = new LinkDecoratedVariable>("linkVar5", initializers!.__backing_linkVar5!); + }; + if (({let gensym___60105491 = initializers; + (((gensym___60105491) == (null)) ? undefined : gensym___60105491.__backing_linkVar6)})) { + this.__backing_linkVar6 = new LinkDecoratedVariable>("linkVar6", initializers!.__backing_linkVar6!); + }; + if (({let gensym___3429048 = initializers; + (((gensym___3429048) == (null)) ? undefined : gensym___3429048.__backing_linkVar7)})) { + this.__backing_linkVar7 = new LinkDecoratedVariable>("linkVar7", initializers!.__backing_linkVar7!); + }; + if (({let gensym___139916435 = initializers; + (((gensym___139916435) == (null)) ? undefined : gensym___139916435.__backing_linkVar8)})) { + this.__backing_linkVar8 = new LinkDecoratedVariable<((sr: string)=> void)>("linkVar8", initializers!.__backing_linkVar8!); + }; + if (({let gensym___145003260 = initializers; + (((gensym___145003260) == (null)) ? undefined : gensym___145003260.__backing_linkVar9)})) { + this.__backing_linkVar9 = new LinkDecoratedVariable("linkVar9", initializers!.__backing_linkVar9!); + }; + if (({let gensym___122643185 = initializers; + (((gensym___122643185) == (null)) ? undefined : gensym___122643185.__backing_linkVar10)})) { + this.__backing_linkVar10 = new LinkDecoratedVariable>("linkVar10", initializers!.__backing_linkVar10!); + }; + if (({let gensym___222468503 = initializers; + (((gensym___222468503) == (null)) ? undefined : gensym___222468503.__backing_linkVar11)})) { + this.__backing_linkVar11 = new LinkDecoratedVariable("linkVar11", initializers!.__backing_linkVar11!); + }; + if (({let gensym___243301539 = initializers; + (((gensym___243301539) == (null)) ? undefined : gensym___243301539.__backing_linkVar12)})) { + this.__backing_linkVar12 = new LinkDecoratedVariable | Per>("linkVar12", initializers!.__backing_linkVar12!); + }; + } + public __updateStruct(initializers: __Options_Parent | undefined): void {} + private __backing_linkVar1?: LinkDecoratedVariable; + public get linkVar1(): Per { + return this.__backing_linkVar1!.get(); + } + public set linkVar1(value: Per) { + this.__backing_linkVar1!.set(value); + } + private __backing_linkVar2?: LinkDecoratedVariable>; + public get linkVar2(): Array { + return this.__backing_linkVar2!.get(); + } + public set linkVar2(value: Array) { + this.__backing_linkVar2!.set(value); + } + private __backing_linkVar3?: LinkDecoratedVariable; + public get linkVar3(): LinkType { + return this.__backing_linkVar3!.get(); + } + public set linkVar3(value: LinkType) { + this.__backing_linkVar3!.set(value); + } + private __backing_linkVar4?: LinkDecoratedVariable>; + public get linkVar4(): Set { + return this.__backing_linkVar4!.get(); + } + public set linkVar4(value: Set) { + this.__backing_linkVar4!.set(value); + } + private __backing_linkVar5?: LinkDecoratedVariable>; + public get linkVar5(): Array { + return this.__backing_linkVar5!.get(); + } + public set linkVar5(value: Array) { + this.__backing_linkVar5!.set(value); + } + private __backing_linkVar6?: LinkDecoratedVariable>; + public get linkVar6(): Array { + return this.__backing_linkVar6!.get(); + } + public set linkVar6(value: Array) { + this.__backing_linkVar6!.set(value); + } + private __backing_linkVar7?: LinkDecoratedVariable>; + public get linkVar7(): Array { + return this.__backing_linkVar7!.get(); + } + public set linkVar7(value: Array) { + this.__backing_linkVar7!.set(value); + } + private __backing_linkVar8?: LinkDecoratedVariable<((sr: string)=> void)>; + public get linkVar8(): ((sr: string)=> void) { + return this.__backing_linkVar8!.get(); + } + public set linkVar8(value: ((sr: string)=> void)) { + this.__backing_linkVar8!.set(value); + } + private __backing_linkVar9?: LinkDecoratedVariable; + public get linkVar9(): Date { + return this.__backing_linkVar9!.get(); + } + public set linkVar9(value: Date) { + this.__backing_linkVar9!.set(value); + } + private __backing_linkVar10?: LinkDecoratedVariable>; + public get linkVar10(): Map { + return this.__backing_linkVar10!.get(); + } + public set linkVar10(value: Map) { + this.__backing_linkVar10!.set(value); + } + private __backing_linkVar11?: LinkDecoratedVariable; + public get linkVar11(): string | number { + return this.__backing_linkVar11!.get(); + } + public set linkVar11(value: string | number) { + this.__backing_linkVar11!.set(value); + } + private __backing_linkVar12?: LinkDecoratedVariable | Per>; + public get linkVar12(): Set | Per { + return this.__backing_linkVar12!.get(); + } + public set linkVar12(value: Set | Per) { + this.__backing_linkVar12!.set(value); + } + @memo() public _build(@memo() style: ((instance: Parent)=> Parent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Parent | undefined): void {} + public constructor() {} +} + +interface __Options_Parent { + set linkVar1(linkVar1: Per | undefined) + get linkVar1(): Per | undefined + set __backing_linkVar1(__backing_linkVar1: DecoratedV1VariableBase | undefined) + get __backing_linkVar1(): DecoratedV1VariableBase | undefined + set linkVar2(linkVar2: Array | undefined) + get linkVar2(): Array | undefined + set __backing_linkVar2(__backing_linkVar2: DecoratedV1VariableBase> | undefined) + get __backing_linkVar2(): DecoratedV1VariableBase> | undefined + set linkVar3(linkVar3: LinkType | undefined) + get linkVar3(): LinkType | undefined + set __backing_linkVar3(__backing_linkVar3: DecoratedV1VariableBase | undefined) + get __backing_linkVar3(): DecoratedV1VariableBase | undefined + set linkVar4(linkVar4: Set | undefined) + get linkVar4(): Set | undefined + set __backing_linkVar4(__backing_linkVar4: DecoratedV1VariableBase> | undefined) + get __backing_linkVar4(): DecoratedV1VariableBase> | undefined + set linkVar5(linkVar5: Array | undefined) + get linkVar5(): Array | undefined + set __backing_linkVar5(__backing_linkVar5: DecoratedV1VariableBase> | undefined) + get __backing_linkVar5(): DecoratedV1VariableBase> | undefined + set linkVar6(linkVar6: Array | undefined) + get linkVar6(): Array | undefined + set __backing_linkVar6(__backing_linkVar6: DecoratedV1VariableBase> | undefined) + get __backing_linkVar6(): DecoratedV1VariableBase> | undefined + set linkVar7(linkVar7: Array | undefined) + get linkVar7(): Array | undefined + set __backing_linkVar7(__backing_linkVar7: DecoratedV1VariableBase> | undefined) + get __backing_linkVar7(): DecoratedV1VariableBase> | undefined + set linkVar8(linkVar8: ((sr: string)=> void) | undefined) + get linkVar8(): ((sr: string)=> void) | undefined + set __backing_linkVar8(__backing_linkVar8: DecoratedV1VariableBase<((sr: string)=> void)> | undefined) + get __backing_linkVar8(): DecoratedV1VariableBase<((sr: string)=> void)> | undefined + set linkVar9(linkVar9: Date | undefined) + get linkVar9(): Date | undefined + set __backing_linkVar9(__backing_linkVar9: DecoratedV1VariableBase | undefined) + get __backing_linkVar9(): DecoratedV1VariableBase | undefined + set linkVar10(linkVar10: Map | undefined) + get linkVar10(): Map | undefined + set __backing_linkVar10(__backing_linkVar10: DecoratedV1VariableBase> | undefined) + get __backing_linkVar10(): DecoratedV1VariableBase> | undefined + set linkVar11(linkVar11: string | number | undefined) + get linkVar11(): string | number | undefined + set __backing_linkVar11(__backing_linkVar11: DecoratedV1VariableBase | undefined) + get __backing_linkVar11(): DecoratedV1VariableBase | undefined + set linkVar12(linkVar12: Set | Per | undefined) + get linkVar12(): Set | Per | undefined + set __backing_linkVar12(__backing_linkVar12: DecoratedV1VariableBase | Per> | undefined) + get __backing_linkVar12(): DecoratedV1VariableBase | Per> | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test complex type @Link decorated variables transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/link/link-to-link-prop-state.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/link/link-to-link-prop-state.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..01a8275f91b30ba6ba4f45a333f48b0424eae2d6 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/link/link-to-link-prop-state.test.ts @@ -0,0 +1,186 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/link'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'link-to-link-prop-state.ets'), +]; + +const pluginTester = new PluginTester('test @Link decorated variables passing to other variables', buildConfig); + +const parsedTransform: Plugins = { + name: 'link-to-link-prop-state', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { PropDecoratedVariable as PropDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { DecoratedV1VariableBase as DecoratedV1VariableBase } from "@ohos.arkui.stateManagement"; +import { LinkDecoratedVariable as LinkDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { UITextInputAttribute as UITextInputAttribute } from "@ohos.arkui.component"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, Column as Column, TextInput as TextInput } from "@ohos.arkui.component"; +import { Link as Link, State as State, Prop as Prop } from "@ohos.arkui.stateManagement"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class Parant extends CustomComponent { + public __initializeStruct(initializers: __Options_Parant | undefined, @memo() content: (()=> void) | undefined): void { + if (({let gensym___10127521 = initializers; + (((gensym___10127521) == (null)) ? undefined : gensym___10127521.__backing_text1)})) { + this.__backing_text1 = new LinkDecoratedVariable("text1", initializers!.__backing_text1!); + }; + } + public __updateStruct(initializers: __Options_Parant | undefined): void {} + private __backing_text1?: LinkDecoratedVariable; + public get text1(): string { + return this.__backing_text1!.get(); + } + public set text1(value: string) { + this.__backing_text1!.set(value); + } + @memo() public _build(@memo() style: ((instance: Parant)=> Parant) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Parant | undefined): void { + Column(undefined, undefined, (() => { + TextInput(undefined, { + text: this.text1, + }, undefined); + Child._instantiateImpl(undefined, (() => { + return new Child(); + }), ({ + __backing_childText: this.__backing_text1, + childText2: this.text1, + childText3: this.text1, + childText4: this.text1, + } as __Options_Child), undefined, undefined); + })); + } + public constructor() {} +} + +@Component({freezeWhenInactive:false}) final class Child extends CustomComponent { + public __initializeStruct(initializers: __Options_Child | undefined, @memo() content: (()=> void) | undefined): void { + if (({let gensym___161337494 = initializers; + (((gensym___161337494) == (null)) ? undefined : gensym___161337494.__backing_childText)})) { + this.__backing_childText = new LinkDecoratedVariable("childText", initializers!.__backing_childText!); + }; + this.__backing_childText2 = new StateDecoratedVariable("childText2", ((({let gensym___95513066 = initializers; + (((gensym___95513066) == (null)) ? undefined : gensym___95513066.childText2)})) ?? ("sss"))); + this.__backing_childText3 = new PropDecoratedVariable("childText3", (initializers!.childText3 as string)); + this.__backing_childText4 = new PropDecoratedVariable("childText4", ((({let gensym___162028107 = initializers; + (((gensym___162028107) == (null)) ? undefined : gensym___162028107.childText4)})) ?? ("cc"))); + } + public __updateStruct(initializers: __Options_Child | undefined): void { + if (((({let gensym___77632518 = initializers; + (((gensym___77632518) == (null)) ? undefined : gensym___77632518.childText3)})) !== (undefined))) { + this.__backing_childText3!.update((initializers!.childText3 as string)); + } + if (((({let gensym___250510741 = initializers; + (((gensym___250510741) == (null)) ? undefined : gensym___250510741.childText4)})) !== (undefined))) { + this.__backing_childText4!.update((initializers!.childText4 as string)); + } + } + private __backing_childText?: LinkDecoratedVariable; + public get childText(): string { + return this.__backing_childText!.get(); + } + public set childText(value: string) { + this.__backing_childText!.set(value); + } + private __backing_childText2?: StateDecoratedVariable; + public get childText2(): string { + return this.__backing_childText2!.get(); + } + public set childText2(value: string) { + this.__backing_childText2!.set(value); + } + private __backing_childText3?: PropDecoratedVariable; + public get childText3(): string { + return this.__backing_childText3!.get(); + } + public set childText3(value: string) { + this.__backing_childText3!.set(value); + } + private __backing_childText4?: PropDecoratedVariable; + public get childText4(): string { + return this.__backing_childText4!.get(); + } + public set childText4(value: string) { + this.__backing_childText4!.set(value); + } + @memo() public _build(@memo() style: ((instance: Child)=> Child) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Child | undefined): void { + TextInput(undefined, { + text: this.childText, + }, undefined); + } + public constructor() {} +} + +interface __Options_Parant { + set text1(text1: string | undefined) + get text1(): string | undefined + set __backing_text1(__backing_text1: DecoratedV1VariableBase | undefined) + get __backing_text1(): DecoratedV1VariableBase | undefined +} + +interface __Options_Child { + set childText(childText: string | undefined) + get childText(): string | undefined + set __backing_childText(__backing_childText: DecoratedV1VariableBase | undefined) + get __backing_childText(): DecoratedV1VariableBase | undefined + set childText2(childText2: string | undefined) + get childText2(): string | undefined + set __backing_childText2(__backing_childText2: StateDecoratedVariable | undefined) + get __backing_childText2(): StateDecoratedVariable | undefined + set childText3(childText3: string | undefined) + get childText3(): string | undefined + set __backing_childText3(__backing_childText3: PropDecoratedVariable | undefined) + get __backing_childText3(): PropDecoratedVariable | undefined + set childText4(childText4: string | undefined) + get childText4(): string | undefined + set __backing_childText4(__backing_childText4: PropDecoratedVariable | undefined) + get __backing_childText4(): PropDecoratedVariable | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test @Link decorated variables passing to other variables', + [parsedTransform, uiNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/link/state-to-link.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/link/state-to-link.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..cd9424e90a9b9d10cfb84261831bc31b0f48db4b --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/link/state-to-link.test.ts @@ -0,0 +1,175 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/link'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'state-to-link.ets'), +]; + +const pluginTester = new PluginTester('test @Link decorated variables passing', buildConfig); + +const parsedTransform: Plugins = { + name: 'state-to-link', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { DecoratedV1VariableBase as DecoratedV1VariableBase } from "@ohos.arkui.stateManagement"; +import { LinkDecoratedVariable as LinkDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { UIDatePickerAttribute as UIDatePickerAttribute } from "@ohos.arkui.component"; +import { UIButtonAttribute as UIButtonAttribute } from "@ohos.arkui.component"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { EntryPoint as EntryPoint } from "arkui.UserView"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, Entry as Entry, Column as Column, Button as Button, DatePicker as DatePicker, ClickEvent as ClickEvent } from "@ohos.arkui.component"; +import { Link as Link, State as State } from "@ohos.arkui.stateManagement"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class DateComponent extends CustomComponent { + public __initializeStruct(initializers: __Options_DateComponent | undefined, @memo() content: (()=> void) | undefined): void { + if (({let gensym___164314175 = initializers; + (((gensym___164314175) == (null)) ? undefined : gensym___164314175.__backing_selectedDate)})) { + this.__backing_selectedDate = new LinkDecoratedVariable("selectedDate", initializers!.__backing_selectedDate!); + }; + } + public __updateStruct(initializers: __Options_DateComponent | undefined): void {} + private __backing_selectedDate?: LinkDecoratedVariable; + public get selectedDate(): Date { + return this.__backing_selectedDate!.get(); + } + public set selectedDate(value: Date) { + this.__backing_selectedDate!.set(value); + } + @memo() public _build(@memo() style: ((instance: DateComponent)=> DateComponent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_DateComponent | undefined): void { + Column(undefined, undefined, (() => { + Button(@memo() ((instance: UIButtonAttribute): void => { + instance.onClick(((e: ClickEvent) => { + this.selectedDate.setFullYear(((this.selectedDate.getFullYear()) + (1))); + })); + return; + }), "child increase the year by 1", undefined, undefined); + Button(@memo() ((instance: UIButtonAttribute): void => { + instance.margin(10).onClick(((e: ClickEvent) => { + this.selectedDate = new Date("2023-09-09"); + })); + return; + }), "child update the new date", undefined, undefined); + DatePicker(undefined, { + start: new Date("1970-1-1"), + end: new Date("2100-1-1"), + selected: this.selectedDate, + }, undefined); + })); + } + public constructor() {} + +} + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class ParentComponent extends CustomComponent { + public __initializeStruct(initializers: __Options_ParentComponent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_parentSelectedDate = new StateDecoratedVariable("parentSelectedDate", ((({let gensym___80922148 = initializers; + (((gensym___80922148) == (null)) ? undefined : gensym___80922148.parentSelectedDate)})) ?? (new Date("2021-08-08")))); + } + public __updateStruct(initializers: __Options_ParentComponent | undefined): void {} + private __backing_parentSelectedDate?: StateDecoratedVariable; + public get parentSelectedDate(): Date { + return this.__backing_parentSelectedDate!.get(); + } + public set parentSelectedDate(value: Date) { + this.__backing_parentSelectedDate!.set(value); + } + @memo() public _build(@memo() style: ((instance: ParentComponent)=> ParentComponent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_ParentComponent | undefined): void { + Column(undefined, undefined, (() => { + Button(@memo() ((instance: UIButtonAttribute): void => { + instance.margin(10).onClick(((e: ClickEvent) => { + this.parentSelectedDate.setMonth(((this.parentSelectedDate.getMonth()) + (1))); + })); + return; + }), "parent increase the month by 1", undefined, undefined); + Button(@memo() ((instance: UIButtonAttribute): void => { + instance.margin(10).onClick(((e: ClickEvent) => { + this.parentSelectedDate = new Date("2023-07-07"); + })); + return; + }), "parent update the new date", undefined, undefined); + DatePicker(undefined, { + start: new Date("1970-1-1"), + end: new Date("2100-1-1"), + selected: this.parentSelectedDate, + }, undefined); + DateComponent._instantiateImpl(undefined, (() => { + return new DateComponent(); + }), ({ + __backing_selectedDate: this.__backing_parentSelectedDate, + } as __Options_DateComponent), undefined, undefined); + })); + } + public constructor() {} +} + +interface __Options_DateComponent { + set selectedDate(selectedDate: Date | undefined) + get selectedDate(): Date | undefined + set __backing_selectedDate(__backing_selectedDate: DecoratedV1VariableBase | undefined) + get __backing_selectedDate(): DecoratedV1VariableBase | undefined +} + +interface __Options_ParentComponent { + set parentSelectedDate(parentSelectedDate: Date | undefined) + get parentSelectedDate(): Date | undefined + set __backing_parentSelectedDate(__backing_parentSelectedDate: StateDecoratedVariable | undefined) + get __backing_parentSelectedDate(): StateDecoratedVariable | undefined +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + ParentComponent._instantiateImpl(undefined, (() => { + return new ParentComponent(); + }), undefined, undefined, undefined); + } + public constructor() {} +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test @Link decorated variables passing', + [parsedTransform, uiNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-only.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-only.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..08e0ec65b6f512f4a15e88aadad83489868eacf0 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-only.test.ts @@ -0,0 +1,157 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const OBSERVED_DIR_PATH: string = 'decorators/observed-track'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, OBSERVED_DIR_PATH, 'observed-only.ets'), +]; + +const observedTrackTransform: Plugins = { + name: 'observedTrack', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test observed only transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { SubscribedWatches as SubscribedWatches } from "@ohos.arkui.stateManagement"; + +import { WatchIdType as WatchIdType } from "@ohos.arkui.stateManagement"; + +import { int32 as int32 } from "@ohos.arkui.stateManagement"; + +import { IObservedObject as IObservedObject } from "@ohos.arkui.stateManagement"; + +import { setObservationDepth as setObservationDepth } from "@ohos.arkui.stateManagement"; + +import { BackingValue as BackingValue } from "@ohos.arkui.stateManagement"; + +import { MutableStateMeta as MutableStateMeta } from "@ohos.arkui.stateManagement"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component } from "@ohos.arkui.component"; + +import { Observed as Observed } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +@Observed() class A implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + private __meta: MutableStateMeta = new MutableStateMeta("@Observe properties (no @Track)"); + + private __backing_propA: number = 1; + + private __backing_trackA: number = 2; + + public constructor() {} + + public get propA(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_propA; + } + + public set propA(newValue: number) { + if (((this.__backing_propA) !== (newValue))) { + this.__backing_propA = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("propA"); + } + } + + public get trackA(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_trackA; + } + + public set trackA(newValue: number) { + if (((this.__backing_trackA) !== (newValue))) { + this.__backing_trackA = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("trackA"); + } + } + +} + +@Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + +`; + +function testObservedOnlyTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test observed only transform', + [observedTrackTransform, uiNoRecheck], + { + checked: [testObservedOnlyTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-track-class-property.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-track-class-property.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..5bd7f75517d71041264a000359ffd6c6319532c8 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-track-class-property.test.ts @@ -0,0 +1,206 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const OBSERVED_DIR_PATH: string = 'decorators/observed-track'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, OBSERVED_DIR_PATH, 'observed-track-class-property.ets'), +]; + +const observedTrackTransform: Plugins = { + name: 'observedTrack', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test observed track transform with class property', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { SubscribedWatches as SubscribedWatches } from "@ohos.arkui.stateManagement"; + +import { WatchIdType as WatchIdType } from "@ohos.arkui.stateManagement"; + +import { int32 as int32 } from "@ohos.arkui.stateManagement"; + +import { IObservedObject as IObservedObject } from "@ohos.arkui.stateManagement"; + +import { setObservationDepth as setObservationDepth } from "@ohos.arkui.stateManagement"; + +import { BackingValue as BackingValue } from "@ohos.arkui.stateManagement"; + +import { MutableStateMeta as MutableStateMeta } from "@ohos.arkui.stateManagement"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component } from "@ohos.arkui.component"; + +import { Observed as Observed, Track as Track } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +class Info { + public constructor() {} + +} + +class E implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + public propE: Info = new Info(); + + private __backing_trackE: BackingValue = new BackingValue(new Info()); + + private __meta_trackE: MutableStateMeta = new MutableStateMeta("@Track"); + + public constructor() {} + + public get trackE(): Info { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_trackE.addRef(); + } + setObservationDepth(this.__backing_trackE.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_trackE.value; + } + + public set trackE(newValue: Info) { + if (((this.__backing_trackE.value) !== (newValue))) { + this.__backing_trackE.value = newValue; + this.__meta_trackE.fireChange(); + this.executeOnSubscribingWatches("trackE"); + } + } + +} + +@Observed() class E1 implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + private __meta: MutableStateMeta = new MutableStateMeta("@Observe properties (no @Track)"); + + private __backing_propE1: BackingValue = new BackingValue(new Info()); + + private __backing_trackE1: BackingValue = new BackingValue(new Info()); + + public constructor() {} + + public get propE1(): Info { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_propE1.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_propE1.value; + } + + public set propE1(newValue: Info) { + if (((this.__backing_propE1.value) !== (newValue))) { + this.__backing_propE1.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("propE1"); + } + } + + public get trackE1(): Info { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_trackE1.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_trackE1.value; + } + + public set trackE1(newValue: Info) { + if (((this.__backing_trackE1.value) !== (newValue))) { + this.__backing_trackE1.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("trackE1"); + } + } + +} + +@Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} +`; + +function testObservedOnlyTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test observed track transform with class property', + [observedTrackTransform, uiNoRecheck], + { + checked: [testObservedOnlyTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-track-complex-type.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-track-complex-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..371c48a6cdcc181bc867a0a93f514b67615c6bc7 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-track-complex-type.test.ts @@ -0,0 +1,898 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const OBSERVED_DIR_PATH: string = 'decorators/observed-track'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, OBSERVED_DIR_PATH, 'observed-track-complex-type.ets'), +]; + +const observedTrackTransform: Plugins = { + name: 'observedTrack', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test observed track transform with complex type', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { SubscribedWatches as SubscribedWatches } from "@ohos.arkui.stateManagement"; + +import { WatchIdType as WatchIdType } from "@ohos.arkui.stateManagement"; + +import { int32 as int32 } from "@ohos.arkui.stateManagement"; + +import { IObservedObject as IObservedObject } from "@ohos.arkui.stateManagement"; + +import { setObservationDepth as setObservationDepth } from "@ohos.arkui.stateManagement"; + +import { BackingValue as BackingValue } from "@ohos.arkui.stateManagement"; + +import { MutableStateMeta as MutableStateMeta } from "@ohos.arkui.stateManagement"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry } from "@ohos.arkui.component"; + +import { Observed as Observed, Track as Track } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +class Person { + public constructor() {} + +} + +final class Status extends BaseEnum { + private readonly #ordinal: int; + + private static () {} + + public constructor(ordinal: int, value: int) { + super(value); + this.#ordinal = ordinal; + } + + public static readonly Success: Status = new Status(0, 200); + + public static readonly NotFound: Status = new Status(1, 404); + + public static readonly ServerError: Status = new Status(2, 500); + + private static readonly #NamesArray: String[] = ["Success", "NotFound", "ServerError"]; + + private static readonly #ValuesArray: int[] = [200, 404, 500]; + + private static readonly #StringValuesArray: String[] = ["200", "404", "500"]; + + private static readonly #ItemsArray: Status[] = [Status.Success, Status.NotFound, Status.ServerError]; + + public getName(): String { + return Status.#NamesArray[this.#ordinal]; + } + + public static getValueOf(name: String): Status { + for (let i = 0;((i) < (Status.#NamesArray.length));(++i)) { + if (((name) == (Status.#NamesArray[i]))) { + return Status.#ItemsArray[i]; + } + } + throw new Error((("No enum constant Status.") + (name))); + } + + public static fromValue(value: int): Status { + for (let i = 0;((i) < (Status.#ValuesArray.length));(++i)) { + if (((value) == (Status.#ValuesArray[i]))) { + return Status.#ItemsArray[i]; + } + } + throw new Error((("No enum Status with value ") + (value))); + } + + public valueOf(): int { + return Status.#ValuesArray[this.#ordinal]; + } + + public toString(): String { + return Status.#StringValuesArray[this.#ordinal]; + } + + public static values(): Status[] { + return Status.#ItemsArray; + } + + public getOrdinal(): int { + return this.#ordinal; + } + + public static $_get(e: Status): String { + return e.getName(); + } + +} + +@Observed() class mixed1 implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + private __backing_numA: number = 33; + + private __meta_numA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_stringA: string = "AA"; + + private __meta_stringA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_booleanA: boolean = true; + + private __meta_booleanA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_arrayA: BackingValue> = new BackingValue>([1, 2, 3]); + + private __meta_arrayA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_objectA: BackingValue = new BackingValue({}); + + private __meta_objectA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_dateA: BackingValue = new BackingValue(new Date("2021-08-08")); + + private __meta_dateA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_setA: BackingValue> = new BackingValue>(new Set()); + + private __meta_setA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_mapA: BackingValue> = new BackingValue>(new Map()); + + private __meta_mapA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_unionA: string | undefined = ""; + + private __meta_unionA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_classA: BackingValue = new BackingValue(new Person()); + + private __meta_classA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_enumA: BackingValue = new BackingValue(Status.NotFound); + + private __meta_enumA: MutableStateMeta = new MutableStateMeta("@Track"); + + public numB: number = 33; + + public stringB: string = "AA"; + + public booleanB: boolean = true; + + public arrayB: Array = [1, 2, 3]; + + public objectB: Object = {}; + + public dateB: Date = new Date("2021-08-08"); + + public setB: Set = new Set(); + + public mapB: Map = new Map(); + + public unionB: string | undefined = ""; + + public classB: Person = new Person(); + + public enumB: Status = Status.NotFound; + + public constructor() {} + + public get numA(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_numA.addRef(); + } + return this.__backing_numA; + } + + public set numA(newValue: number) { + if (((this.__backing_numA) !== (newValue))) { + this.__backing_numA = newValue; + this.__meta_numA.fireChange(); + this.executeOnSubscribingWatches("numA"); + } + } + + public get stringA(): string { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_stringA.addRef(); + } + return this.__backing_stringA; + } + + public set stringA(newValue: string) { + if (((this.__backing_stringA) !== (newValue))) { + this.__backing_stringA = newValue; + this.__meta_stringA.fireChange(); + this.executeOnSubscribingWatches("stringA"); + } + } + + public get booleanA(): boolean { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_booleanA.addRef(); + } + return this.__backing_booleanA; + } + + public set booleanA(newValue: boolean) { + if (((this.__backing_booleanA) !== (newValue))) { + this.__backing_booleanA = newValue; + this.__meta_booleanA.fireChange(); + this.executeOnSubscribingWatches("booleanA"); + } + } + + public get arrayA(): Array { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_arrayA.addRef(); + } + setObservationDepth(this.__backing_arrayA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_arrayA.value; + } + + public set arrayA(newValue: Array) { + if (((this.__backing_arrayA.value) !== (newValue))) { + this.__backing_arrayA.value = newValue; + this.__meta_arrayA.fireChange(); + this.executeOnSubscribingWatches("arrayA"); + } + } + + public get objectA(): Object { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_objectA.addRef(); + } + setObservationDepth(this.__backing_objectA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_objectA.value; + } + + public set objectA(newValue: Object) { + if (((this.__backing_objectA.value) !== (newValue))) { + this.__backing_objectA.value = newValue; + this.__meta_objectA.fireChange(); + this.executeOnSubscribingWatches("objectA"); + } + } + + public get dateA(): Date { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_dateA.addRef(); + } + setObservationDepth(this.__backing_dateA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_dateA.value; + } + + public set dateA(newValue: Date) { + if (((this.__backing_dateA.value) !== (newValue))) { + this.__backing_dateA.value = newValue; + this.__meta_dateA.fireChange(); + this.executeOnSubscribingWatches("dateA"); + } + } + + public get setA(): Set { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_setA.addRef(); + } + setObservationDepth(this.__backing_setA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_setA.value; + } + + public set setA(newValue: Set) { + if (((this.__backing_setA.value) !== (newValue))) { + this.__backing_setA.value = newValue; + this.__meta_setA.fireChange(); + this.executeOnSubscribingWatches("setA"); + } + } + + public get mapA(): Map { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_mapA.addRef(); + } + setObservationDepth(this.__backing_mapA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_mapA.value; + } + + public set mapA(newValue: Map) { + if (((this.__backing_mapA.value) !== (newValue))) { + this.__backing_mapA.value = newValue; + this.__meta_mapA.fireChange(); + this.executeOnSubscribingWatches("mapA"); + } + } + + public get unionA(): string | undefined { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_unionA.addRef(); + } + return this.__backing_unionA; + } + + public set unionA(newValue: string | undefined) { + if (((this.__backing_unionA) !== (newValue))) { + this.__backing_unionA = newValue; + this.__meta_unionA.fireChange(); + this.executeOnSubscribingWatches("unionA"); + } + } + + public get classA(): Person { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_classA.addRef(); + } + setObservationDepth(this.__backing_classA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_classA.value; + } + + public set classA(newValue: Person) { + if (((this.__backing_classA.value) !== (newValue))) { + this.__backing_classA.value = newValue; + this.__meta_classA.fireChange(); + this.executeOnSubscribingWatches("classA"); + } + } + + public get enumA(): Status { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_enumA.addRef(); + } + setObservationDepth(this.__backing_enumA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_enumA.value; + } + + public set enumA(newValue: Status) { + if (((this.__backing_enumA.value) !== (newValue))) { + this.__backing_enumA.value = newValue; + this.__meta_enumA.fireChange(); + this.executeOnSubscribingWatches("enumA"); + } + } + +} + +@Observed() class mixed2 implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + private __meta: MutableStateMeta = new MutableStateMeta("@Observe properties (no @Track)"); + + private __backing_numA: number = 33; + + private __backing_stringA: string = "AA"; + + private __backing_booleanA: boolean = true; + + private __backing_arrayA: BackingValue> = new BackingValue>([1, 2, 3]); + + private __backing_objectA: BackingValue = new BackingValue({}); + + private __backing_dateA: BackingValue = new BackingValue(new Date("2021-08-08")); + + private __backing_setA: BackingValue> = new BackingValue>(new Set()); + + private __backing_mapA: BackingValue> = new BackingValue>(new Map()); + + private __backing_unionA: string | undefined = ""; + + private __backing_classA: BackingValue = new BackingValue(new Person()); + + private __backing_enumA: BackingValue = new BackingValue(Status.NotFound); + + public constructor() {} + + public get numA(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_numA; + } + + public set numA(newValue: number) { + if (((this.__backing_numA) !== (newValue))) { + this.__backing_numA = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("numA"); + } + } + + public get stringA(): string { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_stringA; + } + + public set stringA(newValue: string) { + if (((this.__backing_stringA) !== (newValue))) { + this.__backing_stringA = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("stringA"); + } + } + + public get booleanA(): boolean { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_booleanA; + } + + public set booleanA(newValue: boolean) { + if (((this.__backing_booleanA) !== (newValue))) { + this.__backing_booleanA = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("booleanA"); + } + } + + public get arrayA(): Array { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_arrayA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_arrayA.value; + } + + public set arrayA(newValue: Array) { + if (((this.__backing_arrayA.value) !== (newValue))) { + this.__backing_arrayA.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("arrayA"); + } + } + + public get objectA(): Object { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_objectA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_objectA.value; + } + + public set objectA(newValue: Object) { + if (((this.__backing_objectA.value) !== (newValue))) { + this.__backing_objectA.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("objectA"); + } + } + + public get dateA(): Date { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_dateA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_dateA.value; + } + + public set dateA(newValue: Date) { + if (((this.__backing_dateA.value) !== (newValue))) { + this.__backing_dateA.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("dateA"); + } + } + + public get setA(): Set { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_setA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_setA.value; + } + + public set setA(newValue: Set) { + if (((this.__backing_setA.value) !== (newValue))) { + this.__backing_setA.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("setA"); + } + } + + public get mapA(): Map { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_mapA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_mapA.value; + } + + public set mapA(newValue: Map) { + if (((this.__backing_mapA.value) !== (newValue))) { + this.__backing_mapA.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("mapA"); + } + } + + public get unionA(): string | undefined { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_unionA; + } + + public set unionA(newValue: string | undefined) { + if (((this.__backing_unionA) !== (newValue))) { + this.__backing_unionA = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("unionA"); + } + } + + public get classA(): Person { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_classA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_classA.value; + } + + public set classA(newValue: Person) { + if (((this.__backing_classA.value) !== (newValue))) { + this.__backing_classA.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("classA"); + } + } + + public get enumA(): Status { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_enumA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_enumA.value; + } + + public set enumA(newValue: Status) { + if (((this.__backing_enumA.value) !== (newValue))) { + this.__backing_enumA.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("enumA"); + } + } + +} + +class mixed3 implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + private __backing_numA: number = 33; + + private __meta_numA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_stringA: string = "AA"; + + private __meta_stringA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_booleanA: boolean = true; + + private __meta_booleanA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_arrayA: BackingValue> = new BackingValue>([1, 2, 3]); + + private __meta_arrayA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_objectA: BackingValue = new BackingValue({}); + + private __meta_objectA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_dateA: BackingValue = new BackingValue(new Date("2021-08-08")); + + private __meta_dateA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_setA: BackingValue> = new BackingValue>(new Set()); + + private __meta_setA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_mapA: BackingValue> = new BackingValue>(new Map()); + + private __meta_mapA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_unionA: string | undefined = ""; + + private __meta_unionA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_classA: BackingValue = new BackingValue(new Person()); + + private __meta_classA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_enumA: BackingValue = new BackingValue(Status.NotFound); + + private __meta_enumA: MutableStateMeta = new MutableStateMeta("@Track"); + + public constructor() {} + + public get numA(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_numA.addRef(); + } + return this.__backing_numA; + } + + public set numA(newValue: number) { + if (((this.__backing_numA) !== (newValue))) { + this.__backing_numA = newValue; + this.__meta_numA.fireChange(); + this.executeOnSubscribingWatches("numA"); + } + } + + public get stringA(): string { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_stringA.addRef(); + } + return this.__backing_stringA; + } + + public set stringA(newValue: string) { + if (((this.__backing_stringA) !== (newValue))) { + this.__backing_stringA = newValue; + this.__meta_stringA.fireChange(); + this.executeOnSubscribingWatches("stringA"); + } + } + + public get booleanA(): boolean { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_booleanA.addRef(); + } + return this.__backing_booleanA; + } + + public set booleanA(newValue: boolean) { + if (((this.__backing_booleanA) !== (newValue))) { + this.__backing_booleanA = newValue; + this.__meta_booleanA.fireChange(); + this.executeOnSubscribingWatches("booleanA"); + } + } + + public get arrayA(): Array { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_arrayA.addRef(); + } + setObservationDepth(this.__backing_arrayA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_arrayA.value; + } + + public set arrayA(newValue: Array) { + if (((this.__backing_arrayA.value) !== (newValue))) { + this.__backing_arrayA.value = newValue; + this.__meta_arrayA.fireChange(); + this.executeOnSubscribingWatches("arrayA"); + } + } + + public get objectA(): Object { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_objectA.addRef(); + } + setObservationDepth(this.__backing_objectA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_objectA.value; + } + + public set objectA(newValue: Object) { + if (((this.__backing_objectA.value) !== (newValue))) { + this.__backing_objectA.value = newValue; + this.__meta_objectA.fireChange(); + this.executeOnSubscribingWatches("objectA"); + } + } + + public get dateA(): Date { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_dateA.addRef(); + } + setObservationDepth(this.__backing_dateA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_dateA.value; + } + + public set dateA(newValue: Date) { + if (((this.__backing_dateA.value) !== (newValue))) { + this.__backing_dateA.value = newValue; + this.__meta_dateA.fireChange(); + this.executeOnSubscribingWatches("dateA"); + } + } + + public get setA(): Set { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_setA.addRef(); + } + setObservationDepth(this.__backing_setA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_setA.value; + } + + public set setA(newValue: Set) { + if (((this.__backing_setA.value) !== (newValue))) { + this.__backing_setA.value = newValue; + this.__meta_setA.fireChange(); + this.executeOnSubscribingWatches("setA"); + } + } + + public get mapA(): Map { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_mapA.addRef(); + } + setObservationDepth(this.__backing_mapA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_mapA.value; + } + + public set mapA(newValue: Map) { + if (((this.__backing_mapA.value) !== (newValue))) { + this.__backing_mapA.value = newValue; + this.__meta_mapA.fireChange(); + this.executeOnSubscribingWatches("mapA"); + } + } + + public get unionA(): string | undefined { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_unionA.addRef(); + } + return this.__backing_unionA; + } + + public set unionA(newValue: string | undefined) { + if (((this.__backing_unionA) !== (newValue))) { + this.__backing_unionA = newValue; + this.__meta_unionA.fireChange(); + this.executeOnSubscribingWatches("unionA"); + } + } + + public get classA(): Person { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_classA.addRef(); + } + setObservationDepth(this.__backing_classA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_classA.value; + } + + public set classA(newValue: Person) { + if (((this.__backing_classA.value) !== (newValue))) { + this.__backing_classA.value = newValue; + this.__meta_classA.fireChange(); + this.executeOnSubscribingWatches("classA"); + } + } + + public get enumA(): Status { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_enumA.addRef(); + } + setObservationDepth(this.__backing_enumA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_enumA.value; + } + + public set enumA(newValue: Status) { + if (((this.__backing_enumA.value) !== (newValue))) { + this.__backing_enumA.value = newValue; + this.__meta_enumA.fireChange(); + this.executeOnSubscribingWatches("enumA"); + } + } + +} + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + MyStateSample._instantiateImpl(undefined, (() => { + return new MyStateSample(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} +`; + +function testObservedOnlyTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test observed track transform with complex type', + [observedTrackTransform, uiNoRecheck], + { + checked: [testObservedOnlyTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-track-extends.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-track-extends.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..f3f3a001e2c591788fd4d8553b3d78cdbcf1a73e --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-track-extends.test.ts @@ -0,0 +1,204 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const OBSERVED_DIR_PATH: string = 'decorators/observed-track'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, OBSERVED_DIR_PATH, 'observed-track-extends.ets'), +]; + +const observedTrackTransform: Plugins = { + name: 'observedTrack', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test observed track transform with extends', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { SubscribedWatches as SubscribedWatches } from "@ohos.arkui.stateManagement"; + +import { WatchIdType as WatchIdType } from "@ohos.arkui.stateManagement"; + +import { int32 as int32 } from "@ohos.arkui.stateManagement"; + +import { IObservedObject as IObservedObject } from "@ohos.arkui.stateManagement"; + +import { setObservationDepth as setObservationDepth } from "@ohos.arkui.stateManagement"; + +import { BackingValue as BackingValue } from "@ohos.arkui.stateManagement"; + +import { MutableStateMeta as MutableStateMeta } from "@ohos.arkui.stateManagement"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component } from "@ohos.arkui.component"; + +import { Observed as Observed, Track as Track } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +@Observed() class A implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + private __meta: MutableStateMeta = new MutableStateMeta("@Observe properties (no @Track)"); + + private __backing_propA: number = 1; + + private __backing_trackA: number = 2; + + public constructor() {} + + public get propA(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_propA; + } + + public set propA(newValue: number) { + if (((this.__backing_propA) !== (newValue))) { + this.__backing_propA = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("propA"); + } + } + + public get trackA(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_trackA; + } + + public set trackA(newValue: number) { + if (((this.__backing_trackA) !== (newValue))) { + this.__backing_trackA = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("trackA"); + } + } + +} + +class G extends A { + public propG: number = 1; + + public constructor() {} + +} + +@Observed() class H extends G implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + private __backing_propG: number = 1; + + private __meta_propG: MutableStateMeta = new MutableStateMeta("@Track"); + + public constructor() {} + + public get propG(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_propG.addRef(); + } + return this.__backing_propG; + } + + public set propG(newValue: number) { + if (((this.__backing_propG) !== (newValue))) { + this.__backing_propG = newValue; + this.__meta_propG.fireChange(); + this.executeOnSubscribingWatches("propG"); + } + } + +} + +@Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + +`; + +function testObservedOnlyTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test observed track transform with extends', + [observedTrackTransform, uiNoRecheck], + { + checked: [testObservedOnlyTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-track-implements.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-track-implements.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..f71a5e9220baae369451ae7da09f53299cf542b0 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-track-implements.test.ts @@ -0,0 +1,171 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const OBSERVED_DIR_PATH: string = 'decorators/observed-track'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, OBSERVED_DIR_PATH, 'observed-track-implements.ets'), +]; + +const observedTrackTransform: Plugins = { + name: 'observedTrack', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test observed track transform with implements', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { SubscribedWatches as SubscribedWatches } from "@ohos.arkui.stateManagement"; + +import { WatchIdType as WatchIdType } from "@ohos.arkui.stateManagement"; + +import { int32 as int32 } from "@ohos.arkui.stateManagement"; + +import { IObservedObject as IObservedObject } from "@ohos.arkui.stateManagement"; + +import { setObservationDepth as setObservationDepth } from "@ohos.arkui.stateManagement"; + +import { BackingValue as BackingValue } from "@ohos.arkui.stateManagement"; + +import { MutableStateMeta as MutableStateMeta } from "@ohos.arkui.stateManagement"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component } from "@ohos.arkui.component"; + +import { Observed as Observed } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +interface PropInterface { + set propF(propF: number) + + get propF(): number + +} + +interface trackInterface { + set trackF(trackF: number) + + get trackF(): number + +} + +@Observed() class F implements PropInterface, trackInterface, IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + private __meta: MutableStateMeta = new MutableStateMeta("@Observe properties (no @Track)"); + + private __backing_propF: number = 1; + + private __backing_trackF: number = 2; + + public constructor() {} + + public set propF(newValue: number) { + if (((this.__backing_propF) !== (newValue))) { + this.__backing_propF = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("propF"); + } + } + + public get propF(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_propF; + } + + public set trackF(newValue: number) { + if (((this.__backing_trackF) !== (newValue))) { + this.__backing_trackF = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("trackF"); + } + } + + public get trackF(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_trackF; + } + +} + +@Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + +`; + +function testObservedOnlyTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test observed track transform with implements', + [observedTrackTransform, uiNoRecheck], + { + checked: [testObservedOnlyTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-track.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-track.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..9f28609dcd64f3b519634444a4aefb6cda4ade5f --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/observed-track.test.ts @@ -0,0 +1,142 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const OBSERVED_DIR_PATH: string = 'decorators/observed-track'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, OBSERVED_DIR_PATH, 'observed-track.ets'), +]; + +const observedTrackTransform: Plugins = { + name: 'observedTrack', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test observed with track transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { SubscribedWatches as SubscribedWatches } from "@ohos.arkui.stateManagement"; + +import { WatchIdType as WatchIdType } from "@ohos.arkui.stateManagement"; + +import { int32 as int32 } from "@ohos.arkui.stateManagement"; + +import { IObservedObject as IObservedObject } from "@ohos.arkui.stateManagement"; + +import { setObservationDepth as setObservationDepth } from "@ohos.arkui.stateManagement"; + +import { BackingValue as BackingValue } from "@ohos.arkui.stateManagement"; + +import { MutableStateMeta as MutableStateMeta } from "@ohos.arkui.stateManagement"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component } from "@ohos.arkui.component"; + +import { Observed as Observed, Track as Track } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +@Observed() class B implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + public propB: number = 1; + + private __backing_trackB: number = 2; + + private __meta_trackB: MutableStateMeta = new MutableStateMeta("@Track"); + + public constructor() {} + + public get trackB(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_trackB.addRef(); + } + return this.__backing_trackB; + } + + public set trackB(newValue: number) { + if (((this.__backing_trackB) !== (newValue))) { + this.__backing_trackB = newValue; + this.__meta_trackB.fireChange(); + this.executeOnSubscribingWatches("trackB"); + } + } + +} + +@Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + +`; + +function testObservedOnlyTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test observed with track transform', + [observedTrackTransform, uiNoRecheck], + { + checked: [testObservedOnlyTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/track-only.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/track-only.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..a1e60b0fac2f4c912322eaa339453d70a5a0e624 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/observed-track/track-only.test.ts @@ -0,0 +1,142 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const OBSERVED_DIR_PATH: string = 'decorators/observed-track'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, OBSERVED_DIR_PATH, 'track-only.ets'), +]; + +const observedTrackTransform: Plugins = { + name: 'observedTrack', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test track only transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { SubscribedWatches as SubscribedWatches } from "@ohos.arkui.stateManagement"; + +import { WatchIdType as WatchIdType } from "@ohos.arkui.stateManagement"; + +import { int32 as int32 } from "@ohos.arkui.stateManagement"; + +import { IObservedObject as IObservedObject } from "@ohos.arkui.stateManagement"; + +import { setObservationDepth as setObservationDepth } from "@ohos.arkui.stateManagement"; + +import { BackingValue as BackingValue } from "@ohos.arkui.stateManagement"; + +import { MutableStateMeta as MutableStateMeta } from "@ohos.arkui.stateManagement"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component } from "@ohos.arkui.component"; + +import { Track as Track } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +class C implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + public propC: number = 1; + + private __backing_trackC: number = 2; + + private __meta_trackC: MutableStateMeta = new MutableStateMeta("@Track"); + + public constructor() {} + + public get trackC(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_trackC.addRef(); + } + return this.__backing_trackC; + } + + public set trackC(newValue: number) { + if (((this.__backing_trackC) !== (newValue))) { + this.__backing_trackC = newValue; + this.__meta_trackC.fireChange(); + this.executeOnSubscribingWatches("trackC"); + } + } + +} + +@Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + +`; + +function testObservedOnlyTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test track only transform', + [observedTrackTransform, uiNoRecheck], + { + checked: [testObservedOnlyTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/prop/prop-basic-type.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/prop/prop-basic-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..9ed1637237c1bb9de9903aebfa230cc77d88d070 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/prop/prop-basic-type.test.ts @@ -0,0 +1,161 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/prop'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'prop-basic-type.ets'), +]; + +const pluginTester = new PluginTester('test basic type @Prop decorated variables transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'prop-basic-type', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { PropDecoratedVariable as PropDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { Prop as Prop } from "@ohos.arkui.stateManagement"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class PropParent extends CustomComponent { + public __initializeStruct(initializers: __Options_PropParent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_propVar1 = new PropDecoratedVariable("propVar1", ((({let gensym___95172135 = initializers; + (((gensym___95172135) == (null)) ? undefined : gensym___95172135.propVar1)})) ?? ("propVar1"))); + this.__backing_propVar2 = new PropDecoratedVariable("propVar2", ((({let gensym___222490386 = initializers; + (((gensym___222490386) == (null)) ? undefined : gensym___222490386.propVar2)})) ?? (50))); + this.__backing_propVar3 = new PropDecoratedVariable("propVar3", ((({let gensym___201781257 = initializers; + (((gensym___201781257) == (null)) ? undefined : gensym___201781257.propVar3)})) ?? (true))); + this.__backing_propVar4 = new PropDecoratedVariable("propVar4", ((({let gensym___22028950 = initializers; + (((gensym___22028950) == (null)) ? undefined : gensym___22028950.propVar4)})) ?? (undefined))); + this.__backing_propVar5 = new PropDecoratedVariable("propVar5", ((({let gensym___54872258 = initializers; + (((gensym___54872258) == (null)) ? undefined : gensym___54872258.propVar5)})) ?? (null))); + } + public __updateStruct(initializers: __Options_PropParent | undefined): void { + if (((({let gensym___67969738 = initializers; + (((gensym___67969738) == (null)) ? undefined : gensym___67969738.propVar1)})) !== (undefined))) { + this.__backing_propVar1!.update((initializers!.propVar1 as string)); + } + if (((({let gensym___52350476 = initializers; + (((gensym___52350476) == (null)) ? undefined : gensym___52350476.propVar2)})) !== (undefined))) { + this.__backing_propVar2!.update((initializers!.propVar2 as number)); + } + if (((({let gensym___103864283 = initializers; + (((gensym___103864283) == (null)) ? undefined : gensym___103864283.propVar3)})) !== (undefined))) { + this.__backing_propVar3!.update((initializers!.propVar3 as boolean)); + } + if (((({let gensym___175155715 = initializers; + (((gensym___175155715) == (null)) ? undefined : gensym___175155715.propVar4)})) !== (undefined))) { + this.__backing_propVar4!.update((initializers!.propVar4 as undefined)); + } + if (((({let gensym___134530703 = initializers; + (((gensym___134530703) == (null)) ? undefined : gensym___134530703.propVar5)})) !== (undefined))) { + this.__backing_propVar5!.update((initializers!.propVar5 as null)); + } + } + private __backing_propVar1?: PropDecoratedVariable; + public get propVar1(): string { + return this.__backing_propVar1!.get(); + } + public set propVar1(value: string) { + this.__backing_propVar1!.set(value); + } + private __backing_propVar2?: PropDecoratedVariable; + public get propVar2(): number { + return this.__backing_propVar2!.get(); + } + public set propVar2(value: number) { + this.__backing_propVar2!.set(value); + } + private __backing_propVar3?: PropDecoratedVariable; + public get propVar3(): boolean { + return this.__backing_propVar3!.get(); + } + public set propVar3(value: boolean) { + this.__backing_propVar3!.set(value); + } + private __backing_propVar4?: PropDecoratedVariable; + public get propVar4(): undefined { + return this.__backing_propVar4!.get(); + } + public set propVar4(value: undefined) { + this.__backing_propVar4!.set(value); + } + private __backing_propVar5?: PropDecoratedVariable; + public get propVar5(): null { + return this.__backing_propVar5!.get(); + } + public set propVar5(value: null) { + this.__backing_propVar5!.set(value); + } + @memo() public _build(@memo() style: ((instance: PropParent)=> PropParent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_PropParent | undefined): void {} + public constructor() {} +} + +interface __Options_PropParent { + set propVar1(propVar1: string | undefined) + get propVar1(): string | undefined + set __backing_propVar1(__backing_propVar1: PropDecoratedVariable | undefined) + get __backing_propVar1(): PropDecoratedVariable | undefined + set propVar2(propVar2: number | undefined) + get propVar2(): number | undefined + set __backing_propVar2(__backing_propVar2: PropDecoratedVariable | undefined) + get __backing_propVar2(): PropDecoratedVariable | undefined + set propVar3(propVar3: boolean | undefined) + get propVar3(): boolean | undefined + set __backing_propVar3(__backing_propVar3: PropDecoratedVariable | undefined) + get __backing_propVar3(): PropDecoratedVariable | undefined + set propVar4(propVar4: undefined | undefined) + get propVar4(): undefined | undefined + set __backing_propVar4(__backing_propVar4: PropDecoratedVariable | undefined) + get __backing_propVar4(): PropDecoratedVariable | undefined + set propVar5(propVar5: null | undefined) + get propVar5(): null | undefined + set __backing_propVar5(__backing_propVar5: PropDecoratedVariable | undefined) + get __backing_propVar5(): PropDecoratedVariable | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test basic type @Prop decorated variables transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/prop/prop-complex-type.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/prop/prop-complex-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..7db4457811022389e20f8b2b1ab1b2d0067444d1 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/prop/prop-complex-type.test.ts @@ -0,0 +1,337 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/prop'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'prop-complex-type.ets'), +]; + +const pluginTester = new PluginTester('test complex type @Prop decorated variables transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'prop-complex-type', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { PropDecoratedVariable as PropDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { Prop as Prop } from "@ohos.arkui.stateManagement"; + +function main() {} + +class Per { + public num: number; + public constructor(num: number) { + this.num = num; + } +} + +final class PropType extends BaseEnum { + private readonly #ordinal: int; + private static () {} + public constructor(ordinal: int, value: int) { + super(value); + this.#ordinal = ordinal; + } + public static readonly TYPE1: PropType = new PropType(0, 0); + public static readonly TYPE2: PropType = new PropType(1, 1); + public static readonly TYPE3: PropType = new PropType(2, 3); + private static readonly #NamesArray: String[] = ["TYPE1", "TYPE2", "TYPE3"]; + private static readonly #ValuesArray: int[] = [0, 1, 3]; + private static readonly #StringValuesArray: String[] = ["0", "1", "3"]; + private static readonly #ItemsArray: PropType[] = [PropType.TYPE1, PropType.TYPE2, PropType.TYPE3]; + public getName(): String { + return PropType.#NamesArray[this.#ordinal]; + } + public static getValueOf(name: String): PropType { + for (let i = 0;((i) < (PropType.#NamesArray.length));(++i)) { + if (((name) == (PropType.#NamesArray[i]))) { + return PropType.#ItemsArray[i]; + } + } + throw new Error((("No enum constant PropType.") + (name))); + } + public static fromValue(value: int): PropType { + for (let i = 0;((i) < (PropType.#ValuesArray.length));(++i)) { + if (((value) == (PropType.#ValuesArray[i]))) { + return PropType.#ItemsArray[i]; + } + } + throw new Error((("No enum PropType with value ") + (value))); + } + public valueOf(): int { + return PropType.#ValuesArray[this.#ordinal]; + } + public toString(): String { + return PropType.#StringValuesArray[this.#ordinal]; + } + public static values(): PropType[] { + return PropType.#ItemsArray; + } + public getOrdinal(): int { + return this.#ordinal; + } + public static $_get(e: PropType): String { + return e.getName(); + } +} + +@Component({freezeWhenInactive:false}) final class Parent extends CustomComponent { + public __initializeStruct(initializers: __Options_Parent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_propVar1 = new PropDecoratedVariable("propVar1", ((({let gensym___95172135 = initializers; + (((gensym___95172135) == (null)) ? undefined : gensym___95172135.propVar1)})) ?? (new Per(6)))); + this.__backing_propVar2 = new PropDecoratedVariable>("propVar2", ((({let gensym___222490386 = initializers; + (((gensym___222490386) == (null)) ? undefined : gensym___222490386.propVar2)})) ?? (new Array(3, 6, 8)))); + this.__backing_propVar3 = new PropDecoratedVariable("propVar3", ((({let gensym___201781257 = initializers; + (((gensym___201781257) == (null)) ? undefined : gensym___201781257.propVar3)})) ?? (PropType.TYPE3))); + this.__backing_propVar4 = new PropDecoratedVariable>("propVar4", ((({let gensym___22028950 = initializers; + (((gensym___22028950) == (null)) ? undefined : gensym___22028950.propVar4)})) ?? (new Set(new Array("aa", "bb"))))); + this.__backing_propVar5 = new PropDecoratedVariable>("propVar5", ((({let gensym___54872258 = initializers; + (((gensym___54872258) == (null)) ? undefined : gensym___54872258.propVar5)})) ?? ([true, false]))); + this.__backing_propVar6 = new PropDecoratedVariable>("propVar6", ((({let gensym___128760941 = initializers; + (((gensym___128760941) == (null)) ? undefined : gensym___128760941.propVar6)})) ?? (new Array(new Per(7), new Per(11))))); + this.__backing_propVar7 = new PropDecoratedVariable>("propVar7", ((({let gensym___30534085 = initializers; + (((gensym___30534085) == (null)) ? undefined : gensym___30534085.propVar7)})) ?? ([new Per(7), new Per(11)]))); + this.__backing_propVar8 = new PropDecoratedVariable<((sr: string)=> void)>("propVar8", ((({let gensym___12471776 = initializers; + (((gensym___12471776) == (null)) ? undefined : gensym___12471776.propVar8)})) ?? (((sr: string) => {})))); + this.__backing_propVar9 = new PropDecoratedVariable("propVar9", ((({let gensym___123472108 = initializers; + (((gensym___123472108) == (null)) ? undefined : gensym___123472108.propVar9)})) ?? (new Date("2025-4-23")))); + this.__backing_propVar10 = new PropDecoratedVariable>("propVar10", ((({let gensym___147847012 = initializers; + (((gensym___147847012) == (null)) ? undefined : gensym___147847012.propVar10)})) ?? (new Map([[0, new Per(7)], [1, new Per(10)]])))); + this.__backing_propVar11 = new PropDecoratedVariable("propVar11", ((({let gensym___117026760 = initializers; + (((gensym___117026760) == (null)) ? undefined : gensym___117026760.propVar11)})) ?? (0.0))); + this.__backing_propVar12 = new PropDecoratedVariable | Per>("propVar12", ((({let gensym___220245132 = initializers; + (((gensym___220245132) == (null)) ? undefined : gensym___220245132.propVar12)})) ?? (new Per(6)))); + } + public __updateStruct(initializers: __Options_Parent | undefined): void { + if (((({let gensym___67969738 = initializers; + (((gensym___67969738) == (null)) ? undefined : gensym___67969738.propVar1)})) !== (undefined))) { + this.__backing_propVar1!.update((initializers!.propVar1 as Per)); + } + if (((({let gensym___52350476 = initializers; + (((gensym___52350476) == (null)) ? undefined : gensym___52350476.propVar2)})) !== (undefined))) { + this.__backing_propVar2!.update((initializers!.propVar2 as Array)); + } + if (((({let gensym___103864283 = initializers; + (((gensym___103864283) == (null)) ? undefined : gensym___103864283.propVar3)})) !== (undefined))) { + this.__backing_propVar3!.update((initializers!.propVar3 as PropType)); + } + if (((({let gensym___175155715 = initializers; + (((gensym___175155715) == (null)) ? undefined : gensym___175155715.propVar4)})) !== (undefined))) { + this.__backing_propVar4!.update((initializers!.propVar4 as Set)); + } + if (((({let gensym___134530703 = initializers; + (((gensym___134530703) == (null)) ? undefined : gensym___134530703.propVar5)})) !== (undefined))) { + this.__backing_propVar5!.update((initializers!.propVar5 as Array)); + } + if (((({let gensym___211600890 = initializers; + (((gensym___211600890) == (null)) ? undefined : gensym___211600890.propVar6)})) !== (undefined))) { + this.__backing_propVar6!.update((initializers!.propVar6 as Array)); + } + if (((({let gensym___124229427 = initializers; + (((gensym___124229427) == (null)) ? undefined : gensym___124229427.propVar7)})) !== (undefined))) { + this.__backing_propVar7!.update((initializers!.propVar7 as Array)); + } + if (((({let gensym___248056380 = initializers; + (((gensym___248056380) == (null)) ? undefined : gensym___248056380.propVar8)})) !== (undefined))) { + this.__backing_propVar8!.update((initializers!.propVar8 as ((sr: string)=> void))); + } + if (((({let gensym___55399278 = initializers; + (((gensym___55399278) == (null)) ? undefined : gensym___55399278.propVar9)})) !== (undefined))) { + this.__backing_propVar9!.update((initializers!.propVar9 as Date)); + } + if (((({let gensym___125042885 = initializers; + (((gensym___125042885) == (null)) ? undefined : gensym___125042885.propVar10)})) !== (undefined))) { + this.__backing_propVar10!.update((initializers!.propVar10 as Map)); + } + if (((({let gensym___2015283 = initializers; + (((gensym___2015283) == (null)) ? undefined : gensym___2015283.propVar11)})) !== (undefined))) { + this.__backing_propVar11!.update((initializers!.propVar11 as string | number)); + } + if (((({let gensym___39009414 = initializers; + (((gensym___39009414) == (null)) ? undefined : gensym___39009414.propVar12)})) !== (undefined))) { + this.__backing_propVar12!.update((initializers!.propVar12 as Set | Per)); + } + } + private __backing_propVar1?: PropDecoratedVariable; + public get propVar1(): Per { + return this.__backing_propVar1!.get(); + } + public set propVar1(value: Per) { + this.__backing_propVar1!.set(value); + } + private __backing_propVar2?: PropDecoratedVariable>; + public get propVar2(): Array { + return this.__backing_propVar2!.get(); + } + public set propVar2(value: Array) { + this.__backing_propVar2!.set(value); + } + private __backing_propVar3?: PropDecoratedVariable; + public get propVar3(): PropType { + return this.__backing_propVar3!.get(); + } + public set propVar3(value: PropType) { + this.__backing_propVar3!.set(value); + } + private __backing_propVar4?: PropDecoratedVariable>; + public get propVar4(): Set { + return this.__backing_propVar4!.get(); + } + public set propVar4(value: Set) { + this.__backing_propVar4!.set(value); + } + private __backing_propVar5?: PropDecoratedVariable>; + public get propVar5(): Array { + return this.__backing_propVar5!.get(); + } + public set propVar5(value: Array) { + this.__backing_propVar5!.set(value); + } + private __backing_propVar6?: PropDecoratedVariable>; + public get propVar6(): Array { + return this.__backing_propVar6!.get(); + } + public set propVar6(value: Array) { + this.__backing_propVar6!.set(value); + } + private __backing_propVar7?: PropDecoratedVariable>; + public get propVar7(): Array { + return this.__backing_propVar7!.get(); + } + public set propVar7(value: Array) { + this.__backing_propVar7!.set(value); + } + private __backing_propVar8?: PropDecoratedVariable<((sr: string)=> void)>; + public get propVar8(): ((sr: string)=> void) { + return this.__backing_propVar8!.get(); + } + public set propVar8(value: ((sr: string)=> void)) { + this.__backing_propVar8!.set(value); + } + private __backing_propVar9?: PropDecoratedVariable; + public get propVar9(): Date { + return this.__backing_propVar9!.get(); + } + public set propVar9(value: Date) { + this.__backing_propVar9!.set(value); + } + private __backing_propVar10?: PropDecoratedVariable>; + public get propVar10(): Map { + return this.__backing_propVar10!.get(); + } + public set propVar10(value: Map) { + this.__backing_propVar10!.set(value); + } + private __backing_propVar11?: PropDecoratedVariable; + public get propVar11(): string | number { + return this.__backing_propVar11!.get(); + } + public set propVar11(value: string | number) { + this.__backing_propVar11!.set(value); + } + private __backing_propVar12?: PropDecoratedVariable | Per>; + public get propVar12(): Set | Per { + return this.__backing_propVar12!.get(); + } + public set propVar12(value: Set | Per) { + this.__backing_propVar12!.set(value); + } + @memo() public _build(@memo() style: ((instance: Parent)=> Parent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Parent | undefined): void {} + public constructor() {} +} + +interface __Options_Parent { + set propVar1(propVar1: Per | undefined) + get propVar1(): Per | undefined + set __backing_propVar1(__backing_propVar1: PropDecoratedVariable | undefined) + get __backing_propVar1(): PropDecoratedVariable | undefined + set propVar2(propVar2: Array | undefined) + get propVar2(): Array | undefined + set __backing_propVar2(__backing_propVar2: PropDecoratedVariable> | undefined) + get __backing_propVar2(): PropDecoratedVariable> | undefined + set propVar3(propVar3: PropType | undefined) + get propVar3(): PropType | undefined + set __backing_propVar3(__backing_propVar3: PropDecoratedVariable | undefined) + get __backing_propVar3(): PropDecoratedVariable | undefined + set propVar4(propVar4: Set | undefined) + get propVar4(): Set | undefined + set __backing_propVar4(__backing_propVar4: PropDecoratedVariable> | undefined) + get __backing_propVar4(): PropDecoratedVariable> | undefined + set propVar5(propVar5: Array | undefined) + get propVar5(): Array | undefined + set __backing_propVar5(__backing_propVar5: PropDecoratedVariable> | undefined) + get __backing_propVar5(): PropDecoratedVariable> | undefined + set propVar6(propVar6: Array | undefined) + get propVar6(): Array | undefined + set __backing_propVar6(__backing_propVar6: PropDecoratedVariable> | undefined) + get __backing_propVar6(): PropDecoratedVariable> | undefined + set propVar7(propVar7: Array | undefined) + get propVar7(): Array | undefined + set __backing_propVar7(__backing_propVar7: PropDecoratedVariable> | undefined) + get __backing_propVar7(): PropDecoratedVariable> | undefined + set propVar8(propVar8: ((sr: string)=> void) | undefined) + get propVar8(): ((sr: string)=> void) | undefined + set __backing_propVar8(__backing_propVar8: PropDecoratedVariable<((sr: string)=> void)> | undefined) + get __backing_propVar8(): PropDecoratedVariable<((sr: string)=> void)> | undefined + set propVar9(propVar9: Date | undefined) + get propVar9(): Date | undefined + set __backing_propVar9(__backing_propVar9: PropDecoratedVariable | undefined) + get __backing_propVar9(): PropDecoratedVariable | undefined + set propVar10(propVar10: Map | undefined) + get propVar10(): Map | undefined + set __backing_propVar10(__backing_propVar10: PropDecoratedVariable> | undefined) + get __backing_propVar10(): PropDecoratedVariable> | undefined + set propVar11(propVar11: string | number | undefined) + get propVar11(): string | number | undefined + set __backing_propVar11(__backing_propVar11: PropDecoratedVariable | undefined) + get __backing_propVar11(): PropDecoratedVariable | undefined + set propVar12(propVar12: Set | Per | undefined) + get propVar12(): Set | Per | undefined + set __backing_propVar12(__backing_propVar12: PropDecoratedVariable | Per> | undefined) + get __backing_propVar12(): PropDecoratedVariable | Per> | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test complex type @Prop decorated variables transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/prop/state-to-prop.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/prop/state-to-prop.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..0809c2d4618d31b1122ddb9aa96913a92229c623 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/prop/state-to-prop.test.ts @@ -0,0 +1,169 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/prop'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'state-to-prop.ets'), +]; + +const pluginTester = new PluginTester('test @Prop decorated variables passing', buildConfig); + +const parsedTransform: Plugins = { + name: 'state-to-prop', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { PropDecoratedVariable as PropDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { UIButtonAttribute as UIButtonAttribute } from "@ohos.arkui.component"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, Text as Text, Button as Button, Column as Column, ClickEvent as ClickEvent } from "@ohos.arkui.component"; +import { Prop as Prop, State as State } from "@ohos.arkui.stateManagement"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class CountDownComponent extends CustomComponent { + public __initializeStruct(initializers: __Options_CountDownComponent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_count = new PropDecoratedVariable("count", ((({let gensym___58710805 = initializers; + (((gensym___58710805) == (null)) ? undefined : gensym___58710805.count)})) ?? (0))); + this.__backing_costOfOneAttempt = ((({let gensym___88948111 = initializers; + (((gensym___88948111) == (null)) ? undefined : gensym___88948111.costOfOneAttempt)})) ?? (1)); + } + public __updateStruct(initializers: __Options_CountDownComponent | undefined): void { + if (((({let gensym___188547633 = initializers; + (((gensym___188547633) == (null)) ? undefined : gensym___188547633.count)})) !== (undefined))) { + this.__backing_count!.update((initializers!.count as number)); + } + } + private __backing_count?: PropDecoratedVariable; + public get count(): number { + return this.__backing_count!.get(); + } + public set count(value: number) { + this.__backing_count!.set(value); + } + private __backing_costOfOneAttempt?: number; + public get costOfOneAttempt(): number { + return (this.__backing_costOfOneAttempt as number); + } + public set costOfOneAttempt(value: number) { + this.__backing_costOfOneAttempt = value; + } + + @memo() public _build(@memo() style: ((instance: CountDownComponent)=> CountDownComponent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_CountDownComponent | undefined): void { + Column(undefined, undefined, (() => { + if (((this.count) > (0))) { + Text(undefined, (((("You have") + (this.count))) + ("Nuggets left")), undefined, undefined); + } else { + Text(undefined, "Game over!", undefined, undefined); + } + Button(@memo() ((instance: UIButtonAttribute): void => { + instance.onClick(((e: ClickEvent) => { + this.count -= this.costOfOneAttempt; + })); + return; + }), "Try again", undefined, undefined); + })); + } + public constructor() {} +} + +@Component({freezeWhenInactive:false}) final class ParentComponent extends CustomComponent { + public __initializeStruct(initializers: __Options_ParentComponent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_countDownStartValue = new StateDecoratedVariable("countDownStartValue", ((({let gensym___249912438 = initializers; + (((gensym___249912438) == (null)) ? undefined : gensym___249912438.countDownStartValue)})) ?? (10))); + } + public __updateStruct(initializers: __Options_ParentComponent | undefined): void {} + private __backing_countDownStartValue?: StateDecoratedVariable; + public get countDownStartValue(): number { + return this.__backing_countDownStartValue!.get(); + } + public set countDownStartValue(value: number) { + this.__backing_countDownStartValue!.set(value); + } + @memo() public _build(@memo() style: ((instance: ParentComponent)=> ParentComponent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_ParentComponent | undefined): void { + Column(undefined, undefined, (() => { + Text(undefined, (((("Grant") + (this.countDownStartValue))) + ("nuggets to play.")), undefined, undefined); + Button(@memo() ((instance: UIButtonAttribute): void => { + instance.onClick(((e: ClickEvent) => { + this.countDownStartValue += 1; + })); + return; + }), "+1 - Nuggets in New Game", undefined, undefined); + Button(@memo() ((instance: UIButtonAttribute): void => { + instance.onClick(((e: ClickEvent) => { + this.countDownStartValue -= 1; + })); + return; + }), "-1 - Nuggets in New Game", undefined, undefined); + CountDownComponent._instantiateImpl(undefined, (() => { + return new CountDownComponent(); + }), ({ + count: this.countDownStartValue, + costOfOneAttempt: 2, + } as __Options_CountDownComponent), undefined, undefined); + })); + } + public constructor() {} +} + +interface __Options_CountDownComponent { + set count(count: number | undefined) + get count(): number | undefined + set __backing_count(__backing_count: PropDecoratedVariable | undefined) + get __backing_count(): PropDecoratedVariable | undefined + set costOfOneAttempt(costOfOneAttempt: number | undefined) + get costOfOneAttempt(): number | undefined +} + +interface __Options_ParentComponent { + set countDownStartValue(countDownStartValue: number | undefined) + get countDownStartValue(): number | undefined + set __backing_countDownStartValue(__backing_countDownStartValue: StateDecoratedVariable | undefined) + get __backing_countDownStartValue(): StateDecoratedVariable | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test @Prop decorated variables passing', + [parsedTransform, uiNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/provide-and-consume/provide-annotation-usage.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/provide-and-consume/provide-annotation-usage.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..9f57877626b1b3aa3a18de0419f718f1971bf41d --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/provide-and-consume/provide-annotation-usage.test.ts @@ -0,0 +1,179 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/provide-and-consume'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'provide-annotation-usage.ets'), +]; + +const pluginTester = new PluginTester('test different @Provide annotation usage transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'provide-annotation-usage', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { ProvideDecoratedVariable as ProvideDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { Provide as Provide } from "@ohos.arkui.stateManagement"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class Ancestors extends CustomComponent { + public __initializeStruct(initializers: __Options_Ancestors | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_count = this.addProvidedVar("count", "count", ((({let gensym___58710805 = initializers; + (((gensym___58710805) == (null)) ? undefined : gensym___58710805.count)})) ?? ("Child0")), false); + this.__backing_count1 = this.addProvidedVar("count1", "prov1", ((({let gensym___84874570 = initializers; + (((gensym___84874570) == (null)) ? undefined : gensym___84874570.count1)})) ?? ("Child1")), false); + this.__backing_count2 = this.addProvidedVar("count2", "prov2", ((({let gensym___124037738 = initializers; + (((gensym___124037738) == (null)) ? undefined : gensym___124037738.count2)})) ?? ("Child2")), false); + this.__backing_count3 = this.addProvidedVar("count3", "prov3", ((({let gensym___199202238 = initializers; + (((gensym___199202238) == (null)) ? undefined : gensym___199202238.count3)})) ?? ("Child3")), true); + this.__backing_count4 = this.addProvidedVar("count4", "count4", ((({let gensym___4359740 = initializers; + (((gensym___4359740) == (null)) ? undefined : gensym___4359740.count4)})) ?? ("Child4")), false); + this.__backing_count5 = this.addProvidedVar("count5", "count5", ((({let gensym___208755050 = initializers; + (((gensym___208755050) == (null)) ? undefined : gensym___208755050.count5)})) ?? ("Child5")), true); + this.__backing_count6 = this.addProvidedVar("count6", "", ((({let gensym___37571585 = initializers; + (((gensym___37571585) == (null)) ? undefined : gensym___37571585.count6)})) ?? ("Child6")), true); + this.__backing_count7 = this.addProvidedVar("count7", "", ((({let gensym___2162781 = initializers; + (((gensym___2162781) == (null)) ? undefined : gensym___2162781.count7)})) ?? ("Child7")), false); + } + public __updateStruct(initializers: __Options_Ancestors | undefined): void {} + private __backing_count?: ProvideDecoratedVariable; + public get count(): string | undefined { + return this.__backing_count!.get(); + } + public set count(value: string | undefined) { + this.__backing_count!.set(value); + } + private __backing_count1?: ProvideDecoratedVariable; + public get count1(): string | undefined { + return this.__backing_count1!.get(); + } + public set count1(value: string | undefined) { + this.__backing_count1!.set(value); + } + private __backing_count2?: ProvideDecoratedVariable; + public get count2(): string | undefined { + return this.__backing_count2!.get(); + } + public set count2(value: string | undefined) { + this.__backing_count2!.set(value); + } + private __backing_count3?: ProvideDecoratedVariable; + public get count3(): string | undefined { + return this.__backing_count3!.get(); + } + public set count3(value: string | undefined) { + this.__backing_count3!.set(value); + } + private __backing_count4?: ProvideDecoratedVariable; + public get count4(): string | undefined { + return this.__backing_count4!.get(); + } + public set count4(value: string | undefined) { + this.__backing_count4!.set(value); + } + private __backing_count5?: ProvideDecoratedVariable; + public get count5(): string | undefined { + return this.__backing_count5!.get(); + } + public set count5(value: string | undefined) { + this.__backing_count5!.set(value); + } + private __backing_count6?: ProvideDecoratedVariable; + public get count6(): string | undefined { + return this.__backing_count6!.get(); + } + public set count6(value: string | undefined) { + this.__backing_count6!.set(value); + } + private __backing_count7?: ProvideDecoratedVariable; + public get count7(): string | undefined { + return this.__backing_count7!.get(); + } + public set count7(value: string | undefined) { + this.__backing_count7!.set(value); + } + @memo() public _build(@memo() style: ((instance: Ancestors)=> Ancestors) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Ancestors | undefined): void {} + public constructor() {} +} + +interface __Options_Ancestors { + set count(count: string | undefined | undefined) + get count(): string | undefined | undefined + set __backing_count(__backing_count: ProvideDecoratedVariable | undefined) + get __backing_count(): ProvideDecoratedVariable | undefined + set count1(count1: string | undefined | undefined) + get count1(): string | undefined | undefined + set __backing_count1(__backing_count1: ProvideDecoratedVariable | undefined) + get __backing_count1(): ProvideDecoratedVariable | undefined + set count2(count2: string | undefined | undefined) + get count2(): string | undefined | undefined + set __backing_count2(__backing_count2: ProvideDecoratedVariable | undefined) + get __backing_count2(): ProvideDecoratedVariable | undefined + set count3(count3: string | undefined | undefined) + get count3(): string | undefined | undefined + set __backing_count3(__backing_count3: ProvideDecoratedVariable | undefined) + get __backing_count3(): ProvideDecoratedVariable | undefined + set count4(count4: string | undefined | undefined) + get count4(): string | undefined | undefined + set __backing_count4(__backing_count4: ProvideDecoratedVariable | undefined) + get __backing_count4(): ProvideDecoratedVariable | undefined + set count5(count5: string | undefined | undefined) + get count5(): string | undefined | undefined + set __backing_count5(__backing_count5: ProvideDecoratedVariable | undefined) + get __backing_count5(): ProvideDecoratedVariable | undefined + set count6(count6: string | undefined | undefined) + get count6(): string | undefined | undefined + set __backing_count6(__backing_count6: ProvideDecoratedVariable | undefined) + get __backing_count6(): ProvideDecoratedVariable | undefined + set count7(count7: string | undefined | undefined) + get count7(): string | undefined | undefined + set __backing_count7(__backing_count7: ProvideDecoratedVariable | undefined) + get __backing_count7(): ProvideDecoratedVariable | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test different @Provide annotation usage transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/provide-and-consume/provide-basic-type.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/provide-and-consume/provide-basic-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..dffbb429f3593481a71463a651ede773270191d5 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/provide-and-consume/provide-basic-type.test.ts @@ -0,0 +1,140 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/provide-and-consume'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'provide-basic-type.ets'), +]; + +const pluginTester = new PluginTester('test basic type @Provide decorated variables transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'provide-basic-type', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { ProvideDecoratedVariable as ProvideDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { Provide as Provide } from "@ohos.arkui.stateManagement"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class PropParent extends CustomComponent { + public __initializeStruct(initializers: __Options_PropParent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_provideVar1 = this.addProvidedVar("provideVar1", "provideVar1", ((({let gensym___181030638 = initializers; + (((gensym___181030638) == (null)) ? undefined : gensym___181030638.provideVar1)})) ?? ("propVar1")), false); + this.__backing_provideVar2 = this.addProvidedVar("provideVar2", "provideVar2", ((({let gensym___143944235 = initializers; + (((gensym___143944235) == (null)) ? undefined : gensym___143944235.provideVar2)})) ?? (50)), false); + this.__backing_provideVar3 = this.addProvidedVar("provideVar3", "provideVar3", ((({let gensym___262195977 = initializers; + (((gensym___262195977) == (null)) ? undefined : gensym___262195977.provideVar3)})) ?? (true)), false); + this.__backing_provideVar4 = this.addProvidedVar("provideVar4", "provideVar4", ((({let gensym___85711435 = initializers; + (((gensym___85711435) == (null)) ? undefined : gensym___85711435.provideVar4)})) ?? (undefined)), false); + this.__backing_provideVar5 = this.addProvidedVar("provideVar5", "provideVar5", ((({let gensym___139253630 = initializers; + (((gensym___139253630) == (null)) ? undefined : gensym___139253630.provideVar5)})) ?? (null)), false); + } + public __updateStruct(initializers: __Options_PropParent | undefined): void {} + private __backing_provideVar1?: ProvideDecoratedVariable; + public get provideVar1(): string { + return this.__backing_provideVar1!.get(); + } + public set provideVar1(value: string) { + this.__backing_provideVar1!.set(value); + } + private __backing_provideVar2?: ProvideDecoratedVariable; + public get provideVar2(): number { + return this.__backing_provideVar2!.get(); + } + public set provideVar2(value: number) { + this.__backing_provideVar2!.set(value); + } + private __backing_provideVar3?: ProvideDecoratedVariable; + public get provideVar3(): boolean { + return this.__backing_provideVar3!.get(); + } + public set provideVar3(value: boolean) { + this.__backing_provideVar3!.set(value); + } + private __backing_provideVar4?: ProvideDecoratedVariable; + public get provideVar4(): undefined { + return this.__backing_provideVar4!.get(); + } + public set provideVar4(value: undefined) { + this.__backing_provideVar4!.set(value); + } + private __backing_provideVar5?: ProvideDecoratedVariable; + public get provideVar5(): null { + return this.__backing_provideVar5!.get(); + } + public set provideVar5(value: null) { + this.__backing_provideVar5!.set(value); + } + @memo() public _build(@memo() style: ((instance: PropParent)=> PropParent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_PropParent | undefined): void {} + public constructor() {} +} + +interface __Options_PropParent { + set provideVar1(provideVar1: string | undefined) + get provideVar1(): string | undefined + set __backing_provideVar1(__backing_provideVar1: ProvideDecoratedVariable | undefined) + get __backing_provideVar1(): ProvideDecoratedVariable | undefined + set provideVar2(provideVar2: number | undefined) + get provideVar2(): number | undefined + set __backing_provideVar2(__backing_provideVar2: ProvideDecoratedVariable | undefined) + get __backing_provideVar2(): ProvideDecoratedVariable | undefined + set provideVar3(provideVar3: boolean | undefined) + get provideVar3(): boolean | undefined + set __backing_provideVar3(__backing_provideVar3: ProvideDecoratedVariable | undefined) + get __backing_provideVar3(): ProvideDecoratedVariable | undefined + set provideVar4(provideVar4: undefined | undefined) + get provideVar4(): undefined | undefined + set __backing_provideVar4(__backing_provideVar4: ProvideDecoratedVariable | undefined) + get __backing_provideVar4(): ProvideDecoratedVariable | undefined + set provideVar5(provideVar5: null | undefined) + get provideVar5(): null | undefined + set __backing_provideVar5(__backing_provideVar5: ProvideDecoratedVariable | undefined) + get __backing_provideVar5(): ProvideDecoratedVariable | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test basic type @Provide decorated variables transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/provide-and-consume/provide-complex-type.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/provide-and-consume/provide-complex-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..6684a83fe1e9ce59451fe32b83243e045150e5c3 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/provide-and-consume/provide-complex-type.test.ts @@ -0,0 +1,288 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/provide-and-consume'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'provide-complex-type.ets'), +]; + +const pluginTester = new PluginTester('test complex type @Provide decorated variables transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'provide-complex-type', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { ProvideDecoratedVariable as ProvideDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { Provide as Provide } from "@ohos.arkui.stateManagement"; + +function main() {} + +class Per { + public num: number; + public constructor(num: number) { + this.num = num; + } +} + +final class PropType extends BaseEnum { + private readonly #ordinal: int; + private static () {} + public constructor(ordinal: int, value: int) { + super(value); + this.#ordinal = ordinal; + } + public static readonly TYPE1: PropType = new PropType(0, 0); + public static readonly TYPE2: PropType = new PropType(1, 1); + public static readonly TYPE3: PropType = new PropType(2, 3); + private static readonly #NamesArray: String[] = ["TYPE1", "TYPE2", "TYPE3"]; + private static readonly #ValuesArray: int[] = [0, 1, 3]; + private static readonly #StringValuesArray: String[] = ["0", "1", "3"]; + private static readonly #ItemsArray: PropType[] = [PropType.TYPE1, PropType.TYPE2, PropType.TYPE3]; + public getName(): String { + return PropType.#NamesArray[this.#ordinal]; + } + public static getValueOf(name: String): PropType { + for (let i = 0;((i) < (PropType.#NamesArray.length));(++i)) { + if (((name) == (PropType.#NamesArray[i]))) { + return PropType.#ItemsArray[i]; + } + } + throw new Error((("No enum constant PropType.") + (name))); + } + public static fromValue(value: int): PropType { + for (let i = 0;((i) < (PropType.#ValuesArray.length));(++i)) { + if (((value) == (PropType.#ValuesArray[i]))) { + return PropType.#ItemsArray[i]; + } + } + throw new Error((("No enum PropType with value ") + (value))); + } + public valueOf(): int { + return PropType.#ValuesArray[this.#ordinal]; + } + public toString(): String { + return PropType.#StringValuesArray[this.#ordinal]; + } + public static values(): PropType[] { + return PropType.#ItemsArray; + } + public getOrdinal(): int { + return this.#ordinal; + } + public static $_get(e: PropType): String { + return e.getName(); + } +} + +@Component({freezeWhenInactive:false}) final class Parent extends CustomComponent { + public __initializeStruct(initializers: __Options_Parent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_provideVar1 = this.addProvidedVar("provideVar1", "provideVar1", ((({let gensym___181030638 = initializers; + (((gensym___181030638) == (null)) ? undefined : gensym___181030638.provideVar1)})) ?? (new Per(6))), false); + this.__backing_provideVar2 = this.addProvidedVar>("provideVar2", "provideVar2", ((({let gensym___143944235 = initializers; + (((gensym___143944235) == (null)) ? undefined : gensym___143944235.provideVar2)})) ?? (new Array(3, 6, 8))), false); + this.__backing_provideVar3 = this.addProvidedVar("provideVar3", "provideVar3", ((({let gensym___262195977 = initializers; + (((gensym___262195977) == (null)) ? undefined : gensym___262195977.provideVar3)})) ?? (PropType.TYPE3)), false); + this.__backing_provideVar4 = this.addProvidedVar>("provideVar4", "provideVar4", ((({let gensym___85711435 = initializers; + (((gensym___85711435) == (null)) ? undefined : gensym___85711435.provideVar4)})) ?? (new Set(new Array("aa", "bb")))), false); + this.__backing_provideVar5 = this.addProvidedVar>("provideVar5", "provideVar5", ((({let gensym___139253630 = initializers; + (((gensym___139253630) == (null)) ? undefined : gensym___139253630.provideVar5)})) ?? ([true, false])), false); + this.__backing_provideVar6 = this.addProvidedVar>("provideVar6", "provideVar6", ((({let gensym___146872112 = initializers; + (((gensym___146872112) == (null)) ? undefined : gensym___146872112.provideVar6)})) ?? (new Array(new Per(7), new Per(11)))), false); + this.__backing_provideVar7 = this.addProvidedVar>("provideVar7", "provideVar7", ((({let gensym___174412117 = initializers; + (((gensym___174412117) == (null)) ? undefined : gensym___174412117.provideVar7)})) ?? ([new Per(7), new Per(11)])), false); + this.__backing_provideVar8 = this.addProvidedVar<((sr: string)=> void)>("provideVar8", "provideVar8", ((({let gensym___253467853 = initializers; + (((gensym___253467853) == (null)) ? undefined : gensym___253467853.provideVar8)})) ?? (((sr: string) => {}))), false); + this.__backing_provideVar9 = this.addProvidedVar("provideVar9", "provideVar9", ((({let gensym___179115605 = initializers; + (((gensym___179115605) == (null)) ? undefined : gensym___179115605.provideVar9)})) ?? (new Date("2025-4-23"))), false); + this.__backing_provideVar10 = this.addProvidedVar>("provideVar10", "provideVar10", ((({let gensym___209671248 = initializers; + (((gensym___209671248) == (null)) ? undefined : gensym___209671248.provideVar10)})) ?? (new Map([[0, new Per(7)], [1, new Per(10)]]))), false); + this.__backing_provideVar11 = this.addProvidedVar("provideVar11", "provideVar11", ((({let gensym___150211849 = initializers; + (((gensym___150211849) == (null)) ? undefined : gensym___150211849.provideVar11)})) ?? (0.0)), false); + this.__backing_provideVar12 = this.addProvidedVar | Per>("provideVar12", "provideVar12", ((({let gensym___256025818 = initializers; + (((gensym___256025818) == (null)) ? undefined : gensym___256025818.provideVar12)})) ?? (new Per(6))), false); + } + public __updateStruct(initializers: __Options_Parent | undefined): void {} + private __backing_provideVar1?: ProvideDecoratedVariable; + public get provideVar1(): Per { + return this.__backing_provideVar1!.get(); + } + public set provideVar1(value: Per) { + this.__backing_provideVar1!.set(value); + } + private __backing_provideVar2?: ProvideDecoratedVariable>; + public get provideVar2(): Array { + return this.__backing_provideVar2!.get(); + } + public set provideVar2(value: Array) { + this.__backing_provideVar2!.set(value); + } + private __backing_provideVar3?: ProvideDecoratedVariable; + public get provideVar3(): PropType { + return this.__backing_provideVar3!.get(); + } + public set provideVar3(value: PropType) { + this.__backing_provideVar3!.set(value); + } + private __backing_provideVar4?: ProvideDecoratedVariable>; + public get provideVar4(): Set { + return this.__backing_provideVar4!.get(); + } + public set provideVar4(value: Set) { + this.__backing_provideVar4!.set(value); + } + private __backing_provideVar5?: ProvideDecoratedVariable>; + public get provideVar5(): Array { + return this.__backing_provideVar5!.get(); + } + public set provideVar5(value: Array) { + this.__backing_provideVar5!.set(value); + } + private __backing_provideVar6?: ProvideDecoratedVariable>; + public get provideVar6(): Array { + return this.__backing_provideVar6!.get(); + } + public set provideVar6(value: Array) { + this.__backing_provideVar6!.set(value); + } + private __backing_provideVar7?: ProvideDecoratedVariable>; + public get provideVar7(): Array { + return this.__backing_provideVar7!.get(); + } + public set provideVar7(value: Array) { + this.__backing_provideVar7!.set(value); + } + private __backing_provideVar8?: ProvideDecoratedVariable<((sr: string)=> void)>; + public get provideVar8(): ((sr: string)=> void) { + return this.__backing_provideVar8!.get(); + } + public set provideVar8(value: ((sr: string)=> void)) { + this.__backing_provideVar8!.set(value); + } + private __backing_provideVar9?: ProvideDecoratedVariable; + public get provideVar9(): Date { + return this.__backing_provideVar9!.get(); + } + public set provideVar9(value: Date) { + this.__backing_provideVar9!.set(value); + } + private __backing_provideVar10?: ProvideDecoratedVariable>; + public get provideVar10(): Map { + return this.__backing_provideVar10!.get(); + } + public set provideVar10(value: Map) { + this.__backing_provideVar10!.set(value); + } + private __backing_provideVar11?: ProvideDecoratedVariable; + public get provideVar11(): string | number { + return this.__backing_provideVar11!.get(); + } + public set provideVar11(value: string | number) { + this.__backing_provideVar11!.set(value); + } + private __backing_provideVar12?: ProvideDecoratedVariable | Per>; + public get provideVar12(): Set | Per { + return this.__backing_provideVar12!.get(); + } + public set provideVar12(value: Set | Per) { + this.__backing_provideVar12!.set(value); + } + @memo() public _build(@memo() style: ((instance: Parent)=> Parent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Parent | undefined): void {} + public constructor() {} +} + +interface __Options_Parent { + set provideVar1(provideVar1: Per | undefined) + get provideVar1(): Per | undefined + set __backing_provideVar1(__backing_provideVar1: ProvideDecoratedVariable | undefined) + get __backing_provideVar1(): ProvideDecoratedVariable | undefined + set provideVar2(provideVar2: Array | undefined) + get provideVar2(): Array | undefined + set __backing_provideVar2(__backing_provideVar2: ProvideDecoratedVariable> | undefined) + get __backing_provideVar2(): ProvideDecoratedVariable> | undefined + set provideVar3(provideVar3: PropType | undefined) + get provideVar3(): PropType | undefined + set __backing_provideVar3(__backing_provideVar3: ProvideDecoratedVariable | undefined) + get __backing_provideVar3(): ProvideDecoratedVariable | undefined + set provideVar4(provideVar4: Set | undefined) + get provideVar4(): Set | undefined + set __backing_provideVar4(__backing_provideVar4: ProvideDecoratedVariable> | undefined) + get __backing_provideVar4(): ProvideDecoratedVariable> | undefined + set provideVar5(provideVar5: Array | undefined) + get provideVar5(): Array | undefined + set __backing_provideVar5(__backing_provideVar5: ProvideDecoratedVariable> | undefined) + get __backing_provideVar5(): ProvideDecoratedVariable> | undefined + set provideVar6(provideVar6: Array | undefined) + get provideVar6(): Array | undefined + set __backing_provideVar6(__backing_provideVar6: ProvideDecoratedVariable> | undefined) + get __backing_provideVar6(): ProvideDecoratedVariable> | undefined + set provideVar7(provideVar7: Array | undefined) + get provideVar7(): Array | undefined + set __backing_provideVar7(__backing_provideVar7: ProvideDecoratedVariable> | undefined) + get __backing_provideVar7(): ProvideDecoratedVariable> | undefined + set provideVar8(provideVar8: ((sr: string)=> void) | undefined) + get provideVar8(): ((sr: string)=> void) | undefined + set __backing_provideVar8(__backing_provideVar8: ProvideDecoratedVariable<((sr: string)=> void)> | undefined) + get __backing_provideVar8(): ProvideDecoratedVariable<((sr: string)=> void)> | undefined + set provideVar9(provideVar9: Date | undefined) + get provideVar9(): Date | undefined + set __backing_provideVar9(__backing_provideVar9: ProvideDecoratedVariable | undefined) + get __backing_provideVar9(): ProvideDecoratedVariable | undefined + set provideVar10(provideVar10: Map | undefined) + get provideVar10(): Map | undefined + set __backing_provideVar10(__backing_provideVar10: ProvideDecoratedVariable> | undefined) + get __backing_provideVar10(): ProvideDecoratedVariable> | undefined + set provideVar11(provideVar11: string | number | undefined) + get provideVar11(): string | number | undefined + set __backing_provideVar11(__backing_provideVar11: ProvideDecoratedVariable | undefined) + get __backing_provideVar11(): ProvideDecoratedVariable | undefined + set provideVar12(provideVar12: Set | Per | undefined) + get provideVar12(): Set | Per | undefined + set __backing_provideVar12(__backing_provideVar12: ProvideDecoratedVariable | Per> | undefined) + get __backing_provideVar12(): ProvideDecoratedVariable | Per> | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test complex type @Provide decorated variables transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-build.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-build.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..ad9e6798bfc7ccefd79c5de649aa8965ae5e6969 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-build.test.ts @@ -0,0 +1,142 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/resource'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'resource-in-build.ets'), +]; + +const pluginTester = new PluginTester('test resource transform in build method', buildConfig); + +const parsedTransform: Plugins = { + name: 'resource-in-build', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { UIImageAnimatorAttribute as UIImageAnimatorAttribute } from "@ohos.arkui.component"; +import { UISelectAttribute as UISelectAttribute } from "@ohos.arkui.component"; +import { UITextInputAttribute as UITextInputAttribute } from "@ohos.arkui.component"; +import { UIImageAttribute as UIImageAttribute } from "@ohos.arkui.component"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { _rawfile as _rawfile } from "@ohos.arkui.component"; +import { _r as _r } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, $r as $r, $rawfile as $rawfile, Column as Column, Text as Text, Image as Image, TextInput as TextInput, Select as Select, SelectOption as SelectOption, Margin as Margin, ImageAnimator as ImageAnimator } from "@ohos.arkui.component"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class ResourceComponent extends CustomComponent { + public __initializeStruct(initializers: __Options_ResourceComponent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_str1 = ((({let gensym___147578113 = initializers; + (((gensym___147578113) == (null)) ? undefined : gensym___147578113.str1)})) ?? ("app.media.ri")); + this.__backing_str2 = ((({let gensym___220149772 = initializers; + (((gensym___220149772) == (null)) ? undefined : gensym___220149772.str2)})) ?? ("app.photo2.png")); + } + public __updateStruct(initializers: __Options_ResourceComponent | undefined): void {} + private __backing_str1?: string; + public get str1(): string { + return (this.__backing_str1 as string); + } + public set str1(value: string) { + this.__backing_str1 = value; + } + private __backing_str2?: string; + public get str2(): string { + return (this.__backing_str2 as string); + } + public set str2(value: string) { + this.__backing_str2 = value; + } + + @memo() public _build(@memo() style: ((instance: ResourceComponent)=> ResourceComponent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_ResourceComponent | undefined): void { + Column(undefined, undefined, (() => { + Text(undefined, _r("", "", "app.string.app_name"), undefined, undefined); + Image(undefined, _rawfile("", "", "app.photo.png"), undefined, undefined); + TextInput(undefined, { + text: _r("", "", "app.string.input_content"), + }, undefined); + Text(undefined, _r("", "", this.str1), undefined, undefined); + Text(undefined, _r("", "", this.str2), undefined, undefined); + Select(undefined, new Array({ + value: "aaa", + icon: _r("", "", "app.media.selection"), + }, { + value: "bbb", + icon: _r("", "", "app.media.selection"), + }, { + value: "ccc", + icon: _r("", "", "app.media.selection"), + }, { + value: "ddd", + icon: _r("", "", "app.media.selection"), + }), undefined); + Image(@memo() ((instance: UIImageAttribute): void => { + instance.margin(({ + top: _r("", "", "app.float.elements_margin_horizontal_m"), + bottom: _r("", "", "app.float.elements_margin_horizontal_l"), + } as Margin)); + return; + }), _r("", "", "app.media.app_icon"), undefined, undefined); + ImageAnimator(@memo() ((instance: UIImageAnimatorAttribute): void => { + instance.images([{ + src: _r("", "", "app.media.aaa"), + }, { + src: _r("", "", "app.media.bbb"), + }]); + return; + }), undefined); + })); + } + public constructor() {} +} + +interface __Options_ResourceComponent { + set str1(str1: string | undefined) + get str1(): string | undefined + set str2(str2: string | undefined) + get str2(): string | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test resource transform in build method', + [parsedTransform, uiNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-property.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-property.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..741751b9f990049cc0999c3afe3bfdbb0fb74d61 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/resource/resource-in-property.test.ts @@ -0,0 +1,108 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/resource'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'resource-in-property.ets'), +]; + +const pluginTester = new PluginTester('test resource transform in property', buildConfig); + +const parsedTransform: Plugins = { + name: 'resource-in-property', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { UIImageAttribute as UIImageAttribute } from "@ohos.arkui.component"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { _rawfile as _rawfile } from "@ohos.arkui.component"; +import { _r as _r } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, $r as $r, $rawfile as $rawfile, Column as Column, Text as Text, Image as Image, Resource as Resource } from "@ohos.arkui.component"; + +let i: Resource; +function main() {} +i = _r("", "", "app.string.app_name"); + +@Component({freezeWhenInactive:false}) final class ResourceComponent extends CustomComponent { + public __initializeStruct(initializers: __Options_ResourceComponent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_str = ((({let gensym___42103502 = initializers; + (((gensym___42103502) == (null)) ? undefined : gensym___42103502.str)})) ?? (_r("", "", "app.string.app_name"))); + this.__backing_icon = ((({let gensym___38135554 = initializers; + (((gensym___38135554) == (null)) ? undefined : gensym___38135554.icon)})) ?? (_rawfile("", "", "app.photo.png"))); + } + public __updateStruct(initializers: __Options_ResourceComponent | undefined): void {} + private __backing_str?: Resource; + public get str(): Resource { + return (this.__backing_str as Resource); + } + public set str(value: Resource) { + this.__backing_str = value; + } + private __backing_icon?: Resource; + public get icon(): Resource { + return (this.__backing_icon as Resource); + } + public set icon(value: Resource) { + this.__backing_icon = value; + } + @memo() public _build(@memo() style: ((instance: ResourceComponent)=> ResourceComponent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_ResourceComponent | undefined): void { + Column(undefined, undefined, (() => { + Text(undefined, this.str, undefined, undefined); + Text(undefined, i, undefined, undefined); + Image(undefined, this.icon, undefined, undefined); + })); + } + public constructor() {} +} + +interface __Options_ResourceComponent { + set str(str: Resource | undefined) + get str(): Resource | undefined + set icon(icon: Resource | undefined) + get icon(): Resource | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test resource transform in property', + [parsedTransform, uiNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/reusable/reusable-basic.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/reusable/reusable-basic.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..0589b25abf0770ba560c8f64696ec51e428e9836 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/reusable/reusable-basic.test.ts @@ -0,0 +1,159 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const REUSABLE_DIR_PATH: string = 'decorators/reusable'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, REUSABLE_DIR_PATH, 'reusable-basic.ets'), +]; + +const reusableTransform: Plugins = { + name: 'reusable', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test basic reusable', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { DecoratedV1VariableBase as DecoratedV1VariableBase } from "@ohos.arkui.stateManagement"; + +import { LinkDecoratedVariable as LinkDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Reusable as Reusable } from "@ohos.arkui.component"; + +import { State as State, Link as Link } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +@Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void { + Child._instantiateImpl(undefined, (() => { + return new Child(); + }), ({ + num: 5, + } as __Options_Child), undefined, "Child"); + } + + public constructor() {} + +} + +@Component({freezeWhenInactive:false}) @Reusable() final class Child extends CustomComponent { + public __initializeStruct(initializers: __Options_Child | undefined, @memo() content: (()=> void) | undefined): void { + if (({let gensym___98468840 = initializers; + (((gensym___98468840) == (null)) ? undefined : gensym___98468840.__backing_num)})) { + this.__backing_num = new LinkDecoratedVariable("num", initializers!.__backing_num!); + }; + this.__backing_num1 = new StateDecoratedVariable("num1", ((({let gensym___33833641 = initializers; + (((gensym___33833641) == (null)) ? undefined : gensym___33833641.num1)})) ?? (2))); + } + + public __updateStruct(initializers: __Options_Child | undefined): void {} + + public override __toRecord(params: Object): Record { + const paramsCasted = (params as __Options_Child); + return { + "num": ((paramsCasted.num) ?? (new Object())), + "num1": ((paramsCasted.num1) ?? (new Object())), + }; + } + + private __backing_num?: LinkDecoratedVariable; + + public get num(): number { + return this.__backing_num!.get(); + } + + public set num(value: number) { + this.__backing_num!.set(value); + } + + private __backing_num1?: StateDecoratedVariable; + + public get num1(): number { + return this.__backing_num1!.get(); + } + + public set num1(value: number) { + this.__backing_num1!.set(value); + } + + @memo() public _build(@memo() style: ((instance: Child)=> Child) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Child | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + +interface __Options_Child { + set num(num: number | undefined) + + get num(): number | undefined + set __backing_num(__backing_num: DecoratedV1VariableBase | undefined) + + get __backing_num(): DecoratedV1VariableBase | undefined + set num1(num1: number | undefined) + + get num1(): number | undefined + set __backing_num1(__backing_num1: StateDecoratedVariable | undefined) + + get __backing_num1(): StateDecoratedVariable | undefined + +} +`; + +function testReusableTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test basic reusable', + [reusableTransform, uiNoRecheck], + { + checked: [testReusableTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/reusable/reusable-complex.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/reusable/reusable-complex.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..873738ced9f080079d9a4a5cb4e461ebb57f6f94 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/reusable/reusable-complex.test.ts @@ -0,0 +1,209 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const REUSABLE_DIR_PATH: string = 'decorators/reusable'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, REUSABLE_DIR_PATH, 'reusable-complex.ets'), +]; + +const reusableTransform: Plugins = { + name: 'reusable', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test complex reusable', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { UIButtonAttribute as UIButtonAttribute } from "@ohos.arkui.component"; + +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; + +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry, Reusable as Reusable, Column as Column, Text as Text, Button as Button, ClickEvent as ClickEvent, FontWeight as FontWeight } from "@ohos.arkui.component"; + +import { State as State } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +class Message { + public value: string | undefined; + + public constructor(value: string) { + this.value = value; + } + +} + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class Index extends CustomComponent { + public __initializeStruct(initializers: __Options_Index | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_display = new StateDecoratedVariable("display", ((({let gensym___83835842 = initializers; + (((gensym___83835842) == (null)) ? undefined : gensym___83835842.display)})) ?? (true))); + } + + public __updateStruct(initializers: __Options_Index | undefined): void {} + + private __backing_display?: StateDecoratedVariable; + + public get display(): boolean { + return this.__backing_display!.get(); + } + + public set display(value: boolean) { + this.__backing_display!.set(value); + } + + @memo() public _build(@memo() style: ((instance: Index)=> Index) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Index | undefined): void { + Column(@memo() ((instance: UIColumnAttribute): void => { + instance.height("100%").width("100%"); + return; + }), undefined, (() => { + Button(@memo() ((instance: UIButtonAttribute): void => { + instance.fontSize(30).fontWeight(FontWeight.Bold).onClick(((e: ClickEvent) => { + this.display = !(this.display); + })); + return; + }), "Hello", undefined, undefined); + if (this.display) { + Child._instantiateImpl(undefined, (() => { + return new Child(); + }), ({ + message: new Message("Child"), + } as __Options_Child), undefined, "Child"); + } + })); + } + + public constructor() {} + +} + +@Reusable() @Component({freezeWhenInactive:false}) final class Child extends CustomComponent { + public __initializeStruct(initializers: __Options_Child | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_message = new StateDecoratedVariable("message", ((({let gensym___91869411 = initializers; + (((gensym___91869411) == (null)) ? undefined : gensym___91869411.message)})) ?? (new Message("AboutToReuse")))); + } + + public __updateStruct(initializers: __Options_Child | undefined): void {} + + public override __toRecord(params: Object): Record { + const paramsCasted = (params as __Options_Child); + return { + "message": ((paramsCasted.message) ?? (new Object())), + }; + } + + private __backing_message?: StateDecoratedVariable; + + public get message(): Message { + return this.__backing_message!.get(); + } + + public set message(value: Message) { + this.__backing_message!.set(value); + } + + public aboutToReuse(params: Record) { + console.info("Recycle ====Child=="); + } + + @memo() public _build(@memo() style: ((instance: Child)=> Child) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Child | undefined): void { + Column(@memo() ((instance: UIColumnAttribute): void => { + instance.borderWidth(1).height(100); + return; + }), undefined, (() => { + Text(@memo() ((instance: UITextAttribute): void => { + instance.fontSize(30); + return; + }), this.message.value, undefined, undefined); + })); + } + + public constructor() {} + +} + +interface __Options_Index { + set display(display: boolean | undefined) + + get display(): boolean | undefined + set __backing_display(__backing_display: StateDecoratedVariable | undefined) + + get __backing_display(): StateDecoratedVariable | undefined + +} + +interface __Options_Child { + set message(message: Message | undefined) + + get message(): Message | undefined + set __backing_message(__backing_message: StateDecoratedVariable | undefined) + + get __backing_message(): StateDecoratedVariable | undefined + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + Index._instantiateImpl(undefined, (() => { + return new Index(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} + +`; + +function testReusableTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test complex reusable', + [reusableTransform, uiNoRecheck], + { + checked: [testReusableTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/state/state-basic-type.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/state/state-basic-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..96d03ea4bf7ee85d2432a1a0864d36e4d7268084 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/state/state-basic-type.test.ts @@ -0,0 +1,140 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/state'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'state-basic-type.ets'), +]; + +const pluginTester = new PluginTester('test basic type @State decorated variables transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'state-basic-type', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { State as State } from "@ohos.arkui.stateManagement"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class Parent extends CustomComponent { + public __initializeStruct(initializers: __Options_Parent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_stateVar1 = new StateDecoratedVariable("stateVar1", ((({let gensym___213853607 = initializers; + (((gensym___213853607) == (null)) ? undefined : gensym___213853607.stateVar1)})) ?? ("stateVar1"))); + this.__backing_stateVar2 = new StateDecoratedVariable("stateVar2", ((({let gensym___113574154 = initializers; + (((gensym___113574154) == (null)) ? undefined : gensym___113574154.stateVar2)})) ?? (50))); + this.__backing_stateVar3 = new StateDecoratedVariable("stateVar3", ((({let gensym___166994972 = initializers; + (((gensym___166994972) == (null)) ? undefined : gensym___166994972.stateVar3)})) ?? (true))); + this.__backing_stateVar4 = new StateDecoratedVariable("stateVar4", ((({let gensym___148024261 = initializers; + (((gensym___148024261) == (null)) ? undefined : gensym___148024261.stateVar4)})) ?? (undefined))); + this.__backing_stateVar5 = new StateDecoratedVariable("stateVar5", ((({let gensym___99384342 = initializers; + (((gensym___99384342) == (null)) ? undefined : gensym___99384342.stateVar5)})) ?? (null))); + } + public __updateStruct(initializers: __Options_Parent | undefined): void {} + private __backing_stateVar1?: StateDecoratedVariable; + public get stateVar1(): string { + return this.__backing_stateVar1!.get(); + } + public set stateVar1(value: string) { + this.__backing_stateVar1!.set(value); + } + private __backing_stateVar2?: StateDecoratedVariable; + public get stateVar2(): number { + return this.__backing_stateVar2!.get(); + } + public set stateVar2(value: number) { + this.__backing_stateVar2!.set(value); + } + private __backing_stateVar3?: StateDecoratedVariable; + public get stateVar3(): boolean { + return this.__backing_stateVar3!.get(); + } + public set stateVar3(value: boolean) { + this.__backing_stateVar3!.set(value); + } + private __backing_stateVar4?: StateDecoratedVariable; + public get stateVar4(): undefined { + return this.__backing_stateVar4!.get(); + } + public set stateVar4(value: undefined) { + this.__backing_stateVar4!.set(value); + } + private __backing_stateVar5?: StateDecoratedVariable; + public get stateVar5(): null { + return this.__backing_stateVar5!.get(); + } + public set stateVar5(value: null) { + this.__backing_stateVar5!.set(value); + } + @memo() public _build(@memo() style: ((instance: Parent)=> Parent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Parent | undefined): void {} + public constructor() {} +} + +interface __Options_Parent { + set stateVar1(stateVar1: string | undefined) + get stateVar1(): string | undefined + set __backing_stateVar1(__backing_stateVar1: StateDecoratedVariable | undefined) + get __backing_stateVar1(): StateDecoratedVariable | undefined + set stateVar2(stateVar2: number | undefined) + get stateVar2(): number | undefined + set __backing_stateVar2(__backing_stateVar2: StateDecoratedVariable | undefined) + get __backing_stateVar2(): StateDecoratedVariable | undefined + set stateVar3(stateVar3: boolean | undefined) + get stateVar3(): boolean | undefined + set __backing_stateVar3(__backing_stateVar3: StateDecoratedVariable | undefined) + get __backing_stateVar3(): StateDecoratedVariable | undefined + set stateVar4(stateVar4: undefined | undefined) + get stateVar4(): undefined | undefined + set __backing_stateVar4(__backing_stateVar4: StateDecoratedVariable | undefined) + get __backing_stateVar4(): StateDecoratedVariable | undefined + set stateVar5(stateVar5: null | undefined) + get stateVar5(): null | undefined + set __backing_stateVar5(__backing_stateVar5: StateDecoratedVariable | undefined) + get __backing_stateVar5(): StateDecoratedVariable | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test basic type @State decorated variables transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/state/state-complex-type.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/state/state-complex-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..e42e3400622c079e69f6b69147b05dad2c0483d6 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/state/state-complex-type.test.ts @@ -0,0 +1,288 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/state'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'state-complex-type.ets'), +]; + +const pluginTester = new PluginTester('test complex type @State decorated variables transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'state-complex-type', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { State as State } from "@ohos.arkui.stateManagement"; + +function main() {} + +class Per { + public num: number; + public constructor(num: number) { + this.num = num; + } +} + +final class StateType extends BaseEnum { + private readonly #ordinal: int; + private static () {} + public constructor(ordinal: int, value: int) { + super(value); + this.#ordinal = ordinal; + } + public static readonly TYPE1: StateType = new StateType(0, 0); + public static readonly TYPE2: StateType = new StateType(1, 1); + public static readonly TYPE3: StateType = new StateType(2, 3); + private static readonly #NamesArray: String[] = ["TYPE1", "TYPE2", "TYPE3"]; + private static readonly #ValuesArray: int[] = [0, 1, 3]; + private static readonly #StringValuesArray: String[] = ["0", "1", "3"]; + private static readonly #ItemsArray: StateType[] = [StateType.TYPE1, StateType.TYPE2, StateType.TYPE3]; + public getName(): String { + return StateType.#NamesArray[this.#ordinal]; + } + public static getValueOf(name: String): StateType { + for (let i = 0;((i) < (StateType.#NamesArray.length));(++i)) { + if (((name) == (StateType.#NamesArray[i]))) { + return StateType.#ItemsArray[i]; + } + } + throw new Error((("No enum constant StateType.") + (name))); + } + public static fromValue(value: int): StateType { + for (let i = 0;((i) < (StateType.#ValuesArray.length));(++i)) { + if (((value) == (StateType.#ValuesArray[i]))) { + return StateType.#ItemsArray[i]; + } + } + throw new Error((("No enum StateType with value ") + (value))); + } + public valueOf(): int { + return StateType.#ValuesArray[this.#ordinal]; + } + public toString(): String { + return StateType.#StringValuesArray[this.#ordinal]; + } + public static values(): StateType[] { + return StateType.#ItemsArray; + } + public getOrdinal(): int { + return this.#ordinal; + } + public static $_get(e: StateType): String { + return e.getName(); + } +} + +@Component({freezeWhenInactive:false}) final class Parent extends CustomComponent { + public __initializeStruct(initializers: __Options_Parent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_stateVar1 = new StateDecoratedVariable("stateVar1", ((({let gensym___213853607 = initializers; + (((gensym___213853607) == (null)) ? undefined : gensym___213853607.stateVar1)})) ?? (new Per(6)))); + this.__backing_stateVar2 = new StateDecoratedVariable>("stateVar2", ((({let gensym___113574154 = initializers; + (((gensym___113574154) == (null)) ? undefined : gensym___113574154.stateVar2)})) ?? (new Array(3, 6, 8)))); + this.__backing_stateVar3 = new StateDecoratedVariable("stateVar3", ((({let gensym___166994972 = initializers; + (((gensym___166994972) == (null)) ? undefined : gensym___166994972.stateVar3)})) ?? (StateType.TYPE3))); + this.__backing_stateVar4 = new StateDecoratedVariable>("stateVar4", ((({let gensym___148024261 = initializers; + (((gensym___148024261) == (null)) ? undefined : gensym___148024261.stateVar4)})) ?? (new Set(new Array("aa", "bb"))))); + this.__backing_stateVar5 = new StateDecoratedVariable>("stateVar5", ((({let gensym___99384342 = initializers; + (((gensym___99384342) == (null)) ? undefined : gensym___99384342.stateVar5)})) ?? ([true, false]))); + this.__backing_stateVar6 = new StateDecoratedVariable>("stateVar6", ((({let gensym___133364871 = initializers; + (((gensym___133364871) == (null)) ? undefined : gensym___133364871.stateVar6)})) ?? (new Array(new Per(7), new Per(11))))); + this.__backing_stateVar7 = new StateDecoratedVariable>("stateVar7", ((({let gensym___69403028 = initializers; + (((gensym___69403028) == (null)) ? undefined : gensym___69403028.stateVar7)})) ?? ([new Per(7), new Per(11)]))); + this.__backing_stateVar8 = new StateDecoratedVariable<((sr: string)=> void)>("stateVar8", ((({let gensym___219403122 = initializers; + (((gensym___219403122) == (null)) ? undefined : gensym___219403122.stateVar8)})) ?? (((sr: string) => {})))); + this.__backing_stateVar9 = new StateDecoratedVariable("stateVar9", ((({let gensym___171171899 = initializers; + (((gensym___171171899) == (null)) ? undefined : gensym___171171899.stateVar9)})) ?? (new Date("2025-4-23")))); + this.__backing_stateVar10 = new StateDecoratedVariable>("stateVar10", ((({let gensym___91651348 = initializers; + (((gensym___91651348) == (null)) ? undefined : gensym___91651348.stateVar10)})) ?? (new Map([[0, new Per(7)], [1, new Per(10)]])))); + this.__backing_stateVar11 = new StateDecoratedVariable("stateVar11", ((({let gensym___56045278 = initializers; + (((gensym___56045278) == (null)) ? undefined : gensym___56045278.stateVar11)})) ?? (0.0))); + this.__backing_stateVar12 = new StateDecoratedVariable | Per>("stateVar12", ((({let gensym___164759887 = initializers; + (((gensym___164759887) == (null)) ? undefined : gensym___164759887.stateVar12)})) ?? (new Per(6)))); + } + public __updateStruct(initializers: __Options_Parent | undefined): void {} + private __backing_stateVar1?: StateDecoratedVariable; + public get stateVar1(): Per { + return this.__backing_stateVar1!.get(); + } + public set stateVar1(value: Per) { + this.__backing_stateVar1!.set(value); + } + private __backing_stateVar2?: StateDecoratedVariable>; + public get stateVar2(): Array { + return this.__backing_stateVar2!.get(); + } + public set stateVar2(value: Array) { + this.__backing_stateVar2!.set(value); + } + private __backing_stateVar3?: StateDecoratedVariable; + public get stateVar3(): StateType { + return this.__backing_stateVar3!.get(); + } + public set stateVar3(value: StateType) { + this.__backing_stateVar3!.set(value); + } + private __backing_stateVar4?: StateDecoratedVariable>; + public get stateVar4(): Set { + return this.__backing_stateVar4!.get(); + } + public set stateVar4(value: Set) { + this.__backing_stateVar4!.set(value); + } + private __backing_stateVar5?: StateDecoratedVariable>; + public get stateVar5(): Array { + return this.__backing_stateVar5!.get(); + } + public set stateVar5(value: Array) { + this.__backing_stateVar5!.set(value); + } + private __backing_stateVar6?: StateDecoratedVariable>; + public get stateVar6(): Array { + return this.__backing_stateVar6!.get(); + } + public set stateVar6(value: Array) { + this.__backing_stateVar6!.set(value); + } + private __backing_stateVar7?: StateDecoratedVariable>; + public get stateVar7(): Array { + return this.__backing_stateVar7!.get(); + } + public set stateVar7(value: Array) { + this.__backing_stateVar7!.set(value); + } + private __backing_stateVar8?: StateDecoratedVariable<((sr: string)=> void)>; + public get stateVar8(): ((sr: string)=> void) { + return this.__backing_stateVar8!.get(); + } + public set stateVar8(value: ((sr: string)=> void)) { + this.__backing_stateVar8!.set(value); + } + private __backing_stateVar9?: StateDecoratedVariable; + public get stateVar9(): Date { + return this.__backing_stateVar9!.get(); + } + public set stateVar9(value: Date) { + this.__backing_stateVar9!.set(value); + } + private __backing_stateVar10?: StateDecoratedVariable>; + public get stateVar10(): Map { + return this.__backing_stateVar10!.get(); + } + public set stateVar10(value: Map) { + this.__backing_stateVar10!.set(value); + } + private __backing_stateVar11?: StateDecoratedVariable; + public get stateVar11(): string | number { + return this.__backing_stateVar11!.get(); + } + public set stateVar11(value: string | number) { + this.__backing_stateVar11!.set(value); + } + private __backing_stateVar12?: StateDecoratedVariable | Per>; + public get stateVar12(): Set | Per { + return this.__backing_stateVar12!.get(); + } + public set stateVar12(value: Set | Per) { + this.__backing_stateVar12!.set(value); + } + @memo() public _build(@memo() style: ((instance: Parent)=> Parent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Parent | undefined): void {} + public constructor() {} +} + +interface __Options_Parent { + set stateVar1(stateVar1: Per | undefined) + get stateVar1(): Per | undefined + set __backing_stateVar1(__backing_stateVar1: StateDecoratedVariable | undefined) + get __backing_stateVar1(): StateDecoratedVariable | undefined + set stateVar2(stateVar2: Array | undefined) + get stateVar2(): Array | undefined + set __backing_stateVar2(__backing_stateVar2: StateDecoratedVariable> | undefined) + get __backing_stateVar2(): StateDecoratedVariable> | undefined + set stateVar3(stateVar3: StateType | undefined) + get stateVar3(): StateType | undefined + set __backing_stateVar3(__backing_stateVar3: StateDecoratedVariable | undefined) + get __backing_stateVar3(): StateDecoratedVariable | undefined + set stateVar4(stateVar4: Set | undefined) + get stateVar4(): Set | undefined + set __backing_stateVar4(__backing_stateVar4: StateDecoratedVariable> | undefined) + get __backing_stateVar4(): StateDecoratedVariable> | undefined + set stateVar5(stateVar5: Array | undefined) + get stateVar5(): Array | undefined + set __backing_stateVar5(__backing_stateVar5: StateDecoratedVariable> | undefined) + get __backing_stateVar5(): StateDecoratedVariable> | undefined + set stateVar6(stateVar6: Array | undefined) + get stateVar6(): Array | undefined + set __backing_stateVar6(__backing_stateVar6: StateDecoratedVariable> | undefined) + get __backing_stateVar6(): StateDecoratedVariable> | undefined + set stateVar7(stateVar7: Array | undefined) + get stateVar7(): Array | undefined + set __backing_stateVar7(__backing_stateVar7: StateDecoratedVariable> | undefined) + get __backing_stateVar7(): StateDecoratedVariable> | undefined + set stateVar8(stateVar8: ((sr: string)=> void) | undefined) + get stateVar8(): ((sr: string)=> void) | undefined + set __backing_stateVar8(__backing_stateVar8: StateDecoratedVariable<((sr: string)=> void)> | undefined) + get __backing_stateVar8(): StateDecoratedVariable<((sr: string)=> void)> | undefined + set stateVar9(stateVar9: Date | undefined) + get stateVar9(): Date | undefined + set __backing_stateVar9(__backing_stateVar9: StateDecoratedVariable | undefined) + get __backing_stateVar9(): StateDecoratedVariable | undefined + set stateVar10(stateVar10: Map | undefined) + get stateVar10(): Map | undefined + set __backing_stateVar10(__backing_stateVar10: StateDecoratedVariable> | undefined) + get __backing_stateVar10(): StateDecoratedVariable> | undefined + set stateVar11(stateVar11: string | number | undefined) + get stateVar11(): string | number | undefined + set __backing_stateVar11(__backing_stateVar11: StateDecoratedVariable | undefined) + get __backing_stateVar11(): StateDecoratedVariable | undefined + set stateVar12(stateVar12: Set | Per | undefined) + get stateVar12(): Set | Per | undefined + set __backing_stateVar12(__backing_stateVar12: StateDecoratedVariable | Per> | undefined) + get __backing_stateVar12(): StateDecoratedVariable | Per> | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test complex type @State decorated variables transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/state/state-to-state.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/state/state-to-state.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..52a438991ebe2faf37081d983e01c4e88afff32c --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/state/state-to-state.test.ts @@ -0,0 +1,132 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/state'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'state-to-state.ets'), +]; + +const pluginTester = new PluginTester('test @State decorated variables passing', buildConfig); + +const parsedTransform: Plugins = { + name: 'state-to-state', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, Column as Column, Text as Text } from "@ohos.arkui.component"; +import { State as State } from "@ohos.arkui.stateManagement"; + +function main() {} + +class Per { + public str: string; + public constructor(str: string) { + this.str = str; + } +} + +@Component({freezeWhenInactive:false}) final class Parent extends CustomComponent { + public __initializeStruct(initializers: __Options_Parent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_parentVar1 = new StateDecoratedVariable("parentVar1", ((({let gensym___247315634 = initializers; + (((gensym___247315634) == (null)) ? undefined : gensym___247315634.parentVar1)})) ?? (new Per("hello")))); + } + public __updateStruct(initializers: __Options_Parent | undefined): void {} + private __backing_parentVar1?: StateDecoratedVariable; + public get parentVar1(): Per { + return this.__backing_parentVar1!.get(); + } + public set parentVar1(value: Per) { + this.__backing_parentVar1!.set(value); + } + @memo() public _build(@memo() style: ((instance: Parent)=> Parent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Parent | undefined): void { + Column(undefined, undefined, (() => { + Child._instantiateImpl(undefined, (() => { + return new Child(); + }), ({ + childVar1: this.parentVar1, + } as __Options_Child), undefined, undefined); + })); + } + public constructor() {} +} + +@Component({freezeWhenInactive:false}) final class Child extends CustomComponent { + public __initializeStruct(initializers: __Options_Child | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_childVar1 = new StateDecoratedVariable("childVar1", ((({let gensym___218939886 = initializers; + (((gensym___218939886) == (null)) ? undefined : gensym___218939886.childVar1)})) ?? (new Per("ccc")))); + } + public __updateStruct(initializers: __Options_Child | undefined): void {} + private __backing_childVar1?: StateDecoratedVariable; + public get childVar1(): Per { + return this.__backing_childVar1!.get(); + } + public set childVar1(value: Per) { + this.__backing_childVar1!.set(value); + } + @memo() public _build(@memo() style: ((instance: Child)=> Child) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Child | undefined): void { + Text(undefined, this.childVar1.str, undefined, undefined); + } + public constructor() {} + +} + +interface __Options_Parent { + set parentVar1(parentVar1: Per | undefined) + get parentVar1(): Per | undefined + set __backing_parentVar1(__backing_parentVar1: StateDecoratedVariable | undefined) + get __backing_parentVar1(): StateDecoratedVariable | undefined +} + +interface __Options_Child { + set childVar1(childVar1: Per | undefined) + get childVar1(): Per | undefined + set __backing_childVar1(__backing_childVar1: StateDecoratedVariable | undefined) + get __backing_childVar1(): StateDecoratedVariable | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test @State decorated variables passing', + [parsedTransform, uiNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storagelink/storagelink-appstorage.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storagelink/storagelink-appstorage.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..7f4460286083061c950d56618195e60c28aeac00 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storagelink/storagelink-appstorage.test.ts @@ -0,0 +1,164 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const STORAGELINK_DIR_PATH: string = 'decorators/storagelink'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, STORAGELINK_DIR_PATH, 'storagelink-appstorage.ets'), +]; + +const storageLinkTransform: Plugins = { + name: 'storageLink', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test storagelink with appstorage', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { StorageLinkDecoratedVariable as StorageLinkDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; + +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry, Column as Column, Text as Text, ClickEvent as ClickEvent } from "@ohos.arkui.component"; + +import { StorageLink as StorageLink, AppStorage as AppStorage } from "@ohos.arkui.stateManagement"; + +function main() {} + +AppStorage.setOrCreate("PropA", 47); +AppStorage.setOrCreate("PropB", new Data(50)); + +class Data { + public code: number; + + public constructor(code: number) { + this.code = code; + } + +} + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class Index extends CustomComponent { + public __initializeStruct(initializers: __Options_Index | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_storageLink = new StorageLinkDecoratedVariable("PropA", "storageLink", 1) + this.__backing_storageLinkObject = new StorageLinkDecoratedVariable("PropB", "storageLinkObject", new Data(1)) + } + + public __updateStruct(initializers: __Options_Index | undefined): void {} + + private __backing_storageLink?: StorageLinkDecoratedVariable; + + public get storageLink(): number { + return this.__backing_storageLink!.get(); + } + + public set storageLink(value: number) { + this.__backing_storageLink!.set(value); + } + + private __backing_storageLinkObject?: StorageLinkDecoratedVariable; + + public get storageLinkObject(): Data { + return this.__backing_storageLinkObject!.get(); + } + + public set storageLinkObject(value: Data) { + this.__backing_storageLinkObject!.set(value); + } + + @memo() public _build(@memo() style: ((instance: Index)=> Index) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Index | undefined): void { + Column(undefined, undefined, (() => { + Text(@memo() ((instance: UITextAttribute): void => { + instance.onClick(((e: ClickEvent) => { + this.storageLink += 1; + })); + return; + }), \`From AppStorage \${this.storageLink}\`, undefined, undefined); + Text(@memo() ((instance: UITextAttribute): void => { + instance.onClick(((e: ClickEvent) => { + this.storageLinkObject.code += 1; + })); + return; + }), \`From AppStorage \${this.storageLinkObject.code}\`, undefined, undefined); + })); + } + + public constructor() {} + +} + +interface __Options_Index { + set storageLink(storageLink: number | undefined) + + get storageLink(): number | undefined + set __backing_storageLink(__backing_storageLink: StorageLinkDecoratedVariable | undefined) + + get __backing_storageLink(): StorageLinkDecoratedVariable | undefined + set storageLinkObject(storageLinkObject: Data | undefined) + + get storageLinkObject(): Data | undefined + set __backing_storageLinkObject(__backing_storageLinkObject: StorageLinkDecoratedVariable | undefined) + + get __backing_storageLinkObject(): StorageLinkDecoratedVariable | undefined + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + Index._instantiateImpl(undefined, (() => { + return new Index(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} +`; + +function testStorageLinkTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test storagelink with appstorage', + [storageLinkTransform, uiNoRecheck], + { + checked: [testStorageLinkTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storagelink/storagelink-complex-type.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storagelink/storagelink-complex-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..dba913594e47878ab3d517d21adb6da488833a00 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storagelink/storagelink-complex-type.test.ts @@ -0,0 +1,313 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const STORAGELINK_DIR_PATH: string = 'decorators/storagelink'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, STORAGELINK_DIR_PATH, 'storagelink-complex-type.ets'), +]; + +const storageLinkTransform: Plugins = { + name: 'storageLink', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test storagelink complex type transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { StorageLinkDecoratedVariable as StorageLinkDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry } from "@ohos.arkui.component"; + +import { StorageLink as StorageLink } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +class Person { + public name: string = ""; + + public constructor(name: string) {} + +} + +final class Status extends BaseEnum { + private readonly #ordinal: int; + + private static () {} + + public constructor(ordinal: int, value: int) { + super(value); + this.#ordinal = ordinal; + } + + public static readonly Success: Status = new Status(0, 200); + + public static readonly NotFound: Status = new Status(1, 404); + + public static readonly ServerError: Status = new Status(2, 500); + + private static readonly #NamesArray: String[] = ["Success", "NotFound", "ServerError"]; + + private static readonly #ValuesArray: int[] = [200, 404, 500]; + + private static readonly #StringValuesArray: String[] = ["200", "404", "500"]; + + private static readonly #ItemsArray: Status[] = [Status.Success, Status.NotFound, Status.ServerError]; + + public getName(): String { + return Status.#NamesArray[this.#ordinal]; + } + + public static getValueOf(name: String): Status { + for (let i = 0;((i) < (Status.#NamesArray.length));(++i)) { + if (((name) == (Status.#NamesArray[i]))) { + return Status.#ItemsArray[i]; + } + } + throw new Error((("No enum constant Status.") + (name))); + } + + public static fromValue(value: int): Status { + for (let i = 0;((i) < (Status.#ValuesArray.length));(++i)) { + if (((value) == (Status.#ValuesArray[i]))) { + return Status.#ItemsArray[i]; + } + } + throw new Error((("No enum Status with value ") + (value))); + } + + public valueOf(): int { + return Status.#ValuesArray[this.#ordinal]; + } + + public toString(): String { + return Status.#StringValuesArray[this.#ordinal]; + } + + public static values(): Status[] { + return Status.#ItemsArray; + } + + public getOrdinal(): int { + return this.#ordinal; + } + + public static $_get(e: Status): String { + return e.getName(); + } + +} + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_arrayA = new StorageLinkDecoratedVariable>("Prop1", "arrayA", [1, 2, 3]) + this.__backing_objectA = new StorageLinkDecoratedVariable("Prop2", "objectA", {}) + this.__backing_dateA = new StorageLinkDecoratedVariable("Prop3", "dateA", new Date("2021-08-08")) + this.__backing_setA = new StorageLinkDecoratedVariable>("Prop4", "setA", new Set()) + this.__backing_mapA = new StorageLinkDecoratedVariable>("Prop5", "mapA", new Map()) + this.__backing_unionA = new StorageLinkDecoratedVariable("Prop6", "unionA", "") + this.__backing_classA = new StorageLinkDecoratedVariable("Prop7", "classA", new Person("John")) + this.__backing_enumA = new StorageLinkDecoratedVariable("Prop8", "enumA", Status.NotFound) + } + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + private __backing_arrayA?: StorageLinkDecoratedVariable>; + + public get arrayA(): Array { + return this.__backing_arrayA!.get(); + } + + public set arrayA(value: Array) { + this.__backing_arrayA!.set(value); + } + + private __backing_objectA?: StorageLinkDecoratedVariable; + + public get objectA(): Object { + return this.__backing_objectA!.get(); + } + + public set objectA(value: Object) { + this.__backing_objectA!.set(value); + } + + private __backing_dateA?: StorageLinkDecoratedVariable; + + public get dateA(): Date { + return this.__backing_dateA!.get(); + } + + public set dateA(value: Date) { + this.__backing_dateA!.set(value); + } + + private __backing_setA?: StorageLinkDecoratedVariable>; + + public get setA(): Set { + return this.__backing_setA!.get(); + } + + public set setA(value: Set) { + this.__backing_setA!.set(value); + } + + private __backing_mapA?: StorageLinkDecoratedVariable>; + + public get mapA(): Map { + return this.__backing_mapA!.get(); + } + + public set mapA(value: Map) { + this.__backing_mapA!.set(value); + } + + private __backing_unionA?: StorageLinkDecoratedVariable; + + public get unionA(): string | undefined { + return this.__backing_unionA!.get(); + } + + public set unionA(value: string | undefined) { + this.__backing_unionA!.set(value); + } + + private __backing_classA?: StorageLinkDecoratedVariable; + + public get classA(): Person { + return this.__backing_classA!.get(); + } + + public set classA(value: Person) { + this.__backing_classA!.set(value); + } + + private __backing_enumA?: StorageLinkDecoratedVariable; + + public get enumA(): Status { + return this.__backing_enumA!.get(); + } + + public set enumA(value: Status) { + this.__backing_enumA!.set(value); + } + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + set arrayA(arrayA: Array | undefined) + + get arrayA(): Array | undefined + set __backing_arrayA(__backing_arrayA: StorageLinkDecoratedVariable> | undefined) + + get __backing_arrayA(): StorageLinkDecoratedVariable> | undefined + set objectA(objectA: Object | undefined) + + get objectA(): Object | undefined + set __backing_objectA(__backing_objectA: StorageLinkDecoratedVariable | undefined) + + get __backing_objectA(): StorageLinkDecoratedVariable | undefined + set dateA(dateA: Date | undefined) + + get dateA(): Date | undefined + set __backing_dateA(__backing_dateA: StorageLinkDecoratedVariable | undefined) + + get __backing_dateA(): StorageLinkDecoratedVariable | undefined + set setA(setA: Set | undefined) + + get setA(): Set | undefined + set __backing_setA(__backing_setA: StorageLinkDecoratedVariable> | undefined) + + get __backing_setA(): StorageLinkDecoratedVariable> | undefined + set mapA(mapA: Map | undefined) + + get mapA(): Map | undefined + set __backing_mapA(__backing_mapA: StorageLinkDecoratedVariable> | undefined) + + get __backing_mapA(): StorageLinkDecoratedVariable> | undefined + set unionA(unionA: string | undefined | undefined) + + get unionA(): string | undefined | undefined + set __backing_unionA(__backing_unionA: StorageLinkDecoratedVariable | undefined) + + get __backing_unionA(): StorageLinkDecoratedVariable | undefined + set classA(classA: Person | undefined) + + get classA(): Person | undefined + set __backing_classA(__backing_classA: StorageLinkDecoratedVariable | undefined) + + get __backing_classA(): StorageLinkDecoratedVariable | undefined + set enumA(enumA: Status | undefined) + + get enumA(): Status | undefined + set __backing_enumA(__backing_enumA: StorageLinkDecoratedVariable | undefined) + + get __backing_enumA(): StorageLinkDecoratedVariable | undefined + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + MyStateSample._instantiateImpl(undefined, (() => { + return new MyStateSample(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} + +`; + +function testStorageLinkTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test storagelink complex type transform', + [storageLinkTransform, uiNoRecheck], + { + checked: [testStorageLinkTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storagelink/storagelink-primitive-type.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storagelink/storagelink-primitive-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..27a78307e6794b6a40d9087fb97ee33800cee8c1 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storagelink/storagelink-primitive-type.test.ts @@ -0,0 +1,153 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const STORAGELINK_DIR_PATH: string = 'decorators/storagelink'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, STORAGELINK_DIR_PATH, 'storagelink-primitive-type.ets'), +]; + +const storageLinkTransform: Plugins = { + name: 'storageLink', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test storagelink primitive type transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { StorageLinkDecoratedVariable as StorageLinkDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry } from "@ohos.arkui.component"; + +import { StorageLink as StorageLink } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_numA = new StorageLinkDecoratedVariable("Prop1", "numA", 33) + this.__backing_stringA = new StorageLinkDecoratedVariable("Prop2", "stringA", "AA") + this.__backing_booleanA = new StorageLinkDecoratedVariable("Prop3", "booleanA", true) + } + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + private __backing_numA?: StorageLinkDecoratedVariable; + + public get numA(): number { + return this.__backing_numA!.get(); + } + + public set numA(value: number) { + this.__backing_numA!.set(value); + } + + private __backing_stringA?: StorageLinkDecoratedVariable; + + public get stringA(): string { + return this.__backing_stringA!.get(); + } + + public set stringA(value: string) { + this.__backing_stringA!.set(value); + } + + private __backing_booleanA?: StorageLinkDecoratedVariable; + + public get booleanA(): boolean { + return this.__backing_booleanA!.get(); + } + + public set booleanA(value: boolean) { + this.__backing_booleanA!.set(value); + } + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + set numA(numA: number | undefined) + + get numA(): number | undefined + set __backing_numA(__backing_numA: StorageLinkDecoratedVariable | undefined) + + get __backing_numA(): StorageLinkDecoratedVariable | undefined + set stringA(stringA: string | undefined) + + get stringA(): string | undefined + set __backing_stringA(__backing_stringA: StorageLinkDecoratedVariable | undefined) + + get __backing_stringA(): StorageLinkDecoratedVariable | undefined + set booleanA(booleanA: boolean | undefined) + + get booleanA(): boolean | undefined + set __backing_booleanA(__backing_booleanA: StorageLinkDecoratedVariable | undefined) + + get __backing_booleanA(): StorageLinkDecoratedVariable | undefined + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + MyStateSample._instantiateImpl(undefined, (() => { + return new MyStateSample(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} + +`; + +function testStorageLinkTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test storagelink primitive type transform', + [storageLinkTransform, uiNoRecheck], + { + checked: [testStorageLinkTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storageprop/storageprop-appstorage.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storageprop/storageprop-appstorage.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..e00d66d86c692d3cf2f4eee7eb9c4c44afc9ca5d --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storageprop/storageprop-appstorage.test.ts @@ -0,0 +1,165 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const STORAGEPROP_DIR_PATH: string = 'decorators/storageprop'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, STORAGEPROP_DIR_PATH, 'storageprop-appstorage.ets'), +]; + +const storagePropTransform: Plugins = { + name: 'storageprop', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test storageprop with appstorage', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { StoragePropDecoratedVariable as StoragePropDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; + +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry, Column as Column, Text as Text, ClickEvent as ClickEvent } from "@ohos.arkui.component"; + +import { StorageProp as StorageProp, AppStorage as AppStorage } from "@ohos.arkui.stateManagement"; + +function main() {} + +AppStorage.setOrCreate("PropA", 47); +AppStorage.setOrCreate("PropB", new Data(50)); + +class Data { + public code: number; + + public constructor(code: number) { + this.code = code; + } + +} + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class Index extends CustomComponent { + public __initializeStruct(initializers: __Options_Index | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_storageProp = new StoragePropDecoratedVariable("PropA", "storageProp", 1) + this.__backing_storagePropObject = new StoragePropDecoratedVariable("PropB", "storagePropObject", new Data(1)) + } + + public __updateStruct(initializers: __Options_Index | undefined): void {} + + private __backing_storageProp?: StoragePropDecoratedVariable; + + public get storageProp(): number { + return this.__backing_storageProp!.get(); + } + + public set storageProp(value: number) { + this.__backing_storageProp!.set(value); + } + + private __backing_storagePropObject?: StoragePropDecoratedVariable; + + public get storagePropObject(): Data { + return this.__backing_storagePropObject!.get(); + } + + public set storagePropObject(value: Data) { + this.__backing_storagePropObject!.set(value); + } + + @memo() public _build(@memo() style: ((instance: Index)=> Index) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Index | undefined): void { + Column(undefined, undefined, (() => { + Text(@memo() ((instance: UITextAttribute): void => { + instance.onClick(((e: ClickEvent) => { + this.storageProp += 1; + })); + return; + }), \`From AppStorage \${this.storageProp}\`, undefined, undefined); + Text(@memo() ((instance: UITextAttribute): void => { + instance.onClick(((e: ClickEvent) => { + this.storagePropObject.code += 1; + })); + return; + }), \`From AppStorage \${this.storagePropObject.code}\`, undefined, undefined); + })); + } + + public constructor() {} + +} + +interface __Options_Index { + set storageProp(storageProp: number | undefined) + + get storageProp(): number | undefined + set __backing_storageProp(__backing_storageProp: StoragePropDecoratedVariable | undefined) + + get __backing_storageProp(): StoragePropDecoratedVariable | undefined + set storagePropObject(storagePropObject: Data | undefined) + + get storagePropObject(): Data | undefined + set __backing_storagePropObject(__backing_storagePropObject: StoragePropDecoratedVariable | undefined) + + get __backing_storagePropObject(): StoragePropDecoratedVariable | undefined + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + Index._instantiateImpl(undefined, (() => { + return new Index(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} + +`; + +function testStoragePropTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test storageprop with appstorage', + [storagePropTransform, uiNoRecheck], + { + checked: [testStoragePropTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storageprop/storageprop-complex-type.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storageprop/storageprop-complex-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..ca212c7caad25e27955d4136240a47414626b8f9 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storageprop/storageprop-complex-type.test.ts @@ -0,0 +1,312 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const STORAGEPROP_DIR_PATH: string = 'decorators/storageprop'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, STORAGEPROP_DIR_PATH, 'storageprop-complex-type.ets'), +]; + +const storagePropTransform: Plugins = { + name: 'storageprop', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test storageprop complex type transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { StoragePropDecoratedVariable as StoragePropDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry } from "@ohos.arkui.component"; + +import { StorageProp as StorageProp } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +class Person { + public name: string = ""; + + public constructor(name: string) {} + +} + +final class Status extends BaseEnum { + private readonly #ordinal: int; + + private static () {} + + public constructor(ordinal: int, value: int) { + super(value); + this.#ordinal = ordinal; + } + + public static readonly Success: Status = new Status(0, 200); + + public static readonly NotFound: Status = new Status(1, 404); + + public static readonly ServerError: Status = new Status(2, 500); + + private static readonly #NamesArray: String[] = ["Success", "NotFound", "ServerError"]; + + private static readonly #ValuesArray: int[] = [200, 404, 500]; + + private static readonly #StringValuesArray: String[] = ["200", "404", "500"]; + + private static readonly #ItemsArray: Status[] = [Status.Success, Status.NotFound, Status.ServerError]; + + public getName(): String { + return Status.#NamesArray[this.#ordinal]; + } + + public static getValueOf(name: String): Status { + for (let i = 0;((i) < (Status.#NamesArray.length));(++i)) { + if (((name) == (Status.#NamesArray[i]))) { + return Status.#ItemsArray[i]; + } + } + throw new Error((("No enum constant Status.") + (name))); + } + + public static fromValue(value: int): Status { + for (let i = 0;((i) < (Status.#ValuesArray.length));(++i)) { + if (((value) == (Status.#ValuesArray[i]))) { + return Status.#ItemsArray[i]; + } + } + throw new Error((("No enum Status with value ") + (value))); + } + + public valueOf(): int { + return Status.#ValuesArray[this.#ordinal]; + } + + public toString(): String { + return Status.#StringValuesArray[this.#ordinal]; + } + + public static values(): Status[] { + return Status.#ItemsArray; + } + + public getOrdinal(): int { + return this.#ordinal; + } + + public static $_get(e: Status): String { + return e.getName(); + } + +} + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_arrayB = new StoragePropDecoratedVariable>("Prop1", "arrayB", [1, 2, 3]) + this.__backing_objectB = new StoragePropDecoratedVariable("Prop2", "objectB", {}) + this.__backing_dateB = new StoragePropDecoratedVariable("Prop3", "dateB", new Date("2021-09-09")) + this.__backing_setB = new StoragePropDecoratedVariable>("Prop4", "setB", new Set()) + this.__backing_mapB = new StoragePropDecoratedVariable>("Prop5", "mapB", new Map()) + this.__backing_unionB = new StoragePropDecoratedVariable("Prop6", "unionB", "") + this.__backing_classB = new StoragePropDecoratedVariable("Prop7", "classB", new Person("Kevin")) + this.__backing_enumB = new StoragePropDecoratedVariable("Prop8", "enumB", Status.NotFound) + } + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + private __backing_arrayB?: StoragePropDecoratedVariable>; + + public get arrayB(): Array { + return this.__backing_arrayB!.get(); + } + + public set arrayB(value: Array) { + this.__backing_arrayB!.set(value); + } + + private __backing_objectB?: StoragePropDecoratedVariable; + + public get objectB(): Object { + return this.__backing_objectB!.get(); + } + + public set objectB(value: Object) { + this.__backing_objectB!.set(value); + } + + private __backing_dateB?: StoragePropDecoratedVariable; + + public get dateB(): Date { + return this.__backing_dateB!.get(); + } + + public set dateB(value: Date) { + this.__backing_dateB!.set(value); + } + + private __backing_setB?: StoragePropDecoratedVariable>; + + public get setB(): Set { + return this.__backing_setB!.get(); + } + + public set setB(value: Set) { + this.__backing_setB!.set(value); + } + + private __backing_mapB?: StoragePropDecoratedVariable>; + + public get mapB(): Map { + return this.__backing_mapB!.get(); + } + + public set mapB(value: Map) { + this.__backing_mapB!.set(value); + } + + private __backing_unionB?: StoragePropDecoratedVariable; + + public get unionB(): string | undefined { + return this.__backing_unionB!.get(); + } + + public set unionB(value: string | undefined) { + this.__backing_unionB!.set(value); + } + + private __backing_classB?: StoragePropDecoratedVariable; + + public get classB(): Person { + return this.__backing_classB!.get(); + } + + public set classB(value: Person) { + this.__backing_classB!.set(value); + } + + private __backing_enumB?: StoragePropDecoratedVariable; + + public get enumB(): Status { + return this.__backing_enumB!.get(); + } + + public set enumB(value: Status) { + this.__backing_enumB!.set(value); + } + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + set arrayB(arrayB: Array | undefined) + + get arrayB(): Array | undefined + set __backing_arrayB(__backing_arrayB: StoragePropDecoratedVariable> | undefined) + + get __backing_arrayB(): StoragePropDecoratedVariable> | undefined + set objectB(objectB: Object | undefined) + + get objectB(): Object | undefined + set __backing_objectB(__backing_objectB: StoragePropDecoratedVariable | undefined) + + get __backing_objectB(): StoragePropDecoratedVariable | undefined + set dateB(dateB: Date | undefined) + + get dateB(): Date | undefined + set __backing_dateB(__backing_dateB: StoragePropDecoratedVariable | undefined) + + get __backing_dateB(): StoragePropDecoratedVariable | undefined + set setB(setB: Set | undefined) + + get setB(): Set | undefined + set __backing_setB(__backing_setB: StoragePropDecoratedVariable> | undefined) + + get __backing_setB(): StoragePropDecoratedVariable> | undefined + set mapB(mapB: Map | undefined) + + get mapB(): Map | undefined + set __backing_mapB(__backing_mapB: StoragePropDecoratedVariable> | undefined) + + get __backing_mapB(): StoragePropDecoratedVariable> | undefined + set unionB(unionB: string | undefined | undefined) + + get unionB(): string | undefined | undefined + set __backing_unionB(__backing_unionB: StoragePropDecoratedVariable | undefined) + + get __backing_unionB(): StoragePropDecoratedVariable | undefined + set classB(classB: Person | undefined) + + get classB(): Person | undefined + set __backing_classB(__backing_classB: StoragePropDecoratedVariable | undefined) + + get __backing_classB(): StoragePropDecoratedVariable | undefined + set enumB(enumB: Status | undefined) + + get enumB(): Status | undefined + set __backing_enumB(__backing_enumB: StoragePropDecoratedVariable | undefined) + + get __backing_enumB(): StoragePropDecoratedVariable | undefined + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + MyStateSample._instantiateImpl(undefined, (() => { + return new MyStateSample(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} +`; + +function testStoragePropTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test storageprop complex type transform', + [storagePropTransform, uiNoRecheck], + { + checked: [testStoragePropTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storageprop/storageprop-primitive-type.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storageprop/storageprop-primitive-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..d6247f205625a78926fd1b6e745ddbaca0b1fd2a --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/storageprop/storageprop-primitive-type.test.ts @@ -0,0 +1,152 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const STORAGEPROP_DIR_PATH: string = 'decorators/storageprop'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, STORAGEPROP_DIR_PATH, 'storageprop-primitive-type.ets'), +]; + +const storagePropTransform: Plugins = { + name: 'storageprop', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test storageprop primitive type transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { StoragePropDecoratedVariable as StoragePropDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry } from "@ohos.arkui.component"; + +import { StorageProp as StorageProp } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_numB = new StoragePropDecoratedVariable("Prop1", "numB", 43) + this.__backing_stringB = new StoragePropDecoratedVariable("Prop2", "stringB", "BB") + this.__backing_booleanB = new StoragePropDecoratedVariable("Prop3", "booleanB", false) + } + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + private __backing_numB?: StoragePropDecoratedVariable; + + public get numB(): number { + return this.__backing_numB!.get(); + } + + public set numB(value: number) { + this.__backing_numB!.set(value); + } + + private __backing_stringB?: StoragePropDecoratedVariable; + + public get stringB(): string { + return this.__backing_stringB!.get(); + } + + public set stringB(value: string) { + this.__backing_stringB!.set(value); + } + + private __backing_booleanB?: StoragePropDecoratedVariable; + + public get booleanB(): boolean { + return this.__backing_booleanB!.get(); + } + + public set booleanB(value: boolean) { + this.__backing_booleanB!.set(value); + } + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + set numB(numB: number | undefined) + + get numB(): number | undefined + set __backing_numB(__backing_numB: StoragePropDecoratedVariable | undefined) + + get __backing_numB(): StoragePropDecoratedVariable | undefined + set stringB(stringB: string | undefined) + + get stringB(): string | undefined + set __backing_stringB(__backing_stringB: StoragePropDecoratedVariable | undefined) + + get __backing_stringB(): StoragePropDecoratedVariable | undefined + set booleanB(booleanB: boolean | undefined) + + get booleanB(): boolean | undefined + set __backing_booleanB(__backing_booleanB: StoragePropDecoratedVariable | undefined) + + get __backing_booleanB(): StoragePropDecoratedVariable | undefined + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + MyStateSample._instantiateImpl(undefined, (() => { + return new MyStateSample(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} +`; + +function testStoragePropTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test storageprop primitive type transform', + [storagePropTransform, uiNoRecheck], + { + checked: [testStoragePropTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/watch/watch-basic.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/watch/watch-basic.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..fbb612c70fa628e4852f9fdc505881799e5d71aa --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/decorators/watch/watch-basic.test.ts @@ -0,0 +1,306 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const WATCH_DIR_PATH: string = 'decorators/watch'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, WATCH_DIR_PATH, 'watch-basic.ets'), +]; + +const watchTransform: Plugins = { + name: 'watch', + parsed: uiTransform().parsed, +}; + +const pluginTester = new PluginTester('test basic watch transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { ConsumeDecoratedVariable as ConsumeDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { ProvideDecoratedVariable as ProvideDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { SubscribedWatches as SubscribedWatches } from "@ohos.arkui.stateManagement"; + +import { WatchIdType as WatchIdType } from "@ohos.arkui.stateManagement"; + +import { int32 as int32 } from "@ohos.arkui.stateManagement"; + +import { IObservedObject as IObservedObject } from "@ohos.arkui.stateManagement"; + +import { setObservationDepth as setObservationDepth } from "@ohos.arkui.stateManagement"; + +import { BackingValue as BackingValue } from "@ohos.arkui.stateManagement"; + +import { MutableStateMeta as MutableStateMeta } from "@ohos.arkui.stateManagement"; + +import { ObjectLinkDecoratedVariable as ObjectLinkDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { DecoratedV1VariableBase as DecoratedV1VariableBase } from "@ohos.arkui.stateManagement"; + +import { LinkDecoratedVariable as LinkDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { StoragePropDecoratedVariable as StoragePropDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { StorageLinkDecoratedVariable as StorageLinkDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { PropDecoratedVariable as PropDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry } from "@ohos.arkui.component"; + +import { State as State, Prop as Prop, StorageLink as StorageLink, StorageProp as StorageProp, Link as Link, Watch as Watch, ObjectLink as ObjectLink, Observed as Observed, Track as Track, Provide as Provide, Consume as Consume } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +@Observed() class A implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + public propA: string = "hello"; + + private __backing_trackA: string = "world"; + + private __meta_trackA: MutableStateMeta = new MutableStateMeta("@Track"); + + public constructor() {} + + public get trackA(): string { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_trackA.addRef(); + } + return this.__backing_trackA; + } + + public set trackA(newValue: string) { + if (((this.__backing_trackA) !== (newValue))) { + this.__backing_trackA = newValue; + this.__meta_trackA.fireChange(); + this.executeOnSubscribingWatches("trackA"); + } + } + +} + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_statevar = new StateDecoratedVariable("statevar", ((({let gensym___76198660 = initializers; + (((gensym___76198660) == (null)) ? undefined : gensym___76198660.statevar)})) ?? ("Hello World")), ((_: string): void => { + this.stateOnChange(_); + })); + this.__backing_propvar = new PropDecoratedVariable("propvar", ((({let gensym___241486692 = initializers; + (((gensym___241486692) == (null)) ? undefined : gensym___241486692.propvar)})) ?? ("Hello World")), ((_: string): void => { + this.propOnChange(_); + })); + this.__backing_storagelinkvar = new StorageLinkDecoratedVariable("prop1", "storagelinkvar", "Hello World", ((_: string): void => { + this.storageLinkOnChange(_); + })) + this.__backing_storagepropvar = new StoragePropDecoratedVariable("prop2", "storagepropvar", "Hello World", ((_: string): void => { + this.storagePropOnChange(_); + })) + this.__backing_providevar = this.addProvidedVar("providevar", "providevar", ((({let gensym___194235814 = initializers; + (((gensym___194235814) == (null)) ? undefined : gensym___194235814.providevar)})) ?? ("Hello World")), false, ((_: string): void => { + this.ProvideOnChange(_); + })); + } + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void { + if (((({let gensym___220608839 = initializers; + (((gensym___220608839) == (null)) ? undefined : gensym___220608839.propvar)})) !== (undefined))) { + this.__backing_propvar!.update((initializers!.propvar as string)); + } + } + + private __backing_statevar?: StateDecoratedVariable; + + public get statevar(): string { + return this.__backing_statevar!.get(); + } + + public set statevar(value: string) { + this.__backing_statevar!.set(value); + } + + private __backing_propvar?: PropDecoratedVariable; + + public get propvar(): string { + return this.__backing_propvar!.get(); + } + + public set propvar(value: string) { + this.__backing_propvar!.set(value); + } + + private __backing_storagelinkvar?: StorageLinkDecoratedVariable; + + public get storagelinkvar(): string { + return this.__backing_storagelinkvar!.get(); + } + + public set storagelinkvar(value: string) { + this.__backing_storagelinkvar!.set(value); + } + + private __backing_storagepropvar?: StoragePropDecoratedVariable; + + public get storagepropvar(): string { + return this.__backing_storagepropvar!.get(); + } + + public set storagepropvar(value: string) { + this.__backing_storagepropvar!.set(value); + } + + private __backing_providevar?: ProvideDecoratedVariable; + + public get providevar(): string { + return this.__backing_providevar!.get(); + } + + public set providevar(value: string) { + this.__backing_providevar!.set(value); + } + + public stateOnChange(propName: string) {} + + public propOnChange(propName: string) {} + + public storageLinkOnChange(propName: string) {} + + public storagePropOnChange(propName: string) {} + + public ProvideOnChange(propName: string) {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void { + Child._instantiateImpl(undefined, (() => { + return new Child(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} + +@Component({freezeWhenInactive:false}) final class Child extends CustomComponent { + public __initializeStruct(initializers: __Options_Child | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_Child | undefined): void {} + + @memo() public _build(@memo() style: ((instance: Child)=> Child) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Child | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + set statevar(statevar: string | undefined) + + get statevar(): string | undefined + set __backing_statevar(__backing_statevar: StateDecoratedVariable | undefined) + + get __backing_statevar(): StateDecoratedVariable | undefined + set propvar(propvar: string | undefined) + + get propvar(): string | undefined + set __backing_propvar(__backing_propvar: PropDecoratedVariable | undefined) + + get __backing_propvar(): PropDecoratedVariable | undefined + set storagelinkvar(storagelinkvar: string | undefined) + + get storagelinkvar(): string | undefined + set __backing_storagelinkvar(__backing_storagelinkvar: StorageLinkDecoratedVariable | undefined) + + get __backing_storagelinkvar(): StorageLinkDecoratedVariable | undefined + set storagepropvar(storagepropvar: string | undefined) + + get storagepropvar(): string | undefined + set __backing_storagepropvar(__backing_storagepropvar: StoragePropDecoratedVariable | undefined) + + get __backing_storagepropvar(): StoragePropDecoratedVariable | undefined + set providevar(providevar: string | undefined) + + get providevar(): string | undefined + set __backing_providevar(__backing_providevar: ProvideDecoratedVariable | undefined) + + get __backing_providevar(): ProvideDecoratedVariable | undefined + +} + +interface __Options_Child { + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + MyStateSample._instantiateImpl(undefined, (() => { + return new MyStateSample(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} + +`; + +function testWatchTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test basic watch transform', + [watchTransform, uiNoRecheck], + { + checked: [testWatchTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/ut/ui-plugins/xcomponent/xcomponent-basic.test.ts b/ets1.2/arkui-plugins/test/ut/ui-plugins/xcomponent/xcomponent-basic.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..fc5ee09c61f539d5e2bd36eda2dff9a5221425c3 --- /dev/null +++ b/ets1.2/arkui-plugins/test/ut/ui-plugins/xcomponent/xcomponent-basic.test.ts @@ -0,0 +1,132 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { uiNoRecheck } from '../../../utils/plugins'; +import { uiTransform } from '../../../../ui-plugins'; +import { Plugins } from '../../../../common/plugin-context'; + +const XCOMPONENT_DIR_PATH: string = 'xcomponent'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, XCOMPONENT_DIR_PATH, 'xcomponent-basic.ets'), +]; + +const xcomponentTransform: Plugins = { + name: 'xcomponent', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test basic XComponent transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { UIXComponentAttribute as UIXComponentAttribute } from "@ohos.arkui.component"; + +import { UIFlexAttribute as UIFlexAttribute } from "@ohos.arkui.component"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Flex as Flex, XComponent as XComponent, FlexDirection as FlexDirection, XComponentType as XComponentType, Entry as Entry, XComponentController as XComponentController, ItemAlign as ItemAlign, FlexAlign as FlexAlign, XComponentParameter as XComponentParameter } from "@ohos.arkui.component"; + +function main() {} + + + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class Index extends CustomComponent { + public __initializeStruct(initializers: __Options_Index | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_myXComponentController = ((({let gensym___221905990 = initializers; + (((gensym___221905990) == (null)) ? undefined : gensym___221905990.myXComponentController)})) ?? (new XComponentController())); + } + + public __updateStruct(initializers: __Options_Index | undefined): void {} + + private __backing_myXComponentController?: XComponentController; + + public get myXComponentController(): XComponentController { + return (this.__backing_myXComponentController as XComponentController); + } + + public set myXComponentController(value: XComponentController) { + this.__backing_myXComponentController = value; + } + + @memo() public _build(@memo() style: ((instance: Index)=> Index) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Index | undefined): void { + Flex(@memo() ((instance: UIFlexAttribute): void => { + instance.width("100%").height("100%"); + return; + }), { + direction: FlexDirection.Column, + alignItems: ItemAlign.Center, + justifyContent: FlexAlign.Start, + }, (() => { + XComponent(undefined, ({ + id: "xComponentId", + type: XComponentType.TEXTURE, + libraryname: "nativerender", + controller: this.myXComponentController, + } as XComponentParameter), "", undefined); + })); + } + + public constructor() {} + +} + +interface __Options_Index { + set myXComponentController(myXComponentController: XComponentController | undefined) + + get myXComponentController(): XComponentController | undefined + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + Index._instantiateImpl(undefined, (() => { + return new Index(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} +`; + +function testXComponentTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test basic XComponent transform', + [xcomponentTransform, uiNoRecheck], + { + checked: [testXComponentTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/arkui-plugins/test/utils/artkts-config.ts b/ets1.2/arkui-plugins/test/utils/artkts-config.ts new file mode 100644 index 0000000000000000000000000000000000000000..3474c59a2f94e9c921fb48e0cfbf6b797cf8ebf2 --- /dev/null +++ b/ets1.2/arkui-plugins/test/utils/artkts-config.ts @@ -0,0 +1,334 @@ +/* + * 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 * as fs from 'fs'; +import * as path from 'path'; +import { + ABC_SUFFIX, + ARKTS_CONFIG_FILE_PATH, + changeFileExtension, + ensurePathExists, + getFileName, + getRootPath, + MOCK_ENTRY_DIR_PATH, + MOCK_ENTRY_FILE_NAME, + MOCK_LOCAL_SDK_DIR_PATH, + MOCK_OUTPUT_CACHE_PATH, + MOCK_OUTPUT_DIR_PATH, + MOCK_OUTPUT_FILE_NAME, + PANDA_SDK_STDLIB_PATH, + RUNTIME_API_PATH, + STDLIB_ESCOMPAT_PATH, + STDLIB_PATH, + STDLIB_STD_PATH, +} from './path-config'; + +export interface ArkTSConfigObject { + compilerOptions: { + package: string; + baseUrl: string; + paths: Record; + dependencies: string[] | undefined; + entry: string; + }; +} + +export interface CompileFileInfo { + fileName: string; + filePath: string; + dependentFiles: string[]; + abcFilePath: string; + arktsConfigFile: string; + stdLibPath: string; +} + +export interface ModuleInfo { + isMainModule: boolean; + packageName: string; + moduleRootPath: string; + sourceRoots: string[]; + entryFile: string; + arktsConfigFile: string; + compileFileInfos: CompileFileInfo[]; + dependencies?: string[]; +} + +export interface DependentModule { + packageName: string; + moduleName: string; + moduleType: string; + modulePath: string; + sourceRoots: string[]; + entryFile: string; +} + +export type ModuleType = 'har' | string; // TODO: module type unclear + +export interface DependentModule { + packageName: string; + moduleName: string; + moduleType: ModuleType; + modulePath: string; + sourceRoots: string[]; + entryFile: string; +} + +export interface BuildConfig { + packageName: string; + compileFiles: string[]; + loaderOutPath: string; + cachePath: string; + pandaSdkPath: string; + buildSdkPath: string; + sourceRoots: string[]; + moduleRootPath: string; + dependentModuleList: DependentModule[]; +} + +export interface ArktsConfigBuilder { + buildConfig: BuildConfig; + entryFiles: Set; + outputDir: string; + cacheDir: string; + pandaSdkPath: string; + buildSdkPath: string; + packageName: string; + sourceRoots: string[]; + moduleRootPath: string; + dependentModuleList: DependentModule[]; + moduleInfos: Map; + mergedAbcFile: string; + // logger: Logger; // TODO + isDebug: boolean; +} + +function writeArkTSConfigFile( + moduleInfo: ModuleInfo, + pathSection: Record, + dependenciesSection: string[] +): void { + if (!moduleInfo.sourceRoots || moduleInfo.sourceRoots.length == 0) { + throw new Error('Write Arkts config: does not have sourceRoots.'); + } + + const baseUrl: string = path.resolve(moduleInfo.moduleRootPath, moduleInfo.sourceRoots[0]); + pathSection[moduleInfo.packageName] = [baseUrl]; + const arktsConfig: ArkTSConfigObject = { + compilerOptions: { + package: moduleInfo.packageName, + baseUrl: baseUrl, + paths: pathSection, + dependencies: dependenciesSection.length === 0 ? undefined : dependenciesSection, + entry: moduleInfo.entryFile, + }, + }; + + ensurePathExists(moduleInfo.arktsConfigFile); + fs.writeFileSync(moduleInfo.arktsConfigFile, JSON.stringify(arktsConfig, null, 2), 'utf-8'); +} + +function getDependentModules(moduleInfo: ModuleInfo, moduleInfoMap: Map): Map { + if (moduleInfo.isMainModule) { + return moduleInfoMap; + } + + const depModules: Map = new Map(); + if (moduleInfo.dependencies) { + moduleInfo.dependencies.forEach((packageName: string) => { + const depModuleInfo: ModuleInfo | undefined = moduleInfoMap.get(packageName); + if (!depModuleInfo) { + throw new Error(`Dependent Module: Module ${packageName} not found in moduleInfos`); + } else { + depModules.set(packageName, depModuleInfo); + } + }); + } + return depModules; +} + +function traverse(currentDir: string, pathSection: Record) { + const items = fs.readdirSync(currentDir); + for (const item of items) { + const itemPath = path.join(currentDir, item); + const stat = fs.statSync(itemPath); + + if (stat.isFile()) { + const basename = path.basename(item, '.d.ets'); + pathSection[basename] = [changeFileExtension(itemPath, '', '.d.ets')]; + } else if (stat.isDirectory()) { + traverse(itemPath, pathSection); + } + } +} + +function traverseSDK(currentDir: string, pathSection: Record, prefix?: string) { + const items = fs.readdirSync(currentDir); + + for (const item of items) { + const itemPath = path.join(currentDir, item); + const stat = fs.statSync(itemPath); + + if (stat.isFile() && !itemPath.endsWith('.d.ets')) { + continue; + } + + if (stat.isFile() && itemPath.endsWith('.d.ets')) { + const basename = path.basename(item, '.d.ets'); + const name = prefix && prefix !== 'arkui.runtime-api' ? `${prefix}.${basename}` : basename; + pathSection[name] = [changeFileExtension(itemPath, '', '.d.ets')]; + } else if (stat.isDirectory()) { + const basename = path.basename(itemPath); + const name = prefix && prefix !== 'arkui.runtime-api' ? `${prefix}.${basename}` : basename; + traverseSDK(itemPath, pathSection, name); + } + } +} + +function mockBuildConfig(): BuildConfig { + return { + packageName: 'mock', + compileFiles: [path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, MOCK_ENTRY_FILE_NAME)], + loaderOutPath: path.resolve(getRootPath(), MOCK_OUTPUT_DIR_PATH), + cachePath: path.resolve(getRootPath(), MOCK_OUTPUT_CACHE_PATH), + pandaSdkPath: global.PANDA_SDK_PATH, + buildSdkPath: global.API_PATH, + sourceRoots: [getRootPath()], + moduleRootPath: path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH), + dependentModuleList: [], + }; +} + +class MockArktsConfigBuilder implements ArktsConfigBuilder { + buildConfig: BuildConfig; + entryFiles: Set; + outputDir: string; + cacheDir: string; + pandaSdkPath: string; + buildSdkPath: string; + packageName: string; + sourceRoots: string[]; + moduleRootPath: string; + dependentModuleList: DependentModule[]; + moduleInfos: Map; + mergedAbcFile: string; + isDebug: boolean; + + constructor(buildConfig?: BuildConfig) { + const _buildConfig: BuildConfig = buildConfig ?? mockBuildConfig(); + this.buildConfig = _buildConfig; + this.entryFiles = new Set(_buildConfig.compileFiles as string[]); + this.outputDir = _buildConfig.loaderOutPath as string; + this.cacheDir = _buildConfig.cachePath as string; + this.pandaSdkPath = path.resolve(_buildConfig.pandaSdkPath as string); + this.buildSdkPath = path.resolve(_buildConfig.buildSdkPath as string); + this.packageName = _buildConfig.packageName as string; + this.sourceRoots = _buildConfig.sourceRoots as string[]; + this.moduleRootPath = path.resolve(_buildConfig.moduleRootPath as string); + this.dependentModuleList = _buildConfig.dependentModuleList as DependentModule[]; + this.isDebug = true; + + this.moduleInfos = new Map(); + this.mergedAbcFile = path.resolve(this.outputDir, MOCK_OUTPUT_FILE_NAME); + + this.generateModuleInfos(); + this.generateArkTSConfigForModules(); + } + + private generateModuleInfos(): void { + if (!this.packageName || !this.moduleRootPath || !this.sourceRoots) { + throw new Error('Main module: packageName, moduleRootPath, and sourceRoots are required'); + } + const mainModuleInfo: ModuleInfo = { + isMainModule: true, + packageName: this.packageName, + moduleRootPath: this.moduleRootPath, + sourceRoots: this.sourceRoots, + entryFile: '', + arktsConfigFile: path.resolve(this.cacheDir, this.packageName, ARKTS_CONFIG_FILE_PATH), + compileFileInfos: [], + }; + this.moduleInfos.set(this.moduleRootPath, mainModuleInfo); + this.dependentModuleList.forEach((module: DependentModule) => { + if (!module.packageName || !module.modulePath || !module.sourceRoots || !module.entryFile) { + throw new Error('Dependent module: packageName, modulePath, sourceRoots, and entryFile are required'); + } + const moduleInfo: ModuleInfo = { + isMainModule: false, + packageName: module.packageName, + moduleRootPath: module.modulePath, + sourceRoots: module.sourceRoots, + entryFile: module.entryFile, + arktsConfigFile: path.resolve(this.cacheDir, module.packageName, ARKTS_CONFIG_FILE_PATH), + compileFileInfos: [], + }; + this.moduleInfos.set(module.modulePath, moduleInfo); + }); + this.entryFiles.forEach((file: string) => { + const _file = path.resolve(file); + for (const [modulePath, moduleInfo] of this.moduleInfos) { + if (_file.startsWith(modulePath)) { + const filePathFromModuleRoot: string = path.relative(modulePath, _file); + const filePathInCache: string = path.join( + this.cacheDir, + moduleInfo.packageName, + filePathFromModuleRoot + ); + const abcFilePath: string = path.resolve(changeFileExtension(filePathInCache, ABC_SUFFIX)); + + const fileInfo: CompileFileInfo = { + fileName: getFileName(_file), + filePath: _file, + dependentFiles: [], + abcFilePath: abcFilePath, + arktsConfigFile: moduleInfo.arktsConfigFile, + stdLibPath: path.resolve(this.pandaSdkPath, PANDA_SDK_STDLIB_PATH, STDLIB_PATH), + }; + moduleInfo.compileFileInfos.push(fileInfo); + return; + } + } + throw new Error('Entry File does not belong to any module in moduleInfos.'); + }); + } + + private generateArkTSConfigForModules(): void { + const pathSection: Record = {}; + pathSection['std'] = [path.resolve(this.pandaSdkPath, PANDA_SDK_STDLIB_PATH, STDLIB_STD_PATH)]; + pathSection['escompat'] = [path.resolve(this.pandaSdkPath, PANDA_SDK_STDLIB_PATH, STDLIB_ESCOMPAT_PATH)]; + traverseSDK(this.buildSdkPath, pathSection); + + this.moduleInfos.forEach((moduleInfo: ModuleInfo, moduleRootPath: string) => { + pathSection[moduleInfo.packageName] = [path.resolve(moduleRootPath, moduleInfo.sourceRoots[0])]; + }); + + this.moduleInfos.forEach((moduleInfo: ModuleInfo, moduleRootPath: string) => { + const dependenciesSection: string[] = []; + this.generateDependenciesSection(moduleInfo, dependenciesSection); + writeArkTSConfigFile(moduleInfo, pathSection, dependenciesSection); + }); + } + + private generateDependenciesSection(moduleInfo: ModuleInfo, dependenciesSection: string[]): void { + const depModules: Map = getDependentModules(moduleInfo, this.moduleInfos); + depModules.forEach((depModuleInfo: ModuleInfo) => { + if (depModuleInfo.isMainModule) { + return; + } + dependenciesSection.push(depModuleInfo.arktsConfigFile); + }); + } +} + +export { mockBuildConfig, MockArktsConfigBuilder }; diff --git a/ets1.2/arkui-plugins/test/utils/cache.ts b/ets1.2/arkui-plugins/test/utils/cache.ts new file mode 100644 index 0000000000000000000000000000000000000000..b24fcdf64e0385cafb3d75e3c0785c4be61242e9 --- /dev/null +++ b/ets1.2/arkui-plugins/test/utils/cache.ts @@ -0,0 +1,59 @@ +/* + * 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. + */ + +class TesterCache { + private cacheInfo: Map; + private static instance: TesterCache; + + private constructor() { + this.cacheInfo = new Map(); + } + + static getInstance(): TesterCache { + if (!this.instance) { + this.instance = new TesterCache(); + } + return this.instance; + } + + public delete(key: string) { + if (this.cacheInfo.has(key)) { + this.cacheInfo.delete(key); + } + } + + public get(key: string) { + if (this.cacheInfo.has(key)) { + return this.cacheInfo.get(key); + } + return undefined; + } + + public has(key: string) { + return this.cacheInfo.has(key); + } + + public set(key: string, value: T) { + if (!this.cacheInfo.has(key)) { + this.cacheInfo.set(key, value); + } + } + + public clear() { + this.cacheInfo.clear(); + } +} + +export { TesterCache }; diff --git a/ets1.2/arkui-plugins/test/utils/compile.ts b/ets1.2/arkui-plugins/test/utils/compile.ts new file mode 100644 index 0000000000000000000000000000000000000000..f893dae3b129643cef280ca4848cb5c4e70fe285 --- /dev/null +++ b/ets1.2/arkui-plugins/test/utils/compile.ts @@ -0,0 +1,60 @@ +/* + * 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 { PluginDriver } from './plugin-driver'; +import { PluginContext, PluginExecutor } from '../../common/plugin-context'; +import { EtsglobalRemover } from '../../common/etsglobal-remover'; +import * as arkts from '@koalaui/libarkts'; + +function restartCompilerUptoState(state: arkts.Es2pandaContextState, restart: boolean): boolean { + try { + const ast: arkts.EtsScript | undefined = arkts.EtsScript.fromContext(); + if (!ast) { + return false; + } + + if (restart) { + const srcText = new EtsglobalRemover().visitor(ast).dumpSrc(); + arkts.arktsGlobal.es2panda._DestroyContext(arkts.arktsGlobal.context); + arkts.arktsGlobal.compilerContext = arkts.Context.createFromString(srcText); + } + + arkts.proceedToState(state); + return true; + } catch (e) { + return false; + } +} + +function insertPlugin( + driver: PluginDriver, + plugin: PluginExecutor | undefined, + state: arkts.Es2pandaContextState +): boolean { + arkts.proceedToState(state); + const pluginContext: PluginContext = driver.getPluginContext(); + const ast: arkts.EtsScript | undefined = arkts.EtsScript.fromContext(); + + if (!ast) { + return false; + } + + if (plugin) { + plugin.handler.apply(pluginContext); + } + return true; +} + +export { restartCompilerUptoState, insertPlugin }; diff --git a/ets1.2/arkui-plugins/test/utils/global.ts b/ets1.2/arkui-plugins/test/utils/global.ts new file mode 100644 index 0000000000000000000000000000000000000000..cbccd4afa9ac1174702cc789f8ddf6f842dece85 --- /dev/null +++ b/ets1.2/arkui-plugins/test/utils/global.ts @@ -0,0 +1,98 @@ +/* + * 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 * as fs from 'fs'; +import { CompileFileInfo } from './artkts-config'; +import * as arkts from '@koalaui/libarkts'; + +function initGlobal(fileInfo: CompileFileInfo, isDebug: boolean = true): void { + const config = [ + '_', + '--extension', + 'ets', + '--arktsconfig', + fileInfo.arktsConfigFile, + '--output', + fileInfo.abcFilePath, + ]; + + if (isDebug) { + config.push('--debug-info'); + } + config.push(fileInfo.filePath); + + arkts.arktsGlobal.filePath = fileInfo.filePath; + resetConfig(config); + + const source: string = fs.readFileSync(fileInfo.filePath).toString(); + resetContext(source); +} + +function resetContext(source: string): void { + try { + arkts.arktsGlobal.context; + } catch (e) { + // Do nothing + } finally { + const context: arkts.Context = arkts.Context.createFromString(source); + arkts.arktsGlobal.compilerContext = context; + } +} + +function resetConfig(cmd: string[]): void { + try { + arkts.arktsGlobal.config; + destroyConfig(); + } catch (e) { + // Do nothing + } finally { + const arkTSConfig: arkts.Config = arkts.Config.create(cmd); + arkts.arktsGlobal.config = arkTSConfig.peer; + } +} + +function destroyContext(): void { + try { + arkts.arktsGlobal.clearContext(); + } catch (e) { + // Do nothing + } +} + +function destroyConfig(): void { + try { + arkts.destroyConfig(arkts.arktsGlobal.config); + } catch (e) { + // Do nothing + } +} + +function canProceedToState(state: arkts.Es2pandaContextState): boolean { + const stateToSkip: arkts.Es2pandaContextState[] = [ + arkts.Es2pandaContextState.ES2PANDA_STATE_SCOPE_INITED, + arkts.Es2pandaContextState.ES2PANDA_STATE_BOUND, + arkts.Es2pandaContextState.ES2PANDA_STATE_LOWERED, + arkts.Es2pandaContextState.ES2PANDA_STATE_ASM_GENERATED, + arkts.Es2pandaContextState.ES2PANDA_STATE_ERROR, + ]; + if (state in stateToSkip) { + return false; + } + + const currState = arkts.arktsGlobal.es2panda._ContextState(arkts.arktsGlobal.context); + return currState < state; +} + +export { initGlobal, resetContext, resetConfig, destroyContext, destroyConfig, canProceedToState }; diff --git a/ets1.2/arkui-plugins/test/utils/parse-string.ts b/ets1.2/arkui-plugins/test/utils/parse-string.ts new file mode 100644 index 0000000000000000000000000000000000000000..2db07c21f9936ba5433116b35f96eae12ba6cbce --- /dev/null +++ b/ets1.2/arkui-plugins/test/utils/parse-string.ts @@ -0,0 +1,49 @@ +/* + * 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. + */ + +function parseDumpSrc(str: string): string { + let _str: string = str; + _str = cleanCopyRight(_str); + _str = removeSpaceAndReturn(_str); + _str = replaceWithRandomNumber(_str); + + return _str; +} + +function filterSource(text: string): string { + const filtered: string = text.replaceAll(/%/g, '_').replaceAll(/#/g, '_').replaceAll('', '_cctor_'); + + return filtered; +} + +function cleanCopyRight(str: string): string { + const copyrightBlockRegex = /(?:\/\*.*Copyright \([c|C]\) [- \d]+ [\w ]+\., Ltd\..*\*\/)/gs; + + return str.replace(copyrightBlockRegex, ''); +} + +function removeSpaceAndReturn(str: string): string { + const spaceAndReturnRegex = /^[\s\r]+/gm; + + return str.replace(spaceAndReturnRegex, '').trim(); +} + +function replaceWithRandomNumber(text: string): string { + return text + .replace(/(?<=__memo_id[\)+]?\s?\+\s?[\(+]?)\d+/g, () => '') + .replace(/(?<=gensym[_%]+)\d+/g, () => ''); +} + +export { parseDumpSrc, filterSource, cleanCopyRight, removeSpaceAndReturn, replaceWithRandomNumber }; diff --git a/ets1.2/arkui-plugins/test/utils/path-config.ts b/ets1.2/arkui-plugins/test/utils/path-config.ts new file mode 100644 index 0000000000000000000000000000000000000000..608df6deec29a6afd1087b59ef8928a2949c0366 --- /dev/null +++ b/ets1.2/arkui-plugins/test/utils/path-config.ts @@ -0,0 +1,64 @@ +/* + * 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 * as fs from 'fs'; +import * as path from 'path'; + +export const ARKTS_CONFIG_FILE_PATH: string = 'arktsconfig.json'; +export const PANDA_SDK_PATH: string = 'node_modules/@panda/sdk'; +export const PANDA_SDK_STDLIB_PATH: string = 'lib'; +export const STDLIB_PATH: string = 'stdlib'; +export const STDLIB_STD_PATH: string = 'stdlib/std'; +export const STDLIB_ESCOMPAT_PATH: string = 'stdlib/escompat'; +export const RUNTIME_API_PATH: string = 'demo/runtime-api'; +export const MOCK_ENTRY_DIR_PATH: string = 'demo/mock'; +export const MOCK_ENTRY_FILE_NAME: string = 'entry.ets'; +export const MOCK_OUTPUT_CACHE_PATH: string = 'generated/cache'; +export const MOCK_OUTPUT_DIR_PATH: string = 'generated/abc'; +export const MOCK_OUTPUT_FILE_NAME: string = 'entry.abc'; +export const MOCK_LOCAL_SDK_DIR_PATH: string = 'local'; +export const ETS_SUFFIX: string = '.ets'; +export const ABC_SUFFIX: string = '.abc'; + +function getRootPath(): string { + return path.resolve(__dirname, '..'); +} + +function changeFileExtension(file: string, targetExt: string, originExt = ''): string { + const currentExt: string = originExt.length === 0 ? path.extname(file) : originExt; + const fileWithoutExt: string = file.substring(0, file.lastIndexOf(currentExt)); + return fileWithoutExt + targetExt; +} + +function getFileName(file: string): string { + const fileWithExt: string = path.basename(file); + const currentExt: string = path.extname(file); + return fileWithExt.substring(0, fileWithExt.lastIndexOf(currentExt)); +} + +function ensurePathExists(filePath: string): void { + try { + const dirPath: string = path.dirname(filePath); + if (!fs.existsSync(dirPath)) { + fs.mkdirSync(dirPath, { recursive: true }); + } + } catch (error) { + if (error instanceof Error) { + console.error(`Error: ${error.message}`); + } + } +} + +export { getRootPath, changeFileExtension, getFileName, ensurePathExists }; diff --git a/ets1.2/arkui-plugins/test/utils/plugin-driver.ts b/ets1.2/arkui-plugins/test/utils/plugin-driver.ts new file mode 100644 index 0000000000000000000000000000000000000000..46ce7f562cc13bd90b3afd90b667cd2274c1e59b --- /dev/null +++ b/ets1.2/arkui-plugins/test/utils/plugin-driver.ts @@ -0,0 +1,107 @@ +/* + * 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 { isNumber } from './safe-types'; +import { Plugins, PluginContext, PluginHandler, PluginState, PluginExecutor } from '../../common/plugin-context'; +import * as arkts from '@koalaui/libarkts'; + +export interface PluginDriver { + initPlugins(plugins: Plugins[]): void; + getSortedPlugins(state: arkts.Es2pandaContextState): PluginExecutor[] | undefined; + getPluginContext(): PluginContext; +} + +function toCamelCase(str: string): string { + return str + .split('_') + .map((word, index) => { + if (index === 0) { + return word; + } + return word.charAt(0).toUpperCase() + word.slice(1); + }) + .join(''); +} + +function stateName(value: arkts.Es2pandaContextState): PluginState { + return toCamelCase( + arkts.Es2pandaContextState[value].substring('ES2PANDA_STATE_'.length).toLowerCase() + ) as PluginState; +} + +function selectPlugins(plugins: Plugins[], stage: PluginState): PluginExecutor[] { + const pre: PluginExecutor[] = []; + const normal: PluginExecutor[] = []; + const post: PluginExecutor[] = []; + + plugins + .filter((it) => stage in it) + .forEach((it) => { + const pluginName: string = it.name; + const handler: PluginHandler = it[stage]!; + const order: string | undefined = typeof handler === 'object' ? handler.order : undefined; + const rawPluginHook: PluginExecutor = { + name: pluginName, + handler: typeof handler === 'object' ? handler.handler : handler, + }; + + if (order === 'pre') { + pre.push(rawPluginHook); + } else if (order === 'post') { + post.push(rawPluginHook); + } else { + normal.push(rawPluginHook); + } + }); + + return [...pre, ...normal, ...post]; +} + +class MockPluginDriver implements PluginDriver { + private sortedPlugins: Map; + private context: PluginContext; + + constructor() { + this.sortedPlugins = new Map(); + this.context = new PluginContext(); + } + + public initPlugins(plugins: Plugins[]): void { + const pluginsByState = new Map(); + + Object.values(arkts.Es2pandaContextState) + .filter(isNumber) + .forEach((it) => { + const selected = selectPlugins(plugins, stateName(it)); + if (selected.length > 0) { + pluginsByState.set(it, selected); + } else { + pluginsByState.set(it, undefined); + } + }); + + this.sortedPlugins = pluginsByState; + } + + public getSortedPlugins(state: arkts.Es2pandaContextState): PluginExecutor[] | undefined { + return this.sortedPlugins.get(state); + } + + public getPluginContext(): PluginContext { + return this.context; + } +} + +export { stateName, MockPluginDriver }; diff --git a/ets1.2/arkui-plugins/test/utils/plugin-tester.ts b/ets1.2/arkui-plugins/test/utils/plugin-tester.ts new file mode 100644 index 0000000000000000000000000000000000000000..710456e21ed4557b0241b4f7da0491bc3a62c99a --- /dev/null +++ b/ets1.2/arkui-plugins/test/utils/plugin-tester.ts @@ -0,0 +1,209 @@ +/* + * 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 { ArktsConfigBuilder, BuildConfig, CompileFileInfo, MockArktsConfigBuilder, ModuleInfo } from './artkts-config'; +import { MockPluginDriver, PluginDriver, stateName } from './plugin-driver'; +import { isNumber } from './safe-types'; +import { + canProceedToState, + destroyConfig, + destroyContext, + initGlobal, + resetConfig, + resetContext, +} from './global'; +import { insertPlugin } from './compile'; +import { PluginExecutor, Plugins, PluginState } from '../../common/plugin-context'; +import { TesterCache } from './cache'; +import * as arkts from '@koalaui/libarkts'; +import * as fs from 'fs'; + +type TestParams = Parameters; + +type SkipFirstParam = T extends [unknown, ...infer Rest] ? Rest : never; + +type PluginTestHooks = { + [K in PluginState | `${PluginState}:${string}`]?: SkipFirstParam; +}; + +type TestHooks = { + beforeAll?: Parameters; + beforeEach?: Parameters; + afterEach?: Parameters; +}; + +export interface PluginTestContext { + scriptSnapshot?: string; + errors?: string[]; + warnings?: string[]; +} + +export interface PluginTesterOptions { + stopAfter: PluginState; + buildConfig?: BuildConfig; +} + +class PluginTester { + private configBuilder: ArktsConfigBuilder; + private pluginDriver: PluginDriver; + private describe: string; + private cache: TesterCache; + + constructor(describe: string, buildConfig?: BuildConfig) { + this.describe = describe; + this.configBuilder = new MockArktsConfigBuilder(buildConfig); + this.pluginDriver = new MockPluginDriver(); + this.cache = TesterCache.getInstance(); + } + + private loadPluginDriver(plugins: Plugins[]): void { + this.pluginDriver.initPlugins(plugins); + } + + private test( + key: PluginState | `${PluginState}:${string}`, + index: arkts.Es2pandaContextState, + testName: string, + pluginHooks: PluginTestHooks, + plugin?: PluginExecutor + ): void { + let cached: boolean = false; + const cacheKey: string = `${testName}-${key}`; + if (index > arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED) { + return; + } + if (canProceedToState(index)) { + arkts.proceedToState(index); + } + if (plugin) { + insertPlugin(this.pluginDriver, plugin, index); + this.captureContext(cacheKey); + cached = true; + } + const hook: SkipFirstParam | undefined = pluginHooks[key]; + if (!!hook) { + if (!cached) this.captureContext(cacheKey); + test(testName, hook[0]?.bind(this.cache.get(cacheKey)), hook[1]); + } + } + + private captureContext(cacheKey: string): void { + try { + // TODO: add error/warning handling after plugin + const context: PluginTestContext = this.cache.get(cacheKey) ?? {}; + const script: arkts.EtsScript = arkts.EtsScript.fromContext(); + context.scriptSnapshot = script.dumpSrc(); + this.cache.set(cacheKey, context); + } catch (e) { + // Do nothing + } + } + + private proceedToState( + state: PluginState, + index: arkts.Es2pandaContextState, + testName: string, + pluginHooks: PluginTestHooks, + plugins?: PluginExecutor[] + ): void { + if (plugins && plugins.length > 0) { + plugins.forEach((plugin) => { + const pluginName: string = plugin.name; + const key: `${PluginState}:${string}` = `${state}:${pluginName}`; + this.test(key, index, `[${key}] ${testName}`, pluginHooks, plugin); + }); + } + this.test(state, index, `[${state}] ${testName}`, pluginHooks); + } + + private singleFileCompile( + fileInfo: CompileFileInfo, + moduleInfo: ModuleInfo, + testName: string, + pluginHooks: PluginTestHooks, + stopAfter: PluginState + ): void { + let shouldStop: boolean = false; + + Object.values(arkts.Es2pandaContextState) + .filter(isNumber) + .forEach((it) => { + if (shouldStop) { + return; + } + const state: PluginState = stateName(it); + const plugins: PluginExecutor[] | undefined = this.pluginDriver.getSortedPlugins(it); + this.proceedToState( + state, + it, + `${moduleInfo.packageName} - ${fileInfo.fileName}: ${testName}`, + pluginHooks, + plugins + ); + shouldStop = state === stopAfter; + }); + } + + private traverseFile(testName: string, pluginHooks: PluginTestHooks, stopAfter: PluginState): void { + let once: boolean = false; + this.configBuilder.moduleInfos.forEach((moduleInfo) => { + moduleInfo.compileFileInfos.forEach((fileInfo) => { + if (!once) { + initGlobal(fileInfo, this.configBuilder.isDebug); + once = true; + } else { + const source: string = fs.readFileSync(fileInfo.filePath).toString(); + resetContext(source); + } + this.singleFileCompile(fileInfo, moduleInfo, testName, pluginHooks, stopAfter); + }); + }); + } + + run( + testName: string, + plugins: Plugins[], + pluginHooks: PluginTestHooks, + options: PluginTesterOptions, + testHooks?: TestHooks + ): void { + if (!!options.buildConfig) { + this.configBuilder = new MockArktsConfigBuilder(options.buildConfig); + } + + this.cache.clear(); + this.loadPluginDriver(plugins); + + const that = this; + describe(this.describe, () => { + if (testHooks?.beforeAll) { + beforeAll(...testHooks.beforeAll); + } + if (testHooks?.beforeEach) { + beforeEach(...testHooks.beforeEach); + } + if (testHooks?.afterEach) { + afterEach(...testHooks.afterEach); + } + afterAll(() => { + destroyContext(); + destroyConfig(); + }); + that.traverseFile(testName, pluginHooks, options.stopAfter); + }); + } +} + +export { PluginTester }; diff --git a/ets1.2/arkui-plugins/test/utils/plugins/builder-lambda-no-recheck.ts b/ets1.2/arkui-plugins/test/utils/plugins/builder-lambda-no-recheck.ts new file mode 100644 index 0000000000000000000000000000000000000000..69e2b23adfc79c9fc7b138e1f011b07b6b092efb --- /dev/null +++ b/ets1.2/arkui-plugins/test/utils/plugins/builder-lambda-no-recheck.ts @@ -0,0 +1,48 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { PluginContext, Plugins } from '../../../common/plugin-context'; +import { ProgramVisitor } from '../../../common/program-visitor'; +import { EXTERNAL_SOURCE_PREFIX_NAMES } from '../../../common/predefines'; +import { BuilderLambdaTransformer } from '../../../ui-plugins/builder-lambda-translators/builder-lambda-transformer'; + +/** + * AfterCheck builder-lambda transform with no recheck AST. + */ +export const builderLambdaNoRecheck: Plugins = { + name: 'builder-lambda-no-recheck', + checked(this: PluginContext): arkts.EtsScript | undefined { + let script: arkts.EtsScript | undefined; + const contextPtr = arkts.arktsGlobal.compilerContext?.peer ?? this.getContextPtr(); + if (!!contextPtr) { + let program = arkts.getOrUpdateGlobalContext(contextPtr).program; + script = program.astNode; + const builderLambdaTransformer = new BuilderLambdaTransformer(); + const programVisitor = new ProgramVisitor({ + pluginName: builderLambdaNoRecheck.name, + state: arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED, + visitors: [builderLambdaTransformer], + skipPrefixNames: EXTERNAL_SOURCE_PREFIX_NAMES, + pluginContext: this, + }); + program = programVisitor.programVisitor(program); + script = program.astNode; + arkts.GlobalInfo.getInfoInstance().reset(); + return script; + } + return script; + }, +}; diff --git a/ets1.2/arkui-plugins/test/utils/plugins/index.ts b/ets1.2/arkui-plugins/test/utils/plugins/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..4858b84b2f96416bdcffd8779f14baf792ffef95 --- /dev/null +++ b/ets1.2/arkui-plugins/test/utils/plugins/index.ts @@ -0,0 +1,24 @@ +/* + * 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. + */ + +// AfterParse +export * from './struct-to-component'; + +// AfterCheck +export * from './builder-lambda-no-recheck'; +export * from './memo-no-recheck'; +export * from './struct-no-recheck'; +export * from './ui-no-recheck'; +export * from './recheck'; diff --git a/ets1.2/arkui-plugins/test/utils/plugins/memo-no-recheck.ts b/ets1.2/arkui-plugins/test/utils/plugins/memo-no-recheck.ts new file mode 100644 index 0000000000000000000000000000000000000000..ff018cec51611f2fcc51485a17e185fca9ef357e --- /dev/null +++ b/ets1.2/arkui-plugins/test/utils/plugins/memo-no-recheck.ts @@ -0,0 +1,60 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { PluginContext, Plugins } from '../../../common/plugin-context'; +import { ProgramVisitor } from '../../../common/program-visitor'; +import { EXTERNAL_SOURCE_PREFIX_NAMES } from '../../../common/predefines'; +import { PositionalIdTracker } from '../../../memo-plugins/utils'; +import { ParameterTransformer } from '../../../memo-plugins/parameter-transformer'; +import { ReturnTransformer } from '../../../memo-plugins/return-transformer'; +import { SignatureTransformer } from '../../../memo-plugins/signature-transformer'; +import { FunctionTransformer } from '../../../memo-plugins/function-transformer'; + +/** + * AfterCheck unmemoizeTransform with no recheck AST. + */ +export const memoNoRecheck: Plugins = { + name: 'memo-no-recheck', + checked(this: PluginContext): arkts.EtsScript | undefined { + const contextPtr = arkts.arktsGlobal.compilerContext?.peer ?? this.getContextPtr(); + if (!!contextPtr) { + let program = arkts.getOrUpdateGlobalContext(contextPtr).program; + let script = program.astNode; + const positionalIdTracker = new PositionalIdTracker(arkts.getFileName(), false); + const parameterTransformer = new ParameterTransformer({ + positionalIdTracker, + }); + const returnTransformer = new ReturnTransformer(); + const signatureTransformer = new SignatureTransformer(); + const functionTransformer = new FunctionTransformer({ + positionalIdTracker, + parameterTransformer, + returnTransformer, + signatureTransformer, + }); + const programVisitor = new ProgramVisitor({ + pluginName: memoNoRecheck.name, + state: arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED, + visitors: [functionTransformer], + skipPrefixNames: EXTERNAL_SOURCE_PREFIX_NAMES, + pluginContext: this, + }); + program = programVisitor.programVisitor(program); + script = program.astNode; + return script; + } + }, +}; diff --git a/ets1.2/arkui-plugins/test/utils/plugins/recheck.ts b/ets1.2/arkui-plugins/test/utils/plugins/recheck.ts new file mode 100644 index 0000000000000000000000000000000000000000..085d3731e44fbfcb24b73b4b1d32843ce40bc849 --- /dev/null +++ b/ets1.2/arkui-plugins/test/utils/plugins/recheck.ts @@ -0,0 +1,35 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { PluginContext, Plugins } from '../../../common/plugin-context'; + +/** + * Recheck the current AST. This plugin can ONLY be used at afterCheck. + */ +export const recheck: Plugins = { + name: 'recheck', + checked(this: PluginContext): arkts.EtsScript | undefined { + let script: arkts.EtsScript | undefined; + const contextPtr = arkts.arktsGlobal.compilerContext?.peer ?? this.getContextPtr(); + if (!!contextPtr) { + let program = arkts.getOrUpdateGlobalContext(contextPtr).program; + script = program.astNode; + arkts.recheckSubtree(script); + return script; + } + return script; + }, +}; diff --git a/ets1.2/arkui-plugins/test/utils/plugins/struct-no-recheck.ts b/ets1.2/arkui-plugins/test/utils/plugins/struct-no-recheck.ts new file mode 100644 index 0000000000000000000000000000000000000000..c564b71c780c590b555aec03d0b7b10db57fe7f6 --- /dev/null +++ b/ets1.2/arkui-plugins/test/utils/plugins/struct-no-recheck.ts @@ -0,0 +1,48 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { PluginContext, Plugins } from '../../../common/plugin-context'; +import { ProgramVisitor } from '../../../common/program-visitor'; +import { EXTERNAL_SOURCE_PREFIX_NAMES } from '../../../common/predefines'; +import { StructTransformer } from '../../../ui-plugins/struct-translators/struct-transformer'; + +/** + * AfterCheck struct transform with no recheck AST. + */ +export const structNoRecheck: Plugins = { + name: 'struct-no-recheck', + checked(this: PluginContext): arkts.EtsScript | undefined { + let script: arkts.EtsScript | undefined; + const contextPtr = arkts.arktsGlobal.compilerContext?.peer ?? this.getContextPtr(); + if (!!contextPtr) { + let program = arkts.getOrUpdateGlobalContext(contextPtr).program; + script = program.astNode; + const structTransformer = new StructTransformer(this.getProjectConfig()); + const programVisitor = new ProgramVisitor({ + pluginName: structNoRecheck.name, + state: arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED, + visitors: [structTransformer], + skipPrefixNames: EXTERNAL_SOURCE_PREFIX_NAMES, + pluginContext: this, + }); + program = programVisitor.programVisitor(program); + script = program.astNode; + arkts.GlobalInfo.getInfoInstance().reset(); + return script; + } + return script; + }, +}; diff --git a/ets1.2/arkui-plugins/test/utils/plugins/struct-to-component.ts b/ets1.2/arkui-plugins/test/utils/plugins/struct-to-component.ts new file mode 100644 index 0000000000000000000000000000000000000000..14d494c050b2e384430a100c31fa94684ffef1e7 --- /dev/null +++ b/ets1.2/arkui-plugins/test/utils/plugins/struct-to-component.ts @@ -0,0 +1,47 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { PluginContext, Plugins } from '../../../common/plugin-context'; +import { ProgramVisitor } from '../../../common/program-visitor'; +import { EXTERNAL_SOURCE_PREFIX_NAMES } from '../../../common/predefines'; +import { ComponentTransformer } from '../../../ui-plugins/component-transformer'; + +/** + * AfterParse transform struct to component. + */ +export const structToComponent: Plugins = { + name: 'struct-to-component', + parsed(this: PluginContext): arkts.EtsScript | undefined { + let script: arkts.EtsScript | undefined; + const contextPtr = arkts.arktsGlobal.compilerContext?.peer ?? this.getContextPtr(); + if (!!contextPtr) { + let program = arkts.getOrUpdateGlobalContext(contextPtr).program; + script = program.astNode; + const componentTransformer = new ComponentTransformer(); + const programVisitor = new ProgramVisitor({ + pluginName: structToComponent.name, + state: arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED, + visitors: [componentTransformer], + skipPrefixNames: EXTERNAL_SOURCE_PREFIX_NAMES, + pluginContext: this, + }); + program = programVisitor.programVisitor(program); + script = program.astNode; + return script; + } + return script; + }, +}; diff --git a/ets1.2/arkui-plugins/test/utils/plugins/ui-no-recheck.ts b/ets1.2/arkui-plugins/test/utils/plugins/ui-no-recheck.ts new file mode 100644 index 0000000000000000000000000000000000000000..dec4b5296d0c13dceb7a2d3749e09306f2adb4a0 --- /dev/null +++ b/ets1.2/arkui-plugins/test/utils/plugins/ui-no-recheck.ts @@ -0,0 +1,48 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { PluginContext, Plugins } from '../../../common/plugin-context'; +import { ProgramVisitor } from '../../../common/program-visitor'; +import { EXTERNAL_SOURCE_PREFIX_NAMES } from '../../../common/predefines'; +import { CheckedTransformer } from '../../../ui-plugins/checked-transformer'; + +/** + * AfterCheck uiTransform with no recheck AST. + */ +export const uiNoRecheck: Plugins = { + name: 'ui-no-recheck', + checked(this: PluginContext): arkts.EtsScript | undefined { + let script: arkts.EtsScript | undefined; + const contextPtr = arkts.arktsGlobal.compilerContext?.peer ?? this.getContextPtr(); + if (!!contextPtr) { + let program = arkts.getOrUpdateGlobalContext(contextPtr).program; + script = program.astNode; + const checkedTransformer = new CheckedTransformer(this.getProjectConfig()); + const programVisitor = new ProgramVisitor({ + pluginName: uiNoRecheck.name, + state: arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED, + visitors: [checkedTransformer], + skipPrefixNames: EXTERNAL_SOURCE_PREFIX_NAMES, + pluginContext: this, + }); + program = programVisitor.programVisitor(program); + script = program.astNode; + arkts.GlobalInfo.getInfoInstance().reset(); + return script; + } + return script; + }, +}; diff --git a/ets1.2/arkui-plugins/test/utils/safe-types.ts b/ets1.2/arkui-plugins/test/utils/safe-types.ts new file mode 100644 index 0000000000000000000000000000000000000000..728c06501cffc9330993fb6c4d91e3fec93c7bad --- /dev/null +++ b/ets1.2/arkui-plugins/test/utils/safe-types.ts @@ -0,0 +1,20 @@ +/* + * 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. + */ + +function isNumber(value: any): value is number { + return typeof value === `number`; +} + +export { isNumber }; diff --git a/ets1.2/arkui-plugins/tsconfig.build.json b/ets1.2/arkui-plugins/tsconfig.build.json new file mode 100644 index 0000000000000000000000000000000000000000..02074ad930560974d147ac73dbf42454b362dd2f --- /dev/null +++ b/ets1.2/arkui-plugins/tsconfig.build.json @@ -0,0 +1,29 @@ +{ + "compilerOptions": { + "target": "es2018", + "lib": ["ESNext", "ESNext.WeakRef", "DOM"], + "module": "CommonJS", + "rootDir": ".", + "baseUrl": ".", + "outDir": "./lib", + "moduleResolution": "node", + "incremental": false, + "declarationMap": false, + "sourceMap": false, + "declaration": false, + "noEmitOnError": true, + "strict": true, + "skipLibCheck": true, + "removeComments": false + }, + "include": [ + "./common/**/*.ts", + "./memo-plugins/**/*.ts", + "./ui-plugins/**/*.ts", + "./ui-syntax-plugins/**/*.ts", + "./interop-plugins/**/*.ts", + ], + "exclude": [ + "./test/**" + ] +} diff --git a/ets1.2/arkui-plugins/tsconfig.json b/ets1.2/arkui-plugins/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..32677ce448cc2c8909203b25292cb602a457f471 --- /dev/null +++ b/ets1.2/arkui-plugins/tsconfig.json @@ -0,0 +1,35 @@ +{ + "compilerOptions": { + "target": "es2018", + "lib": ["ESNext", "ESNext.WeakRef", "DOM"], + "module": "CommonJS", + "rootDir": ".", + "baseUrl": ".", + "outDir": "./lib", + "moduleResolution": "node", + "composite": true, + "incremental": true, + "declarationMap": true, + "sourceMap": true, + "declaration": true, + "noEmitOnError": true, + "strict": true, + "skipLibCheck": true, + "removeComments": false, + "isolatedModules": true + }, + "include": [ + "./common/**/*.ts", + "./memo-plugins/**/*.ts", + "./ui-plugins/**/*.ts", + "./ui-syntax-plugins/**/*.ts", + "./interop-plugins/**/*.ts", + "./path.ts", + "./test/ut/**/*.ts", + "./test/utils/**/*.ts" + ], + "exclude": [ + "./test/demo/", + "./test/local/" + ] +} diff --git a/ets1.2/arkui-plugins/ui-plugins/builder-lambda-translators/builder-lambda-transformer.ts b/ets1.2/arkui-plugins/ui-plugins/builder-lambda-translators/builder-lambda-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..5e4dc8331a4a365a1caded9ab0e231eb4cb37d2d --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/builder-lambda-translators/builder-lambda-transformer.ts @@ -0,0 +1,37 @@ +/* + * 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 '../../common/abstract-visitor'; +import { isBuilderLambda, isBuilderLambdaMethodDecl } from './utils'; +import { factory } from './factory'; + +export class BuilderLambdaTransformer extends AbstractVisitor { + reset(): void { + super.reset(); + } + + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + if (arkts.isCallExpression(beforeChildren) && isBuilderLambda(beforeChildren)) { + const lambda = factory.transformBuilderLambda(beforeChildren); + return this.visitEachChild(lambda); + } + if (arkts.isMethodDefinition(beforeChildren) && isBuilderLambdaMethodDecl(beforeChildren)) { + const lambda = factory.transformBuilderLambdaMethodDecl(beforeChildren); + return this.visitEachChild(lambda); + } + const node = this.visitEachChild(beforeChildren); + return node; + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/builder-lambda-translators/factory.ts b/ets1.2/arkui-plugins/ui-plugins/builder-lambda-translators/factory.ts new file mode 100644 index 0000000000000000000000000000000000000000..9c303f7659da18e823426653cff0299052e4a535 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/builder-lambda-translators/factory.ts @@ -0,0 +1,648 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { BuilderLambdaNames } from '../utils'; +import { annotation, backingField, filterDefined, removeAnnotationByName } from '../../common/arkts-utils'; +import { + BuilderLambdaDeclInfo, + builderLambdaFunctionName, + builderLambdaMethodDeclType, + builderLambdaTypeName, + callIsGoodForBuilderLambda, + findBuilderLambdaDecl, + findBuilderLambdaDeclInfo, + isBuilderLambda, + isBuilderLambdaFunctionCall, + isSafeType, + replaceBuilderLambdaDeclMethodName, + BindableDecl, + getDecalTypeFromValue, + hasBindableProperty, + isDoubleDollarCall, + InstanceCallInfo, + isStyleChainedCall, + isStyleWithReceiverCall, +} from './utils'; +import { DecoratorNames } from '../property-translators/utils'; +import { factory as PropertyFactory } from '../property-translators/factory'; +import { ProjectConfig } from '../../common/plugin-context'; + +export class factory { + /* + * update @ComponentBuilder decorated method. + */ + static updateBuilderLambdaMethodDecl( + node: arkts.MethodDefinition, + styleArg: arkts.ETSParameterExpression, + newAnno: arkts.AnnotationUsage[], + newName: string | undefined + ): arkts.MethodDefinition { + const func: arkts.ScriptFunction = node.scriptFunction; + const updateFunc = arkts.factory + .updateScriptFunction( + func, + func.body, + arkts.FunctionSignature.createFunctionSignature( + func.typeParams, + [styleArg, ...func.params], + arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID), + false + ), + func.flags, + func.modifiers + ) + .setAnnotations(newAnno); + + return arkts.factory.updateMethodDefinition( + node, + node.kind, + arkts.factory.updateIdentifier(node.name, newName ?? node.name.name), + updateFunc, + node.modifiers, + false // TODO: how do I get it? + ); + } + + /* + * transform arguments in style node. + */ + static getTransformedStyle(call: arkts.CallExpression): arkts.Expression[] { + const decl = arkts.getDecl(call.expression); + if (!decl || !arkts.isMethodDefinition(decl)) { + return [...call.arguments]; + } + const type: arkts.AstNode | undefined = arkts.isEtsParameterExpression(decl.scriptFunction.params[0]) + ? decl.scriptFunction.params[0].type + : undefined; + if ( + type && + arkts.isTypeNode(type) && + hasBindableProperty(type, BindableDecl.BINDABLE) && + isDoubleDollarCall(call.arguments[0]) + ) { + const bindableArg: arkts.Expression = (call.arguments[0] as arkts.CallExpression).arguments[0]; + return [factory.updateBindableStyleArguments(bindableArg), ...call.arguments.slice(1)]; + } + return [...call.arguments]; + } + + /* + * transform bundable arguments in style node, e.g. `Radio().checked($$(this.checked))` => `Radio().checked({value: xxx, onChange: xxx})`. + */ + static updateBindableStyleArguments(bindableArg: arkts.Expression): arkts.Expression { + const valueType: arkts.TypeNode = getDecalTypeFromValue(bindableArg); + const objExp: arkts.ObjectExpression = arkts.factory.createObjectExpression( + arkts.Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION, + [factory.generateValueProperty(bindableArg), factory.generateOnChangeArrowFunc(bindableArg, valueType)], + false + ); + return arkts.factory.createTSAsExpression(objExp, factory.createBindableType(valueType), false); + } + + /* + * create style instance call, e.g. `instance.margin(10)`. + */ + static createStyleLambdaBody(lambdaBody: arkts.AstNode, callInfo: InstanceCallInfo, projectConfig: ProjectConfig | undefined): arkts.CallExpression { + if (!callInfo.isReceiver) { + const newArgs: arkts.Expression[] = factory.getTransformedStyle(callInfo.call); + return arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + lambdaBody, + callInfo.call.expression, + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + newArgs.map((arg) => { + if (arkts.isArrowFunctionExpression(arg)) { + return this.processArgArrowFunction(arg, projectConfig); + } + return arg; + }) + ); + } else { + return arkts.factory.createCallExpression(callInfo.call.expression, callInfo.call.typeArguments, [ + lambdaBody, + ...callInfo.call.arguments.slice(1), + ]); + } + } + + /* + * update parameter passing, e.g. `: __backing_`. + */ + static updateBackingMember(val: arkts.MemberExpression, originName: string): arkts.MemberExpression { + return arkts.factory.updateMemberExpression( + val, + val.object, + arkts.factory.createIdentifier(backingField(originName)), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ); + } + + /* + * create style arguments in builder lambda. + */ + static createStyleArgInBuilderLambda( + lambdaBody: arkts.Expression | undefined, + typeNode: arkts.TypeNode | undefined + ): arkts.UndefinedLiteral | arkts.ArrowFunctionExpression { + if (!lambdaBody) { + return arkts.factory.createUndefinedLiteral(); + } + const safeType: arkts.TypeNode | undefined = isSafeType(typeNode) ? typeNode : undefined; + const styleLambdaParam: arkts.ETSParameterExpression = arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier(BuilderLambdaNames.STYLE_ARROW_PARAM_NAME, safeType), + undefined + ); + + const body: arkts.BlockStatement = arkts.factory.createBlock([ + arkts.factory.createExpressionStatement(lambdaBody), + arkts.factory.createReturnStatement(), + ]); + + const func = arkts.factory.createScriptFunction( + body, + arkts.FunctionSignature.createFunctionSignature( + undefined, + [styleLambdaParam], + arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID), + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC + ); + + return arkts.factory.createArrowFunction(func); + } + + /* + * create style arguments in builder lambda declaration. + */ + static createStyleArgInBuilderLambdaDecl( + typeNode: arkts.TypeNode | undefined, + isFunctionCall: boolean + ): arkts.ETSParameterExpression { + const styleLambdaParam: arkts.ETSParameterExpression = arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier(BuilderLambdaNames.STYLE_ARROW_PARAM_NAME, typeNode), + undefined + ); + const funcType = arkts.factory.createFunctionType( + arkts.FunctionSignature.createFunctionSignature( + undefined, + [styleLambdaParam], + arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID), + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW + ); + + let parameter: arkts.ETSParameterExpression; + if (isFunctionCall) { + parameter = arkts.factory + .createParameterDeclaration( + arkts.factory.createIdentifier(BuilderLambdaNames.STYLE_PARAM_NAME, funcType), + undefined + ) + .setOptional(true); + } else { + const optionalFuncType = arkts.factory.createUnionType([funcType, arkts.factory.createETSUndefinedType()]); + parameter = arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier(BuilderLambdaNames.STYLE_PARAM_NAME, optionalFuncType), + undefined + ); + } + parameter.annotations = [annotation('memo')]; + return parameter; + } + + /** + * If a builder lambda's argument is an arrow function, + * then transform any builder lambda in the function body. + */ + static processArgArrowFunction(arg: arkts.ArrowFunctionExpression, projectConfig: ProjectConfig | undefined): arkts.ArrowFunctionExpression { + const func: arkts.ScriptFunction = arg.scriptFunction; + const updateFunc = arkts.factory.updateScriptFunction( + func, + !!func.body && arkts.isBlockStatement(func.body) + ? arkts.factory.updateBlock( + func.body, + func.body.statements.map((st) => this.updateContentBodyInBuilderLambda(st, projectConfig)) + ) + : undefined, + arkts.FunctionSignature.createFunctionSignature( + func.typeParams, + func.params, + func.returnTypeAnnotation, + false + ), + func.flags, + func.modifiers + ); + return arkts.factory.updateArrowFunction(arg, updateFunc); + } + + /** + * transform options argument in a builder lambda call. + */ + static processOptionsArg(arg: T, typeName: string): T { + let expr: arkts.ObjectExpression | undefined; + if (arkts.isTSAsExpression(arg) && !!arg.expr && arkts.isObjectExpression(arg.expr)) { + expr = arg.expr; + } else if (arkts.isObjectExpression(arg)) { + expr = arg; + } + + if (!expr) { + return arg; + } + + const currentStructInfo: arkts.StructInfo = arkts.GlobalInfo.getInfoInstance().getStructInfo(typeName!); + const properties = expr.properties as arkts.Property[]; + properties.forEach((prop, index) => { + this.updateParameterPassingInLinkedProperties(prop, index, currentStructInfo, properties); + }); + const updatedExpr: arkts.ObjectExpression = arkts.ObjectExpression.updateObjectExpression( + expr, + arkts.Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION, + properties, + false + ); + if (arkts.isTSAsExpression(arg)) { + return arkts.TSAsExpression.updateTSAsExpression(arg, updatedExpr, arg.typeAnnotation, arg.isConst) as T; + } + return updatedExpr as T; + } + + /** + * update any `@Link` parameter passing to the custom-component child. + */ + static updateParameterPassingInLinkedProperties( + prop: arkts.Property, + index: number, + currentStructInfo: arkts.StructInfo, + properties: arkts.Property[] + ): void { + const decl = prop.key ? arkts.getDecl(prop.key) : undefined; + if (decl && arkts.isMethodDefinition(decl)) { + const type: arkts.TypeNode | undefined = decl.scriptFunction.returnTypeAnnotation; + if ( + type && + hasBindableProperty(type, BindableDecl.BINDABLE) && + arkts.isProperty(prop) && + prop.value && + isDoubleDollarCall(prop.value) + ) { + properties[index] = factory.updateBindableProperty(prop); + } + } + if ( + !!prop.key && + !!prop.value && + arkts.isIdentifier(prop.key) && + arkts.isMemberExpression(prop.value) && + arkts.isThisExpression(prop.value.object) && + arkts.isIdentifier(prop.value.property) + ) { + const structVariableMetadata = currentStructInfo.metadata[prop.key.name]; + if ( + structVariableMetadata && + structVariableMetadata.properties.length && + structVariableMetadata.properties.includes(DecoratorNames.LINK) + ) { + properties[index] = arkts.Property.updateProperty( + prop, + arkts.factory.createIdentifier(backingField(prop.key.name)), + this.updateBackingMember(prop.value, prop.value.property.name) + ); + } + } + } + + /** + * create or update arguments in a builder lambda call. + * If the corresponding argument is not provided, fill-in an `undefined` to it. + */ + static createOrUpdateArgInBuilderLambda( + arg: arkts.Expression | undefined, + projectConfig: ProjectConfig | undefined, + typeName?: string, + ): arkts.AstNode { + if (!arg) { + return arkts.factory.createUndefinedLiteral(); + } + if (arkts.isArrowFunctionExpression(arg)) { + return this.processArgArrowFunction(arg, projectConfig); + } + // this is too optimistic to check if this is an options argument... + if (arkts.isTSAsExpression(arg) || arkts.isObjectExpression(arg)) { + return this.processOptionsArg(arg, typeName!); + } + return arg; + } + + /** + * transform arguments in a builder lambda call. + */ + static generateArgsInBuilderLambda( + leaf: arkts.CallExpression, + lambdaBody: arkts.Identifier | arkts.CallExpression, + declInfo: BuilderLambdaDeclInfo, + projectConfig: ProjectConfig | undefined + ): (arkts.AstNode | undefined)[] { + const { params, returnType } = declInfo; + const typeName: string | undefined = builderLambdaTypeName(leaf); + const args: (arkts.AstNode | undefined)[] = [this.createStyleArgInBuilderLambda(lambdaBody, returnType)]; + let index = 0; + while (index < params.length) { + args.push(this.createOrUpdateArgInBuilderLambda(leaf.arguments.at(index), projectConfig, typeName)); + index++; + } + const isReusable: boolean = typeName + ? arkts.GlobalInfo.getInfoInstance().getStructInfo(typeName).isReusable : false; + if (isReusable) { + args.splice(-1, 1, arkts.factory.createStringLiteral(typeName!)); + } + else if (typeName === 'XComponent') { + let packageInfo: string = ''; + if (projectConfig?.bundleName && projectConfig?.moduleName) { + packageInfo = projectConfig?.bundleName + '/' + projectConfig?.moduleName; + } + args.splice(args.length - 1, 0, arkts.factory.createStringLiteral(packageInfo)); + } + return args; + } + + /** + * update if-else in trailing lambda contents in a builder lambda call. + */ + static updateIfElseContentBodyInBuilderLambda(statement: arkts.AstNode, projectConfig: ProjectConfig | undefined): arkts.AstNode { + if (arkts.isIfStatement(statement)) { + const alternate = !!statement.alternate + ? this.updateIfElseContentBodyInBuilderLambda(statement.alternate, projectConfig) + : statement.alternate; + const consequence = this.updateIfElseContentBodyInBuilderLambda(statement.consequent, projectConfig); + return arkts.factory.updateIfStatement(statement, statement.test, consequence!, alternate); + } + if (arkts.isBlockStatement(statement)) { + return arkts.factory.updateBlock( + statement, + statement.statements.map((st) => this.updateContentBodyInBuilderLambda(st, projectConfig)) + ); + } + return statement; + } + + /** + * update trailing lambda contents in a builder lambda call. + */ + static updateContentBodyInBuilderLambda(statement: arkts.Statement, projectConfig: ProjectConfig | undefined): arkts.Statement { + if ( + arkts.isExpressionStatement(statement) && + arkts.isCallExpression(statement.expression) && + isBuilderLambda(statement.expression) + ) { + return arkts.factory.updateExpressionStatement( + statement, + this.transformBuilderLambda(statement.expression, projectConfig) + ); + } + if (arkts.isIfStatement(statement)) { + return this.updateIfElseContentBodyInBuilderLambda(statement, projectConfig); + } + + return statement; + } + + /** + * replace function call's name to the corresponding transformed name. + */ + static builderLambdaReplace(leaf: arkts.CallExpression): arkts.Identifier | arkts.MemberExpression | undefined { + if (!callIsGoodForBuilderLambda(leaf)) { + return undefined; + } + const node = leaf.expression; + const funcName = builderLambdaFunctionName(leaf); + if (!funcName) { + return undefined; + } + if (arkts.isIdentifier(node)) { + return arkts.factory.createIdentifier(funcName); + } + if (arkts.isMemberExpression(node)) { + return arkts.factory.createMemberExpression( + node.object, + arkts.factory.createIdentifier(funcName), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + node.computed, + node.optional + ); + } + return undefined; + } + + /** + * transform `@ComponentBuilder` in declared methods. + */ + static transformBuilderLambdaMethodDecl(node: arkts.MethodDefinition): arkts.MethodDefinition { + const func: arkts.ScriptFunction = node.scriptFunction; + const isFunctionCall: boolean = isBuilderLambdaFunctionCall(node); + const typeNode: arkts.TypeNode | undefined = builderLambdaMethodDeclType(node); + const styleArg: arkts.ETSParameterExpression = this.createStyleArgInBuilderLambdaDecl(typeNode, isFunctionCall); + const newOverloads: arkts.MethodDefinition[] = node.overloads.map((method) => + factory.transformBuilderLambdaMethodDecl(method) + ); + + return this.updateBuilderLambdaMethodDecl( + node, + styleArg, + removeAnnotationByName(func.annotations, BuilderLambdaNames.ANNOTATION_NAME), + replaceBuilderLambdaDeclMethodName(node.name.name) + ).setOverloads(newOverloads); + } + + /** + * transform `.animation(...)` to `.animationStart(...) and .animationStop(...)` + */ + static updateAnimation(instanceCalls: InstanceCallInfo[]): void { + let lastAniIdx = 0; + let curIdx = 0; + + while (curIdx < instanceCalls.length) { + if (instanceCalls[curIdx].isReceiver) { + curIdx++; + continue; + } + const property: arkts.Identifier = instanceCalls[curIdx].call.expression as arkts.Identifier; + if (property.name === BuilderLambdaNames.ANIMATION_NAME) { + const aniStart: arkts.CallExpression = arkts.factory.createCallExpression( + arkts.factory.createIdentifier(BuilderLambdaNames.ANIMATION_START), + undefined, + instanceCalls[curIdx].call.arguments + ); + const aniStop: arkts.CallExpression = arkts.factory.createCallExpression( + arkts.factory.createIdentifier(BuilderLambdaNames.ANIMATION_STOP), + undefined, + instanceCalls[curIdx].call.arguments.map((arg) => arg.clone()) + ); + instanceCalls.splice(lastAniIdx, 0, { isReceiver: false, call: aniStart }); + instanceCalls[curIdx + 1] = { isReceiver: false, call: aniStop }; + curIdx += 2; + lastAniIdx = curIdx; + } else { + curIdx++; + } + } + } + + /** + * transform `@ComponentBuilder` in non-declared calls. + */ + static transformBuilderLambda(node: arkts.CallExpression, projectConfig: ProjectConfig | undefined): arkts.AstNode { + let instanceCalls: InstanceCallInfo[] = []; + let leaf: arkts.CallExpression = node; + + while (isStyleChainedCall(leaf) || isStyleWithReceiverCall(leaf)) { + if (isStyleChainedCall(leaf)) { + instanceCalls.push({ + isReceiver: false, + call: arkts.factory.createCallExpression( + (leaf.expression as arkts.MemberExpression).property, + leaf.typeArguments, + leaf.arguments + ), + }); + leaf = (leaf.expression as arkts.MemberExpression).object as arkts.CallExpression; + } + + if (isStyleWithReceiverCall(leaf)) { + instanceCalls.push({ + isReceiver: true, + call: arkts.factory.createCallExpression(leaf.expression, leaf.typeArguments, leaf.arguments), + }); + leaf = leaf.arguments[0] as arkts.CallExpression; + } + } + + const decl: arkts.AstNode | undefined = findBuilderLambdaDecl(leaf); + if (!decl) { + return node; + } + + const replace: arkts.Identifier | arkts.MemberExpression | undefined = this.builderLambdaReplace(leaf); + const declInfo: BuilderLambdaDeclInfo | undefined = findBuilderLambdaDeclInfo(decl); + if (!replace || !declInfo) { + return node; + } + + let lambdaBody: arkts.Identifier | arkts.CallExpression | undefined; + if (instanceCalls.length > 0) { + instanceCalls = instanceCalls.reverse(); + this.updateAnimation(instanceCalls); + lambdaBody = arkts.factory.createIdentifier(BuilderLambdaNames.STYLE_ARROW_PARAM_NAME); + instanceCalls.forEach((callInfo) => { + lambdaBody = this.createStyleLambdaBody(lambdaBody!, callInfo, projectConfig); + }); + } + + const args: (arkts.AstNode | undefined)[] = this.generateArgsInBuilderLambda(leaf, lambdaBody!, declInfo, projectConfig); + return arkts.factory.updateCallExpression(node, replace, leaf.typeArguments, filterDefined(args)); + } + + /* + * update bindableProperty, e.g. `text: $$(this.text)` => `text: { value: xxx , onChange: xxx }`. + */ + static updateBindableProperty(prop: arkts.Property, type?: arkts.TypeNode): arkts.Property { + let res: arkts.Property[] = []; + let valueType: arkts.TypeNode; + if ( + prop.value && + arkts.isCallExpression(prop.value) && + prop.value.arguments && + prop.value.arguments.length === 1 + ) { + let bindableArg = prop.value.arguments[0]; + valueType = getDecalTypeFromValue(bindableArg); + res.push( + factory.generateValueProperty(bindableArg), + factory.generateOnChangeArrowFunc(bindableArg, valueType) + ); + } else { + return prop; + } + const asObjProp: arkts.TSAsExpression = arkts.factory.createTSAsExpression( + arkts.ObjectExpression.createObjectExpression( + arkts.Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION, + res, + false + ), + factory.createBindableType(valueType), + false + ); + return arkts.factory.updateProperty(prop, prop.key, asObjProp); + } + + /* + * generate `value: ` in object. + */ + static generateValueProperty(bindableArg: arkts.Expression): arkts.Property { + return arkts.factory.createProperty(arkts.factory.createIdentifier('value'), bindableArg.clone()); + } + + /* + * generate `onChange: (value) => = value` in object. + */ + static generateOnChangeArrowFunc(bindableArg: arkts.Expression, valueType: arkts.TypeNode): arkts.Property { + return arkts.factory.createProperty( + arkts.factory.createIdentifier('onChange'), + PropertyFactory.createArrowFunctionWithParamsAndBody( + undefined, + [ + arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier('value', valueType.clone()), + undefined + ), + ], + undefined, + false, + [ + arkts.factory.createExpressionStatement( + arkts.factory.createAssignmentExpression( + bindableArg.clone(), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + arkts.factory.createIdentifier('value') + ) + ), + ] + ) + ); + } + + /* + * generate `Bindable`. + */ + static createBindableType(valueType: arkts.TypeNode): arkts.ETSTypeReference { + return arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier(BindableDecl.BINDABLE), + arkts.factory.createTSTypeParameterInstantiation([valueType.clone()]) + ) + ); + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/builder-lambda-translators/utils.ts b/ets1.2/arkui-plugins/ui-plugins/builder-lambda-translators/utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..f7cd7c6de5efde0ab140b172985a083a8641c13e --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/builder-lambda-translators/utils.ts @@ -0,0 +1,477 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { isAnnotation } from '../../common/arkts-utils'; +import { BuilderLambdaNames, Dollars } from '../utils'; + +export type BuilderLambdaDeclInfo = { + isFunctionCall: boolean; // isFunctionCall means it is from $_instantiate. + params: readonly arkts.Expression[]; + returnType: arkts.TypeNode | undefined; +}; + +export enum BindableDecl { + BINDABLE = 'Bindable', +} + +export type BuilderLambdaAstNode = arkts.ScriptFunction | arkts.ETSParameterExpression | arkts.FunctionDeclaration; + +export type InstanceCallInfo = { + isReceiver: boolean; + call: arkts.CallExpression; +}; + +/** + * Used in finding "XXX" in BuilderLambda("XXX") + * @deprecated + */ +export function builderLambdaArgumentName(annotation: arkts.AnnotationUsage): string | undefined { + if (!isBuilderLambdaAnnotation(annotation)) { + return undefined; + } + + const property = annotation.properties.at(0); + if (!property || !arkts.isClassProperty(property)) { + return undefined; + } + if (!property.value || !arkts.isStringLiteral(property.value)) { + return undefined; + } + + return property.value.str; +} + +/** + * Determine whether it is a custom component. + * + * @param node class declaration node + */ +export function isBuilderLambda(node: arkts.AstNode, isExternal?: boolean): boolean { + const builderLambdaCall: arkts.AstNode | undefined = getDeclForBuilderLambda(node); + if (!builderLambdaCall) { + return arkts.isCallExpression(node) && node.arguments.length > 0 && isBuilderLambda(node.arguments[0]); + } + return !!builderLambdaCall; +} + +/** + * Determine whether it is a function with receiver method definition. + * + * @param node method definition node + */ +export function isFunctionWithReceiver(node: arkts.MethodDefinition): boolean { + if (node.scriptFunction && arkts.isScriptFunction(node.scriptFunction)) { + return node.scriptFunction.hasReceiver; + } + return false; +} + +/** + * Determine whether it is a function with receiver call. + * + * @param node identifier node + */ +export function isFunctionWithReceiverCall(node: arkts.Identifier): boolean { + const decl: arkts.AstNode | undefined = arkts.getDecl(node); + if (decl && arkts.isMethodDefinition(decl)) { + return isFunctionWithReceiver(decl); + } + return false; +} + +/** + * Determine whether it is a style chained call. + * + * @param node call expression node + */ +export function isStyleChainedCall(node: arkts.CallExpression): boolean { + return ( + arkts.isMemberExpression(node.expression) && + arkts.isIdentifier(node.expression.property) && + arkts.isCallExpression(node.expression.object) + ); +} + +/** + * Determine whether it is a style function with receiver call. + * + * @param node call expression node + */ +export function isStyleWithReceiverCall(node: arkts.CallExpression): boolean { + return ( + arkts.isIdentifier(node.expression) && + isFunctionWithReceiverCall(node.expression) && + !!node.arguments.length && + arkts.isCallExpression(node.arguments[0]) + ); +} + +/** + * replace $_instantiate with _instantiateImpl. + * + * @param name origin name + */ +export function replaceBuilderLambdaDeclMethodName(name: string | undefined): string | undefined { + if (!!name && name === BuilderLambdaNames.ORIGIN_METHOD_NAME) { + return BuilderLambdaNames.TRANSFORM_METHOD_NAME; + } + return undefined; +} + +export function isBuilderLambdaMethodDecl(node: arkts.AstNode, isExternal?: boolean): boolean { + const builderLambdaMethodDecl: arkts.AstNode | undefined = getDeclForBuilderLambdaMethodDecl(node); + return !!builderLambdaMethodDecl; +} + +export function getDeclForBuilderLambdaMethodDecl( + node: arkts.AstNode, + isExternal?: boolean +): arkts.AstNode | undefined { + if (!node || !arkts.isMethodDefinition(node)) { + return undefined; + } + + const isBuilderLambda: boolean = !!node.name && isBuilderLambdaCall(node.name); + const isMethodDecl: boolean = + !!node.scriptFunction && + arkts.hasModifierFlag(node.scriptFunction, arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_DECLARE); + if (isBuilderLambda && isMethodDecl) { + return node; + } + return undefined; +} + +export function getDeclForBuilderLambda(node: arkts.AstNode, isExternal?: boolean): arkts.AstNode | undefined { + if (!node || !arkts.isCallExpression(node)) { + return undefined; + } + + let currNode: arkts.AstNode = node; + while ( + !!currNode && + arkts.isCallExpression(currNode) && + !!currNode.expression && + arkts.isMemberExpression(currNode.expression) + ) { + const _node: arkts.MemberExpression = currNode.expression; + + if (!!_node.property && arkts.isIdentifier(_node.property) && isBuilderLambdaCall(_node.property)) { + return node; + } + + if (!!_node.object && arkts.isCallExpression(_node.object) && isBuilderLambdaCall(_node.object)) { + return node; + } + + currNode = _node.object; + } + + if (isBuilderLambdaCall(node)) { + return node; + } + return undefined; +} + +export function isBuilderLambdaCall(node: arkts.CallExpression | arkts.Identifier): boolean { + const expr = arkts.isIdentifier(node) ? node : node.expression; + const decl = arkts.getDecl(expr); + + if (!decl) { + return false; + } + + if (arkts.isMethodDefinition(decl)) { + if (isFunctionWithReceiver(decl)) { + return ( + arkts.isCallExpression(node) && + node.arguments.length > 0 && + !!getDeclForBuilderLambda(node.arguments[0]) + ); + } + return isBuilderLambdaMethod(decl); + } + if (arkts.isFunctionExpression(decl)) { + return hasBuilderLambdaAnnotation(decl.scriptFunction); + } + return false; +} + +export function isBuilderLambdaMethod(node: arkts.MethodDefinition): boolean { + if (!node || !arkts.isMethodDefinition(node)) { + return false; + } + + const result = hasBuilderLambdaAnnotation(node.scriptFunction); + if (result) { + return true; + } + if (node.overloads.length > 0) { + return node.overloads.some(isBuilderLambdaMethod); + } + return false; +} + +export function hasBuilderLambdaAnnotation(node: BuilderLambdaAstNode): boolean { + return node.annotations.some(isBuilderLambdaAnnotation); +} + +export function isBuilderLambdaAnnotation(node: arkts.AnnotationUsage): boolean { + return isAnnotation(node, BuilderLambdaNames.ANNOTATION_NAME); +} + +export function findBuilderLambdaAnnotation( + node: arkts.ScriptFunction | arkts.ETSParameterExpression +): arkts.AnnotationUsage | undefined { + return node.annotations.find(isBuilderLambdaAnnotation); +} + +export function findBuilderLambdaInMethod(node: arkts.MethodDefinition): arkts.AnnotationUsage | undefined { + if (!node || !arkts.isMethodDefinition(node)) { + return undefined; + } + const result = findBuilderLambdaAnnotation(node.scriptFunction); + if (!!result) { + return result; + } + node.overloads.forEach((overload) => { + const anno: arkts.AnnotationUsage | undefined = findBuilderLambdaInMethod(overload); + if (!!anno) { + return anno; + } + }); + return undefined; +} + +export function findBuilderLambdaInCall( + node: arkts.CallExpression | arkts.Identifier +): arkts.AnnotationUsage | undefined { + const decl = findBuilderLambdaDecl(node); + if (!decl) { + return undefined; + } + + if (arkts.isMethodDefinition(decl)) { + return findBuilderLambdaInMethod(decl); + } + if (arkts.isFunctionExpression(decl)) { + return findBuilderLambdaAnnotation(decl.scriptFunction); + } + return undefined; +} + +export function findBuilderLambdaDecl(node: arkts.CallExpression | arkts.Identifier): arkts.AstNode | undefined { + const expr = arkts.isIdentifier(node) ? node : node.expression; + const decl = arkts.getDecl(expr); + if (!decl) { + return undefined; + } + return decl; +} + +/** + * check whether `` is the passing parameter. + * + * @param name origin name + */ +export function isParameterPassing(prop: arkts.Property): boolean | undefined { + return ( + prop.key && + prop.value && + arkts.isIdentifier(prop.key) && + arkts.isMemberExpression(prop.value) && + arkts.isThisExpression(prop.value.object) && + arkts.isIdentifier(prop.value.property) + ); +} + +export function findBuilderLambdaDeclInfo(decl: arkts.AstNode | undefined): BuilderLambdaDeclInfo | undefined { + if (!decl) { + return undefined; + } + + if (arkts.isMethodDefinition(decl)) { + const params = decl.scriptFunction.params.map((p) => p.clone()); + const returnType = decl.scriptFunction.returnTypeAnnotation?.clone(); + const isFunctionCall = isBuilderLambdaFunctionCall(decl); + return { isFunctionCall, params, returnType }; + } + + return undefined; +} + +export function isBuilderLambdaFunctionCall(decl: arkts.AstNode | undefined): boolean { + if (!decl) { + return false; + } + if (arkts.isMethodDefinition(decl)) { + return ( + decl.name.name !== BuilderLambdaNames.ORIGIN_METHOD_NAME && + decl.name.name !== BuilderLambdaNames.TRANSFORM_METHOD_NAME + ); + } + return false; +} + +export function callIsGoodForBuilderLambda(leaf: arkts.CallExpression): boolean { + const node = leaf.expression; + return arkts.isIdentifier(node) || arkts.isMemberExpression(node); +} + +export function isSafeType(type: arkts.TypeNode | undefined): boolean { + if (!type) { + return false; + } + // type can be generic (not safe) if includes any type params in a type reference. + if (arkts.isETSTypeReference(type) && !!type.part && !!type.part.typeParams) { + return false; + } + return true; +} + +export function builderLambdaMethodDeclType(method: arkts.MethodDefinition): arkts.TypeNode | undefined { + if (!method || !method.scriptFunction) { + return undefined; + } + return method.scriptFunction.returnTypeAnnotation; +} + +export function builderLambdaTypeName(leaf: arkts.CallExpression): string | undefined { + if (!callIsGoodForBuilderLambda(leaf)) { + return undefined; + } + const node = leaf.expression; + let name: string | undefined; + if (arkts.isIdentifier(node)) { + name = node.name; + } + if (arkts.isMemberExpression(node) && arkts.isIdentifier(node.object)) { + name = node.object.name; + } + return name; +} + +export function builderLambdaFunctionName(node: arkts.CallExpression): string | undefined { + const annotation = findBuilderLambdaInCall(node); + if (!annotation) { + return undefined; + } + if (arkts.isIdentifier(node.expression)) { + return node.expression.name; + } + if ( + arkts.isMemberExpression(node.expression) && + arkts.isIdentifier(node.expression.property) && + node.expression.property.name === BuilderLambdaNames.ORIGIN_METHOD_NAME + ) { + return BuilderLambdaNames.TRANSFORM_METHOD_NAME; + } + return undefined; +} + +/** + * Determine whether the node `` is `` bindable property. + * + * @param type type node + * @param bindableDecl bindable decalaration name + */ +export function hasBindableProperty(type: arkts.AstNode, bindableDecl: BindableDecl): boolean { + let res: boolean = false; + if (arkts.isETSUnionType(type)) { + type.types.forEach((item: arkts.TypeNode) => { + res = res || hasBindableProperty(item, bindableDecl); + }); + } + if (arkts.isETSTypeReference(type)) { + res = + res || + (!!type.part && + !!type.part.name && + arkts.isIdentifier(type.part.name) && + type.part.name.name === bindableDecl); + } + + return res; +} + +/** + * Determine whether `` is `$$()` call expression node. + * + * @param value expression node + */ +export function isDoubleDollarCall(value: arkts.Expression): boolean { + if ( + arkts.isCallExpression(value) && + value.expression && + arkts.isIdentifier(value.expression) && + value.expression.name + ) { + return value.expression.name === Dollars.DOLLAR_DOLLAR; + } + return false; +} + +/** + * get declaration type from `{xxx: }` or `fun()`. + * + * @param value type node + */ +export function getDecalTypeFromValue(value: arkts.Expression): arkts.TypeNode { + const decl: arkts.AstNode | undefined = arkts.getDecl(value); + if (!decl || !arkts.isClassProperty(decl)) { + throw new Error('cannot get declaration'); + } + if (isArrayType(decl.typeAnnotation!)) { + return getElementTypeFromArray(decl.typeAnnotation!)!; + } + return decl.typeAnnotation!; +} + +/** + * Determine whether `` is array type, e.g. `xxx[]` or `Array`. + * + * @param type type node + */ +export function isArrayType(type: arkts.TypeNode): boolean { + return ( + arkts.isTSArrayType(type) || + (arkts.isETSTypeReference(type) && + !!type.part && + arkts.isETSTypeReferencePart(type.part) && + !!type.part.name && + arkts.isIdentifier(type.part.name) && + type.part.name.name === 'Array') + ); +} + +/** + * get element type from array type node ``. + * + * @param arrayType array type node + */ +export function getElementTypeFromArray(arrayType: arkts.TypeNode): arkts.TypeNode | undefined { + if (arkts.isTSArrayType(arrayType)) { + return arrayType.elementType?.clone(); + } else if ( + arkts.isETSTypeReference(arrayType) && + !!arrayType.part && + arkts.isETSTypeReferencePart(arrayType.part) && + !!arrayType.part.typeParams && + arrayType.part.typeParams.params.length + ) { + return arrayType.part.typeParams.params[0].clone(); + } + return undefined; +} diff --git a/ets1.2/arkui-plugins/ui-plugins/checked-transformer.ts b/ets1.2/arkui-plugins/ui-plugins/checked-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..eddd49be3dcbc46a045237c6deaf0c30de0563d1 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/checked-transformer.ts @@ -0,0 +1,472 @@ +/* + * 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 { ProjectConfig } from '../common/plugin-context'; +import { factory as structFactory } from './struct-translators/factory'; +import { factory as builderLambdaFactory } from './builder-lambda-translators/factory'; +import { factory as uiFactory } from './ui-factory'; +import { factory as entryFactory } from './entry-translators/factory'; +import { AbstractVisitor } from '../common/abstract-visitor'; +import { annotation, collect, filterDefined } from '../common/arkts-utils'; +import { + CustomComponentNames, + getCustomComponentOptionsName, + getTypeNameFromTypeParameter, + getTypeParamsFromClassDecl, + getGettersFromClassDecl, + addMemoAnnotation, +} from './utils'; +import { hasDecorator, DecoratorNames } from './property-translators/utils'; +import { + isCustomComponentClass, + isKnownMethodDefinition, + isEtsGlobalClass, + isReourceNode, + ScopeInfoCollection, + CustomComponentScopeInfo, + isMemoCall, + findCanAddMemoFromArrowFunction, +} from './struct-translators/utils'; +import { isBuilderLambda, isBuilderLambdaMethodDecl } from './builder-lambda-translators/utils'; +import { isEntryWrapperClass } from './entry-translators/utils'; +import { classifyObservedTrack, classifyProperty, PropertyTranslator } from './property-translators'; +import { ObservedTrackTranslator } from './property-translators/observedTrack'; +import { nodeByType } from '@koalaui/libarkts/build/src/reexport-for-generated'; +import { isArkUICompatible, updateArkUICompatible } from './interop'; + +export class CheckedTransformer extends AbstractVisitor { + private scopeInfoCollection: ScopeInfoCollection; + projectConfig: ProjectConfig | undefined; + + constructor(projectConfig: ProjectConfig | undefined) { + super(); + this.projectConfig = projectConfig; + this.scopeInfoCollection = { customComponents: [] }; + } + + reset(): void { + super.reset(); + this.scopeInfoCollection = { customComponents: [] }; + } + + enter(node: arkts.AstNode): void { + if (arkts.isClassDeclaration(node) && isCustomComponentClass(node)) { + this.scopeInfoCollection.customComponents.push({ name: node.definition!.ident!.name }); + } + if (arkts.isMethodDefinition(node) && this.scopeInfoCollection.customComponents.length > 0) { + const name = node.name.name; + const scopeInfo = this.scopeInfoCollection.customComponents.pop()!; + scopeInfo.hasInitializeStruct ||= name === CustomComponentNames.COMPONENT_INITIALIZE_STRUCT; + scopeInfo.hasUpdateStruct ||= name === CustomComponentNames.COMPONENT_UPDATE_STRUCT; + scopeInfo.hasReusableRebind ||= name === CustomComponentNames.REUSABLE_COMPONENT_REBIND_STATE; + this.scopeInfoCollection.customComponents.push(scopeInfo); + } + } + + exit(node: arkts.AstNode): void { + if (arkts.isClassDeclaration(node) && isCustomComponentClass(node)) { + this.scopeInfoCollection.customComponents.pop(); + } + } + + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + this.enter(beforeChildren); + if (arkts.isCallExpression(beforeChildren) && isBuilderLambda(beforeChildren)) { + const lambda = builderLambdaFactory.transformBuilderLambda(beforeChildren, this.projectConfig); + return this.visitEachChild(lambda); + } else if (arkts.isMethodDefinition(beforeChildren) && isBuilderLambdaMethodDecl(beforeChildren)) { + const lambda = builderLambdaFactory.transformBuilderLambdaMethodDecl(beforeChildren); + return this.visitEachChild(lambda); + } + const node = this.visitEachChild(beforeChildren); + if (arkts.isClassDeclaration(node) && isCustomComponentClass(node)) { + let scope: CustomComponentScopeInfo | undefined; + const scopeInfos: CustomComponentScopeInfo[] = this.scopeInfoCollection.customComponents; + if (scopeInfos.length > 0) { + scope = scopeInfos[scopeInfos.length - 1]; + } + const newClass: arkts.ClassDeclaration = tranformClassMembers( + node, + arkts.hasModifierFlag(node, arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_DECLARE), + scope + ); + this.exit(beforeChildren); + return newClass; + } else if (isEntryWrapperClass(node)) { + entryFactory.addMemoToEntryWrapperClassMethods(node); + return node; + } else if (arkts.isClassDeclaration(node) && isEtsGlobalClass(node)) { + return transformEtsGlobalClassMembers(node); + } else if (arkts.isCallExpression(node) && isReourceNode(node)) { + return transformResource(node, this.projectConfig); + } else if (findCanAddMemoFromArrowFunction(node)) { + return addMemoAnnotation(node); + } else if (arkts.isClassDeclaration(node)) { + return transformObservedTracked(node); + } else if (isArkUICompatible(node)) { + return updateArkUICompatible(node as arkts.CallExpression); + } else if (this.externalSourceName) { + return structFactory.transformExternalSource(this.externalSourceName, node); + } + return node; + } +} + +export type ClassScopeInfo = { + isObserved: boolean; + classHasTrack: boolean; + getters: arkts.MethodDefinition[]; +}; + +function transformObservedTracked(node: arkts.ClassDeclaration): arkts.ClassDeclaration { + if (!node.definition) { + return node; + } + const isObserved: boolean = hasDecorator(node.definition, DecoratorNames.OBSERVED); + const classHasTrack: boolean = node.definition.body.some( + (member) => arkts.isClassProperty(member) && hasDecorator(member, DecoratorNames.TRACK) + ); + if (!isObserved && !classHasTrack) { + return node; + } + + const updateClassDef: arkts.ClassDefinition = arkts.factory.updateClassDefinition( + node.definition, + node.definition.ident, + node.definition.typeParams, + node.definition.superTypeParams, + [ + ...node.definition.implements, + arkts.TSClassImplements.createTSClassImplements( + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier('IObservedObject')) + ) + ), + ], + undefined, + node.definition.super, + observedTrackPropertyMembers(classHasTrack, node.definition, isObserved), + node.definition.modifiers, + arkts.classDefinitionFlags(node.definition) + ); + return arkts.factory.updateClassDeclaration(node, updateClassDef); +} + +function observedTrackPropertyMembers( + classHasTrack: boolean, + definition: arkts.ClassDefinition, + isObserved: boolean +): arkts.AstNode[] { + const watchMembers: arkts.AstNode[] = createWatchMembers(); + const permissibleAddRefDepth: arkts.ClassProperty = arkts.factory.createClassProperty( + arkts.factory.createIdentifier('_permissibleAddRefDepth'), + arkts.factory.createNumericLiteral(0), + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier('int32')) + ), + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC, + false + ); + + const meta: arkts.ClassProperty = arkts.factory.createClassProperty( + arkts.factory.createIdentifier('__meta'), + arkts.factory.createETSNewClassInstanceExpression( + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier('MutableStateMeta')) + ), + [arkts.factory.createStringLiteral('@Observe properties (no @Track)')] + ), + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier('MutableStateMeta')) + ), + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE, + false + ); + + const getters: arkts.MethodDefinition[] = getGettersFromClassDecl(definition); + + const classScopeInfo: ClassScopeInfo = { + isObserved: isObserved, + classHasTrack: classHasTrack, + getters: getters, + }; + + const propertyTranslators: ObservedTrackTranslator[] = filterDefined( + definition.body.map((it) => classifyObservedTrack(it, classScopeInfo)) + ); + + const propertyMembers = propertyTranslators.map((translator) => translator.translateMember()); + + const nonClassPropertyOrGetter: arkts.AstNode[] = definition.body.filter( + (member) => + !arkts.isClassProperty(member) && + !( + arkts.isMethodDefinition(member) && + arkts.hasModifierFlag(member, arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_GETTER) + ) + ); + + return [ + ...watchMembers, + ...(classHasTrack ? [permissibleAddRefDepth] : [permissibleAddRefDepth, meta]), + ...collect(...propertyMembers), + ...nonClassPropertyOrGetter, + ...classScopeInfo.getters, + ]; +} + +function createWatchMethod( + methodName: string, + returnType: arkts.Es2pandaPrimitiveType, + paramName: string, + paramType: string, + isReturnStatement: boolean +): arkts.MethodDefinition { + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD, + arkts.factory.createIdentifier(methodName), + arkts.factory.createScriptFunction( + arkts.factory.createBlock([ + isReturnStatement + ? arkts.factory.createReturnStatement( + arkts.factory.createCallExpression(thisSubscribedWatchesMember(methodName), undefined, [ + arkts.factory.createIdentifier(paramName), + ]) + ) + : arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression(thisSubscribedWatchesMember(methodName), undefined, [ + arkts.factory.createIdentifier(paramName), + ]) + ), + ]), + arkts.factory.createFunctionSignature( + undefined, + [ + arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier( + paramName, + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier(paramType)) + ) + ), + undefined + ), + ], + arkts.factory.createPrimitiveType(returnType), + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_METHOD, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC + ), + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC, + false + ); +} + +function createWatchMembers(): arkts.AstNode[] { + const subscribedWatches: arkts.ClassProperty = arkts.factory.createClassProperty( + arkts.factory.createIdentifier('subscribedWatches'), + arkts.factory.createETSNewClassInstanceExpression( + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier('SubscribedWatches')) + ), + [] + ), + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier('SubscribedWatches')) + ), + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE, + false + ); + + const addWatchSubscriber = createWatchMethod( + 'addWatchSubscriber', + arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID, + 'watchId', + 'WatchIdType', + false + ); + + const removeWatchSubscriber = createWatchMethod( + 'removeWatchSubscriber', + arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_BOOLEAN, + 'watchId', + 'WatchIdType', + true + ); + + const executeOnSubscribingWatches = createWatchMethod( + 'executeOnSubscribingWatches', + arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID, + 'propertyName', + 'string', + false + ); + + return [subscribedWatches, addWatchSubscriber, removeWatchSubscriber, executeOnSubscribingWatches]; +} + +function thisSubscribedWatchesMember(member: string): arkts.MemberExpression { + return arkts.factory.createMemberExpression( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier('subscribedWatches'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + arkts.factory.createIdentifier(member), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ); +} + +/** + * @deprecated + */ +function tranformClassMembers( + node: arkts.ClassDeclaration, + isDecl?: boolean, + scope?: CustomComponentScopeInfo +): arkts.ClassDeclaration { + if (!node.definition) { + return node; + } + + let classTypeName: string | undefined; + let classOptionsName: string | undefined; + if (isDecl) { + const [classType, classOptions] = getTypeParamsFromClassDecl(node); + classTypeName = getTypeNameFromTypeParameter(classType); + classOptionsName = getTypeNameFromTypeParameter(classOptions); + } + const definition: arkts.ClassDefinition = node.definition; + const className: string | undefined = node.definition.ident?.name; + if (!className) { + throw new Error('Non Empty className expected for Component'); + } + + const propertyTranslators: PropertyTranslator[] = filterDefined( + definition.body.map((it) => classifyProperty(it, className)) + ); + const translatedMembers: arkts.AstNode[] = tranformPropertyMembers( + className, + propertyTranslators, + classOptionsName ?? getCustomComponentOptionsName(className), + isDecl, + scope + ); + const updateMembers: arkts.AstNode[] = definition.body + .filter((member) => !arkts.isClassProperty(member)) + .map((member: arkts.AstNode) => + transformOtherMembersInClass(member, classTypeName, classOptionsName, className, isDecl) + ); + + const updateClassDef: arkts.ClassDefinition = structFactory.updateCustomComponentClass(definition, [ + ...translatedMembers, + ...updateMembers, + ]); + return arkts.factory.updateClassDeclaration(node, updateClassDef); +} + +/** + * @deprecated + */ +function transformOtherMembersInClass( + member: arkts.AstNode, + classTypeName: string | undefined, + classOptionsName: string | undefined, + className: string, + isDecl?: boolean +): arkts.AstNode { + if (arkts.isMethodDefinition(member) && hasDecorator(member, DecoratorNames.BUILDER)) { + member.scriptFunction.setAnnotations([annotation('memo')]); + return member; + } + if ( + arkts.isMethodDefinition(member) && + isKnownMethodDefinition(member, CustomComponentNames.COMPONENT_CONSTRUCTOR_ORI) && + !isDecl + ) { + return uiFactory.createConstructorMethod(member); + } + if (arkts.isMethodDefinition(member) && isKnownMethodDefinition(member, CustomComponentNames.COMPONENT_BUILD_ORI)) { + return structFactory.transformBuildMethodWithOriginBuild( + member, + classTypeName ?? className, + classOptionsName ?? getCustomComponentOptionsName(className), + isDecl + ); + } + return member; +} + +/** + * @deprecated + */ +function tranformPropertyMembers( + className: string, + propertyTranslators: PropertyTranslator[], + optionsTypeName: string, + isDecl?: boolean, + scope?: CustomComponentScopeInfo +): arkts.AstNode[] { + const propertyMembers = propertyTranslators.map((translator) => translator.translateMember()); + const currentStructInfo: arkts.StructInfo = arkts.GlobalInfo.getInfoInstance().getStructInfo(className); + const collections = []; + if (!scope?.hasInitializeStruct) { + collections.push(structFactory.createInitializeStruct(currentStructInfo, optionsTypeName, isDecl)); + } + if (!scope?.hasUpdateStruct) { + collections.push(structFactory.createUpdateStruct(currentStructInfo, optionsTypeName, isDecl)); + } + if (currentStructInfo.isReusable) { + collections.push(structFactory.toRecord(optionsTypeName, currentStructInfo.toRecordBody)); + } + return collect(...collections, ...propertyMembers); +} + +/** + * @deprecated + */ +function transformEtsGlobalClassMembers(node: arkts.ClassDeclaration): arkts.ClassDeclaration { + if (!node.definition) { + return node; + } + node.definition.body.map((member: arkts.AstNode) => { + if (arkts.isMethodDefinition(member) && hasDecorator(member, DecoratorNames.BUILDER)) { + member.scriptFunction.setAnnotations([annotation('memo')]); + } + return member; + }); + return node; +} + +/** + * @deprecated + */ +function transformResource( + resourceNode: arkts.CallExpression, + projectConfig: ProjectConfig | undefined +): arkts.CallExpression { + const newArgs: arkts.AstNode[] = [ + arkts.factory.create1StringLiteral(projectConfig?.bundleName ? projectConfig.bundleName : ''), + arkts.factory.create1StringLiteral(projectConfig?.moduleName ? projectConfig.moduleName : ''), + ...resourceNode.arguments, + ]; + return structFactory.generateTransformedResource(resourceNode, newArgs); +} diff --git a/ets1.2/arkui-plugins/ui-plugins/component-transformer.ts b/ets1.2/arkui-plugins/ui-plugins/component-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..46c7bfbf214585cc1a644848df14634856bf405e --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/component-transformer.ts @@ -0,0 +1,430 @@ +/* + * 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 { getInteropPath } from '../path'; +const interop = require(getInteropPath()); +const nullptr = interop.nullptr; +import { AbstractVisitor, VisitorOptions } from '../common/abstract-visitor'; +import { + CustomComponentNames, + getCustomComponentOptionsName, + createOptionalClassProperty, + findLocalImport, +} from './utils'; +import { isAnnotation, updateStructMetadata, backingField, expectName, annotation } from '../common/arkts-utils'; +import { EntryWrapperNames, findEntryWithStorageInClassAnnotations } from './entry-translators/utils'; +import { factory as entryFactory } from './entry-translators/factory'; +import { + hasDecorator, + DecoratorNames, + getStateManagementType, + collectPropertyDecorators, +} from './property-translators/utils'; +import { factory } from './ui-factory'; +import { StructMap } from '../common/program-visitor'; +import { generateTempCallFunction } from './interop'; +import { stringify } from 'querystring'; + +export interface ComponentTransformerOptions extends VisitorOptions { + arkui?: string; +} + +type ScopeInfo = { + name: string; + isEntry?: boolean; + isComponent?: boolean; + isReusable?: boolean; +}; + +interface ComponentContext { + structMembers: Map; +} + +export interface InteropContext { + className: string; + path: string; + line?: number; + col?: number; + arguments?: arkts.ObjectExpression; +} + +export class ComponentTransformer extends AbstractVisitor { + private scopeInfos: ScopeInfo[] = []; + private componentInterfaceCollection: arkts.TSInterfaceDeclaration[] = []; + private entryNames: string[] = []; + private reusableNames: string[] = []; + private readonly arkui?: string; + private context: ComponentContext = { structMembers: new Map() }; + private isCustomComponentImported: boolean = false; + private isEntryPointImported: boolean = false; + private hasLegacy = false; + private legacyStructMap: Map = new Map(); + private legacyCallMap: Map = new Map(); + + constructor(options?: ComponentTransformerOptions) { + const _options: ComponentTransformerOptions = options ?? {}; + super(_options); + this.arkui = _options.arkui; + } + + reset(): void { + super.reset(); + this.scopeInfos = []; + this.componentInterfaceCollection = []; + this.entryNames = []; + this.reusableNames = []; + this.context = { structMembers: new Map() }; + this.isCustomComponentImported = false; + this.isEntryPointImported = false; + this.hasLegacy = false; + this.legacyStructMap = new Map(); + this.legacyCallMap = new Map(); + } + + enter(node: arkts.AstNode) { + if (arkts.isStructDeclaration(node) && !!node.definition.ident) { + const scopeInfo: ScopeInfo = { name: node.definition.ident.name }; + node.definition.annotations.forEach((anno) => { + scopeInfo.isEntry ||= isAnnotation(anno, CustomComponentNames.ENTRY_ANNOTATION_NAME); + scopeInfo.isComponent ||= isAnnotation(anno, CustomComponentNames.COMPONENT_ANNOTATION_NAME); + scopeInfo.isReusable ||= isAnnotation(anno, CustomComponentNames.RESUABLE_ANNOTATION_NAME); + }); + this.scopeInfos.push(scopeInfo); + } + if (arkts.isETSImportDeclaration(node) && !this.isCustomComponentImported) { + this.isCustomComponentImported = !!findLocalImport( + node, + CustomComponentNames.COMPONENT_DEFAULT_IMPORT, + CustomComponentNames.COMPONENT_CLASS_NAME + ); + } + if (arkts.isETSImportDeclaration(node) && !this.isEntryPointImported) { + this.isEntryPointImported = !!findLocalImport( + node, + EntryWrapperNames.ENTRY_DEFAULT_IMPORT, + EntryWrapperNames.ENTRY_POINT_CLASS_NAME + ); + } + } + + exit(node: arkts.AstNode) { + if (arkts.isStructDeclaration(node) || arkts.isClassDeclaration(node)) { + if (!node.definition || !node.definition.ident || this.scopeInfos.length === 0) return; + if (this.scopeInfos[this.scopeInfos.length - 1]?.name === node.definition.ident.name) { + this.scopeInfos.pop(); + } + } + } + + isComponentStruct(): boolean { + if (this.scopeInfos.length === 0) return false; + const scopeInfo: ScopeInfo = this.scopeInfos[this.scopeInfos.length - 1]; + return !!scopeInfo.isComponent; + } + + createImportDeclaration(): void { + const source: arkts.StringLiteral = arkts.factory.create1StringLiteral( + this.arkui ?? CustomComponentNames.COMPONENT_DEFAULT_IMPORT + ); + const imported: arkts.Identifier = arkts.factory.createIdentifier(CustomComponentNames.COMPONENT_CLASS_NAME); + // Insert this import at the top of the script's statements. + if (!this.program) { + throw Error('Failed to insert import: Transformer has no program'); + } + factory.createAndInsertImportDeclaration( + source, + imported, + imported, + arkts.Es2pandaImportKinds.IMPORT_KINDS_VALUE, + this.program + ); + } + + processEtsScript(node: arkts.EtsScript): arkts.EtsScript { + if (this.isExternal && this.componentInterfaceCollection.length === 0 && this.entryNames.length === 0) { + return node; + } + let updateStatements: arkts.AstNode[] = []; + if (this.componentInterfaceCollection.length > 0) { + if (!this.isCustomComponentImported) this.createImportDeclaration(); + updateStatements.push(...this.componentInterfaceCollection); + } + + if (this.entryNames.length > 0) { + if (!this.isEntryPointImported) entryFactory.createAndInsertEntryPointImport(this.program); + // TODO: normally, we should only have at most one @Entry component in a single file. + // probably need to handle error message here. + updateStatements.push(...this.entryNames.map(entryFactory.generateEntryWrapper)); + } + if (updateStatements.length > 0) { + return arkts.factory.updateEtsScript(node, [...node.statements, ...updateStatements]); + } + return node; + } + + createStaticMethod(definition: arkts.ClassDefinition): arkts.MethodDefinition { + const param: arkts.ETSParameterExpression = arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier( + CustomComponentNames.OPTIONS, + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier(getCustomComponentOptionsName(definition.ident!.name)) + ) + ) + ), + undefined + ); + + const script = arkts.factory.createScriptFunction( + arkts.factory.createBlock([arkts.factory.createReturnStatement()]), + arkts.FunctionSignature.createFunctionSignature( + undefined, + [param], + arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID), + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_METHOD, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC | arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_STATIC + ); + + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD, + arkts.factory.createIdentifier(CustomComponentNames.BUILDCOMPATIBLENODE), + script, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC | arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_STATIC, + false + ); + } + + processComponent( + node: arkts.ClassDeclaration | arkts.StructDeclaration + ): arkts.ClassDeclaration | arkts.StructDeclaration { + const scopeInfo = this.scopeInfos[this.scopeInfos.length - 1]; + const className = node.definition?.ident?.name; + if (!className || scopeInfo?.name !== className) { + return node; + } + + arkts.GlobalInfo.getInfoInstance().add(className); + + if (arkts.isStructDeclaration(node)) { + this.collectComponentMembers(node, className); + } + + if (scopeInfo.isReusable) { + const currentStructInfo: arkts.StructInfo = arkts.GlobalInfo.getInfoInstance().getStructInfo(className); + currentStructInfo.isReusable = true; + arkts.GlobalInfo.getInfoInstance().setStructInfo(className, currentStructInfo); + } + + this.componentInterfaceCollection.push(this.generateComponentInterface(className, node.modifiers)); + + const definition: arkts.ClassDefinition = node.definition!; + const newDefinitionBody: arkts.AstNode[] = []; + if (scopeInfo.isEntry) { + this.entryNames.push(className); + const entryWithStorage: arkts.ClassProperty | undefined = + findEntryWithStorageInClassAnnotations(definition); + if (!!entryWithStorage) { + newDefinitionBody.push(entryFactory.createEntryLocalStorageInClass(entryWithStorage)); + } + } + const newDefinition: arkts.ClassDefinition = this.createNewDefinition( + node, + className, + definition, + newDefinitionBody + ); + + if (arkts.isStructDeclaration(node)) { + const _node = arkts.factory.createClassDeclaration(newDefinition); + _node.modifiers = node.modifiers; + return _node; + } else { + return arkts.factory.updateClassDeclaration(node, newDefinition); + } + } + + createNewDefinition( + node: arkts.ClassDeclaration | arkts.StructDeclaration, + className: string, + definition: arkts.ClassDefinition, + newDefinitionBody: arkts.AstNode[] + ): arkts.ClassDefinition { + const staticMethodBody: arkts.AstNode[] = []; + const hasExportFlag = + (node.modifiers & arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_EXPORT) === + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_EXPORT; + if (hasExportFlag) { + const buildCompatibleNode: arkts.MethodDefinition = this.createStaticMethod(definition); + if (!!buildCompatibleNode) { + staticMethodBody.push(buildCompatibleNode); + } + } + return arkts.factory.updateClassDefinition( + definition, + definition.ident, + undefined, + undefined, // superTypeParams doen't work + definition.implements, + undefined, + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier(CustomComponentNames.COMPONENT_CLASS_NAME), + arkts.factory.createTSTypeParameterInstantiation([ + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier(className)) + ), + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier( + `${CustomComponentNames.COMPONENT_INTERFACE_PREFIX}${className}` + ) + ) + ), + ]) + ) + ), + [ + ...newDefinitionBody, + ...definition.body.map((st: arkts.AstNode) => factory.PreprocessClassPropertyModifier(st)), + ...staticMethodBody, + ], + definition.modifiers, + arkts.classDefinitionFlags(definition) | arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_FINAL + ); + } + + generateComponentInterface(name: string, modifiers: number): arkts.TSInterfaceDeclaration { + const interfaceNode = arkts.factory.createInterfaceDeclaration( + [], + arkts.factory.createIdentifier(getCustomComponentOptionsName(name)), + nullptr, // TODO: wtf + arkts.factory.createInterfaceBody([...(this.context.structMembers.get(name) || [])]), + false, + false + ); + interfaceNode.modifiers = modifiers; + return interfaceNode; + } + + collectComponentMembers(node: arkts.StructDeclaration, className: string): void { + const structInfo: arkts.StructInfo = arkts.GlobalInfo.getInfoInstance().getStructInfo(className); + if (!this.context.structMembers.has(className)) { + this.context.structMembers.set(className, []); + } + node.definition.body.map((it) => { + if (arkts.isClassProperty(it)) { + if (hasDecorator(it, DecoratorNames.PROVIDE)) { + factory.processNoAliasProvideVariable(it); + } + this.context.structMembers.get(className)!.push(...this.createInterfaceInnerMember(it, structInfo)); + } + }); + arkts.GlobalInfo.getInfoInstance().setStructInfo(className, structInfo); + } + + createInterfaceInnerMember(member: arkts.ClassProperty, structInfo: arkts.StructInfo): arkts.ClassProperty[] { + const originalName: string = expectName(member.key); + const newName: string = backingField(originalName); + + const properties = collectPropertyDecorators(member); + const hasStateManagementType = properties.length > 0; + updateStructMetadata(structInfo, originalName, properties, member.modifiers, hasStateManagementType); + + const originMember: arkts.ClassProperty = createOptionalClassProperty( + originalName, + member, + '', + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC + ); + if (member.annotations.length > 0 && !hasDecorator(member, DecoratorNames.BUILDER_PARAM)) { + const newMember: arkts.ClassProperty = createOptionalClassProperty( + newName, + member, + getStateManagementType(member), + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC + ); + return [originMember, newMember]; + } + if (hasDecorator(member, DecoratorNames.BUILDER_PARAM) && !!originMember.typeAnnotation) { + originMember.typeAnnotation.setAnnotations([annotation('memo')]); + } + return [originMember]; + } + + registerMap(map: Map): void { + this.legacyStructMap = map; + this.hasLegacy = true; + } + + processImport(node: arkts.ETSImportDeclaration): void { + const source = node.source?.str!; + const specifiers = node.specifiers; + if (this.legacyStructMap.has(source)) { + const structMap = this.legacyStructMap.get(source); + if (!structMap) { + return; + } + for (const specifier of specifiers) { + const name = specifier.local.name; + if (structMap[name]) { + this.legacyCallMap.set(name, structMap[name]); + } + } + } + } + + visitor(node: arkts.AstNode): arkts.AstNode { + this.enter(node); + const newNode = this.visitEachChild(node); + if (arkts.isEtsScript(newNode)) { + return this.processEtsScript(newNode); + } + if (arkts.isStructDeclaration(newNode) && this.isComponentStruct()) { + const updateNode = this.processComponent(newNode); + this.exit(newNode); + return updateNode; + } + if (!this.hasLegacy) { + return newNode; + } + if (arkts.isETSImportDeclaration(newNode)) { + this.processImport(newNode); + } + if (arkts.isCallExpression(newNode)) { + const ident = newNode.expression; + if (!(ident instanceof arkts.Identifier)) { + return newNode; + } + const className = ident.name; + if (this.legacyCallMap.has(className)) { + const path = this.legacyCallMap.get(className)!; + // const pathName = 'path/har1'; + const args = newNode.arguments; + const context: InteropContext = { + className: className, + path: path, + arguments: args && args.length === 1 && args[0] instanceof arkts.ObjectExpression + ? args[0] + : undefined + }; + return generateTempCallFunction(context); + } + } + return newNode; + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/entry-translators/entry-transformer.ts b/ets1.2/arkui-plugins/ui-plugins/entry-translators/entry-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..49d46e67b255702210d67dbf989f6c2af72adf02 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/entry-translators/entry-transformer.ts @@ -0,0 +1,30 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { AbstractVisitor } from '../../common/abstract-visitor'; +import { isEntryWrapperClass } from './utils'; +import { factory } from './factory'; + +export class EntryTransformer extends AbstractVisitor { + visitor(node: arkts.AstNode): arkts.AstNode { + const newNode = this.visitEachChild(node); + if (isEntryWrapperClass(newNode)) { + return factory.registerEntryFunction(newNode); + } + return newNode; + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/entry-translators/factory.ts b/ets1.2/arkui-plugins/ui-plugins/entry-translators/factory.ts new file mode 100644 index 0000000000000000000000000000000000000000..fca4fe867a8113195baff5e824865191ba73b7d9 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/entry-translators/factory.ts @@ -0,0 +1,291 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getInteropPath } from '../../path'; +const interop = require(getInteropPath()); +const nullptr = interop.nullptr; +import { EntryWrapperNames } from './utils'; +import { annotation } from '../../common/arkts-utils'; +import { factory as uiFactory } from '../ui-factory'; + +export class factory { + /** + * insert an 'entry' method to an entry wrapper class. + * + * @param node entry wrapper class declaration node. + */ + static registerEntryFunction(node: arkts.ClassDeclaration): arkts.AstNode { + const definition: arkts.ClassDefinition | undefined = node.definition; + const classname = node?.definition?.ident?.name; + if (!definition || !classname) { + throw new Error('Node definition is undefined'); + } + const updateClassDef: arkts.ClassDefinition = arkts.factory.updateClassDefinition( + definition, + definition.ident, + definition.typeParams, + definition.superTypeParams, + definition.implements, + undefined, + definition.super, + [...definition.body, factory.generateEntryFunction(classname)], + definition.modifiers, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE + ); + return arkts.factory.updateClassDeclaration(node, updateClassDef); + } + + /** + * insert an 'entry' property to an entry wrapper class. + * + * @param node entry wrapper class declaration node. + * @deprecated + */ + static registerEntryProperty(node: arkts.ClassDeclaration): arkts.AstNode { + const definition: arkts.ClassDefinition | undefined = node.definition; + const classname = node?.definition?.ident?.name; + if (!definition || !classname) { + throw new Error('Node definition is undefined'); + } + const updateClassDef: arkts.ClassDefinition = arkts.factory.updateClassDefinition( + definition, + definition.ident, + definition.typeParams, + definition.superTypeParams, + definition.implements, + undefined, + definition.super, + [...definition.body, factory.generateEntryProperty(classname)], + definition.modifiers, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE + ); + return arkts.factory.updateClassDeclaration(node, updateClassDef); + } + + /** + * create `entry(): void { (); }` class method for the entry wrapper class, + * which calls the struct within the method. + * + * @param name class/struct name that has `@Entry` annotation. + */ + static generateEntryFunction(name: string): arkts.MethodDefinition { + const exp = arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createIdentifier(name), + undefined, + [arkts.factory.createUndefinedLiteral()] // TODO: Add this undefined later + ) + ); + const key: arkts.Identifier = arkts.factory.createIdentifier(EntryWrapperNames.ENTRY_FUNC); + const block = arkts.factory.createBlock([exp]); + const entryScript = arkts.factory + .createScriptFunction( + block, + arkts.FunctionSignature.createFunctionSignature( + undefined, + [], + arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID), + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_METHOD, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC + ) + .setIdent(key); + + const def = arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD, + key, + entryScript, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC, + false + ); + + return def; + } + + static generateConstructor(): arkts.MethodDefinition { + const key: arkts.Identifier = arkts.factory.createIdentifier('constructor'); + const block = arkts.factory.createBlock([]); + const entryScript = arkts.factory + .createScriptFunction( + block, + arkts.FunctionSignature.createFunctionSignature(undefined, [], undefined, false), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_CONSTRUCTOR | + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_IMPLICIT_SUPER_CALL_NEEDED, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC | + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_CONSTRUCTOR + ) + .setIdent(key); + const def = arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_CONSTRUCTOR, + key, + entryScript, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + false + ); + return def; + } + + /** + * create `entry = (): void => { (); }` class property for the entry wrapper class, + * which calls the struct within the arrow function. + * + * @param name class/struct name that has `@Entry` annotation. + * @deprecated + */ + static generateEntryProperty(name: string): arkts.ClassProperty { + const exp = arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createIdentifier(name), + undefined, + [arkts.factory.createUndefinedLiteral()] // TODO: Add this undefined later + ) + ); + const key: arkts.Identifier = arkts.factory.createIdentifier(EntryWrapperNames.ENTRY_FUNC); + const block: arkts.BlockStatement = arkts.factory.createBlock([exp]); + const signature: arkts.FunctionSignature = arkts.FunctionSignature.createFunctionSignature( + undefined, + [], + arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID), + false + ); + const entryScript: arkts.ScriptFunction = arkts.factory + .createScriptFunction( + block, + signature, + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC + ) + .setIdent(key); + + const def = arkts.factory.createClassProperty( + key, + arkts.factory.createArrowFunction(entryScript), + arkts.factory.createFunctionType(signature, arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW), + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC, + false + ); + + return def; + } + + /** + * create `__EntryWrapper_Entry` entry wrapper class that contains an 'entry' method that + * calls the struct within the method. + * + * @param name class/struct name that has `@Entry` annotation. + */ + static generateEntryWrapper(name: string): arkts.ClassDeclaration { + const ctor = factory.generateConstructor(); + const definition: arkts.ClassDefinition = arkts.factory + .createClassDefinition( + arkts.factory.createIdentifier(EntryWrapperNames.WRAPPER_CLASS_NAME), + undefined, + undefined, + [], + undefined, + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier(EntryWrapperNames.ENTRY_POINT_CLASS_NAME) + ) + ), + [factory.generateEntryFunction(name), ctor], + arkts.Es2pandaClassDefinitionModifiers.CLASS_DEFINITION_MODIFIERS_CLASS_DECL | + arkts.Es2pandaClassDefinitionModifiers.CLASS_DEFINITION_MODIFIERS_DECLARATION | + arkts.Es2pandaClassDefinitionModifiers.CLASS_DEFINITION_MODIFIERS_ID_REQUIRED, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE + ) + .setCtor(ctor as any); + const newClass = arkts.factory.createClassDeclaration(definition); + newClass.modifiers = arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE; + return newClass; + } + + /** + * add `@memo` to all class methods that are named 'entry'. + * + * @param node class declaration node + */ + static addMemoToEntryWrapperClassMethods(node: arkts.ClassDeclaration): void { + node.definition?.body.forEach((member) => { + if ( + arkts.isMethodDefinition(member) && + !!member.scriptFunction.id && + member.scriptFunction.id.name === EntryWrapperNames.ENTRY_FUNC + ) { + member.scriptFunction.setAnnotations([annotation('memo')]); + } + }); + } + + /** + * add `@memo` to the class property's value (expecting an arrow function), where the property is named 'entry'. + * + * @param node class declaration node + * @deprecated + */ + static addMemoToEntryWrapperPropertyValue(node: arkts.ClassDeclaration): void { + node.definition?.body.forEach((member) => { + if ( + arkts.isClassProperty(member) && + !!member.value && + arkts.isArrowFunctionExpression(member.value) && + !!member.key && + arkts.isIdentifier(member.key) && + member.key.name === EntryWrapperNames.ENTRY_FUNC + ) { + member.setAnnotations([annotation('memo')]); + } + }); + } + + /** + * create `private _entry_local_storage_ = ;` class property + * from `{storage: ""}` in `@Entry`'s properties. + * + * @param annotation `@Entry` annotation. + */ + static createEntryLocalStorageInClass(property: arkts.ClassProperty) { + const value = property.value as arkts.StringLiteral; + return arkts.factory.createClassProperty( + arkts.factory.createIdentifier(EntryWrapperNames.ENTRY_STORAGE_LOCAL_STORAGE_PROPERTY_NAME), + arkts.factory.createIdentifier(value.str), + undefined, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE, + false + ); + } + + /** + * create and insert `import { EntryPoint as EntryPoint } from "@ohos.arkui.UserView";` + * to the top of script's statements. + */ + static createAndInsertEntryPointImport(program?: arkts.Program) { + const source: arkts.StringLiteral = arkts.factory.create1StringLiteral(EntryWrapperNames.ENTRY_DEFAULT_IMPORT); + const imported: arkts.Identifier = arkts.factory.createIdentifier(EntryWrapperNames.ENTRY_POINT_CLASS_NAME); + // Insert this import at the top of the script's statements. + if (!program) { + throw Error('Failed to insert import: Transformer has no program'); + } + uiFactory.createAndInsertImportDeclaration( + source, + imported, + imported, + arkts.Es2pandaImportKinds.IMPORT_KINDS_VALUE, + program + ); + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/entry-translators/utils.ts b/ets1.2/arkui-plugins/ui-plugins/entry-translators/utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..61a03783c1351832c2f132559c3e393c8257a936 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/entry-translators/utils.ts @@ -0,0 +1,84 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { factory } from './factory'; +import { isAnnotation } from '../../common/arkts-utils'; +import { CustomComponentNames } from '../utils'; + +export enum EntryWrapperNames { + ENTRY_FUNC = 'entry', + WRAPPER_CLASS_NAME = '__EntryWrapper', + ENTRY_STORAGE_ANNOTATION_KEY = 'storage', + ENTRY_STORAGE_LOCAL_STORAGE_PROPERTY_NAME = '_entry_local_storage_', + ENTRY_DEFAULT_IMPORT = 'arkui.UserView', + ENTRY_POINT_CLASS_NAME = 'EntryPoint', +} + +/** + * @deprecated + */ +export class EntryHandler { + private entryDefClassName: Set; + + private static instance: EntryHandler; + + private constructor() { + this.entryDefClassName = new Set(); + } + + public static getInstance(): EntryHandler { + if (!this.instance) { + this.instance = new EntryHandler(); + } + return this.instance; + } + + public rememberEntryFunction(classname: string): void { + this.entryDefClassName.add(classname); + } + + public createEntryWrapper(): arkts.ClassDeclaration[] { + let result: arkts.ClassDeclaration[] = []; + this.entryDefClassName.forEach((classname) => { + result.push(factory.generateEntryWrapper(classname)); + }); + return result; + } +} + +export function isEntryWrapperClass(node: arkts.AstNode): node is arkts.ClassDeclaration { + if (!arkts.isClassDeclaration(node)) return false; + const className = node?.definition?.ident?.name; + if (!className) return false; + return className === EntryWrapperNames.WRAPPER_CLASS_NAME; +} + +/** + * find `{storage: ""}` in `@Entry({storage: ""})` (i.e. annotation's properties). + * + * @param node class definition node + */ +export function findEntryWithStorageInClassAnnotations(node: arkts.ClassDefinition): arkts.ClassProperty | undefined { + const annotation = node.annotations.find((anno) => { + if (!isAnnotation(anno, CustomComponentNames.ENTRY_ANNOTATION_NAME)) return false; + const property = anno.properties?.at(0); + if (!property || !arkts.isClassProperty(property)) return false; + if (!property.key || !arkts.isIdentifier(property.key)) return false; + if (!property.value || !arkts.isStringLiteral(property.value)) return false; + return property.key.name === EntryWrapperNames.ENTRY_STORAGE_ANNOTATION_KEY; + }); + return annotation?.properties?.at(0) as arkts.ClassProperty | undefined; +} diff --git a/ets1.2/arkui-plugins/ui-plugins/index.ts b/ets1.2/arkui-plugins/ui-plugins/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..1397e89c23400d38951a60aa9761b1f8352bd312 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/index.ts @@ -0,0 +1,157 @@ +/* + * 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 { ComponentTransformer } from './component-transformer'; +import { PreprocessorTransformer } from './preprocessor-transform'; +import { CheckedTransformer } from './checked-transformer'; +import { Plugins, PluginContext, ProjectConfig } from '../common/plugin-context'; +import { ProgramVisitor } from '../common/program-visitor'; +import { EXTERNAL_SOURCE_PREFIX_NAMES } from '../common/predefines'; +import { debugDump, debugLog, getDumpFileName } from '../common/debug'; + +export function uiTransform(): Plugins { + return { + name: 'ui-plugin', + parsed: parsedTransform, + checked: checkedTransform, + clean() { + arkts.arktsGlobal.clearContext(); + }, + }; +} + +function parsedTransform(this: PluginContext): arkts.EtsScript | undefined { + let script: arkts.EtsScript | undefined; + console.log('[UI PLUGIN] AFTER PARSED ENTER'); + const contextPtr = arkts.arktsGlobal.compilerContext?.peer ?? this.getContextPtr(); + if (!!contextPtr) { + let program = arkts.getOrUpdateGlobalContext(contextPtr).program; + script = program.astNode; + const cachePath: string | undefined = this.getProjectConfig()?.cachePath; + debugLog('[BEFORE PARSED SCRIPT] script: ', script.dumpSrc()); + debugDump( + script.dumpSrc(), + getDumpFileName(0, 'SRC', 1, 'UI_AfterParse_Begin'), + true, + cachePath, + program.programFileNameWithExtension + ); + arkts.Performance.getInstance().createEvent('ui-parsed'); + program = parsedProgramVisit(program, this); + script = program.astNode; + arkts.Performance.getInstance().stopEvent('ui-parsed', true); + debugLog('[AFTER PARSED SCRIPT] script: ', script.dumpSrc()); + debugDump( + script.dumpSrc(), + getDumpFileName(0, 'SRC', 2, 'UI_AfterParse_End'), + true, + cachePath, + program.programFileNameWithExtension + ); + this.setArkTSAst(script); + console.log('[UI PLUGIN] AFTER PARSED EXIT'); + return script; + } + console.log('[UI PLUGIN] AFTER PARSED EXIT WITH NO TRANSFORM'); + return script; +} + +function parsedProgramVisit( + program: arkts.Program, + context: PluginContext, + canSkipPhases: boolean = false +): arkts.Program { + if (canSkipPhases) { + debugLog('[SKIP PHASE] phase: ui-parsed, moduleName: ', program.moduleName); + } else { + debugLog('[CANT SKIP PHASE] phase: ui-parsed, moduleName: ', program.moduleName); + const componentTransformer = new ComponentTransformer(); + const preprocessorTransformer = new PreprocessorTransformer(); + const programVisitor = new ProgramVisitor({ + pluginName: uiTransform.name, + state: arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED, + visitors: [componentTransformer, preprocessorTransformer], + skipPrefixNames: EXTERNAL_SOURCE_PREFIX_NAMES, + pluginContext: context, + }); + program = programVisitor.programVisitor(program); + } + return program; +} + +function checkedTransform(this: PluginContext): arkts.EtsScript | undefined { + let script: arkts.EtsScript | undefined; + console.log('[UI PLUGIN] AFTER CHECKED ENTER'); + const contextPtr = arkts.arktsGlobal.compilerContext?.peer ?? this.getContextPtr(); + if (!!contextPtr) { + let program = arkts.getOrUpdateGlobalContext(contextPtr).program; + script = program.astNode; + const cachePath: string | undefined = this.getProjectConfig()?.cachePath; + debugLog('[BEFORE STRUCT SCRIPT] script: ', script.dumpSrc()); + debugDump( + script.dumpSrc(), + getDumpFileName(0, 'SRC', 3, 'UI_AfterCheck_Begin'), + true, + cachePath, + program.programFileNameWithExtension + ); + arkts.Performance.getInstance().createEvent('ui-checked'); + program = checkedProgramVisit(program, this); + script = program.astNode; + arkts.Performance.getInstance().stopEvent('ui-checked', true); + debugLog('[AFTER STRUCT SCRIPT] script: ', script.dumpSrc()); + debugDump( + script.dumpSrc(), + getDumpFileName(0, 'SRC', 4, 'UI_AfterCheck_End'), + true, + cachePath, + program.programFileNameWithExtension + ); + arkts.GlobalInfo.getInfoInstance().reset(); + arkts.Performance.getInstance().createEvent('ui-recheck'); + arkts.recheckSubtree(script); + arkts.Performance.getInstance().stopEvent('ui-recheck', true); + arkts.Performance.getInstance().clearAllEvents(); + this.setArkTSAst(script); + console.log('[UI PLUGIN] AFTER CHECKED EXIT'); + return script; + } + console.log('[UI PLUGIN] AFTER CHECKED EXIT WITH NO TRANSFORM'); + return script; +} + +function checkedProgramVisit( + program: arkts.Program, + context: PluginContext, + canSkipPhases: boolean = false +): arkts.Program { + if (canSkipPhases) { + debugLog('[SKIP PHASE] phase: ui-checked, moduleName: ', program.moduleName); + } else { + debugLog('[CANT SKIP PHASE] phase: ui-checked, moduleName: ', program.moduleName); + const projectConfig: ProjectConfig | undefined = context.getProjectConfig(); + const checkedTransformer = new CheckedTransformer(projectConfig); + const programVisitor = new ProgramVisitor({ + pluginName: uiTransform.name, + state: arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED, + visitors: [checkedTransformer], + skipPrefixNames: EXTERNAL_SOURCE_PREFIX_NAMES, + pluginContext: context, + }); + program = programVisitor.programVisitor(program); + } + return program; +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-plugins/initstatevar.ts b/ets1.2/arkui-plugins/ui-plugins/initstatevar.ts new file mode 100644 index 0000000000000000000000000000000000000000..3264db1a243506492937198b261acd3bf95b1d9b --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/initstatevar.ts @@ -0,0 +1,290 @@ +/* + * 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 { InteroperAbilityNames } from '../common/predefines'; +import { annotation, backingField, isAnnotation } from '../common/arkts-utils'; +import { getPropertyESValue, getWrapValue, setPropertyESValue } from './interop'; + + +export function processNormal(keyName: string, value: arkts.AstNode): arkts.Statement[] { + const result: arkts.Statement[] = []; + const setProperty = setPropertyESValue( + InteroperAbilityNames.PARAM, + keyName, + getWrapValue(value) + ); + result.push(setProperty); + return result; +} + +export function createVariableLet(varName: string, expression: arkts.AstNode): arkts.VariableDeclaration { + return arkts.factory.createVariableDeclaration( + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET, + [arkts.factory.createVariableDeclarator( + arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_LET, + arkts.factory.createIdentifier(varName), + expression + )] + ); +} +export function setValueCallback(name: string, type: arkts.TypeNode, block: arkts.BlockStatement): arkts.AstNode { + return createVariableLet(name, + arkts.factory.createArrowFunction( + arkts.factory.createScriptFunction( + block, + arkts.factory.createFunctionSignature( + undefined, + [ + arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier('value', type), + undefined, + ), + ], + undefined, + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + ) + ) + ); +} + +function createProxyBlock(varName: string): arkts.BlockStatement { + return arkts.factory.createBlock( + [ + arkts.factory.createExpressionStatement( + arkts.factory.createAssignmentExpression( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier(varName), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + arkts.factory.createIdentifier('value') + ) + ) + ] + ); +} + +export function setCallbackForProxy(varName: string, type: arkts.TypeNode): arkts.Statement[] { + const createCallback = setValueCallback(addStatePrefix(varName, 'SetSource'), type, createProxyBlock(varName)); + const createProxyState = createVariableLet(addStatePrefix(varName, 'ProxyState'), + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier('createState'), + arkts.factory.createIdentifier('invoke'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + [ + getWrapValue( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier(varName), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ) + ), + getWrapValue(arkts.factory.createIdentifier(addStatePrefix(varName, 'SetSource'))) + ] + ) + ); + const setProxy = arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createTSNonNullExpression( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier(backingField(varName)), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ) + ), + arkts.factory.createIdentifier('setProxy'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + [arkts.factory.createIdentifier(addStatePrefix(varName, 'ProxyState'))], + ) + ); + return [createCallback, createProxyState, setProxy]; +} + +function createSourceBlock(varName: string): arkts.BlockStatement { + return arkts.factory.createBlock( + [ + arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(addStatePrefix(varName, 'ProxyState')), + arkts.factory.createIdentifier('invokeMethod'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + [ + arkts.factory.createStringLiteral('set'), + getWrapValue( + arkts.factory.createIdentifier('value') + ) + ] + ) + ) + ] + ); +} + +function createNotifyBlock(varName: string): arkts.BlockStatement { + return arkts.factory.createBlock( + [ + arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(addStatePrefix(varName, 'ProxyState')), + arkts.factory.createIdentifier('invokeMethod'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + [ + arkts.factory.createStringLiteral('notifyPropertyHasChangedPU') + ] + ) + ) + ] + ); +} + +function setNotifyForSource(varName: string): arkts.Statement[] { + const block = createNotifyBlock(varName); + const createCallback = createVariableLet(addStatePrefix(varName, 'NotifyCallback'), + arkts.factory.createArrowFunction( + arkts.factory.createScriptFunction( + block, + arkts.factory.createFunctionSignature( + undefined, + [ + arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier('propertyName', + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier('string') + ) + ) + ), + undefined, + ), + ], + undefined, + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + ) + ) + ); + const setCallback = arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createTSNonNullExpression( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier(backingField(varName)), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ) + ), + arkts.factory.createIdentifier('setNotifyCallback'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + [arkts.factory.createIdentifier(addStatePrefix(varName, 'NotifyCallback'))], + ) + ); + return [createCallback, setCallback]; +} + +export function setCallbackForSource(varName: string, type: arkts.TypeNode): arkts.Statement[] { + const createCallback = setValueCallback(addStatePrefix(varName, 'SetProxy'), type, createSourceBlock(varName)); + const setFunc = arkts.factory.createExpressionStatement( + arkts.factory.createAssignmentExpression( + arkts.factory.createMemberExpression( + arkts.factory.createTSNonNullExpression( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier(backingField(varName)), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ) + ), + arkts.factory.createIdentifier('setProxyValue'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + arkts.factory.createIdentifier(addStatePrefix(varName, 'SetProxy')) + ) + ); + const setNotify = setNotifyForSource(varName); + return [createCallback, setFunc, ...setNotify]; +} + +export function processLink(keyName: string, value: arkts.AstNode, type: arkts.TypeNode, proxySet: Set): arkts.Statement[] { + const varName = ((value as arkts.MemberExpression).property as arkts.Identifier).name; + const result: arkts.Statement[] = []; + if (!proxySet.has(varName)) { + proxySet.add(varName); + const setProxy = setCallbackForProxy(varName, type); + result.push(...setProxy); + const setSource = setCallbackForSource(varName, type); + result.push(...setSource); + } + const setParam = setPropertyESValue( + 'param', + keyName, + arkts.factory.createIdentifier(addStatePrefix(varName, 'ProxyState')) + ); + result.push(setParam); + return result; +} + +export function hasLink(decorators: string[]): boolean { + return decorators.some(decorator => decorator === 'Link'); +} + +function addStatePrefix(stateVarName: string, name: string): string { + return `${stateVarName}_${name}`; +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-plugins/interop.ts b/ets1.2/arkui-plugins/ui-plugins/interop.ts new file mode 100644 index 0000000000000000000000000000000000000000..d6c43d1c7d5c14fed395139969d516ae5d12ec13 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/interop.ts @@ -0,0 +1,595 @@ +/* + * 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 { InteroperAbilityNames } from '../common/predefines'; +import { getCustomComponentOptionsName } from './utils'; +import { InteropContext } from './component-transformer'; +import { annotation, backingField, isAnnotation } from '../common/arkts-utils'; +import { hasLink, processLink, processNormal } from './initstatevar'; + +interface propertyInfo { + decorators: string[], + type: arkts.TypeNode, +} + +export function createEmptyESValue(name: string): arkts.VariableDeclaration { + return arkts.factory.createVariableDeclaration( + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET, + [ + arkts.factory.createVariableDeclarator( + arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_LET, + arkts.factory.createIdentifier(name), + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(InteroperAbilityNames.ESVALUE), + arkts.factory.createIdentifier(InteroperAbilityNames.INITEMPTYOBJECT), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + undefined + ) + ) + ] + ); +} + +export function getWrapValue(value: arkts.AstNode): arkts.AstNode { + return arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(InteroperAbilityNames.ESVALUE), + arkts.factory.createIdentifier(InteroperAbilityNames.WRAP), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + [value] + ); +} + +export function setPropertyESValue(name: string, key: string, wrapValue: arkts.AstNode): arkts.ExpressionStatement { + return arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(name), + arkts.factory.createIdentifier(InteroperAbilityNames.SETPROPERTY), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + [ + arkts.factory.createStringLiteral(key), + wrapValue + ] + ) + ); +} + +export function getPropertyESValue(result: string, object: string, key: string): arkts.VariableDeclaration { + return arkts.factory.createVariableDeclaration( + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET, + [ + arkts.factory.createVariableDeclarator( + arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_LET, + arkts.factory.createIdentifier(result), + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(object), + arkts.factory.createIdentifier(InteroperAbilityNames.GETPROPERTY), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + [arkts.factory.create1StringLiteral(key)] + ) + ) + ] + ); +} + +function initialArgs(args: arkts.ObjectExpression, varMap: Map): arkts.Statement[] { + const result: arkts.Statement[] = [ + createEmptyESValue(InteroperAbilityNames.PARAM), + getPropertyESValue('createState', 'global', 'createStateVariable') + ]; + + const proxySet = new Set(); + + for (const property of args.properties) { + if (!(property instanceof arkts.Property)) { + continue; + } + const key = property.key; + const value = property.value; + if (!(key instanceof arkts.Identifier)) { + throw Error('Error arguments in Legacy Component'); + } + const name = key.name; + const decorators = varMap.get(name)?.decorators; + const type = varMap.get(name)?.type!; + if (decorators !== undefined && hasLink(decorators)) { + const initParam = processLink(key.name, value!, type, proxySet); + result.push(...initParam); + } else { + const initParam = processNormal(key.name, value!); + result.push(...initParam); + } + } + return result; +} + +function instantiateComponent(params: arkts.AstNode[]): arkts.VariableDeclaration { + return arkts.factory.createVariableDeclaration( + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET, + [ + arkts.factory.createVariableDeclarator( + arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_LET, + arkts.factory.createIdentifier(InteroperAbilityNames.COMPONENT), + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(InteroperAbilityNames.STRUCTOBJECT), + arkts.factory.createIdentifier(InteroperAbilityNames.INSTANTIATE), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + params + ) + ) + ] + ); +} + +function paramsLambdaDeclaration(name: string, args?: arkts.ObjectExpression): arkts.Statement[] { + const result = []; + result.push( + arkts.factory.createVariableDeclaration( + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET, + [ + arkts.factory.createVariableDeclarator( + arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_LET, + arkts.factory.createIdentifier(InteroperAbilityNames.PARAMSLAMBDA), + arkts.factory.createArrowFunction( + arkts.factory.createScriptFunction( + arkts.factory.createBlock([arkts.factory.createReturnStatement( + args ? args : arkts.ObjectExpression.createObjectExpression( + arkts.Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION, + [], + false + ), + )]), + arkts.factory.createFunctionSignature( + undefined, + [], + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier(getCustomComponentOptionsName(name)) + ) + ), + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + ) + ) + ), + + ] + ) + ); + return result; +} + +function createInitReturn(componentName: string): arkts.ReturnStatement { + return arkts.factory.createReturnStatement( + arkts.ObjectExpression.createObjectExpression( + arkts.Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION, + [ + arkts.Property.createProperty( + arkts.factory.createIdentifier(InteroperAbilityNames.COMPONENT), + arkts.factory.createIdentifier(InteroperAbilityNames.COMPONENT) + ), + arkts.Property.createProperty( + arkts.factory.createIdentifier('name'), + arkts.factory.createStringLiteral(componentName) + ) + ], + false + ), + ); +} + +function createExtraInfo(properties: string[], value: string[]): arkts.Statement[] { + const body: arkts.AstNode[] = []; + body.push(createEmptyESValue(InteroperAbilityNames.EXTRAINFO)); + properties.forEach((prop, index) => { + const val = value[index]; + body.push(setPropertyESValue( + InteroperAbilityNames.EXTRAINFO, + prop, + arkts.factory.createStringLiteral(val)) + ); + }); + return body; +} + +function createESParent(): arkts.Statement { + return arkts.factory.createVariableDeclaration( + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET, + [ + arkts.factory.createVariableDeclarator( + arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_LET, + arkts.factory.createIdentifier('esparent'), + getWrapValue(arkts.factory.createIdentifier(InteroperAbilityNames.PARENT)) + ) + ] + ); +} + +function createESUndefined(): arkts.Statement { + return arkts.factory.createVariableDeclaration( + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET, + [ + arkts.factory.createVariableDeclarator( + arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_LET, + arkts.factory.createIdentifier('esundefined'), + getWrapValue(arkts.factory.createUndefinedLiteral()) + ) + ] + ); +} + +function createESBlank(): arkts.Statement[] { + const body: arkts.Statement[] = []; + const blank = arkts.factory.createVariableDeclaration( + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET, + [ + arkts.factory.createVariableDeclarator( + arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_LET, + arkts.factory.createIdentifier('blank'), + arkts.factory.createArrowFunction( + arkts.factory.createScriptFunction( + arkts.factory.createBlock([]), + arkts.factory.createFunctionSignature( + undefined, + [], + undefined, + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + ) + ) + ) + ] + ); + body.push(blank); + const asExpression = arkts.factory.createTSAsExpression( + arkts.factory.createIdentifier('blank'), + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier('object') + ) + ), + false + ); + const esblank = arkts.factory.createVariableDeclaration( + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET, + [ + arkts.factory.createVariableDeclarator( + arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_LET, + arkts.factory.createIdentifier('esblank'), + getWrapValue(asExpression) + ) + ] + ); + body.push(esblank); + return body; +} + +function createGlobal(): arkts.Statement { + return arkts.factory.createVariableDeclaration( + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET, + [arkts.factory.createVariableDeclarator( + arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_LET, + arkts.factory.createIdentifier('global'), + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(InteroperAbilityNames.ESVALUE), + arkts.factory.createIdentifier('getGlobal'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + undefined + ) + )] + ); +} + +function createELMTID(): arkts.Statement[] { + const body: arkts.Statement[] = []; + const viewStackProcessor = getPropertyESValue('viewStackProcessor', 'global', 'ViewStackProcessor'); + body.push(viewStackProcessor); + const createId = getPropertyESValue('createId', 'viewStackProcessor', 'AllocateNewElmetIdForNextComponent'); + body.push(createId); + const elmtId = arkts.factory.createVariableDeclaration( + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET, + [arkts.factory.createVariableDeclarator( + arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_LET, + arkts.factory.createIdentifier(InteroperAbilityNames.ELMTID), + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier('createId'), + arkts.factory.createIdentifier('invoke'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + undefined + ) + )] + ); + body.push(elmtId); + return body; +} + +function createComponent(moduleName: string, className: string): arkts.Statement[] { + const body: arkts.Statement[] = []; + const module = arkts.factory.createVariableDeclaration( + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET, + [ + arkts.factory.createVariableDeclarator( + arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_LET, + arkts.factory.createIdentifier(moduleName), + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(InteroperAbilityNames.ESVALUE), + arkts.factory.createIdentifier(InteroperAbilityNames.LOAD), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + [arkts.factory.create1StringLiteral(InteroperAbilityNames.OHMURL)] + ) + ) + ] + ); + body.push(module); + const structObject = getPropertyESValue('structObject', moduleName, className); + body.push(structObject); + const component = instantiateComponent( + [ + arkts.factory.createIdentifier('esundefined'), + arkts.factory.createIdentifier(InteroperAbilityNames.PARAM), + arkts.factory.createIdentifier('esundefined'), + arkts.factory.createIdentifier(InteroperAbilityNames.ELMTID), + arkts.factory.createIdentifier('esblank'), + arkts.factory.createIdentifier(InteroperAbilityNames.EXTRAINFO) + ] + ); + body.push(component); + return body; +} + +function invokeViewPUCreate(): arkts.Statement[] { + const body: arkts.Statement[] = []; + const createMethod = getPropertyESValue('create', 'structObject', 'create'); + body.push(createMethod); + const viewPUCreate = arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier('create'), + arkts.factory.createIdentifier('invoke'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + [ + arkts.factory.createIdentifier('component') + ] + ) + ); + body.push(viewPUCreate); + return body; +} + +function createWrapperBlock(context: InteropContext, varMap: Map): arkts.BlockStatement { + const className = context.className; + const path = context.path; + const args = context.arguments; + const index = path.indexOf('/'); + if (index === -1) { + throw new Error('Error path of Legacy Component.'); + } + const moduleName = path.substring(0, index); + const initialArgsStatement = args ? initialArgs(args, varMap) : []; + return arkts.factory.createBlock( + [ + createGlobal(), + ...initialArgsStatement, + ...createExtraInfo(['page'], [path]), + createESUndefined(), + ...createESBlank(), + ...createELMTID(), + ...createComponent(moduleName, className), + ...invokeViewPUCreate(), + // ...paramsLambdaDeclaration(className, args), + // setPropertyESValue( + // 'component', + // 'paramsGenerator_', + // arkts.factory.createIdentifier(InteroperAbilityNames.PARAMSLAMBDA) + // ), + createInitReturn(className) + ] + ); +} + +function createInitializer(context: InteropContext, varMap: Map): arkts.ArrowFunctionExpression { + const block = createWrapperBlock(context, varMap); + return arkts.factory.createArrowFunction( + arkts.factory.createScriptFunction( + block, + arkts.factory.createFunctionSignature( + undefined, + [], + undefined, + false, + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + ) + ); +} + +function createUpdater(esvalue: arkts.ETSTypeReference, varMap: Map): arkts.ArrowFunctionExpression { + return arkts.factory.createArrowFunction( + arkts.factory.createScriptFunction( + arkts.factory.createBlock( + [ + + ] + ), + arkts.factory.createFunctionSignature( + undefined, + [ + arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier(InteroperAbilityNames.INSTANCE, esvalue), + undefined, + ), + ], + undefined, + false, + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + ) + ); +} + +function generateVarMap(node: arkts.Identifier): Map { + const decl = arkts.getDecl(node); + if (!(decl instanceof arkts.ClassDefinition)) { + throw Error("can't find legacy class declaration"); + } + const result = new Map(); + const definition = decl; + const body = definition.body; + body.forEach(node => { + if (node instanceof arkts.ClassProperty && node.key instanceof arkts.Identifier) { + const key = node.key.name; + const annotations = node.annotations; + const decorators: string[] = annotations.map(annotation => { + return (annotation.expr as arkts.Identifier).name; + }); + const type: arkts.TypeNode = node.typeAnnotation!; + result.set(key, {decorators: decorators, type: type}); + } + }); + return result; +} + +export function updateArkUICompatible(node: arkts.CallExpression): arkts.CallExpression { + const classInterop = (node.expression as arkts.MemberExpression).object as arkts.Identifier; + const className = classInterop.name; + const args = node.arguments; + const path = (args[0] as arkts.StringLiteral).str; + const line = args[1] instanceof arkts.UndefinedLiteral ? undefined : (args[1] as arkts.NumberLiteral).value; + const col = args[2] instanceof arkts.UndefinedLiteral ? undefined : (args[2] as arkts.NumberLiteral).value; + const options = args[3] instanceof arkts.UndefinedLiteral ? undefined : args[3] as arkts.ObjectExpression; + const context: InteropContext = { + className: className, + path: path, + line: line, + col: col, + arguments: options + }; + + const varMap: Map = generateVarMap(classInterop); + const esvalue = arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier(InteroperAbilityNames.ESVALUE) + ) + ); + const initializer = createInitializer(context, varMap); + const updater = createUpdater(esvalue, varMap); + return arkts.factory.updateCallExpression( + node, + arkts.factory.createIdentifier(InteroperAbilityNames.ARKUICOMPATIBLE), + undefined, + [ + initializer, + updater, + ] + ); +} + + +function generateStructInfo(context: InteropContext): arkts.AstNode[] { + const result: arkts.AstNode[] = [ + arkts.factory.createStringLiteral(context.path), + context.line ? arkts.factory.createIdentifier(context.line.toString()) : arkts.factory.createUndefinedLiteral(), + context.col ? arkts.factory.createIdentifier(context.col.toString()) : arkts.factory.createUndefinedLiteral(), + context.arguments ?? arkts.factory.createUndefinedLiteral() + ]; + return result; + +} + +export function generateTempCallFunction(context: InteropContext): arkts.CallExpression { + return arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(context.className), + arkts.factory.createIdentifier('instantiate_Interop'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + generateStructInfo(context) + ); +} + +export function isArkUICompatible(node: arkts.AstNode): boolean { + if (node instanceof arkts.CallExpression && node.expression instanceof arkts.MemberExpression && + node.expression.property instanceof arkts.Identifier && + node.expression.property.name === 'instantiate_Interop') { + return true; + } + return false; +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-plugins/legacy-transformer.ts b/ets1.2/arkui-plugins/ui-plugins/legacy-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..10047677ad11f81e98654faf738971ad3883be4a --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/legacy-transformer.ts @@ -0,0 +1,254 @@ +/* + * 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 { getInteropPath } from '../path'; +const interop = require(getInteropPath()); +const nullptr = interop.nullptr; +import { AbstractVisitor, VisitorOptions } from '../common/abstract-visitor'; +import { InteroperAbilityNames } from '../common/predefines'; +import { getCustomComponentOptionsName } from './utils'; + +interface LegacyTransformerOptions extends VisitorOptions { + structList?: string[] +} + +export class LegacyTransformer extends AbstractVisitor { + private structList: string[] = []; + private componentInterfaceCollection: arkts.TSInterfaceDeclaration[] = []; + + constructor(options?: LegacyTransformerOptions) { + const _options: LegacyTransformerOptions = options ?? {}; + super(_options); + this.structList = _options.structList ?? []; + } + + reset(): void { + super.reset(); + this.componentInterfaceCollection = []; + } + + getList(): string[] { + return this.structList; + } + + createParam(name: string, type: string): arkts.ETSParameterExpression { + return arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier( + name, + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier(type) + ) + ) + ), + undefined + ); + } + + createInteropMethod(name: string): arkts.MethodDefinition { + const path = this.createParam('path', 'string'); + const line = this.createParam('line', 'number'); + line.setOptional(true); + const col = this.createParam('col', 'number'); + col.setOptional(true); + const options = this.createParam('options', getCustomComponentOptionsName(name)); + options.setOptional(true); + + const script = arkts.factory.createScriptFunction( + arkts.factory.createBlock([]), + arkts.FunctionSignature.createFunctionSignature( + undefined, + [path, line, col, options], + arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID), + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_METHOD, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC | arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_STATIC + ); + + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD, + arkts.factory.createIdentifier('instantiate_Interop'), + script, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC | arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_STATIC, + false + ); + } + + generateMember(map: Map): arkts.ClassProperty[] { + const properties: arkts.ClassProperty[] = []; + + map.forEach((value, key) => { + const property = arkts.factory.createClassProperty( + arkts.factory.createIdentifier(key), + undefined, + value, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC | + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_OPTIONAL, + false + ); + + properties.push(property); + }); + + return properties; + } + + generateComponentInterface(name: string, modifiers: number, map: Map): arkts.TSInterfaceDeclaration { + const interfaceNode = arkts.factory.createInterfaceDeclaration( + [], + arkts.factory.createIdentifier(getCustomComponentOptionsName(name)), + nullptr, // TODO: wtf + arkts.factory.createInterfaceBody([...(this.generateMember(map) || [])]), + false, + false + ); + interfaceNode.modifiers = modifiers; + return interfaceNode; + } + + processComponent(node: arkts.StructDeclaration): arkts.StructDeclaration | arkts.ClassDeclaration { + const definition: arkts.ClassDefinition = node.definition!; + const ident = definition.ident!; + const hasExportFlag = + (node.modifiers & arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_EXPORT) === + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_EXPORT; + if (hasExportFlag) { + this.structList.push(ident.name); + } + + const instantiate_Interop: arkts.MethodDefinition = this.createInteropMethod(ident.name); + + const newDefinition = arkts.factory.updateClassDefinition( + definition, + definition.ident, + definition.typeParams, + definition.superTypeParams, + definition.implements, + undefined, + definition.super, + [...definition.body, instantiate_Interop], + definition.modifiers, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE + ); + + console.log('print legacyclass definition' + newDefinition.dumpSrc()); + + + //TODO: need check + if (arkts.isStructDeclaration(node)) { + const _node = arkts.factory.createClassDeclaration(newDefinition); + _node.modifiers = node.modifiers; + return _node; + } else { + return arkts.factory.updateClassDeclaration(node, newDefinition); + } + } + + processConstructor(node: arkts.MethodDefinition): arkts.MethodDefinition { + const esvalue = arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier(InteroperAbilityNames.ESVALUE) + ) + ); + const script = arkts.factory.createScriptFunction( + arkts.factory.createBlock([]), + arkts.factory.createFunctionSignature( + undefined, + [ + arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier(InteroperAbilityNames.PARENT, esvalue), + undefined, + ), + arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier(InteroperAbilityNames.PARAM, esvalue), + undefined, + ), + arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier('localStorage', esvalue), + undefined, + ), + arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier(InteroperAbilityNames.ELMTID, esvalue), + undefined, + ), + arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier(InteroperAbilityNames.PARAMSLAMBDA, esvalue), + undefined, + ), + arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier(InteroperAbilityNames.EXTRAINFO, esvalue), + undefined, + ) + ], undefined, false), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_CONSTRUCTOR, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC, + ); + return arkts.factory.updateMethodDefinition( + node, + node.kind, + node.name, + script, + node.modifiers, + false + ); + } + + collectComponentMembers(node: arkts.StructDeclaration, className: string): Map { + const result: Map = new Map(); + node.definition.body.map((it) => { + if (arkts.isClassProperty(it)) { + const name = (it.key as arkts.Identifier).name; + const type = it.typeAnnotation!; + result.set(name, type); + } + }); + return result; + } + + processEtsScript(node: arkts.EtsScript): arkts.EtsScript { + let updateStatements: arkts.AstNode[] = []; + if (this.componentInterfaceCollection.length > 0) { + updateStatements.push(...this.componentInterfaceCollection); + } + if (updateStatements.length > 0) { + return arkts.factory.updateEtsScript(node, [...node.statements, ...updateStatements]); + } + return node; + } + + visitor(node: arkts.AstNode): arkts.AstNode { + const newNode = this.visitEachChild(node); + if (arkts.isEtsScript(newNode)) { + return this.processEtsScript(newNode); + } + if (arkts.isStructDeclaration(newNode)) { + const className = node.definition?.ident?.name; + const memberMap = this.collectComponentMembers(node as arkts.StructDeclaration, className); + this.componentInterfaceCollection.push(this.generateComponentInterface(className, node.modifiers, memberMap)); + const updateNode = this.processComponent(newNode); + return updateNode; + } + if (arkts.isMethodDefinition(newNode)) { + const kind = newNode.kind; + if (kind === arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_CONSTRUCTOR) { + const updateNode = this.processConstructor(newNode); + return updateNode; + } + } + return newNode; + } +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-plugins/name-collector.ts b/ets1.2/arkui-plugins/ui-plugins/name-collector.ts new file mode 100644 index 0000000000000000000000000000000000000000..60d29a3e06e15f48b93298d1aa4b34dde0bc902a --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/name-collector.ts @@ -0,0 +1,87 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { AbstractVisitor } from '../common/abstract-visitor'; +import { hasBuilderLambdaAnnotation } from './builder-lambda-translators/utils'; + +interface ComponentInfo { + argsNum: number; +} + +type ComponentCollection = Map; + +export class NameCollector extends AbstractVisitor { + private components: ComponentCollection; + private static instance: NameCollector; + + private constructor() { + super(); + this.components = new Map(); + } + + static getInstance(): NameCollector { + if (!this.instance) { + this.instance = new NameCollector(); + } + return this.instance; + } + + getComponents(): string[] { + return Array.from(this.components.keys()); + } + + getComponentInfo(componentName: string): ComponentInfo | undefined { + return this.components.get(componentName); + } + + collectInfoFromComponentFunction(component: arkts.ScriptFunction): void { + if (!component.id) return; + + const name: string = component.id.name; + const argsNum: number = component.params.length; + this.components.set(name, { argsNum }); + } + + reset(): void { + super.reset(); + this.components.clear(); + } + + findComponentFunction(node: arkts.FunctionDeclaration): arkts.ScriptFunction | undefined { + const isDeclareAndExport: boolean = arkts.hasModifierFlag( + node, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_DECLARE | arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_EXPORT + ); + if (!isDeclareAndExport) return undefined; + + const isComponentBuilder = hasBuilderLambdaAnnotation(node); + if (!isComponentBuilder) return undefined; + if (!node.scriptFunction.id) return undefined; + + return node.scriptFunction; + } + + visitor(node: arkts.AstNode): arkts.AstNode { + const newNode = this.visitEachChild(node); + if (arkts.isFunctionDeclaration(newNode)) { + const component = this.findComponentFunction(newNode); + if (!!component) { + this.collectInfoFromComponentFunction(component); + } + } + return newNode; + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/preprocessor-transform.ts b/ets1.2/arkui-plugins/ui-plugins/preprocessor-transform.ts new file mode 100644 index 0000000000000000000000000000000000000000..139a00d95f7c42aa537f0bd982eaf2de64ebecfd --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/preprocessor-transform.ts @@ -0,0 +1,287 @@ +/* + * 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, VisitorOptions } from '../common/abstract-visitor'; +import { CustomComponentNames } from './utils'; +import { factory } from './ui-factory'; +import { + ARKUI_COMPONENT_IMPORT_NAME, + IMPORT_SOURCE_MAP, + OUTPUT_DEPENDENCY_MAP, + ARKUI_STATEMANAGEMENT_IMPORT_NAME, + KIT_ARKUI_NAME, +} from '../common/predefines'; +import { NameCollector } from './name-collector'; + +interface MemoImportCollection { + memo: boolean; + memoContextType: boolean; + memoIdType: boolean; +} + +export class PreprocessorTransformer extends AbstractVisitor { + private outNameArr: string[] = []; + private memoNameArr: string[] = []; + private structInterfaceImport: arkts.ETSImportDeclaration[] = []; + private memoImportCollection: Partial = {}; + private localComponentNames: string[] = []; + private isMemoImportOnce: boolean = false; + + private readonly nameCollector: NameCollector; + + constructor(options?: VisitorOptions) { + super(options); + this.nameCollector = NameCollector.getInstance(); + } + + reset(): void { + super.reset(); + this.outNameArr = []; + this.memoNameArr = []; + this.structInterfaceImport = []; + this.memoImportCollection = {}; + this.localComponentNames = []; + this.isMemoImportOnce = false; + IMPORT_SOURCE_MAP.clear(); + IMPORT_SOURCE_MAP.set('arkui.stateManagement.runtime', new Set(['memo', '__memo_context_type', '__memo_id_type'])); + } + + isCustomConponentDecl(node: arkts.CallExpression): boolean { + const structCollection: Set = arkts.GlobalInfo.getInfoInstance().getStructCollection(); + const nodeName: string = node.expression.dumpSrc(); + if (structCollection.has(nodeName)) { + return true; + } + return false; + } + + isComponentFunctionCall(node: arkts.CallExpression): boolean { + if (!node || !arkts.isIdentifier(node.expression)) return false; + return this.localComponentNames.includes(node.expression.name); + } + + transformComponentCall(node: arkts.CallExpression): arkts.TSAsExpression | arkts.CallExpression { + if (node.arguments.length === 0 && node.trailingBlock) { + return arkts.factory.updateCallExpression(node, node.expression, node.typeArguments, [ + arkts.factory.createUndefinedLiteral(), + ]); + } else if (arkts.isObjectExpression(node.arguments[0])) { + const componentName: string = `${ + CustomComponentNames.COMPONENT_INTERFACE_PREFIX + }${node.expression.dumpSrc()}`; + const newArg = arkts.factory.createTSAsExpression( + node.arguments[0].clone(), + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier(componentName)) + ), + true + ); + return arkts.factory.updateCallExpression(node, node.expression, node.typeArguments, [ + newArg, + ...node.arguments.slice(1), + ]); + } else { + return node; + } + } + + transformComponentFunctionCall(node: arkts.CallExpression) { + if (!node || !arkts.isIdentifier(node.expression)) return node; + + const componentInfo = this.nameCollector.getComponentInfo(node.expression.name); + if (!componentInfo) return node; + if (componentInfo.argsNum === 0) return node; + if (node.arguments.length >= componentInfo.argsNum - 1) return node; + + const defaultArgs: arkts.UndefinedLiteral[] = []; + let count = 0; + while (count < componentInfo.argsNum - node.arguments.length - 1) { + defaultArgs.push(arkts.factory.createUndefinedLiteral()); + count++; + } + return arkts.factory.updateCallExpression(node, node.expression, node.typeArguments, [ + ...node.arguments, + ...defaultArgs, + ]); + } + + addDependencesImport(node: arkts.ETSImportDeclaration): void { + if (!node.source) return; + + const isFromCompImport: boolean = node.source.str === ARKUI_COMPONENT_IMPORT_NAME || node.source.str === KIT_ARKUI_NAME; + const structCollection: Set = arkts.GlobalInfo.getInfoInstance().getStructCollection(); + node.specifiers.forEach((item: arkts.AstNode) => { + if (!arkts.isImportSpecifier(item) || !item.imported?.name) return; + + const importName: string = item.imported.name; + this.memoImportCollection.memo ||= importName === 'memo'; + this.memoImportCollection.memoContextType ||= importName === '__memo_context_type'; + this.memoImportCollection.memoIdType ||= importName === '__memo_id_type'; + if (isFromCompImport && this.nameCollector.getComponents().includes(importName)) { + this.localComponentNames.push(item.local?.name ?? importName); + } + + if (structCollection.has(importName)) { + const interfaceName: string = CustomComponentNames.COMPONENT_INTERFACE_PREFIX + importName; + const newImport: arkts.ETSImportDeclaration = arkts.factory.createImportDeclaration( + node.source?.clone(), + [factory.createAdditionalImportSpecifier(interfaceName, interfaceName)], + arkts.Es2pandaImportKinds.IMPORT_KINDS_VALUE, + this.program!, + arkts.Es2pandaImportFlags.IMPORT_FLAGS_NONE + ); + this.structInterfaceImport.push(newImport); + } else { + this.addImportWithSpecifier(item, node.source!); + } + }); + } + + getSourceDependency(sourceName: string): string { + let dependencyName: string = ''; + IMPORT_SOURCE_MAP.forEach((value: Set, key: string) => { + if (value.has(sourceName)) { + dependencyName = key; + } + }); + return dependencyName; + } + + updateSourceDependencyMap(key: string, value: string[]): void { + const newValue: Set = IMPORT_SOURCE_MAP.get(key) ?? new Set(); + for (const v of value) { + newValue.add(v); + } + IMPORT_SOURCE_MAP.set(key, newValue); + } + + getOutDependencyName(inputName: string): string[] { + const sourceName: string[] = []; + if (OUTPUT_DEPENDENCY_MAP.has(inputName)) { + OUTPUT_DEPENDENCY_MAP.get(inputName)!.forEach((item: string) => { + sourceName.push(item); + }); + } + return sourceName; + } + + updateOutDependencyMap(key: string, value: string[]): void { + const oldValue: string[] = OUTPUT_DEPENDENCY_MAP.get(key) ?? []; + const newValue: string[] = [...value, ...oldValue]; + OUTPUT_DEPENDENCY_MAP.set(key, newValue); + } + + clearGenSymInOutDependencyMap(genSymKey: string): void { + if (OUTPUT_DEPENDENCY_MAP.has(genSymKey)) { + OUTPUT_DEPENDENCY_MAP.delete(genSymKey); + } + } + + prepareDependencyMap(node: arkts.ImportSpecifier, source: arkts.StringLiteral): void { + if (!node.imported?.name) return; + + // Handling component imports + const importName: string = node.imported.name; + const sourceName: string = source.str; + if ( + this.nameCollector.getComponents().includes(importName) && + (sourceName === ARKUI_COMPONENT_IMPORT_NAME || sourceName === KIT_ARKUI_NAME) + ) { + const newDependencies = [`${importName}Attribute`]; + this.updateOutDependencyMap(importName, newDependencies); + this.updateSourceDependencyMap(sourceName, newDependencies); + } else if ( + OUTPUT_DEPENDENCY_MAP.get(importName) && + (sourceName === ARKUI_COMPONENT_IMPORT_NAME || + sourceName === ARKUI_STATEMANAGEMENT_IMPORT_NAME || + sourceName === KIT_ARKUI_NAME) + ) { + const newDependencies: string[] = OUTPUT_DEPENDENCY_MAP.get(importName) ?? []; + this.updateSourceDependencyMap(sourceName, newDependencies); + } + } + + prepareMemoImports(): void { + const newDependencies = []; + if (!this.memoImportCollection.memo) { + newDependencies.push('memo'); + } + if (!this.memoImportCollection.memoContextType) { + newDependencies.push('__memo_context_type'); + } + if (!this.memoImportCollection.memoIdType) { + newDependencies.push('__memo_id_type'); + } + if (newDependencies.length > 0) { + this.memoNameArr.push(...newDependencies); + this.isMemoImportOnce = true; + } + } + + addImportWithSpecifier(node: arkts.ImportSpecifier, source: arkts.StringLiteral): void { + if (!node.imported?.name) return; + + this.prepareDependencyMap(node, source); + const outName: string[] = this.getOutDependencyName(node.imported?.name); + this.outNameArr.push(...outName); + } + + updateScriptWithImport(): void { + if (!this.program) { + throw Error('Failed to insert import: Transformer has no program'); + } + + const outNames = new Set([...this.outNameArr, ...this.memoNameArr]); + outNames.forEach((item: string) => { + const source: string = this.getSourceDependency(item); + const newImport: arkts.ETSImportDeclaration = arkts.factory.createImportDeclaration( + arkts.factory.create1StringLiteral(source), + [factory.createAdditionalImportSpecifier(item, item)], + arkts.Es2pandaImportKinds.IMPORT_KINDS_VALUE, + this.program!, + arkts.Es2pandaImportFlags.IMPORT_FLAGS_NONE + ); + arkts.importDeclarationInsert(newImport, this.program!); + }); + this.structInterfaceImport.forEach((element: arkts.ETSImportDeclaration) => { + arkts.importDeclarationInsert(element, this.program!); + }); + } + + enter(node: arkts.AstNode): void { + if (this.isExternal && arkts.isFunctionDeclaration(node)) { + const component = this.nameCollector.findComponentFunction(node); + if (!!component) this.nameCollector.collectInfoFromComponentFunction(component); + } + } + + visitor(node: arkts.AstNode): arkts.AstNode { + this.enter(node); + const newNode = this.visitEachChild(node); + if (arkts.isCallExpression(newNode) && this.isCustomConponentDecl(newNode)) { + return this.transformComponentCall(newNode); + } else if (arkts.isCallExpression(newNode) && this.isComponentFunctionCall(newNode)) { + return this.transformComponentFunctionCall(newNode); + } + if (arkts.isETSImportDeclaration(node)) { + this.addDependencesImport(node); + } else if (arkts.isEtsScript(node)) { + if (!this.isMemoImportOnce) this.prepareMemoImports(); + this.updateScriptWithImport(); + } + return newNode; + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/printer-transformer.ts b/ets1.2/arkui-plugins/ui-plugins/printer-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..2ccab0b0ee73c012f40da268ffb6e7398c58b7b8 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/printer-transformer.ts @@ -0,0 +1,27 @@ +/* + * 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 { PrintVisitor } from '../common/print-visitor'; + +export interface TransformerOptions { + trace?: boolean; +} + +export default function printerTransformer(userPluginOptions?: TransformerOptions) { + return (node: arkts.EtsScript) => { + return new PrintVisitor().visitor(node); + }; +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/base.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/base.ts new file mode 100644 index 0000000000000000000000000000000000000000..4be00d1c8cca9781352e3477afcf32952e6aa32f --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/base.ts @@ -0,0 +1,86 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { createGetter, createSetter, getStageManagementIdent } from './utils'; +import { createOptionalClassProperty } from '../utils'; + +export abstract class PropertyTranslator { + constructor( + protected property: arkts.ClassProperty, + protected structName: string + ) {} + + abstract translateMember(): arkts.AstNode[]; + + translateWithoutInitializer(newName: string, originalName: string): arkts.AstNode[] { + const field = createOptionalClassProperty( + newName, + this.property, + getStageManagementIdent(this.property), + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE + ); + + const member = arkts.factory.createTSNonNullExpression( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier(newName), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ) + ); + const thisValue: arkts.MemberExpression = arkts.factory.createMemberExpression( + member, + arkts.factory.createIdentifier('value'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ); + + const getter: arkts.MethodDefinition = this.translateGetter( + originalName, + this.property.typeAnnotation, + thisValue + ); + const setter: arkts.MethodDefinition = this.translateSetter( + originalName, + this.property.typeAnnotation, + thisValue + ); + return [field, getter, setter]; + } + + translateGetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + returnValue: arkts.MemberExpression + ): arkts.MethodDefinition { + return createGetter(originalName, typeAnnotation, returnValue); + } + + translateSetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + left: arkts.MemberExpression + ): arkts.MethodDefinition { + const right: arkts.CallExpression = arkts.factory.createCallExpression( + arkts.factory.createIdentifier('observableProxy'), + undefined, + [arkts.factory.createIdentifier('value')] + ); + return createSetter(originalName, typeAnnotation, left, right); + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/builderParam.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/builderParam.ts new file mode 100644 index 0000000000000000000000000000000000000000..fbf600f066715a3f170c0f2bb9c9f07af511aedf --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/builderParam.ts @@ -0,0 +1,102 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { + createGetter, + createSetter, + generateThisBackingValue, + generateThisBacking, + getValueInAnnotation, + DecoratorNames, +} from './utils'; +import { PropertyTranslator } from './base'; +import { GetterSetter, InitializerConstructor } from './types'; +import { backingField, expectName } from '../../common/arkts-utils'; +import { createOptionalClassProperty } from '../utils'; +import { factory } from './factory'; + +export class BuilderParamTranslator extends PropertyTranslator implements InitializerConstructor, GetterSetter { + translateMember(): arkts.AstNode[] { + const originalName: string = expectName(this.property.key); + const newName: string = backingField(originalName); + this.cacheTranslatedInitializer(newName, originalName); // TODO: need to release cache after some point... + return this.translateWithoutInitializer(newName, originalName); + } + + cacheTranslatedInitializer(newName: string, originalName: string): void { + const currentStructInfo: arkts.StructInfo = arkts.GlobalInfo.getInfoInstance().getStructInfo(this.structName); + const mutableThis: arkts.Expression = generateThisBacking(newName); + const initializeStruct: arkts.AstNode = this.generateInitializeStruct(mutableThis, originalName); + currentStructInfo.initializeBody.push(initializeStruct); + arkts.GlobalInfo.getInfoInstance().setStructInfo(this.structName, currentStructInfo); + } + + translateWithoutInitializer(newName: string, originalName: string): arkts.AstNode[] { + const field: arkts.ClassProperty = createOptionalClassProperty(newName, this.property, '', + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE, true); + const thisGetValue: arkts.Expression = generateThisBacking(newName, false, true); + const thisSetValue: arkts.Expression = generateThisBacking(newName, false, false); + const getter: arkts.MethodDefinition = this.translateGetter( + originalName, + this.property.typeAnnotation, + thisGetValue + ); + const setter: arkts.MethodDefinition = this.translateSetter( + originalName, + this.property.typeAnnotation, + thisSetValue + ); + + return [field, getter, setter]; + } + + translateGetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + returnValue: arkts.Expression + ): arkts.MethodDefinition { + return createGetter(originalName, typeAnnotation, returnValue, true); + } + + translateSetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + left: arkts.Expression + ): arkts.MethodDefinition { + const right: arkts.Identifier = arkts.factory.createIdentifier('value'); + return createSetter(originalName, typeAnnotation, left, right, true); + } + + generateInitializeStruct(mutableThis: arkts.Expression, originalName: string): arkts.AstNode { + return arkts.factory.createAssignmentExpression( + mutableThis, + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + arkts.factory.createBinaryExpression( + arkts.factory.createBinaryExpression( + factory.createBlockStatementForOptionalExpression( + arkts.factory.createIdentifier('initializers'), + originalName + ), + arkts.factory.createIdentifier('content'), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_NULLISH_COALESCING + ), + this.property.value ?? arkts.factory.createUndefinedLiteral(), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_NULLISH_COALESCING + ) + ); + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/consume.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/consume.ts new file mode 100644 index 0000000000000000000000000000000000000000..bbb32deb1c9ffdfe306a05bf50c910e0843480c9 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/consume.ts @@ -0,0 +1,103 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { + generateToRecord, + createGetter, + createSetter2, + generateThisBacking, + generateGetOrSetCall, + getValueInAnnotation, + DecoratorNames, +} from './utils'; +import { PropertyTranslator } from './base'; +import { GetterSetter, InitializerConstructor } from './types'; +import { backingField, expectName } from '../../common/arkts-utils'; +import { createOptionalClassProperty } from '../utils'; +import { factory } from './factory'; + +export class ConsumeTranslator extends PropertyTranslator implements InitializerConstructor, GetterSetter { + translateMember(): arkts.AstNode[] { + const originalName: string = expectName(this.property.key); + const newName: string = backingField(originalName); + this.cacheTranslatedInitializer(newName, originalName); // TODO: need to release cache after some point... + return this.translateWithoutInitializer(newName, originalName); + } + + cacheTranslatedInitializer(newName: string, originalName: string): void { + const currentStructInfo: arkts.StructInfo = arkts.GlobalInfo.getInfoInstance().getStructInfo(this.structName); + const initializeStruct: arkts.AstNode = this.generateInitializeStruct(originalName, newName); + currentStructInfo.initializeBody.push(initializeStruct); + if (currentStructInfo.isReusable) { + const toRecord = generateToRecord(newName, originalName); + currentStructInfo.toRecordBody.push(toRecord); + } + arkts.GlobalInfo.getInfoInstance().setStructInfo(this.structName, currentStructInfo); + } + + translateWithoutInitializer(newName: string, originalName: string): arkts.AstNode[] { + const field: arkts.ClassProperty = createOptionalClassProperty( + newName, + this.property, + 'ConsumeDecoratedVariable', + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE + ); + const thisValue: arkts.Expression = generateThisBacking(newName, false, true); + const thisGet: arkts.CallExpression = generateGetOrSetCall(thisValue, 'get'); + const thisSet: arkts.ExpressionStatement = arkts.factory.createExpressionStatement( + generateGetOrSetCall(thisValue, 'set') + ); + const getter: arkts.MethodDefinition = this.translateGetter( + originalName, + this.property.typeAnnotation, + thisGet + ); + const setter: arkts.MethodDefinition = this.translateSetter( + originalName, + this.property.typeAnnotation, + thisSet + ); + + return [field, getter, setter]; + } + + translateGetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + returnValue: arkts.Expression + ): arkts.MethodDefinition { + return createGetter(originalName, typeAnnotation, returnValue); + } + + translateSetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + statement: arkts.AstNode + ): arkts.MethodDefinition { + return createSetter2(originalName, typeAnnotation, statement); + } + + generateInitializeStruct(originalName: string, newName: string): arkts.AstNode { + const alias = getValueInAnnotation(this.property, DecoratorNames.CONSUME); + const assign: arkts.AssignmentExpression = arkts.factory.createAssignmentExpression( + generateThisBacking(newName), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + factory.generateInitConsumeCall(originalName, this.property, alias ?? originalName) + ); + return arkts.factory.createExpressionStatement(assign); + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/factory.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/factory.ts new file mode 100644 index 0000000000000000000000000000000000000000..c1f610a4bf9c4ff43b0b5286ac50f8432f349c57 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/factory.ts @@ -0,0 +1,296 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { GenSymGenerator } from '../../common/gensym-generator'; +import { factory as UIFactory } from '../ui-factory'; +import { judgeIfAddWatchFunc } from './utils'; + +export class factory { + /** + * generate an substitution for optional expression ?., e.g. `{let _tmp = xxx; _tmp == null ? undefined : xxx}`. + * + * @param object item before ?.. + * @param key item after ?.. + */ + static createBlockStatementForOptionalExpression( + object: arkts.AstNode, + key: string, + isCall: boolean = false + ): arkts.Expression { + let id = GenSymGenerator.getInstance().id(key); + const statements: arkts.Statement[] = [ + factory.generateLetVariableDecl(arkts.factory.createIdentifier(id), object), + factory.generateTernaryExpression(id, key, isCall), + ]; + return arkts.factory.createBlockExpression(statements); + } + + /** + * generate a variable declaration, e.g. `let = `; + * + * @param left left expression. + * @param right right expression. + */ + static generateLetVariableDecl(left: arkts.Identifier, right: arkts.AstNode): arkts.VariableDeclaration { + return arkts.factory.createVariableDeclaration( + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET, + [ + arkts.factory.createVariableDeclarator( + arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_LET, + left, + right + ), + ] + ); + } + + /** + * generate a ternary expression, e.g. ` ? : `; + * + * @param testLeft the left hand of the test condition. + * @param key item after ?. + */ + static generateTernaryExpression( + testLeft: string, + key: string, + isCall: boolean = false + ): arkts.ExpressionStatement { + const test = arkts.factory.createBinaryExpression( + arkts.factory.createIdentifier(testLeft), + arkts.factory.createNullLiteral(), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_EQUAL + ); + const consequent: arkts.Expression = arkts.factory.createUndefinedLiteral(); + const alternate: arkts.MemberExpression = arkts.factory.createMemberExpression( + arkts.factory.createIdentifier(testLeft), + arkts.factory.createIdentifier(key), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ); + return arkts.factory.createExpressionStatement( + arkts.factory.createConditionalExpression( + test, + consequent, + isCall ? arkts.factory.createCallExpression(alternate, undefined, undefined) : alternate + ) + ); + } + + /** + * generate an substitution for two optional expression ?., e.g. a?.b?.c. + * + * @param node entry wrapper class declaration node. + */ + static createDoubleBlockStatementForOptionalExpression( + object: arkts.AstNode, + key1: string, + key2: string + ): arkts.Expression { + let id = GenSymGenerator.getInstance().id(key1); + let initial: arkts.Expression = factory.createBlockStatementForOptionalExpression(object, key1); + const statements: arkts.Statement[] = [ + factory.generateLetVariableDecl(arkts.factory.createIdentifier(id), initial), + factory.generateTernaryExpression(id, key2), + ]; + return arkts.factory.createBlockExpression(statements); + } + + /** + * generate an memberExpression with nonNull or optional, e.g. object.property, object?.property or object!.property + * + * @param object item before point. + * @param property item after point. + */ + static createNonNullOrOptionalMemberExpression( + object: string, + property: string, + optional: boolean, + nonNull: boolean + ): arkts.Expression { + const objectNode: arkts.Identifier = arkts.factory.createIdentifier(object); + return arkts.factory.createMemberExpression( + nonNull ? arkts.factory.createTSNonNullExpression(objectNode) : objectNode, + arkts.factory.createIdentifier(property), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + optional + ); + } + + /* + * create `(): => { }`. + */ + static createArrowFunctionWithParamsAndBody( + typeParams: arkts.TSTypeParameterDeclaration | undefined, + params: arkts.Expression[] | undefined, + returnType: arkts.TypeNode | undefined, + hasReceiver: boolean, + bodyStatementsList: arkts.Statement[] + ): arkts.ArrowFunctionExpression { + return arkts.factory.createArrowFunction( + arkts.factory.createScriptFunction( + arkts.BlockStatement.createBlockStatement(bodyStatementsList), + arkts.factory.createFunctionSignature(typeParams, params ? params : [], returnType, hasReceiver), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE + ) + ); + } + + /* + * create @Watch callback, e.g. (propertyName: string): void => {this.(propertyName)}. + */ + static createWatchCallback(callbackName: string): arkts.ArrowFunctionExpression { + return factory.createArrowFunctionWithParamsAndBody( + undefined, + [ + arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier('_', UIFactory.createTypeReferenceFromString('string')), + undefined + ), + ], + arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID), + false, + [ + arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression(factory.generateThisCall(callbackName), undefined, [ + arkts.factory.createIdentifier('_'), + ]) + ), + ] + ); + } + + /* + * create this. with optional or nonNullable. + */ + static generateThisCall(name: string, optional: boolean = false, nonNull: boolean = false): arkts.Expression { + const member: arkts.Expression = arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier(`${name}`), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + optional + ); + return nonNull ? arkts.factory.createTSNonNullExpression(member) : member; + } + + /* + * create `initializers!.!.()`. + */ + static createBackingGetOrSetCall( + newName: string, + getOrSet: string, + args: arkts.AstNode[] | undefined + ): arkts.CallExpression { + return arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createTSNonNullExpression( + factory.createNonNullOrOptionalMemberExpression('initializers', newName, false, true) + ), + arkts.factory.createIdentifier(getOrSet), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + args + ); + } + + /* + * create `new ()`. + */ + static createNewDecoratedInstantiate( + className: string, + typeAnnotation: arkts.TypeNode | undefined, + args: arkts.Expression[] | undefined + ): arkts.ETSNewClassInstanceExpression { + return arkts.factory.createETSNewClassInstanceExpression( + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier(className), + arkts.factory.createTSTypeParameterInstantiation(typeAnnotation ? [typeAnnotation.clone()] : []) + ) + ), + args?.length ? args : [] + ); + } + + /* + * create `this.addProvidedVar(, , initializers?. ?? , , watchFunc)`. + */ + static generateAddProvideVarCall( + originalName: string, + property: arkts.ClassProperty, + alias: string, + allowOverride: boolean = false + ): arkts.CallExpression { + const args: arkts.Expression[] = [ + arkts.factory.create1StringLiteral(originalName), + arkts.factory.create1StringLiteral(alias), + arkts.factory.createBinaryExpression( + factory.createBlockStatementForOptionalExpression( + arkts.factory.createIdentifier('initializers'), + originalName + ), + property.value ?? arkts.factory.createUndefinedLiteral(), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_NULLISH_COALESCING + ), + arkts.factory.createBooleanLiteral(allowOverride), + ]; + judgeIfAddWatchFunc(args, property); + return arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier('addProvidedVar'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + property.typeAnnotation ? [property.typeAnnotation.clone()] : undefined, + args + ); + } + + /* + * create `this.initConsume(, , watchFunc)`. + */ + static generateInitConsumeCall( + originalName: string, + property: arkts.ClassProperty, + alias: string + ): arkts.CallExpression { + const args: arkts.Expression[] = [ + arkts.factory.create1StringLiteral(originalName), + arkts.factory.create1StringLiteral(alias), + ]; + judgeIfAddWatchFunc(args, property); + return arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier('initConsume'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + property.typeAnnotation ? [property.typeAnnotation.clone()] : undefined, + args + ); + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/index.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..013eaa286d140d4664c074c678fa5e7f865be722 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/index.ts @@ -0,0 +1,85 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { PropertyTranslator } from './base'; +import { DecoratorNames, hasDecorator } from './utils'; +import { StateTranslator } from './state'; +import { PropTranslator } from './prop'; +import { StorageLinkTranslator } from './storagelink'; +import { LocalStorageLinkTranslator } from './localstoragelink'; +import { LinkTranslator } from './link'; +import { ObjectLinkTranslator } from './objectlink'; +import { LocalStoragePropTranslator } from './localstorageprop'; +import { regularPropertyTranslator } from './regularProperty'; +import { staticPropertyTranslator } from './staticProperty'; +import { isStatic } from '../utils'; +import { StoragePropTranslator } from './storageProp'; +import { ConsumeTranslator } from './consume'; +import { ProvideTranslator } from './provide'; +import { BuilderParamTranslator } from './builderParam'; +import { ObservedTrackTranslator } from './observedTrack'; +import { ClassScopeInfo } from 'ui-plugins/checked-transformer'; + +export { PropertyTranslator }; + +export function classifyProperty(member: arkts.AstNode, structName: string): PropertyTranslator | undefined { + if (!arkts.isClassProperty(member)) return undefined; + if (isStatic(member)) return new staticPropertyTranslator(member, structName); + + if (hasDecorator(member, DecoratorNames.STATE)) { + return new StateTranslator(member, structName); + } + if (hasDecorator(member, DecoratorNames.STORAGE_LINK)) { + return new StorageLinkTranslator(member, structName); + } + if (hasDecorator(member, DecoratorNames.LOCAL_STORAGE_LINK)) { + return new LocalStorageLinkTranslator(member, structName); + } + if (hasDecorator(member, DecoratorNames.LINK)) { + return new LinkTranslator(member, structName); + } + if (hasDecorator(member, DecoratorNames.OBJECT_LINK)) { + return new ObjectLinkTranslator(member, structName); + } + if (hasDecorator(member, DecoratorNames.LOCAL_STORAGE_PROP)) { + return new LocalStoragePropTranslator(member, structName); + } + if (hasDecorator(member, DecoratorNames.STORAGE_PROP)) { + return new StoragePropTranslator(member, structName); + } + if (hasDecorator(member, DecoratorNames.PROP)) { + return new PropTranslator(member, structName); + } + if (hasDecorator(member, DecoratorNames.PROVIDE)) { + return new ProvideTranslator(member, structName); + } + if (hasDecorator(member, DecoratorNames.CONSUME)) { + return new ConsumeTranslator(member, structName); + } + if (hasDecorator(member, DecoratorNames.BUILDER_PARAM)) { + return new BuilderParamTranslator(member, structName); + } + + return new regularPropertyTranslator(member, structName); +} + +export function classifyObservedTrack(member: arkts.AstNode, classScopeInfo: ClassScopeInfo): ObservedTrackTranslator | undefined { + if (!arkts.isClassProperty(member)) { + return undefined; + } + return new ObservedTrackTranslator(member, classScopeInfo); +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/link.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/link.ts new file mode 100644 index 0000000000000000000000000000000000000000..eafd90c955bfc1232e20cb6549218f525d4642e3 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/link.ts @@ -0,0 +1,119 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { + generateToRecord, + createGetter, + createSetter2, + generateThisBacking, + generateGetOrSetCall, + judgeIfAddWatchFunc, +} from './utils'; +import { PropertyTranslator } from './base'; +import { GetterSetter, InitializerConstructor } from './types'; +import { backingField, expectName } from '../../common/arkts-utils'; +import { factory } from './factory'; +import { createOptionalClassProperty } from '../utils'; + +export class LinkTranslator extends PropertyTranslator implements InitializerConstructor, GetterSetter { + translateMember(): arkts.AstNode[] { + const originalName: string = expectName(this.property.key); + const newName: string = backingField(originalName); + + this.cacheTranslatedInitializer(newName, originalName); // TODO: need to release cache after some point... + return this.translateWithoutInitializer(newName, originalName); + } + + cacheTranslatedInitializer(newName: string, originalName: string): void { + const currentStructInfo: arkts.StructInfo = arkts.GlobalInfo.getInfoInstance().getStructInfo(this.structName); + const initializeStruct: arkts.AstNode = this.generateInitializeStruct(newName, originalName); + currentStructInfo.initializeBody.push(initializeStruct); + if (currentStructInfo.isReusable) { + const toRecord = generateToRecord(newName, originalName); + currentStructInfo.toRecordBody.push(toRecord); + } + arkts.GlobalInfo.getInfoInstance().setStructInfo(this.structName, currentStructInfo); + } + + generateInitializeStruct(newName: string, originalName: string) { + const test = factory.createBlockStatementForOptionalExpression( + arkts.factory.createIdentifier('initializers'), + newName + ); + + const args: arkts.Expression[] = [ + arkts.factory.create1StringLiteral(originalName), + arkts.factory.createTSNonNullExpression( + factory.createNonNullOrOptionalMemberExpression('initializers', newName, false, true) + ), + ]; + judgeIfAddWatchFunc(args, this.property); + const consequent = arkts.BlockStatement.createBlockStatement([ + arkts.factory.createExpressionStatement( + arkts.factory.createAssignmentExpression( + generateThisBacking(newName, false, false), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + factory.createNewDecoratedInstantiate('LinkDecoratedVariable', this.property.typeAnnotation, args) + ) + ), + ]); + + return arkts.factory.createExpressionStatement(arkts.factory.createIfStatement(test, consequent)); + } + + translateWithoutInitializer(newName: string, originalName: string): arkts.AstNode[] { + const field: arkts.ClassProperty = createOptionalClassProperty( + newName, + this.property, + 'LinkDecoratedVariable', + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE + ); + const thisValue: arkts.Expression = generateThisBacking(newName, false, true); + const thisGet: arkts.CallExpression = generateGetOrSetCall(thisValue, 'get'); + const thisSet: arkts.ExpressionStatement = arkts.factory.createExpressionStatement( + generateGetOrSetCall(thisValue, 'set') + ); + const getter: arkts.MethodDefinition = this.translateGetter( + originalName, + this.property.typeAnnotation, + thisGet + ); + const setter: arkts.MethodDefinition = this.translateSetter( + originalName, + this.property.typeAnnotation, + thisSet + ); + + return [field, getter, setter]; + } + + translateGetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + returnValue: arkts.Expression + ): arkts.MethodDefinition { + return createGetter(originalName, typeAnnotation, returnValue); + } + + translateSetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + statement: arkts.AstNode + ): arkts.MethodDefinition { + return createSetter2(originalName, typeAnnotation, statement); + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/localstoragelink.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/localstoragelink.ts new file mode 100755 index 0000000000000000000000000000000000000000..a050e985294f30dcc9ddc5b92c4bcc8673eb18da --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/localstoragelink.ts @@ -0,0 +1,108 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { backingField, expectName } from '../../common/arkts-utils'; +import { PropertyTranslator } from './base'; +import { GetterSetter, InitializerConstructor } from './types'; +import { DecoratorNames, generateToRecord } from './utils'; + +function getLocalStorageLinkValueStr(node: arkts.AstNode): string | undefined { + if (!arkts.isClassProperty(node) || !node.value) return undefined; + return arkts.isStringLiteral(node.value) ? node.value.str : undefined; +} + +function getLocalStorageLinkAnnotationValue(anno: arkts.AnnotationUsage): string | undefined { + const isStorageLinkAnnotation: boolean = + !!anno.expr && arkts.isIdentifier(anno.expr) && anno.expr.name === DecoratorNames.LOCAL_STORAGE_LINK; + + if (isStorageLinkAnnotation && anno.properties.length === 1) { + return getLocalStorageLinkValueStr(anno.properties.at(0)!); + } + return undefined; +} + +function getLocalStorageLinkValueInAnnotation(node: arkts.ClassProperty): string | undefined { + const annotations: readonly arkts.AnnotationUsage[] = node.annotations; + + for (let i = 0; i < annotations.length; i++) { + const anno: arkts.AnnotationUsage = annotations[i]; + const str: string | undefined = getLocalStorageLinkAnnotationValue(anno); + if (!!str) { + return str; + } + } + + return undefined; +} + +export class LocalStorageLinkTranslator extends PropertyTranslator implements InitializerConstructor, GetterSetter { + translateMember(): arkts.AstNode[] { + const originalName: string = expectName(this.property.key); + const newName: string = backingField(originalName); + + this.cacheTranslatedInitializer(newName, originalName); // TODO: need to release cache after some point... + return this.translateWithoutInitializer(newName, originalName); + } + + cacheTranslatedInitializer(newName: string, originalName: string): void { + const currentStructInfo: arkts.StructInfo = arkts.GlobalInfo.getInfoInstance().getStructInfo(this.structName); + const initializeStruct: arkts.AstNode = this.generateInitializeStruct(newName, originalName); + currentStructInfo.initializeBody.push(initializeStruct); + + if (currentStructInfo.isReusable) { + const toRecord = generateToRecord(newName, originalName); + currentStructInfo.toRecordBody.push(toRecord); + } + + arkts.GlobalInfo.getInfoInstance().setStructInfo(this.structName, currentStructInfo); + } + + generateInitializeStruct(newName: string, originalName: string): arkts.AstNode { + const localStorageLinkValueStr: string | undefined = getLocalStorageLinkValueInAnnotation(this.property); + if (!localStorageLinkValueStr) { + throw new Error('LocalStorageLink required only one value!!'); // TODO: replace this with proper error message. + } + + const call = arkts.factory.createCallExpression( + arkts.factory.createIdentifier('StorageLinkState'), + this.property.typeAnnotation ? [this.property.typeAnnotation] : [], + [ + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier('_entry_local_storage_'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + arkts.factory.createStringLiteral(localStorageLinkValueStr), + this.property.value ?? arkts.factory.createUndefinedLiteral(), + ] + ); + + return arkts.factory.createAssignmentExpression( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier(newName), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + call + ); + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/localstorageprop.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/localstorageprop.ts new file mode 100644 index 0000000000000000000000000000000000000000..d20d982cd7feb8f773a4cbf7ffb19e48cb4ab48d --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/localstorageprop.ts @@ -0,0 +1,177 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { DecoratorNames, generateToRecord } from './utils'; +import { PropertyTranslator } from './base'; +import { GetterSetter, InitializerConstructor } from './types'; +import { backingField, expectName } from '../../common/arkts-utils'; + +function getLocalStorageporpValueStr(node: arkts.AstNode): string | undefined { + if (!arkts.isClassProperty(node) || !node.value) return undefined; + + return arkts.isStringLiteral(node.value) ? node.value.str : undefined; +} +function getLocalStorageporpAnnotationValue(anno: arkts.AnnotationUsage): string | undefined { + const isLocalStorageporpAnnotation: boolean = + !!anno.expr && arkts.isIdentifier(anno.expr) && anno.expr.name === DecoratorNames.LOCAL_STORAGE_PROP; + + if (isLocalStorageporpAnnotation && anno.properties.length === 1) { + return getLocalStorageporpValueStr(anno.properties.at(0)!); + } + return undefined; +} + +function getLocalStorageporpValueInAnnotation(node: arkts.ClassProperty): string | undefined { + const annotations: readonly arkts.AnnotationUsage[] = node.annotations; + + for (let i = 0; i < annotations.length; i++) { + const anno: arkts.AnnotationUsage = annotations[i]; + const str: string | undefined = getLocalStorageporpAnnotationValue(anno); + if (!!str) { + return str; + } + } + + return undefined; +} + +export class LocalStoragePropTranslator extends PropertyTranslator implements InitializerConstructor, GetterSetter { + translateMember(): arkts.AstNode[] { + const originalName: string = expectName(this.property.key); + const newName: string = backingField(originalName); + + this.cacheTranslatedInitializer(newName, originalName); // TODO: need to release cache after some point... + return this.translateWithoutInitializer(newName, originalName); + } + + cacheTranslatedInitializer(newName: string, originalName: string): void { + const currentStructInfo: arkts.StructInfo = arkts.GlobalInfo.getInfoInstance().getStructInfo(this.structName); + const initializeStruct: arkts.AstNode = this.generateInitializeStruct(newName, originalName); + const updateStruct: arkts.AstNode = this.generateUpdateStruct(newName, originalName); + currentStructInfo.initializeBody.push(initializeStruct); + currentStructInfo.updateBody.push(updateStruct); + + if (currentStructInfo.isReusable) { + const toRecord = generateToRecord(newName, originalName); + currentStructInfo.toRecordBody.push(toRecord); + } + + arkts.GlobalInfo.getInfoInstance().setStructInfo(this.structName, currentStructInfo); + } + + generateInitializeStruct(newName: string, originalName: string): arkts.AstNode { + const localStorageporpValueStr: string | undefined = getLocalStorageporpValueInAnnotation(this.property); + if (!localStorageporpValueStr) { + throw new Error('LocalStorageProp required only one value!!'); // TODO: replace this with proper error message. + } + const insideMember = arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier('_entry_local_storage_'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ); + const binaryItem = arkts.factory.createCallExpression( + arkts.factory.createIdentifier('StorageLinkState'), + this.property.typeAnnotation ? [this.property.typeAnnotation] : [], + [ + insideMember, + arkts.factory.createStringLiteral(localStorageporpValueStr), + this.property.value ?? arkts.factory.createUndefinedLiteral(), + ] + ); + const call = arkts.factory.createCallExpression( + arkts.factory.createIdentifier('propState'), + this.property.typeAnnotation ? [this.property.typeAnnotation] : [], + [ + arkts.factory.createMemberExpression( + binaryItem, + arkts.factory.createIdentifier('value'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + ] + ); + return arkts.factory.createAssignmentExpression( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier(newName), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + call + ); + } + + generateUpdateStruct(newName: string, originalName: string): arkts.AstNode { + const localStorageporpValueStr: string | undefined = getLocalStorageporpValueInAnnotation(this.property); + if (!localStorageporpValueStr) { + throw new Error('StorageLink required only one value!!'); // TODO: replace this with proper error message. + } + + const StorageLinkStateValue = arkts.factory.createMemberExpression( + arkts.factory.createCallExpression( + arkts.factory.createIdentifier('StorageLinkState'), + this.property.typeAnnotation ? [this.property.typeAnnotation] : [], + [ + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier('_entry_local_storage_'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + arkts.factory.createStringLiteral(localStorageporpValueStr), + this.property.value ?? arkts.factory.createUndefinedLiteral(), + ] + ), + arkts.factory.createIdentifier('value'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ); + + const test = arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier(newName), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ); + + const consequent = arkts.BlockStatement.createBlockStatement([ + arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createTSNonNullExpression(test), + arkts.factory.createIdentifier('update'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + [StorageLinkStateValue] + ) + ), + ]); + + return arkts.factory.createExpressionStatement(arkts.factory.createIfStatement(test, consequent)); + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/objectlink.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/objectlink.ts new file mode 100644 index 0000000000000000000000000000000000000000..8da1283a269f18d813221d7c34db35c7f9f96a26 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/objectlink.ts @@ -0,0 +1,153 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { + createGetter, + DecoratorNames, + generateGetOrSetCall, + generateThisBacking, + generateToRecord, + hasDecorator, + judgeIfAddWatchFunc, +} from './utils'; +import { PropertyTranslator } from './base'; +import { GetterSetter, InitializerConstructor } from './types'; +import { backingField, expectName } from '../../common/arkts-utils'; +import { factory } from './factory'; +import { createOptionalClassProperty } from '../utils'; + +export class ObjectLinkTranslator extends PropertyTranslator implements InitializerConstructor, GetterSetter { + translateMember(): arkts.AstNode[] { + const originalName: string = expectName(this.property.key); + const newName: string = backingField(originalName); + if (!this.ifObservedDecoratedClass()) { + throw new Error('@ObjectLink decorated property only accepts @Observed decorated class instance'); // TODO: replace this with proper error message. + } + + this.cacheTranslatedInitializer(newName, originalName); // TODO: need to release cache after some point... + return this.translateWithoutInitializer(newName, originalName); + } + + cacheTranslatedInitializer(newName: string, originalName: string): void { + const currentStructInfo: arkts.StructInfo = arkts.GlobalInfo.getInfoInstance().getStructInfo(this.structName); + const initializeStruct: arkts.AstNode = this.generateInitializeStruct(newName, originalName); + const updateStruct: arkts.AstNode = this.generateUpdateStruct(newName, originalName); + currentStructInfo.initializeBody.push(initializeStruct); + currentStructInfo.updateBody.push(updateStruct); + + if (currentStructInfo.isReusable) { + const toRecord = generateToRecord(newName, originalName); + currentStructInfo.toRecordBody.push(toRecord); + } + + arkts.GlobalInfo.getInfoInstance().setStructInfo(this.structName, currentStructInfo); + } + + generateInitializeStruct(newName: string, originalName: string): arkts.AstNode { + const initializers = arkts.factory.createTSNonNullExpression( + factory.createBlockStatementForOptionalExpression( + arkts.factory.createIdentifier('initializers'), + originalName + ) + ); + + const args: arkts.Expression[] = [arkts.factory.create1StringLiteral(originalName), initializers]; + judgeIfAddWatchFunc(args, this.property); + + const newClass = arkts.factory.createETSNewClassInstanceExpression( + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier('ObjectLinkDecoratedVariable'), + arkts.factory.createTSTypeParameterInstantiation( + this.property.typeAnnotation ? [this.property.typeAnnotation] : [] + ) + ) + ), + args + ); + + return arkts.factory.createAssignmentExpression( + generateThisBacking(newName), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + newClass + ); + } + + generateUpdateStruct(newName: string, originalName: string): arkts.AstNode { + const binaryItem = arkts.factory.createBinaryExpression( + factory.createBlockStatementForOptionalExpression( + arkts.factory.createIdentifier('initializers'), + originalName + ), + arkts.factory.createUndefinedLiteral(), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_NOT_STRICT_EQUAL + ); + const member: arkts.MemberExpression = arkts.factory.createMemberExpression( + generateThisBacking(newName, false, true), + arkts.factory.createIdentifier('update'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ); + const nonNullItem = arkts.factory.createTSNonNullExpression( + factory.createNonNullOrOptionalMemberExpression('initializers', originalName, false, true) + ); + return arkts.factory.createIfStatement( + binaryItem, + arkts.factory.createBlock([ + arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression(member, undefined, [nonNullItem]) + ), + ]) + ); + } + + translateWithoutInitializer(newName: string, originalName: string): arkts.AstNode[] { + const field: arkts.ClassProperty = createOptionalClassProperty( + newName, + this.property, + 'ObjectLinkDecoratedVariable', + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE + ); + const thisValue: arkts.Expression = generateThisBacking(newName, false, true); + const thisGet: arkts.CallExpression = generateGetOrSetCall(thisValue, 'get'); + const getter: arkts.MethodDefinition = this.translateGetter( + originalName, + this.property.typeAnnotation, + thisGet + ); + return [field, getter]; + } + + translateGetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + returnValue: arkts.Expression + ): arkts.MethodDefinition { + return createGetter(originalName, typeAnnotation, returnValue); + } + + ifObservedDecoratedClass(): boolean { + if (this.property.typeAnnotation && arkts.isETSTypeReference(this.property.typeAnnotation)) { + const decl = arkts.getDecl(this.property.typeAnnotation.part?.name!); + if (arkts.isClassDefinition(decl!) && hasDecorator(decl, DecoratorNames.OBSERVED)) { + return true; + } + } + return false; + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/observedTrack.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/observedTrack.ts new file mode 100644 index 0000000000000000000000000000000000000000..036132553c06bbb54e0c5a7cbd35848221a36eed --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/observedTrack.ts @@ -0,0 +1,348 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { backingField, expectName } from '../../common/arkts-utils'; +import { DecoratorNames, hasDecorator } from './utils'; +import { ClassScopeInfo } from 'ui-plugins/checked-transformer'; + +export class ObservedTrackTranslator { + constructor(protected property: arkts.ClassProperty, protected classScopeInfo: ClassScopeInfo) {} + + private hasImplement: boolean = expectName(this.property.key).startsWith(''); + private isTracked: boolean = hasDecorator(this.property, DecoratorNames.TRACK); + + translateMember(): arkts.AstNode[] { + if (!this.isTracked && (this.classScopeInfo.classHasTrack || !this.classScopeInfo.isObserved)) { + return [this.property]; + } + const originalName: string = this.hasImplement + ? this.removeImplementProperty(expectName(this.property.key)) + : expectName(this.property.key); + const newName: string = backingField(originalName); + let properyIsClass = false; + + if (this.property.typeAnnotation && arkts.isETSTypeReference(this.property.typeAnnotation)) { + const decl = arkts.getDecl(this.property.typeAnnotation.part?.name!); + if (arkts.isClassDefinition(decl!)) { + properyIsClass = true; + } + } + const field = this.createField(originalName, newName, properyIsClass); + + this.transformGetterSetter(originalName, newName, properyIsClass); + + return [...field]; + } + + createField(originalName: string, newName: string, properyIsClass: boolean): arkts.ClassProperty[] { + const backingField = properyIsClass + ? this.propertyIsClassField(newName) + : arkts.factory.createClassProperty( + arkts.factory.createIdentifier(newName), + this.property.value, + this.property.typeAnnotation, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE, + false + ); + if (!this.isTracked) { + return [backingField]; + } + const metaField = this.metaField(originalName); + return [backingField, metaField]; + } + + createGetter(originalName: string, newName: string, properyIsClass: boolean): arkts.MethodDefinition { + const ifRefDepth: arkts.IfStatement = this.getterIfRefDepth(originalName); + const returnMember: arkts.ReturnStatement = this.getterReturnMember(properyIsClass, newName); + const setObservationDepth = this.getterSetObservationDepth(newName); + + const body = arkts.factory.createBlock([ + ifRefDepth, + ...(properyIsClass ? [setObservationDepth] : []), + returnMember, + ]); + + const scriptFunction = arkts.factory.createScriptFunction( + body, + arkts.FunctionSignature.createFunctionSignature(undefined, [], this.property.typeAnnotation, false), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_GETTER, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC + ); + + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_GET, + arkts.factory.createIdentifier(originalName), + scriptFunction, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC, + false + ); + } + + createSetter(originalName: string, newName: string, properyIsClass: boolean): arkts.MethodDefinition { + const ifEqualsNewValue: arkts.IfStatement = this.setterIfEqualsNewValue(properyIsClass, originalName, newName); + const body = arkts.factory.createBlock([ifEqualsNewValue]); + const param = arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier('newValue', this.property.typeAnnotation), + undefined + ); + + const scriptFunction = arkts.factory.createScriptFunction( + body, + arkts.FunctionSignature.createFunctionSignature(undefined, [param], undefined, false), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_SETTER, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC + ); + + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_SET, + arkts.factory.createIdentifier(originalName), + scriptFunction, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC, + false + ); + } + + genThisBacking(newName: string): arkts.MemberExpression { + return arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier(newName), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ); + } + + genThisBackingValue(newName: string): arkts.MemberExpression { + return arkts.factory.createMemberExpression( + this.genThisBacking(newName), + arkts.factory.createIdentifier('value'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ); + } + + metaIdentifier(originalName: string): arkts.Identifier { + return this.isTracked + ? arkts.factory.createIdentifier(`__meta_${originalName}`) + : arkts.factory.createIdentifier('__meta'); + } + + removeImplementProperty(originalName: string): string { + const prefix = ''; + return originalName.substring(prefix.length); + } + + transformGetterSetter(originalName: string, newName: string, properyIsClass: boolean): void { + const newGetter = this.createGetter(originalName, newName, properyIsClass); + const newSetter = this.createSetter(originalName, newName, properyIsClass); + if (this.hasImplement) { + { + const idx: number = this.classScopeInfo.getters.findIndex( + (getter) => getter.name.name === originalName + ); + const originGetter: arkts.MethodDefinition = this.classScopeInfo.getters[idx]; + const originSetter: arkts.MethodDefinition = originGetter.overloads[0]; + const updateGetter: arkts.MethodDefinition = arkts.factory.updateMethodDefinition( + originGetter, + originGetter.kind, + newGetter.name, + newGetter.scriptFunction.addFlag(arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_METHOD), + originGetter.modifiers, + false + ); + arkts.factory.updateMethodDefinition( + originSetter, + originSetter.kind, + newSetter.name, + newSetter.scriptFunction + .addFlag(arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_OVERLOAD) + .addFlag(arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_METHOD), + originSetter.modifiers, + false + ); + this.classScopeInfo.getters[idx] = updateGetter; + } + } else { + this.classScopeInfo.getters.push(...[newGetter, newSetter]); + } + } + + propertyIsClassField(newName: string): arkts.ClassProperty { + return arkts.factory.createClassProperty( + arkts.factory.createIdentifier(newName), + this.property.value + ? arkts.factory.createETSNewClassInstanceExpression( + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier('BackingValue'), + arkts.factory.createTSTypeParameterInstantiation( + this.property.typeAnnotation ? [this.property.typeAnnotation] : [] + ) + ) + ), + [this.property.value] + ) + : undefined, + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier('BackingValue'), + arkts.factory.createTSTypeParameterInstantiation( + this.property.typeAnnotation ? [this.property.typeAnnotation] : [] + ) + ) + ), + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE, + false + ); + } + + metaField(originalName: string): arkts.ClassProperty { + return arkts.factory.createClassProperty( + arkts.factory.createIdentifier(`__meta_${originalName}`), + arkts.factory.createETSNewClassInstanceExpression( + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier('MutableStateMeta')) + ), + [arkts.factory.createStringLiteral('@Track')] + ), + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier('MutableStateMeta')) + ), + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE, + false + ); + } + + getterIfRefDepth(originalName: string): arkts.IfStatement { + return arkts.factory.createIfStatement( + arkts.factory.createBinaryExpression( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier('_permissibleAddRefDepth'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + arkts.factory.createNumericLiteral(0), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_GREATER_THAN + ), + arkts.factory.createBlock([ + arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + this.metaIdentifier(originalName), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + arkts.factory.createIdentifier('addRef'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + undefined, + false, + false + ) + ), + ]) + ); + } + + getterSetObservationDepth(newName: string): arkts.ExpressionStatement { + return arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression(arkts.factory.createIdentifier('setObservationDepth'), undefined, [ + this.genThisBackingValue(newName), + arkts.factory.createBinaryExpression( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier('_permissibleAddRefDepth'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + arkts.factory.createNumericLiteral(1), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_MINUS + ), + ]) + ); + } + + getterReturnMember(properyIsClass: boolean, newName: string): arkts.ReturnStatement { + return arkts.factory.createReturnStatement( + properyIsClass ? this.genThisBackingValue(newName) : this.genThisBacking(newName) + ); + } + + setterIfEqualsNewValue(properyIsClass: boolean, originalName: string, newName: string): arkts.IfStatement { + const backingValue = properyIsClass ? this.genThisBackingValue(newName) : this.genThisBacking(newName); + + const setNewValue = arkts.factory.createExpressionStatement( + arkts.factory.createAssignmentExpression( + backingValue, + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + arkts.factory.createIdentifier('newValue') + ) + ); + + const fireChange = arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + this.metaIdentifier(originalName), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + arkts.factory.createIdentifier('fireChange'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + undefined + ) + ); + + const subscribingWatches = arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier('executeOnSubscribingWatches'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + [arkts.factory.createStringLiteral(originalName)] + ) + ); + + return arkts.factory.createIfStatement( + arkts.factory.createBinaryExpression( + backingValue, + arkts.factory.createIdentifier('newValue'), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_NOT_STRICT_EQUAL + ), + arkts.factory.createBlock([setNewValue, fireChange, subscribingWatches]) + ); + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/prop.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/prop.ts new file mode 100644 index 0000000000000000000000000000000000000000..b8bb3d9914cf0e37a87249cf2d94c899f0caab9c --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/prop.ts @@ -0,0 +1,167 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { + generateToRecord, + createGetter, + createSetter2, + generateGetOrSetCall, + generateThisBacking, + judgeIfAddWatchFunc, +} from './utils'; +import { PropertyTranslator } from './base'; +import { GetterSetter, InitializerConstructor } from './types'; +import { backingField, expectName } from '../../common/arkts-utils'; +import { createOptionalClassProperty } from '../utils'; +import { factory } from './factory'; + +export class PropTranslator extends PropertyTranslator implements InitializerConstructor, GetterSetter { + translateMember(): arkts.AstNode[] { + const originalName: string = expectName(this.property.key); + const newName: string = backingField(originalName); + + this.cacheTranslatedInitializer(newName, originalName); // TODO: need to release cache after some point... + return this.translateWithoutInitializer(newName, originalName); + } + + cacheTranslatedInitializer(newName: string, originalName: string): void { + const currentStructInfo: arkts.StructInfo = arkts.GlobalInfo.getInfoInstance().getStructInfo(this.structName); + const mutableThis: arkts.Expression = generateThisBacking(newName); + const initializeStruct: arkts.AstNode = this.generateInitializeStruct(newName, originalName); + const updateStruct: arkts.AstNode = this.generateUpdateStruct(mutableThis, originalName); + currentStructInfo.initializeBody.push(initializeStruct); + currentStructInfo.updateBody.push(updateStruct); + if (currentStructInfo.isReusable) { + const toRecord = generateToRecord(newName, originalName); + currentStructInfo.toRecordBody.push(toRecord); + } + arkts.GlobalInfo.getInfoInstance().setStructInfo(this.structName, currentStructInfo); + } + + translateWithoutInitializer(newName: string, originalName: string): arkts.AstNode[] { + const field: arkts.ClassProperty = createOptionalClassProperty( + newName, + this.property, + 'PropDecoratedVariable', + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE + ); + const thisValue: arkts.Expression = generateThisBacking(newName, false, true); + const thisGet: arkts.CallExpression = generateGetOrSetCall(thisValue, 'get'); + const thisSet: arkts.ExpressionStatement = arkts.factory.createExpressionStatement( + generateGetOrSetCall(thisValue, 'set') + ); + const getter: arkts.MethodDefinition = this.translateGetter( + originalName, + this.property.typeAnnotation, + thisGet + ); + const setter: arkts.MethodDefinition = this.translateSetter( + originalName, + this.property.typeAnnotation, + thisSet + ); + + return [field, getter, setter]; + } + + translateGetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + returnValue: arkts.Expression + ): arkts.MethodDefinition { + return createGetter(originalName, typeAnnotation, returnValue); + } + + translateSetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + statement: arkts.AstNode + ): arkts.MethodDefinition { + return createSetter2(originalName, typeAnnotation, statement); + } + + generateInitializeStruct(newName: string, originalName: string): arkts.AstNode { + const binaryItem = arkts.factory.createBinaryExpression( + factory.createBlockStatementForOptionalExpression( + arkts.factory.createIdentifier('initializers'), + originalName + ), + this.property.value ?? arkts.factory.createUndefinedLiteral(), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_NULLISH_COALESCING + ); + const args: arkts.Expression[] = [ + arkts.factory.create1StringLiteral(originalName), + this.property.value + ? binaryItem + : arkts.factory.createTSAsExpression( + factory.createNonNullOrOptionalMemberExpression('initializers', originalName, false, true), + this.property.typeAnnotation ? this.property.typeAnnotation.clone() : undefined, + false + ), + ]; + judgeIfAddWatchFunc(args, this.property); + const right = arkts.factory.createETSNewClassInstanceExpression( + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier('PropDecoratedVariable'), + arkts.factory.createTSTypeParameterInstantiation( + this.property.typeAnnotation ? [this.property.typeAnnotation] : [] + ) + ) + ), + args + ); + const assign: arkts.AssignmentExpression = arkts.factory.createAssignmentExpression( + generateThisBacking(newName), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + right + ); + return arkts.factory.createExpressionStatement(assign); + } + + generateUpdateStruct(mutableThis: arkts.Expression, originalName: string): arkts.AstNode { + const binaryItem = arkts.factory.createBinaryExpression( + factory.createBlockStatementForOptionalExpression( + arkts.factory.createIdentifier('initializers'), + originalName + ), + arkts.factory.createUndefinedLiteral(), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_NOT_STRICT_EQUAL + ); + const member: arkts.MemberExpression = arkts.factory.createMemberExpression( + arkts.factory.createTSNonNullExpression(mutableThis), + arkts.factory.createIdentifier('update'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ); + return arkts.factory.createIfStatement( + binaryItem, + arkts.factory.createBlock([ + arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression(member, undefined, [ + arkts.factory.createTSAsExpression( + factory.createNonNullOrOptionalMemberExpression('initializers', originalName, false, true), + this.property.typeAnnotation ? this.property.typeAnnotation.clone() : undefined, + false + ), + ]) + ), + ]) + ); + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/provide.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/provide.ts new file mode 100644 index 0000000000000000000000000000000000000000..144d1239a1d34d35c53518940cb2398ade5fd8cc --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/provide.ts @@ -0,0 +1,105 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { + generateToRecord, + createGetter, + createSetter2, + generateThisBacking, + generateGetOrSetCall, + getValueInProvideAnnotation, + ProvideOptions, +} from './utils'; +import { PropertyTranslator } from './base'; +import { GetterSetter, InitializerConstructor } from './types'; +import { backingField, expectName } from '../../common/arkts-utils'; +import { createOptionalClassProperty } from '../utils'; +import { factory } from './factory'; + +export class ProvideTranslator extends PropertyTranslator implements InitializerConstructor, GetterSetter { + translateMember(): arkts.AstNode[] { + const originalName: string = expectName(this.property.key); + const newName: string = backingField(originalName); + this.cacheTranslatedInitializer(newName, originalName); // TODO: need to release cache after some point... + return this.translateWithoutInitializer(newName, originalName); + } + + cacheTranslatedInitializer(newName: string, originalName: string): void { + const currentStructInfo: arkts.StructInfo = arkts.GlobalInfo.getInfoInstance().getStructInfo(this.structName); + const initializeStruct: arkts.AstNode = this.generateInitializeStruct(originalName, newName); + currentStructInfo.initializeBody.push(initializeStruct); + if (currentStructInfo.isReusable) { + const toRecord = generateToRecord(newName, originalName); + currentStructInfo.toRecordBody.push(toRecord); + } + arkts.GlobalInfo.getInfoInstance().setStructInfo(this.structName, currentStructInfo); + } + + translateWithoutInitializer(newName: string, originalName: string): arkts.AstNode[] { + const field: arkts.ClassProperty = createOptionalClassProperty( + newName, + this.property, + 'ProvideDecoratedVariable', + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE + ); + const thisValue: arkts.Expression = generateThisBacking(newName, false, true); + const thisGet: arkts.CallExpression = generateGetOrSetCall(thisValue, 'get'); + const thisSet: arkts.ExpressionStatement = arkts.factory.createExpressionStatement( + generateGetOrSetCall(thisValue, 'set') + ); + const getter: arkts.MethodDefinition = this.translateGetter( + originalName, + this.property.typeAnnotation, + thisGet + ); + const setter: arkts.MethodDefinition = this.translateSetter( + originalName, + this.property.typeAnnotation, + thisSet + ); + + return [field, getter, setter]; + } + + translateGetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + returnValue: arkts.Expression + ): arkts.MethodDefinition { + return createGetter(originalName, typeAnnotation, returnValue); + } + + translateSetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + statement: arkts.AstNode + ): arkts.MethodDefinition { + return createSetter2(originalName, typeAnnotation, statement); + } + + generateInitializeStruct(originalName: string, newName: string): arkts.AstNode { + const options: undefined | ProvideOptions = getValueInProvideAnnotation(this.property); + const alias: string = options?.alias ?? originalName; + const allowOverride: boolean = options?.allowOverride ?? false; + const assign: arkts.AssignmentExpression = arkts.factory.createAssignmentExpression( + generateThisBacking(newName), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + factory.generateAddProvideVarCall(originalName, this.property, alias, allowOverride) + ); + return arkts.factory.createExpressionStatement(assign); + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/regularProperty.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/regularProperty.ts new file mode 100644 index 0000000000000000000000000000000000000000..d89b471e77471008589650dea558d5d86e5e201c --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/regularProperty.ts @@ -0,0 +1,105 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { createGetter, generateToRecord, generateThisBacking, createSetter2 } from './utils'; +import { PropertyTranslator } from './base'; +import { GetterSetter, InitializerConstructor } from './types'; +import { createOptionalClassProperty } from '../utils'; +import { backingField, expectName } from '../../common/arkts-utils'; +import { factory } from './factory'; + +export class regularPropertyTranslator extends PropertyTranslator implements InitializerConstructor, GetterSetter { + translateMember(): arkts.AstNode[] { + const originalName: string = expectName(this.property.key); + const newName: string = backingField(originalName); + this.cacheTranslatedInitializer(newName, originalName); // TODO: need to release cache after some point... + return this.translateWithoutInitializer(newName, originalName); + } + + cacheTranslatedInitializer(newName: string, originalName: string): void { + const currentStructInfo: arkts.StructInfo = arkts.GlobalInfo.getInfoInstance().getStructInfo(this.structName); + const initializeStruct: arkts.AstNode = this.generateInitializeStruct(newName, originalName); + currentStructInfo.initializeBody.push(initializeStruct); + if (currentStructInfo.isReusable) { + const toRecord = generateToRecord(newName, originalName); + currentStructInfo.toRecordBody.push(toRecord); + } + arkts.GlobalInfo.getInfoInstance().setStructInfo(this.structName, currentStructInfo); + } + + translateWithoutInitializer(newName: string, originalName: string): arkts.AstNode[] { + const field: arkts.ClassProperty = createOptionalClassProperty( + newName, + this.property, + '', + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE + ); + const thisValue: arkts.Expression = generateThisBacking(newName, false, false); + const thisSet: arkts.ExpressionStatement = arkts.factory.createExpressionStatement( + arkts.factory.createAssignmentExpression( + thisValue, + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + arkts.factory.createIdentifier('value'), + ) + ); + const getter: arkts.MethodDefinition = this.translateGetter( + originalName, + this.property.typeAnnotation, + arkts.factory.createTSAsExpression(thisValue, this.property.typeAnnotation, false) + ); + const setter: arkts.MethodDefinition = this.translateSetter( + originalName, + this.property.typeAnnotation, + thisSet + ); + + return [field, getter, setter]; + } + + translateGetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + returnValue: arkts.Expression + ): arkts.MethodDefinition { + return createGetter(originalName, typeAnnotation, returnValue); + } + + translateSetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + statement: arkts.AstNode + ): arkts.MethodDefinition { + return createSetter2(originalName, typeAnnotation, statement); + } + + generateInitializeStruct(newName: string, originalName: string): arkts.AstNode { + const binaryItem = arkts.factory.createBinaryExpression( + factory.createBlockStatementForOptionalExpression( + arkts.factory.createIdentifier('initializers'), + originalName + ), + this.property.value ?? arkts.factory.createUndefinedLiteral(), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_NULLISH_COALESCING + ); + const assign: arkts.AssignmentExpression = arkts.factory.createAssignmentExpression( + generateThisBacking(newName), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + binaryItem + ); + return arkts.factory.createExpressionStatement(assign); + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/state.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/state.ts new file mode 100644 index 0000000000000000000000000000000000000000..667fabac74a82ac38516770170ca9f536560aa3c --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/state.ts @@ -0,0 +1,122 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { + generateToRecord, + createGetter, + createSetter2, + generateThisBacking, + generateGetOrSetCall, + judgeIfAddWatchFunc, +} from './utils'; +import { PropertyTranslator } from './base'; +import { GetterSetter, InitializerConstructor } from './types'; +import { backingField, expectName } from '../../common/arkts-utils'; +import { createOptionalClassProperty } from '../utils'; +import { factory } from './factory'; + +export class StateTranslator extends PropertyTranslator implements InitializerConstructor, GetterSetter { + translateMember(): arkts.AstNode[] { + const originalName: string = expectName(this.property.key); + const newName: string = backingField(originalName); + this.cacheTranslatedInitializer(newName, originalName); // TODO: need to release cache after some point... + return this.translateWithoutInitializer(newName, originalName); + } + + cacheTranslatedInitializer(newName: string, originalName: string): void { + const currentStructInfo: arkts.StructInfo = arkts.GlobalInfo.getInfoInstance().getStructInfo(this.structName); + const initializeStruct: arkts.AstNode = this.generateInitializeStruct(newName, originalName); + currentStructInfo.initializeBody.push(initializeStruct); + if (currentStructInfo.isReusable) { + const toRecord = generateToRecord(newName, originalName); + currentStructInfo.toRecordBody.push(toRecord); + } + arkts.GlobalInfo.getInfoInstance().setStructInfo(this.structName, currentStructInfo); + } + + translateWithoutInitializer(newName: string, originalName: string): arkts.AstNode[] { + const field: arkts.ClassProperty = createOptionalClassProperty( + newName, + this.property, + 'StateDecoratedVariable', + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE + ); + const thisValue: arkts.Expression = generateThisBacking(newName, false, true); + const thisGet: arkts.CallExpression = generateGetOrSetCall(thisValue, 'get'); + const thisSet: arkts.ExpressionStatement = arkts.factory.createExpressionStatement( + generateGetOrSetCall(thisValue, 'set') + ); + const getter: arkts.MethodDefinition = this.translateGetter( + originalName, + this.property.typeAnnotation, + thisGet + ); + const setter: arkts.MethodDefinition = this.translateSetter( + originalName, + this.property.typeAnnotation, + thisSet + ); + + return [field, getter, setter]; + } + + translateGetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + returnValue: arkts.Expression + ): arkts.MethodDefinition { + return createGetter(originalName, typeAnnotation, returnValue); + } + + translateSetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + statement: arkts.AstNode + ): arkts.MethodDefinition { + return createSetter2(originalName, typeAnnotation, statement); + } + + generateInitializeStruct(newName: string, originalName: string): arkts.AstNode { + const binaryItem = arkts.factory.createBinaryExpression( + factory.createBlockStatementForOptionalExpression( + arkts.factory.createIdentifier('initializers'), + originalName + ), + this.property.value ?? arkts.factory.createUndefinedLiteral(), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_NULLISH_COALESCING + ); + const args: arkts.Expression[] = [arkts.factory.create1StringLiteral(originalName), binaryItem]; + judgeIfAddWatchFunc(args, this.property); + const right = arkts.factory.createETSNewClassInstanceExpression( + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier('StateDecoratedVariable'), + arkts.factory.createTSTypeParameterInstantiation( + this.property.typeAnnotation ? [this.property.typeAnnotation] : [] + ) + ) + ), + args + ); + const assign: arkts.AssignmentExpression = arkts.factory.createAssignmentExpression( + generateThisBacking(newName), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + right + ); + return arkts.factory.createExpressionStatement(assign); + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/staticProperty.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/staticProperty.ts new file mode 100644 index 0000000000000000000000000000000000000000..12e9535c5eebcbfcafca53beb45df1dcc221a1b0 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/staticProperty.ts @@ -0,0 +1,52 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { createGetter, createSetter } from './utils'; +import { PropertyTranslator } from './base'; +import { GetterSetter, InitializerConstructor } from './types'; +import { backingField, expectName } from '../../common/arkts-utils'; + +export class staticPropertyTranslator extends PropertyTranslator implements InitializerConstructor, GetterSetter { + translateMember(): arkts.AstNode[] { + const originalName: string = expectName(this.property.key); + const newName: string = backingField(originalName); + return this.translateWithoutInitializer(newName, originalName); + } + + cacheTranslatedInitializer(newName: string, originalName: string): void {} + + translateWithoutInitializer(newName: string, originalName: string): arkts.AstNode[] { + return [this.property]; + } + + translateGetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + returnValue: arkts.Expression + ): arkts.MethodDefinition { + return createGetter(originalName, typeAnnotation, returnValue); + } + + translateSetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + left: arkts.MemberExpression + ): arkts.MethodDefinition { + const right: arkts.Identifier = arkts.factory.createIdentifier('value'); + return createSetter(originalName, typeAnnotation, left, right); + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/storageProp.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/storageProp.ts new file mode 100644 index 0000000000000000000000000000000000000000..2693f749d866c47d3e6651bcb961979954473f58 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/storageProp.ts @@ -0,0 +1,161 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { backingField, expectName } from '../../common/arkts-utils'; +import { PropertyTranslator } from './base'; +import { GetterSetter, InitializerConstructor } from './types'; +import { + DecoratorNames, + generateToRecord, + createGetter, + createSetter2, + generateThisBacking, + generateGetOrSetCall, + judgeIfAddWatchFunc, +} from './utils'; +import { createOptionalClassProperty } from '../utils'; + +function getStoragePropValueStr(node: arkts.AstNode): string | undefined { + if (!arkts.isClassProperty(node) || !node.value) return undefined; + + return arkts.isStringLiteral(node.value) ? node.value.str : undefined; +} + +function getStoragePropAnnotationValue(anno: arkts.AnnotationUsage): string | undefined { + const isStoragePropAnnotation: boolean = + !!anno.expr && arkts.isIdentifier(anno.expr) && anno.expr.name === DecoratorNames.STORAGE_PROP; + + if (isStoragePropAnnotation && anno.properties.length === 1) { + return getStoragePropValueStr(anno.properties.at(0)!); + } + return undefined; +} + +function getStoragePropValueInAnnotation(node: arkts.ClassProperty): string | undefined { + const annotations: readonly arkts.AnnotationUsage[] = node.annotations; + + for (let i = 0; i < annotations.length; i++) { + const anno: arkts.AnnotationUsage = annotations[i]; + const str: string | undefined = getStoragePropAnnotationValue(anno); + if (!!str) { + return str; + } + } + return undefined; +} + +export class StoragePropTranslator extends PropertyTranslator implements InitializerConstructor, GetterSetter { + translateMember(): arkts.AstNode[] { + const originalName: string = expectName(this.property.key); + const newName: string = backingField(originalName); + + this.cacheTranslatedInitializer(newName, originalName); // TODO: need to release cache after some point... + return this.translateWithoutInitializer(newName, originalName); + } + + cacheTranslatedInitializer(newName: string, originalName: string): void { + const currentStructInfo: arkts.StructInfo = arkts.GlobalInfo.getInfoInstance().getStructInfo(this.structName); + const initializeStruct: arkts.AstNode = this.generateInitializeStruct(newName, originalName); + currentStructInfo.initializeBody.push(initializeStruct); + + if (currentStructInfo.isReusable) { + const toRecord = generateToRecord(newName, originalName); + currentStructInfo.toRecordBody.push(toRecord); + } + + arkts.GlobalInfo.getInfoInstance().setStructInfo(this.structName, currentStructInfo); + } + + generateInitializeStruct(newName: string, originalName: string): arkts.AstNode { + const storagePropValueStr: string | undefined = getStoragePropValueInAnnotation(this.property); + if (!storagePropValueStr) { + throw new Error('StorageProp required only one value!!'); // TODO: replace this with proper error message. + } + + const args: arkts.Expression[] = [ + arkts.factory.createStringLiteral(storagePropValueStr), + arkts.factory.create1StringLiteral(originalName), + this.property.value ?? arkts.factory.createUndefinedLiteral(), + ]; + judgeIfAddWatchFunc(args, this.property); + + const newClass = arkts.factory.createETSNewClassInstanceExpression( + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier('StoragePropDecoratedVariable'), + arkts.factory.createTSTypeParameterInstantiation( + this.property.typeAnnotation ? [this.property.typeAnnotation] : [] + ) + ) + ), + args + ); + + return arkts.factory.createAssignmentExpression( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier(newName), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + newClass + ); + } + + translateWithoutInitializer(newName: string, originalName: string): arkts.AstNode[] { + const field = createOptionalClassProperty( + newName, + this.property, + 'StoragePropDecoratedVariable', + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE + ); + const thisValue: arkts.Expression = generateThisBacking(newName, false, true); + const thisGet: arkts.CallExpression = generateGetOrSetCall(thisValue, 'get'); + const thisSet: arkts.ExpressionStatement = arkts.factory.createExpressionStatement( + generateGetOrSetCall(thisValue, 'set') + ); + const getter: arkts.MethodDefinition = this.translateGetter( + originalName, + this.property.typeAnnotation, + thisGet + ); + const setter: arkts.MethodDefinition = this.translateSetter( + originalName, + this.property.typeAnnotation, + thisSet + ); + return [field, getter, setter]; + } + + translateGetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + returnValue: arkts.Expression + ): arkts.MethodDefinition { + return createGetter(originalName, typeAnnotation, returnValue); + } + + translateSetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + statement: arkts.AstNode + ): arkts.MethodDefinition { + return createSetter2(originalName, typeAnnotation, statement); + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/storagelink.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/storagelink.ts new file mode 100644 index 0000000000000000000000000000000000000000..efd83e9d60c3adc50a715613808566a85b108ef7 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/storagelink.ts @@ -0,0 +1,161 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +import { backingField, expectName } from '../../common/arkts-utils'; +import { PropertyTranslator } from './base'; +import { GetterSetter, InitializerConstructor } from './types'; +import { + DecoratorNames, + generateToRecord, + createGetter, + createSetter2, + generateThisBacking, + generateGetOrSetCall, + judgeIfAddWatchFunc, +} from './utils'; +import { createOptionalClassProperty } from '../utils'; + +function getStorageLinkValueStr(node: arkts.AstNode): string | undefined { + if (!arkts.isClassProperty(node) || !node.value) return undefined; + + return arkts.isStringLiteral(node.value) ? node.value.str : undefined; +} + +function getStorageLinkAnnotationValue(anno: arkts.AnnotationUsage): string | undefined { + const isStorageLinkAnnotation: boolean = + !!anno.expr && arkts.isIdentifier(anno.expr) && anno.expr.name === DecoratorNames.STORAGE_LINK; + + if (isStorageLinkAnnotation && anno.properties.length === 1) { + return getStorageLinkValueStr(anno.properties.at(0)!); + } + return undefined; +} + +function getStorageLinkValueInAnnotation(node: arkts.ClassProperty): string | undefined { + const annotations: readonly arkts.AnnotationUsage[] = node.annotations; + + for (let i = 0; i < annotations.length; i++) { + const anno: arkts.AnnotationUsage = annotations[i]; + const str: string | undefined = getStorageLinkAnnotationValue(anno); + if (!!str) { + return str; + } + } + return undefined; +} + +export class StorageLinkTranslator extends PropertyTranslator implements InitializerConstructor, GetterSetter { + translateMember(): arkts.AstNode[] { + const originalName: string = expectName(this.property.key); + const newName: string = backingField(originalName); + + this.cacheTranslatedInitializer(newName, originalName); // TODO: need to release cache after some point... + return this.translateWithoutInitializer(newName, originalName); + } + + cacheTranslatedInitializer(newName: string, originalName: string): void { + const currentStructInfo: arkts.StructInfo = arkts.GlobalInfo.getInfoInstance().getStructInfo(this.structName); + const initializeStruct: arkts.AstNode = this.generateInitializeStruct(newName, originalName); + currentStructInfo.initializeBody.push(initializeStruct); + + if (currentStructInfo.isReusable) { + const toRecord = generateToRecord(newName, originalName); + currentStructInfo.toRecordBody.push(toRecord); + } + + arkts.GlobalInfo.getInfoInstance().setStructInfo(this.structName, currentStructInfo); + } + + generateInitializeStruct(newName: string, originalName: string): arkts.AstNode { + const storageLinkValueStr: string | undefined = getStorageLinkValueInAnnotation(this.property); + if (!storageLinkValueStr) { + throw new Error('StorageLink required only one value!!'); // TODO: replace this with proper error message. + } + + const args: arkts.Expression[] = [ + arkts.factory.createStringLiteral(storageLinkValueStr), + arkts.factory.create1StringLiteral(originalName), + this.property.value ?? arkts.factory.createUndefinedLiteral(), + ]; + judgeIfAddWatchFunc(args, this.property); + + const newClass = arkts.factory.createETSNewClassInstanceExpression( + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier('StorageLinkDecoratedVariable'), + arkts.factory.createTSTypeParameterInstantiation( + this.property.typeAnnotation ? [this.property.typeAnnotation] : [] + ) + ) + ), + args + ); + + return arkts.factory.createAssignmentExpression( + arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier(newName), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + newClass + ); + } + + translateWithoutInitializer(newName: string, originalName: string): arkts.AstNode[] { + const field = createOptionalClassProperty( + newName, + this.property, + 'StorageLinkDecoratedVariable', + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE + ); + const thisValue: arkts.Expression = generateThisBacking(newName, false, true); + const thisGet: arkts.CallExpression = generateGetOrSetCall(thisValue, 'get'); + const thisSet: arkts.ExpressionStatement = arkts.factory.createExpressionStatement( + generateGetOrSetCall(thisValue, 'set') + ); + const getter: arkts.MethodDefinition = this.translateGetter( + originalName, + this.property.typeAnnotation, + thisGet + ); + const setter: arkts.MethodDefinition = this.translateSetter( + originalName, + this.property.typeAnnotation, + thisSet + ); + return [field, getter, setter]; + } + + translateGetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + returnValue: arkts.Expression + ): arkts.MethodDefinition { + return createGetter(originalName, typeAnnotation, returnValue); + } + + translateSetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + statement: arkts.AstNode + ): arkts.MethodDefinition { + return createSetter2(originalName, typeAnnotation, statement); + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/types.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/types.ts new file mode 100644 index 0000000000000000000000000000000000000000..b791a7da1c893b054ec9c591dddd2152cd681faa --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/types.ts @@ -0,0 +1,34 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +export interface GetterSetter { + translateGetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + returnValue: arkts.Expression + ): arkts.MethodDefinition; + translateSetter( + originalName: string, + typeAnnotation: arkts.TypeNode | undefined, + left: arkts.MemberExpression + ): arkts.MethodDefinition; +} + +export interface InitializerConstructor { + cacheTranslatedInitializer(newName: string, originalName: string): void; + translateWithoutInitializer(newName: string, originalName: string): arkts.AstNode[]; +} diff --git a/ets1.2/arkui-plugins/ui-plugins/property-translators/utils.ts b/ets1.2/arkui-plugins/ui-plugins/property-translators/utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..cda1293fc1c39be003a8c2d37efffcd8b79ab629 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/property-translators/utils.ts @@ -0,0 +1,367 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { annotation } from '../../common/arkts-utils'; +import { factory } from './factory'; + +export enum DecoratorNames { + STATE = 'State', + STORAGE_LINK = 'StorageLink', + STORAGE_PROP = 'StorageProp', + LINK = 'Link', + PROP = 'Prop', + PROVIDE = 'Provide', + CONSUME = 'Consume', + OBJECT_LINK = 'ObjectLink', + OBSERVED = 'Observed', + WATCH = 'Watch', + BUILDER_PARAM = 'BuilderParam', + BUILDER = 'Builder', + CUSTOM_DIALOG = 'CustomDialog', + LOCAL_STORAGE_PROP = 'LocalStorageProp', + LOCAL_STORAGE_LINK = 'LocalStorageLink', + REUSABLE = 'Reusable', + TRACK = 'Track', +} + +export function collectPropertyDecorators(property: arkts.ClassProperty): string[] { + const properties: string[] = []; + property.annotations.forEach((anno) => { + if (!!anno.expr && arkts.isIdentifier(anno.expr)) { + properties.push(anno.expr.name); + } + }); + return properties; +} + +export function isDecoratorAnnotation(anno: arkts.AnnotationUsage, decoratorName: DecoratorNames): boolean { + return !!anno.expr && arkts.isIdentifier(anno.expr) && anno.expr.name === decoratorName; +} + +export function hasDecorator( + property: arkts.ClassProperty | arkts.ClassDefinition | arkts.MethodDefinition, + decoratorName: DecoratorNames +): boolean { + if (arkts.isMethodDefinition(property)) { + return property.scriptFunction.annotations.some((anno) => isDecoratorAnnotation(anno, decoratorName)); + } + return property.annotations.some((anno) => isDecoratorAnnotation(anno, decoratorName)); +} + +/** + * Determine whether the node `` is decorated by decorators that need initializing without assignment. + * + * @param st class property node + */ +export function needDefiniteOrOptionalModifier(st: arkts.ClassProperty): boolean { + return ( + hasDecorator(st, DecoratorNames.LINK) || + hasDecorator(st, DecoratorNames.CONSUME) || + hasDecorator(st, DecoratorNames.OBJECT_LINK) || + (hasDecorator(st, DecoratorNames.PROP) && !st.value) + ); +} + +export function getStateManagementType(node: arkts.ClassProperty): string { + if (hasDecorator(node, DecoratorNames.STATE)) { + return 'StateDecoratedVariable'; + } else if (hasDecorator(node, DecoratorNames.LINK)) { + return 'DecoratedV1VariableBase'; + } else if (hasDecorator(node, DecoratorNames.PROP)) { + return 'PropDecoratedVariable'; + } else if (hasDecorator(node, DecoratorNames.STORAGE_LINK)) { + return 'StorageLinkDecoratedVariable'; + } else if (hasDecorator(node, DecoratorNames.STORAGE_PROP)) { + return 'StoragePropDecoratedVariable'; + } else if (hasDecorator(node, DecoratorNames.PROVIDE)) { + return 'ProvideDecoratedVariable'; + } else if (hasDecorator(node, DecoratorNames.CONSUME)) { + return 'ConsumeDecoratedVariable'; + } else if (hasDecorator(node, DecoratorNames.OBJECT_LINK)) { + return 'ObjectLinkDecoratedVariable'; + } else if (hasDecorator(node, DecoratorNames.LOCAL_STORAGE_PROP)) { + return 'SyncedProperty'; + } + return 'MutableState'; +} + +export function createGetter( + name: string, + type: arkts.TypeNode | undefined, + returns: arkts.Expression, + needMemo: boolean = false, +): arkts.MethodDefinition { + const returnType: arkts.TypeNode | undefined = type?.clone(); + if (needMemo) { + returnType?.setAnnotations([annotation('memo')]); + } + const body = arkts.factory.createBlock([arkts.factory.createReturnStatement(returns)]); + const scriptFunction = arkts.factory.createScriptFunction( + body, + arkts.FunctionSignature.createFunctionSignature(undefined, [], returnType, false), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_GETTER, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC + ); + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_GET, + arkts.factory.createIdentifier(name), + scriptFunction, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC, + false + ); +} + +export function createSetter( + name: string, + type: arkts.TypeNode | undefined, + left: arkts.Expression, + right: arkts.AstNode, + needMemo: boolean = false +): arkts.MethodDefinition { + const body = arkts.factory.createBlock([ + arkts.factory.createExpressionStatement( + arkts.factory.createAssignmentExpression( + left, + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION, + right + ) + ), + ]); + const param: arkts.ETSParameterExpression = arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier('value', type?.clone()), + undefined + ); + if (needMemo) { + param.annotations = [annotation('memo')]; + } + const scriptFunction = arkts.factory.createScriptFunction( + body, + arkts.FunctionSignature.createFunctionSignature(undefined, [param], undefined, false), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_SETTER, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC + ); + + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_SET, + arkts.factory.createIdentifier(name), + scriptFunction, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC, + false + ); +} + +export function createSetter2( + name: string, + type: arkts.TypeNode | undefined, + statement: arkts.AstNode +): arkts.MethodDefinition { + const body = arkts.factory.createBlock([statement]); + const param: arkts.ETSParameterExpression = arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier('value', type?.clone()), + undefined + ); + const scriptFunction = arkts.factory.createScriptFunction( + body, + arkts.FunctionSignature.createFunctionSignature(undefined, [param], undefined, false), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_SETTER, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC + ); + + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_SET, + arkts.factory.createIdentifier(name), + scriptFunction, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC, + false + ); +} + +export function generateThisBackingValue( + name: string, + optional: boolean = false, + nonNull: boolean = false +): arkts.MemberExpression { + const member: arkts.Expression = generateThisBacking(name, optional, nonNull); + return arkts.factory.createMemberExpression( + member, + arkts.factory.createIdentifier('value'), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ); +} + +export function generateThisBacking( + name: string, + optional: boolean = false, + nonNull: boolean = false +): arkts.Expression { + const member: arkts.Expression = arkts.factory.createMemberExpression( + arkts.factory.createThisExpression(), + arkts.factory.createIdentifier(`${name}`), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + optional + ); + return nonNull ? arkts.factory.createTSNonNullExpression(member) : member; +} + +function getValueStr(node: arkts.AstNode): string | undefined { + if (!arkts.isClassProperty(node) || !node.value) return undefined; + return arkts.isStringLiteral(node.value) ? node.value.str : undefined; +} + +function getAnnotationValue(anno: arkts.AnnotationUsage, decoratorName: DecoratorNames): string | undefined { + const isSuitableAnnotation: boolean = + !!anno.expr && arkts.isIdentifier(anno.expr) && anno.expr.name === decoratorName; + if (isSuitableAnnotation && anno.properties.length === 1) { + return getValueStr(anno.properties.at(0)!); + } + return undefined; +} + +export function getValueInAnnotation(node: arkts.ClassProperty, decoratorName: DecoratorNames): string | undefined { + const annotations: readonly arkts.AnnotationUsage[] = node.annotations; + for (let i = 0; i < annotations.length; i++) { + const anno: arkts.AnnotationUsage = annotations[i]; + const str: string | undefined = getAnnotationValue(anno, decoratorName); + if (!!str) { + return str; + } + } + return undefined; +} + +export interface ProvideOptions { + alias: string | undefined; + allowOverride: boolean; +} + +export function getValueInProvideAnnotation(node: arkts.ClassProperty): ProvideOptions | undefined { + const annotations: readonly arkts.AnnotationUsage[] = node.annotations; + for (let i = 0; i < annotations.length; i++) { + const anno: arkts.AnnotationUsage = annotations[i]; + if (anno.expr && arkts.isIdentifier(anno.expr) && anno.expr.name === DecoratorNames.PROVIDE) { + const alias = getValueInObjectAnnotation(anno, DecoratorNames.PROVIDE, 'alias') as string | undefined; + const allowOverride: boolean = getValueInObjectAnnotation(anno, DecoratorNames.PROVIDE, 'allowOverride') + ? true + : false; + return { alias, allowOverride }; + } + } + return undefined; +} + +function getValueInObjectAnnotation( + anno: arkts.AnnotationUsage, + decoratorName: DecoratorNames, + key: string +): string | boolean | undefined { + const isSuitableAnnotation: boolean = + !!anno.expr && arkts.isIdentifier(anno.expr) && anno.expr.name === decoratorName; + if (!isSuitableAnnotation) { + return undefined; + } + const keyItem: arkts.AstNode | undefined = anno.properties.find( + (annoProp: arkts.AstNode) => + arkts.isClassProperty(annoProp) && + annoProp.key && + arkts.isIdentifier(annoProp.key) && + annoProp.key.name === key + ); + if (keyItem && arkts.isClassProperty(keyItem) && keyItem.value) { + return getDifferentAnnoTypeValue(keyItem.value); + } + return undefined; +} + +function getDifferentAnnoTypeValue(value: arkts.Expression): string | boolean { + if (arkts.isBooleanLiteral(value)) { + return value.value; + } else if (arkts.isStringLiteral(value)) { + return value.str; + } + return value.dumpSrc(); +} + +export function judgeIfAddWatchFunc(args: arkts.Expression[], property: arkts.ClassProperty): void { + if (hasDecorator(property, DecoratorNames.WATCH)) { + const watchStr: string | undefined = getValueInAnnotation(property, DecoratorNames.WATCH); + if (watchStr) { + args.push(factory.createWatchCallback(watchStr)); + } + } +} + +export function generateGetOrSetCall(beforCall: arkts.AstNode, type: string) { + return arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + beforCall, + arkts.factory.createIdentifier(type), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + undefined, + type === 'set' ? [arkts.factory.createIdentifier('value')] : undefined, + undefined + ); +} + +export function generateToRecord(newName: string, originalName: string): arkts.Property { + return arkts.Property.createProperty( + arkts.factory.createStringLiteral(originalName), + arkts.factory.createBinaryExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier('paramsCasted'), + arkts.factory.createIdentifier(originalName), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + arkts.ETSNewClassInstanceExpression.createETSNewClassInstanceExpression( + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier('Object')) + ), + [] + ), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_NULLISH_COALESCING + ) + ); +} + +export function getStageManagementIdent(property: arkts.ClassProperty): string { + const useMutableState: boolean = + hasDecorator(property, DecoratorNames.STATE) || + hasDecorator(property, DecoratorNames.STORAGE_LINK) || + hasDecorator(property, DecoratorNames.PROVIDE) || + hasDecorator(property, DecoratorNames.CONSUME) || + hasDecorator(property, DecoratorNames.LINK) || + hasDecorator(property, DecoratorNames.LOCAL_STORAGE_LINK) || + hasDecorator(property, DecoratorNames.LINK); + const useSyncedProperty: boolean = + hasDecorator(property, DecoratorNames.PROP) || + hasDecorator(property, DecoratorNames.STORAGE_PROP) || + hasDecorator(property, DecoratorNames.LOCAL_STORAGE_PROP) || + hasDecorator(property, DecoratorNames.OBJECT_LINK); + if (useMutableState) { + return 'MutableState'; + } else if (useSyncedProperty) { + return 'SyncedProperty'; + } else { + return ''; + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/struct-translators/factory.ts b/ets1.2/arkui-plugins/ui-plugins/struct-translators/factory.ts new file mode 100644 index 0000000000000000000000000000000000000000..6fd41c6b6cc8d05190a06545cc47e50267a78518 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/struct-translators/factory.ts @@ -0,0 +1,385 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { BuilderLambdaNames, CustomComponentNames, Dollars } from '../utils'; +import { factory as uiFactory } from '../ui-factory'; +import { annotation } from '../../common/arkts-utils'; + +export class factory { + /* + * create `constructor() {}`. + */ + static createConstructorMethod(member: arkts.MethodDefinition): arkts.MethodDefinition { + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_CONSTRUCTOR, + member.name, + member.scriptFunction, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_CONSTRUCTOR, + false + ); + } + + /* + * create _build method. + */ + static transformBuildMethodWithOriginBuild( + method: arkts.MethodDefinition, + typeName: string, + optionsName: string, + isDecl?: boolean + ): arkts.MethodDefinition { + const updateKey: arkts.Identifier = arkts.factory.createIdentifier(CustomComponentNames.COMPONENT_BUILD); + + const scriptFunction: arkts.ScriptFunction = method.scriptFunction; + const updateScriptFunction = arkts.factory + .createScriptFunction( + scriptFunction.body, + arkts.FunctionSignature.createFunctionSignature( + scriptFunction.typeParams, + [ + uiFactory.createStyleParameter(typeName), + uiFactory.createContentParameter(), + uiFactory.createInitializersOptionsParameter(optionsName), + ], + arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID), + false + ), + scriptFunction.flags, + scriptFunction.modifiers + ) + .setAnnotations([annotation('memo')]); + + const modifiers: arkts.Es2pandaModifierFlags = isDecl + ? arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_ABSTRACT + : arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC; + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD, + updateKey, + updateScriptFunction, + modifiers, + false + ); + } + + /* + * generate _r() or _rawfile(). + */ + static generateTransformedResource( + resourceNode: arkts.CallExpression, + newArgs: arkts.AstNode[] + ): arkts.CallExpression { + const transformedKey: string = + resourceNode.expression.dumpSrc() === Dollars.DOLLAR_RESOURCE ? '_r' : '_rawfile'; + return arkts.factory.updateCallExpression( + resourceNode, + arkts.factory.createIdentifier(transformedKey), + resourceNode.typeArguments, + newArgs + ); + } + + /* + * create __initializeStruct method. + */ + static createInitializeStruct( + structInfo: arkts.StructInfo, + optionsTypeName: string, + isDecl?: boolean + ): arkts.MethodDefinition { + const updateKey: arkts.Identifier = arkts.factory.createIdentifier( + CustomComponentNames.COMPONENT_INITIALIZE_STRUCT + ); + + let body: arkts.BlockStatement | undefined; + let modifiers: arkts.Es2pandaModifierFlags = arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_ABSTRACT; + if (!isDecl) { + body = arkts.factory.createBlock(structInfo.initializeBody); + modifiers = arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC; + } + const scriptFunction: arkts.ScriptFunction = arkts.factory + .createScriptFunction( + body, + arkts.FunctionSignature.createFunctionSignature( + undefined, + [uiFactory.createInitializersOptionsParameter(optionsTypeName), uiFactory.createContentParameter()], + arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID), + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_METHOD, + modifiers + ) + .setIdent(updateKey); + + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD, + updateKey, + scriptFunction, + modifiers, + false + ); + } + + /* + * create __updateStruct method. + */ + static createUpdateStruct( + structInfo: arkts.StructInfo, + optionsTypeName: string, + isDecl?: boolean + ): arkts.MethodDefinition { + const updateKey: arkts.Identifier = arkts.factory.createIdentifier( + CustomComponentNames.COMPONENT_UPDATE_STRUCT + ); + + let body: arkts.BlockStatement | undefined; + let modifiers: arkts.Es2pandaModifierFlags = arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_ABSTRACT; + if (!isDecl) { + body = arkts.factory.createBlock(structInfo.updateBody); + modifiers = arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC; + } + + const scriptFunction: arkts.ScriptFunction = arkts.factory + .createScriptFunction( + body, + arkts.FunctionSignature.createFunctionSignature( + undefined, + [uiFactory.createInitializersOptionsParameter(optionsTypeName)], + arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID), + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_METHOD, + modifiers + ) + .setIdent(updateKey); + + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD, + updateKey, + scriptFunction, + modifiers, + false + ); + } + + /* + * create __toRecord method when the component is decorated with @Reusable. + */ + static toRecord(optionsTypeName: string, toRecordBody: arkts.Property[]): arkts.MethodDefinition { + const paramsCasted = factory.generateParamsCasted(optionsTypeName); + const returnRecord = arkts.factory.createReturnStatement( + arkts.ObjectExpression.createObjectExpression( + arkts.Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION, + toRecordBody, + false + ) + ); + const body: arkts.BlockStatement = arkts.factory.createBlock([paramsCasted, returnRecord]); + + const params = arkts.ETSParameterExpression.create( + arkts.factory.createIdentifier('params', factory.generateTypeReferenceWithTypeName('Object')), + undefined + ); + + const toRecordScriptFunction = arkts.factory.createScriptFunction( + body, + arkts.FunctionSignature.createFunctionSignature(undefined, [params], factory.generateTypeRecord(), false), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_METHOD, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC + ); + + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_CONSTRUCTOR, + arkts.factory.createIdentifier('__toRecord'), + toRecordScriptFunction, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_OVERRIDE, + false + ); + } + + /* + * generate `const paramsCasted = (params as )`. + */ + static generateParamsCasted(optionsTypeName: string): arkts.VariableDeclaration { + return arkts.factory.createVariableDeclaration( + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_CONST, + [ + arkts.factory.createVariableDeclarator( + arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_CONST, + arkts.factory.createIdentifier('paramsCasted'), + arkts.TSAsExpression.createTSAsExpression( + arkts.factory.createIdentifier('params'), + factory.generateTypeReferenceWithTypeName(optionsTypeName), + false + ) + ), + ] + ); + } + + /* + * generate Record type. + */ + static generateTypeRecord(): arkts.ETSTypeReference { + return arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier('Record'), + arkts.factory.createTSTypeParameterInstantiation([ + factory.generateTypeReferenceWithTypeName('string'), + factory.generateTypeReferenceWithTypeName('Object'), + ]) + ) + ); + } + + /* + * create type reference with type name, e.g. number. + */ + static generateTypeReferenceWithTypeName(typeName: string): arkts.ETSTypeReference { + return arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier(typeName)) + ); + } + + /* + * create type reference with type name, e.g. number. + */ + static updateCustomComponentClass( + definition: arkts.ClassDefinition, + members: arkts.AstNode[] + ): arkts.ClassDefinition { + return arkts.factory.updateClassDefinition( + definition, + definition.ident, + definition.typeParams, + definition.superTypeParams, + definition.implements, + undefined, + definition.super, + members, + definition.modifiers, + arkts.classDefinitionFlags(definition) + ); + } + + /* + * add headers for animation in CommonMethod + */ + static modifyExternalComponentCommon(node: arkts.TSInterfaceDeclaration): arkts.AstNode { + const animationStart = factory.createAnimationMethod(BuilderLambdaNames.ANIMATION_START); + const animationStop = factory.createAnimationMethod(BuilderLambdaNames.ANIMATION_STOP); + const updatedBody = arkts.factory.updateInterfaceBody(node.body!, [ + animationStart, + animationStop, + ...node.body!.body, + ]); + return arkts.factory.updateInterfaceDeclaration( + node, + node.extends, + node.id, + node.typeParams, + updatedBody, + node.isStatic, + node.isFromExternal + ); + } + + /* + * generate animationStart(...) and animationStop(...) + */ + static createAnimationMethod(key: string): arkts.MethodDefinition { + const aniparams: arkts.Expression[] = [ + arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier( + 'value', + arkts.factory.createUnionType( + [ + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier('AnimateParam')) + ), + arkts.factory.createETSUndefinedType() + ] + ) + ), + undefined + ), + ]; + const aniFuncExpr = arkts.factory.createScriptFunction( + undefined, + arkts.factory.createFunctionSignature(undefined, aniparams, arkts.TSThisType.createTSThisType(), false), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_METHOD, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC + ); + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD, + arkts.factory.createIdentifier(key), + aniFuncExpr, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC, + false + ); + } + + /* + * generate XComponent(..., packageInfo: string, ...) + */ + static modifyXcomponent(node: arkts.ScriptFunction): arkts.ScriptFunction { + const info = arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier( + 'packageInfo', + arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier('string') + ) + ) + ), + undefined + ); + return arkts.factory.updateScriptFunction( + node, + node.body, + arkts.factory.createFunctionSignature( + node.typeParams, + [...node.params.slice(0, 2), info, ...node.params.slice(2)], + node.returnTypeAnnotation, + false + ), + node.flags, + node.modifiers + ); + } + + /* + * transform ExternalSource headers + */ + static transformExternalSource(externalSourceName: string, node: arkts.AstNode): arkts.AstNode { + if ( + externalSourceName === 'arkui.component.common' && + arkts.isTSInterfaceDeclaration(node) && + !!node.id && + node.id.name === 'CommonMethod' + ) { + return factory.modifyExternalComponentCommon(node); + } else if ( + externalSourceName === 'arkui.component.xcomponent' && + arkts.isScriptFunction(node) && + !!node.id && + node.id.name === 'XComponent' + ) { + return factory.modifyXcomponent(node); + } + return node; + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/struct-translators/struct-transformer.ts b/ets1.2/arkui-plugins/ui-plugins/struct-translators/struct-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..be9ebdb11009ba304b153b32293d579e6feffa63 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/struct-translators/struct-transformer.ts @@ -0,0 +1,220 @@ +/* + * 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 '../../common/abstract-visitor'; +import { annotation, collect, filterDefined } from '../../common/arkts-utils'; +import { ProjectConfig } from '../../common/plugin-context'; +import { classifyProperty, PropertyTranslator } from '../property-translators'; +import { + addMemoAnnotation, + CustomComponentNames, + getCustomComponentOptionsName, + getTypeNameFromTypeParameter, + getTypeParamsFromClassDecl, +} from '../utils'; +import { isCustomComponentClass, isKnownMethodDefinition, isEtsGlobalClass, isReourceNode, CustomComponentScopeInfo, findCanAddMemoFromArrowFunction } from './utils'; +import { factory as uiFactory } from '../ui-factory'; +import { factory } from './factory'; +import { isEntryWrapperClass } from '../entry-translators/utils'; +import { factory as entryFactory } from '../entry-translators/factory'; +import { DecoratorNames, hasDecorator } from '../property-translators/utils'; +import { ScopeInfoCollection } from './utils'; + +function tranformPropertyMembers( + className: string, + propertyTranslators: PropertyTranslator[], + optionsTypeName: string, + isDecl?: boolean, + scope?: CustomComponentScopeInfo +): arkts.AstNode[] { + const propertyMembers = propertyTranslators.map((translator) => translator.translateMember()); + const currentStructInfo: arkts.StructInfo = arkts.GlobalInfo.getInfoInstance().getStructInfo(className); + const collections = []; + if (!scope?.hasInitializeStruct) { + collections.push(factory.createInitializeStruct(currentStructInfo, optionsTypeName, isDecl)); + } + if (!scope?.hasUpdateStruct) { + collections.push(factory.createUpdateStruct(currentStructInfo, optionsTypeName, isDecl)); + } + if (currentStructInfo.isReusable) { + collections.push(factory.toRecord(optionsTypeName, currentStructInfo.toRecordBody)); + } + return collect(...collections, ...propertyMembers); +} + +function transformEtsGlobalClassMembers(node: arkts.ClassDeclaration): arkts.ClassDeclaration { + if (!node.definition) { + return node; + } + node.definition.body.map((member: arkts.AstNode) => { + if (arkts.isMethodDefinition(member) && hasDecorator(member, DecoratorNames.BUILDER)) { + member.scriptFunction.setAnnotations([annotation('memo')]); + } + return member; + }); + return node; +} + +function transformOtherMembersInClass( + member: arkts.AstNode, + classTypeName: string | undefined, + classOptionsName: string | undefined, + className: string, + isDecl?: boolean +): arkts.AstNode { + if (arkts.isMethodDefinition(member) && hasDecorator(member, DecoratorNames.BUILDER)) { + member.scriptFunction.setAnnotations([annotation('memo')]); + return member; + } + if ( + arkts.isMethodDefinition(member) && + isKnownMethodDefinition(member, CustomComponentNames.COMPONENT_CONSTRUCTOR_ORI) && + !isDecl + ) { + return uiFactory.createConstructorMethod(member); + } + if (arkts.isMethodDefinition(member) && isKnownMethodDefinition(member, CustomComponentNames.COMPONENT_BUILD_ORI)) { + return factory.transformBuildMethodWithOriginBuild( + member, + classTypeName ?? className, + classOptionsName ?? getCustomComponentOptionsName(className), + isDecl + ); + } + return member; +} + +function tranformClassMembers( + node: arkts.ClassDeclaration, + isDecl?: boolean, + scope?: CustomComponentScopeInfo +): arkts.ClassDeclaration { + if (!node.definition) { + return node; + } + + let classTypeName: string | undefined; + let classOptionsName: string | undefined; + if (isDecl) { + const [classType, classOptions] = getTypeParamsFromClassDecl(node); + classTypeName = getTypeNameFromTypeParameter(classType); + classOptionsName = getTypeNameFromTypeParameter(classOptions); + } + const definition: arkts.ClassDefinition = node.definition; + const className: string | undefined = node.definition.ident?.name; + if (!className) { + throw new Error('Non Empty className expected for Component'); + } + + const propertyTranslators: PropertyTranslator[] = filterDefined( + definition.body.map((it) => classifyProperty(it, className)) + ); + const translatedMembers: arkts.AstNode[] = tranformPropertyMembers( + className, + propertyTranslators, + classOptionsName ?? getCustomComponentOptionsName(className), + isDecl, + scope + ); + const updateMembers: arkts.AstNode[] = definition.body + .filter((member) => !arkts.isClassProperty(member)) + .map((member: arkts.AstNode) => + transformOtherMembersInClass(member, classTypeName, classOptionsName, className, isDecl) + ); + + const updateClassDef: arkts.ClassDefinition = factory.updateCustomComponentClass(definition, [ + ...translatedMembers, + ...updateMembers, + ]); + return arkts.factory.updateClassDeclaration(node, updateClassDef); +} + +function transformResource( + resourceNode: arkts.CallExpression, + projectConfig: ProjectConfig | undefined +): arkts.CallExpression { + const newArgs: arkts.AstNode[] = [ + arkts.factory.create1StringLiteral(projectConfig?.bundleName ? projectConfig.bundleName : ''), + arkts.factory.create1StringLiteral(projectConfig?.moduleName ? projectConfig.moduleName : ''), + ...resourceNode.arguments, + ]; + return factory.generateTransformedResource(resourceNode, newArgs); +} + +export class StructTransformer extends AbstractVisitor { + private scopeInfoCollection: ScopeInfoCollection; + projectConfig: ProjectConfig | undefined; + + constructor(projectConfig: ProjectConfig | undefined) { + super(); + this.projectConfig = projectConfig; + this.scopeInfoCollection = { customComponents: [] }; + } + + reset(): void { + super.reset(); + this.scopeInfoCollection = { customComponents: [] }; + } + + enter(node: arkts.AstNode): void { + if (arkts.isClassDeclaration(node) && isCustomComponentClass(node)) { + this.scopeInfoCollection.customComponents.push({ name: node.definition!.ident!.name }); + } + if (arkts.isMethodDefinition(node) && this.scopeInfoCollection.customComponents.length > 0) { + const name = node.name.name; + const scopeInfo = this.scopeInfoCollection.customComponents.pop()!; + scopeInfo.hasInitializeStruct ||= name === CustomComponentNames.COMPONENT_INITIALIZE_STRUCT; + scopeInfo.hasUpdateStruct ||= name === CustomComponentNames.COMPONENT_UPDATE_STRUCT; + scopeInfo.hasReusableRebind ||= name === CustomComponentNames.REUSABLE_COMPONENT_REBIND_STATE; + this.scopeInfoCollection.customComponents.push(scopeInfo); + } + } + + exit(node: arkts.AstNode): void { + if (arkts.isClassDeclaration(node) && isCustomComponentClass(node)) { + this.scopeInfoCollection.customComponents.pop(); + } + } + + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + this.enter(beforeChildren); + const node = this.visitEachChild(beforeChildren); + if (arkts.isClassDeclaration(node) && isCustomComponentClass(node)) { + let scope: CustomComponentScopeInfo | undefined; + const scopeInfos: CustomComponentScopeInfo[] = this.scopeInfoCollection.customComponents; + if (scopeInfos.length > 0) { + scope = scopeInfos[scopeInfos.length - 1]; + } + const newClass: arkts.ClassDeclaration = tranformClassMembers( + node, + arkts.hasModifierFlag(node, arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_DECLARE), + scope + ); + this.exit(beforeChildren); + return newClass; + } else if (isEntryWrapperClass(node)) { + entryFactory.addMemoToEntryWrapperClassMethods(node); + return node; + } else if (arkts.isClassDeclaration(node) && isEtsGlobalClass(node)) { + return transformEtsGlobalClassMembers(node); + } else if (arkts.isCallExpression(node) && isReourceNode(node)) { + return transformResource(node, this.projectConfig); + } else if (findCanAddMemoFromArrowFunction(node)) { + return addMemoAnnotation(node); + } + return node; + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/struct-translators/utils.ts b/ets1.2/arkui-plugins/ui-plugins/struct-translators/utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..2af2176268987f3a1077635768f59a00735d2bd5 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/struct-translators/utils.ts @@ -0,0 +1,116 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { Dollars, isMemoAnnotation } from '../utils'; +import { CustomComponentNames } from '../utils'; +import { DecoratorNames, isDecoratorAnnotation } from '../property-translators/utils'; + +export type ScopeInfoCollection = { + customComponents: CustomComponentScopeInfo[]; +}; + +export type CustomComponentScopeInfo = { + name: string; + hasInitializeStruct?: boolean; + hasUpdateStruct?: boolean; + hasReusableRebind?: boolean; +}; + +/** + * Determine whether it is a custom component. + * + * @param node class declaration node + */ +export function isCustomComponentClass(node: arkts.ClassDeclaration): boolean { + if (!node.definition?.ident?.name) { + return false; + } + const name: string = node.definition.ident.name; + const structCollection: Set = arkts.GlobalInfo.getInfoInstance().getStructCollection(); + return name === CustomComponentNames.COMPONENT_CLASS_NAME || structCollection.has(name); +} + +/** + * Determine whether it is method with specified name. + * + * @param method method definition node + * @param name specified method name + */ +export function isKnownMethodDefinition(method: arkts.MethodDefinition, name: string): boolean { + if (!method || !arkts.isMethodDefinition(method)) { + return false; + } + + // For now, we only considered matched method name. + const isNameMatched: boolean = method.name?.name === name; + return isNameMatched; +} + +/** + * Determine whether it is ETSGLOBAL class. + * + * @param node class declaration node + */ +export function isEtsGlobalClass(node: arkts.ClassDeclaration): boolean { + if (node.definition?.ident?.name === 'ETSGLOBAL') { + return true; + } + return false; +} + +/** + * Determine whether it is resource node begin with '$r' or '$rawfile'. + * + * @param node call expression node + */ +export function isReourceNode(node: arkts.CallExpression): boolean { + if (node.expression.dumpSrc() === Dollars.DOLLAR_RESOURCE || node.expression.dumpSrc() === Dollars.DOLLAR_RAWFILE) { + return true; + } + return false; +} + +export function isMemoCall(node: arkts.AstNode): node is arkts.CallExpression { + if (!arkts.isCallExpression(node)) { + return false; + } + const expr: arkts.AstNode = node.expression; + const decl: arkts.AstNode | undefined = arkts.getDecl(expr); + + if (!decl) { + return false; + } + + if (arkts.isMethodDefinition(decl)) { + return decl.scriptFunction.annotations.some( + (anno) => isDecoratorAnnotation(anno, DecoratorNames.BUILDER) || isMemoAnnotation(anno, 'memo') + ); + } + return false; +} + +export function findCanAddMemoFromArrowFunction(node: arkts.AstNode): node is arkts.ArrowFunctionExpression { + if (!arkts.isArrowFunctionExpression(node)) { + return false; + } + const hasMemo: boolean = node.annotations.some((anno) => isMemoAnnotation(anno, 'memo')); + if (!hasMemo && !!node.scriptFunction.body && arkts.isBlockStatement(node.scriptFunction.body)) { + return node.scriptFunction.body.statements.some( + (st) => arkts.isExpressionStatement(st) && isMemoCall(st.expression) + ); + } + return false; +} diff --git a/ets1.2/arkui-plugins/ui-plugins/ui-factory.ts b/ets1.2/arkui-plugins/ui-plugins/ui-factory.ts new file mode 100644 index 0000000000000000000000000000000000000000..2b64ac64fd6c7775c6830c58f2e50aa541cb6d32 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/ui-factory.ts @@ -0,0 +1,287 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { BuilderLambdaNames, CustomComponentNames, hasPropertyInAnnotation, hasNullOrUndefinedType } from './utils'; +import { annotation } from '../common/arkts-utils'; +import { DecoratorNames, needDefiniteOrOptionalModifier } from './property-translators/utils'; + +export class factory { + /** + * create `instance: ` as identifier + */ + static createInstanceIdentifier(typeName: string): arkts.Identifier { + return arkts.factory.createIdentifier( + BuilderLambdaNames.STYLE_ARROW_PARAM_NAME, + factory.createTypeReferenceFromString(typeName) + ); + } + + /** + * create `instance: ` as parameter + */ + static createInstanceParameter(typeName: string): arkts.ETSParameterExpression { + return arkts.factory.createParameterDeclaration(factory.createInstanceIdentifier(typeName), undefined); + } + + /** + * create `(instance: ) => void` + */ + static createStyleLambdaFunctionType(typeName: string): arkts.ETSFunctionType { + return arkts.factory.createFunctionType( + arkts.FunctionSignature.createFunctionSignature( + undefined, + [factory.createInstanceParameter(typeName)], + factory.createTypeReferenceFromString(typeName), + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW + ); + } + + /** + * create `style: ((instance: ) => void) | undefined` as identifier + */ + static createStyleIdentifier(typeName: string): arkts.Identifier { + return arkts.factory.createIdentifier( + BuilderLambdaNames.STYLE_PARAM_NAME, + arkts.factory.createUnionType([ + factory.createStyleLambdaFunctionType(typeName), + arkts.factory.createETSUndefinedType(), + ]) + ); + } + + /** + * create `@memo() style: ((instance: ) => void) | undefined` as parameter + */ + static createStyleParameter(typeName: string): arkts.ETSParameterExpression { + const styleParam: arkts.Identifier = factory.createStyleIdentifier(typeName); + const param = arkts.factory.createParameterDeclaration(styleParam, undefined); + param.annotations = [annotation('memo')]; + return param; + } + + /** + * create `initializers: | undefined` as identifier + */ + static createInitializerOptionsIdentifier(optionsName: string): arkts.Identifier { + return arkts.factory.createIdentifier( + CustomComponentNames.COMPONENT_INITIALIZERS_NAME, + arkts.factory.createUnionType([ + factory.createTypeReferenceFromString(optionsName), + arkts.factory.createETSUndefinedType(), + ]) + ); + } + + /** + * create `initializers: | undefined` as parameter + */ + static createInitializersOptionsParameter(optionsName: string): arkts.ETSParameterExpression { + return arkts.factory.createParameterDeclaration( + factory.createInitializerOptionsIdentifier(optionsName), + undefined + ); + } + + /** + * create `content: (() => void) | undefined` as identifier + */ + static createContentIdentifier(): arkts.Identifier { + return arkts.factory.createIdentifier( + BuilderLambdaNames.CONTENT_PARAM_NAME, + arkts.factory.createUnionType([factory.createLambdaFunctionType(), arkts.factory.createETSUndefinedType()]) + ); + } + + /** + * create `@memo() content: (() => void) | undefined` as parameter + */ + static createContentParameter(): arkts.ETSParameterExpression { + const contentParam: arkts.Identifier = factory.createContentIdentifier(); + const param = arkts.factory.createParameterDeclaration(contentParam, undefined); + param.annotations = [annotation('memo')]; + return param; + } + + /** + * create type from string + */ + static createTypeReferenceFromString(name: string): arkts.TypeNode { + return arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart(arkts.factory.createIdentifier(name)) + ); + } + + /** + * create `() => `. If returnType is not given, then using `void`. + */ + static createLambdaFunctionType( + params?: arkts.Expression[], + returnType?: arkts.TypeNode | undefined + ): arkts.ETSFunctionType { + return arkts.factory.createFunctionType( + arkts.FunctionSignature.createFunctionSignature( + undefined, + params ?? [], + returnType ?? arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID), + false + ), + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW + ); + } + + /** + * create and insert `import { as } from ` to the top of script's statements. + */ + static createAndInsertImportDeclaration( + source: arkts.StringLiteral, + imported: arkts.Identifier, + local: arkts.Identifier, + importKind: arkts.Es2pandaImportKinds, + program: arkts.Program + ): void { + const importDecl: arkts.ETSImportDeclaration = arkts.factory.createImportDeclaration( + source, + [arkts.factory.createImportSpecifier(imported, local)], + importKind, + program, + arkts.Es2pandaImportFlags.IMPORT_FLAGS_NONE + ); + arkts.importDeclarationInsert(importDecl, program); + return; + } + + /* + * create `import { as } ...`. + */ + static createAdditionalImportSpecifier(imported: string, local: string): arkts.ImportSpecifier { + return arkts.factory.createImportSpecifier( + arkts.factory.createIdentifier(imported), + arkts.factory.createIdentifier(local) + ); + } + + /* + * create `constructor() {}`. + */ + static createConstructorMethod(member: arkts.MethodDefinition): arkts.MethodDefinition { + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_CONSTRUCTOR, + member.name, + member.scriptFunction, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_CONSTRUCTOR, + false + ); + } + + /* + * create `@memo() _build(<>)`. + */ + static transformBuildMethodWithOriginBuild( + method: arkts.MethodDefinition, + typeName: string, + optionsName: string, + isDecl?: boolean + ): arkts.MethodDefinition { + const updateKey: arkts.Identifier = arkts.factory.createIdentifier(CustomComponentNames.COMPONENT_BUILD); + + const scriptFunction: arkts.ScriptFunction = method.scriptFunction; + const updateScriptFunction = arkts.factory + .createScriptFunction( + scriptFunction.body, + arkts.FunctionSignature.createFunctionSignature( + scriptFunction.typeParams, + [ + factory.createStyleParameter(typeName), + factory.createContentParameter(), + factory.createInitializersOptionsParameter(optionsName), + ], + arkts.factory.createPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID), + false + ), + scriptFunction.flags, + scriptFunction.modifiers + ) + .setAnnotations([annotation('memo')]); + + const modifiers: arkts.Es2pandaModifierFlags = isDecl + ? arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_ABSTRACT + : arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC; + return arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD, + updateKey, + updateScriptFunction, + modifiers, + false + ); + } + + /* + * add alias: to @Provide annotation when no alias in @Provide({...}). + */ + static processNoAliasProvideVariable(property: arkts.ClassProperty): void { + let annotations: readonly arkts.AnnotationUsage[] = property.annotations; + if (annotations.length === 0) { + return; + } + const newAnnos: arkts.AnnotationUsage[] = annotations.map((anno: arkts.AnnotationUsage) => { + if ( + !!anno.expr && + arkts.isIdentifier(anno.expr) && + anno.expr.name === DecoratorNames.PROVIDE && + !hasPropertyInAnnotation(anno, 'alias') && + property.key && + arkts.isIdentifier(property.key) + ) { + return arkts.factory.update1AnnotationUsage(anno, anno.expr, [ + ...anno.properties, + factory.createAliasClassProperty(property.key), + ]); + } else { + return anno; + } + }); + property.setAnnotations(newAnnos); + } + + /* + * create class property : `alias: `. + */ + static createAliasClassProperty(value: arkts.Identifier): arkts.ClassProperty { + return arkts.factory.createClassProperty( + arkts.factory.createIdentifier('alias'), + arkts.factory.create1StringLiteral(value.name), + undefined, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + false + ); + } + + /* + * add optional or definite modifier for class property needs initializing without assignment. + */ + static PreprocessClassPropertyModifier(st: arkts.AstNode): arkts.AstNode { + if (arkts.isClassProperty(st) && needDefiniteOrOptionalModifier(st)) { + if (st.typeAnnotation && hasNullOrUndefinedType(st.typeAnnotation)) { + st.modifiers = arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_OPTIONAL; + } else { + st.modifiers = arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_DEFINITE; + } + } + return st; + } +} diff --git a/ets1.2/arkui-plugins/ui-plugins/utils.ts b/ets1.2/arkui-plugins/ui-plugins/utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..847a830a55d073882303beadbe04b4b210dbabba --- /dev/null +++ b/ets1.2/arkui-plugins/ui-plugins/utils.ts @@ -0,0 +1,199 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { annotation } from '../common/arkts-utils'; +import { DecoratorNames } from './property-translators/utils'; + +export enum CustomComponentNames { + ENTRY_ANNOTATION_NAME = 'Entry', + COMPONENT_ANNOTATION_NAME = 'Component', + RESUABLE_ANNOTATION_NAME = 'Reusable', + COMPONENT_BUILD_ORI = 'build', + COMPONENT_CONSTRUCTOR_ORI = 'constructor', + COMPONENT_DEFAULT_IMPORT = 'arkui.component.customComponent', + COMPONENT_CLASS_NAME = 'CustomComponent', + COMPONENT_INTERFACE_PREFIX = '__Options_', + COMPONENT_INITIALIZE_STRUCT = '__initializeStruct', + COMPONENT_UPDATE_STRUCT = '__updateStruct', + COMPONENT_BUILD = '_build', + REUSABLE_COMPONENT_REBIND_STATE = '__rebindStates', + COMPONENT_INITIALIZERS_NAME = 'initializers', + BUILDCOMPATIBLENODE = '_buildCompatibleNode', + OPTIONS = 'options', +} + +export enum BuilderLambdaNames { + ANNOTATION_NAME = 'ComponentBuilder', + ORIGIN_METHOD_NAME = '$_instantiate', + TRANSFORM_METHOD_NAME = '_instantiateImpl', + STYLE_PARAM_NAME = 'style', + STYLE_ARROW_PARAM_NAME = 'instance', + CONTENT_PARAM_NAME = 'content', + ANIMATION_NAME = 'animation', + ANIMATION_START = 'animationStart', + ANIMATION_STOP = 'animationStop', +} + +export enum Dollars { + DOLLAR_RESOURCE = '$r', + DOLLAR_RAWFILE = '$rawfile', + DOLLAR_DOLLAR = '$$', +} + +export function findLocalImport( + node: arkts.ETSImportDeclaration, + sourceName: string, + importedName: string +): arkts.Identifier | undefined { + const isFromSource = !!node.source && node.source.str === sourceName; + if (!isFromSource) return undefined; + + const importSpecifier = node.specifiers.find( + (spec) => arkts.isImportSpecifier(spec) && !!spec.imported && spec.imported.name === importedName + ) as arkts.ImportSpecifier | undefined; + return importSpecifier?.local ?? importSpecifier?.imported; +} + +// TODO: currently, we forcely assume initializerOptions is named in pattern __Options_xxx +export function getCustomComponentNameFromInitializerOptions(name: string): string | undefined { + const prefix: string = CustomComponentNames.COMPONENT_INTERFACE_PREFIX; + if (name.startsWith(prefix)) { + return name.substring(prefix.length); + } +} + +export function getCustomComponentOptionsName(className: string): string { + return `${CustomComponentNames.COMPONENT_INTERFACE_PREFIX}${className}`; +} + +export function isStatic(node: arkts.AstNode): boolean { + return node.isStatic; +} + +export function getTypeParamsFromClassDecl(node: arkts.ClassDeclaration | undefined): readonly arkts.TSTypeParameter[] { + return node?.definition?.typeParams?.params ?? []; +} + +export function getTypeNameFromTypeParameter(node: arkts.TSTypeParameter | undefined): string | undefined { + return node?.name?.name; +} + +export function createOptionalClassProperty( + name: string, + property: arkts.ClassProperty, + stageManagementIdent: string, + modifiers: arkts.Es2pandaModifierFlags, + needMemo: boolean = false +): arkts.ClassProperty { + const newType: arkts.TypeNode | undefined = property.typeAnnotation?.clone(); + if (needMemo) { + newType?.setAnnotations([annotation('memo')]); + } + const newProperty = arkts.factory.createClassProperty( + arkts.factory.createIdentifier(name), + undefined, + stageManagementIdent.length ? createStageManagementType(stageManagementIdent, property) : newType, + modifiers, + false + ); + return arkts.classPropertySetOptional(newProperty, true); +} + +export function createStageManagementType( + stageManagementIdent: string, + property: arkts.ClassProperty +): arkts.ETSTypeReference { + return arkts.factory.createTypeReference( + arkts.factory.createTypeReferencePart( + arkts.factory.createIdentifier(stageManagementIdent), + arkts.factory.createTSTypeParameterInstantiation([ + property.typeAnnotation ? property.typeAnnotation.clone() : arkts.factory.createETSUndefinedType(), + ]) + ) + ); +} + +export function getGettersFromClassDecl(definition: arkts.ClassDefinition): arkts.MethodDefinition[] { + return definition.body.filter( + (member) => + arkts.isMethodDefinition(member) && + arkts.hasModifierFlag(member, arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_GETTER) + ) as arkts.MethodDefinition[]; +} + +export type MemoAstNode = + | arkts.ScriptFunction + | arkts.ETSParameterExpression + | arkts.ClassProperty + | arkts.TSTypeAliasDeclaration + | arkts.ETSFunctionType + | arkts.ArrowFunctionExpression + | arkts.ETSUnionType; + +export function isMemoAnnotation(node: arkts.AnnotationUsage, memoName: string): boolean { + if (!(node.expr !== undefined && arkts.isIdentifier(node.expr) && node.expr.name === memoName)) { + return false; + } + return true; +} + +export function addMemoAnnotation(node: T, memoName: string = 'memo'): T { + if (arkts.isETSUnionType(node)) { + const functionType = node.types.find((type) => arkts.isETSFunctionType(type)); + if (!functionType) { + return node; + } + addMemoAnnotation(functionType, memoName); + return node; + } + const newAnnotations: arkts.AnnotationUsage[] = [ + ...node.annotations.filter((it) => !isMemoAnnotation(it, memoName)), + annotation(memoName), + ]; + if (arkts.isEtsParameterExpression(node)) { + node.annotations = newAnnotations; + return node; + } + return node.setAnnotations(newAnnotations) as T; +} + +export function hasPropertyInAnnotation(annotation: arkts.AnnotationUsage, propertyName: string): boolean { + return !!annotation.properties.find( + (annoProp: arkts.AstNode) => + arkts.isClassProperty(annoProp) && + annoProp.key && + arkts.isIdentifier(annoProp.key) && + annoProp.key.name === propertyName + ); +} + +/** + * Determine whether the type node includes null or undefined type. + * + * @param type type node + */ +export function hasNullOrUndefinedType(type: arkts.TypeNode): boolean { + let res: boolean = false; + if (arkts.isETSUnionType(type)) { + type.types.forEach((item: arkts.TypeNode) => { + res = res || hasNullOrUndefinedType(item); + }); + } + if (arkts.isETSUndefinedType(type) || arkts.isETSNullType(type)) { + res = true; + } + return res; +} \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/index.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..53232081ede8d769c434e28a3bbb0b038e6a304f --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/index.ts @@ -0,0 +1,44 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { PluginContext, Plugins } from '../common/plugin-context'; +import { ParsedUISyntaxLinterTransformer } from './transformers/parsed-ui-syntax-linter-transformer'; +import { createUISyntaxRuleProcessor } from './processor'; +import rules from './rules'; + +export function uiSyntaxLinterTransform(): Plugins { + const processor = createUISyntaxRuleProcessor(rules); + return { + name: 'ui-syntax-plugin', + parsed(this: PluginContext): arkts.EtsScript | undefined { + const contextPtr = arkts.arktsGlobal.compilerContext?.peer ?? this.getContextPtr(); + if (!contextPtr) { + return undefined; + } + let program = arkts.getOrUpdateGlobalContext(contextPtr).program; + const node = program.astNode; + if (node) { + const script = new ParsedUISyntaxLinterTransformer(processor).visitor( + node, + ) as arkts.EtsScript; + arkts.setAllParents(script); + this.setArkTSAst(script); + return script; + } + return undefined; + } + }; +} diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/processor/index.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/processor/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..0a447759e85e1d8c7e5eaa0698820bc082ea52a7 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/processor/index.ts @@ -0,0 +1,64 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { UISyntaxRule, UISyntaxRuleContext } from '../rules/ui-syntax-rule'; +import { getContainerComponents } from '../utils'; + +export type UISyntaxRuleProcessor = { + parsed(node: arkts.AstNode): void; +}; + +export function createUISyntaxRuleProcessor( + rules: UISyntaxRule[], +): UISyntaxRuleProcessor { + const containerComponents = getContainerComponents('../../components/'); + const context: UISyntaxRuleContext = { + report(options) { + const position = arkts.getStartPosition(options.node); + let message: string; + if (!options.data) { + message = options.message; + } else { + message = Object.entries(options.data).reduce( + (message, [placehoderName, placehoderValue]) => { + return message.replace(`{{${placehoderName}}}`, placehoderValue); + }, + options.message, + ); + } + // todo + if (options.fix) { + const suggestion = options.fix(options.node); + console.log(`error: ${message}`); + console.log(`range: (${suggestion.range[0].index()}, ${suggestion.range[0].line()}) - (${suggestion.range[1].index()}, ${suggestion.range[1].line()})`, + `code: ${suggestion.code}`); + } else { + console.log(`syntax-error: ${message} (${position.index()},${position.line()})`); + } + }, + containerComponents: containerComponents, + }; + + const instances = rules.map((rule) => rule.setup(context)); + + return { + parsed(node): void { + for (const instance of instances) { + instance.parsed?.(node); + } + }, + }; +} diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/build-root-node.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/build-root-node.ts new file mode 100644 index 0000000000000000000000000000000000000000..c3678f1fe2e25a39bab9c7eb0b115b71196488d8 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/build-root-node.ts @@ -0,0 +1,100 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getIdentifierName, getAnnotationUsage, PresetDecorators } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +const BUILD_NAME: string = 'build'; +const BUILD_ROOT_NUM: number = 1; +const STATEMENT_LENGTH: number = 1; + +function isBuildOneRoot(statements: readonly arkts.Statement[], buildNode: arkts.Identifier, + context: UISyntaxRuleContext): void { + if (statements.length > STATEMENT_LENGTH && buildNode) { + context.report({ + node: buildNode, + message: rule.messages.invalidBuildRootCount, + }); + } +} + +function checkBuildRootNode(node: arkts.AstNode, context: UISyntaxRuleContext): void { + const loadedContainerComponents = context.containerComponents; + if (!arkts.isStructDeclaration(node)) { + return; + } + const entryDecoratorUsage = getAnnotationUsage(node, PresetDecorators.ENTRY); + node.definition.body.forEach(member => { + // Determine the number of root node + if (!arkts.isMethodDefinition(member) || getIdentifierName(member.name) !== BUILD_NAME) { + return; + } + const blockStatement = member.scriptFunction.body; + if (!blockStatement || !arkts.isBlockStatement(blockStatement)) { + return; + } + const buildNode = member.scriptFunction.id; + const statements = blockStatement.statements; + // rule1: The 'build' method cannot have more than one root node. + if (buildNode) { + isBuildOneRoot(statements, buildNode, context); + } + if (statements.length !== BUILD_ROOT_NUM) { + return; + } + // Determine whether it is a container component + const expressionStatement = statements[0]; + if (!arkts.isExpressionStatement(expressionStatement)) { + return; + } + const callExpression = expressionStatement.expression; + if (!arkts.isCallExpression(callExpression)) { + return; + } + const componentName = callExpression.expression.dumpSrc(); + let isContainer: boolean = false; + loadedContainerComponents?.forEach(container => { + if (componentName.includes(container)) { + isContainer = true; + } + }); + // rule2: If the component is decorated by '@Entry', + // its 'build' function can have only one root node, which must be a container component. + if (entryDecoratorUsage && !isContainer && buildNode) { + context.report({ + node: buildNode, + message: rule.messages.invalidBuildRoot, + }); + } + }); +} + +const rule: UISyntaxRule = { + name: 'build-root-node', + messages: { + invalidBuildRootCount: `The 'build' method cannot have more than one root node.`, + invalidBuildRoot: `If the component is decorated by '@Entry', its 'build' function can have only one root node, which must be a container component.` + }, + setup(context) { + return { + parsed: (node): void => { + checkBuildRootNode(node, context); + }, + }; + }, +}; + +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/check-construct-private-parameter.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/check-construct-private-parameter.ts new file mode 100644 index 0000000000000000000000000000000000000000..7dfa570b04da98eeea09a1f315c47adcc1e2b67c --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/check-construct-private-parameter.ts @@ -0,0 +1,93 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getClassPropertyName, isPrivateClassProperty } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +function addProperty(item: arkts.AstNode, structName: string, privateMap: Map): void { + if (!arkts.isClassProperty(item) || !isPrivateClassProperty(item)) { + return; + } + // Check if structName already exists in privateMap + if (privateMap.has(structName)) { + // If it exists, retrieve the current string[] and append the new content + privateMap.get(structName)?.push(getClassPropertyName(item)); + } else { + // If it doesn't exist, create a new string[] and add the content + privateMap.set(structName, [getClassPropertyName(item)]); + } +} + +function checkPrivateVariables( + node: arkts.AstNode, + context: UISyntaxRuleContext, + privateMap: Map +): void { + // Check if the current node is the root node + if (arkts.nodeType(node) === arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) { + node.getChildren().forEach((member) => { + if (!arkts.isStructDeclaration(member)) { + return; + } + const structName: string = member.definition.ident?.name ?? ''; + member.definition?.body?.forEach((item) => { + addProperty(item, structName, privateMap); + }); + }); + } + if (!arkts.isCallExpression(node)) { + return; + } + const componentName = node.expression.dumpSrc(); + // If the initialization is for a component with private properties + if (!privateMap.has(componentName)) { + return; + } + node.arguments?.forEach((member) => { + member.getChildren().forEach((property) => { + if (!arkts.isProperty(property)) { + return; + } + const propertyName: string = property.key?.dumpSrc() ?? ''; + if (privateMap.get(componentName)!.includes(propertyName)) { + context.report({ + node: property, + message: rule.messages.cannotInitializePrivateVariables, + data: { + propertyName: propertyName, + }, + }); + } + }); + }); +} + +const rule: UISyntaxRule = { + name: 'check-construct-private-parameter', + messages: { + cannotInitializePrivateVariables: `Property '{{propertyName}}' is private and can not be initialized through the component constructor.`, + }, + setup(context) { + let privateMap: Map = new Map(); + return { + parsed: (node): void => { + checkPrivateVariables(node, context, privateMap); + }, + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/check-decorated-property-type.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/check-decorated-property-type.ts new file mode 100644 index 0000000000000000000000000000000000000000..8448fa4351390e77f69b24b28174ae79de7d5008 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/check-decorated-property-type.ts @@ -0,0 +1,77 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; +import { + getAnnotationUsage, getClassPropertyAnnotationNames, getClassPropertyName, + getClassPropertyType, PresetDecorators +} from '../utils'; + +function checkDecoratedPropertyType( + member: arkts.AstNode, + context: UISyntaxRuleContext, + relationship: Record +): void { + if (!arkts.isClassProperty(member)) { + return; + } + const propertyName = getClassPropertyName(member); + const propertyType = getClassPropertyType(member); + const propertyAnnotationNames = getClassPropertyAnnotationNames(member); + Object.entries(relationship).forEach(([decoratorName, invalidPropertyTypes]) => { + if (propertyAnnotationNames.some(annotationName => annotationName === decoratorName) && + invalidPropertyTypes + .some(invalidPropertyType => invalidPropertyType === propertyType)) { + if (!arkts.isClassProperty || member.key === undefined) { + return; + } + const errorNode = member.key; + context.report({ + node: errorNode, + message: rule.messages.invalidDecoratedPropertyType, + data: { decoratorName, propertyName, propertyType }, + }); + } + }); +} + +const rule: UISyntaxRule = { + name: 'check-decorated-property-type', + messages: { + invalidDecoratedPropertyType: `The {{decoratorName}} property '{{propertyName}}' cannot be a '{{propertyType}}' object.`, + }, + setup(context) { + const relationship: Record = { + [PresetDecorators.STATE]: ['CustomDialogController'], + }; + return { + parsed: (node): void => { + if (!arkts.isStructDeclaration(node)) { + return; + } + const componentDecorator = getAnnotationUsage(node, PresetDecorators.COMPONENT_V1); + if (!componentDecorator) { + return; + } + node.definition.body.forEach(member => { + checkDecoratedPropertyType(member, context, relationship); + }); + }, + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/component-componentV2-mix-use-check.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/component-componentV2-mix-use-check.ts new file mode 100644 index 0000000000000000000000000000000000000000..ce7afdf8ffdd1b6362c5692a8d3f87d343afd724 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/component-componentV2-mix-use-check.ts @@ -0,0 +1,177 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { PresetDecorators } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +// Report an Observed version violation error +function reportObservedConflict( + node: arkts.ClassProperty, + context: UISyntaxRuleContext, + message: string +): void { + node.annotations.forEach((anno) => { + if (anno.expr?.dumpSrc()) { + context.report({ + node: anno, + message: message, + data: { + annotation: anno.expr?.dumpSrc(), + } + }); + } + }); +} + +function processNode( + node: arkts.ClassProperty, + annotationName: string, + observedV1Name: Set, + observedV2Name: Set, + context: UISyntaxRuleContext +): void { + const queue: Array = [node]; + while (queue.length > 0) { + const currentNode: arkts.AstNode = queue.shift() as arkts.AstNode; + if (arkts.isIdentifier(currentNode)) { + if (observedV1Name.has(currentNode.dumpSrc()) && annotationName === PresetDecorators.COMPONENT_V2) { + reportObservedConflict(node, context, rule.messages.observedv1_v2); + break; + } + if (observedV2Name.has(currentNode.dumpSrc()) && annotationName === PresetDecorators.COMPONENT_V1) { + reportObservedConflict(node, context, rule.messages.observedv2_v1); + break; + } + } + const children = currentNode.getChildren(); + for (const child of children) { + queue.push(child); + } + } +} + +function traverseTree( + node: arkts.AstNode, + annotationName: string, + observedV1Name: Set, + observedV2Name: Set, + context: UISyntaxRuleContext +): void { + if (arkts.isClassProperty(node)) { + processNode(node, annotationName, observedV1Name, observedV2Name, context); + } + const children = node.getChildren(); + for (const child of children) { + traverseTree(child, annotationName, observedV1Name, observedV2Name, context); + } +} + +function findAllObserved(node: arkts.AstNode, observedV1Name: Set, observedV2Name: Set): void { + if (arkts.isClassDeclaration(node)) { + node.definition?.annotations.forEach((anno) => { + if (anno.expr?.dumpSrc() === PresetDecorators.OBSERVED_V1) { + const componentV1Name = node?.definition?.ident?.name; + componentV1Name ? observedV1Name.add(componentV1Name) : null; + } + if (anno.expr?.dumpSrc() === PresetDecorators.OBSERVED_V2) { + const componentV2Name = node?.definition?.ident?.name; + componentV2Name ? observedV2Name.add(componentV2Name) : null; + } + }); + } + const children = node.getChildren(); + for (const child of children) { + findAllObserved(child, observedV1Name, observedV2Name); + } +} + +function findAllTSTypeAliasDeclaration( + node: arkts.AstNode, + observedV1Name: Set, + observedV2Name: Set +): void { + if (arkts.nodeType(node) === arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION) { + node.getChildren().forEach((child) => { + if (arkts.isIdentifier(child)) { + const typeName = child.dumpSrc(); + findAllObservedType(node, typeName, observedV1Name, observedV2Name); + } + }); + } + const children = node.getChildren(); + for (const child of children) { + findAllTSTypeAliasDeclaration(child, observedV1Name, observedV2Name); + } +} + +function findAllObservedType( + node: arkts.AstNode, + typeName: string, + observedV1Name: Set, + observedV2Name: Set +): void { + if (arkts.isIdentifier(node) && observedV1Name.has(node.dumpSrc())) { + observedV1Name.add(typeName); + } + if (arkts.isIdentifier(node) && observedV2Name.has(node.dumpSrc())) { + observedV2Name.add(typeName); + } + const children = node.getChildren(); + for (const child of children) { + findAllObservedType(child, typeName, observedV1Name, observedV2Name); + } +} + +function processComponentAnnotations( + node: arkts.StructDeclaration, + observedV1Name: Set, + observedV2Name: Set, + context: UISyntaxRuleContext +): void { + node?.definition?.annotations.forEach((anno) => { + if (anno.expr?.dumpSrc() === PresetDecorators.COMPONENT_V2) { + traverseTree(node, PresetDecorators.COMPONENT_V2, observedV1Name, observedV2Name, context); + } + if (anno.expr?.dumpSrc() === PresetDecorators.COMPONENT_V1) { + traverseTree(node, PresetDecorators.COMPONENT_V1, observedV1Name, observedV2Name, context); + } + }); +} + +const rule: UISyntaxRule = { + name: 'component-componentV2-mix-use-check', + messages: { + observedv1_v2: `The type of the @{{annotation}} Decorator property can not be a class decorated with @Observed.`, + observedv2_v1: `The type of the @{{annotation}} Decorator property can not be a class decorated with @ObservedV2.` + }, + setup(context) { + let observedV1Name: Set = new Set(); + let observedV2Name: Set = new Set(); + return { + parsed: (node): void => { + if (arkts.nodeType(node) === arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) { + findAllObserved(node, observedV1Name, observedV2Name); + findAllTSTypeAliasDeclaration(node, observedV1Name, observedV2Name); + } + if (arkts.isStructDeclaration(node)) { + processComponentAnnotations(node, observedV1Name, observedV2Name, context); + } + }, + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/componentV2-mix-check.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/componentV2-mix-check.ts new file mode 100644 index 0000000000000000000000000000000000000000..082d768d1abf99e1fffe480a88fdc4e829fa0afb --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/componentV2-mix-check.ts @@ -0,0 +1,57 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getAnnotationUsage, PresetDecorators } from '../utils'; +import { UISyntaxRule } from './ui-syntax-rule'; + +const rule: UISyntaxRule = { + name: 'componentV2-mix-check', + messages: { + conflictWithComponentV2: `The struct '{{structName}}' can not be decorated with '@ComponentV2' and '@Component', '@Reusable', '@CustomDialog' at the same time.`, + }, + setup(context) { + return { + parsed: (node): void => { + if (!arkts.isStructDeclaration(node)) { + return; + } + const structName = node.definition.ident?.name ?? ''; + const structNameNode = node.definition.ident; + if (!structNameNode) { + return; + } + // Check if the struct has the '@ComponentV2' annotation + const hasComponentV2 = getAnnotationUsage(node, PresetDecorators.COMPONENT_V2); + if (!hasComponentV2) { + return; + } + // Check for the presence of conflicting decorators: '@Component', '@Reusable', '@CustomDialog' + const hasComponent = getAnnotationUsage(node, PresetDecorators.COMPONENT_V1); + const hasReusable = getAnnotationUsage(node, PresetDecorators.REUSABLE_V1); + const hasCustomDialog = getAnnotationUsage(node, PresetDecorators.CUSTOM_DIALOG); + if (hasComponent || hasReusable || hasCustomDialog) { + context.report({ + node: structNameNode, + message: rule.messages.conflictWithComponentV2, + data: { structName }, + }); + } + }, + }; + }, +}; + +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/componentV2-state-usage-validation.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/componentV2-state-usage-validation.ts new file mode 100644 index 0000000000000000000000000000000000000000..b60587aeece7799fc34f3f48b37c5dc0aad66a0c --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/componentV2-state-usage-validation.ts @@ -0,0 +1,168 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getClassPropertyAnnotationNames, PresetDecorators, getAnnotationUsage } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +// Helper functions for rules +const hasisComponentV2 = (node: arkts.StructDeclaration): boolean => !!getAnnotationUsage(node, + PresetDecorators.COMPONENT_V2); + +const hasComponent = (node: arkts.StructDeclaration): boolean => !!getAnnotationUsage(node, + PresetDecorators.COMPONENT_V1); +function checkMultipleBuiltInDecorators(context: UISyntaxRuleContext, member: arkts.ClassProperty, + propertyDecorators: string[]): void { + const builtInDecorators = [PresetDecorators.LOCAL, PresetDecorators.PARAM, PresetDecorators.EVENT]; + const appliedBuiltInDecorators = propertyDecorators.filter(d => builtInDecorators.includes(d)); + if (appliedBuiltInDecorators.length > 1) { + member.annotations?.forEach(annotation => { + const annotationsName = annotation.expr?.dumpSrc(); + reportMultipleBuiltInDecoratorsError(context, annotation, annotationsName, builtInDecorators); + }); + } +}; + +function reportMultipleBuiltInDecoratorsError(context: UISyntaxRuleContext, annotation: arkts.AstNode, + annotationsName: string | undefined, builtInDecorators: string[]): void { + if (annotationsName && builtInDecorators.includes(annotationsName)) { + context.report({ + node: annotation, + message: rule.messages.multipleBuiltInDecorators, + fix: (annotation) => { + const startPosition = arkts.getStartPosition(annotation); + const endPosition = arkts.getEndPosition(annotation); + return { + range: [startPosition, endPosition], + code: '', + }; + }, + }); + } +} + +function checkDecoratorOnlyInisComponentV2(context: UISyntaxRuleContext, member: arkts.ClassProperty, + node: arkts.StructDeclaration, hasisComponentV2: boolean, hasComponent: boolean): void { + const builtInDecorators = [PresetDecorators.LOCAL, PresetDecorators.PARAM, PresetDecorators.EVENT]; + member.annotations?.forEach(annotation => { + const annotationsName = annotation.expr?.dumpSrc(); + if (annotationsName && builtInDecorators.includes(annotationsName) && !hasisComponentV2 && !hasComponent) { + reportDecoratorOnlyInisComponentV2Error(context, annotation, annotationsName, node); + } + }); +}; + +function reportDecoratorOnlyInisComponentV2Error(context: UISyntaxRuleContext, annotation: arkts.AnnotationUsage, + annotationsName: string, node: arkts.StructDeclaration): void { + context.report({ + node: annotation, + message: rule.messages.decoratorOnlyInisComponentV2, + data: { annotationsName }, + fix: (annotation) => { + const startPosition = arkts.getStartPosition(node); + return { + range: [startPosition, startPosition], + code: `@${PresetDecorators.COMPONENT_V2}\n`, + }; + }, + }); +} + +function checkParamRequiresRequire(context: UISyntaxRuleContext, member: arkts.ClassProperty, + propertyDecorators: string[]): void { + if (propertyDecorators.includes(PresetDecorators.PARAM) && !member.value && + !propertyDecorators.includes(PresetDecorators.REQUIRE) && member.key) { + const memberKey = member.key; + context.report({ + node: memberKey, + message: rule.messages.paramRequiresRequire, + fix: (memberKey) => { + const startPosition = arkts.getStartPosition(memberKey); + return { + range: [startPosition, startPosition], + code: `@${PresetDecorators.REQUIRE} `, + }; + }, + }); + } +}; + +function checkRequireOnlyWithParam(context: UISyntaxRuleContext, member: arkts.ClassProperty, + propertyDecorators: string[]): void { + const requireDecorator = member.annotations?.find(annotation => + annotation.expr && annotation.expr.dumpSrc() === PresetDecorators.REQUIRE + ); + if (requireDecorator && !propertyDecorators.includes(PresetDecorators.PARAM)) { + context.report({ + node: requireDecorator, + message: rule.messages.requireOnlyWithParam, + fix: (requireDecorator) => { + const startPosition = arkts.getStartPosition(requireDecorator); + const endPosition = arkts.getEndPosition(requireDecorator); + return { + range: [startPosition, endPosition], + code: '', + }; + }, + }); + } +}; + +function validateClassPropertyDecorators(context: UISyntaxRuleContext, node: arkts.StructDeclaration): void { + const isComponentV2 = hasisComponentV2(node); + const isComponent = hasComponent(node); + node.definition.body.forEach(member => { + if (!arkts.isClassProperty(member)) { + return; + } + const propertyDecorators = getClassPropertyAnnotationNames(member); + + // Rule 1: Multiple built-in decorators + checkMultipleBuiltInDecorators(context, member, propertyDecorators); + + // Rule 2: Built-in decorators only allowed in @isComponentV2 + checkDecoratorOnlyInisComponentV2(context, member, node, isComponentV2, isComponent); + + // Rule 3: @Param without default value must be combined with @Require + checkParamRequiresRequire(context, member, propertyDecorators); + + // Rule 4: @Require must be used together with @Param + checkRequireOnlyWithParam(context, member, propertyDecorators); + }); +} + +const rule: UISyntaxRule = { + name: 'iscomponentV2-state-usage-validation', + messages: { + multipleBuiltInDecorators: `The member property or method cannot be decorated by multiple built-in decorators.`, + decoratorOnlyInisComponentV2: `The '@{{annotationsName}}' decorator can only be used in a 'struct' decorated with '@isComponentV2'.`, + paramRequiresRequire: `When a variable decorated with @Param is not assigned a default value, it must also be decorated with @Require.`, + requireOnlyWithParam: `In a struct decorated with @isComponentV2, @Require can only be used with @Param. ` + }, + + setup(context) { + return { + parsed: (node): void => { + + if (!arkts.isStructDeclaration(node)) { + return; + } + validateClassPropertyDecorators(context, node); + }, + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/construct-parameter-literal.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/construct-parameter-literal.ts new file mode 100644 index 0000000000000000000000000000000000000000..f893b01ded67683f6d0a0e31f23845cc6a8ac9aa --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/construct-parameter-literal.ts @@ -0,0 +1,112 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; +import { PresetDecorators } from '../utils'; + +function recordStructWithLinkDecorators(item: arkts.AstNode, structName: string, linkMap: Map): void { + if (!arkts.isClassProperty(item)) { + return; + } + item.annotations?.forEach((annotation) => { + const annotationName: string = annotation.expr?.dumpSrc() ?? ''; + if (annotationName === '') { + return; + } + // If the node has properties decorated with Link or ObjectLink, record this structure node + if (annotationName === PresetDecorators.LINK || annotationName === PresetDecorators.OBJECT_LINK) { + linkMap.set(structName, annotationName); + } + }); +} + +function initMap(node: arkts.AstNode, linkMap: Map): void { + // Check if the current node is the root node + if (arkts.nodeType(node) !== arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) { + return; + } + node.getChildren().forEach((member) => { + if (!arkts.isStructDeclaration(member)) { + return; + } + const structName: string = member.definition.ident?.name ?? ''; + if (structName === '') { + return; + } + member.definition?.body?.forEach((item) => { + recordStructWithLinkDecorators(item, structName, linkMap); + }); + }); +} + +function checkInitializeWithLiteral(node: arkts.AstNode, context: UISyntaxRuleContext, + linkMap: Map +): void { + if (!arkts.isCallExpression(node)) { + return; + } + const componentName = node.expression.dumpSrc(); + // Only assignments to properties decorated with Link or ObjectLink trigger rule checks + if (!linkMap.has(componentName)) { + return; + } + node.arguments.forEach((member) => { + member.getChildren().forEach((property) => { + if (!arkts.isProperty(property)) { + return; + } + if (property.value === undefined) { + return; + } + const propertyType: arkts.Es2pandaAstNodeType = arkts.nodeType(property.value); + const key: string = property.key?.dumpSrc() ?? ''; + if (key === '') { + return; + } + const value = property.value?.dumpSrc() ? property.value.dumpSrc() : ''; + // If the assignment statement is not of type MemberExpression, throw an error + if (propertyType !== arkts.Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION) { + context.report({ + node: property, + message: rule.messages.cannotInitializeWithLiteral, + data: { + value: value, + annotationName: linkMap.get(componentName)!, + key: key, + }, + }); + } + }); + }); +} + +const rule: UISyntaxRule = { + name: 'construct-parameter-literal', + messages: { + cannotInitializeWithLiteral: `Assigning the attribute'{{value}}' to the '@{{annotationName}}' decorated attribute '{{key}}' is not allowed.`, + }, + setup(context) { + let linkMap: Map = new Map(); + return { + parsed: (node): void => { + initMap(node, linkMap); + checkInitializeWithLiteral(node, context, linkMap); + }, + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/consumer-provider-decorator-check.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/consumer-provider-decorator-check.ts new file mode 100644 index 0000000000000000000000000000000000000000..cb4f7fcd8d2ca14ee0257e8f7424a9e82aec7755 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/consumer-provider-decorator-check.ts @@ -0,0 +1,271 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getAnnotationUsage, MultiMap, PresetDecorators } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; +// Traverse the member variables of the struct, recording the members of the @Consumer modifications +function processStructMembers( + node: arkts.StructDeclaration, + structName: string, + componentv2WithConsumer: MultiMap +): void { + node.definition.body.forEach((member) => { + // When a member variable is @consumer modified, it is stored to mark fields that cannot be initialized + if (arkts.isClassProperty(member)) { + const memberName = member?.key?.dumpSrc(); + structName && memberName ? componentv2WithConsumer.add(structName, memberName) : null; + } + }); +} +function rememberStructName(node: arkts.AstNode, componentv2WithConsumer: MultiMap): void { + // First it has to be of the struct type + if (arkts.isStructDeclaration(node)) { + node?.definition?.annotations.forEach((anno) => { + // Second, it must be decorated with a @component v2 decorator + if (anno.expr?.dumpSrc() === PresetDecorators.COMPONENT_V2) { + const structName = node.definition.ident?.name ?? ''; + processStructMembers(node, structName, componentv2WithConsumer); + } + }); + } +} +function findDecorator(member: arkts.ClassProperty, decorator: string): arkts.AnnotationUsage | undefined { + return member.annotations?.find(annotation => + annotation.expr && + annotation.expr.dumpSrc() === decorator + ); +} +// Verify that the @Consumer decorator is used on the method +function validateConsumerOnMethod(member: arkts.MethodDefinition, context: UISyntaxRuleContext): void { + const annotationNode = member.scriptFunction.annotations?.find(annotation => + annotation.expr && annotation.expr.dumpSrc() === PresetDecorators.CONSUMER + ); + if (annotationNode) { + context.report({ + node: annotationNode, + message: rule.messages.consumerOnlyOnMember, + fix: (annotationNode) => { + const startPosition = arkts.getStartPosition(annotationNode); + const endPosition = arkts.getEndPosition(annotationNode); + return { + range: [startPosition, endPosition], + code: '', + }; + } + }); + } +} +// @Consumer Bugs that conflict with other decorators +function reportMultipleBuiltInDecorators( + hasConsumeDecorator: arkts.AnnotationUsage, + otherDecorators: arkts.AnnotationUsage, + context: UISyntaxRuleContext, +): void { + context.report({ + node: hasConsumeDecorator, + message: rule.messages.multipleBuiltInDecorators, + fix: (hasConsumeDecorator) => { + const startPosition = arkts.getStartPosition(otherDecorators); + const endPosition = arkts.getEndPosition(otherDecorators); + return { + range: [startPosition, endPosition], + code: '', + }; + } + }); +} +// Report a bug where @Provider is missing @ComponentV2 +function reportProviderRequiresComponentV2( + hasProviderDecorator: arkts.AnnotationUsage, + hasComponent: arkts.AnnotationUsage | undefined, + node: arkts.AstNode, + context: UISyntaxRuleContext, +): void { + if (hasComponent) { + context.report({ + node: hasProviderDecorator, + message: rule.messages.providerRequiresComponentV2, + fix: (hasProviderDecorator) => { + const startPosition = arkts.getStartPosition(hasComponent); + const endPosition = arkts.getEndPosition(hasComponent); + return { + range: [startPosition, endPosition], + code: `@${PresetDecorators.COMPONENT_V2}`, + }; + } + }); + } else { + context.report({ + node: hasProviderDecorator, + message: rule.messages.providerRequiresComponentV2, + fix: (hasProviderDecorator) => { + const startPosition = arkts.getStartPosition(node); + const endPosition = startPosition; + return { + range: [startPosition, endPosition], + code: `@${PresetDecorators.COMPONENT_V2}\n`, + }; + } + }); + } +} +// Verify decorator conflicts on member variables +function validateMemberDecorators(member: arkts.ClassProperty, + hasComponentV2: arkts.AnnotationUsage | undefined, + hasComponent: arkts.AnnotationUsage | undefined, + node: arkts.AstNode, + context: UISyntaxRuleContext +): void { + const hasConsumeDecorator = findDecorator(member, PresetDecorators.CONSUMER); + const hasProviderDecorator = findDecorator(member, PresetDecorators.PROVIDER); + const otherDecorators = member.annotations?.find(annotation => + annotation.expr && + annotation.expr.dumpSrc() !== PresetDecorators.CONSUMER + ); + if (hasConsumeDecorator && otherDecorators) { + reportMultipleBuiltInDecorators(hasConsumeDecorator, otherDecorators, context); + } + if (hasProviderDecorator && !hasComponentV2) { + reportProviderRequiresComponentV2(hasProviderDecorator, hasComponent, node, context); + } +} +// Verify that @Provider is being used in the class +function validateProviderInClass(member: arkts.ClassProperty, context: UISyntaxRuleContext): void { + const hasProviderDecorator = findDecorator(member, PresetDecorators.PROVIDER); + if (hasProviderDecorator) { + context.report({ + node: hasProviderDecorator, + message: rule.messages.providerOnlyInStruct, + fix: (hasProviderDecorator) => { + const startPosition = arkts.getStartPosition(hasProviderDecorator); + const endPosition = arkts.getEndPosition(hasProviderDecorator); + return { + range: [startPosition, endPosition], + code: '', + }; + } + }); + } +} +// Verify that the current identifier is an illegally initialized @Consumer member variable +function reportValidateConsumer( + currentNode: arkts.Identifier, + callExpName: string, + componentv2WithConsumer: MultiMap, + context: UISyntaxRuleContext +): void { + if (componentv2WithConsumer.get(callExpName).includes(currentNode.dumpSrc())) { + context.report({ + node: currentNode.parent, + message: rule.messages.forbiddenInitialization, + data: { + value: currentNode.dumpSrc(), + structName: callExpName + }, + fix: () => { + const startPosition = arkts.getStartPosition(currentNode.parent); + const endPosition = arkts.getEndPosition(currentNode.parent); + return { + range: [startPosition, endPosition], + code: '', + }; + } + }); + } +} +// Verify that the @Consumer-decorated property is initialized +function validateConsumerInitialization(node: arkts.CallExpression, componentv2WithConsumer: MultiMap, + context: UISyntaxRuleContext): void { + const callExpName: string = node.expression.dumpSrc(); + if (componentv2WithConsumer.has(callExpName)) { + const queue: Array = [node]; + while (queue.length > 0) { + const currentNode: arkts.AstNode = queue.shift() as arkts.AstNode; + if (arkts.isIdentifier(currentNode)) { + reportValidateConsumer(currentNode, callExpName, componentv2WithConsumer, context); + } + const children = currentNode.getChildren(); + for (const child of children) { + queue.push(child); + } + } + } +} +function collectStructsWithConsumer(node: arkts.AstNode, componentv2WithConsumer: MultiMap): void { + // Used to document all V2 structs that use '@Consumer' + if (arkts.nodeType(node) === arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) { + // Breadth traversal is done through while and queues + const queue: Array = [node]; + while (queue.length > 0) { + const currentNode: arkts.AstNode = queue.shift() as arkts.AstNode; + // Filter and record the nodes of the tree + rememberStructName(currentNode, componentv2WithConsumer); + const children = currentNode.getChildren(); + for (const child of children) { + queue.push(child); + } + } + } +} +function validateStructDecoratorsAndMembers(node: arkts.AstNode, context: UISyntaxRuleContext): void { + if (arkts.isStructDeclaration(node)) { + const hasComponentV2 = getAnnotationUsage(node, PresetDecorators.COMPONENT_V2); + const hasComponent = getAnnotationUsage(node, PresetDecorators.COMPONENT_V1); + node.definition.body.forEach(member => { + if (arkts.isMethodDefinition(member)) { + validateConsumerOnMethod(member, context); + } + if (arkts.isClassProperty(member)) { + validateMemberDecorators(member, hasComponentV2, hasComponent, node, context); + } + }); + } +} +function validateProviderInClasses(node: arkts.AstNode, context: UISyntaxRuleContext): void { + if (arkts.isClassDeclaration(node)) { + node.definition?.body.forEach(member => { + if (arkts.isClassProperty(member)) { + validateProviderInClass(member, context); + } + }); + } +} +const rule: UISyntaxRule = { + name: 'consumer-provider-decorator-check', + messages: { + consumerOnlyOnMember: `'@Consumer' can only decorate member property.`, + multipleBuiltInDecorators: `The struct member variable can not be decorated by multiple built-in decorators.`, + providerRequiresComponentV2: `The '@Provider' decorator can only be used in a 'struct' decorated with '@ComponentV2'.`, + providerOnlyInStruct: `The '@Provider' decorator can only be used with 'struct'.`, + forbiddenInitialization: `Property '{{value}}' in the custom component '{{structName}}' cannot be initialized here (forbidden to specify).`, + }, + setup(context) { + // Used to record the names of the corresponding structs and member variables that are @consumer modified + let componentv2WithConsumer: MultiMap = new MultiMap(); + return { + parsed: (node): void => { + collectStructsWithConsumer(node, componentv2WithConsumer); + validateStructDecoratorsAndMembers(node, context); + validateProviderInClasses(node, context); + if (arkts.isCallExpression(node)) { + validateConsumerInitialization(node, componentv2WithConsumer, context); + } + }, + }; + }, +}; + +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/custom-dialog-missing-controller.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/custom-dialog-missing-controller.ts new file mode 100644 index 0000000000000000000000000000000000000000..f7721812ca2cff340b1b259cc62cb30e1aa5c3a7 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/custom-dialog-missing-controller.ts @@ -0,0 +1,68 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getClassPropertyType, PresetDecorators, getAnnotationUsage } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +const CUSTOM_DIALOG_CONTROLLER: string = 'CustomDialogController'; + +function missingController( + node: arkts.StructDeclaration, + context: UISyntaxRuleContext +): void { + // Check for the @CustomDialog decorator + const hasCustomDialogDecorator = getAnnotationUsage(node, PresetDecorators.CUSTOM_DIALOG); + const structName = node.definition.ident; + if (!structName) { + return; + } + // Check if there is an attribute of type CustomDialogController in the class + let hasControllerProperty = false; + node.definition.body.forEach((property) => { + if (arkts.isClassProperty(property)) { + const propertyType = getClassPropertyType(property); + if (propertyType === CUSTOM_DIALOG_CONTROLLER) { + hasControllerProperty = true; + } + } + }); + if (!hasControllerProperty && hasCustomDialogDecorator) { + context.report({ + node: structName, + message: rule.messages.missingController, + }); + } +} + +const rule: UISyntaxRule = { + name: 'custom-dialog-missing-controller', + messages: { + missingController: `The @CustomDialog decorated custom component must contain a property of the CustomDialogController type.`, + }, + setup(context) { + return { + parsed: (node): void => { + if (!arkts.isStructDeclaration(node)) { + return; + } + missingController(node, context); + }, + }; + }, +}; + +export default rule; + diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/decorators-in-ui-component-only.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/decorators-in-ui-component-only.ts new file mode 100644 index 0000000000000000000000000000000000000000..b01e0d40a1f5677f0ffb5a5e25cbe87dc665aa57 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/decorators-in-ui-component-only.ts @@ -0,0 +1,102 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; +import { PresetDecorators } from '../utils/index'; + +// Helper function to find the '@Component' decorator in a ClassDeclaration and report errors. +function findComponentDecorator(context: UISyntaxRuleContext, node: arkts.ClassDeclaration): void { + const componentDecorator = node.definition?.annotations?.find( + (annotation) => + annotation.expr && + arkts.isIdentifier(annotation.expr) && + annotation.expr.name === PresetDecorators.COMPONENT_V1 + ); + if (componentDecorator) { + reportDecoratorError(context, componentDecorator, rule.messages.invalidComponentDecorator); + } +} + +// Helper function to find the '@Prop' decorator in a MethodDefinition or ClassProperty. +const findPropDecorator = (node: arkts.MethodDefinition | arkts.ClassProperty): arkts.AnnotationUsage | undefined => { + const annotations = 'scriptFunction' in node ? node.scriptFunction.annotations : node.annotations; + return annotations?.find( + (annotation) => + annotation.expr && annotation.expr.dumpSrc() === PresetDecorators.PROP + ); +}; + +// Rule 2: Check for '@Prop' on MethodDefinition +function checkPropOnMethod(context: UISyntaxRuleContext, node: arkts.MethodDefinition): void { + const propDecorator = findPropDecorator(node); + if (propDecorator) { + reportDecoratorError(context, propDecorator, rule.messages.propOnMethod); + } +}; + +// Rule 3: Check for '@Prop' on ClassProperty within a ClassDeclaration +function checkPropOnClassProperty(context: UISyntaxRuleContext, node: arkts.ClassProperty, currentNode: arkts.AstNode) + : void { + const propDecorator = findPropDecorator(node); + while (arkts.nodeType(currentNode) !== arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) { + currentNode = currentNode.parent; + if (propDecorator && arkts.isClassDeclaration(currentNode)) { + reportDecoratorError(context, propDecorator, rule.messages.propOnMethod); + } + } +}; + +function reportDecoratorError(context: UISyntaxRuleContext, Decorator: arkts.AnnotationUsage, message: string +): void { + context.report({ + node: Decorator, + message: message, + fix: () => { + const startPosition = arkts.getStartPosition(Decorator); + const endPosition = arkts.getEndPosition(Decorator); + return { + range: [startPosition, endPosition], + code: '', + }; + }, + }); +} + +const rule: UISyntaxRule = { + name: 'no-prop-on-method', + messages: { + invalidComponentDecorator: `'@Component' can decorate only custom components.`, + propOnMethod: `'@Prop' can decorate only member variables of custom components.`, + }, + setup(context) { + return { + parsed: (node: arkts.AstNode): void => { + if (arkts.isClassDeclaration(node)) { + findComponentDecorator(context, node); + } + if (arkts.isMethodDefinition(node)) { + checkPropOnMethod(context, node); + } + let currentNode = node; + if (arkts.isClassProperty(node)) { + checkPropOnClassProperty(context, node, currentNode); + } + }, + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/entry-localstorage-check.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/entry-localstorage-check.ts new file mode 100644 index 0000000000000000000000000000000000000000..aa82f31044b738f69246d70bc95354f54a737801 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/entry-localstorage-check.ts @@ -0,0 +1,61 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getAnnotationUsage, getClassPropertyAnnotationNames, PresetDecorators } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +function checkLocalStorageLink(node: arkts.StructDeclaration, context: UISyntaxRuleContext): void { + // Check if @Entry decorator exists with parameter + const entryDecorator = getAnnotationUsage(node, PresetDecorators.ENTRY); + const isStorageUsed = entryDecorator && node.definition?.annotations[0].properties[0]; + // Check if @LocalStorageLink exists + let localStorageLinkUsed = false; + node.definition.body.forEach(body => { + if (!arkts.isClassProperty(body)) { + return; + } + const propertyDecorators = getClassPropertyAnnotationNames(body); + localStorageLinkUsed = propertyDecorators.some( + decorator => decorator === PresetDecorators.LOCAL_STORAGE_LINK); + }); + + // If @LocalStorageLink is used but @Entry(storage) is missing, report error + if (entryDecorator && localStorageLinkUsed && !isStorageUsed) { + context.report({ + node: entryDecorator, + message: rule.messages.invalidUsage + }); + } +} + +const rule: UISyntaxRule = { + name: 'entry-localstorage-check', + messages: { + invalidUsage: `@LocalStorageLink requires @Entry(storage) on the struct.`, + }, + setup(context) { + return { + parsed: (node): void => { + if (!arkts.isStructDeclaration(node)) { + return; + } + checkLocalStorageLink(node, context); + }, + }; + }, +}; + +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/entry-struct-no-export.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/entry-struct-no-export.ts new file mode 100644 index 0000000000000000000000000000000000000000..7017ab54f4e3b08dfb6f28480dd1e747746aa1af --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/entry-struct-no-export.ts @@ -0,0 +1,53 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getAnnotationUsage, PresetDecorators } from '../utils'; +import { UISyntaxRule } from './ui-syntax-rule'; + +const rule: UISyntaxRule = { + name: 'entry-struct-no-export', + messages: { + noExportWithEntry: `It's not a recommended way to export struct with @Entry decorator, which may cause ACE Engine error in component preview mode.`, + }, + setup(context) { + return { + parsed: (node): void => { + // Check if the current node is a schema declaration + if (!arkts.isStructDeclaration(node)) { + return; + } + // Get the usage of the @Entry decorator + const entryDecoratorUsage = getAnnotationUsage( + node, + PresetDecorators.ENTRY, + ); + + //Determines whether the struct is exported + const isExported = node.dumpSrc().includes('export struct'); + + // If a @Entry decorator is present and the struct is exported + if (entryDecoratorUsage && isExported) { + context.report({ + node: entryDecoratorUsage, + message: this.messages.noExportWithEntry, + }); + } + }, + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/index.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..13b008b627bb821cbb05603a977ad1238898fc87 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/index.ts @@ -0,0 +1,99 @@ +/* + * 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 { UISyntaxRule } from './ui-syntax-rule'; +import BuildRootNode from './build-root-node'; +import CheckConstructPrivateParameter from './check-construct-private-parameter'; +import CheckDecoratedPropertyType from './check-decorated-property-type'; +import ComponentComponentV2MixUseCheck from './component-componentV2-mix-use-check'; +import ComponentV2MixCheck from './componentV2-mix-check'; +import ConsumerProviderDecoratorCheck from './consumer-provider-decorator-check'; +import ComponentV2StateUsageValidation from './componentV2-state-usage-validation'; +import ConstructParameterLiteral from './construct-parameter-literal'; +import CustomDialogMissingController from './custom-dialog-missing-controller'; +import DecoratorsInUIComponentOnly from './decorators-in-ui-component-only'; +import EntryLoacalStorageCheck from './entry-localstorage-check'; +import EntryStructNoExport from './entry-struct-no-export'; +import LocalBuilderCheck from './local-builder-check'; +import MonitorDecoratorCheck from './monitor-decorator-check'; +import NestedRelationship from './nested-relationship'; +import NoChildInButton from './no-child-in-button'; +import NoDuplicateDecorators from './no-duplicate-decorators'; +import NoDuplicateEntry from './no-duplicate-entry'; +import NoDuplicatePreview from './no-duplicate-preview'; +import NoDuplicateStateManager from './no-duplicate-state-manager'; +import NoPropLinkObjectlinkInEntry from './no-prop-link-objectlink-in-entry'; +import NoSameAsBuiltInAttribute from './no-same-as-built-in-attribute'; +import ReuseAttributeCheck from './reuse-attribute-check'; +import StructMissingDecorator from './struct-missing-decorator'; +import StructPropertyDecorator from './struct-property-decorator'; +import StructVariableInitialization from './struct-variable-initialization'; +import TrackDecoratorCheck from './track-decorator-check'; +import TypeDecoratorCheck from './type-decorator-check'; +import ValidateBuildInStruct from './validate-build-in-struct'; +import VariableInitializationViaComponentCons from './variable-initialization-via-component-cons'; +import WatchDecoratorFunction from './watch-decorator-function'; +import WatchDecoratorRegular from './watch-decorator-regular'; +import WrapBuilderCheck from './wrap-builder-check'; +import ObservedHeritageCompatibleCheck from './observed-heritage-compatible-check'; +import ObservedObservedV2 from './observed-observedV2-check'; +import ObservedV2TraceUsageValidation from './observedV2-trace-usage-validation'; +import OnceDecoratorCheck from './once-decorator-check'; +import OneDecoratorOnFunctionMethod from './one-decorator-on-function-method'; +import OldNewDecoratorMixUseCheck from './old-new-decorator-mix-use-check'; + +const rules: UISyntaxRule[] = [ + BuildRootNode, + CheckConstructPrivateParameter, + CheckDecoratedPropertyType, + ComponentComponentV2MixUseCheck, + ComponentV2MixCheck, + ConsumerProviderDecoratorCheck, + ComponentV2StateUsageValidation, + ConstructParameterLiteral, + CustomDialogMissingController, + DecoratorsInUIComponentOnly, + EntryLoacalStorageCheck, + EntryStructNoExport, + LocalBuilderCheck, + MonitorDecoratorCheck, + NestedRelationship, + NoChildInButton, + NoDuplicateDecorators, + NoDuplicateEntry, + NoDuplicatePreview, + NoDuplicateStateManager, + NoPropLinkObjectlinkInEntry, + NoSameAsBuiltInAttribute, + ReuseAttributeCheck, + StructMissingDecorator, + StructPropertyDecorator, + StructVariableInitialization, + TrackDecoratorCheck, + TypeDecoratorCheck, + ValidateBuildInStruct, + VariableInitializationViaComponentCons, + WatchDecoratorFunction, + WatchDecoratorRegular, + WrapBuilderCheck, + ObservedHeritageCompatibleCheck, + ObservedObservedV2, + ObservedV2TraceUsageValidation, + OnceDecoratorCheck, + OneDecoratorOnFunctionMethod, + OldNewDecoratorMixUseCheck, +]; + +export default rules; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/local-builder-check.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/local-builder-check.ts new file mode 100644 index 0000000000000000000000000000000000000000..cbfeef0c308b74d99a45959d0b4c2e4b4263ebb4 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/local-builder-check.ts @@ -0,0 +1,63 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { PresetDecorators } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +function checkLocalBuilder(node: arkts.ClassDeclaration, context: UISyntaxRuleContext): void { + node.definition?.body.forEach(body => { + if (!arkts.isMethodDefinition(body)) { + return; + } + const localBuilder = body.scriptFunction?.annotations?.find( + annotation => annotation.expr && + annotation.expr.dumpSrc() === PresetDecorators.LOCAL_BUILDER); + if (!localBuilder) { + return; + } + context.report({ + node: localBuilder, + message: rule.messages.invalidUsage, + fix: (localBuilder) => { + const startPosition = arkts.getStartPosition(localBuilder); + const endPosition = arkts.getEndPosition(localBuilder); + return { + range: [startPosition, endPosition], + code: '', + }; + }, + }); + }); +} + +const rule: UISyntaxRule = { + name: 'local-builder-check', + messages: { + invalidUsage: `The '@LocalBuilder' decorator can only be used in 'struct'.`, + }, + setup(context) { + return { + parsed: (node): void => { + if (!arkts.isClassDeclaration(node)) { + return; + } + checkLocalBuilder(node, context); + }, + }; + }, +}; + +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/monitor-decorator-check.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/monitor-decorator-check.ts new file mode 100644 index 0000000000000000000000000000000000000000..e0696de480d387ca451ee31ccd429e29d9547250 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/monitor-decorator-check.ts @@ -0,0 +1,174 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { PresetDecorators } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +// Function declarations moved to the top with explicit return types +function getLocalMonitorUsed(body: arkts.MethodDefinition): arkts.AnnotationUsage | undefined { + const localMonitorUsed = body.scriptFunction.annotations?.find( + annotation => annotation.expr && + annotation.expr.dumpSrc() === PresetDecorators.MONITOR + ); + return localMonitorUsed; +} + +function checkConflictingDecorators(context: UISyntaxRuleContext, body: arkts.MethodDefinition, + localMonitorUsed: arkts.AnnotationUsage): boolean { + const conflictingDecorators = body.scriptFunction.annotations?.filter( + annotation => annotation.expr && + annotation.expr.dumpSrc() !== PresetDecorators.MONITOR + ); + if (conflictingDecorators?.length > 0) { + reportConflictingDecorators(context, localMonitorUsed, conflictingDecorators); + return true; + } + return false; +} + +function reportConflictingDecorators(context: UISyntaxRuleContext, localMonitorUsed: arkts.AstNode, + conflictingDecorators: arkts.AnnotationUsage[]): void { + context.report({ + node: localMonitorUsed, + message: rule.messages.invalidUsage1, + fix: () => { + const startPositions = conflictingDecorators.map(annotation => + arkts.getStartPosition(annotation)); + const endPositions = conflictingDecorators.map(annotation => arkts.getEndPosition(annotation)); + const startPosition = startPositions[0]; + const endPosition = endPositions[endPositions.length - 1]; + return { + range: [startPosition, endPosition], + code: '' + }; + } + }); +} + +function checkIfClassIsObservedV2(node: arkts.ClassDeclaration): boolean { + return node.definition?.annotations?.some( + observedV2 => observedV2.expr?.dumpSrc() === PresetDecorators.OBSERVED_V2 + ) ?? false; +} + +function checkIfStructIsComponentV2(node: arkts.StructDeclaration): boolean { + return node.definition?.annotations?.some( + componentV2 => componentV2.expr?.dumpSrc() === PresetDecorators.COMPONENT_V2 + ) ?? false; +} + +function reportInvalidUsage(context: UISyntaxRuleContext, node: arkts.AstNode, message: string, fixCode: string) + : void { + const startPosition = arkts.getStartPosition(node); + context.report({ + node, + message, + fix: () => ({ + range: [startPosition, startPosition], + code: fixCode, + }), + }); +} + +function checkMultipleDecorators( + node: arkts.ClassDeclaration | arkts.StructDeclaration, + context: UISyntaxRuleContext +): boolean { + // Traverse body of the class to check for @Monitor usage + let monitorUsed: boolean = false; + node.definition?.body.forEach(body => { + if (arkts.isMethodDefinition(body)) { + const localMonitorUsed = getLocalMonitorUsed(body); + if (localMonitorUsed) { + monitorUsed = true; + checkConflictingDecorators(context, body, localMonitorUsed); + return; // Stop further checks for this method + } + } + }); + return monitorUsed; +} + +function checkDecorateMethod( + node: arkts.ClassDeclaration | arkts.StructDeclaration, + context: UISyntaxRuleContext +): void { + // Check if @Monitor is used on a property (which is not allowed) + node.definition?.body.forEach(body => { + if (!arkts.isClassProperty(body)) { + return; + } + const monitorDecorator = body.annotations?.find( + annotation => annotation.expr?.dumpSrc() === PresetDecorators.MONITOR); + if (monitorDecorator === undefined) { + return; + } + context.report({ + node: monitorDecorator, + message: rule.messages.invalidUsage4, + fix: () => { + const startPosition = arkts.getStartPosition(monitorDecorator); + const endPosition = arkts.getEndPosition(monitorDecorator); + return { + range: [startPosition, endPosition], + code: '', + }; + }, + }); + }); +} + +// The rule object with its setup method +const rule: UISyntaxRule = { + name: 'monitor-decorator-check', + messages: { + invalidUsage1: + `The member property or method can not be decorated by multiple built-in decorators.`, + invalidUsage2: + `The '@Monitor' can decorate only member method within a 'class' decorated with @ObservedV2.`, + invalidUsage3: + `The '@Monitor' decorator can only be used in a 'struct' decorated with '@ComponentV2'.`, + invalidUsage4: + `@Monitor can only decorate method`, + }, + setup(context) { + return { + parsed: (node: arkts.AstNode): void => { + if (!arkts.isClassDeclaration(node) && !arkts.isStructDeclaration(node)) { + return; + } + let monitorUsed = false; + + const isObservedV2 = arkts.isClassDeclaration(node) && checkIfClassIsObservedV2(node); + const isComponentV2 = arkts.isStructDeclaration(node) && checkIfStructIsComponentV2(node); + + monitorUsed = checkMultipleDecorators(node, context); + + // Check for errors related to @Monitor usage + if (monitorUsed && !isObservedV2 && arkts.isClassDeclaration(node)) { + reportInvalidUsage(context, node, rule.messages.invalidUsage2, `@${PresetDecorators.OBSERVED_V2}\n`); + } + if (monitorUsed && !isComponentV2 && arkts.isStructDeclaration(node)) { + reportInvalidUsage(context, node, rule.messages.invalidUsage3, `@${PresetDecorators.COMPONENT_V2}\n`); + } + + checkDecorateMethod(node, context); + }, + }; + }, +}; + +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/nested-relationship.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/nested-relationship.ts new file mode 100644 index 0000000000000000000000000000000000000000..fd18100e9be82ade14f15b2b746c4cf718f3237b --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/nested-relationship.ts @@ -0,0 +1,191 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getIdentifierName } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +function checkInvalidChildInText(node: arkts.AstNode, context: UISyntaxRuleContext, textChild: string[]): void { + // Check if the current node is an identifier, and name is 'Text' + if (!arkts.isIdentifier(node)) { + return; + } + if (getIdentifierName(node) !== 'Text') { + return; + } + if (!node.parent) { + return; + } + const parentNode = node.parent; + if (!arkts.isCallExpression(parentNode)) { + return; + } + // If the BlockStatement contains a child component that should not exist under the text, an error will be reported + parentNode.getChildren().forEach(member => { + if (!arkts.isBlockStatement(member)) { + return; + } + member.getChildren().forEach(sibling => { + if (!arkts.isExpressionStatement(sibling) || !arkts.isCallExpression(sibling.expression)) { + return; + } + const childComponentName = sibling.expression.expression.dumpSrc(); + if (!textChild.includes(childComponentName)) { + context.report({ + node: node, + message: rule.messages.invalidChildInText + }); + return; + } + }); + }); +} +function checkOneChildInButton(node: arkts.AstNode, context: UISyntaxRuleContext): void { + // Check if the current node is an identifier, and name is 'Button' + if (!arkts.isIdentifier(node)) { + return; + } + if (getIdentifierName(node) !== 'Button') { + return; + } + if (!node.parent) { + return; + } + const parentNode = node.parent; + if (!arkts.isCallExpression(parentNode)) { + return; + } + // If there is more than one subcomponent in the BlockStatement, an error is reported + parentNode.getChildren().forEach(member => { + if (!arkts.isBlockStatement(member)) { + return; + } + if (member.statements.length > 1) { + context.report({ + node: node, + message: rule.messages.oneChildInButton + }); + } + }); +} + +function checkListItem(node: arkts.AstNode, context: UISyntaxRuleContext): void { + // Check if the current node is an identifier, and name is 'ListItem' + if (!arkts.isIdentifier(node)) { + return; + } + if (getIdentifierName(node) !== 'ListItem') { + return; + } + if (!node.parent || !node.parent.parent) { + return; + } + let curNode: arkts.AstNode = node.parent.parent; + do { + while (!arkts.isCallExpression(curNode)) { + if (!curNode.parent) { + return; + } + curNode = curNode.parent; + } + const parentName: string = curNode.expression.dumpSrc(); + if (parentName === 'List') { // If the parent component's name is 'List', exit directly + break; + } else if (parentName !== 'ForEach') { // If the parent component's name is not 'List' or 'ForEach', throw an error + context.report({ + node: node, + message: rule.messages.listItemCannotInOther, + data: { parentName: parentName } + }); + context.report({ + node: node, + message: rule.messages.listItemMustInList + }); + break; + } + // In the remaining case, the parent component is 'ForEach', continue traversing upwards for further checks + if (!curNode.parent) { + return; + } + curNode = curNode.parent; + } while (true); +} + +function checkSpan(node: arkts.AstNode, context: UISyntaxRuleContext): void { + // Check if the current node is an identifier, and name is 'Span' + if (!arkts.isIdentifier(node)) { + return; + } + if (getIdentifierName(node) !== 'Span') { + return; + } + let parentNode = node.parent; + if (!arkts.isCallExpression(parentNode)) { + return; + } + // If there are subcomponents in the BlockStatement, an error is reported + parentNode.getChildren().forEach(sibling => { + if (!arkts.isBlockStatement(sibling)) { + return; + } + if (sibling.statements.length > 0) { + context.report({ + node: node, + message: rule.messages.noChildInSpan + }); + } + }); + if (!node.parent || !node.parent.parent) { + return; + } + parentNode = parentNode.parent; + while (!arkts.isCallExpression(parentNode)) { + parentNode = parentNode.parent; + } + const parentName: string = parentNode.expression.dumpSrc(); + // If the name of the parent component is not 'Text', an error is reported + if (parentName !== 'Text' && parentName !== 'RichEditor' && parentName !== 'ContainerSpan') { + context.report({ + node: node, + message: rule.messages.spanMustInText + }); + } +} +// The 'Text' component can have only the Span, ImageSpan, ContainerSpan and SymbolSpan child component. + +const rule: UISyntaxRule = { + name: 'nested-relationship', + messages: { + invalidChildInText: `The 'Text' component can have only the Span, ImageSpan, ContainerSpan and SymbolSpan child component.`, + oneChildInButton: `The 'Button' component can have only one child component.`, + listItemMustInList: `The 'ListItem' component can only be nested in the List and ListItemGroup parent component.`, + listItemCannotInOther: `The 'ListItem' component cannot be a child component of the '{{parentName}}' component.`, + noChildInSpan: `No child component is allowed in the 'Span' component. `, + spanMustInText: `The 'Span' component can only be nested in the Text, RichEditor and ContainerSpan parent component. `, + }, + setup(context) { + const textChild: string[] = ['Span', 'ImageSpan', 'ContainerSpan', 'SymbolSpan']; + return { + parsed: (node): void => { + checkInvalidChildInText(node, context, textChild); + checkOneChildInButton(node, context); + checkListItem(node, context); + checkSpan(node, context); + }, + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-child-in-button.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-child-in-button.ts new file mode 100644 index 0000000000000000000000000000000000000000..6cf999a272d61eb0c3610d9d70ff3b55a6551a46 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-child-in-button.ts @@ -0,0 +1,89 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; +import { getIdentifierName } from '../utils'; + +function isInsideStructAndBuild(node: arkts.AstNode): boolean { + let parentNode = node.parent; + let isInStruct = false; + let isInBuild = false; + while (arkts.nodeType(parentNode) !== arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) { + if (arkts.isStructDeclaration(parentNode)) { + isInStruct = true; + } + if (arkts.isScriptFunction(parentNode) && parentNode.id?.name === 'build') { + isInBuild = true; + } + parentNode = parentNode.parent; + } + return isInStruct && isInBuild; +} + +function reportNoChildInButtonError(parentNode: arkts.AstNode, context: UISyntaxRuleContext): void { + const siblings = parentNode.getChildren(); + if (!Array.isArray(siblings) || siblings.length < 3) { + return; + } + if (arkts.isStringLiteral(siblings[1]) && arkts.isBlockStatement(siblings[2])) { + context.report({ + node: parentNode, + message: rule.messages.noChildInButton, + fix: (parentNode) => { + const startPosition = arkts.getStartPosition(siblings[2]); + const endPosition = arkts.getEndPosition(siblings[2]); + return { + range: [startPosition, endPosition], + code: '', + }; + }, + }); + } +} + +const rule: UISyntaxRule = { + name: 'no-child-in-button', + messages: { + noChildInButton: `The Button component with a label parameter can not have any child.`, + }, + setup(context: UISyntaxRuleContext) { + return { + parsed: (node): void => { + // Check if the current node is an identifier + if (!arkts.isIdentifier(node)) { + return; + } + const componentName = getIdentifierName(node); + // If the current node is 'Button' + if (componentName !== 'Button') { + return; + } + if (!isInsideStructAndBuild(node)) { + return; + } + // Obtain the information of the parent node of the current node + let parentNode = node.parent; + if (!arkts.isCallExpression(parentNode)) { + return; + }; + // Gets and traverses all the children of the parent node + reportNoChildInButtonError(parentNode, context); + } + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-duplicate-decorators.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-duplicate-decorators.ts new file mode 100644 index 0000000000000000000000000000000000000000..ff42b2180727514624a4dfc03e5d2b05558c27b5 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-duplicate-decorators.ts @@ -0,0 +1,104 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getAnnotationName, PresetDecorators } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +// Decorators that cannot be repeated +const validDecorators = [ + PresetDecorators.ENTRY, + PresetDecorators.COMPONENT_V1, + PresetDecorators.COMPONENT_V2, + PresetDecorators.REUSABLE_V1, + PresetDecorators.PREVIEW, + PresetDecorators.REUSABLE_V2, + PresetDecorators.CUSTOM_DIALOG, +]; + +function checkForDuplicateDecorators(context: UISyntaxRuleContext, node: arkts.StructDeclaration): void { + // Initialize a map to record decorators and their occurrences + const decoratorCounts: Map = new Map(); + if (!node.definition || !node.definition.annotations) { + return; + } + // Record all decorators and their counts + node.definition.annotations.forEach((annotation) => { + const decoratorName = getAnnotationName(annotation); + if (!validDecorators.includes(decoratorName)) { + return; + } + + if (decoratorCounts.has(decoratorName)) { + const decoratorInfo = decoratorCounts.get(decoratorName)!; + decoratorInfo.count += 1; + decoratorInfo.annotations.push(annotation); + } else { + decoratorCounts.set(decoratorName, { count: 1, annotations: [annotation] }); + } + }); + + // Process decorators with more than one occurrence + decoratorCounts.forEach(({ count, annotations }, decoratorName) => { + if (count <= 1) { + return; + } + // Report errors for all occurrences except the last one + for (let i = 0; i < annotations.length - 1; i++) { + const prevAnnotation = annotations[i]; + reportDuplicateDecorator(context, prevAnnotation); + } + // For the last occurrence, report an error but do not provide a fix + const lastAnnotation = annotations[annotations.length - 1]; + context.report({ + node: lastAnnotation, + message: rule.messages.duplicateDecorator, + }); + }); +} + +function reportDuplicateDecorator(context: UISyntaxRuleContext, annotation: arkts.AnnotationUsage): void { + context.report({ + node: annotation, + message: rule.messages.duplicateDecorator, + fix: () => { + const startPosition = arkts.getStartPosition(annotation); + const endPosition = arkts.getEndPosition(annotation); + return { + range: [startPosition, endPosition], + code: '', + }; + }, + }); +} + +const rule: UISyntaxRule = { + name: 'no-duplicate-decorators', + messages: { + duplicateDecorator: `Duplicate decorators for struct are not allowed.`, + }, + setup(context) { + return { + parsed: (node): void => { + if (!arkts.isStructDeclaration(node)) { + return; + } + checkForDuplicateDecorators(context, node); + }, + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-duplicate-entry.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-duplicate-entry.ts new file mode 100644 index 0000000000000000000000000000000000000000..60c810180a2b7982a950901930e78174479b28dd --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-duplicate-entry.ts @@ -0,0 +1,72 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getAnnotationUsage, PresetDecorators } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +const MAX_ENTRY_DECORATOR_COUNT = 1; +function checkDuplicateEntry(node: arkts.AstNode, context: UISyntaxRuleContext): void { + if (arkts.nodeType(node) !== arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) { + return; + } + let entryDecoratorUsages: arkts.AnnotationUsage[] = []; + node.getChildren().forEach((child) => { + if (!arkts.isStructDeclaration(child)) { + return; + } + const entryDecoratorUsage = getAnnotationUsage( + child, + PresetDecorators.ENTRY, + ); + if (entryDecoratorUsage) { + entryDecoratorUsages.push(entryDecoratorUsage); + } + }); + // If more than one entry decorator is recorded, an error is reported + if (entryDecoratorUsages.length <= MAX_ENTRY_DECORATOR_COUNT) { + return; + } + entryDecoratorUsages.forEach((entryDocoratorUsage) => { + context.report({ + node: entryDocoratorUsage, + message: rule.messages.duplicateEntry, + fix: (entryDocoratorUsage) => { + const startPosition = arkts.getStartPosition(entryDocoratorUsage); + const endPosition = arkts.getEndPosition(entryDocoratorUsage); + return { + range: [startPosition, endPosition], + code: '', + }; + } + }); + }); +} + +const rule: UISyntaxRule = { + name: 'no-duplicate-entry', + messages: { + duplicateEntry: `An ArkTS file can contain only one '@Entry' decorator.`, + }, + setup(context) { + return { + parsed: (node): void => { + checkDuplicateEntry(node, context); + }, + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-duplicate-preview.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-duplicate-preview.ts new file mode 100644 index 0000000000000000000000000000000000000000..fe57d8f11fb33bf5626493a63b1987660b3ed2f0 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-duplicate-preview.ts @@ -0,0 +1,73 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getAnnotationUsage, PresetDecorators } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +const MAX_PREVIEW_DECORATOR_COUNT = 10; + +function checkDuplicatePreview(node: arkts.AstNode, context: UISyntaxRuleContext): void { + if (arkts.nodeType(node) !== arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) { + return; + } + let previewDecoratorUsages: arkts.AnnotationUsage[] = []; + node.getChildren().forEach((child) => { + if (!arkts.isStructDeclaration(child)) { + return; + } + const previewDecoratorUsage = getAnnotationUsage( + child, + PresetDecorators.PREVIEW, + ); + if (previewDecoratorUsage) { + previewDecoratorUsages.push(previewDecoratorUsage); + } + }); + // If the number of preview decorators is greater than 10, an error is reported + if (previewDecoratorUsages.length <= MAX_PREVIEW_DECORATOR_COUNT) { + return; + } + previewDecoratorUsages.forEach((previewDecoratorUsage) => { + context.report({ + node: previewDecoratorUsage, + message: rule.messages.duplicateEntry, + fix: (previewDecoratorUsage) => { + const startPosition = arkts.getStartPosition(previewDecoratorUsage); + const endPosition = arkts.getEndPosition(previewDecoratorUsage); + return { + range: [startPosition, endPosition], + code: '', + }; + } + }); + }); +} + +const rule: UISyntaxRule = { + name: 'no-duplicate-preview', + messages: { + duplicateEntry: `An ArkTS file con contain at most 10 '@Preview' decorators.`, + }, + setup(context) { + return { + parsed: (node): void => { + checkDuplicatePreview(node, context); + }, + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-duplicate-state-manager.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-duplicate-state-manager.ts new file mode 100644 index 0000000000000000000000000000000000000000..df1468fd56b754c15210ad0f0e65a9049d625fe5 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-duplicate-state-manager.ts @@ -0,0 +1,74 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getClassPropertyAnnotationNames } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +export const stateManagementDecorator = { + STATE: 'State', + PROP: 'Prop', + LINK: 'Link', + PROVIDE: 'Provide', + CONSUME: 'Consume' +}; + +const CLASS_PROPERTY_ANNOTATION_ONE: number = 1; +function duplicateState( + node: arkts.StructDeclaration, + context: UISyntaxRuleContext +): void { + node.definition.body.forEach(body => { + if (arkts.isClassProperty(body)) { + // Get the list of decorators + const propertyDecorators = getClassPropertyAnnotationNames(body); + // Filter the decorators to get those related to state management + const stateDecorators = propertyDecorators.filter(decorator => + Object.values(stateManagementDecorator).includes(decorator) + ); + const propertyNameNode = body.key; + const attributeName = body.key?.dumpSrc(); + if (!propertyNameNode || !attributeName) { + return; + } + if (stateDecorators.length > CLASS_PROPERTY_ANNOTATION_ONE) { + context.report({ + node: propertyNameNode, + message: rule.messages.duplicateState, + data: { attributeName }, + }); + } + } + }); +} + +const rule: UISyntaxRule = { + name: 'no-duplicate-state-manager', + messages: { + duplicateState: `This attribute '{{attributeName}}' cannot have mutilate state management decorators. `, + }, + setup(context) { + return { + parsed: (node): void => { + if (!arkts.isStructDeclaration(node)) { + return; + } + duplicateState(node, context); + }, + }; + }, +}; + +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-prop-link-objectlink-in-entry.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-prop-link-objectlink-in-entry.ts new file mode 100644 index 0000000000000000000000000000000000000000..8815feff46576bfaec7dc8c0713ea58a62144993 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-prop-link-objectlink-in-entry.ts @@ -0,0 +1,75 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getAnnotationUsage, PresetDecorators } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +function checkNoPropLinkOrObjectLinkInEntry(context: UISyntaxRuleContext, node: arkts.StructDeclaration): void { + // Check if the struct has the @Entry decorator + const isEntryComponent = !!getAnnotationUsage(node, PresetDecorators.ENTRY); + if (!isEntryComponent) { + return; + } + node.definition.body.forEach(body => { + if (!arkts.isClassProperty(body)) { + return; + } + const invalidDecorators = [PresetDecorators.PROP, PresetDecorators.LINK, PresetDecorators.OBJECT_LINK]; + // Check if any invalid decorators are applied to the class property + body.annotations?.forEach(annotation => { + reportInvalidDecorator(context, annotation, invalidDecorators); + }); + }); +} + +function reportInvalidDecorator(context: UISyntaxRuleContext, annotation: arkts.AnnotationUsage, + invalidDecorators: string[],): void { + if (annotation.expr && invalidDecorators.includes(annotation.expr.dumpSrc())) { + const decorator = annotation.expr.dumpSrc(); + context.report({ + node: annotation, + message: rule.messages.invalidUsage, + data: { decorator }, + fix: (annotation) => { + const startPosition = arkts.getStartPosition(annotation); + const endPosition = arkts.getEndPosition(annotation); + return { + range: [startPosition, endPosition], + code: '', + }; + }, + }); + } +} + +const rule: UISyntaxRule = { + name: 'no-prop-link-objectlink-in-entry', + messages: { + invalidUsage: `@{{decorator}} decorator cannot be used for '@Entry' decorated components.`, + }, + setup(context) { + return { + parsed: (node): void => { + if (!arkts.isStructDeclaration(node)) { + return; + } + checkNoPropLinkOrObjectLinkInEntry(context, node); + }, + }; + }, +}; + +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-same-as-built-in-attribute.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-same-as-built-in-attribute.ts new file mode 100644 index 0000000000000000000000000000000000000000..e61af0b5682a58405b0de144d1331314fd665d4d --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/no-same-as-built-in-attribute.ts @@ -0,0 +1,47 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { UISyntaxRule } from './ui-syntax-rule'; + +const rule: UISyntaxRule = { + name: 'no-same-as-built-in-attribute', + messages: { + duplicateName: `The struct name '{{structName}}' should not have the same name as a built-in attribute.`, + }, + setup(context) { + const builtInAttributes = ['fontColor', 'width', 'height', 'size', 'border', 'backgroundColor', 'margin', + 'padding']; + return { + parsed: (node): void => { + if (!arkts.isStructDeclaration(node)) { + return; + } + const structName = node.definition.ident?.name ?? ' '; + const structIdent = node.definition.ident; + // If the struct name matches any built-in attribute, report an error + if (builtInAttributes.includes(structName) && structIdent) { + context.report({ + node: structIdent, + message: rule.messages.duplicateName, + data: { structName } + }); + } + }, + }; + }, +}; + +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/observed-heritage-compatible-check.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/observed-heritage-compatible-check.ts new file mode 100644 index 0000000000000000000000000000000000000000..95b605f2cfdae926f518c06a859a21cd57c1f4c5 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/observed-heritage-compatible-check.ts @@ -0,0 +1,106 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; +import { PresetDecorators } from '../utils/index'; + +function getObservedDecorator(node: arkts.AstNode, observedClasses: string[], observedV2Classes: string[]): void { + for (const child of node.getChildren()) { + // Check if it is of the ClassDeclaration type + if (arkts.isClassDeclaration(child)) { + // Get a list of annotations + const annotations = child.definition?.annotations ?? []; + // Check for @Observed decorators + const hasObservedDecorator = annotations.find((annotation: any) => + annotation.expr.name === PresetDecorators.OBSERVED_V1); + // Check if there is a @ObservedV2 decorator + const hasObservedV2Decorator = annotations.find((annotation: any) => + annotation.expr.name === PresetDecorators.OBSERVED_V2); + // If there is a @Observed decorator, record the class name + if (hasObservedDecorator) { + const className = child.definition?.ident?.name ?? ''; + observedClasses.push(className); + } + // If there is a @ObservedV2 decorator, record the class name + if (hasObservedV2Decorator) { + const className = child.definition?.ident?.name ?? ''; + observedV2Classes.push(className); + } + } + } +} + +function checkInheritanceCompatibility(context: UISyntaxRuleContext, node: arkts.ClassDeclaration, + observedClasses: string[], observedV2Classes: string[]): void { + const observedV1Decorator = node.definition?.annotations?.find(annotations => + annotations.expr && + arkts.isIdentifier(annotations.expr) && + annotations.expr.name === PresetDecorators.OBSERVED_V1 + ); + const observedV2Decorator = node.definition?.annotations?.find(annotations => + annotations.expr && + arkts.isIdentifier(annotations.expr) && + annotations.expr.name === PresetDecorators.OBSERVED_V2 + ); + + //Get the name of the superClass + const superClassName = node.definition?.super?.dumpSrc(); + if (!superClassName) { + return; + } + // Verify that the inheritance relationship is compatible + if (observedV1Decorator && observedV2Classes.includes(superClassName)) { + context.report({ + node: observedV1Decorator, + message: rule.messages.incompatibleHeritageObservedToObservedV2, + }); + } + if (observedV2Decorator && observedClasses.includes(superClassName)) { + context.report({ + node: observedV2Decorator, + message: rule.messages.incompatibleHeritageObservedV2ToObserved, + }); + } +} + +const rule: UISyntaxRule = { + name: 'observed-heritage-compatible-check', + messages: { + incompatibleHeritageObservedToObservedV2: `The current class is decorated by '@Observed', it cannot inherit a class decorated by '@ObservedV2'.`, + incompatibleHeritageObservedV2ToObserved: `The current class is decorated by '@ObservedV2', it cannot inherit a class decorated by '@Observed'.`, + }, + setup(context) { + // Record the class name decorated with @Observed and @ObservedV2 + const observedClasses: string[] = []; + const observedV2Classes: string[] = []; + return { + parsed: (node): void => { + // Check if it's of type "Program". + if (arkts.nodeType(node) === arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) { + getObservedDecorator(node, observedClasses, observedV2Classes); + } + + // Check if the current node is a class declaration + if (!arkts.isClassDeclaration(node)) { + return; + } + checkInheritanceCompatibility(context, node, observedClasses, observedV2Classes); + }, + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/observed-observedV2-check.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/observed-observedV2-check.ts new file mode 100644 index 0000000000000000000000000000000000000000..e02304b3ceb27c0a1b36ee159889a7f672c27144 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/observed-observedV2-check.ts @@ -0,0 +1,47 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { PresetDecorators } from '../utils'; +import { UISyntaxRule } from './ui-syntax-rule'; + +const rule: UISyntaxRule = { + name: 'observed-observedV2-check', + messages: { + conflictingDecorators: `A class cannot be decorated by both '@Observed' and '@ObservedV2' at the same time.`, + }, + setup(context) { + return { + parsed: (node): void => { + if (!arkts.isClassDeclaration(node)) { + return; + } + const hasObservedDecorator = node.definition?.annotations?.find(annotations => annotations.expr && + annotations.expr.dumpSrc() === PresetDecorators.OBSERVED_V1); + const hasObservedV2Decorator = node.definition?.annotations?.find(annotations => annotations.expr && + annotations.expr.dumpSrc() === PresetDecorators.OBSERVED_V2); + // If the current class is decorated by @Observed and @ObservedV2, an error is reported + if (hasObservedDecorator && hasObservedV2Decorator) { + context.report({ + node: hasObservedDecorator, + message: rule.messages.conflictingDecorators, + }); + } + }, + }; + }, +}; + +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/observedV2-trace-usage-validation.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/observedV2-trace-usage-validation.ts new file mode 100644 index 0000000000000000000000000000000000000000..278a9bc7326969f423e16e8d080bb99fe4ab6b15 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/observedV2-trace-usage-validation.ts @@ -0,0 +1,154 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { PresetDecorators, getAnnotationUsage } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +const rule: UISyntaxRule = { + name: 'observedV2-trace-usage-validation', + messages: { + observedV2DecoratorError: `The '@ObservedV2' decorator can only be used in 'class'.`, + traceDecoratorError: `The '@Trace' decorator can only be used in 'class'.`, + traceInObservedV2Error: `The '@Trace' decorator can only be used in a 'class' decorated with '@ObservedV2'.`, + traceMemberVariableError: `The '@Trace' decorator can only decorate member variables within a 'class' decorated with '@ObservedV2'.`, + }, + setup(context) { + return { + parsed: (node): void => { + validateTraceDecoratorUsage(node, context); + }, + }; + }, +}; + +function reportObservedV2DecoratorError(context: UISyntaxRuleContext, hasObservedV2Decorator: arkts.AnnotationUsage) + : void { + context.report({ + node: hasObservedV2Decorator, + message: rule.messages.observedV2DecoratorError, + fix: (hasObservedV2Decorator) => { + const startPosition = arkts.getStartPosition(hasObservedV2Decorator); + const endPosition = arkts.getEndPosition(hasObservedV2Decorator); + return { + range: [startPosition, endPosition], + code: '', + }; + }, + }); +} + +function reportTraceMemberVariableError(context: UISyntaxRuleContext, hasTraceDecorator: arkts.AnnotationUsage) + : void { + context.report({ + node: hasTraceDecorator, + message: rule.messages.traceMemberVariableError, + fix: (hasTraceDecorator) => { + const startPosition = arkts.getStartPosition(hasTraceDecorator); + const endPosition = arkts.getEndPosition(hasTraceDecorator); + return { + range: [startPosition, endPosition], + code: '', + }; + }, + }); +} + +function tracePerportyRule( + context: UISyntaxRuleContext, + currentNode: arkts.AstNode, + hasTraceDecorator: arkts.AnnotationUsage +): void { + if (arkts.isStructDeclaration(currentNode)) { + reportTraceDecoratorError(context, hasTraceDecorator); + } else if (arkts.isClassDeclaration(currentNode)) { + // The '@Trace' decorator can only be used in a 'class' decorated with '@ObservedV2' + if ( + !currentNode.definition?.annotations?.some((annotation: arkts.AnnotationUsage) => { + return ( + !!annotation.expr && + arkts.isIdentifier(annotation.expr) && + annotation.expr.name === PresetDecorators.OBSERVED_V2 + ); + }) + ) { + reportTraceInObservedV2Error(context, hasTraceDecorator, currentNode); + } + } +} + +function reportTraceDecoratorError(context: UISyntaxRuleContext, hasTraceDecorator: arkts.AnnotationUsage) + : void { + context.report({ + node: hasTraceDecorator, + message: rule.messages.traceDecoratorError, + fix: (hasTraceDecorator) => { + const startPosition = arkts.getStartPosition(hasTraceDecorator); + const endPosition = arkts.getEndPosition(hasTraceDecorator); + return { + range: [startPosition, endPosition], + code: '', + }; + }, + }); +} + +function reportTraceInObservedV2Error(context: UISyntaxRuleContext, hasTraceDecorator: arkts.AnnotationUsage, + currentNode: arkts.ClassDeclaration): void { + context.report({ + node: hasTraceDecorator, + message: rule.messages.traceInObservedV2Error, + fix: () => { + const startPosition = arkts.getStartPosition(currentNode); + return { + range: [startPosition, startPosition], + code: `@${PresetDecorators.OBSERVED_V2}\n`, + }; + }, + }); +} + +function validateTraceDecoratorUsage(node: arkts.AstNode, context: UISyntaxRuleContext): void { + let currentNode = node; + if (arkts.isStructDeclaration(node)) { + // Check whether the current custom component is decorated by the @ObservedV2 decorator + const hasObservedV2Decorator = getAnnotationUsage(node, PresetDecorators.OBSERVED_V2); + if (hasObservedV2Decorator) { + reportObservedV2DecoratorError(context, hasObservedV2Decorator); + } + } + if (arkts.isClassProperty(node)) { + const hasTraceDecorator = node.annotations?.find(annotation => + annotation.expr && annotation.expr.dumpSrc() === PresetDecorators.TRACE); + if (hasTraceDecorator) { + // Iterate up the parent node to check whether it is a class or a custom component + while (!arkts.isStructDeclaration(currentNode) && !arkts.isClassDeclaration(currentNode)) { + currentNode = currentNode.parent; + } + // The '@Trace' decorator can only be used in 'class' + tracePerportyRule(context, currentNode, hasTraceDecorator); + } + } + if (arkts.isMethodDefinition(node)) { + // Check that @Trace is in the correct location + const hasTraceDecorator = node.scriptFunction.annotations?.find(annotation => + annotation.expr && annotation.expr.dumpSrc() === PresetDecorators.TRACE); + if (hasTraceDecorator) { + reportTraceMemberVariableError(context, hasTraceDecorator); + } + } +} + +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/old-new-decorator-mix-use-check.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/old-new-decorator-mix-use-check.ts new file mode 100644 index 0000000000000000000000000000000000000000..356a28098854e9031f63161d2cf9c69aa0b39f3d --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/old-new-decorator-mix-use-check.ts @@ -0,0 +1,111 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { PresetDecorators, getAnnotationUsage } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +function findPropertyDecorator( + node: arkts.ClassProperty, + decoratorName: string +): arkts.AnnotationUsage | undefined { + const annotation = node.annotations?.find(annotation => + annotation.expr && + annotation.expr.dumpSrc() === decoratorName + ); + return annotation; +} + +function paramDecoratorError( + context: UISyntaxRuleContext, + hasParamDecorator: arkts.AnnotationUsage, + hasComponentDecorator: arkts.AnnotationUsage +): void { + context.report({ + node: hasParamDecorator, + message: rule.messages.paramDecoratorError, + fix: () => { + const startPosition = arkts.getStartPosition(hasComponentDecorator); + const endPosition = arkts.getEndPosition(hasComponentDecorator); + return { + range: [startPosition, endPosition], + code: `@${PresetDecorators.COMPONENT_V2}`, + }; + }, + }); +} + +function stateDecoratorError( + context: UISyntaxRuleContext, + hasStateDecorator: arkts.AnnotationUsage, + hasComponentV2Decorator: arkts.AnnotationUsage +): void { + context.report({ + node: hasStateDecorator, + message: rule.messages.stateDecoratorError, + fix: () => { + const startPosition = arkts.getStartPosition(hasComponentV2Decorator); + const endPosition = arkts.getEndPosition(hasComponentV2Decorator); + return { + range: [startPosition, endPosition], + code: `@${PresetDecorators.COMPONENT_V1}`, + }; + }, + }); +} + +function findDecoratorError( + node: arkts.StructDeclaration, + context: UISyntaxRuleContext +): void { + const hasComponentV2Decorator = getAnnotationUsage(node, PresetDecorators.COMPONENT_V2); + const hasComponentDecorator = getAnnotationUsage(node, PresetDecorators.COMPONENT_V1); + // Check where @Param and @State are used + node.definition.body.forEach((property) => { + if (arkts.isClassProperty(property)) { + const hasParamDecorator = findPropertyDecorator(property, PresetDecorators.PARAM); + const hasStateDecorator = findPropertyDecorator(property, PresetDecorators.STATE); + // Check that @Param is in the correct location + if (hasParamDecorator && !hasComponentV2Decorator && hasComponentDecorator) { + paramDecoratorError(context, hasParamDecorator, hasComponentDecorator); + } + // Check that @State is in the correct location + if (hasStateDecorator && !hasComponentDecorator && hasComponentV2Decorator) { + stateDecoratorError(context, hasStateDecorator, hasComponentV2Decorator); + } + } + }); +} + + +const rule: UISyntaxRule = { + name: 'old-new-decorator-mix-use-check', + messages: { + paramDecoratorError: `The '@Param' decorator can only be used in a 'struct' decorated with '@ComponentV2'.`, + stateDecoratorError: `The '@State' decorator can only be used in a 'struct' decorated with '@Component'.`, + }, + setup(context) { + return { + parsed: (node): void => { + if (!arkts.isStructDeclaration(node)) { + return; + } + findDecoratorError(node, context); + }, + }; + }, +}; + +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/once-decorator-check.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/once-decorator-check.ts new file mode 100644 index 0000000000000000000000000000000000000000..fabe04af00c11adc8fd5e43f1a1e279e1c307bf6 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/once-decorator-check.ts @@ -0,0 +1,187 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getAnnotationUsage, getClassPropertyAnnotationNames, PresetDecorators } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +function findDecorator(member: arkts.ClassProperty, decorator: string): arkts.AnnotationUsage | undefined { + return member.annotations?.find(annotation => + annotation.expr && + annotation.expr.dumpSrc() === decorator + ); +} + +// Check that the property decorator complies with the rules +function validatePropertyAnnotations( + body: arkts.ClassProperty, + context: UISyntaxRuleContext, + hasOnceDecorator: arkts.AnnotationUsage | undefined +): void { + const propertyAnnotations = getClassPropertyAnnotationNames(body); + hasOnceDecorator = findDecorator(body, PresetDecorators.ONCE); + if (hasOnceDecorator) { + const isParamUsed = propertyAnnotations.includes(PresetDecorators.PARAM); + // If @Once is found, check if @Param is also used + if (!isParamUsed) { + reportMissingParamWithOnce(hasOnceDecorator, context); + } else { + // If both @Once and @Param are used, check for other + // incompatible decorators + const otherDecorators = body.annotations?.find(annotation => + annotation.expr && + annotation.expr.dumpSrc() !== PresetDecorators.ONCE && + annotation.expr.dumpSrc() !== PresetDecorators.PARAM + ); + reportInvalidDecoratorsWithOnceAndParam(otherDecorators, context); + } + } +} + +function reportMissingParamWithOnce( + hasOnceDecorator: arkts.AnnotationUsage | undefined, + context: UISyntaxRuleContext +): void { + if (!hasOnceDecorator) { + return; + } + context.report({ + node: hasOnceDecorator, + message: rule.messages.invalidDecorator, + fix: (hasOnceDecorator) => { + const startPosition = arkts.getEndPosition(hasOnceDecorator); + const endPosition = arkts.getEndPosition(hasOnceDecorator); + return { + range: [startPosition, endPosition], + code: `@${PresetDecorators.PARAM}` + }; + } + }); +} + +function reportInvalidDecoratorsWithOnceAndParam( + otherDecorators: arkts.AnnotationUsage | undefined, + context: UISyntaxRuleContext +): void { + if (!otherDecorators) { + return; + } + context.report({ + node: otherDecorators, + message: rule.messages.invalidDecorator, + fix: (otherDecorators) => { + const startPosition = arkts.getStartPosition(otherDecorators); + const endPosition = arkts.getEndPosition(otherDecorators); + return { + range: [startPosition, endPosition], + code: '' + }; + } + }); +} + +// Check if the method is @Once decorated (not allowed) +function validateMethodAnnotations(body: arkts.MethodDefinition, context: UISyntaxRuleContext): void { + const methodAnnotations = body.scriptFunction.annotations?.find(annotation => + annotation.expr && + annotation.expr.dumpSrc() === PresetDecorators.ONCE + ); + if (methodAnnotations) { + context.report({ + node: methodAnnotations, + message: rule.messages.invalidMemberDecorate, + fix: (methodAnnotations) => { + const startPosition = arkts.getStartPosition(methodAnnotations); + const endPosition = arkts.getEndPosition(methodAnnotations); + return { + range: [startPosition, endPosition], + code: '' + }; + } + }); + } +} + +function invalidComponentUsage( + body: arkts.ClassProperty, + hasOnceDecorator: arkts.AnnotationUsage | undefined, + componentV2DocoratorUsage: arkts.AnnotationUsage | undefined, + componentDocoratorUsage: arkts.AnnotationUsage | undefined, + context: UISyntaxRuleContext +): void { + hasOnceDecorator = findDecorator(body, PresetDecorators.ONCE); + if (hasOnceDecorator && !componentV2DocoratorUsage && componentDocoratorUsage) { + context.report({ + node: hasOnceDecorator, + message: rule.messages.invalidUsage, + fix: (hasOnceDecorator) => { + const startPosition = arkts.getStartPosition(componentDocoratorUsage); + const endPosition = arkts.getEndPosition(componentDocoratorUsage); + return { + range: [startPosition, endPosition], + code: `@${PresetDecorators.COMPONENT_V2}` + }; + } + }); + } +} + +function validateDecorater( + node: arkts.StructDeclaration, + hasOnceDecorator: arkts.AnnotationUsage | undefined, + componentV2DocoratorUsage: arkts.AnnotationUsage | undefined, + componentDocoratorUsage: arkts.AnnotationUsage | undefined, + context: UISyntaxRuleContext, +): void { + node.definition?.body.forEach(body => { + // Check if @Once is used on a property and if @Param is used with + if (arkts.isClassProperty(body)) { + validatePropertyAnnotations(body, context, hasOnceDecorator); + // If @Once is used but not in a @ComponentV2 struct, report an error + invalidComponentUsage(body, hasOnceDecorator, componentV2DocoratorUsage, componentDocoratorUsage, context); + } + if (!arkts.isMethodDefinition(body)) { + return; + } + // Check if @Once is used on a method (which is not allowed) + validateMethodAnnotations(body, context); + }); +} + +const rule: UISyntaxRule = { + name: 'once-decorator-check', + messages: { + invalidUsage: `@Once can only decorate member properties in a @ComponentV2 struct.`, + invalidMemberDecorate: `@Once can only decorate member properties.`, + invalidDecorator: `@Once must be only used with @Param. ` + }, + setup(context) { + return { + parsed: (node): void => { + // Check if the node is a struct declaration + if (!arkts.isStructDeclaration(node)) { + return; + } + let hasOnceDecorator: arkts.AnnotationUsage | undefined; + // Check if the struct is decorated with @ComponentV2 + const componentV2DocoratorUsage = getAnnotationUsage(node, PresetDecorators.COMPONENT_V2); + const componentDocoratorUsage = getAnnotationUsage(node, PresetDecorators.COMPONENT_V1); + validateDecorater(node, hasOnceDecorator, componentV2DocoratorUsage, componentDocoratorUsage, context); + }, + }; + }, +}; + +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/one-decorator-on-function-method.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/one-decorator-on-function-method.ts new file mode 100644 index 0000000000000000000000000000000000000000..66dd9cdbd86d4d9028486a94d949d67bfa80c53b --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/one-decorator-on-function-method.ts @@ -0,0 +1,68 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getAnnotationName } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +const allowedDecorators = new Set(['Extend', 'Builder', 'Styles']); + +function validateFunctionDecorator(node: arkts.EtsScript, context: UISyntaxRuleContext): void { + node.statements.forEach((statement) => { + // If the node is not a function declaration, it is returned + if (!arkts.isFunctionDeclaration(statement)) { + return; + } + const annotations = statement.annotations; + // If there is no annotation, go straight back + if (!annotations) { + return; + } + // Check that each annotation is in the list of allowed decorators + annotations.forEach((annotation) => { + const decoratorName = getAnnotationName(annotation); + // rule1: misuse of decorator, only '@Extend', '@Builder' , '@Styles' decorators allowed on global functions + if (!allowedDecorators.has(decoratorName)) { + context.report({ + node: annotation, + message: rule.messages.invalidDecorator, + data: { + decoratorName, + }, + }); + } + }); + }); +} + +const rule: UISyntaxRule = { + name: 'one-decorator-on-function-method', + messages: { + invalidDecorator: `misuse of '@{{decoratorName}}' decorator, only '@Extend', '@Builder' and '@Styles' decorators allowed on global functions.`, + }, + setup(context) { + return { + parsed: (node: arkts.AstNode): void => { + // If the node is not an ETS script, it is returned directly + if (!arkts.isEtsScript(node)) { + return; + } + validateFunctionDecorator(node, context); + }, + }; + }, +}; + +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/reuse-attribute-check.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/reuse-attribute-check.ts new file mode 100644 index 0000000000000000000000000000000000000000..773b133ac3fad557e76e0c22fc4ec61f9201487f --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/reuse-attribute-check.ts @@ -0,0 +1,107 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; +import { PresetDecorators, getAnnotationUsage } from '../utils'; + +function findStructsWithReusableAndComponentV2(node: arkts.AstNode, reusableV2ComponentV2Struct: string[]): void { + //Go through all the children of Program + for (const childNode of node.getChildren()) { + // Check whether the type is struct + if (!arkts.isStructDeclaration(childNode)) { + continue; + } + // Check that the current component has @ComponentV2 and @ReusableV2 decorators + const hasReusableV2Decorator = getAnnotationUsage(childNode, PresetDecorators.REUSABLE_V2); + const hasComponentV2Decorator = getAnnotationUsage(childNode, PresetDecorators.COMPONENT_V2); + if (hasReusableV2Decorator && hasComponentV2Decorator) { + const struceName = childNode.definition?.ident?.name ?? ''; + reusableV2ComponentV2Struct.push(struceName); + } + } +} + +function validateReuseOrReuseIdUsage(context: UISyntaxRuleContext, node: arkts.MemberExpression, + reusableV2ComponentV2Struct: string[]): void { + const structNode = node.object; + // Gets the reuse or reuseId attribute + const decoratedNode = node.property; + if (arkts.isCallExpression(structNode)) { + const Node = structNode.expression; + if (decoratedNode.dumpSrc() === 'reuse' && !reusableV2ComponentV2Struct.includes(Node.dumpSrc())) { + reportInvalidReuseUsage(context, node, structNode, rule); + } + else if (decoratedNode.dumpSrc() === 'reuseId' && reusableV2ComponentV2Struct.includes(Node.dumpSrc())) { + reportInvalidReuseIdUsage(context, node, structNode, rule); + } + } +} + +function reportInvalidReuseUsage(context: UISyntaxRuleContext, node: arkts.AstNode, structNode: arkts.AstNode, + rule: any): void { + context.report({ + node: node, + message: rule.messages.invalidReuseUsage, + fix: (node) => { + const startPosition = arkts.getStartPosition(node); + const endPosition = arkts.getEndPosition(node); + return { + range: [startPosition, endPosition], + code: `${structNode.dumpSrc()}.reuseId`, + }; + }, + }); +} + +function reportInvalidReuseIdUsage(context: UISyntaxRuleContext, node: arkts.AstNode, structNode: arkts.AstNode, + rule: any): void { + context.report({ + node: node, + message: rule.messages.invalidReuseIdUsage, + fix: (node) => { + const startPosition = arkts.getStartPosition(node); + const endPosition = arkts.getEndPosition(node); + return { + range: [startPosition, endPosition], + code: `${structNode.dumpSrc()}.reuse`, + }; + }, + }); +} + +const rule: UISyntaxRule = { + name: 'reuse-attribute-check', + messages: { + invalidReuseUsage: `The reuse attribute is only applicable to custom components decorated with both @ComponentV2 and @ReusableV2.`, + invalidReuseIdUsage: `The reuseId attribute is not applicable to custom components decorated with both @ComponentV2 and @ReusableV2.`, + }, + setup(context) { + const reusableV2ComponentV2Struct: string[] = []; + return { + parsed: (node): void => { + // Check whether the type is "Program" + if (arkts.nodeType(node) === arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) { + findStructsWithReusableAndComponentV2(node, reusableV2ComponentV2Struct); + } + if (arkts.isMemberExpression(node)) { + validateReuseOrReuseIdUsage(context, node, reusableV2ComponentV2Struct); + } + }, + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/struct-missing-decorator.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/struct-missing-decorator.ts new file mode 100644 index 0000000000000000000000000000000000000000..7ca8e7b3a619c974d1eea7dae318313ff951ff47 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/struct-missing-decorator.ts @@ -0,0 +1,74 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getAnnotationUsage, PresetDecorators } from '../utils'; +import { UISyntaxRule } from './ui-syntax-rule'; + +const rule: UISyntaxRule = { + name: 'struct-missing-decorator', + messages: { + missingComponentDecorator: `struct '{{structName}}' is missing '@Component' or '@CustomDialog' decorators`, + misusedPreview: `struct '{{structName}}' misused '@Preview' decorator. it should be decorated by '@Component' or '@CustomDialog'`, + misusedObserved: `struct '{{structName}}' misused '@Observed' decorator. it should be decorated by '@Component' or '@CustomDialog'`, + }, + setup(context) { + function hasDecorator(node: arkts.StructDeclaration, decorator: string): boolean { + return !!getAnnotationUsage(node, decorator); + } + + return { + parsed: (node): void => { + if (!arkts.isStructDeclaration(node)) { + return; + } + // Check for the presence of specific decorators on the struct + const structName = node.definition.ident?.name ?? ''; + const structNode = node.definition.ident; + const hasComponent = hasDecorator(node, PresetDecorators.COMPONENT_V1); + const hasComponentV2 = hasDecorator(node, PresetDecorators.COMPONENT_V2); + const hasCustomDialog = hasDecorator(node, PresetDecorators.CUSTOM_DIALOG); + const hasPreview = getAnnotationUsage(node, PresetDecorators.PREVIEW); + const hasObserved = getAnnotationUsage(node, PresetDecorators.OBSERVED_V1); + // If no valid component decorators (@Component or @CustomDialog) are found + if (!hasComponent && !hasComponentV2 && !hasCustomDialog && structNode) { + context.report({ + node: structNode, + message: rule.messages.missingComponentDecorator, + data: { structName }, + }); + } + // If the @Preview decorator is used but the struct is not decorated with @Component or @CustomDialog + if (hasPreview && !hasComponent && !hasComponentV2 && !hasCustomDialog && structNode) { + context.report({ + node: structNode, + message: rule.messages.misusedPreview, + data: { structName }, + }); + } + // If the @Observed decorator is used but the struct is not decorated with @Component or @CustomDialog + if (hasObserved && !hasComponent && !hasComponentV2 && !hasCustomDialog && structNode) { + context.report({ + node: structNode, + message: rule.messages.misusedObserved, + data: { structName }, + }); + } + }, + }; + }, +}; + +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/struct-property-decorator.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/struct-property-decorator.ts new file mode 100644 index 0000000000000000000000000000000000000000..9aaa53de01b43f3b6dcf7be32c17dd39156f6a7e --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/struct-property-decorator.ts @@ -0,0 +1,52 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getClassPropertyAnnotationNames } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +function checkInvalidStaticPropertyDecorations(context: UISyntaxRuleContext, node: arkts.StructDeclaration): void { + node.definition.body.forEach((member) => { + // Errors are reported when the node type is ClassProperty, + if (arkts.isClassProperty(member)) { + const propertyNameNode = member.key; + if ((member.isStatic && getClassPropertyAnnotationNames(member).length > 0) && propertyNameNode) { + context.report({ + node: propertyNameNode, + message: rule.messages.invalidStaticUsage + }); + } + } + }); +} + +const rule: UISyntaxRule = { + name: 'struct-property-decorator', + messages: { + invalidStaticUsage: `Static variables in custom components cannot be decorated by built-in variable decorators.` + }, + setup(context) { + return { + parsed: (node): void => { + if (!arkts.isStructDeclaration(node)) { + return; + } + checkInvalidStaticPropertyDecorations(context, node); + }, + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/struct-variable-initialization.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/struct-variable-initialization.ts new file mode 100644 index 0000000000000000000000000000000000000000..63c06587f6aff660befe92e7c0ace646ec249363 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/struct-variable-initialization.ts @@ -0,0 +1,72 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +// A list of decorators that needs to be initialized locally +const mustInitializeDecorators = ['State', 'StorageLink', 'StorageProp', 'LocalStorageLink', 'LocalStorageProp', + 'Provide']; +// Disables a list of decorators that are initialized locally +const prohibitInitializeDecorators = ['Link', 'Consume', 'ObjectLink']; + +function reportVariablesInitializationError(context: UISyntaxRuleContext, node: arkts.ClassProperty): void { + // Check whether the value field exists and whether it has been initialized + const valueExists = !!node.value; + // Iterate through each decorator and verify the initialization rules + node.annotations.forEach(annotation => { + const decoratorName = annotation.expr?.dumpSrc() ?? ''; + if (mustInitializeDecorators.includes(decoratorName)) { + // If it is a decorator that needs to be initialized + if (!valueExists) { + // If there is no initialization expression and there is no @Require, an error is reported + context.report({ + node: annotation, + message: rule.messages.mustBeInitializedLocally, + }); + } + } else if (prohibitInitializeDecorators.includes(decoratorName)) { + // If it is a decorator that prohibits initialization + if (valueExists) { + // If an initialization expression exists, an error is reported + context.report({ + node: annotation, + message: rule.messages.prohibitLocalInitialization, + }); + } + } + }); +} + +const rule: UISyntaxRule = { + name: 'struct-variable-initialization', + messages: { + mustBeInitializedLocally: `Variables decorated by '@State', '@StorageLink', '@StorageProp', '@LocalStorageLink', '@LocalStorageProp' and '@Provide' must be initialized locally.`, + prohibitLocalInitialization: `Variables decorated by '@Link', '@Consume', and '@ObjectLink' cannot be initialized locally.` + }, + setup(context) { + return { + parsed: (node): void => { + // Check if the current node is a class attribute + if (!arkts.isClassProperty(node)) { + return; + } + reportVariablesInitializationError(context, node); + } + }; + } +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/track-decorator-check.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/track-decorator-check.ts new file mode 100644 index 0000000000000000000000000000000000000000..db909687b0635ef60fb91ca85e451d374e386733 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/track-decorator-check.ts @@ -0,0 +1,146 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; +import { PresetDecorators } from '../utils/index'; + +const rule: UISyntaxRule = { + name: 'track-decorator-check', + messages: { + invalidTarget: `The '@Track' decorator can only be used on class member variables.`, + invalidClass: `The '@Track' decorator can only be used within a 'class' decorated with '@Observed'.` + }, + setup(context) { + return { + parsed: (node): void => { + if (arkts.isStructDeclaration(node)) { + checkInvalidTrackAnnotations(context, node); + } + // Check if the current node is a class declaration + if (arkts.isClassDeclaration(node)) { + checkTrackOnlyUsedWithObserved(context, node); + } + } + }; + } +}; + +function checkInvalidTrackAnnotations(context: UISyntaxRuleContext, node: arkts.StructDeclaration): void { + // Traverse all members of the struct body + node.definition.body.forEach((member) => { + // Check whether it is a member variable + if (arkts.isClassProperty(member)) { + const hasTrackDecorator = findClassPropertyAnnotation(member, PresetDecorators.TRACK); + // If a member variable is decorated with @Track, an error is reported immediately + if (hasTrackDecorator) { + reportInvalidTarget(context, hasTrackDecorator); + } + } + // Check whether this is the method + if (arkts.isMethodDefinition(member)) { + const hasTrackDecorator = getMethodAnnotation(member, PresetDecorators.TRACK); + // If the method is decorated with @Track, an error is reported immediately + if (hasTrackDecorator) { + reportInvalidTarget(context, hasTrackDecorator); + } + } + },); +} + +function checkTrackOnlyUsedWithObserved(context: UISyntaxRuleContext, node: arkts.ClassDeclaration): void { + // Check if the class is decorated with @Observed + const hasObservedDecorator = node.definition?.annotations?.find( + annotations => + annotations.expr && + arkts.isIdentifier(annotations.expr) && + annotations.expr.name === PresetDecorators.OBSERVED_V1 + ); + // Traverse all members of the body class + node.definition?.body.forEach((member) => { + // Check whether it is a class attribute + if (arkts.isClassProperty(member)) { + const hasTrackDecorator = findClassPropertyAnnotation(member, PresetDecorators.TRACK); + // If the class is not decorated with @Observed and has decorators, an error is reported + if (!hasObservedDecorator && hasTrackDecorator) { + reportInvalidClass(context, hasTrackDecorator); + } + } + // Check whether this is the method + if (arkts.isMethodDefinition(member)) { + const hasTrackDecorator = getMethodAnnotation(member, PresetDecorators.TRACK); + // If the method is decorated with @Track, an error is reported immediately + if (hasTrackDecorator) { + reportInvalidTarget(context, hasTrackDecorator); + } + } + }); +} + +function reportInvalidClass(context: UISyntaxRuleContext, hasTrackDecorator: arkts.AnnotationUsage): void { + context.report({ + node: hasTrackDecorator, + message: rule.messages.invalidClass, + fix: (hasTrackDecorator) => { + const startPosition = arkts.getStartPosition(hasTrackDecorator); + const endPosition = arkts.getEndPosition(hasTrackDecorator); + return { + range: [startPosition, endPosition], + code: '', + }; + }, + }); +} + +function getMethodAnnotation( + node: arkts.MethodDefinition, + annotationName: string) + : arkts.AnnotationUsage | undefined { + return node.scriptFunction.annotations?.find( + annotation => + annotation.expr && + annotation.expr.dumpSrc() === annotationName + ); +} + +function findClassPropertyAnnotation( + node: arkts.ClassProperty, + annotationName: string) + : arkts.AnnotationUsage | undefined { + return node.annotations?.find(annotation => + annotation.expr && + annotation.expr.dumpSrc() === annotationName + ); +} + +function reportInvalidTarget( + context: UISyntaxRuleContext, + node: arkts.AnnotationUsage) + : void { + context.report({ + node: node, + message: rule.messages.invalidTarget, + fix: (node) => { + const startPosition = arkts.getStartPosition(node); + const endPosition = arkts.getEndPosition(node); + return { + range: [startPosition, endPosition], + code: '', + }; + }, + }); +} + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/type-decorator-check.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/type-decorator-check.ts new file mode 100644 index 0000000000000000000000000000000000000000..79c60be2e1557b43ad9d29e255dc5fb61f60d7fc --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/type-decorator-check.ts @@ -0,0 +1,167 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getAnnotationName, PresetDecorators } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +function findTypeDecorator( + annotations: readonly arkts.AnnotationUsage[] +): arkts.AnnotationUsage | undefined { + let hasTypeDecorator = annotations?.find(annotation => + annotation.expr && + annotation.expr.dumpSrc() === PresetDecorators.TYPE + ); + return hasTypeDecorator; +} + +function hasDecoratorType( + node: arkts.ClassDeclaration, +): arkts.AnnotationUsage | undefined { + let hasTypeDecorator: arkts.AnnotationUsage | undefined; + node.definition?.body.forEach(member => { + if (arkts.isClassProperty(member) && member.annotations) { + hasTypeDecorator = findTypeDecorator(member.annotations); + } + }); + return hasTypeDecorator; +} + +// rule1: @Type can only be used for class +function checkTypeInStruct( + node: arkts.StructDeclaration, + context: UISyntaxRuleContext, +): void { + let hasTypeDecorator: arkts.AnnotationUsage | undefined; + node.definition?.body.forEach(member => { + if (arkts.isClassProperty(member) && member.annotations) { + hasTypeDecorator = findTypeDecorator(member.annotations); + reportInvalidTypeUsageInStruct(hasTypeDecorator, context); + } + }); +} + +function reportInvalidTypeUsageInStruct( + hasTypeDecorator: arkts.AnnotationUsage | undefined, + context: UISyntaxRuleContext +): void { + if (!hasTypeDecorator) { + return; + } + context.report({ + node: hasTypeDecorator, + message: rule.messages.invalidType, + fix: (hasTypeDecorator) => { + const startPosition = arkts.getStartPosition(hasTypeDecorator); + const endPosition = arkts.getEndPosition(hasTypeDecorator); + return { + range: [startPosition, endPosition], + code: '' + }; + } + }); +} + +// rule2: Conflict between @Type and @Observed +function checkObservedAndTypeConflict( + node: arkts.ClassDeclaration, + context: UISyntaxRuleContext +): void { + let hasTypeDecorator: arkts.AnnotationUsage | undefined; + node.definition?.annotations.forEach(member => { + const annotation = getAnnotationName(member); + hasTypeDecorator = hasDecoratorType(node); + if (annotation === PresetDecorators.OBSERVED_V1) { + reportObservedAndTypeDecoratorConflict(hasTypeDecorator, context); + } + }); +} + +function reportObservedAndTypeDecoratorConflict( + hasTypeDecorator: arkts.AnnotationUsage | undefined, + context: UISyntaxRuleContext +): void { + if (!hasTypeDecorator) { + return; + } + context.report({ + node: hasTypeDecorator, + message: rule.messages.invalidDecoratorWith, + fix: () => { + const startPosition = arkts.getStartPosition(hasTypeDecorator); + const endPosition = arkts.getEndPosition(hasTypeDecorator); + return { + range: [startPosition, endPosition], + code: '' + }; + } + }); +} + +// rule3: @TypeCannot be used for function members +function validateScriptFunctionForTypeDecorator( + node: arkts.ScriptFunction, + context: UISyntaxRuleContext +): void { + const hasTypeDecorator = findTypeDecorator(node.annotations); + reportInvalidTypeDecorator(hasTypeDecorator, context); +} + +function reportInvalidTypeDecorator( + hasTypeDecorator: arkts.AnnotationUsage | undefined, + context: UISyntaxRuleContext +): void { + if (!hasTypeDecorator) { + return; + } + context.report({ + node: hasTypeDecorator, + message: rule.messages.invalidTypeMember, + fix: (hasTypeDecorator) => { + const startPosition = arkts.getStartPosition(hasTypeDecorator); + const endPosition = arkts.getEndPosition(hasTypeDecorator); + return { + range: [startPosition, endPosition], + code: '' + }; + } + }); +} + +const rule: UISyntaxRule = { + name: 'type-decorator-check', + messages: { + invalidType: `The @Type decorator can only be used in 'class'.`, + invalidDecoratorWith: `The @Type decorator can not be used within a 'class' decorated with @Observed.`, + invalidTypeMember: `The @Type can decorate only member variables in a 'class'.` + }, + setup(context) { + return { + parsed: (node): void => { + // Check the decorator on the class + if (arkts.isClassDeclaration(node)) { + checkObservedAndTypeConflict(node, context); + } + if (arkts.isStructDeclaration(node)) { + checkTypeInStruct(node, context); + } + if (arkts.isScriptFunction(node) && node.annotations) { + validateScriptFunctionForTypeDecorator(node, context); + } + }, + }; + }, +}; +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/ui-syntax-rule.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/ui-syntax-rule.ts new file mode 100644 index 0000000000000000000000000000000000000000..c71a7c298ca697f0d2de52c0645c5e56f0923a8f --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/ui-syntax-rule.ts @@ -0,0 +1,43 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; + +export type FixSuggestion = { + range: [start: arkts.SourcePosition, end: arkts.SourcePosition]; + code: string; +}; + +export type ReportOptions = { + node: arkts.AstNode; + message: string; + data?: Record; + fix?: (node: arkts.AstNode) => FixSuggestion; +}; + +export type UISyntaxRuleContext = { + report(options: ReportOptions): void; + containerComponents?: Set | undefined; +}; + +export type UISyntaxRuleHandler = (node: arkts.AstNode) => void; + +export type UISyntaxRule = { + name: string; + messages: Record; + setup(context: UISyntaxRuleContext): { + parsed?: UISyntaxRuleHandler; + }; +}; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/validate-build-in-struct.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/validate-build-in-struct.ts new file mode 100644 index 0000000000000000000000000000000000000000..938c3a210931105d572ea62ab5011d5b68b281b3 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/validate-build-in-struct.ts @@ -0,0 +1,135 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getIdentifierName } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +const NOT_PARAM_LENGTH: number = 0; +const BUILD_NAME: string = 'build'; +const BUILD_FUNCTION_COUNT_INI: number = 0; +const BUILD_FUNCTION_COUNT: number = 1; +const NOT_STATEMENT_LENGTH: number = 0; + +// rule1: Check if the build function contains arguments and report an error +function validateBuildFunctionParameters(buildFunction: arkts.MethodDefinition, context: UISyntaxRuleContext): void { + const paramsNodes = buildFunction.scriptFunction.params; + if (paramsNodes.length > NOT_PARAM_LENGTH) { + paramsNodes.forEach((param) => { + if (arkts.isEtsParameterExpression(param)) { + reportBuildParamNotAllowed(param, context); + } + }); + } +} + +// Report an error with an unallowed parameter in the build function +function reportBuildParamNotAllowed( + param: arkts.ETSParameterExpression, + context: UISyntaxRuleContext +): void { + context.report({ + node: param, + message: rule.messages.invalidComponet, + fix: (param) => { + const startPosition = arkts.getStartPosition(param); + const endPosition = arkts.getEndPosition(param); + return { + range: [startPosition, endPosition], + code: '' + }; + } + }); +} + +function validateConstructorForBuildFunction( + node: arkts.StructDeclaration, + member: arkts.MethodDefinition, + buildFunctionCount: number, + context: UISyntaxRuleContext +): void { + const blockStatement = member.scriptFunction.body; + if (!blockStatement || !arkts.isBlockStatement(blockStatement)) { + return; + } + const statements = blockStatement.statements; + const structName = node.definition.ident; + if (buildFunctionCount !== BUILD_FUNCTION_COUNT && + statements.length === NOT_STATEMENT_LENGTH) { + reportMissingBuildInStruct(structName, blockStatement, context); + } +} + +function reportMissingBuildInStruct( + structName: arkts.Identifier | undefined, + blockStatement: arkts.BlockStatement, + context: UISyntaxRuleContext +): void { + if (!structName) { + return; + } + context.report({ + node: structName, + message: rule.messages.invalidBuild, + fix: (structName) => { + const startPosition = arkts.getStartPosition(blockStatement); + const endPosition = startPosition; + return { + range: [startPosition, endPosition], + code: '{\nbuild {\n}' + }; + } + }); +} + +function validateBuild( + node: arkts.StructDeclaration, + buildFunctionCount: number, + context: UISyntaxRuleContext, +): void { + node.definition.body.forEach((member) => { + // Check if the member is defined for the method and the method name is 'build' + if (arkts.isMethodDefinition(member) && getIdentifierName(member.name) === BUILD_NAME) { + buildFunctionCount++; + validateBuildFunctionParameters(member, context); + } + // rule2: This rule validates the use of the 'build' function + if (arkts.isMethodDefinition(member) && + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_CONSTRUCTOR === member.kind) { + validateConstructorForBuildFunction(node, member, buildFunctionCount, context); + } + }); +} + +const rule: UISyntaxRule = { + name: 'validate-build-in-struct', + messages: { + invalidComponet: `A custom component can have only one 'build' function, which does not require parameters.`, + invalidBuild: `This rule validates the use of the 'build' function`, + }, + setup(context) { + return { + parsed: (node: arkts.AstNode): void => { + if (!arkts.isStructDeclaration(node)) { + return; + } + let buildFunctionCount: number = BUILD_FUNCTION_COUNT_INI; + validateBuild(node, buildFunctionCount, context); + }, + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/variable-initialization-via-component-cons.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/variable-initialization-via-component-cons.ts new file mode 100644 index 0000000000000000000000000000000000000000..7660e662468b62dd664167a283982c3b6a6b3a73 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/variable-initialization-via-component-cons.ts @@ -0,0 +1,210 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getIdentifierName, getClassPropertyAnnotationNames, PresetDecorators } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +// Define a function to add property data to the property map +function addProperty(propertyMap: Map>, structName: string, + propertyName: string, annotationName: string): void { + if (!propertyMap.has(structName)) { + propertyMap.set(structName, new Map()); + } + const structProperties = propertyMap.get(structName); + if (structProperties) { + structProperties.set(propertyName, annotationName); + } +} +// categorizePropertyBasedOnAnnotations +function checkPropertyByAnnotations( + item: arkts.AstNode, + structName: string, + mustInitMap: Map>, + cannotInitMap: Map> = new Map(), + mustInitArray: string[][], + cannotInitArray: string[][] +): void { + if (!arkts.isClassProperty(item)) { + return; + } + const propertyName: string = item.key?.dumpSrc() ?? ''; + if (item.annotations.length === 0 || propertyName === '') { + return; + } + const annotationArray: string[] = getClassPropertyAnnotationNames(item); + // If the member variable is decorated, it is added to the corresponding map + mustInitArray.forEach(arr => { + if (arr.every(annotation => annotationArray.includes(annotation))) { + const annotationName: string = arr[0]; + addProperty(mustInitMap, structName, propertyName, annotationName); + } + }); + cannotInitArray.forEach(arr => { + if (arr.every(annotation => annotationArray.includes(annotation))) { + const annotationName: string = arr[0]; + addProperty(cannotInitMap, structName, propertyName, annotationName); + } + }); +} + +function initMap( + node: arkts.AstNode, + mustInitMap: Map>, + cannotInitMap: Map> = new Map(), + mustInitArray: string[][], + cannotInitArray: string[][] +): void { + if (arkts.nodeType(node) !== arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) { + return; + } + node.getChildren().forEach((member) => { + if (!arkts.isStructDeclaration(member)) { + return; + } + const structName: string = member.definition.ident?.name ?? ''; + if (structName === '') { + return; + } + member.definition?.body.forEach((item) => { + checkPropertyByAnnotations(item, structName, mustInitMap, cannotInitMap, mustInitArray, cannotInitArray); + }); + }); +} + +function getChildKeyNameArray(member: arkts.AstNode): string[] { + const childkeyNameArray: string[] = []; + member.getChildren().forEach((property) => { + if (arkts.isProperty(property)) { + const childkeyName = property.key?.dumpSrc() ?? ''; + if (childkeyName !== '') { + childkeyNameArray.push(childkeyName); + } + } + }); + return childkeyNameArray; +} + +function checkMustInitialize( + node: arkts.AstNode, + context: UISyntaxRuleContext, + mustInitMap: Map> +): void { + if (!arkts.isIdentifier(node)) { + return; + } + const structName: string = getIdentifierName(node); + if (!mustInitMap.has(structName)) { + return; + } + const parentNode: arkts.AstNode = node.parent; + if (!arkts.isCallExpression(parentNode)) { + return; + } + // Get all the properties of a record via StructName + const mustInitName: Map = mustInitMap.get(structName)!; + parentNode.arguments?.forEach((member) => { + const childkeyNameArray: string[] = getChildKeyNameArray(member); + mustInitName.forEach((value, key) => { + // If an attribute that must be initialized is not initialized, an error is reported + if (!childkeyNameArray.includes(key)) { + context.report({ + node: parentNode, + message: rule.messages.mustInitializeRule, + data: { + annotationName: value, + propertyName: key, + }, + }); + } + }); + }); +} + +function checkCannotInitialize( + node: arkts.AstNode, + context: UISyntaxRuleContext, + cannotInitMap: Map> +): void { + if (!arkts.isIdentifier(node)) { + return; + } + const structName: string = getIdentifierName(node); + if (!cannotInitMap.has(structName)) { + return; + } + const parentNode: arkts.AstNode = node.parent; + if (!arkts.isCallExpression(parentNode)) { + return; + } + // Get all the properties of a record via StructName + const cannotInitName: Map = cannotInitMap.get(structName)!; + parentNode.arguments.forEach((member) => { + member.getChildren().forEach((property) => { + if (!arkts.isProperty(property)) { + return; + } + if (!property.key) { + return; + } + const propertyName = property.key.dumpSrc(); + // If a property that cannot be initialized is initialized, an error is reported + if (cannotInitName.has(propertyName)) { + context.report({ + node: property.key, + message: rule.messages.cannotInitializeRule, + data: { + annotationName: cannotInitName.get(propertyName)!, + propertyName: propertyName, + }, + }); + } + }); + }); +} + +const rule: UISyntaxRule = { + name: 'variable-initialization-via-component-cons', + messages: { + mustInitializeRule: `'@{{annotationName}}' decorated '{{propertyName}}' must be initialized through the component constructor.`, + cannotInitializeRule: `'@{{annotationName}}' decorated '{{propertyName}}' cannot be initialized through the component constructor.`, + }, + setup(context) { + let mustInitMap: Map> = new Map(); + let cannotInitMap: Map> = new Map(); + const mustInitArray: string[][] = [ + [PresetDecorators.REQUIRE, PresetDecorators.PROP], + [PresetDecorators.REQUIRE, PresetDecorators.BUILDER_PARAM], + [PresetDecorators.LINK], + [PresetDecorators.OBJECT_LINK] + ]; + const cannotInitArray: string[][] = [ + [PresetDecorators.STORAGE_LINK], + [PresetDecorators.STORAGE_PROP], + [PresetDecorators.CONSUME], + [PresetDecorators.LOCAL_STORAGE_LINK], + [PresetDecorators.LOCAL_STORAGE_PROP] + ]; + return { + parsed: (node): void => { + initMap(node, mustInitMap, cannotInitMap, mustInitArray, cannotInitArray); + checkMustInitialize(node, context, mustInitMap); + checkCannotInitialize(node, context, cannotInitMap); + }, + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/watch-decorator-function.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/watch-decorator-function.ts new file mode 100644 index 0000000000000000000000000000000000000000..dae346a7958033a1d2c0dc703d2ece3c2554682c --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/watch-decorator-function.ts @@ -0,0 +1,128 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getIdentifierName, PresetDecorators } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +// Gets the names of all methods in the struct +function getMethodNames(node: arkts.StructDeclaration): string[] { + const methodNames: string[] = []; + node.definition.body.forEach((member) => { + if (arkts.isMethodDefinition(member)) { + const methodName = getIdentifierName(member.name); + if (methodName) { + methodNames.push(methodName); + } + } + }); + return methodNames; +} + +// Invalid @Watch decorator bugs are reported +function reportInvalidWatch( + member: arkts.ClassProperty, + methodName: string, + hasWatchDecorator: arkts.AnnotationUsage, + context: UISyntaxRuleContext +): void { + context.report({ + node: hasWatchDecorator, + message: rule.messages.invalidWatch, + data: { methodName }, + fix: () => { + const startPosition = arkts.getEndPosition(member); + const endPosition = arkts.getEndPosition(member); + return { + range: [startPosition, endPosition], + code: `\n${methodName}(){\n}`, + }; + }, + }); +} + +function validateWatchDecorator( + member: arkts.ClassProperty, + methodNames: string[], + hasWatchDecorator: arkts.AnnotationUsage | undefined, + context: UISyntaxRuleContext +): void { + member.annotations.forEach((annotation) => { + validateWatchProperty(annotation, member, methodNames, hasWatchDecorator, context); + }); +} + +function validateWatchProperty( + annotation: arkts.AnnotationUsage, + member: arkts.ClassProperty, + methodNames: string[], + hasWatchDecorator: arkts.AnnotationUsage | undefined, + context: UISyntaxRuleContext +): void { + if ( + annotation.expr && + annotation.expr.dumpSrc() === PresetDecorators.WATCH + ) { + annotation.properties.forEach((element) => { + if (!arkts.isClassProperty(element)) { + return; + } + const methodName = element.value?.dumpSrc().slice(1, -1); + if (hasWatchDecorator && methodName && !methodNames.includes(methodName)) { + reportInvalidWatch(member, methodName, hasWatchDecorator, context); + } + }); + } + +} + +function validateWatch( + node: arkts.StructDeclaration, + methodNames: string[], + context: UISyntaxRuleContext +): void { + node.definition.body.forEach(member => { + if (!arkts.isClassProperty(member)) { + return; + } + const hasWatchDecorator = member.annotations?.find(annotation => + annotation.expr && + annotation.expr.dumpSrc() === PresetDecorators.WATCH + ); + // Determine whether it contains @watch decorators + validateWatchDecorator(member, methodNames, hasWatchDecorator, context); + }); +} + +const rule: UISyntaxRule = { + name: 'watch-decorator-function', + messages: { + invalidWatch: `The '@Watch' decorated parameter must be a callback '{{methodName}}' of a function in a custom component.`, + }, + setup(context) { + return { + parsed: (node): void => { + if (!arkts.isStructDeclaration(node)) { + return; + } + // Get all method names + const methodNames = getMethodNames(node); + validateWatch(node, methodNames, context); + }, + }; + }, +}; + +export default rule; \ No newline at end of file diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/watch-decorator-regular.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/watch-decorator-regular.ts new file mode 100644 index 0000000000000000000000000000000000000000..22eb47c74686b3882d25c52357c8e1079e7685e1 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/watch-decorator-regular.ts @@ -0,0 +1,60 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getClassPropertyAnnotationNames, PresetDecorators } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +const PROPERTY_ANNOTATION_NUM: number = 2; + +function validateWatchDecorator(node: arkts.StructDeclaration, context: UISyntaxRuleContext): void { + node.definition.body.forEach(member => { + if (!arkts.isClassProperty(member)) { + return; + } + const hasWatchDecorator = member.annotations?.find(annotation => + annotation.expr && + annotation.expr.dumpSrc() === PresetDecorators.WATCH + ); + const propertyAnnotationNames = getClassPropertyAnnotationNames(member); + // Determine if there are any decorations other than @watch decorations + // rule1: The @Watch decorator must be used with other decorators + if (hasWatchDecorator && propertyAnnotationNames.length < PROPERTY_ANNOTATION_NUM) { + context.report({ + node: hasWatchDecorator, + message: rule.messages.invalidWatch, + }); + } + }); +} + +const rule: UISyntaxRule = { + name: 'watch-decorator-regular', + messages: { + invalidWatch: `The @Watch decorator must be used with other decorators.`, + }, + setup(context) { + return { + parsed: (node): void => { + if (!arkts.isStructDeclaration(node)) { + return; + } + validateWatchDecorator(node, context); + }, + }; + }, +}; + +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/rules/wrap-builder-check.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/wrap-builder-check.ts new file mode 100644 index 0000000000000000000000000000000000000000..5f87ef3fc7ac23eeae4e586a5972049d2a04ce29 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/rules/wrap-builder-check.ts @@ -0,0 +1,109 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { getIdentifierName, getAnnotationName, PresetDecorators } from '../utils'; +import { UISyntaxRule, UISyntaxRuleContext } from './ui-syntax-rule'; + +const WRAPBUILDER_NAME: string = 'wrapBuilder'; +// Collect all the function names that are decorated with @Builder +function collectBuilderFunctions(node: arkts.EtsScript, builderFunctionNames: string[]): void { + node.statements.forEach((statement) => { + if (!arkts.isFunctionDeclaration(statement)) { + return; + } + const annotations = statement.annotations; + if (!annotations) { + return; + } + annotations.forEach((annotation) => { + const decoratorName = getAnnotationName(annotation); + // Find all the functions that are decorated with @Builder and note their names + if (!decoratorName.includes(PresetDecorators.BUILDER)) { + return; + } + const functionName = statement.scriptFunction.id?.name; + if (!functionName || builderFunctionNames.includes(functionName)) { + return; + } + builderFunctionNames.push(functionName); + }); + }); +} + +// Verify that the wrapBuilder's arguments are decorated with @Builder +function validateWrapBuilderArguments( + member: arkts.ClassProperty, + context: UISyntaxRuleContext, + builderFunctionNames: string[] +): void { + member.getChildren().forEach((child) => { + if (!arkts.isCallExpression(child) || child.expression.dumpSrc() !== WRAPBUILDER_NAME) { + return; + } + let functionName: string | undefined; + child.arguments.forEach(firstArgument => { + if (arkts.isMemberExpression(firstArgument)) { + functionName = getIdentifierName(firstArgument.property); + } else if (arkts.isIdentifier(firstArgument)) { + functionName = firstArgument.name; + } + // Verify that wrapBuilder's arguments are decorated with @Builder + // rule1: The wrapBuilder accepts only a function decorated by '@Builder' + if (functionName && !builderFunctionNames.includes(functionName)) { + context.report({ + node: firstArgument, + message: rule.messages.invalidBuilderCheck, + }); + } + }); + }); +} + +function validateWrapBuilder( + node: arkts.StructDeclaration, + builderFunctionNames: string[], + context: UISyntaxRuleContext +): void { + node.definition.body.forEach(member => { + if (!arkts.isClassProperty(member)) { + return; + } + validateWrapBuilderArguments(member, context, builderFunctionNames); + }); +} + +const rule: UISyntaxRule = { + name: 'wrap-builder-check', + messages: { + invalidBuilderCheck: 'The wrapBuilder accepts only a function decorated by @Builder.', + }, + setup(context) { + let builderFunctionNames: string[] = []; + return { + parsed: (node): void => { + if (arkts.isEtsScript(node)) { + collectBuilderFunctions(node, builderFunctionNames); + } + if (!arkts.isStructDeclaration(node)) { + return; + } + validateWrapBuilder(node, builderFunctionNames, context); + }, + }; + }, +}; + +export default rule; diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/transformers/parsed-ui-syntax-linter-transformer.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/transformers/parsed-ui-syntax-linter-transformer.ts new file mode 100644 index 0000000000000000000000000000000000000000..d8c642ed22902f185edc4b5e0d950da2d3665a02 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/transformers/parsed-ui-syntax-linter-transformer.ts @@ -0,0 +1,25 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import { UISyntaxLinterVisitor } from './ui-syntax-linter-visitor'; + +export class ParsedUISyntaxLinterTransformer extends UISyntaxLinterVisitor { + visitor(node: arkts.AstNode): arkts.AstNode { + this.processor.parsed(node); + node = this.visitEachChild(node); + return node; + } +} diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/transformers/ui-syntax-linter-visitor.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/transformers/ui-syntax-linter-visitor.ts new file mode 100644 index 0000000000000000000000000000000000000000..356304f88f8ce0dd457aaff3c92c7ac66e14d3d3 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/transformers/ui-syntax-linter-visitor.ts @@ -0,0 +1,23 @@ +/* + * 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 { AbstractVisitor } from '../../common/abstract-visitor'; +import { UISyntaxRuleProcessor } from '../processor'; + +export abstract class UISyntaxLinterVisitor extends AbstractVisitor { + constructor(protected processor: UISyntaxRuleProcessor) { + super(); + } +} diff --git a/ets1.2/arkui-plugins/ui-syntax-plugins/utils/index.ts b/ets1.2/arkui-plugins/ui-syntax-plugins/utils/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..87ba336a7ce55c0fcc12bce3a392b2b1d2dc0898 --- /dev/null +++ b/ets1.2/arkui-plugins/ui-syntax-plugins/utils/index.ts @@ -0,0 +1,200 @@ +/* + * 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 * as arkts from '@koalaui/libarkts'; +import * as fs from 'fs'; +import * as path from 'path'; + +export const PresetDecorators = { + BUILDER_PARAM: 'BuilderParam', + COMPONENT_V1: 'Component', + COMPONENT_V2: 'ComponentV2', + COMPUTED: 'Computed', + CONSUME: 'Consume', + CONSUMER: 'Consumer', + CUSTOM_DIALOG: 'CustomDialog', + ENTRY: 'Entry', + EVENT: 'Event', + PREVIEW: 'Preview', + STATE: 'State', + PARAM: 'Param', + PROP: 'Prop', + PROVIDE: 'Provide', + PROVIDER: 'Provider', + LINK: 'Link', + LOCAL: 'Local', + OBJECT_LINK: 'ObjectLink', + STORAGE_PROP: 'StorageProp', + STORAGE_LINK: 'StorageLink', + LOCAL_STORAGE_PROP: 'LocalStorageProp', + LOCAL_STORAGE_LINK: 'LocalStorageLink', + REQUIRE: 'Require', + REUSABLE_V1: 'Reusable', + REUSABLE_V2: 'ReusableV2', + OBSERVED_V1: 'Observed', + OBSERVED_V2: 'ObservedV2', + TYPE: 'Type', + WATCH: 'Watch', + BUILDER: 'Builder', + TRACK: 'Track', + TRACE: 'Trace', + ONCE: 'Once', + MONITOR: 'Monitor', + LOCAL_BUILDER: 'LocalBuilder', +}; + +const PUBLIC_PROPERTY_MODIFIERS: Number = 4; +const PROTECTED_PROPERTY_MODIFIERS: Number = 8; +const PRIVATE_PROPERTY_MODIFIERS: Number = 16; +export function getIdentifierName(node: arkts.AstNode): string { + if (!arkts.isIdentifier(node)) { + throw new Error(`Except a Identifier type!`); + } + return node.name; +} + +export function getAnnotationName(annotation: arkts.AnnotationUsage): string { + if (!annotation.expr) { + throw new Error(`The expr property does not exist!`); + } + return getIdentifierName(annotation.expr); +} + +export function getAnnotationUsage( + declaration: arkts.StructDeclaration, + annotationName: string, +): arkts.AnnotationUsage | undefined { + return declaration.definition.annotations.find( + (annotation) => + annotation.expr && + arkts.isIdentifier(annotation.expr) && + annotation.expr.name === annotationName, + ); +} + +export function getClassAnnotationUsage( + declaration: arkts.ClassDeclaration, + annotationName: string, +): arkts.AnnotationUsage | undefined { + if (!declaration.definition || !declaration.definition.annotations) { + return undefined; + } + return declaration.definition.annotations.find( + (annotation) => + annotation.expr && + ((arkts.isIdentifier(annotation.expr) && annotation.expr.name === annotationName) || + (arkts.isCallExpression(annotation.expr) && + arkts.isIdentifier(annotation.expr) && + annotation.expr.name === annotationName)) + ); +} + + + +export function getClassPropertyName(property: arkts.ClassProperty): string { + return getIdentifierName(property.key); +} + +export function getClassPropertyType(property: arkts.ClassProperty): string { + return property.typeAnnotation.dumpSrc(); +} + +export function getClassPropertyAnnotationNames( + property: arkts.ClassProperty, +): string[] { + return property.annotations.map((annotation) => + getAnnotationName(annotation), + ); +} + +export function isPublicClassProperty(property: arkts.ClassProperty): boolean { + // todo 使用接口实现 + return property.modifiers === PUBLIC_PROPERTY_MODIFIERS; +} + +export function isPrivateClassProperty(property: arkts.ClassProperty): boolean { + // todo 使用接口实现 + return property.modifiers === PRIVATE_PROPERTY_MODIFIERS; +} + +export function isProtectedlassProperty(property: arkts.ClassProperty): boolean { + // todo 使用接口实现 + return property.modifiers === PROTECTED_PROPERTY_MODIFIERS; +} + +export class MultiMap { + private readonly map: Map; + constructor() { + this.map = new Map(); + } + /** + * Add key-value pairs to MultiMap + * @param key key + * @param value value + */ + add(key: K, value: V): void { + if (!this.map.has(key)) { + this.map.set(key, []); + } + this.map.get(key)!.push(value); + } + + /** + * Gets all the values of the specified key + * @param key key + * @returns An array of values, which returns an empty array if the key does not exist + */ + get(key: K): V[] { + return this.map.get(key) || []; + } + + /** + * Check if the specified key exists in the MultiMap + * @param key key + * @returns Whether it exists + */ + has(key: K): boolean { + return this.map.has(key); + } +} + +interface ComponentJson { + name: string; + atomic?: boolean; + attrs: string[]; +} + +export function getContainerComponents(dirPath: string): Set { + const resultSet = new Set(); + const absolutePath = path.resolve(__dirname, dirPath); + + if (!fs.existsSync(absolutePath)) { + throw new Error(`Directory does not exist: ${absolutePath}`); + } + // Read all files in the directory + const files = fs.readdirSync(absolutePath); + + files.forEach(file => { + if (path.extname(file) === '.json') { + const filePath = path.join(absolutePath, file); + const fileContent = fs.readFileSync(filePath, 'utf-8'); + const componentJson: ComponentJson = JSON.parse(fileContent); + if ((!componentJson.atomic || componentJson.atomic !== true) && (componentJson.name)) { + resultSet.add(componentJson.name); + } + } + }); + return resultSet; +} \ No newline at end of file diff --git a/ets1.2/build-common/package.json b/ets1.2/build-common/package.json new file mode 100644 index 0000000000000000000000000000000000000000..0668d2a49fa558775681caaff70e97673dba4231 --- /dev/null +++ b/ets1.2/build-common/package.json @@ -0,0 +1,11 @@ +{ + "name": "@koalaui/build-common", + "version": "1.7.9+devel", + "description": "", + "files": [ + "tsconfig.json" + ], + "scripts": { + "compile:release": "" + } +} \ No newline at end of file diff --git a/ets1.2/build-common/tsconfig.json b/ets1.2/build-common/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..02ca836732ea922edcb061e64008364e67b8f1e9 --- /dev/null +++ b/ets1.2/build-common/tsconfig.json @@ -0,0 +1,17 @@ +{ + "compilerOptions": { + "target": "es2017", + "module": "ESNext", + "lib": ["ESNext", "ESNext.WeakRef"], + "moduleResolution": "node", + "composite": true, + "incremental": true, + "declarationMap": true, + "sourceMap": true, + "declaration": true, + "noEmitOnError": true, + "strict": true, + "skipLibCheck": true, + "removeComments": false + } +} diff --git a/ets1.2/common/empty.js b/ets1.2/common/empty.js new file mode 100644 index 0000000000000000000000000000000000000000..ac57d1240ec618f291f4624f135240eb8c6bde18 --- /dev/null +++ b/ets1.2/common/empty.js @@ -0,0 +1,15 @@ +/* + * 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. + */ + diff --git a/ets1.2/common/package.json b/ets1.2/common/package.json new file mode 100644 index 0000000000000000000000000000000000000000..0cab425a221789d624df2e5d55fb07d93c875ae9 --- /dev/null +++ b/ets1.2/common/package.json @@ -0,0 +1,45 @@ +{ + "name": "@koalaui/common", + "version": "1.7.9+devel", + "description": "", + "main": "build/lib/src/index.js", + "types": "./index.d.ts", + "files": [ + "build/lib/**/*.js", + "build/lib/**/*.d.ts", + "src/**/*" + ], + "exports": { + ".": "./build/lib/src/index.js" + }, + "typesVersions": { + "*": { + "*": [ + "build/lib/src/*", + "build/lib/typescript/*" + ] + } + }, + "scripts": { + "compile": "ets-tsc -b .", + "compile:release": "ets-tsc -b .", + "clean": "rimraf build", + "test": "mocha", + "test:coverage": "nyc mocha", + "build": "node ../../ui2abc/fast-arktsc --config ./ui2abcconfig.json --compiler ../tools/panda/arkts/ui2abc --link-name ./build/common.abc --simultaneous && PANDA_SDK_PATH=${PANDA_SDK_PATH:=../tools/panda/node_modules/@panda/sdk} ninja ${NINJA_OPTIONS} -f build/abc/build.ninja" + }, + "keywords": [], + "dependencies": { + "@koalaui/compat": "1.7.9+devel" + }, + "devDependencies": { + "@ohos/hypium": "1.0.6", + "@types/mocha": "^9.1.0", + "@typescript-eslint/eslint-plugin": "^5.20.0", + "@typescript-eslint/parser": "^5.20.0", + "eslint": "^8.13.0", + "eslint-plugin-unused-imports": "^2.0.0", + "mocha": "^9.2.2", + "source-map-support": "^0.5.21" + } +} \ No newline at end of file diff --git a/ets1.2/common/src/Finalization.ts b/ets1.2/common/src/Finalization.ts new file mode 100644 index 0000000000000000000000000000000000000000..2ba480ca2d549e5299bb8d71454f9c7b0294c57f --- /dev/null +++ b/ets1.2/common/src/Finalization.ts @@ -0,0 +1,40 @@ +/* + * Copyright (c) 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 { finalizerRegister as finalizerRegisterCompat, finalizerUnregister as finalizerUnregisterCompat, Thunk } from "@koalaui/compat" + +export { Thunk } from "@koalaui/compat" + +export function finalizerRegister(target: object, thunk: Thunk) { + finalizerRegisterCompat(target, thunk) +} + +export function finalizerRegisterWithCleaner(target: object, cleaner: () => void) { + finalizerRegisterCompat(target, new CleanerThunk(cleaner)) +} + +export function finalizerUnregister(target: object) { + finalizerUnregisterCompat(target) +} + +class CleanerThunk implements Thunk { + private cleaner: () => void + constructor(cleaner: () => void) { + this.cleaner = cleaner + } + clean() { + this.cleaner() + } +} diff --git a/ets1.2/common/src/index.ts b/ets1.2/common/src/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..0533296ef8e6b1a150114df1a463e6d371fec255 --- /dev/null +++ b/ets1.2/common/src/index.ts @@ -0,0 +1,55 @@ +/* + * 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. + */ + +export { + int8, uint8, + int32, int32toFloat32, int32toFloat64, int32to64, + uint32, + int64, int64toFloat32, int64toFloat64, int64to32, + uint64, + float32, float32to64, float32toInt32, float32toInt64, + float64, float64to32, float64toInt32, float64toInt64, + asArray, + asFloat64, + Array_from_set, + AtomicRef, + CustomTextDecoder, + CustomTextEncoder, + className, lcClassName, + functionOverValue, + Observed, + Observable, + ObservableHandler, + observableProxy, + observableProxyArray, + TrackableProperties, + trackableProperties, + isFunction, + propDeepCopy, + refEqual, + int8Array, + errorAsString, + unsafeCast, + CoroutineLocalValue, + scheduleCoroutine, + memoryStats, + launchJob +} from "@koalaui/compat" +export { clamp, lerp, modulo, parseNumber, isFiniteNumber, getDistancePx } from "./math" +export { hashCodeFromString } from "./stringUtils" +export * from "./Finalization" +export { SHA1Hash, createSha1 } from "./sha1" +export { UniqueId } from "./uniqueId" +export * from "./koalaKey" diff --git a/ets1.2/common/src/koalaKey.ts b/ets1.2/common/src/koalaKey.ts new file mode 100644 index 0000000000000000000000000000000000000000..109a306d5cf637dafd7ca104f6043f158f1bb176 --- /dev/null +++ b/ets1.2/common/src/koalaKey.ts @@ -0,0 +1,30 @@ +/* + * 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 { int32 } from "@koalaui/compat" + +export type KoalaCallsiteKey = int32 + +export class KoalaCallsiteKeys { + static readonly empty: KoalaCallsiteKey = 0 + + static combine(key1: KoalaCallsiteKey, key2: KoalaCallsiteKey): KoalaCallsiteKey { + return key1 + key2 + } + + static asString(key: KoalaCallsiteKey): string { + return key.toString(16) + } +} diff --git a/ets1.2/common/src/math.ts b/ets1.2/common/src/math.ts new file mode 100644 index 0000000000000000000000000000000000000000..95bf2b8bd4925d5c62451a2acd56dc7f1a672354 --- /dev/null +++ b/ets1.2/common/src/math.ts @@ -0,0 +1,97 @@ +/* + * 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 { asFloat64, float64 } from "@koalaui/compat" + +/** + * Computes the linear interpolation between `source` and `target` based on `weight`. + * + * @param weight - interpolation factor in the range [0..1] + * @param source - a value corresponding to weight 0 + * @param target - a value corresponding to weight 1 + * @returns interpolated value + */ +export function lerp(weight: float64, source: float64, target: float64): float64 { + return source * (1.0 - weight) + target * weight +} + +/** + * Clamps a {@link value} within the specified range. + * + * @param value - a value to clamp + * @param min - the lower boundary of the range + * @param max - the upper boundary of the range + * @returns `min` if `value` is less than `min`, + * `max` if `value` is greater than `max`, + * `value` otherwise + */ +export function clamp(value: float64, min: float64, max: float64): float64 { + return value <= min ? min : value >= max ? max : value +} + +/** + * Calculates the difference between the argument and + * the largest (closest to positive infinity) integer value + * that is less than or equal to the argument. + * + * @param value a floating-point value to process + * @returns a floor modulus of the given value in the range [0..1) + */ +export function modulo(value: float64): float64 { + // The casts below are needed since floor returns double in ArkTS + const modulo: float64 = value - Math.floor(value) + return (modulo < 1.0) ? modulo : 0.0 +} + +/** + * @param str a string to parse + * @param name a name for error message + * @param verify whether to verify parsing validity + * @returns a floating-point number + * @throws Error if `str` cannot be parsed + */ +export function parseNumber(str: string, name: string = "number", verify: boolean = false): float64 { + if (str != "") { // do not parse empty string to 0 + // ArkTS does not support NaN, isNaN, parseFloat + const value = asFloat64(str) + if (verify) { + const reverseStr = value.toString() + if (reverseStr !== undefined && reverseStr?.length == str.length && reverseStr == str) { + return value + } + } + else { + return value + } + } + throw new Error(`cannot parse ${name}: "${str}"`) +} + +/** + * An ArkTS-compliant replacement for {@link isFinite}. + */ +export function isFiniteNumber(number: float64): boolean { + // With Node.js: + // isFiniteNumber(Number.NEGATIVE_INFINITY) == false + // isFiniteNumber(Number.POSITIVE_INFINITY) == false + // isFiniteNumber(NaN) == false + return number >= Number.MIN_SAFE_INTEGER && number <= Number.MAX_SAFE_INTEGER +} + +export function getDistancePx(startX: float64, startY: float64, endX: float64, endY: float64): float64 { + const cathetA = Math.abs(endX - startX) + const cathetB = Math.abs(endY - startY) + return Math.sqrt(cathetA * cathetA + cathetB * cathetB) as float64 +} \ No newline at end of file diff --git a/ets1.2/common/src/sha1.ts b/ets1.2/common/src/sha1.ts new file mode 100644 index 0000000000000000000000000000000000000000..ad4ec9bfdec31d858431071cd89cc98503d96402 --- /dev/null +++ b/ets1.2/common/src/sha1.ts @@ -0,0 +1,354 @@ +/* + * 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 { CustomTextDecoder, float64toInt32, int64to32 } from "@koalaui/compat" +import { int32 } from "@koalaui/compat" + +const K = [ + 0x5a827999 | 0, + 0x6ed9eba1 | 0, + 0x8f1bbcdc | 0, + 0xca62c1d6 | 0, +] + +const inputBytes = 64 +const inputWords = inputBytes / 4 +const highIndex = inputWords - 2 +const lowIndex = inputWords - 1 +const workWords = 80 +const allocBytes = 80 +const allocWords = allocBytes / 4 +const allocTotal = allocBytes * 100 + +export function createSha1(): SHA1Hash { + return new SHA1Hash() +} + +export class SHA1Hash { + private A = 0x67452301 | 0 + private B = 0xefcdab89 | 0 + private C = 0x98badcfe | 0 + private D = 0x10325476 | 0 + private E = 0xc3d2e1f0 | 0 + private readonly _byte: Uint8Array + private readonly _word: Int32Array + private _size = 0 + private _sp = 0 // surrogate pair + + constructor() { + if (!sharedBuffer || sharedOffset >= allocTotal) { + sharedBuffer = new ArrayBuffer(allocTotal) + sharedOffset = 0 + } + + this._byte = new Uint8Array(sharedBuffer, sharedOffset, allocBytes) + this._word = new Int32Array(sharedBuffer, sharedOffset, allocWords) + sharedOffset += allocBytes + } + + updateString(data: string, encoding?: string): SHA1Hash { + return this._utf8(data) + } + updateInt32(data: int32): SHA1Hash { + const buffer = new Int32Array(1) + buffer[0] = data + return this.update(buffer) + } + + update(data: Int32Array | Float32Array | Uint32Array | Uint8Array): SHA1Hash { + if (data == null) { + throw new TypeError("SHA1Hash expected non-null data: ") + } + + let byteOffset: int32 = 0 + let length: int32 = 0 + let buffer: ArrayBufferLike | undefined = undefined + + // Improve: an attempt to wrie this in a generic form causes + // es2panda to segfault. + let BYTES_PER_ELEMENT = 4 + if (data instanceof Int32Array) { + byteOffset = float64toInt32(data.byteOffset) + length = float64toInt32(data.byteLength) + buffer = data.buffer + } else if (data instanceof Uint32Array) { + byteOffset = float64toInt32(data.byteOffset) + length = float64toInt32(data.byteLength) + buffer = data.buffer + } else if (data instanceof Float32Array) { + byteOffset = float64toInt32(data.byteOffset) + length = float64toInt32(data.byteLength) + buffer = data.buffer + } else if (data instanceof Uint8Array) { + byteOffset = float64toInt32(data.byteOffset) + length = float64toInt32(data.byteLength) + buffer = data.buffer + BYTES_PER_ELEMENT = 1 + } + + let blocks: int32 = (length / inputBytes) | 0 + let offset: int32 = 0 + + // longer than 1 block + if ((blocks != 0) && !(byteOffset & 3) && !(this._size % inputBytes)) { + const block = new Int32Array(buffer!, byteOffset, blocks * inputWords) + while (blocks--) { + this._int32(block, offset >> 2) + offset += inputBytes + } + this._size += offset + } + + // data: TypedArray | DataView + if ((BYTES_PER_ELEMENT != 1) && buffer != undefined) { + const rest = new Uint8Array(buffer, byteOffset + offset, length - offset) + return this._uint8(rest) + } + + // no more bytes + if (offset == length) return this + + return this._uint8(new Uint8Array(buffer!), offset) + } + + private _uint8(data: Uint8Array, offset?: int32): SHA1Hash { + const _byte = this._byte + const _word = this._word + const length = data.length + offset = (offset ?? 0) | 0 + + while (offset < length) { + const start = this._size % inputBytes + let index = start + + while (offset < length && index < inputBytes) { + _byte[index++] = data[offset++] + } + + if (index >= inputBytes) { + this._int32(_word) + } + + this._size += index - start + } + + return this + } + + private _utf8(text: string): SHA1Hash { + const _byte = this._byte + const _word = this._word + const length = text.length + let surrogate = this._sp + + for (let offset = 0; offset < length; ) { + const start = this._size % inputBytes + let index = start + + while (offset < length && index < inputBytes) { + let code = float64toInt32(text.charCodeAt(offset++)) | 0 + if (code < 0x80) { + // ASCII characters + _byte[index++] = code + } else if (code < 0x800) { + // 2 bytes + _byte[index++] = 0xC0 | (code >>> 6) + _byte[index++] = 0x80 | (code & 0x3F) + } else if (code < 0xD800 || code > 0xDFFF) { + // 3 bytes + _byte[index++] = 0xE0 | (code >>> 12) + _byte[index++] = 0x80 | ((code >>> 6) & 0x3F) + _byte[index++] = 0x80 | (code & 0x3F) + } else if (surrogate) { + // 4 bytes - surrogate pair + code = ((surrogate & 0x3FF) << 10) + (code & 0x3FF) + 0x10000 + _byte[index++] = 0xF0 | (code >>> 18) + _byte[index++] = 0x80 | ((code >>> 12) & 0x3F) + _byte[index++] = 0x80 | ((code >>> 6) & 0x3F) + _byte[index++] = 0x80 | (code & 0x3F) + surrogate = 0 + } else { + surrogate = int64to32(code) + } + } + + if (index >= inputBytes) { + this._int32(_word) + _word[0] = _word[inputWords] + } + + this._size += index - start + } + + this._sp = surrogate + return this + } + + private _int32(data: Int32Array, offset?: int32): void { + let A = this.A + let B = this.B + let C = this.C + let D = this.D + let E = this.E + let i = 0 + offset = (offset ?? 0) | 0 + + while (i < inputWords) { + W[i++] = swap32(float64toInt32(data[offset!++])) + } + + for (i = inputWords; i < workWords; i++) { + W[i] = rotate1(float64toInt32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16])) + } + + for (i = 0; i < workWords; i++) { + const S = (i / 20) | 0 + const T = float64toInt32((rotate5(A) + ft(S, B, C, D) + E + W[i] + K[S]) | 0) + E = D + D = C + C = rotate30(B) + B = A + A = T + } + + this.A = (A + this.A) | 0 + this.B = (B + this.B) | 0 + this.C = (C + this.C) | 0 + this.D = (D + this.D) | 0 + this.E = (E + this.E) | 0 + } + + // digest(): Uint8Array + // digest(encoding: string): string + digest(encoding?: string): Uint8Array | string { + const _byte = this._byte + const _word = this._word + let i = (this._size % inputBytes) | 0 + _byte[i++] = 0x80 + + // pad 0 for current word + while (i & 3) { + _byte[i++] = 0 + } + i >>= 2 + + if (i > highIndex) { + while (i < inputWords) { + _word[i++] = 0 + } + i = 0 + this._int32(_word) + } + + // pad 0 for rest words + while (i < inputWords) { + _word[i++] = 0 + } + + // input size + const bits64: int32 = this._size * 8 + const low32: int32 = float64toInt32((bits64 & 0xffffffff) >>> 0) + const high32: int32 = float64toInt32((bits64 - low32) / 0x100000000) + if (high32) _word[highIndex] = swap32(high32) + if (low32) _word[lowIndex] = swap32(low32) + + this._int32(_word) + + return (encoding === "hex") ? this._hex() : this._bin() + } + + private _hex(): string { + let A = this.A + let B = this.B + let C = this.C + let D = this.D + let E = this.E + + return hex32Str(A, B, C, D, E) + } + + private _bin(): Uint8Array { + let A = this.A + let B = this.B + let C = this.C + let D = this.D + let E = this.E + const _byte = this._byte + const _word = this._word + + _word[0] = swap32(A) + _word[1] = swap32(B) + _word[2] = swap32(C) + _word[3] = swap32(D) + _word[4] = swap32(E) + + return _byte.slice(0, 20) + } +} + +type NS = (num: int32) => string +type NN = (num: int32) => int32 + +const W = new Int32Array(workWords) + +let sharedBuffer: ArrayBuffer +let sharedOffset: int32 = 0 + +const swapLE: NN = ((c:int32):int32 => (((c << 24) & 0xff000000) | ((c << 8) & 0xff0000) | ((c >> 8) & 0xff00) | ((c >> 24) & 0xff))) +const swapBE: NN = ((c:int32):int32 => c) +const swap32: NN = isBE() ? swapBE : swapLE +const rotate1: NN = (num: int32): int32 => (num << 1) | (num >>> 31) +const rotate5: NN = (num: int32): int32 => (num << 5) | (num >>> 27) +const rotate30: NN = (num: int32): int32 => (num << 30) | (num >>> 2) + +function isBE(): boolean { + let a16 = new Uint16Array(1) + a16[0] = 0xFEFF + let a8 = new Uint8Array(a16.buffer) + return a8[0] == 0xFE // BOM +} + + +function ft(s: int32, b: int32, c: int32, d: int32) { + if (s == 0) return (b & c) | ((~b) & d) + if (s == 2) return (b & c) | (b & d) | (c & d) + return b ^ c ^ d +} + +const hex32Decoder = new CustomTextDecoder() +const hex32DecodeBuffer = new Uint8Array(40) +function hex32Str(A: int32, B: int32, C: int32, D: int32, E: int32): string { + writeIntAsHexUTF8(A, hex32DecodeBuffer, 0) + writeIntAsHexUTF8(B, hex32DecodeBuffer, 8) + writeIntAsHexUTF8(C, hex32DecodeBuffer, 16) + writeIntAsHexUTF8(D, hex32DecodeBuffer, 24) + writeIntAsHexUTF8(E, hex32DecodeBuffer, 32) + return hex32Decoder.decode(hex32DecodeBuffer) +} + +function writeIntAsHexUTF8(value: int32, buffer: Uint8Array, byteOffset: int32) { + buffer[byteOffset++] = nibbleToHexCode((value >> 28) & 0xF) + buffer[byteOffset++] = nibbleToHexCode((value >> 24) & 0xF) + buffer[byteOffset++] = nibbleToHexCode((value >> 20) & 0xF) + buffer[byteOffset++] = nibbleToHexCode((value >> 16) & 0xF) + buffer[byteOffset++] = nibbleToHexCode((value >> 12) & 0xF) + buffer[byteOffset++] = nibbleToHexCode((value >> 8 ) & 0xF) + buffer[byteOffset++] = nibbleToHexCode((value >> 4 ) & 0xF) + buffer[byteOffset++] = nibbleToHexCode((value >> 0 ) & 0xF) +} + +function nibbleToHexCode(nibble: int32) { + return nibble > 9 ? nibble + 87 : nibble + 48 +} diff --git a/ets1.2/common/src/stringUtils.ts b/ets1.2/common/src/stringUtils.ts new file mode 100644 index 0000000000000000000000000000000000000000..439460fe08088b7b9ee27de5e2716194b99b490e --- /dev/null +++ b/ets1.2/common/src/stringUtils.ts @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { float64toInt32, int32, int64to32 } from "@koalaui/compat" + + +/** + * Computes a hash code from the string {@link value}. + */ +export function hashCodeFromString(value: string): int32 { + let hash = 5381 + for(let i = 0; i < value.length; i++) { + hash = int64to32((hash * 33) ^ float64toInt32(value.charCodeAt(i))) + } + return hash +} diff --git a/ets1.2/common/src/uniqueId.ts b/ets1.2/common/src/uniqueId.ts new file mode 100644 index 0000000000000000000000000000000000000000..8087362c32705b3a3d110c9f8a1bb5721b4f8594 --- /dev/null +++ b/ets1.2/common/src/uniqueId.ts @@ -0,0 +1,62 @@ +/* + * 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 { float64toInt32, int32 } from "@koalaui/compat" +import { createSha1 } from "./sha1"; + +export class UniqueId { + private sha = createSha1() + + public addString(data: string): UniqueId { + this.sha.updateString(data) + return this + } + + public addI32(data: int32): UniqueId { + this.sha.updateInt32(data) + return this + } + + public addF32Array(data: Float32Array): UniqueId { + this.sha.update(data) + return this + } + + public addI32Array(data: Int32Array): UniqueId { + this.sha.update(data) + return this + } + + public addU32Array(data: Uint32Array): UniqueId { + this.sha.update(data) + return this + } + + public addU8Array(data: Uint8Array): UniqueId { + this.sha.update(data) + return this + } + + public addPtr(data: Uint32Array | number): UniqueId { + if (data instanceof Uint32Array) { + return this.addU32Array(data) + } + return this.addI32(float64toInt32(data)) + } + + public compute(): string { + return this.sha.digest("hex") as string + } +} diff --git a/ets1.2/common/tsconfig.json b/ets1.2/common/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..443ddd555f10cccdf26ec4a7c46345652c18b6ca --- /dev/null +++ b/ets1.2/common/tsconfig.json @@ -0,0 +1,16 @@ +{ + "extends": "@koalaui/build-common/tsconfig.json", + "compilerOptions": { + "baseUrl": ".", + "outDir": "build/lib", + "module": "CommonJS", + "paths": { + "@koalaui/compat": ["../compat/typescript"] + } + }, + "include": ["./src/**/*"], + "exclude": ["./src/ohos"], + "references": [ + {"path": "../compat"} + ] +} diff --git a/ets1.2/common/ui2abcconfig.json b/ets1.2/common/ui2abcconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..dcacec76b99a9d7f60c6f2f3a3b18c1a87480bea --- /dev/null +++ b/ets1.2/common/ui2abcconfig.json @@ -0,0 +1,14 @@ +{ + "compilerOptions": { + "package": "@koalaui/common", + "outDir": "build/abc", + "baseUrl": "./src", + "paths": { + "@koalaui/compat": ["../../compat/src/arkts"] + } + }, + "include": ["src/**/*.ts"], + "references": [ + { "path": "../compat" } + ] +} diff --git a/ets1.2/compat/package.json b/ets1.2/compat/package.json new file mode 100644 index 0000000000000000000000000000000000000000..667b7cb0e7204b8a50b60012c6094583b6865432 --- /dev/null +++ b/ets1.2/compat/package.json @@ -0,0 +1,39 @@ +{ + "name": "@koalaui/compat", + "version": "1.7.9+devel", + "description": "", + "main": "build/src/index.js", + "types": "build/src/index.d.ts", + "files": [ + "build/src/**/*.js", + "build/src/**/*.d.ts", + "src/**/*" + ], + "imports": { + "#platform": { + "ark": "./build/src/ohos/index.js", + "ios": "./build/src/typescript/index.js", + "browser": "./build/src/typescript/index.js", + "node": "./build/src/typescript/index.js", + "default": "./build/src/typescript/index.js" + } + }, + "exports": { + ".": "./build/src/index.js" + }, + "scripts": { + "clean": "rimraf build dist", + "compile": "ets-tsc -b .", + "compile:release": "ets-tsc -b .", + "build": "node ../../ui2abc/fast-arktsc --config ./ui2abcconfig.json --compiler ../tools/panda/arkts/ui2abc --link-name ./build/compat.abc --simultaneous && PANDA_SDK_PATH=${PANDA_SDK_PATH:=../tools/panda/node_modules/@panda/sdk} ninja ${NINJA_OPTIONS} -f build/abc/build.ninja" + }, + "keywords": [], + "dependencies": {}, + "devDependencies": { + "@typescript-eslint/eslint-plugin": "^5.20.0", + "@typescript-eslint/parser": "^5.20.0", + "eslint": "^8.13.0", + "eslint-plugin-unused-imports": "^2.0.0", + "source-map-support": "^0.5.21" + } +} \ No newline at end of file diff --git a/ets1.2/compat/src/arkts/array.ts b/ets1.2/compat/src/arkts/array.ts new file mode 100644 index 0000000000000000000000000000000000000000..e6d3eaf2b1dcf0e71bd6ede7241f911cd331c8fa --- /dev/null +++ b/ets1.2/compat/src/arkts/array.ts @@ -0,0 +1,59 @@ +/* + * 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 { float64, int32, int8 } from "./types" + +// Improve: this can be a performance disaster +// just wait for the library to provide the proper functionality. +export function asArray(value: T[]): Array { + return Array.of(...value) +} + +// Improve: this can be a performance disaster +// just wait for the library to provide the proper functionality. +export function Array_from_set(set: Set): Array { + const array = new Array() // to avoid creation of undefined content + const values = set.values() + for (let it = values.next(); it.done != true; it = values.next()) { + array.push(it.value as T) + } + return array +} + +// Improve: this can be a performance disaster +// just wait for the library to provide the proper functionality. +export function Array_from_int32(data: Int32Array): number[] { + const result: number[] = [] + for (let i: int32 = 0; i < data.length; i++) { + result[i] = data.at(i) as number + } + return result +} + +// Improve: this can be a performance disaster +// just wait for the library to provide the proper functionality. +export function Array_from_number(data: float64[]): Array { + const result = new Array(data.length) + for (let i: int32 = 0; i < data.length; i++) { + result[i] = data[i] + } + return result +} + +export function int8Array(size: int32): FixedArray { + const array: FixedArray = new int8[size] + return array +} + diff --git a/ets1.2/compat/src/arkts/atomic.ts b/ets1.2/compat/src/arkts/atomic.ts new file mode 100644 index 0000000000000000000000000000000000000000..bbe71d19e2eb31df68cb7e48385699260b0727c0 --- /dev/null +++ b/ets1.2/compat/src/arkts/atomic.ts @@ -0,0 +1,41 @@ +/* + * 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. + */ + +/** + * A reference that may be updated atomically. + */ +export class AtomicRef { + value: Value + + /** + * Creates a new reference object with the given initial value. + * @param value - the new value + */ + constructor(value: Value) { + this.value = value + } + + /** + * Atomically sets the reference value to the given value and returns the previous one. + * @param value - the new value + * @returns the previous value + */ + getAndSet(value: Value): Value { + // Improve: replace with the implementation from ArkTS language when it is ready + const result = this.value + this.value = value + return result + } +} diff --git a/ets1.2/compat/src/arkts/finalization.ts b/ets1.2/compat/src/arkts/finalization.ts new file mode 100644 index 0000000000000000000000000000000000000000..021bc1d43f17c58b07110041d506202183097f1f --- /dev/null +++ b/ets1.2/compat/src/arkts/finalization.ts @@ -0,0 +1,31 @@ + +/* + * Copyright (c) 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. + */ + +export interface Thunk { + clean(): void +} + +const registry = new FinalizationRegistry((thunk: Thunk) => { + thunk.clean() +}) + +export function finalizerRegister(target: Object, thunk: Object) { + registry.register(target, thunk as Thunk) +} + +export function finalizerUnregister(target: Object) { + registry.unregister(target) +} diff --git a/ets1.2/compat/src/arkts/index.ts b/ets1.2/compat/src/arkts/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..610fafc3ffb8b55ef552769eb184e54d1eec36e1 --- /dev/null +++ b/ets1.2/compat/src/arkts/index.ts @@ -0,0 +1,27 @@ +/* + * 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. + */ + +export * from "./array" +export * from "./atomic" +export * from "./primitive" +export * from "./finalization" +export * from "./performance" +export * from "./prop-deep-copy" +export * from "./observable" +export * from "./reflection" +export * from "./strings" +export * from "./ts-reflection" +export * from "./types" +export * from "./utils" diff --git a/ets1.2/compat/src/arkts/observable.ts b/ets1.2/compat/src/arkts/observable.ts new file mode 100644 index 0000000000000000000000000000000000000000..b9b3038124db9918ae8f10199ca2fe20ae983d24 --- /dev/null +++ b/ets1.2/compat/src/arkts/observable.ts @@ -0,0 +1,1255 @@ +/* + * 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. + */ + +export function getObservableTarget(proxy0: Object): Object { + try { + // do not use proxy for own observables + if (proxy0 instanceof ObservableArray + || proxy0 instanceof ObservableDate + || proxy0 instanceof ObservableMap + || proxy0 instanceof ObservableSet ) { + return proxy0 + } + return (proxy.Proxy.tryGetTarget(proxy0) as Object|undefined|null) ?? proxy0 + } catch (error) { + return proxy0 + } +} + +/** + * Data class decorator that makes all child fields trackable. + */ +export function Observed() { + throw new Error("TypeScript class decorators are not supported yet") +} + +/** @internal */ +export interface Observable { + /** + * It is called when the observable value is accessed. + * @param propertyName - Optional name of the accessed property. + * Should be provided when tracking individual properties. + * */ + onAccess(propertyName?: string): void + /** + * It is called when the observable value is modified. + * @param propertyName - Optional name of the modified property. + * Should be provided when tracking individual properties. + * */ + onModify(propertyName?: string): void +} + +/** @internal */ +export class ObservableHandler implements Observable { + private static handlers: WeakMap | undefined = undefined + + private parents = new Set() + private children = new Map() + + private readonly observables = new Set() + private _modified = false + + readonly observed: boolean + constructor(parent?: ObservableHandler, observed: boolean = false) { + this.observed = observed + if (parent) this.addParent(parent) + } + + onAccess(propertyName?: string): void { + if (this.observables.size > 0) { + const it = this.observables.keys() + while (true) { + const result = it.next() + if (result.done) break + result.value?.onAccess(propertyName) + } + } + } + + onModify(propertyName?: string): void { + const set = new Set() + this.collect(true, set) + set.forEach((handler: ObservableHandler) => { + handler._modified = true + if (handler.observables.size > 0) { + const it = handler.observables.keys() + while (true) { + const result = it.next() + if (result.done) break + result.value?.onModify(propertyName) + } + } + }) + } + + static dropModified(value: Value): boolean { + const handler = ObservableHandler.findIfObject(value) + if (handler === undefined) return false + const result = handler._modified + handler._modified = false + return result + } + + /** Adds the specified `observable` to the handler corresponding to the given `value`. */ + static attach(value: Value, observable: Observable): void { + const handler = ObservableHandler.findIfObject(value) + if (handler) handler.observables.add(observable) + } + + /** Deletes the specified `observable` from the handler corresponding to the given `value`. */ + static detach(value: Value, observable: Observable): void { + const handler = ObservableHandler.findIfObject(value) + if (handler) handler.observables.delete(observable) + } + + /** @returns the handler corresponding to the given `value` if it was installed */ + private static findIfObject(value: Value): ObservableHandler | undefined { + const handlers = ObservableHandler.handlers + return handlers !== undefined && value instanceof Object ? handlers.get(getObservableTarget(value as Object)) : undefined + } + + /** + * @param value - any non-null object including arrays + * @returns an observable handler or `undefined` if it is not installed + */ + static find(value: Object): ObservableHandler | undefined { + const handlers = ObservableHandler.handlers + return handlers ? handlers.get(getObservableTarget(value)) : undefined + } + + /** + * @param value - any non-null object including arrays + * @param observable - a handler to install on this object + * @throws an error if observable handler cannot be installed + */ + static installOn(value: Object, observable?: ObservableHandler): void { + let handlers = ObservableHandler.handlers + if (handlers === undefined) { + handlers = new WeakMap() + ObservableHandler.handlers = handlers + } + observable + ? handlers.set(getObservableTarget(value), observable) + : handlers.delete(getObservableTarget(value)) + } + + addParent(parent: ObservableHandler) { + const count = parent.children.get(this) ?? 0 + parent.children.set(this, count + 1) + this.parents.add(parent) + } + + hasChild(child: ObservableHandler): boolean { + return this.children.has(child) + } + + removeParent(parent: ObservableHandler) { + const count = parent.children.get(this) ?? 0 + if (count > 1) { + parent.children.set(this, count - 1) + } + else if (count == 1) { + parent.children.delete(this) + this.parents.delete(parent) + } + } + + removeChild(value: Value) { + const child = ObservableHandler.findIfObject(value) + if (child) child.removeParent(this) + } + + private collect(all: boolean, guards: Set) { + if (guards.has(this)) return guards // already collected + guards.add(this) // handler is already guarded + this.parents.forEach((handler: ObservableHandler) => { handler.collect(all, guards) }) + if (all) this.children.forEach((_count: number, handler: ObservableHandler) => { handler.collect(all, guards) }) + return guards + } + + static contains(observable: ObservableHandler, guards?: Set) { + if (observable.observed) return true + if (guards === undefined) guards = new Set() // create if needed + else if (guards!.has(observable)) return false // already checked + guards.add(observable) // handler is already guarded + for (const it of observable.parents.keys()) { + if (ObservableHandler.contains(it, guards)) return true + } + return false + } +} + +/** @internal */ +export function observableProxyArray(...value: Value[]): Array { + return observableProxy(Array.of(...value)) +} + +/** @internal */ +export function observableProxy(value: Value, parent?: ObservableHandler, observed?: boolean, strict: boolean = true): Value { + if (value instanceof ObservableHandler) return value as Value // do not proxy a marker itself + if (value == null || !(value instanceof Object)) return value as Value // only non-null object can be observable + const observable = ObservableHandler.find(value as Object) + if (observable) { + if (parent) { + if (strict) observable.addParent(parent) + if (observed === undefined) observed = ObservableHandler.contains(parent) + } + if (observed) { + if (value instanceof Array) { + for (let index = 0; index < value.length; index++) { + value[index] = observableProxy(value[index], observable, observed, false) + } + } else { + // Improve: proxy fields of the given object + } + } + return value as Value + } + if (value instanceof Array) { + return ObservableArray(value, parent, observed) as Value + } else if (value instanceof Map) { + return ObservableMap(value, parent, observed) as Value + } else if (value instanceof Set) { + return ObservableSet(value, parent, observed) as Value + } else if (value instanceof Date) { + return ObservableDate(value, parent, observed) as Value + } + + // Improve: Fatal error on using proxy with generic types + // see: panda issue #26492 + + const valueType = Type.of(value) + if (valueType instanceof ClassType && !(value instanceof BaseEnum)) { + const isObservable = isObservedV1Class(value as Object) + if (!hasTrackableProperties(value as Object) && !isObservable) { + return value as Value + } + if (valueType.hasEmptyConstructor()) { + const result = proxy.Proxy.create(value as Object, new CustomProxyHandler(isObservable)) as Value + ObservableHandler.installOn(result as Object, new ObservableHandler(parent)) + return result + } else { + throw new Error(`Class '${valueType.getName()}' must contain a default constructor`) + } + } + + return value as Value +} + +class CustomProxyHandler extends proxy.DefaultProxyHandler { + private readonly isObservable: boolean + + constructor(isObservable: boolean) { + super(); + this.isObservable = isObservable + } + + override get(target: T, name: string): Any { + const value = super.get(target, name) + const targetHandler = ObservableHandler.find(target) + if (targetHandler && this.isObservable) { + const valueHandler = ObservableHandler.find(value as Object) + if (valueHandler && !targetHandler.hasChild(valueHandler)) { + valueHandler.addParent(targetHandler) + } + } + targetHandler?.onAccess(name) + return value + } + + override set(target: T, name: string, value: Any): boolean { + const observable = ObservableHandler.find(target) + if (observable) { + observable.onModify(name) + observable.removeChild(super.get(target, name)) + value = observableProxy(value, observable, ObservableHandler.contains(observable)) + } + return super.set(target, name, value) + } +} + +function proxyChildrenOnly(array: T[], parent: ObservableHandler, observed?: boolean) { + for (let i = 0; i < array.length; i++) { + if (observed === undefined) observed = ObservableHandler.contains(parent) + array[i] = observableProxy(array[i], parent, observed) + } +} + +class ObservableArray extends Array { + static $_invoke(array: Array, parent?: ObservableHandler, observed?: boolean): Array { + return new ObservableArray(array, parent, observed); + } + + constructor(array: Array, parent?: ObservableHandler, observed?: boolean) { + super(array.length) + const handler = new ObservableHandler(parent) + for (let i = 0; i < array.length; i++) { + if (observed === undefined) observed = ObservableHandler.contains(handler) + super.$_set(i, observableProxy(array[i], handler, observed)) + } + ObservableHandler.installOn(this, handler) + } + + private get handler(): ObservableHandler | undefined { + return ObservableHandler.find(this) + } + + override get length(): int { + this.handler?.onAccess() + return super.length + } + + override set length(length: int) { + this.handler?.onModify() + super.length = length + } + + override at(index: int): T | undefined { + this.handler?.onAccess() + return super.at(index) + } + + override $_get(index: int): T { + this.handler?.onAccess() + return super.$_get(index) + } + + override $_set(index: int, value: T): void { + const handler = this.handler + if (handler) { + handler.onModify() + handler.removeChild(super.$_get(index)) + value = observableProxy(value, handler) + } + super.$_set(index, value) + } + + override copyWithin(target: int, start: int, end: int): this { + this.handler?.onModify() + super.copyWithin(target, start, end) + return this + } + + override fill(value: T, start: int, end: int): this { + const handler = this.handler + if (handler) { + handler.onModify() + value = observableProxy(value, handler) + } + super.fill(value, start, end) + return this + } + + override pop(): T | undefined { + const handler = this.handler + handler?.onModify() + const result = super.pop() + if (result) handler?.removeChild(result) + return result + } + + override pushArray(...items: T[]): number { + const handler = this.handler + if (handler) { + handler.onModify() + proxyChildrenOnly(items, handler) + } + return super.pushArray(...items) + } + + override pushOne(value: T): number { + const handler = this.handler + if (handler) { + handler.onModify() + value = observableProxy(value, handler) + } + return super.pushOne(value) + } + + override pushECMA(...items: T[]): number { + const handler = this.handler + if (handler) { + handler.onModify() + proxyChildrenOnly(items, handler) + } + return super.pushECMA(...items) + } + + override reverse(): this { + this.handler?.onModify() + super.reverse() + return this + } + + override shift(): T | undefined { + const handler = this.handler + handler?.onModify() + const result = super.shift() + if (result) handler?.removeChild(result) + return result + } + + override sort(comparator?: (a: T, b: T) => number): this { + this.handler?.onModify() + super.sort(comparator) + return this + } + + override splice(index: int, count: int, ...items: T[]): Array { + const handler = this.handler + if (handler) { + handler.onModify() + proxyChildrenOnly(items, handler) + const result = super.splice(index, count, ...items) + for (let i = 0; i < result.length; i++) { + handler.removeChild(result[i]) + } + return result + } + return super.splice(index, count, ...items) + } + + override unshift(...items: T[]): number { + const handler = this.handler + if (handler) { + handler.onModify() + proxyChildrenOnly(items, handler) + } + return super.unshift(...items) + } + + override keys(): IterableIterator { + this.handler?.onAccess() + return super.keys() + } + + // === methods with uncompatible implementation === + + override filter(predicate: (value: T, index: number, array: Array) => boolean): Array { + this.handler?.onAccess() + return super.filter(predicate) + } + + override flat(depth: int): Array { + this.handler?.onAccess() + return super.flat(depth) + } + + override flatMap(fn: (v: T, k: number, arr: Array) => U): Array { + this.handler?.onAccess() + return super.flatMap(fn) + } + + // === methods common among all arrays === + + override concat(...items: FixedArray>): Array { + this.handler?.onAccess() + return super.concat(...items) + } + + override find(predicate: (value: T, index: number, array: Array) => boolean): T | undefined { + this.handler?.onAccess() + return super.find(predicate) + } + + override findIndex(predicate: (value: T, index: number, array: Array) => boolean): number { + this.handler?.onAccess() + return super.findIndex(predicate) + } + + override findLast(predicate: (elem: T, index: number, array: Array) => boolean): T | undefined { + this.handler?.onAccess() + return super.findLast(predicate) + } + + override every(predicate: (value: T, index: number, array: Array) => boolean): boolean { + this.handler?.onAccess() + return super.every(predicate) + } + + override some(predicate: (value: T, index: number, array: Array) => boolean): boolean { + this.handler?.onAccess() + return super.some(predicate) + } + + override findLastIndex(predicate: (element: T, index: number, array: Array) => boolean): number { + this.handler?.onAccess() + return super.findLastIndex(predicate) + } + + override reduce(callbackfn: (previousValue: T, currentValue: T, index: number, array: Array) => T): T { + this.handler?.onAccess() + return super.reduce(callbackfn) + } + + override reduce(callbackfn: (previousValue: U, currentValue: T, index: number, array: Array) => U, initialValue: U): U { + this.handler?.onAccess() + return super.reduce(callbackfn, initialValue) + } + + override reduceRight(callbackfn: (previousValue: T, currentValue: T, index: number, array: Array) => T): T { + this.handler?.onAccess() + return super.reduceRight(callbackfn) + } + + override reduceRight(callbackfn: (previousValue: U, currentValue: T, index: number, array: Array) => U, initialValue: U): U { + this.handler?.onAccess() + return super.reduceRight(callbackfn, initialValue) + } + + override forEach(callbackfn: (value: T, index: number, array: Array) => void): void { + this.handler?.onAccess() + super.forEach(callbackfn) + } + + override slice(start: int, end: int): Array { + this.handler?.onAccess() + return super.slice(start, end) + } + + override lastIndexOf(searchElement: T, fromIndex: int): int { + this.handler?.onAccess() + return super.lastIndexOf(searchElement, fromIndex) + } + + override join(sep?: String): string { + this.handler?.onAccess() + return super.join(sep) + } + + override toLocaleString(): string { + this.handler?.onAccess() + return super.toLocaleString() + } + + override toSpliced(start: int, delete: int, ...items: FixedArray): Array { + this.handler?.onAccess() + return super.toSpliced(start, delete, ...items) + } + + override includes(val: T, fromIndex?: Number): boolean { + this.handler?.onAccess() + return super.includes(val, fromIndex) + } + + override indexOf(val: T, fromIndex?: int): int { + this.handler?.onAccess() + return super.indexOf(val, fromIndex) + } + + override toSorted(): Array { + this.handler?.onAccess() + return super.toSorted() + } + + override toSorted(comparator: (a: T, b: T) => number): Array { + this.handler?.onAccess() + return super.toSorted(comparator) + } + + override toReversed(): Array { + this.handler?.onAccess() + return super.toReversed() + } + + override with(index: int, value: T): Array { + this.handler?.onAccess() + return super.with(index, value) + } + + override values(): IterableIterator { + this.handler?.onAccess() + return super.values() + } + + override entries(): IterableIterator<[number, T]> { + this.handler?.onAccess() + return super.entries() + } + + override map(callbackfn: (value: T, index: number, array: Array) => U): Array { + this.handler?.onAccess() + return super.map(callbackfn) + } +} + +class ObservableMap extends Map { + static $_invoke(data: Map, parent?: ObservableHandler, observed?: boolean): Map { + return new ObservableMap(data, parent, observed); + } + + constructor(data: Map, parent?: ObservableHandler, observed?: boolean) { + super() + const handler = new ObservableHandler(parent) + for (let item: [T, V] of data.entries()) { + if (observed === undefined) observed = ObservableHandler.contains(handler) + super.set(item[0], observableProxy(item[1], handler, observed)) + } + ObservableHandler.installOn(this, handler) + } + + private get handler(): ObservableHandler | undefined { + return ObservableHandler.find(this) + } + + override get size(): int { + this.handler?.onAccess() + return super.size + } + + override has(key: T): boolean { + this.handler?.onAccess() + return super.has(key) + } + + override get(key: T): V | undefined { + this.handler?.onAccess() + return super.get(key) + } + + override set(key: T, value: V): this { + const handler = this.handler + if (handler) { + handler.onModify() + const prev = super.get(key) + if (prev) handler.removeChild(prev) + value = observableProxy(value, handler) + } + super.set(key, value) + return this + } + + override delete(key: T): boolean { + const handler = this.handler + if (handler) { + handler.onModify() + const value = super.get(key) + if (value) handler.removeChild(value) + } + return super.delete(key) + } + + override clear() { + const handler = this.handler + if (handler) { + handler.onModify() + for (let value of super.values()) { + handler!.removeChild(value) + } + } + super.clear() + } + + override keys(): IterableIterator { + this.handler?.onAccess() + return super.keys() + } + + override values(): IterableIterator { + this.handler?.onAccess() + return super.values() + } + + override $_iterator(): IterableIterator<[T, V]> { + this.handler?.onAccess() + return super.$_iterator() + } + + override entries(): IterableIterator<[T, V]> { + this.handler?.onAccess() + return super.entries() + } + + override forEach(callbackfn: (value: V, key: T, map: Map) => void) { + this.handler?.onAccess() + super.forEach(callbackfn) + } + + override toString(): string { + this.handler?.onAccess() + return super.toString() + } +} + +class ObservableSet extends Set { + private readonly elements: Map + + static $_invoke(data: Set, parent?: ObservableHandler, observed?: boolean): Set { + return new ObservableSet(data, parent, observed); + } + + constructor(data: Set, parent?: ObservableHandler, observed?: boolean) { + this.elements = new Map() + const handler = new ObservableHandler(parent) + for (let item of data.values()) { + if (observed === undefined) observed = ObservableHandler.contains(handler) + this.elements.set(item, observableProxy(item, handler, observed)) + } + ObservableHandler.installOn(this, handler) + } + + private get handler(): ObservableHandler | undefined { + return ObservableHandler.find(this) + } + + override toString(): string { + return new Set(this.elements.keys()).toString() + } + + override get size(): int { + this.handler?.onAccess() + return this.elements.size + } + + override has(value: T): boolean { + this.handler?.onAccess() + return this.elements.has(value) + } + + override add(value: T): this { + const handler = this.handler + let observable = value + if (handler) { + if (!this.elements.has(value)) handler.onModify() + const prev = this.elements.get(value) + if (prev) handler.removeChild(prev) + observable = observableProxy(value) + } + this.elements.set(value, observable) + return this + } + + override delete(value: T): boolean { + const handler = this.handler + if (handler) { + handler.onModify() + const prev = this.elements.get(value) + if (prev) handler.removeChild(prev) + } + return this.elements.delete(value) + } + + override clear() { + const handler = this.handler + if (handler) { + handler.onModify() + for (let value of this.elements.values()) { + handler!.removeChild(value) + } + } + this.elements.clear() + } + + override keys(): IterableIterator { + return this.values() + } + + override values(): IterableIterator { + this.handler?.onAccess() + return this.elements.values() + } + + override $_iterator(): IterableIterator { + return this.values() + } + + override entries(): IterableIterator<[T, T]> { + this.handler?.onAccess() + return new MappingIterator(this.elements.values(), (item) => [item, item]) + } + + override forEach(callbackfn: (value: T, key: T, set: Set) => void) { + this.handler?.onAccess() + const it = this.elements.values() + while (true) { + const item = it.next() + if (item.done) return + callbackfn(item.value as T, item.value as T, this) + } + } +} + +class MappingIterator implements IterableIterator { + private it: IterableIterator + private mapper: (value: T) => V + + constructor(it: IterableIterator, fn: (value: T) => V) { + this.it = it + this.mapper = fn + } + + override next(): IteratorResult { + const item = this.it.next() + if (item.done) return new IteratorResult() + return new IteratorResult(this.mapper(item.value as T)) + } + + override $_iterator(): IterableIterator { + return this + } +} + +class ObservableDate extends Date { + static $_invoke(value: Date, parent?: ObservableHandler, observed?: boolean): Date { + return new ObservableDate(value, parent, observed); + } + + constructor(value: Date, parent?: ObservableHandler, observed?: boolean) { + super(value) + const handler = new ObservableHandler(parent) + ObservableHandler.installOn(this, handler) + } + + private get handler(): ObservableHandler | undefined { + return ObservableHandler.find(this) + } + + override isDateValid(): boolean { + this.handler?.onAccess() + return super.isDateValid() + } + + override valueOf(): number { + this.handler?.onAccess() + return super.valueOf() + } + + override toLocaleTimeString(): string { + this.handler?.onAccess() + return super.toLocaleTimeString() + } + + override toLocaleString(): string { + this.handler?.onAccess() + return super.toLocaleString() + } + + override toLocaleDateString(): string { + this.handler?.onAccess() + return super.toLocaleDateString() + } + + override toISOString(): string { + this.handler?.onAccess() + return super.toISOString() + } + + override toTimeString(): string { + this.handler?.onAccess() + return super.toTimeString() + } + + override toDateString(): string { + this.handler?.onAccess() + return super.toDateString() + } + + override toString(): string { + this.handler?.onAccess() + return super.toString() + } + + override toUTCString(): string { + this.handler?.onAccess() + return super.toUTCString() + } + + override getDate(): number { + this.handler?.onAccess() + return super.getDate() + } + + override setDate(value: byte) { + this.handler?.onModify() + super.setDate(value) + } + + override setDate(value: number): number { + this.handler?.onModify() + return super.setDate(value) + } + + override getUTCDate(): number { + this.handler?.onAccess() + return super.getUTCDate() + } + + override setUTCDate(value: byte) { + this.handler?.onModify() + super.setUTCDate(value) + } + + override setUTCDate(value: number): number { + this.handler?.onModify() + return super.setUTCDate(value) + } + + override getDay(): number { + this.handler?.onAccess() + return super.getDay() + } + + override setDay(value: byte) { + this.handler?.onModify() + super.setDay(value) + } + + override getUTCDay(): number { + this.handler?.onAccess() + return super.getUTCDay() + } + + override setUTCDay(value: byte) { + this.handler?.onModify() + super.setUTCDay(value) + } + + override setUTCDay(value: number): number { + this.handler?.onModify() + return super.setUTCDay(value) + } + + override getMonth(): number { + this.handler?.onAccess() + return super.getMonth() + } + + override setMonth(value: int) { + this.handler?.onModify() + super.setMonth(value) + } + + override setMonth(value: number, date?: number): number { + this.handler?.onModify() + return super.setMonth(value, date) + } + + override getUTCMonth(): number { + this.handler?.onAccess() + return super.getUTCMonth() + } + + override setUTCMonth(value: int) { + this.handler?.onModify() + super.setUTCMonth(value) + } + + override setUTCMonth(value: number, date?: number): number { + this.handler?.onModify() + return super.setUTCMonth(value, date) + } + + override getYear(): int { + this.handler?.onAccess() + return super.getYear() + } + + override setYear(value: int) { + this.handler?.onModify() + super.setYear(value) + } + + override setYear(value: number) { + this.handler?.onModify() + super.setYear(value) + } + + override getFullYear(): number { + this.handler?.onAccess() + return super.getFullYear() + } + + override setFullYear(value: number, month?: number, date?: number): number { + this.handler?.onModify() + return super.setFullYear(value, month, date) + } + + override setFullYear(value: int) { + this.handler?.onModify() + super.setFullYear(value) + } + + override getUTCFullYear(): number { + this.handler?.onAccess() + return super.getUTCFullYear() + } + + override setUTCFullYear(value: number, month?: number, date?: number): number { + this.handler?.onModify() + return super.setUTCFullYear(value, month, date) + } + + override setUTCFullYear(value: int) { + this.handler?.onModify() + super.setUTCFullYear(value) + } + + override getTime(): number { + this.handler?.onAccess() + return super.getTime() + } + + override setTime(value: long) { + this.handler?.onModify() + super.setTime(value) + } + + override setTime(value: number): number { + this.handler?.onModify() + return super.setTime(value) + } + + override getHours(): number { + this.handler?.onAccess() + return super.getHours() + } + + override setHours(value: number, min?: number, sec?: number, ms?: number): number { + this.handler?.onModify() + return super.setHours(value, min, sec, ms) + } + + override setHours(value: byte) { + this.handler?.onModify() + super.setHours(value) + } + + override getUTCHours(): number { + this.handler?.onAccess() + return super.getUTCHours() + } + + override setUTCHours(value: number, min?: number, sec?: number, ms?: number): number { + this.handler?.onModify() + return super.setUTCHours(value, min, sec, ms) + } + + override setUTCHours(value: byte) { + this.handler?.onModify() + super.setUTCHours(value) + } + + override getMilliseconds(): number { + this.handler?.onAccess() + return super.getMilliseconds() + } + + override setMilliseconds(value: short) { + this.handler?.onModify() + super.setMilliseconds(value) + } + + override setMilliseconds(value: number): number { + this.handler?.onModify() + return super.setMilliseconds(value) + } + + override getUTCMilliseconds(): number { + this.handler?.onAccess() + return super.getUTCMilliseconds() + } + + override setUTCMilliseconds(value: short) { + this.handler?.onModify() + super.setUTCMilliseconds(value) + } + + override setUTCMilliseconds(value: number): number { + this.handler?.onModify() + return super.setUTCMilliseconds(value) + } + + override getSeconds(): number { + this.handler?.onAccess() + return super.getSeconds() + } + + override setSeconds(value: byte) { + this.handler?.onModify() + super.setSeconds(value) + } + + override setSeconds(value: number, ms?: number): number { + this.handler?.onModify() + return super.setSeconds(value, ms) + } + + override getUTCSeconds(): number { + this.handler?.onAccess() + return super.getUTCSeconds() + } + + override setUTCSeconds(value: byte) { + this.handler?.onModify() + super.setUTCSeconds(value) + } + + override setUTCSeconds(value: number, ms?: number): number { + this.handler?.onModify() + return super.setUTCSeconds(value, ms) + } + + override getMinutes(): number { + this.handler?.onAccess() + return super.getMinutes() + } + + override setMinutes(value: byte) { + this.handler?.onModify() + super.setMinutes(value) + } + + override setMinutes(value: number, sec?: Number, ms?: number): number { + this.handler?.onModify() + return super.setMinutes(value, sec, ms) + } + + override getUTCMinutes(): number { + this.handler?.onAccess() + return super.getUTCMinutes() + } + + override setUTCMinutes(value: byte) { + this.handler?.onModify() + super.setUTCMinutes(value) + } + + override setUTCMinutes(value: number, sec?: Number, ms?: number): number { + this.handler?.onModify() + return super.setUTCMinutes(value, sec, ms) + } +} + +function getClassMetadata(value: T): ClassMetadata | undefined { + return value instanceof ObservableClass ? value.getClassMetadata() : undefined +} + +function isObservedV1Class(value: Object): boolean { + return getClassMetadata(value)?.isObservedV1(value) ?? false +} + +function hasTrackableProperties(value: Object): boolean { + return getClassMetadata(value)?.hasTrackableProperties() ?? false +} + +/** + * Interface for getting the observability status of a class + */ +export interface ObservableClass { + getClassMetadata(): ClassMetadata | undefined +} + +/** + * Interface for checking the observed properties of a class + */ +export interface TrackableProperties { + isTrackable(propertyName: string): boolean +} + +/** + * If value is a class, then returns a list of trackable properties + * @param value + */ +export function trackableProperties(value: T): TrackableProperties | undefined { + return getClassMetadata(value) +} + +export class ClassMetadata implements TrackableProperties { + private readonly parent: ClassMetadata | undefined + private readonly markAsObservedV1: boolean + private readonly markAsObservedV2: boolean + private readonly targetClass: Class + private static readonly metadataPropName = "__classMetadata" + + /** + * Class property names marked with the @Track or @Trace decorator + * @private + */ + private readonly trackableProperties: ReadonlySet | undefined + + /** + * Contains fields marked with the @Type decorator. + * The key of the map is the property name and the value is the typename of the corresponding field. + * @private + */ + private readonly typedProperties: ReadonlyMap | undefined + + constructor(parent: ClassMetadata | undefined, + markAsObservedV1: boolean, + markAsObservedV2: boolean, + trackable: string[] | undefined, + typed: [string, string][] | undefined) { + const target = Class.ofCaller() + if (target == undefined) { + throw new Error("ClassMetadata must be created in the class context") + } + this.targetClass = target! + this.parent = parent + this.markAsObservedV1 = markAsObservedV1 + this.markAsObservedV2 = markAsObservedV2 + if (trackable) { + this.trackableProperties = new Set(trackable) + } + if (typed) { + this.typedProperties = new Map(typed) + } + } + + isObservedV1(value: Object): boolean { + return this.markAsObservedV1 && Class.of(value) == this.targetClass + } + + isObservedV2(value: Object): boolean { + return this.markAsObservedV2 && Class.of(value) == this.targetClass + } + + isTrackable(propertyName: string): boolean { + return (this.trackableProperties?.has(propertyName) || this.parent?.isTrackable(propertyName)) ?? false + } + + hasTrackableProperties(): boolean { + if (this.trackableProperties) { + return this.trackableProperties!.size > 0 + } + return this.parent?.hasTrackableProperties() ?? false + } + + getTypenameTypeDecorator(propertyName: string): string | undefined { + if (this.typedProperties) { + return this.typedProperties?.get(propertyName) + } + if (this.parent) { + return this.parent!.getTypenameTypeDecorator(propertyName) + } + return undefined + } + + static findClassMetadata(type: Type): ClassMetadata | undefined { + if (type instanceof ClassType) { + const fieldsNum = type.getFieldsNum() + for (let i = 0; i < fieldsNum; i++) { + const field = type.getField(i) + if (field.isStatic() && field.getName() == ClassMetadata.metadataPropName) { + const meta = field.getStaticValue() + if (meta != undefined && meta instanceof ClassMetadata) { + return meta + } + break + } + } + } + return undefined + } +} \ No newline at end of file diff --git a/ets1.2/compat/src/arkts/performance.ts b/ets1.2/compat/src/arkts/performance.ts new file mode 100644 index 0000000000000000000000000000000000000000..8926ff8519d1a22bb9a26c81d4d0bae7476ddd9b --- /dev/null +++ b/ets1.2/compat/src/arkts/performance.ts @@ -0,0 +1,30 @@ +/* + * 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. + */ + +/** + * @returns the number of milliseconds elapsed since midnight, + * January 1, 1970 Universal Coordinated Time (UTC). + */ +export function timeNow(): number { + return Date.now() +} + +/** + * @param fractionDigits - number of digits after the decimal point [0 - 20] + * @returns a string representing a number in fixed-point notation + */ +export function numberToFixed(value: number, fractionDigits: number): string { + return new Number(value).toFixed(fractionDigits) +} diff --git a/ets1.2/compat/src/arkts/primitive.ts b/ets1.2/compat/src/arkts/primitive.ts new file mode 100644 index 0000000000000000000000000000000000000000..6f66d673451e91e6cb8baebca1634ec89a4db283 --- /dev/null +++ b/ets1.2/compat/src/arkts/primitive.ts @@ -0,0 +1,60 @@ + +/* + * Copyright (c) 2024-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 { float32, float64, int32, int64 } from "./types" + +export function float32to64(value: float32): float64 { + return value.toDouble() +} +export function float32toInt32(value: float32): int32 { + return value.toInt() +} +export function float32toInt64(value: float32): int64 { + return value.toLong() +} + +export function float64to32(value: float64): float32 { + return value.toFloat() +} +export function float64toInt32(value: float64): int32 { + return value.toInt() +} +export function float64toInt64(value: float64): int64 { + return value.toLong() +} + +export function int32toFloat32(value: int32): float32 { + return value.toFloat() +} +export function int32toFloat64(value: int32): float64 { + return value.toDouble() +} +export function int32to64(value: int32): int64 { + return value.toLong() +} + +export function int64toFloat32(value: int64): float32 { + return value.toFloat() +} +export function int64toFloat64(value: int64): float64 { + return value.toDouble() +} +export function int64to32(value: int64): int32 { + return value.toInt() +} + +export function asFloat64(value: string): float64 { + return (new Number(value)).valueOf() +} diff --git a/ets1.2/compat/src/arkts/prop-deep-copy.ts b/ets1.2/compat/src/arkts/prop-deep-copy.ts new file mode 100644 index 0000000000000000000000000000000000000000..0835da8b568b153178a7fbec02882b6eed460d36 --- /dev/null +++ b/ets1.2/compat/src/arkts/prop-deep-copy.ts @@ -0,0 +1,32 @@ +/* + * 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. + */ + +/* + When decorating variables of complex types, + @Prop makes a deep copy, during which all types, + except primitive types, Map, Set, Date, and Array, will be lost. + */ +import { getObservableTarget } from "./observable.ts" + +export function propDeepCopy(sourceObject: T): T { + // at the moment of intergation deepcopy from the stdlib requires a default constructor + // but default constructor is not available for ObservableDate, so we + // add a special case for Date (a parent for ObservableDate) + if (sourceObject instanceof Date) { + const copy : Date = new Date(sourceObject.valueOf()) + return copy as T + } + return deepcopy(getObservableTarget(sourceObject as Object) as T) as T +} diff --git a/ets1.2/compat/src/arkts/reflection.ts b/ets1.2/compat/src/arkts/reflection.ts new file mode 100644 index 0000000000000000000000000000000000000000..7961ab53e335fea16eec61cd8444bc890e318790 --- /dev/null +++ b/ets1.2/compat/src/arkts/reflection.ts @@ -0,0 +1,20 @@ + +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { className } from "./ts-reflection" + +export function lcClassName(object: Object) { + return className(object).toLowerCase() +} diff --git a/ets1.2/compat/src/arkts/strings.ts b/ets1.2/compat/src/arkts/strings.ts new file mode 100644 index 0000000000000000000000000000000000000000..66442a51c036426dd868104f6ee1900edd4dfe78 --- /dev/null +++ b/ets1.2/compat/src/arkts/strings.ts @@ -0,0 +1,214 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { int32, uint8 } from "./types" +import { Array_from_int32 } from "./array" + + +interface SystemTextEncoder { + encode(input?: string): Uint8Array; + encodeInto(src: string, dest: Uint8Array): void; +} + +interface WithStreamOption { + stream: Boolean | undefined; +} + +interface SystemTextDecoder { + decode( + input: ArrayBuffer | null | undefined | Uint8Array, + options: WithStreamOption | undefined + ): string; +} + +export class CustomTextEncoder { + static readonly HeaderLen: int32 = Int32Array.BYTES_PER_ELEMENT + + constructor(encoder:SystemTextEncoder|undefined = undefined) { + this.encoder = encoder + } + + private readonly encoder: SystemTextEncoder|undefined + + public static stringLength(input: string): int32 { + let length = 0 + for (let i = 0; i < input.length; i++) { + length++ + let cp = input.codePointAt(i)! + if (cp >= 0x10000) { + i++ + } + } + return length + } + + encodedLength(input: string): int32 { + let length = 0 + for (let i = 0; i < input.length; i++) { + let cp = input.codePointAt(i)! + if (cp < 0x80) { + length += 1 + } else if (cp < 0x800) { + length += 2 + } else if (cp < 0x10000) { + length += 3 + } else { + length += 4 + i++ + } + } + return length + } + + private addLength(array: Uint8Array, offset: int32, length: int32 | number): void { + const len = length.toInt() + array.set(offset, len & 0xff) + array.set(offset + 1, (len >> 8) & 0xff) + array.set(offset + 2, (len >> 16) & 0xff) + array.set(offset + 3, (len >> 24) & 0xff) + } + + static getHeaderLength(array: Uint8Array, offset: int32 = 0): int32 { + return ( + (array.at(offset)!.toInt()) | + (array.at(((offset + 1) << 8))!.toInt()) | + (array.at((offset + 2) << 16)!.toInt()) | + (array.at((offset + 3) << 24))!.toInt()) + } + + // Produces array of bytes with encoded string headed by 4 bytes (little endian) size information: + // [s0][s1][s2][s3] [c_0] ... [c_size-1] + encode(input: string | undefined, addLength: boolean = true): Uint8Array { + let headerLen = addLength ? CustomTextEncoder.HeaderLen : 0 + let result: Uint8Array + if (!input) { + result = new Uint8Array(headerLen) + } else if (this.encoder !== undefined) { + result = this.encoder!.encode('s'.repeat(headerLen) + input) + } else { + let length = this.encodedLength(input) + result = new Uint8Array(length + headerLen) + this.encodeInto(input, result, headerLen) + } + if (addLength) { + this.addLength(result, 0, (result.length - headerLen).toInt()) + } + return result + } + + // Produces encoded array of strings with size information. + encodeArray(strings: Array): Uint8Array { + let totalBytes = CustomTextEncoder.HeaderLen + let lengths = new Int32Array(strings.length) + for (let i = 0; i < lengths.length; i++) { + let len = this.encodedLength(strings[i]) + lengths[i] = len + totalBytes += len + CustomTextEncoder.HeaderLen + } + let array = new Uint8Array(totalBytes) + let position = 0 + this.addLength(array, position, lengths.length.toInt()) + position += CustomTextEncoder.HeaderLen + for (let i = 0; i < lengths.length; i++) { + this.addLength(array, position, lengths[i].toInt()) + position += CustomTextEncoder.HeaderLen + this.encodeInto(strings[i], array, position) + position += lengths[i] + } + return array + } + + encodeInto(input: string, result: Uint8Array, position: int32): Uint8Array { + if (this.encoder !== undefined) { + this.encoder!.encodeInto(input, result.subarray(position, result.length)) + return result + } + let index = position + for (let stringPosition = 0; stringPosition < input.length; stringPosition++) { + let cp = input.codePointAt(stringPosition)! + if (cp < 0x80) { + result[index++] = (cp | 0) + } else if (cp < 0x800) { + result[index++] = ((cp >> 6) | 0xc0) + result[index++] = ((cp & 0x3f) | 0x80) + } else if (cp < 0x10000) { + result[index++] = ((cp >> 12) | 0xe0) + result[index++] = (((cp >> 6) & 0x3f) | 0x80) + result[index++] = ((cp & 0x3f) | 0x80) + } else { + result[index++] = ((cp >> 18) | 0xf0) + result[index++] = (((cp >> 12) & 0x3f) | 0x80) + result[index++] = (((cp >> 6) & 0x3f) | 0x80) + result[index++] = ((cp & 0x3f) | 0x80) + stringPosition++ + } + } + result[index] = 0 + return result + } +} + +export class CustomTextDecoder { + static cpArrayMaxSize = 128 + constructor(decoder: SystemTextDecoder|undefined = undefined) { + this.decoder = decoder + } + + private readonly decoder: SystemTextDecoder|undefined + + decode(input: Uint8Array): string { + if (this.decoder !== undefined) { + return this.decoder!.decode(input, undefined) + } + + const cpSize = Math.min(CustomTextDecoder.cpArrayMaxSize, input.length) + let codePoints = new Int32Array(cpSize) + let cpIndex = 0; + let index = 0 + let result = "" + while (index < input.length) { + let elem = input[index].toByte() + let lead = elem & 0xff + let count = 0 + let value = 0 + if (lead < 0x80) { + count = 1 + value = elem + } else if ((lead >> 5) == 0x6) { + value = (((elem << 6) & 0x7ff) + (input[index + 1] & 0x3f)).toInt() + count = 2 + } else if ((lead >> 4) == 0xe) { + value = (((elem << 12) & 0xffff) + ((input[index + 1] << 6) & 0xfff) + + (input[index + 2] & 0x3f)).toInt() + count = 3 + } else if ((lead >> 3) == 0x1e) { + value = (((elem << 18) & 0x1fffff) + ((input[index + 1] << 12) & 0x3ffff) + + ((input[index + 2] << 6) & 0xfff) + (input[index + 3] & 0x3f)).toInt() + count = 4 + } + codePoints[cpIndex++] = value + if (cpIndex == cpSize) { + cpIndex = 0 + //result += String.fromCodePoint(...codePoints) + result += String.fromCodePoint(...Array_from_int32(codePoints)) + } + index += count + } + if (cpIndex > 0) { + result += String.fromCodePoint(...Array_from_int32(codePoints.slice(0, cpIndex))) + } + return result + } +} diff --git a/ets1.2/compat/src/arkts/ts-reflection.ts b/ets1.2/compat/src/arkts/ts-reflection.ts new file mode 100644 index 0000000000000000000000000000000000000000..f9f80694482030a254ec166534ba660a3551fbc5 --- /dev/null +++ b/ets1.2/compat/src/arkts/ts-reflection.ts @@ -0,0 +1,38 @@ +/* + * 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. + */ + +export function className(object?: Object): string { + return object ? (Type.of(object) as ClassType).getName() : "null" +} + +export function isFunction(object?: Object): boolean { + return Type.of(object) instanceof FunctionType +} + +// Improve: This is an very ad hoc function, +// but I could not find in ArkTS stdlib enough functionality +// for a more generic way. +export function functionOverValue(value: Value|(()=>Value)): boolean { + return Type.of(value) instanceof FunctionType +} + +// Somehow es2panda only allows === on reference types. +export function refEqual(a: Value, b: Value): boolean { + return a == b +} + +export function isNotPrimitive(value: Object): boolean { + return !Type.of(value).isPrimitive() +} diff --git a/ets1.2/compat/src/arkts/types.ts b/ets1.2/compat/src/arkts/types.ts new file mode 100644 index 0000000000000000000000000000000000000000..b0edbd27a4e7da12223d11fdf834cd34739ac413 --- /dev/null +++ b/ets1.2/compat/src/arkts/types.ts @@ -0,0 +1,25 @@ +/* + * 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. + */ + +export type uint8 = byte +export type int8 = byte +export type unt16 = short +export type int16 = short +export type int32 = int +export type uint32 = int +export type int64 = long +export type uint64 = long +export type float32 = float +export type float64 = double \ No newline at end of file diff --git a/ets1.2/compat/src/arkts/utils.ts b/ets1.2/compat/src/arkts/utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..ec855ec898564683a16314c9a42ca7adf74030ea --- /dev/null +++ b/ets1.2/compat/src/arkts/utils.ts @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2024-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. + */ + +export function errorAsString(error: Any): string { + if (error instanceof Error) { + const stack = error.stack + return stack + ? error.toString() + '\n' + stack + : error.toString() + } + return JSON.stringify(error) +} + +export function unsafeCast(value: Object): T { + return value as T +} + +export function scheduleCoroutine(): void { + Coroutine.Schedule() +} + +export function memoryStats(): string { + return `used ${GC.getUsedHeapSize()} free ${GC.getFreeHeapSize()}` +} + +export function launchJob(task: () => void): Promise { + return taskpool.execute(task) +} + +export class CoroutineLocalValue { + private map = new containers.ConcurrentHashMap + get(): T | undefined { + return this.map.get(CoroutineExtras.getWorkerId()) + } + set(value: T | undefined) { + if (value) { + this.map.set(CoroutineExtras.getWorkerId(), value) + } else { + this.map.delete(CoroutineExtras.getWorkerId()) + } + } +} diff --git a/ets1.2/compat/src/index.ts b/ets1.2/compat/src/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..d068f170afefa359a4ac4d8fd1f976dca122fd50 --- /dev/null +++ b/ets1.2/compat/src/index.ts @@ -0,0 +1,62 @@ +/* + * 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. + */ + +export { + asArray, + Array_from_set, + Array_from_int32, + Array_from_number, + AtomicRef, + asFloat64, + Thunk, + finalizerRegister, + finalizerUnregister, + timeNow, + numberToFixed, + Observed, + Observable, + ObservableHandler, + ObservableClass, + TrackableProperties, + trackableProperties, + ClassMetadata, + observableProxy, + observableProxyArray, + propDeepCopy, + lcClassName, + CustomTextEncoder, + CustomTextDecoder, + className, + isFunction, + functionOverValue, + refEqual, + isNotPrimitive, + uint8, + int8, + int16, + int32, int32toFloat32, int32toFloat64, int32to64, + uint32, + int64, int64toFloat32, int64toFloat64, int64to32, + uint64, + float32, float32to64, float32toInt32, float32toInt64, + float64, float64to32, float64toInt32, float64toInt64, + int8Array, + errorAsString, + unsafeCast, + CoroutineLocalValue, + scheduleCoroutine, + memoryStats, + launchJob +} from "#platform" diff --git a/ets1.2/compat/src/ohos/index.ts b/ets1.2/compat/src/ohos/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..892265e6691bc3bd0423b50d01327d3293bc1952 --- /dev/null +++ b/ets1.2/compat/src/ohos/index.ts @@ -0,0 +1,65 @@ +/* + * 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. + */ + +export { + asArray, + Array_from_set, + Array_from_int32, + Array_from_number, + AtomicRef, + asFloat64, + Thunk, + finalizerRegister, + finalizerUnregister, + Observed, + Observable, + ObservableHandler, + observableProxy, + ObservableClass, + TrackableProperties, + trackableProperties, + ClassMetadata, + observableProxyArray, + propDeepCopy, + lcClassName, + CustomTextEncoder, + CustomTextDecoder, + className, + isFunction, + functionOverValue, + refEqual, + isNotPrimitive, + uint8, + int8, + int16, + int32, int32toFloat32, int32toFloat64, int32to64, + uint32, + int64, int64toFloat32, int64toFloat64, int64to32, + uint64, + float32, float32to64, float32toInt32, float32toInt64, + float64, float64to32, float64toInt32, float64toInt64, + int8Array, + errorAsString, + unsafeCast, + CoroutineLocalValue, + scheduleCoroutine, + memoryStats, + launchJob +} from "../typescript" + +export { + timeNow, + numberToFixed, +} from "./performance" diff --git a/ets1.2/compat/src/ohos/performance.ts b/ets1.2/compat/src/ohos/performance.ts new file mode 100644 index 0000000000000000000000000000000000000000..8926ff8519d1a22bb9a26c81d4d0bae7476ddd9b --- /dev/null +++ b/ets1.2/compat/src/ohos/performance.ts @@ -0,0 +1,30 @@ +/* + * 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. + */ + +/** + * @returns the number of milliseconds elapsed since midnight, + * January 1, 1970 Universal Coordinated Time (UTC). + */ +export function timeNow(): number { + return Date.now() +} + +/** + * @param fractionDigits - number of digits after the decimal point [0 - 20] + * @returns a string representing a number in fixed-point notation + */ +export function numberToFixed(value: number, fractionDigits: number): string { + return new Number(value).toFixed(fractionDigits) +} diff --git a/ets1.2/compat/src/typescript/Types.d.ts b/ets1.2/compat/src/typescript/Types.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4d42fbbf5de01bc8cb67946a38e9d8c42b70bc9a --- /dev/null +++ b/ets1.2/compat/src/typescript/Types.d.ts @@ -0,0 +1,19 @@ +/* + * 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. + */ + +type int = number +type long = number +type float = number +type double = number diff --git a/ets1.2/compat/src/typescript/array.ts b/ets1.2/compat/src/typescript/array.ts new file mode 100644 index 0000000000000000000000000000000000000000..156ea36f2e31b66ebb1fdfa8aaa564dfd32c29ef --- /dev/null +++ b/ets1.2/compat/src/typescript/array.ts @@ -0,0 +1,36 @@ +/* + * 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 { float64, int32, int8 } from "./types" + +export function asArray(value: T[]): Array { + return value +} + +export function Array_from_set(set: Set): Array { + return Array.from(set) +} + +export function Array_from_int32(data: Int32Array): int32[] { + return Array.from(data) +} + +export function Array_from_number(data: float64[]): Array { + return data +} + +export function int8Array(size: int32): int8[] { + return [] +} diff --git a/ets1.2/compat/src/typescript/atomic.ts b/ets1.2/compat/src/typescript/atomic.ts new file mode 100644 index 0000000000000000000000000000000000000000..b3b12b85fa0b57555b12e219c515c26ca97ebb15 --- /dev/null +++ b/ets1.2/compat/src/typescript/atomic.ts @@ -0,0 +1,40 @@ +/* + * 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. + */ + +/** + * A reference that may be updated atomically. + */ +export class AtomicRef { + value: Value + + /** + * Creates a new reference object with the given initial value. + * @param value - the new value + */ + constructor(value: Value) { + this.value = value + } + + /** + * Atomically sets the reference value to the given value and returns the previous one. + * @param value - the new value + * @returns the previous value + */ + getAndSet(value: Value): Value { + const result = this.value + this.value = value + return result + } +} diff --git a/ets1.2/compat/src/typescript/finalization.ts b/ets1.2/compat/src/typescript/finalization.ts new file mode 100644 index 0000000000000000000000000000000000000000..c7d5e05e8462a886f38ab969e3752c16d109e181 --- /dev/null +++ b/ets1.2/compat/src/typescript/finalization.ts @@ -0,0 +1,42 @@ +/* + * Copyright (c) 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. + */ + +export interface Thunk { + clean(): void +} + +interface FinalizationRegistry { + register(target: object, value: any, token?: object): void; + unregister(token: object): void; +} + +interface FinalizationRegistryConstructor { + readonly prototype: FinalizationRegistry; + new(callback: (value: any) => void): FinalizationRegistry; +} + +declare const FinalizationRegistry: FinalizationRegistryConstructor + +const registry = new FinalizationRegistry((thunk: Thunk) => { + thunk.clean() +}) + +export function finalizerRegister(target: object, thunk: object) { + registry.register(target, thunk) +} + +export function finalizerUnregister(target: object) { + registry.unregister(target) +} diff --git a/ets1.2/compat/src/typescript/index.ts b/ets1.2/compat/src/typescript/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..e5ca0c3be7c24d909bb2bfb5d9f36946e9437ca6 --- /dev/null +++ b/ets1.2/compat/src/typescript/index.ts @@ -0,0 +1,27 @@ +/* + * 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. + */ + +export * from "./array" +export * from "./atomic" +export * from "./primitive" +export * from "./finalization" +export * from "./observable" +export * from "./performance" +export * from "./prop-deep-copy" +export * from "./reflection" +export * from "./strings" +export * from "./ts-reflection" +export * from "./types" +export * from "./utils" diff --git a/ets1.2/compat/src/typescript/observable.ts b/ets1.2/compat/src/typescript/observable.ts new file mode 100644 index 0000000000000000000000000000000000000000..31d9f74cd32af3928946c723f831f8e90d06c477 --- /dev/null +++ b/ets1.2/compat/src/typescript/observable.ts @@ -0,0 +1,628 @@ +/* + * 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. + */ + +const OBSERVABLE_TARGET = "__proxy_observable_target__" + +export function getObservableTarget(proxy: Object): Object { + return getPropertyValue(OBSERVABLE_TARGET, proxy) ?? proxy +} + +function getPropertyValue(name: string, object: any): any { + return object[name] +} + +/** + * Data class decorator that makes all child fields trackable. + */ +export function Observed(constructorFunction: Function) { + constructorFunction.prototype[OBSERVED] = true +} + +const OBSERVED = "__ObservedByArkUI__" +function isObserved(value: any): boolean { + return value[OBSERVED] === true +} + +/** @internal */ +export interface Observable { + /** It is called when the observable value is accessed. */ + onAccess(): void + /** It is called when the observable value is modified. */ + onModify(): void +} + +/** @internal */ +export class ObservableHandler implements Observable { + private static handlers: WeakMap | undefined = undefined + + private parents = new Set() + private children = new Map() + + private readonly observables = new Set() + private _modified = false + + readonly observed: boolean + constructor(parent?: ObservableHandler, observed: boolean = false) { + this.observed = observed + if (parent) this.addParent(parent) + } + + onAccess(): void { + if (this.observables.size > 0) { + const it = this.observables.keys() + while (true) { + const result = it.next() + if (result.done) break + result.value?.onAccess() + } + } + } + + onModify(): void { + const set = new Set() + this.collect(true, set) + set.forEach((handler: ObservableHandler) => { + handler._modified = true + if (handler.observables.size > 0) { + const it = handler.observables.keys() + while (true) { + const result = it.next() + if (result.done) break + result.value?.onModify() + } + } + }) + } + + static dropModified(value: Value): boolean { + const handler = ObservableHandler.findIfObject(value) + if (handler === undefined) return false + const result = handler._modified + handler._modified = false + return result + } + + /** Adds the specified `observable` to the handler corresponding to the given `value`. */ + static attach(value: Value, observable: Observable): void { + const handler = ObservableHandler.findIfObject(value) + if (handler) handler.observables.add(observable) + } + + /** Deletes the specified `observable` from the handler corresponding to the given `value`. */ + static detach(value: Value, observable: Observable): void { + const handler = ObservableHandler.findIfObject(value) + if (handler) handler.observables.delete(observable) + } + + /** @returns the handler corresponding to the given `value` if it was installed */ + private static findIfObject(value: Value): ObservableHandler | undefined { + const handlers = ObservableHandler.handlers + return handlers !== undefined && value instanceof Object ? handlers.get(getObservableTarget(value as Object)) : undefined + } + + /** + * @param value - any non-null object including arrays + * @returns an observable handler or `undefined` if it is not installed + */ + static find(value: Object): ObservableHandler | undefined { + const handlers = ObservableHandler.handlers + return handlers ? handlers.get(getObservableTarget(value)) : undefined + } + + /** + * @param value - any non-null object including arrays + * @param observable - a handler to install on this object + * @throws an error if observable handler cannot be installed + */ + static installOn(value: Object, observable?: ObservableHandler): void { + let handlers = ObservableHandler.handlers + if (handlers === undefined) { + handlers = new WeakMap() + ObservableHandler.handlers = handlers + } + observable + ? handlers.set(getObservableTarget(value), observable) + : handlers.delete(getObservableTarget(value)) + } + + addParent(parent: ObservableHandler) { + const count = parent.children.get(this) ?? 0 + parent.children.set(this, count + 1) + this.parents.add(parent) + } + + removeParent(parent: ObservableHandler) { + const count = parent.children.get(this) ?? 0 + if (count > 1) { + parent.children.set(this, count - 1) + } + else if (count == 1) { + parent.children.delete(this) + this.parents.delete(parent) + } + } + + removeChild(value: Value) { + const child = ObservableHandler.findIfObject(value) + if (child) child.removeParent(this) + } + + private collect(all: boolean, guards = new Set()) { + if (guards.has(this)) return guards // already collected + guards.add(this) // handler is already guarded + this.parents.forEach(handler => handler.collect(all, guards)) + if (all) this.children.forEach((_count, handler) => handler.collect(all, guards)) + return guards + } + + static contains(observable: ObservableHandler, guards?: Set) { + if (observable.observed) return true + if (guards === undefined) guards = new Set() // create if needed + else if (guards.has(observable)) return false // already checked + guards.add(observable) // handler is already guarded + for (const it of observable.parents.keys()) { + if (ObservableHandler.contains(it, guards)) return true + } + return false + } +} + +/** @internal */ +export function observableProxyArray(...value: Value[]): Array { + return observableProxy(value) +} + +/** @internal */ +export function observableProxy(value: Value, parent?: ObservableHandler, observed?: boolean, strict = true): Value { + if (value instanceof ObservableHandler) return value // do not proxy a marker itself + if (value === null || !(value instanceof Object)) return value // only non-null object can be observable + const observable = ObservableHandler.find(value) + if (observable) { + if (parent) { + if (strict) observable.addParent(parent) + if (observed === undefined) observed = ObservableHandler.contains(parent) + } + if (observed) { + if (Array.isArray(value)) { + for (let index = 0; index < value.length; index++) { + value[index] = observableProxy(value[index], observable, observed, false) + } + } else { + proxyFields(value, false, observable) + } + } + return value + } + if (Array.isArray(value)) { + const handler = new ObservableHandler(parent) + const array = proxyChildrenOnly(value, handler, observed) + copyWithinObservable(array) + fillObservable(array) + popObservable(array) + pushObservable(array) + reverseObservable(array) + shiftObservable(array) + sortObservable(array) + spliceObservable(array) + unshiftObservable(array) + return proxyObject(array, handler) + } + if (value instanceof Date) { + const valueAsAny = (value as any) + const handler = new ObservableHandler(parent) + const setMethods = new Set([ + "setFullYear", "setMonth", "setDate", "setHours", "setMinutes", "setSeconds", + "setMilliseconds", "setTime", "setUTCFullYear", "setUTCMonth", "setUTCDate", + "setUTCHours", "setUTCMinutes", "setUTCSeconds", "setUTCMilliseconds" + ]) + setMethods.forEach((method: string) => { + const originalMethod = method + 'Original' + if (valueAsAny[originalMethod] !== undefined) { + return + } + valueAsAny[originalMethod] = valueAsAny[method] + valueAsAny[method] = function (...args: any[]) { + ObservableHandler.find(this)?.onModify() + return this[originalMethod](...args) + } + }) + return proxyObject(value, handler) + } + if (value instanceof Map) { + const handler = new ObservableHandler(parent) + const data = proxyMapValues(value, handler, observed) + setObservable(data) + deleteObservable(data) + clearObservable(data) + return proxyMapOrSet(data, handler) + } + if (value instanceof Set) { + const handler = new ObservableHandler(parent) + const data = proxySetValues(value, handler, observed) + addObservable(data) + deleteObservable(data) + clearObservable(data) + return proxyMapOrSet(data, handler) + } + const handler = new ObservableHandler(parent, isObserved(value)) + if (handler.observed || observed) proxyFields(value, true, handler) + return proxyObject(value, handler) +} + +function proxyObject(value: any, observable: ObservableHandler) { + ObservableHandler.installOn(value, observable) + return new Proxy(value, { + get(target, property, receiver) { + if (property == OBSERVABLE_TARGET) return target + const value: any = Reflect.get(target, property, receiver) + ObservableHandler.find(target)?.onAccess() + return typeof value == "function" + ? value.bind(target) + : value + }, + set(target, property, value, receiver) { + const old = Reflect.get(target, property, receiver) + if (value === old) return true + const observable = ObservableHandler.find(target) + if (observable) { + observable.onModify() + observable.removeChild(old) + const observed = ObservableHandler.contains(observable) + if (observed || Array.isArray(target)) { + value = observableProxy(value, observable, observed) + } + } + return Reflect.set(target, property, value, receiver) + }, + deleteProperty(target, property) { + ObservableHandler.find(target)?.onModify() + delete target[property] + return true + }, + }) +} + +function proxyFields(value: any, strict: boolean, parent?: ObservableHandler) { + for (const name of Object.getOwnPropertyNames(value)) { + const descriptor = Object.getOwnPropertyDescriptor(value, name) + if (descriptor?.writable) value[name] = observableProxy(value[name], parent, true, strict) + } +} + +function proxyChildrenOnly(array: any[], parent: ObservableHandler, observed?: boolean): any[] { + if (observed === undefined) observed = ObservableHandler.contains(parent) + return array.map(it => observableProxy(it, parent, observed)) +} + +function copyWithinObservable(array: any) { + if (array.copyWithinOriginal === undefined) { + array.copyWithinOriginal = array.copyWithin + array.copyWithin = function (this, target: number, start: number, end?: number) { + const observable = ObservableHandler.find(this) + observable?.onModify() + return this.copyWithinOriginal(target, start, end) + } + } +} + +function fillObservable(array: any) { + if (array.fillOriginal === undefined) { + array.fillOriginal = array.fill + array.fill = function (this, value: any, start?: number, end?: number) { + const observable = ObservableHandler.find(this) + observable?.onModify() + if (observable) value = observableProxy(value, observable) + return this.fillOriginal(value, start, end) + } + } +} + +function popObservable(array: any) { + if (array.popOriginal === undefined) { + array.popOriginal = array.pop + array.pop = function (...args: any[]) { + const observable = ObservableHandler.find(this) + observable?.onModify() + const result = this.popOriginal(...args) + if (observable) observable.removeChild(result) + return result + } + } +} + +function pushObservable(array: any) { + if (array.pushOriginal === undefined) { + array.pushOriginal = array.push + array.push = function (this, ...args: any[]) { + const observable = ObservableHandler.find(this) + observable?.onModify() + if (observable) args = proxyChildrenOnly(args, observable) + return this.pushOriginal(...args) + } + } +} + +function reverseObservable(array: any) { + if (array.reverseOriginal === undefined) { + array.reverseOriginal = array.reverse + array.reverse = function (this) { + const observable = ObservableHandler.find(this) + observable?.onModify() + return this.reverseOriginal() + } + } +} + +function shiftObservable(array: any) { + if (array.shiftOriginal === undefined) { + array.shiftOriginal = array.shift + array.shift = function (this, ...args: any[]) { + const observable = ObservableHandler.find(this) + observable?.onModify() + const result = this.shiftOriginal(...args) + if (observable) observable.removeChild(result) + return result + } + } +} + +function sortObservable(array: any) { + if (array.sortOriginal === undefined) { + array.sortOriginal = array.sort + array.sort = function (this, compareFn?: (a: any, b: any) => number) { + const observable = ObservableHandler.find(this) + observable?.onModify() + return this.sortOriginal(compareFn) + } + } +} + +function spliceObservable(array: any) { + if (array.spliceOriginal === undefined) { + array.spliceOriginal = array.splice + array.splice = function (this, start: number, deleteCount: number, ...items: any[]) { + const observable = ObservableHandler.find(this) + observable?.onModify() + if (observable) items = proxyChildrenOnly(items, observable) + if (deleteCount === undefined) deleteCount = array.length + const result = this.spliceOriginal(start, deleteCount, ...items) + if (observable && Array.isArray(result)) { + result.forEach(it => observable.removeChild(it)) + } + return result + } + } +} + +function unshiftObservable(array: any) { + if (array.unshiftOriginal === undefined) { + array.unshiftOriginal = array.unshift + array.unshift = function (this, ...items: any[]) { + const observable = ObservableHandler.find(this) + observable?.onModify() + if (observable) items = proxyChildrenOnly(items, observable) + return this.unshiftOriginal(...items) + } + } +} + +function proxyMapValues(data: Map, parent: ObservableHandler, observed?: boolean): Map { + if (observed === undefined) observed = ObservableHandler.contains(parent) + const result = new Map() + for (const [key, value] of data.entries()) { + result.set(key, observableProxy(value, parent, observed)) + } + return result +} + +function proxySetValues(data: Set, parent: ObservableHandler, observed?: boolean): Set { + // Improve: check if necessary to replace items of the set with observed objects as + // for complex objects add() function won't find original object inside the set of proxies + /* + if (observed === undefined) observed = ObservableHandler.contains(parent) + const result = new Set() + for (const value of data.values()) { + result.add(observableProxy(value, parent, observed)) + } + return result + */ + return data +} + +function proxyMapOrSet(value: any, observable: ObservableHandler) { + ObservableHandler.installOn(value, observable) + return new Proxy(value, { + get(target, property, receiver) { + if (property == OBSERVABLE_TARGET) return target + if (property == 'size') { + ObservableHandler.find(target)?.onAccess() + return target.size + } + const value: any = Reflect.get(target, property, receiver) + ObservableHandler.find(target)?.onAccess() + return typeof value == "function" + ? value.bind(target) + : value + }, + }) +} + +function addObservable(data: any) { + if (data.addOriginal === undefined) { + data.addOriginal = data.add + data.add = function (this, value: any) { + const observable = ObservableHandler.find(this) + if (observable && !this.has(value)) { + observable.onModify() + // Improve: check if necessary to replace items of the set with observed objects as + // for complex objects add() function won't find original object inside the set of proxies + // value = observableProxy(value, observable) + } + return this.addOriginal(value) + } + } +} + +function setObservable(data: any) { + if (data.setOriginal === undefined) { + data.setOriginal = data.set + data.set = function (this, key: any, value: any) { + const observable = ObservableHandler.find(this) + if (observable) { + observable.onModify() + observable.removeChild(this.get(key)) + value = observableProxy(value, observable) + } + return this.setOriginal(key, value) + } + } +} + +function deleteObservable(data: any) { + if (data.deleteOriginal === undefined) { + data.deleteOriginal = data.delete + data.delete = function (this, key: any) { + const observable = ObservableHandler.find(this) + if (observable) { + observable.onModify() + if (this instanceof Map) { + observable.removeChild(this.get(key)) + } else if (this instanceof Set) { + observable.removeChild(key) + } + } + return this.deleteOriginal(key) + } + } +} + +function clearObservable(data: any) { + if (data.clearOriginal === undefined) { + data.clearOriginal = data.clear + data.clear = function (this) { + const observable = ObservableHandler.find(this) + if (observable) { + observable.onModify() + Array.from(this.values()).forEach(it => observable.removeChild(it)) + } + return this.clearOriginal() + } + } +} + +function getClassMetadata(value: any): ClassMetadata | undefined { + if (value !== undefined && typeof value.getClassMetadata === 'function') { + return (value as ObservableClass).getClassMetadata() + } + return undefined +} + +/** + * Interface for getting the observability status of a class + */ +export interface ObservableClass { + getClassMetadata(): ClassMetadata | undefined +} + +/** + * Interface for checking the observed properties of a class + */ +export interface TrackableProperties { + isTrackable(propertyName: string): boolean +} + +/** + * If value is a class, then returns a list of trackable properties + * @param value + */ +export function trackableProperties(value: T): TrackableProperties | undefined { + return getClassMetadata(value) +} + +export class ClassMetadata implements TrackableProperties { + private readonly parent: ClassMetadata | undefined + private readonly markAsObservedV1: boolean + private readonly markAsObservedV2: boolean + private static readonly metadataPropName = "__classMetadata" + + /** + * Class property names marked with the @Track or @Trace decorator + * @private + */ + private readonly trackableProperties: ReadonlySet | undefined + + /** + * Contains fields marked with the @Type decorator. + * The key of the map is the property name and the value is the typename of the corresponding field. + * @private + */ + private readonly typedProperties: ReadonlyMap | undefined + + constructor(parent: ClassMetadata | undefined, + markAsObservedV1: boolean, + markAsObservedV2: boolean, + trackable: string[] | undefined, + typed: [string, string][] | undefined) { + this.parent = parent + this.markAsObservedV1 = markAsObservedV1 + this.markAsObservedV2 = markAsObservedV2 + if (trackable) { + this.trackableProperties = new Set(trackable) + } + if (typed) { + this.typedProperties = new Map(typed) + } + } + + isObservedV1(value: Object): boolean { + return this.markAsObservedV1 + } + + isObservedV2(value: Object): boolean { + return this.markAsObservedV2 + } + + isTrackable(propertyName: string): boolean { + return (this.trackableProperties?.has(propertyName) || this.parent?.isTrackable(propertyName)) ?? false + } + + hasTrackableProperties(): boolean { + if (this.trackableProperties) { + return this.trackableProperties!.size > 0 + } + return this.parent?.hasTrackableProperties() ?? false + } + + getTypenameTypeDecorator(propertyName: string): string | undefined { + if (this.typedProperties) { + return this.typedProperties?.get(propertyName) + } + if (this.parent) { + return this.parent!.getTypenameTypeDecorator(propertyName) + } + return undefined + } + + private static findClassMetadata(type: any): ClassMetadata | undefined { + let prototype = Object.getPrototypeOf(type) + while (prototype) { + if (prototype.hasOwnProperty(ClassMetadata.metadataPropName) && prototype.__classMetadata !== undefined) { + return prototype.__classMetadata + } + prototype = Object.getPrototypeOf(prototype) + } + return undefined + } +} \ No newline at end of file diff --git a/ets1.2/compat/src/typescript/performance.ts b/ets1.2/compat/src/typescript/performance.ts new file mode 100644 index 0000000000000000000000000000000000000000..9451185bcdcd9caa514e08d22f7c54d1d315eca9 --- /dev/null +++ b/ets1.2/compat/src/typescript/performance.ts @@ -0,0 +1,30 @@ +/* + * 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. + */ + +/** + * @returns the number of milliseconds elapsed since midnight, + * January 1, 1970 Universal Coordinated Time (UTC). + */ +export function timeNow(): number { + return performance.now() +} + +/** + * @param fractionDigits - number of digits after the decimal point [0 - 20] + * @returns a string representing a number in fixed-point notation + */ +export function numberToFixed(value: number, fractionDigits: number): string { + return value.toFixed(fractionDigits) +} diff --git a/ets1.2/compat/src/typescript/primitive.ts b/ets1.2/compat/src/typescript/primitive.ts new file mode 100644 index 0000000000000000000000000000000000000000..642a98ecc705cd27c1be52c9c375a79e68815070 --- /dev/null +++ b/ets1.2/compat/src/typescript/primitive.ts @@ -0,0 +1,60 @@ +/* + * 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 { float32, float64, int32, int64 } from "./types" + +export function float32to64(value: float32): float64 { + return value // toDouble() +} +export function float32toInt32(value: float32): int32 { + return value | 0 // toInt() +} +export function float32toInt64(value: float32): int64 { + return Math.trunc(value) // toLong() +} + +export function float64to32(value: float64): float32 { + return value // toFloat() +} +export function float64toInt32(value: float64): int32 { + return value | 0 // toInt() +} +export function float64toInt64(value: float64): int64 { + return Math.trunc(value) // toLong() +} + +export function int32toFloat32(value: int32): float32 { + return value // toFloat() +} +export function int32toFloat64(value: int32): float64 { + return value // toDouble() +} +export function int32to64(value: int32): int64 { + return Math.trunc(value) // toLong() +} + +export function int64toFloat32(value: int64): float32 { + return value // toFloat() +} +export function int64toFloat64(value: int64): float64 { + return value // toDouble() +} +export function int64to32(value: int64): int32 { + return value | 0 // toInt() +} + +export function asFloat64(value: string): float64 { + return Number(value) +} diff --git a/ets1.2/compat/src/typescript/prop-deep-copy.ts b/ets1.2/compat/src/typescript/prop-deep-copy.ts new file mode 100644 index 0000000000000000000000000000000000000000..3dd13819df356a5701b8e7bbb9d8f9769cd1e33e --- /dev/null +++ b/ets1.2/compat/src/typescript/prop-deep-copy.ts @@ -0,0 +1,95 @@ +/* + * 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 { getObservableTarget } from "./observable" + +/* + When decorating variables of complex types, + @Prop makes a deep copy, during which all types, + except primitive types, Map, Set, Date, and Array, will be lost. + */ + +export function propDeepCopy(sourceObject: T): T { + if (!sourceObject || typeof sourceObject !== 'object') { + return sourceObject + } + + const copiedObjects = new Map() + return recursiveDeepCopy(sourceObject) as T + + function recursiveDeepCopy(sourceObject: Object): Object { + if (!sourceObject || typeof sourceObject !== 'object') { + return sourceObject + } + + const storedObject = copiedObjects.get(sourceObject) + if (storedObject !== undefined) { + return storedObject + } + + const copy: any = copyDeepTrackable(sourceObject) + + const objectToCopyFrom = getObservableTarget(sourceObject) + Object.keys(objectToCopyFrom) + .forEach((key) => { + const property = objectToCopyFrom[key as keyof Object] + + if (typeof property === "function") { + Reflect.set(copy, key, property) + copy[key] = copy[key].bind(copy) + return + } + Reflect.set(copy, key, recursiveDeepCopy(property)); + }) + + return copy + } + + function copyDeepTrackable(sourceObject: T): T { + if (sourceObject instanceof Set) { + const copy = new Set() + Object.setPrototypeOf(copy, Object.getPrototypeOf(sourceObject)) + copiedObjects.set(sourceObject, copy) + for (const setKey of sourceObject.keys()) { + copy.add(recursiveDeepCopy(setKey)) + } + return copy as T + } + if (sourceObject instanceof Map) { + const copy = new Map() + Object.setPrototypeOf(copy, Object.getPrototypeOf(sourceObject)) + copiedObjects.set(sourceObject, copy) + for (const mapKey of sourceObject.keys()) { + copy.set(mapKey, recursiveDeepCopy(sourceObject.get(mapKey))) + } + return copy as T + } + if (sourceObject instanceof Date) { + const copy = new Date() + copy.setTime(sourceObject.getTime()) + Object.setPrototypeOf(copy, Object.getPrototypeOf(sourceObject)) + copiedObjects.set(sourceObject, copy) + return copy as T + } + if (sourceObject instanceof Object) { + const copy = Array.isArray(sourceObject) ? [] : {} + Object.setPrototypeOf(copy, Object.getPrototypeOf(sourceObject)) + copiedObjects.set(sourceObject, copy) + return copy as T + } + + return sourceObject + } +} diff --git a/ets1.2/compat/src/typescript/reflection.ts b/ets1.2/compat/src/typescript/reflection.ts new file mode 100644 index 0000000000000000000000000000000000000000..7961ab53e335fea16eec61cd8444bc890e318790 --- /dev/null +++ b/ets1.2/compat/src/typescript/reflection.ts @@ -0,0 +1,20 @@ + +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +import { className } from "./ts-reflection" + +export function lcClassName(object: Object) { + return className(object).toLowerCase() +} diff --git a/ets1.2/compat/src/typescript/strings.ts b/ets1.2/compat/src/typescript/strings.ts new file mode 100644 index 0000000000000000000000000000000000000000..3fd4a2a78db63831b19f9c026a1911e3e62a0196 --- /dev/null +++ b/ets1.2/compat/src/typescript/strings.ts @@ -0,0 +1,205 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { int32 } from "./types" + +interface SystemTextEncoder { + encode(input?: string): Uint8Array; + encodeInto(src: string, dest: Uint8Array): void; +} + +interface WithStreamOption { + stream?: boolean | undefined; +} + +interface SystemTextDecoder { + decode( + input?: ArrayBuffer | null, + options?: WithStreamOption + ): string; +} + +export class CustomTextEncoder { + static readonly HeaderLen: int32 = Int32Array.BYTES_PER_ELEMENT + + constructor(encoder: SystemTextEncoder|undefined = ((typeof TextEncoder != "undefined") ? new TextEncoder() : undefined)) { + this.encoder = encoder + } + + private readonly encoder: SystemTextEncoder|undefined + + public static stringLength(input: string): int32 { + let length = 0 + for (let i = 0; i < input.length; i++) { + length++ + let cp = input.codePointAt(i)! + if (cp >= 0x10000) { + i++ + } + } + return length + } + + encodedLength(input: string): int32 { + let length = 0 + for (let i = 0; i < input.length; i++) { + let cp = input.codePointAt(i)! + if (cp < 0x80) { + length += 1 + } else if (cp < 0x800) { + length += 2 + } else if (cp < 0x10000) { + length += 3 + } else { + length += 4 + i++ + } + } + return length + } + + private addLength(array: Uint8Array, offset: int32, len: int32): void { + array[offset] = (len & 0xff) + array[offset + 1] = ((len >> 8) & 0xff) + array[offset + 2] = ((len >> 16) & 0xff) + array[offset + 3] = ((len >> 24) & 0xff) + } + + static getHeaderLength(array: Uint8Array, offset: int32 = 0): int32 { + return (array[offset] | (array[offset + 1] << 8) | (array[offset + 2] << 16) | (array[offset + 3] << 24)) + } + + // Produces array of bytes with encoded string headed by 4 bytes (little endian) size information: + // [s0][s1][s2][s3] [c_0] ... [c_size-1] + encode(input: string | undefined, addLength: boolean = true): Uint8Array { + let headerLen = addLength ? CustomTextEncoder.HeaderLen : 0 + let result: Uint8Array + if (!input) { + result = new Uint8Array(headerLen) + } else if (this.encoder !== undefined) { + result = this.encoder!.encode('s'.repeat(headerLen) + input) + } else { + let length = this.encodedLength(input) + result = new Uint8Array(length + headerLen) + this.encodeInto(input, result, headerLen) + } + if (addLength) { + this.addLength(result, 0, result.length - headerLen) + } + return result + } + + // Produces encoded array of strings with size information. + encodeArray(strings: Array): Uint8Array { + let totalBytes = CustomTextEncoder.HeaderLen + let lengths = new Int32Array(strings.length) + for (let i = 0; i < lengths.length; i++) { + let len = this.encodedLength(strings[i]) + lengths[i] = len + totalBytes += len + CustomTextEncoder.HeaderLen + } + let array = new Uint8Array(totalBytes) + let position = 0 + this.addLength(array, position, lengths.length) + position += CustomTextEncoder.HeaderLen + for (let i = 0; i < lengths.length; i++) { + this.addLength(array, position, lengths[i]) + position += CustomTextEncoder.HeaderLen + this.encodeInto(strings[i], array, position) + position += lengths[i] + } + return array + } + + encodeInto(input: string, result: Uint8Array, position: int32): Uint8Array { + if (this.encoder !== undefined) { + this.encoder!.encodeInto(input, result.subarray(position, result.length)) + return result + } + let index = position + for (let stringPosition = 0; stringPosition < input.length; stringPosition++) { + let cp = input.codePointAt(stringPosition)! + if (cp < 0x80) { + result[index++] = (cp | 0) + } else if (cp < 0x800) { + result[index++] = ((cp >> 6) | 0xc0) + result[index++] = ((cp & 0x3f) | 0x80) + } else if (cp < 0x10000) { + result[index++] = ((cp >> 12) | 0xe0) + result[index++] = (((cp >> 6) & 0x3f) | 0x80) + result[index++] = ((cp & 0x3f) | 0x80) + } else { + result[index++] = ((cp >> 18) | 0xf0) + result[index++] = (((cp >> 12) & 0x3f) | 0x80) + result[index++] = (((cp >> 6) & 0x3f) | 0x80) + result[index++] = ((cp & 0x3f) | 0x80) + stringPosition++ + } + } + result[index] = 0 + return result + } +} + +export class CustomTextDecoder { + static cpArrayMaxSize = 128 + constructor(decoder: SystemTextDecoder|undefined = ((typeof TextDecoder != "undefined") ? new TextDecoder() : undefined)) { + this.decoder = decoder + } + + private readonly decoder: SystemTextDecoder|undefined + + decode(input: Uint8Array): string { + if (this.decoder !== undefined) { + return this.decoder!.decode(input) + } + const cpSize = Math.min(CustomTextDecoder.cpArrayMaxSize, input.length) + let codePoints = new Int32Array(cpSize) + let cpIndex = 0; + let index = 0 + let result = "" + while (index < input.length) { + let elem = input[index] + let lead = elem & 0xff + let count = 0 + let value = 0 + if (lead < 0x80) { + count = 1 + value = elem + } else if ((lead >> 5) == 0x6) { + value = ((elem << 6) & 0x7ff) + (input[index + 1] & 0x3f) + count = 2 + } else if ((lead >> 4) == 0xe) { + value = ((elem << 12) & 0xffff) + ((input[index + 1] << 6) & 0xfff) + + (input[index + 2] & 0x3f) + count = 3 + } else if ((lead >> 3) == 0x1e) { + value = ((elem << 18) & 0x1fffff) + ((input[index + 1] << 12) & 0x3ffff) + + ((input[index + 2] << 6) & 0xfff) + (input[index + 3] & 0x3f) + count = 4 + } + codePoints[cpIndex++] = value + if (cpIndex == cpSize) { + cpIndex = 0 + result += String.fromCodePoint(...codePoints) + } + index += count + } + if (cpIndex > 0) { + result += String.fromCodePoint(...codePoints.slice(0, cpIndex)) + } + return result + } +} diff --git a/ets1.2/compat/src/typescript/ts-reflection.ts b/ets1.2/compat/src/typescript/ts-reflection.ts new file mode 100644 index 0000000000000000000000000000000000000000..8afbf82663e19eb4ab341e6d3ac7692c28321f40 --- /dev/null +++ b/ets1.2/compat/src/typescript/ts-reflection.ts @@ -0,0 +1,35 @@ +/* + * 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. + */ + +export function className(object?: Object): string { + return object?.constructor.name ?? "" +} + +export function isFunction(object?: Object): boolean { + return typeof object === 'function' +} + +// Improve: this is to match arkts counterpart +export function functionOverValue(value: Value|(()=>Value)): boolean { + return typeof value === 'function' +} + +export function refEqual(a: Value, b: Value): boolean { + return a === b +} + +export function isNotPrimitive(value: Object): boolean { + return true +} diff --git a/ets1.2/compat/src/typescript/types.ts b/ets1.2/compat/src/typescript/types.ts new file mode 100644 index 0000000000000000000000000000000000000000..8ae746ed00df3168a192c2f837c9f9ade45b6159 --- /dev/null +++ b/ets1.2/compat/src/typescript/types.ts @@ -0,0 +1,48 @@ +/* + * 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. + */ + +/// +export type uint8 = int +export type int8 = int +export type int16 = int +export type int32 = int +export type uint32 = int +export type int64 = long +export type uint64 = long +export type float32 = float +export type float64 = double + +export {} +declare global { + export interface Number { + toByte(): int + toShort(): int + toInt(): int + toLong(): long + toFloat(): float + toDouble(): double + } +} +Number.prototype.toByte = function() { return (this as Number | 0) as number; } + +Number.prototype.toShort = function() { return (this as Number | 0) as number; } + +Number.prototype.toInt = function() { return (this as Number | 0) as number; } + +Number.prototype.toLong = function() { return (this as Number | 0) as number; } + +Number.prototype.toFloat = function() { return this as number; } + +Number.prototype.toDouble = function() { return this as number; } diff --git a/ets1.2/compat/src/typescript/utils.ts b/ets1.2/compat/src/typescript/utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..1169707fa520b1284d29a1a5d3f7422460d31a4e --- /dev/null +++ b/ets1.2/compat/src/typescript/utils.ts @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2024-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. + */ + +export function errorAsString(error: any): string { + if (error instanceof Error) { + return error.stack ?? error.toString() + } + return JSON.stringify(error) +} + +export function unsafeCast(value: unknown): T { + return value as unknown as T +} + +export function scheduleCoroutine(): void {} + +export function memoryStats(): string { + return `none` +} + +export function launchJob(task: () => void): Promise { + return new Promise((resolve, reject) => { + try { + task() + resolve(undefined) + } catch (error) { + reject(error) + } + }) +} + +export class CoroutineLocalValue { + private value: T | undefined = undefined + get(): T | undefined { + return this.value + } + set(value: T | undefined) { + this.value = value + } +} diff --git a/ets1.2/compat/tsconfig.json b/ets1.2/compat/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..595bc28a0a80e17714720a214ec119cb15774206 --- /dev/null +++ b/ets1.2/compat/tsconfig.json @@ -0,0 +1,13 @@ +{ + "extends": "@koalaui/build-common/tsconfig.json", + "compilerOptions": { + "baseUrl": ".", + "rootDir": ".", + "outDir": "build/", + "module": "CommonJS", + "paths": { + "#platform": ["./src/typescript"] + } + }, + "include": ["./src/index.ts", "./src/typescript/**/*"] +} diff --git a/ets1.2/compat/ui2abcconfig.json b/ets1.2/compat/ui2abcconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..fcb140e0b5d235f8337b881d9c3763f10e618a33 --- /dev/null +++ b/ets1.2/compat/ui2abcconfig.json @@ -0,0 +1,13 @@ +{ + "compilerOptions": { + "package": "@koalaui/compat", + "outDir": "build/abc", + "rootDir": "./src/arkts", + "baseUrl": "./src/arkts", + "paths": { + "#platform": ["./"], + "@koalaui/compat": ["../"] + } + }, + "include": ["src/arkts/**/*.ts"] +} diff --git a/ets1.2/gn/__pycache__/npm_util.cpython-310.pyc b/ets1.2/gn/__pycache__/npm_util.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..384813106ad7fbc00d2b8aa908297575234f640e Binary files /dev/null and b/ets1.2/gn/__pycache__/npm_util.cpython-310.pyc differ diff --git a/ets1.2/gn/__pycache__/npm_util.cpython-311.pyc b/ets1.2/gn/__pycache__/npm_util.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7de63ff6afd66de4e137b58fe52f7b3b788fcdf6 Binary files /dev/null and b/ets1.2/gn/__pycache__/npm_util.cpython-311.pyc differ diff --git a/ets1.2/gn/command/npm_util.py b/ets1.2/gn/command/npm_util.py new file mode 100755 index 0000000000000000000000000000000000000000..e32b92f359f790f7a8f7463c54e8a3e123495080 --- /dev/null +++ b/ets1.2/gn/command/npm_util.py @@ -0,0 +1,91 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# 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 argparse +import shutil +import subprocess +import os +import sys + +NPM_REPO = "https://repo.huaweicloud.com/repository/npm/" + +parser = argparse.ArgumentParser(description="npm command parser") +parser.add_argument("--project-path", help="project directory in koala repo") +parser.add_argument("--node-path", help="nodejs path") +parser.add_argument("--arklink-path", help="ark-link path") +parser.add_argument("--es2panda-path", help="es2panda path") +parser.add_argument("--stdlib-path", help="stdlib path") +parser.add_argument("--target-out-path", help="out directory of built target") +parser.add_argument("--built-file-path", help="result of building") +parser.add_argument("--install", action="store_true", help="request npm install") +parser.add_argument("--install-path", help="path to install in") +parser.add_argument("--run-tasks", nargs='+', help="npm run tasks") + +args = parser.parse_args() + +project_path = args.project_path +koala_log = os.path.join(project_path, "koala_build.log") + +if args.node_path is None: + print("Error: --node-path is expected") + sys.exit(1) + +os.environ["PATH"] = f"{args.node_path}:{os.environ['PATH']}" + +if args.es2panda_path: + os.environ["ES2PANDA_PATH"] = args.es2panda_path +if args.arklink_path: + os.environ["ARKLINK_PATH"] = args.arklink_path +if args.stdlib_path: + os.environ["ETS_STDLIB_PATH"] = args.stdlib_path + +os.environ["PANDA_SDK_PATH"] = os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../ui2abc/build/sdk") + +def run(args, dir = None): + os.chdir(dir or project_path) + + if os.environ.get("KOALA_LOG_STDOUT"): + subprocess.run(["npm"] + args, env=os.environ, text=True, check=True, stderr=subprocess.STDOUT) + return + + result = subprocess.run(["npm"] + args, capture_output=True, env=os.environ, text=True) + with open(koala_log, "a+") as f: + f.write(f"npm args: {args}; project: {project_path}:\n" + result.stdout) + if result.returncode != 0: + f.write(f"npm args: {args}; project: {project_path}:\n" + result.stderr) + print(open(koala_log, "r").read()) + raise Exception("npm failed") + f.close() + +def install(dir = None): + run(["install", "--registry", NPM_REPO, "--verbose"], dir or project_path) + +def copy_target(): + if not os.path.exists(args.built_file_path): + print(f"Error: Built file not found at {args.built_file_path}") + sys.exit(1) + shutil.copy(args.built_file_path, args.target_out_path) + +def main(): + if args.install: + install(args.install_path) + if args.run_tasks: + for task in args.run_tasks: + run(["run", task]) + if args.target_out_path and args.built_file_path: + copy_target() + +if __name__ == '__main__': + main() diff --git a/ets1.2/gn/npm_util.gni b/ets1.2/gn/npm_util.gni new file mode 100644 index 0000000000000000000000000000000000000000..bf1f906cd36a03192b2931e51ecc5d6504678f08 --- /dev/null +++ b/ets1.2/gn/npm_util.gni @@ -0,0 +1,63 @@ +# 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("//build/config/components/ets_frontend/ets2abc_config.gni") + +node_version = "v16.20.2" +host_arch = "${host_os}-${host_cpu}" + +template("npm_cmd") { + action("$target_name") { + script = "//foundation/arkui/ace_engine/frameworks/bridge/arkts_frontend/koala_mirror/gn/command/npm_util.py" + outputs = invoker.outputs + if (defined(invoker.deps)) { + deps = invoker.deps + } + if (defined(invoker.inputs)) { + inputs = invoker.inputs + } + if (defined(invoker.external_deps)) { + external_deps = invoker.external_deps + } + args = [ + "--node-path", rebase_path("//prebuilts/build-tools/common/nodejs/node-${node_version}-${host_arch}/bin"), + "--arklink-path", rebase_path("${static_linker_build_path}"), + "--es2panda-path", rebase_path("${ets2abc_build_path}"), + "--stdlib-path", rebase_path("//arkcompiler/runtime_core/static_core/plugins/ets/stdlib"), + "--project-path", invoker.project_path + ] + if (defined(invoker.target_out_path)) { + args += [ "--target-out-path", invoker.target_out_path ] + } + if (defined(invoker.built_file_path)) { + args += [ "--built-file-path", invoker.built_file_path ] + } + if (defined(invoker.install) && invoker.install) { + args += [ "--install" ] + } + if (defined(invoker.install_path)) { + args += [ "--install-path", invoker.install_path ] + } + if (defined(invoker.run_tasks)) { + args += [ "--run-tasks" ] + invoker.run_tasks + } + } +} + +template("npm_install") { + assert(current_toolchain == host_toolchain, "must be executed with host_toolchain") + forward_variables_from(invoker, "*") + npm_cmd(target_name) { + install = true + } +} \ No newline at end of file diff --git a/ets1.2/interop/.gitignore b/ets1.2/interop/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..44a0964582ad20972cb3bc522a25f96c04a00484 --- /dev/null +++ b/ets1.2/interop/.gitignore @@ -0,0 +1 @@ +*.ini \ No newline at end of file diff --git a/ets1.2/interop/BUILD.gn b/ets1.2/interop/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..f6c9d97d8912b7424a01a32223aecf92e6a8e1d1 --- /dev/null +++ b/ets1.2/interop/BUILD.gn @@ -0,0 +1,55 @@ +# 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("//build/config/components/ets_frontend/ets2abc_config.gni") +import("//build/ohos.gni") +import("//foundation/arkui/ace_engine/ace_config.gni") +import("//foundation/arkui/ace_engine/frameworks/bridge/arkts_frontend/koala_mirror/gn/npm_util.gni") + +koala_root = ".." +interop_root = "" + +node_version = "v16.20.2" +host_arch = "${host_os}-${host_cpu}" + +if (current_toolchain == host_toolchain) { + npm_install("interop_install") { + outputs = [ + "$target_out_dir/interop_install" + ] + project_path = rebase_path(".") + } +} + +npm_cmd("interop.abc") { + outputs = [ + "$target_out_dir/interop.abc" + ] + project_path = rebase_path(".") + run_tasks = [ "build" ] + + deps = [ + "$koala_root/ui2abc:ui2abc" + ] + + external_deps = [ + ets2abc_build_deps, + static_linker_build_deps + ] +} + +group("interop") { + deps = [ + "$interop_root:interop.abc" + ] +} \ No newline at end of file diff --git a/ets1.2/interop/meson_options.txt b/ets1.2/interop/meson_options.txt new file mode 100644 index 0000000000000000000000000000000000000000..0496ac5b57ad30cdc0f1aba0508d6ded4765b766 --- /dev/null +++ b/ets1.2/interop/meson_options.txt @@ -0,0 +1,21 @@ +# 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. + +option('vm_kind', type : 'string', value : '', + description : 'VM type') +option('jdk_dir', type : 'string', value : '', + description : 'A path to JDK root') +option('vmloader', type : 'boolean', value : false, + description : 'Whether to build libvmloader.so') +option('vmloader_apis', type : 'string', value : 'ets', + description : 'APIs to use in libvmloader.so') diff --git a/ets1.2/interop/package.json b/ets1.2/interop/package.json new file mode 100644 index 0000000000000000000000000000000000000000..a08032bdd2991b669c5ad1b05217a78320fa123d --- /dev/null +++ b/ets1.2/interop/package.json @@ -0,0 +1,113 @@ +{ + "name": "@koalaui/interop", + "version": "1.7.9+devel", + "description": "", + "workspaces": [ + "../incremental/build-common", + "../incremental/compat", + "../incremental/common" + ], + "files": [ + "build/lib/src/**/*.js", + "build/lib/src/**/*.d.ts", + "src/**/*", + "index.ts" + ], + "main": "./build/lib/src/interop/index.js", + "exports": { + ".": "./build/lib/src/interop/index.js", + "./*.js": "./build/lib/src/interop/*.js", + "./*": "./build/lib/src/interop/*.js" + }, + "imports": { + "#common/wrappers": { + "browser": "./build/lib/src/wasm/wrappers/index.js", + "node": "./build/lib/src/napi/wrappers/index.js" + }, + "#common/wrappers/*": { + "browser": "./build/lib/src/wasm/wrappers/*.js", + "node": "./build/lib/src/napi/wrappers/*.js", + "default": "./build/lib/src/napi/wrappers/*.js" + } + }, + "types": "index.d.ts", + "typesVersions": { + "*": { + "*": [ + "./build/lib/src/interop/*" + ] + } + }, + "scripts": { + "clean": "rimraf dist build types", + "compile": "ets-tsc -b .", + "compile:release": "ets-tsc -b .", + "build": "node ../ui2abc/fast-arktsc --config ./ui2abcconfig.json --compiler ../incremental/tools/panda/arkts/ui2abc --link-name ./build/interop.abc --simultaneous && ninja ${NINJA_OPTIONS} -f build/abc/build.ninja", + "lint": "eslint src test components", + "test:wasm:coverage": "NODE_OPTIONS='--conditions browser --no-experimental-fetch' nyc mocha", + "test:wasm": "NODE_OPTIONS='--conditions browser --no-experimental-fetch' mocha", + "test:node:coverage": "nyc mocha", + "test:node": "mocha", + "test:coverage": "npm run test:node:coverage", + "test": "npm run test:node", + "watch": "ets-tsc -b . --watch", + "prepare:compiler": "test $(node -e \"console.log(process.platform)\") != \"linux\" && npm run --prefix ../arkoala-arkts/ohos-sdk download || npm run install:toolchain --prefix ../arkoala-arkts/tools/compiler", + "prepare:arm64": "npm run prepare:compiler && npm run install:sysroot:arm64 --prefix ../arkoala-arkts/tools/compiler", + "prepare:arm32": "npm run prepare:compiler && npm run install:sysroot:arm32 --prefix ../arkoala-arkts/tools/compiler", + "configure:native-node-host": "meson setup -D vm_kind=node build-node-host", + "compile:native-node-host": "npm run configure:native-node-host && meson compile -C build-node-host && meson install -C build-node-host", + "configure:native-hzvm-host": "meson setup -D vm_kind=hzvm build-hzvm-host", + "compile:native-hzvm-host": "npm run configure:native-hzvm-host && meson compile -C build-hzvm-host && meson install -C build-hzvm-host", + "configure:native-panda-host": "meson setup -D vm_kind=panda build-panda-host", + "compile:native-panda-host": "npm run configure:native-panda-host && meson compile -C build-panda-host && meson install -C build-panda-host", + "configure:native-kotlin-host": "meson setup -D vm_kind=kotlin build-kotlin-host", + "compile:native-kotlin-host": "npm run configure:native-kotlin-host && meson compile -C build-kotlin-host && meson install -C build-kotlin-host", + "configure:native-panda-linux-x64": "node ./scripts/configure.mjs panda-linux-x64", + "compile:native-panda-linux-x64": "npm run configure:native-panda-linux-x64 && meson compile -C build-panda-linux-x64 && meson install -C build-panda-linux-x64", + "configure:native-panda-linux-arm64": "node ./scripts/configure.mjs panda-linux-arm64", + "compile:native-panda-linux-arm64": "npm run configure:native-panda-linux-arm64 && meson compile -C build-panda-linux-arm64 && meson install -C build-panda-linux-arm64", + "configure:native-panda-windows-x64": "node ./scripts/configure.mjs panda-windows-x64", + "compile:native-panda-windows-x64": "npm run configure:native-panda-windows-x64 && meson compile -C build-panda-windows-x64 && meson install -C build-panda-windows-x64", + "configure:native-panda-macos-x64": "node ./scripts/configure.mjs panda-macos-x64", + "compile:native-panda-macos-x64": "npm run configure:native-panda-macos-x64 && meson compile -C build-panda-macos-x64 && meson install -C build-panda-macos-x64", + "configure:native-panda-macos-arm64": "node ./scripts/configure.mjs panda-macos-arm64", + "compile:native-panda-macos-arm64": "npm run configure:native-panda-macos-arm64 && meson compile -C build-panda-macos-arm64 && meson install -C build-panda-macos-arm64", + "configure:native-jvm-host": "meson setup -D vm_kind=jvm build-jvm-host -D vmloader=true -D jdk_dir=$JAVA_HOME", + "compile:native-jvm-host": "npm run configure:native-jvm-host && meson compile -C build-jvm-host && meson install -C build-jvm-host", + "configure:native-hzvm-ohos-arm64": "npm run prepare:arm64 && node ./scripts/configure.mjs hzvm-ohos-arm64", + "compile:native-hzvm-ohos-arm64": "npm run configure:native-hzvm-ohos-arm64 && meson compile -C build-hzvm-ohos-arm64 && meson install -C build-hzvm-ohos-arm64", + "configure:native-hzvm-ohos-arm32": "npm run prepare:arm32 && node ./scripts/configure.mjs hzvm-ohos-arm32", + "compile:native-hzvm-ohos-arm32": "npm run configure:native-hzvm-ohos-arm32 && meson compile -C build-hzvm-ohos-arm32 && meson install -C build-hzvm-ohos-arm32", + "configure:native-hzvm-ohos": "npm run configure:native-hzvm-ohos-arm64", + "compile:native-hzvm-ohos": "npm run compile:native-hzvm-ohos-arm64", + "configure:native-panda-ohos-arm64": "npm run prepare:arm64 && node ./scripts/configure.mjs panda-ohos-arm64", + "compile:native-panda-ohos-arm64": "npm run configure:native-panda-ohos-arm64 && meson compile -C build-panda-ohos-arm64 && meson install -C build-panda-ohos-arm64", + "configure:native-panda-ohos-arm32": "npm run prepare:arm32 && node ./scripts/configure.mjs panda-ohos-arm32", + "compile:native-panda-ohos-arm32": "npm run configure:native-panda-ohos-arm32 && meson compile -C build-panda-ohos-arm32 && meson install -C build-panda-ohos-arm32", + "configure:native-panda-with-node-host": "npm run configure:native-panda-host && meson setup -D vm_kind=node -D vmloader=true build-node-host-vmloader", + "compile:native-panda-with-node-host": "npm run configure:native-panda-with-node-host && npm run compile:native-panda-host && npm run compile:native-panda-host && meson compile -C build-node-host-vmloader && meson install -C build-node-host-vmloader", + "configure:native-panda-with-hzvm-ohos-arm64": "npm run configure:native-panda-ohos-arm64 && node ./scripts/configure.mjs hzvm-ohos-arm64-vmloader", + "compile:native-panda-with-hzvm-ohos-arm64": "npm run configure:native-panda-with-hzvm-ohos-arm64 && npm run compile:native-panda-ohos-arm64 && meson compile -C build-hzvm-ohos-arm64-vmloader && meson install -C build-hzvm-ohos-arm64-vmloader", + "configure:native-panda-with-hzvm-ohos-arm32": "npm run configure:native-panda-ohos-arm32 && node ./scripts/configure.mjs hzvm-ohos-arm32-vmloader", + "compile:native-panda-with-hzvm-ohos-arm32": "npm run configure:native-panda-with-hzvm-ohos-arm32 && npm run compile:native-panda-ohos-arm32 && meson compile -C build-hzvm-ohos-arm32-vmloader && meson install -C build-hzvm-ohos-arm32-vmloader", + "compile:kotlin:cinterop": "cd src/cpp/kotlin && cinterop -def cinterop-interop_native_module.def -pkg cinterop.interop_native_module -compiler-option -I. -o ../../../build/kotlin-interop/cinterop.interop_native_module", + "compile:kotlin:kt": "konanc ./src/kotlin/*.kt -l ./build/kotlin-interop/cinterop.interop_native_module.klib -p library -o ./build/kotlin-interop/interop", + "compile:kotlin:interop": "rm -rf build/kotlin-interop && npm run compile:kotlin:cinterop && npm run compile:kotlin:kt" + }, + "keywords": [], + "dependencies": { + "@types/node": "^18.0.0", + "@koalaui/common": "1.7.9+devel" + }, + "devDependencies": { + "@ohos/hypium": "1.0.6", + "@types/node": "^18.0.0", + "@typescript-eslint/eslint-plugin": "^5.20.0", + "@typescript-eslint/parser": "^5.20.0", + "eslint": "^8.13.0", + "eslint-plugin-unused-imports": "^2.0.0", + "source-map-support": "^0.5.21", + "@koalaui/ets-tsc": "4.9.5-r5", + "@koalaui/fast-arktsc": "1.5.15" + } +} \ No newline at end of file diff --git a/ets1.2/interop/src/arkts/DeserializerBase.ts b/ets1.2/interop/src/arkts/DeserializerBase.ts new file mode 100644 index 0000000000000000000000000000000000000000..5388affb8487f62b7aaa2df9110bd01b9ac77790 --- /dev/null +++ b/ets1.2/interop/src/arkts/DeserializerBase.ts @@ -0,0 +1,259 @@ +/* + * Copyright (c) 2024-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 { float32, int32, int64 } from "@koalaui/common" +import { pointer, KUint8ArrayPtr, KSerializerBuffer, nullptr } from "./InteropTypes" +import { NativeBuffer } from "./NativeBuffer" +import { InteropNativeModule } from "./InteropNativeModule" +import { Tags, CallbackResource } from "./SerializerBase"; +import { ResourceHolder, Disposable } from "./ResourceManager" + +export class DeserializerBase implements Disposable { + private _position : int64 = 0 + private _buffer: KSerializerBuffer + private readonly _isOwnBuffer: boolean; + private readonly _length: int32 + private readonly _end: int64 + private static customDeserializers: CustomDeserializer | undefined = new DateDeserializer() + + static registerCustomDeserializer(deserializer: CustomDeserializer) { + let current = DeserializerBase.customDeserializers + if (current == undefined) { + DeserializerBase.customDeserializers = deserializer + } else { + while (current!.next != undefined) { + current = current!.next + } + current!.next = deserializer + } + } + + constructor(buffer: KUint8ArrayPtr|KSerializerBuffer, length: int32) { + if (buffer instanceof KUint8ArrayPtr) { + const newBuffer = InteropNativeModule._Malloc(length) + this._isOwnBuffer = true + for (let i = 0; i < length; i++) { + unsafeMemory.writeInt8(newBuffer + i, buffer[i].toByte()) + } + this._buffer = newBuffer + } else { + this._buffer = buffer + } + + const newBuffer = this._buffer; + this._length = length + this._position = newBuffer + this._end = newBuffer + length; + } + + public final dispose() { + if (this._isOwnBuffer) { + InteropNativeModule._Free(this._buffer) + this._buffer = 0 + this._position = 0 + } + } + + final asBuffer(): KSerializerBuffer { + return this._buffer + } + + final currentPosition(): int64 { + return this._position + } + + final resetCurrentPosition(): void { + this._position = this._buffer + } + + final readInt8(): int32 { + const pos = this._position + const newPos = pos + 1 + + if (newPos > this._end) { + throw new Error(`value size(1) is less than remaining buffer length`) + } + + this._position = newPos + return unsafeMemory.readInt8(pos) + } + + final readInt32(): int32 { + const pos = this._position + const newPos = pos + 4 + + if (newPos > this._end) { + throw new Error(`value size(4) is less than remaining buffer length`) + } + + this._position = newPos + return unsafeMemory.readInt32(pos) + } + + final readPointer(): pointer { + const pos = this._position + const newPos = pos + 8 + + if (newPos > this._end) { + throw new Error(`value size(8) is less than remaining buffer length`) + } + + this._position = newPos + return unsafeMemory.readInt64(pos) + } + + final readInt64(): int64 { + const pos = this._position + const newPos = pos + 8 + + if (newPos > this._end) { + throw new Error(`value size(8) is less than remaining buffer length`) + } + + this._position = newPos + return unsafeMemory.readInt64(pos) + } + + final readFloat32(): float32 { + const pos = this._position + const newPos = pos + 4 + + if (newPos > this._end) { + throw new Error(`value size(4) is less than remaining buffer length`) + } + + + this._position = newPos + return unsafeMemory.readFloat32(pos) + } + + final readFloat64(): double { + const pos = this._position + const newPos = pos + 8 + + if (newPos > this._end) { + throw new Error(`value size(8) is less than remaining buffer length`) + } + + + this._position = newPos + return unsafeMemory.readFloat64(pos) + } + + final readBoolean(): boolean { + const pos = this._position + const newPos = pos + 1 + + if (newPos > this._end) { + throw new Error(`value size(1) is less than remaining buffer length`) + } + + + this._position = newPos + const value = unsafeMemory.readInt8(pos); + if (value == Tags.UNDEFINED) + return false; + + return value == 1 + } + + final readCallbackResource(): CallbackResource { + return { + resourceId: this.readInt32(), + hold: this.readPointer(), + release: this.readPointer(), + } + } + + final readString(): string { + const encodedLength = this.readInt32(); + const pos = this._position + const newPos = pos + encodedLength + + if (newPos > this._end) { + throw new Error(`value size(${encodedLength}) is less than remaining buffer length`) + } + + this._position = newPos + // NOTE: skip null-terminated byte + return unsafeMemory.readString(pos, encodedLength - 1) + } + + final readCustomObject(kind: string): object { + let current = DeserializerBase.customDeserializers + while (current) { + if (current!.supports(kind)) { + return current!.deserialize(this, kind) + } + current = current!.next + } + // consume tag + const tag = this.readInt8() + throw Error(`${kind} is not supported`) + } + + final readNumber(): number | undefined { + const pos = this._position + const tag = this.readInt8().toInt() + switch (tag) { + case Tags.UNDEFINED.valueOf(): + return undefined; + case Tags.INT32.valueOf(): + return this.readInt32() + case Tags.FLOAT32.valueOf(): + return this.readFloat32() + default: + throw new Error(`Unknown number tag: ${tag}`) + } + } + + final readObject():object { + const resource = this.readCallbackResource() + return ResourceHolder.instance().get(resource.resourceId) + } + + final readBuffer(): ArrayBuffer { + const resource = this.readCallbackResource() + const data = this.readPointer() + const length = this.readInt64() + InteropNativeModule._CallCallbackResourceHolder(resource.hold, resource.resourceId) + return InteropNativeModule._MaterializeBuffer(data, length, resource.resourceId, resource.hold, resource.release) + } +} + +export abstract class CustomDeserializer { + protected supported: string + protected constructor(supported_: string) { + this.supported = supported_ + } + + supports(kind: string): boolean { + return this.supported.includes(kind) + } + + abstract deserialize(serializer: DeserializerBase, kind: string): object + + next: CustomDeserializer | undefined = undefined +} + +class DateDeserializer extends CustomDeserializer { + constructor() { + super("Date") + } + + deserialize(serializer: DeserializerBase, kind: string): Date { + return new Date(serializer.readString()) + } +} \ No newline at end of file diff --git a/ets1.2/interop/src/arkts/Finalizable.ts b/ets1.2/interop/src/arkts/Finalizable.ts new file mode 100644 index 0000000000000000000000000000000000000000..b2421b1eee73475431812919670eb5dc8aa45265 --- /dev/null +++ b/ets1.2/interop/src/arkts/Finalizable.ts @@ -0,0 +1,109 @@ +/* + * 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 { finalizerRegister, finalizerUnregister, Thunk } from "@koalaui/common" +import { InteropNativeModule } from "./InteropNativeModule" +import { pointer, nullptr } from "./InteropTypes" + +class NativeThunk implements Thunk { + finalizer: pointer + obj: pointer + name: string|undefined + + constructor(obj: pointer, finalizer: pointer, name?: string) { + this.finalizer = finalizer + this.obj = obj + this.name = name + } + + clean() { + if (this.obj != nullptr) { + this.destroyNative(this.obj, this.finalizer) + } + this.obj = nullptr + } + + destroyNative(ptr: pointer, finalizer: pointer): void { + InteropNativeModule._InvokeFinalizer(ptr, finalizer) + } +} + +/** + * Class with the custom finalizer, usually used to release a native peer. + * Do not use directly, only via subclasses. + */ +export class Finalizable { + ptr: pointer + finalizer: pointer + cleaner: NativeThunk|undefined = undefined + managed: boolean + + constructor(ptr: pointer, finalizer: pointer) { + this.init(ptr, finalizer, true) + } + + constructor(ptr: pointer, finalizer: pointer, managed: boolean) { + this.init(ptr, finalizer, managed) + } + + init(ptr: pointer, finalizer: pointer, managed: boolean) { + this.ptr = ptr + this.finalizer = finalizer + this.managed = managed + const handle = undefined + + if (managed) { + if (this.ptr == nullptr) throw new Error("Can't have nullptr ptr ${}") + if (this.finalizer == nullptr) throw new Error("Managed finalizer is 0") + + const thunk = new NativeThunk(ptr, finalizer, handle) + finalizerRegister(this, thunk) + this.cleaner = thunk + } + } + + close() { + if (this.ptr == nullptr) { + throw new Error(`Closing a closed object: ` + this.toString()) + } else if (this.cleaner == undefined) { + throw new Error(`No thunk assigned to ` + this.toString()) + } else { + finalizerUnregister(this) + this.cleaner!.clean() + this.cleaner = undefined + this.ptr = nullptr + } + } + + release(): pointer { + finalizerUnregister(this) + if (this.cleaner) + this.cleaner!.obj = nullptr + let result = this.ptr + this.ptr = nullptr + return result + } + + resetPeer(pointer: pointer) { + if (this.managed) throw new Error("Can only reset peer for an unmanaged object") + this.ptr = pointer + } + + use(body: (value: Finalizable) => R): R { + let result = body(this) + this.close() + return result + } +} diff --git a/ets1.2/interop/src/arkts/InteropNativeModule.ts b/ets1.2/interop/src/arkts/InteropNativeModule.ts new file mode 100644 index 0000000000000000000000000000000000000000..53a57ef9756141ecda2e651845c3fb89dcacb04d --- /dev/null +++ b/ets1.2/interop/src/arkts/InteropNativeModule.ts @@ -0,0 +1,81 @@ +/* + * Copyright (c) 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 { int32, int64 } from "@koalaui/common"; +import { KPointer, KUint8ArrayPtr, KInt, KSerializerBuffer } from "./InteropTypes"; +import { callCallback } from "./callback" +import { loadNativeModuleLibrary } from "./loadLibraries" + +export class InteropNativeModule { + static { + loadNativeModuleLibrary("InteropNativeModule") + } + static callCallbackFromNative(id: KInt, args: KSerializerBuffer, length: KInt): KInt { + return callCallback(id, args, length) + } + native static _GetGroupedLog(index: int32): KPointer + native static _StartGroupedLog(index: int32): void + native static _StopGroupedLog(index: int32): void + native static _AppendGroupedLog(index: int32, message: string): void + native static _PrintGroupedLog(index: int32): void + native static _GetStringFinalizer(): KPointer + native static _InvokeFinalizer(ptr1: KPointer, ptr2: KPointer): void + native static _IncrementNumber(value: number): number + native static _GetPtrVectorElement(ptr1: KPointer, arg: int32): KPointer + native static _StringLength(ptr1: KPointer): int32 + native static _StringData(ptr1: KPointer, array: KUint8ArrayPtr, arrayLength: int32): void + native static _StringMake(str1: string): KPointer + native static _GetPtrVectorSize(ptr1: KPointer): int32 + @ani.unsafe.Quick + native static _ManagedStringWrite(str1: string, array: KPointer, arrayLength: int32, arg: int32): int32 + native static _NativeLog(str1: string): void + @ani.unsafe.Quick + native static _Utf8ToString(data: KPointer, offset: int32, length: int32): string + native static _StdStringToString(cstring: KPointer): string + @ani.unsafe.Direct + native static _CheckCallbackEvent(buffer: KSerializerBuffer, bufferLength: int32): int32 + native static _HoldCallbackResource(resourceId: int32): void + native static _ReleaseCallbackResource(resourceId: int32): void + native static _CallCallback(apiKind: int32, callbackKind: int32, args: KSerializerBuffer, argsSize: int32): void + native static _CallCallbackSync(apiKind: int32, callbackKind: int32, args: KSerializerBuffer, argsSize: int32): void + native static _CallCallbackResourceHolder(holder: KPointer, resourceId: int32): void + native static _CallCallbackResourceReleaser(releaser: KPointer, resourceId: int32): void + native static _CallbackAwait(pipeline: KPointer): Object + native static _UnblockCallbackWait(pipeline: KPointer): void + + native static _LoadVirtualMachine(arg0: int32, arg1: string, arg2: string, arg3: string): int32 + native static _RunApplication(arg0: int32, arg1: int32): boolean + native static _StartApplication(appUrl: string, appParams: string): KPointer + native static _EmitEvent(eventType: int32, target: int32, arg0: int32, arg1: int32): string + native static _CallForeignVM(context:KPointer, callback: int32, data: KSerializerBuffer, dataLength: int32): int32 + native static _SetForeignVMContext(context: KPointer): void + native static _RestartWith(page: string): void + @ani.unsafe.Direct + native static _ReadByte(data: KPointer, index: int64, length: int64): int32 + @ani.unsafe.Direct + native static _WriteByte(data: KPointer, index: int64, length: int64, value: int32): void + @ani.unsafe.Direct + native static _Malloc(length: int64): KPointer + @ani.unsafe.Direct + native static _GetMallocFinalizer(): KPointer + @ani.unsafe.Direct + native static _Free(data: KPointer): void + @ani.unsafe.Quick + native static _CopyArray(data: KPointer, length: int64, args: KUint8ArrayPtr): void + native static _ReportMemLeaks(): void + native static _MaterializeBuffer(data: KPointer, length: int64, resourceId: int32, hold: KPointer, release: KPointer): ArrayBuffer + native static _GetNativeBufferPointer(data: ArrayBuffer): KPointer +} + diff --git a/ets1.2/interop/src/arkts/InteropTypes.ts b/ets1.2/interop/src/arkts/InteropTypes.ts new file mode 100644 index 0000000000000000000000000000000000000000..b01abe95557048eed4c000def9b9f0a649a4035b --- /dev/null +++ b/ets1.2/interop/src/arkts/InteropTypes.ts @@ -0,0 +1,36 @@ +/* + * 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. + */ + +export type NodePointer = pointer // Improve: move to NativeModule + +export type KStringPtr = string +export type KStringPtrArray = FixedArray +export type KUint8ArrayPtr = FixedArray +export type KInt32ArrayPtr = FixedArray +export type KFloat32ArrayPtr = FixedArray +export type KInt = int +export type KLong = long +export type KUInt = KInt +export type KBoolean = int +export type KFloat = float +export type KDouble = double; +export type KPointer = long // look once again +export type pointer = KPointer +export type KNativePointer = KPointer +export type KInteropReturnBuffer = FixedArray +export type KSerializerBuffer = pointer + +export const nullptr: pointer = 0 + diff --git a/ets1.2/interop/src/arkts/MaterializedBase.ts b/ets1.2/interop/src/arkts/MaterializedBase.ts new file mode 100644 index 0000000000000000000000000000000000000000..335ee78047b7ee47ce63a94be96386ad8cc2c188 --- /dev/null +++ b/ets1.2/interop/src/arkts/MaterializedBase.ts @@ -0,0 +1,26 @@ +/* + * Copyright (c) 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 { Finalizable } from "./Finalizable" + +export class MaterializedBaseTag { + static NOP = new MaterializedBaseTag() + private constructor() { } +} + +export interface MaterializedBase { + getPeer(): Finalizable | undefined +} + diff --git a/ets1.2/interop/src/arkts/NativeBuffer.ts b/ets1.2/interop/src/arkts/NativeBuffer.ts new file mode 100644 index 0000000000000000000000000000000000000000..a6dceba23ff04f82cdbffaad4704570fe023580d --- /dev/null +++ b/ets1.2/interop/src/arkts/NativeBuffer.ts @@ -0,0 +1,82 @@ +/* + * Copyright (c) 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 { pointer, KSerializerBuffer, nullptr } from './InteropTypes' +import { int32, int64 } from '@koalaui/common' +import { InteropNativeModule } from "./InteropNativeModule" +import { Disposable } from "./ResourceManager" +import { Finalizable } from './Finalizable' + +export final class NativeBuffer { + public data: pointer + public length: int64 + protected finalizable: Finalizable + + constructor(length: int64) { + this(InteropNativeModule._Malloc(length), length, InteropNativeModule._GetMallocFinalizer()) + } + + constructor(data: pointer, length: int64, destroy: pointer) { + this.data = data + this.length = length + this.finalizable = new Finalizable(data, destroy) + } + + public readByte(index:int64): int32 { + return unsafeMemory.readInt8(this.data + index) + } + + public writeByte(index:int64, value: int32): void { + unsafeMemory.writeInt8(this.data + index, value.toByte()) + } +} + +export class KBuffer implements Disposable { + private _buffer: KSerializerBuffer + private readonly _length: int64 + private readonly _owned: boolean + constructor(length: int64) { + this._buffer = InteropNativeModule._Malloc(length) + this._length = length + this._owned = true + } + constructor(buffer: KSerializerBuffer, length: int64) { + this._buffer = buffer + this._length = length + this._owned = false + } + + dispose(): void { + if (this._owned && this._buffer != nullptr) { + InteropNativeModule._Free(this._buffer) + this._buffer = nullptr + } + } + + public get buffer(): KSerializerBuffer { + return this._buffer + } + + public get length(): int64 { + return this._length + } + + public get(index: int64): byte { + return unsafeMemory.readInt8(this._buffer + index) + } + public set(index: int64, value: byte): void { + unsafeMemory.writeInt8(this._buffer + index, value) + } +} \ No newline at end of file diff --git a/ets1.2/interop/src/arkts/ResourceManager.ts b/ets1.2/interop/src/arkts/ResourceManager.ts new file mode 100644 index 0000000000000000000000000000000000000000..2bbb72ecb75e2d9fcb3396d9d2608f215adb2e37 --- /dev/null +++ b/ets1.2/interop/src/arkts/ResourceManager.ts @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { int32, float64toInt32 } from "@koalaui/common" + +export type ResourceId = int32 + +interface ResourceInfo { + resource: object + holdersCount: int32 +} + +export interface Disposable { + dispose(): void; +} + +export class ResourceHolder { + private static nextResourceId: ResourceId = 100 + private resources: Map = new Map() + private static _instance: ResourceHolder|undefined = undefined + private static disposables = new Array(); + private static disposablesSize = 0 + + static instance(): ResourceHolder { + if (ResourceHolder._instance == undefined) { + ResourceHolder._instance = new ResourceHolder() + } + return ResourceHolder._instance! + } + + public hold(resourceId: ResourceId) { + if (!this.resources.has(resourceId)) + throw new Error(`Resource ${resourceId} does not exists, can not hold`) + this.resources.get(resourceId)!.holdersCount++ + } + + public release(resourceId: ResourceId) { + if (!this.resources.has(resourceId)) + throw new Error(`Resource ${resourceId} does not exists, can not release`) + const resource = this.resources.get(resourceId)! + resource.holdersCount-- + if (resource.holdersCount <= 0) + this.resources.delete(resourceId) + } + + public registerAndHold(resource: object): ResourceId { + const resourceId = ResourceHolder.nextResourceId++ + this.resources.set(resourceId, { + resource: resource, + holdersCount: 1, + }) + return resourceId + } + + public get(resourceId: ResourceId): object { + if (!this.resources.has(resourceId)) + throw new Error(`Resource ${resourceId} does not exists`) + return this.resources.get(resourceId)!.resource + } + + public has(resourceId: ResourceId): boolean { + return this.resources.has(resourceId) + } + + static register(resource: Disposable) { + if (ResourceHolder.disposablesSize < ResourceHolder.disposables.length) { + ResourceHolder.disposables[ResourceHolder.disposablesSize] = resource + } else { + ResourceHolder.disposables.push(resource) + } + ResourceHolder.disposablesSize++ + } + + static unregister(resource: Disposable) { + const index = float64toInt32(ResourceHolder.disposables.indexOf(resource)); + if (index !== -1 && index < ResourceHolder.disposablesSize) { + if (index !== ResourceHolder.disposablesSize - 1) { + ResourceHolder.disposables[index] = ResourceHolder.disposables[ResourceHolder.disposablesSize - 1]; + } + ResourceHolder.disposablesSize--; + } + } + + static disposeAll() { + for (let i = 0; i < ResourceHolder.disposablesSize; ++i) { + ResourceHolder.disposables[i].dispose() + } + ResourceHolder.disposablesSize = 0 + } + + static compactDisposables() { + ResourceHolder.disposables = ResourceHolder.disposables.slice(0, ResourceHolder.disposablesSize); + } +} diff --git a/ets1.2/interop/src/arkts/SerializerBase.ts b/ets1.2/interop/src/arkts/SerializerBase.ts new file mode 100644 index 0000000000000000000000000000000000000000..992546fcf976c6b530eb47543fb28a73cfbe5fdc --- /dev/null +++ b/ets1.2/interop/src/arkts/SerializerBase.ts @@ -0,0 +1,424 @@ +/* + * Copyright (c) 2024-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 { float32, int32, int64 } from "@koalaui/common" +import { pointer, nullptr, KSerializerBuffer } from "./InteropTypes" +import { ResourceId, ResourceHolder, Disposable } from "./ResourceManager" +import { NativeBuffer } from "./NativeBuffer" +import { InteropNativeModule } from "./InteropNativeModule" +import { MaterializedBase } from "./MaterializedBase" + +/** + * Value representing possible JS runtime object type. + * Must be synced with "enum RuntimeType" in C++. + */ +export final class RuntimeType { + static readonly UNEXPECTED = -1 + static readonly NUMBER = 1 + static readonly STRING = 2 + static readonly OBJECT = 3 + static readonly BOOLEAN = 4 + static readonly UNDEFINED = 5 + static readonly BIGINT = 6 + static readonly FUNCTION = 7 + static readonly SYMBOL = 8 + static readonly MATERIALIZED = 9 +} + +export function registerCallback(value: object): int32 { + throw new Error("Should no longer be used") +} + +/** + * Value representing object type in serialized data. + * Must be synced with "enum Tags" in C++. + */ +export enum Tags { + UNDEFINED = 101, + INT32 = 102, + FLOAT32 = 103, + STRING = 104, + LENGTH = 105, + RESOURCE = 106, + OBJECT = 107, +} + +const VALUE_TRUE: number = 1 +const VALUE_FALSE: number = 0 + +export function runtimeType(value: T): int32 { + if (value === undefined) + return RuntimeType.UNDEFINED; + + if (value === null) + return RuntimeType.OBJECT; + + if (value instanceof String) + return RuntimeType.STRING + + if (value instanceof Numeric) + return RuntimeType.NUMBER + + if (value instanceof Boolean) + return RuntimeType.BOOLEAN + + if (value instanceof BigInt) + return RuntimeType.BIGINT + + if (value instanceof Function) + return RuntimeType.FUNCTION + + // slow workaround for enum + const typeName = typeof value + if (typeName == "number") + return RuntimeType.NUMBER + + if (typeName == "string") + return RuntimeType.STRING + + return RuntimeType.OBJECT +} + +export function toPeerPtr(value: object): pointer { + if (value instanceof MaterializedBase) { + const peer = (value as MaterializedBase).getPeer() + return peer ? peer.ptr : nullptr + } else { + throw new Error("Value is not a MaterializedBase instance") + } +} + +export interface CallbackResource { + resourceId: int32 + hold: pointer + release: pointer +} + +/* Serialization extension point */ +export abstract class CustomSerializer { + protected supported: Array + constructor(supported: Array) { + this.supported = supported + } + supports(kind: string): boolean { return this.supported.includes(kind) } + abstract serialize(serializer: SerializerBase, value: object, kind: string): void + next: CustomSerializer | undefined = undefined +} + +class DateSerializer extends CustomSerializer { + constructor() { + super(new Array("Date")) + } + + serialize(serializer: SerializerBase, value: object, kind: string): void { + serializer.writeString((value as Date).toISOString()) + } +} +SerializerBase.registerCustomSerializer(new DateSerializer()) + +export class SerializerBase implements Disposable { + private _position: int64 = 0 + private _buffer: KSerializerBuffer + private _length: int32 + private _last: int64 + + private static pool: SerializerBase[] = [ + new SerializerBase(), + new SerializerBase(), + new SerializerBase(), + new SerializerBase(), + new SerializerBase(), + new SerializerBase(), + new SerializerBase(), + new SerializerBase(), + ] + private static poolTop = 0 + + static hold(): SerializerBase { + if (SerializerBase.poolTop === SerializerBase.pool.length) { + throw new Error("Pool empty! Release one of taken serializers") + } + return SerializerBase.pool[SerializerBase.poolTop++] + } + + private static customSerializers: CustomSerializer | undefined = new DateSerializer() + static registerCustomSerializer(serializer: CustomSerializer) { + if (SerializerBase.customSerializers == undefined) { + SerializerBase.customSerializers = serializer + } else { + let current = SerializerBase.customSerializers + while (current!.next != undefined) { + current = current!.next + } + current!.next = serializer + } + } + + constructor() { + let length = 96 + this._buffer = InteropNativeModule._Malloc(length.toLong()) + this._length = length + this._position = this._buffer + this._last = this._buffer + length - 1; + } + + public release() { + this.releaseResources() + this._position = this._buffer + if (this !== SerializerBase.pool[SerializerBase.poolTop - 1]) { + throw new Error("Serializers should be release in LIFO order") + } + SerializerBase.poolTop-- + } + public final dispose() { + InteropNativeModule._Free(this._buffer) + this._buffer = nullptr + } + + final asBuffer(): KSerializerBuffer { + return this._buffer + } + final length(): int32 { + return (this._position - this._buffer).toInt() + } + + final toArray(): byte[] { + const len = this.length() + let result = new byte[len] + for (let i = 0; i < len; i++) { + result[i] = unsafeMemory.readInt8(this._buffer + i) + } + return result + } + + private final updateCapacity(value: int32) { + let buffSize = this._length + const minSize = buffSize + value + const resizedSize = Math.max(minSize, Math.round(3 * buffSize / 2)).toInt() + if (value <= 0 || resizedSize <= 0) { + throw new Error(`bug: value(${value}) resizedSize(${resizedSize}) is illegal`) + } + let resizedBuffer = InteropNativeModule._Malloc(resizedSize) + let oldBuffer = this._buffer + let offset = this._position - oldBuffer; + for (let i = 0; i < offset; i++) { + let val = unsafeMemory.readInt8(oldBuffer + i); + unsafeMemory.writeInt8(resizedBuffer + i, val) + } + this._buffer = resizedBuffer + this._position = this._position - oldBuffer + resizedBuffer + this._length = resizedSize + this._last = resizedBuffer + resizedSize - 1; + InteropNativeModule._Free(oldBuffer) + } + + private heldResources: Array = new Array() + private heldResourcesCount: int32 = 0 + private final addHeldResource(resourceId: ResourceId) { + if (this.heldResourcesCount == this.heldResources.length) + this.heldResources.push(resourceId) + else + this.heldResources[this.heldResourcesCount] = resourceId + this.heldResourcesCount++ + } + final holdAndWriteCallback(callback: object, hold: pointer = 0, release: pointer = 0, call: pointer = 0, callSync: pointer = 0): ResourceId { + const resourceId = ResourceHolder.instance().registerAndHold(callback) + this.addHeldResource(resourceId) + this.writeInt32(resourceId) + this.writePointer(hold) + this.writePointer(release) + this.writePointer(call) + this.writePointer(callSync) + return resourceId + } + final holdAndWriteCallbackForPromiseVoid(hold: pointer = 0, release: pointer = 0, call: pointer = 0): [Promise, ResourceId] { + let resourceId: ResourceId = 0 + const promise = new Promise((resolve: (value: PromiseLike) => void, reject: (err: Error) => void) => { + const callback = (err?: string[] | undefined) => { + if (err !== undefined) + reject(new Error(err!.join(';'))) + else + resolve(Promise.resolve()) + } + resourceId = this.holdAndWriteCallback(callback, hold, release, call) + }) + return [promise, resourceId] + } + final holdAndWriteCallbackForPromise(hold: pointer = 0, release: pointer = 0, call: pointer = 0): [Promise, ResourceId] { + let resourceId: ResourceId = 0 + const promise = new Promise((resolve: (value: T | PromiseLike) => void, reject: (err: Error) => void) => { + const callback = (value?: T | undefined, err?: string[] | undefined) => { + if (err !== undefined) + reject(new Error(err!.join(';'))) + else + resolve(value!) + } + resourceId = this.holdAndWriteCallback(callback, hold, release, call) + }) + return [promise, resourceId] + } + final holdAndWriteObject(obj: object, hold: pointer = 0, release: pointer = 0): ResourceId { + const resourceId = ResourceHolder.instance().registerAndHold(obj) + this.addHeldResource(resourceId) + this.writeInt32(resourceId) + this.writePointer(hold) + this.writePointer(release) + return resourceId + } + final writeCallbackResource(resource: CallbackResource) { + this.writeInt32(resource.resourceId) + this.writePointer(resource.hold) + this.writePointer(resource.release) + } + final writeResource(resource: object) { + const resourceId = ResourceHolder.instance().registerAndHold(resource) + this.addHeldResource(resourceId) + this.writeInt32(resourceId) + } + private final releaseResources() { + if (this.heldResourcesCount == 0) return + for (let i = 0; i < this.heldResourcesCount; i++) { + InteropNativeModule._ReleaseCallbackResource(this.heldResources[i]) + } + this.heldResourcesCount = 0 + } + final writeCustomObject(kind: string, value: object) { + let current = SerializerBase.customSerializers + while (current) { + if (current!.supports(kind)) { + current!.serialize(this, value, kind) + return + } + current = current!.next + } + this.writeInt8(Tags.UNDEFINED.valueOf()) + } + final writeTag(tag: int32): void { + this.writeInt8(tag) + } + final writeNumber(value: number | undefined) { + if (value == undefined) { + this.writeTag(Tags.UNDEFINED) + return + } + if (Number.isInteger(value)) { + this.writeTag(Tags.INT32) + this.writeInt32(value.toInt()) + } else { + this.writeInt8(Tags.FLOAT32) + this.writeFloat32(value.toFloat()) + } + } + + final writeInt8(value: int32) { + let pos = this._position + let newPos = pos + 1 + if (newPos > this._last) { + this.updateCapacity(1) + pos = this._position + newPos = pos + 1 + } + + unsafeMemory.writeInt8(pos, value.toByte()) + this._position = newPos + } + + final writeInt32(value: int32) { + let pos = this._position + let newPos = pos + 4 + if (newPos > this._last) { + this.updateCapacity(4) + pos = this._position + newPos = pos + 4 + } + unsafeMemory.writeInt32(pos, value) + this._position = newPos + } + final writeInt64(value: int64) { + let pos = this._position + let newPos = pos + 8 + if (newPos > this._last) { + this.updateCapacity(8) + pos = this._position + newPos = pos + 8 + } + unsafeMemory.writeInt64(pos, value) + this._position = newPos + } + final writeFloat32(value: float32) { + let pos = this._position + let newPos = pos + 4 + if (newPos > this._last) { + this.updateCapacity(4) + pos = this._position + newPos = pos + 4 + } + unsafeMemory.writeFloat32(pos, value) + this._position = newPos + } + final writeFloat64(value: double) { + let pos = this._position + let newPos = pos + 8 + if (newPos > this._last) { + this.updateCapacity(8) + pos = this._position + newPos = pos + 8 + } + unsafeMemory.writeFloat64(pos, value) + this._position = newPos + } + final writePointer(value: pointer) { + this.writeInt64(value) + } + final writeBoolean(value: boolean | undefined) { + let pos = this._position + let newPos = pos + 1 + if (newPos > this._last) { + this.updateCapacity(1) + pos = this._position + newPos = pos + 1 + } + this._position = newPos + + if (value == undefined) + unsafeMemory.writeInt8(pos, Tags.UNDEFINED); + else if (value == true) + unsafeMemory.writeInt8(pos, VALUE_TRUE.toByte()); + else if (value == false) + unsafeMemory.writeInt8(pos, VALUE_FALSE.toByte()); + } + final writeString(value: string) { + const encodedLength = unsafeMemory.getStringSizeInBytes(value) + + let pos = this._position + if (pos + encodedLength + 5 > this._last) { + this.updateCapacity(encodedLength + 5) + pos = this._position + } + + if (encodedLength > 0) + unsafeMemory.writeString(pos + 4, value) + // NOTE: add \0 for supporting C char* reading from buffer for utf8-strings, + // need check native part fot utf16 cases and probably change this solution. + unsafeMemory.writeInt8(pos + encodedLength + 4, 0) + unsafeMemory.writeInt32(pos, encodedLength + 1) + this._position = pos + encodedLength + 4 + 1 + } + final writeBuffer(value: ArrayBuffer) { + this.holdAndWriteObject(value) + const ptr = InteropNativeModule._GetNativeBufferPointer(value) + this.writePointer(ptr) + this.writeInt64(value.byteLength) + } +} diff --git a/ets1.2/interop/src/arkts/callback.ts b/ets1.2/interop/src/arkts/callback.ts new file mode 100644 index 0000000000000000000000000000000000000000..ea7eac29623f62bb59f08f4694c42c226e8d0aec --- /dev/null +++ b/ets1.2/interop/src/arkts/callback.ts @@ -0,0 +1,92 @@ +/* + * 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 { KUint8ArrayPtr, KSerializerBuffer } from "./InteropTypes" +import { int32 } from "@koalaui/common" + +export type CallbackType = (args: KSerializerBuffer, length: int32) => int32 + +class CallbackRecord { + public readonly callback: CallbackType + public readonly autoDisposable: boolean + + constructor( + callback: CallbackType, + autoDisposable: boolean + ) { + this.callback = callback + this.autoDisposable = autoDisposable + } +} + +class CallbackRegistry { + + static INSTANCE = new CallbackRegistry() + + private callbacks = new Map() + private id = 1024 + + constructor() { + this.callbacks.set(0, new CallbackRecord( + (args: KSerializerBuffer, length: int32): int32 => { + console.log(`Callback 0 called with args = ${args} and length = ${length}`) + throw new Error(`Null callback called`) + }, false) + ) + } + + wrap(callback: CallbackType, autoDisposable: boolean): int32 { + const id = this.id++ + this.callbacks.set(id, new CallbackRecord(callback, autoDisposable)) + return id + } + + wrapSystem(id: int32, callback: CallbackType, autoDisposable: boolean): int32 { + this.callbacks.set(id, new CallbackRecord(callback, autoDisposable)) + return id + } + + call(id: int32, args: KSerializerBuffer, length: int32): int32 { + const record = this.callbacks.get(id) + if (!record) { + console.log(`Callback ${id} is not known`) + throw new Error(`Disposed or unwrapped callback called (id = ${id})`) + } + if (record.autoDisposable) { + this.dispose(id) + } + return record.callback(args, length) + } + + dispose(id: int32) { + this.callbacks.delete(id) + } +} + +export function wrapCallback(callback: CallbackType, autoDisposable: boolean = true): int32 { + return CallbackRegistry.INSTANCE.wrap(callback, autoDisposable) +} + +export function wrapSystemCallback(id:int32, callback: CallbackType): int32 { + return CallbackRegistry.INSTANCE.wrapSystem(id, callback, false) +} + +export function disposeCallback(id: int32) { + CallbackRegistry.INSTANCE.dispose(id) +} + +export function callCallback(id: int32, args: KSerializerBuffer, length: int32): int32 { + return CallbackRegistry.INSTANCE.call(id, args, length) +} diff --git a/ets1.2/interop/src/arkts/events.ts b/ets1.2/interop/src/arkts/events.ts new file mode 100644 index 0000000000000000000000000000000000000000..cf61b3ba6f25ec08bd8408aa94aff0bda5fa5975 --- /dev/null +++ b/ets1.2/interop/src/arkts/events.ts @@ -0,0 +1,79 @@ +import { int32 } from "@koalaui/common" +import { DeserializerBase } from "./DeserializerBase" +import { InteropNativeModule } from "./InteropNativeModule" +import { ResourceHolder } from "../arkts/ResourceManager" +import { KSerializerBuffer } from "./InteropTypes" +import { wrapSystemCallback } from "./callback" +import { KBuffer } from "./NativeBuffer" + +const API_KIND_MAX = 100 +const apiEventHandlers = new Array(API_KIND_MAX).fill(undefined) +export type EventHandler = (deserializer: DeserializerBase) => void +export function registerApiEventHandler(apiKind: int32, handler: EventHandler) { + if (apiKind < 0 || apiKind > API_KIND_MAX) { + throw new Error(`Maximum api kind is ${API_KIND_MAX}, received ${apiKind}`) + } + if (apiEventHandlers[apiKind] !== undefined) { + throw new Error(`Callback caller for api kind ${apiKind} already was set`) + } + apiEventHandlers[apiKind] = handler +} +export function handleApiEvent(apiKind: int32, deserializer: DeserializerBase) { + if (apiKind < 0 || apiKind > API_KIND_MAX) { + throw new Error(`Maximum api kind is ${API_KIND_MAX}, received ${apiKind}`) + } + if (apiEventHandlers[apiKind] === undefined) { + throw new Error(`Callback caller for api kind ${apiKind} was not set`) + } + apiEventHandlers[apiKind]!(deserializer) +} +export function wrapSystemApiHandlerCallback() { + wrapSystemCallback(1, (buffer: KSerializerBuffer, len:int32) => { + const deserializer = new DeserializerBase(buffer, len) + const apiKind = deserializer.readInt32() + handleApiEvent(apiKind, deserializer) + return 0 + }) +} +export function checkEvents(): void { + while (checkSingleEvent()) {} +} + + +enum CallbackEventKind { + Event_CallCallback = 0, + Event_HoldManagedResource = 1, + Event_ReleaseManagedResource = 2, +} + +const bufferSize = 8 * 1024 +const buffer = new KBuffer(bufferSize) +const deserializer = new DeserializerBase(buffer.buffer, bufferSize) +function checkSingleEvent(): boolean { + deserializer.resetCurrentPosition() + let result = InteropNativeModule._CheckCallbackEvent(buffer.buffer, bufferSize) + if (result == 0) + return false + + const eventKind = deserializer.readInt32() as CallbackEventKind + switch (eventKind) { + case CallbackEventKind.Event_CallCallback: { + const apiKind = deserializer.readInt32() + handleApiEvent(apiKind, deserializer) + return true; + } + case CallbackEventKind.Event_HoldManagedResource: { + const resourceId = deserializer.readInt32() + ResourceHolder.instance().hold(resourceId) + return true; + } + case CallbackEventKind.Event_ReleaseManagedResource: { + const resourceId = deserializer.readInt32() + ResourceHolder.instance().release(resourceId) + return true; + } + default: { + throw new Error(`Unknown callback event kind ${eventKind}`) + } + } +} \ No newline at end of file diff --git a/ets1.2/interop/src/arkts/index.ts b/ets1.2/interop/src/arkts/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..9a878ec5919866352501e4e6cd497bc039958e26 --- /dev/null +++ b/ets1.2/interop/src/arkts/index.ts @@ -0,0 +1,26 @@ +/* + * 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. + */ + +export * from "./InteropTypes" +export * from "./callback" +export * from "./ResourceManager" +export * from "./NativeBuffer" +export * from "./InteropNativeModule" +export * from "./SerializerBase" +export * from "./DeserializerBase" +export * from "./Finalizable" +export * from "./loadLibraries" +export * from "./MaterializedBase" +export * from "./events" diff --git a/ets1.2/interop/src/arkts/loadLibraries.ts b/ets1.2/interop/src/arkts/loadLibraries.ts new file mode 100644 index 0000000000000000000000000000000000000000..feda358f44b86f4d8afdb14f381916134582bd16 --- /dev/null +++ b/ets1.2/interop/src/arkts/loadLibraries.ts @@ -0,0 +1,31 @@ +/* + * Copyright (c) 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. +*/ + +const nativeModuleLibraries: Map = new Map() + +export function loadNativeLibrary(library: string) { + console.log(`[loadLibraries] Loading ${library} [${library}]`) + loadLibrary(library) +} + +export function registerNativeModuleLibraryName(nativeModule: string, libraryName: string) { + console.log(`[loadLibraries] Registered ${libraryName} as ${nativeModule}`) + nativeModuleLibraries.set(nativeModule, libraryName) +} + +export function loadNativeModuleLibrary(nativeModule: string) { + console.log(`[loadLibraries] Loading ${nativeModule} [${nativeModuleLibraries.get(nativeModule) ?? nativeModule}]`) + loadLibrary(nativeModuleLibraries.get(nativeModule) ?? nativeModule) +} diff --git a/ets1.2/interop/src/cangjie/DeserializerBase.cj b/ets1.2/interop/src/cangjie/DeserializerBase.cj new file mode 100644 index 0000000000000000000000000000000000000000..22861ded266025139ccef43c0db2257083f0554c --- /dev/null +++ b/ets1.2/interop/src/cangjie/DeserializerBase.cj @@ -0,0 +1,162 @@ +/* + * Copyright (c) 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. + */ +package Interop + +import std.binary.* +import std.collection.* + +public class CallbackResource { + public var resourceId: Int32 + public var hold: pointer + public var release: pointer + init(resourceId: Int32, hold: pointer, release: pointer) { + this.resourceId = resourceId + this.hold = hold + this.release = release + } +} + +public open class DeserializerBase { + private var position: Int32 = 0 + public var length: Int32 = 96 // make private + public var buffer: pointer // make private + + public init(buffer: UInt64, length: Int32) { + this.buffer = buffer + this.length = length + } + public init(buffer: Array, length: Int32) { + this.buffer = InteropNativeModule._Malloc(length) + for (i in 0..length) { + DeserializerBase.writeu8(this.buffer, i, length, buffer[Int64(i)]) + } + this.length = length + } + + private static func writeu8(buffer: pointer, offset: Int32, length: Int32, value: UInt8): Unit { + InteropNativeModule._WriteByte(buffer, Int64(offset), Int64(length), Int32(value)) + } + private static func readu8(buffer: pointer, offset: Int32, length: Int32): Int32 { + return InteropNativeModule._ReadByte(buffer, Int64(offset), Int64(length)) + } + + public func asBuffer(): pointer { + return this.buffer + } + + public func currentPosition(): Int32 { + return this.position + } + + public func resetCurrentPosition(): Unit { + this.position = 0 + } + + private func checkCapacity(value: Int32) { + if (value > this.length) { + throw Exception("${value} is less than remaining buffer length") + } + } + + public func readInt8(): Int8 { + this.checkCapacity(1) + var res = DeserializerBase.readu8(this.buffer, this.position, this.length) + this.position += 1 + return Int8(res) + } + + public func readInt32(): Int32 { + this.checkCapacity(4) + let arr = Array(4, {i => UInt8(DeserializerBase.readu8(this.buffer, this.position + Int32(i), this.length))}) + this.position += 4 + return Int32.readLittleEndian(arr) + } + + public func readInt64(): Int64 { + this.checkCapacity(8) + let arr = Array(8, {i => UInt8(DeserializerBase.readu8(this.buffer, this.position + Int32(i), this.length))}) + this.position += 8 + return Int64.readLittleEndian(arr) + } + + public func readPointer(): KPointer { + this.checkCapacity(8) + let arr = Array(8, {i => UInt8(DeserializerBase.readu8(this.buffer, this.position + Int32(i), this.length))}) + this.position += 8 + return UInt64.readLittleEndian(arr) + } + + public func readFloat32(): Float32 { + this.checkCapacity(4) + let arr = Array(4, {i => UInt8(DeserializerBase.readu8(this.buffer, this.position + Int32(i), this.length))}) + this.position += 4 + return Float32.readLittleEndian(arr) + } + public func readFloat64(): Float64 { + this.checkCapacity(8) + let arr = Array(8, {i => UInt8(DeserializerBase.readu8(this.buffer, this.position + Int32(i), this.length))}) + this.position += 8 + return Float64.readLittleEndian(arr) + } + + public func readBoolean(): Bool { + var byteVal = DeserializerBase.readu8(this.buffer, this.position, this.length) + this.position += 1 + return byteVal == 1 + } + + public func readString(): String { + let length = this.readInt32() + this.checkCapacity(length) + // read without null-terminated byte + let value = InteropNativeModule._Utf8ToString(this.buffer, Int32(this.position), Int32(length)) + this.position += length + return value + } + + public func readCustomObject(kind: String): Object { + throw Exception("readCustomObject") + } + + public func readObject(): Any { + let resource = this.readCallbackResource() + return ResourceHolder.instance().get(resource.resourceId) + } + + public func readBuffer(): Array { + return Array() + } + + public func readFunction(): Any { + return { => } + } + + public func readNumber(): Float64 { + let tag = this.readInt8() + if (tag == Tag.UNDEFINED.value) { + throw Exception("Read number can't return undefined.") + } else if (tag == Tag.INT32.value) { + return Float64(this.readInt32()) + } else if (tag == Tag.FLOAT32.value) { + return Float64(this.readFloat32()) + } else { + throw Exception("Unknown number tag: ${tag}") + } + } + + public func readCallbackResource(): CallbackResource { + return CallbackResource(this.readInt32(), this.readPointer(), this.readPointer()) + } +} diff --git a/ets1.2/interop/src/cangjie/InteropNativeModule.cj b/ets1.2/interop/src/cangjie/InteropNativeModule.cj new file mode 100644 index 0000000000000000000000000000000000000000..779c0597aeefa7e89c7f9944adb3a4f2259b0944 --- /dev/null +++ b/ets1.2/interop/src/cangjie/InteropNativeModule.cj @@ -0,0 +1,260 @@ +/* + * Copyright (c) 2024-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. + */ + +package Interop + +import std.collection.* + +foreign { + func Malloc(length: Int32): UInt64 + func Free(data: KPointer): Unit + func ReadByte(data: KPointer, index: Int64, length: Int64): Int32 + func WriteByte(data: KPointer, index: Int64, length: Int64, value: Int32): Unit + func ReleaseCallbackResource(resourceId: Int32): Unit + + func GetGroupedLog(index: Int32): UInt64 + func StartGroupedLog(index: Int32): Unit + func StopGroupedLog(index: Int32): Unit + func AppendGroupedLog(index: Int32, message: CString): Unit + func PrintGroupedLog(index: Int32): Unit + func GetStringFinalizer(): UInt64 + func InvokeFinalizer(ptr1: UInt64, ptr2: UInt64): Unit + func GetPtrVectorElement(ptr1: UInt64, arg: Int32): UInt64 + func StringLength(ptr1: UInt64): Int32 + func StringData(ptr1: UInt64, array: CPointer, arrayLength: Int32): Unit + func StringMake(str1: CString): UInt64 + func GetPtrVectorSize(ptr1: UInt64): Int32 + func ManagedStringWrite(str1: CString, array: pointer, arrayLength: Int32, arg: Int32): Int32 + func NativeLog(str1: CString): Unit + func Utf8ToString(data: pointer, offset: Int32, length: Int32): CString + func CheckCallbackEvent(buffer: KSerializerBuffer, bufferLength: Int32): Int32 + func StdStringToString(cstring: UInt64): CString + func IncrementNumber(input: Float64): Float64 + func CallCallback(callbackKind: Int32, args: KSerializerBuffer, argsSize: Int32): Unit + func CallCallbackSync(callbackKind: Int32, args: KSerializerBuffer, argsSize: Int32): Unit + func CallCallbackResourceHolder(holder: UInt64, resourceId: Int32): Unit + func CallCallbackResourceReleaser(releaser: UInt64, resourceId: Int32): Unit + func CallForeignVM(foreignContext: UInt64, kind: Int32, data: CPointer, length: Int32): Int32 + func LoadVirtualMachine(arg0: Int32, arg1: CString, arg2: CString): Int32 + func RunApplication(arg0: Int32, arg1: Int32): Bool + func StartApplication(appUrl: CString, appParams: CString): UInt64 + func EmitEvent(eventType: Int32, target: Int32, arg0: Int32, arg1: Int32): CString + func RestartWith(page: CString): Unit +} + +public open class InteropNativeModule { + public static func _Malloc(length: Int32) { + unsafe { + return Malloc(length) + } + } + public static func _Free(data: KPointer): Unit { + unsafe { + Free(data) + } + } + public static func _ReadByte(data: KPointer, index: Int64, length: Int64): Int32 { + unsafe { + return ReadByte(data, index, length) + } + } + public static func _WriteByte(data: KPointer, index: Int64, length: Int64, value: Int32) { + unsafe { + WriteByte(data, index, length, value) + } + } + public static func _ReleaseCallbackResource(resourceId: Int32): Unit { + unsafe { + ReleaseCallbackResource(resourceId) + } + } + public static func _GetGroupedLog(index: Int32): UInt64 { + unsafe { + let result = GetGroupedLog(index) + return result + } + } + public static func _StartGroupedLog(index: Int32): Unit { + unsafe { + StartGroupedLog(index) + } + } + public static func _StopGroupedLog(index: Int32): Unit { + unsafe { + StopGroupedLog(index) + } + } + public static func _AppendGroupedLog(index: Int32, message: String): Unit { + unsafe { + let message = LibC.mallocCString(message) + AppendGroupedLog(index, message) + LibC.free(message) + } + } + public static func _PrintGroupedLog(index: Int32): Unit { + unsafe { + PrintGroupedLog(index) + } + } + public static func _GetStringFinalizer(): UInt64 { + unsafe { + let result = GetStringFinalizer() + return result + } + } + public static func _InvokeFinalizer(ptr1: UInt64, ptr2: UInt64): Unit { + unsafe { + InvokeFinalizer(ptr1, ptr2) + } + } + public static func _GetPtrVectorElement(ptr1: UInt64, arg: Int32): UInt64 { + unsafe { + let result = GetPtrVectorElement(ptr1, arg) + return result + } + } + public static func _StringLength(ptr1: UInt64): Int32 { + unsafe { + let result = StringLength(ptr1) + return result + } + } + public static func _StringData(ptr1: UInt64, array: Array, arrayLength: Int32): Unit { + unsafe { + let handle_1 = acquireArrayRawData(arr) + StringData(ptr1, handle_1.pointer, i) + releaseArrayRawData(handle_1) + } + } + public static func _StringMake(str1: String): UInt64 { + unsafe { + let str1 = LibC.mallocCString(str1) + let result = StringMake(str1) + LibC.free(str1) + return result + } + } + public static func _GetPtrVectorSize(ptr1: UInt64): Int32 { + unsafe { + let result = GetPtrVectorSize(ptr1) + return result + } + } + public static func _ManagedStringWrite(str1: String, array: pointer, arrayLength: Int32, arg: Int32): Int32 { + unsafe { + let str1 = LibC.mallocCString(str1) + let result = ManagedStringWrite(str1, arr, arrLength, arg) + LibC.free(str1) + return result + } + } + public static func _NativeLog(str1: String): Unit { + unsafe { + let str1 = LibC.mallocCString(str1) + NativeLog(str1) + LibC.free(str1) + } + } + public static func _Utf8ToString(data: pointer, offset: Int32, length: Int32): String { + unsafe { + let result = Utf8ToString(data, offset, length) + return result.toString() + } + } + public static func _CheckCallbackEvent(buffer: KSerializerBuffer, bufferLength: Int32): Int32 { + unsafe { + return CheckCallbackEvent(buffer, bufferLength) + } + } + public static func _StdStringToString(cstring: UInt64): String { + unsafe { + let result = StdStringToString(cstring) + return result.toString() + } + } + public static func _IncrementNumber(input: Float64): Float64 { + unsafe { + let result = IncrementNumber(input) + return result + } + } + public static func _CallCallback(callbackKind: Int32, args: KSerializerBuffer, argsSize: Int32): Unit { + unsafe { + CallCallback(callbackKind, args, argsSize) + } + } + public static func _CallCallbackSync(callbackKind: Int32, args: KSerializerBuffer, argsSize: Int32): Unit { + unsafe { + CallCallbackSync(callbackKind, args, argsSize) + } + } + public static func _CallCallbackResourceHolder(holder: UInt64, resourceId: Int32): Unit { + unsafe { + CallCallbackResourceHolder(holder, resourceId) + } + } + public static func _CallCallbackResourceReleaser(releaser: UInt64, resourceId: Int32): Unit { + unsafe { + CallCallbackResourceReleaser(releaser, resourceId) + } + } + public static func _CallForeignVM(foreignContext: UInt64, kind: Int32, data: ArrayList, length: Int32): Int32 { + unsafe { + let handle_2 = acquireArrayRawData(data.toArray()) + let result = CallForeignVM(foreignContext, kind, handle_2.pointer, length) + releaseArrayRawData(handle_2) + return result + } + } + public static func _LoadVirtualMachine(arg0: Int32, arg1: String, arg2: String): Int32 { + unsafe { + let arg1 = LibC.mallocCString(arg1) + let arg2 = LibC.mallocCString(arg2) + let result = LoadVirtualMachine(arg0, arg1, arg2) + LibC.free(arg1) + LibC.free(arg2) + return result + } + } + public static func _RunApplication(arg0: Int32, arg1: Int32): Bool { + unsafe { + let result = RunApplication(arg0, arg1) + return result + } + } + public static func _StartApplication(appUrl: String, appParams: String): UInt64 { + unsafe { + let appUrl = LibC.mallocCString(appUrl) + let appParams = LibC.mallocCString(appParams) + let result = StartApplication(appUrl, appParams) + LibC.free(appUrl) + LibC.free(appParams) + return result + } + } + public static func _EmitEvent(eventType: Int32, target: Int32, arg0: Int32, arg1: Int32): String { + unsafe { + let result = EmitEvent(eventType, target, arg0, arg1) + return result.toString() + } + } + public static func _RestartWith(page: String): Unit { + unsafe { + let page = LibC.mallocCString(page) + RestartWith(page) + LibC.free(page) + } + } +} \ No newline at end of file diff --git a/ets1.2/interop/src/cangjie/InteropTypes.cj b/ets1.2/interop/src/cangjie/InteropTypes.cj new file mode 100644 index 0000000000000000000000000000000000000000..3240744bc4c342867cd195ae1edc5b62d92e225f --- /dev/null +++ b/ets1.2/interop/src/cangjie/InteropTypes.cj @@ -0,0 +1,39 @@ +/* + * Copyright (c) 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. + */ +package Interop + +import std.collection.* + +public type KPointer = UInt64 +public type KFloat = Float32 +public type KDouble = Float64 +public type pointer = KPointer +public type KInt = Int32 +public type KLong = Int64 +public type KStringPtr = String +public type ArrayBuffer = ArrayList +public type KSerializerBuffer = pointer +public const nullptr: UInt64 = 0 +@C +public struct KInteropReturnBuffer { + public var length: Int32 + public var data: CPointer + public var dispose: CPointer, Int32) -> Unit>> + init (length: Int32, data: CPointer, dispose: CPointer, Int32) -> Unit>>) { + this.length = length + this.data = data + this.dispose = dispose + } +} \ No newline at end of file diff --git a/ets1.2/interop/src/cangjie/MaterializedBase.cj b/ets1.2/interop/src/cangjie/MaterializedBase.cj new file mode 100644 index 0000000000000000000000000000000000000000..2f39fb7b64ab2dbf6c3a1e0d663b2a9310136e34 --- /dev/null +++ b/ets1.2/interop/src/cangjie/MaterializedBase.cj @@ -0,0 +1,46 @@ +/* + * Copyright (c) 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. + */ +package Interop + +public open class Finalizable { + public var ptr: KPointer + public var finalizer: KPointer + + public Finalizable(ptr: KPointer, finalizer: KPointer) { + this.ptr = ptr + this.finalizer = finalizer + } +} + +public open class MaterializedBaseTag { + static var NOP = MaterializedBaseTag() + private init() { } +} + +public interface MaterializedBase { + public func getPeer(): ?Finalizable + + public static func toPeerPtr(value: Any): KPointer + { + let base: MaterializedBase = match (value as MaterializedBase) { + case Some(x) => x + case None => throw Exception("Value is not a MaterializedBase instance!") + } + return match (base.getPeer()) { + case Some(peer) => peer.ptr + case None => nullptr + } + } +} diff --git a/ets1.2/interop/src/cangjie/ResourceManager.cj b/ets1.2/interop/src/cangjie/ResourceManager.cj new file mode 100644 index 0000000000000000000000000000000000000000..d2e589d5f6058a8dd469da300134321754f4aba0 --- /dev/null +++ b/ets1.2/interop/src/cangjie/ResourceManager.cj @@ -0,0 +1,78 @@ +/* + * 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. + */ +package Interop + +import std.binary.* +import std.math.* +import std.collection.* + +public type ResourceId = Int32 + +class ResourceInfo { + public var resource: Any + public var holdersCount: Int32 + init(resource: Any, holdersCount: Int32 ) { + this.resource = resource + this.holdersCount = holdersCount + } +} + +public class ResourceHolder { + private static var nextResourceId: ResourceId = 100 + private var resources: HashMap = HashMap() + private static var _instance: ?ResourceHolder = Option.None + public static func instance(): ResourceHolder { + ResourceHolder._instance = match (ResourceHolder._instance) { + case Some(resourceHolder) => resourceHolder + case _ => ResourceHolder() + } + if (let Some(rh) <- ResourceHolder._instance) { + return rh + } else { + throw Exception() + } + } + public func hold(resourceId: ResourceId) { + match(this.resources.get(resourceId)) { + case Some(resource) => resource.holdersCount++ + case _ => throw Exception("Resource ${resourceId} does not exists, can not hold") + } + } + + public func release(resourceId: ResourceId) { + let resource = match (this.resources.get(resourceId)) { + case Some(resource) => resource + case _ => throw Exception("Resource ${resourceId} does not exists, can not hold") + } + resource.holdersCount-- + if (resource.holdersCount <= 0) { + this.resources.remove(resourceId) + } + } + + public func registerAndHold(resource: Any): ResourceId { + ResourceHolder.nextResourceId += 1 + let resourceId = ResourceHolder.nextResourceId + this.resources.add(resourceId, ResourceInfo(resource, resourceId)) + return resourceId + } + + public func get(resourceId: ResourceId): Any { + match(this.resources.get(resourceId)) { + case Some(resource) => return resource.resource + case _ => throw Exception("Resource ${resourceId} does not exists") + } + } +} diff --git a/ets1.2/interop/src/cangjie/SerializerBase.cj b/ets1.2/interop/src/cangjie/SerializerBase.cj new file mode 100644 index 0000000000000000000000000000000000000000..931bc704a95f7faed20afc7812634cb7e8229870 --- /dev/null +++ b/ets1.2/interop/src/cangjie/SerializerBase.cj @@ -0,0 +1,355 @@ +/* + * Copyright (c) 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. + */ + +package Interop + +import std.binary.* +import std.math.* +import std.collection.* + +public enum RuntimeType { + |UNEXPECTED + |NUMBER + |STRING + |OBJECT + |BOOLEAN + |UNDEFINED + |BIGINT + |FUNCTION + |SYMBOL + |MATERIALIZED + public prop ordinal: Int32 { + get() { + match (this) { + case UNEXPECTED => -1 + case NUMBER => 1 + case STRING => 2 + case OBJECT => 3 + case BOOLEAN => 4 + case UNDEFINED => 5 + case BIGINT => 6 + case FUNCTION => 7 + case SYMBOL => 8 + case MATERIALIZED => 9 + } + } + } +} + +public class PromiseAndResourceId { + public var promise: Any + public var resourceId: ResourceId + init (promise: Any, resourceId: ResourceId) { + this.promise = promise + this.resourceId = resourceId + } +} + + +/* Serialization extension point */ +public abstract class CustomSerializer { + public var supported: Array + init(supported: Array) { + this.supported = supported + } + public func supports(kind: String): Bool { return this.supported.contains(kind) } + public func serialize(serializer: SerializerBase, value: Object, kind: String): Unit {} + var next: ?CustomSerializer = Option.None +} + +public open class SerializerBase { + private var position: Int32 = 0 + private var _buffer: pointer + private var _length: Int32 + + private static var customSerializers: ?CustomSerializer = Option.None + static func registerCustomSerializer(serializer: CustomSerializer) { + // Improve: + } + + public init() { + let length: Int32 = 96 + this._buffer = InteropNativeModule._Malloc(length) + this._length = length + } + + private static func writeu8(_buffer: pointer, offset: Int32, length: Int32, value: Int32): Unit { + InteropNativeModule._WriteByte(_buffer, Int64(offset), Int64(length), value) + } + private static func readu8(_buffer: pointer, offset: Int32, length: Int32): Int32 { + return InteropNativeModule._ReadByte(_buffer, Int64(offset), Int64(length)) + } + + public open func release() { + this.releaseResources() + this.position = 0 + } + private func releaseResources() { + if (this.heldResourcesCount == 0) { + return + } + for (i in 0..this.heldResourcesCount) { + InteropNativeModule._ReleaseCallbackResource(this.heldResources[i]) + } + this.heldResourcesCount = 0 + } + public func asBuffer(): KSerializerBuffer { + this._buffer + } + public func length(): Int32 { + return Int32(this.position) + } + public func currentPosition(): Int32 { return this.position } + private func checkCapacity(value: Int32) { + if (value < 1) { + throw Exception("${value} is less than 1") + } + var buffSize = this._length + if (this.position > buffSize - value) { + let minSize: Int32 = this.position + value + let resizedSize: Int32 = max(minSize, Int32(round(1.5 * Float64(buffSize)))) + let resizedBuffer = InteropNativeModule._Malloc(resizedSize) + let oldBuffer = this._buffer + for (i in 0..this.position) { + SerializerBase.writeu8(resizedBuffer, Int32(i), resizedSize, SerializerBase.readu8(oldBuffer, i, this.position)) + } + this._buffer = resizedBuffer + this._length = resizedSize + InteropNativeModule._Free(oldBuffer) + } + } + public func writeCustomObject(kind: String, value: Any): Unit { + var current = SerializerBase.customSerializers + // Improve: + println("Unsupported custom serialization for ${kind}, write undefined") + this.writeInt8(Tag.UNDEFINED.value) + } + + private var heldResources: ArrayList = ArrayList() + private var heldResourcesCount: Int64 = 0 + private func addHeldResource(resourceId: ResourceId) { + if (this.heldResourcesCount == this.heldResources.size) { + this.heldResources.add(resourceId) + } + else { + this.heldResources[this.heldResourcesCount] = resourceId + } + this.heldResourcesCount += 1 + } + + public func holdAndWriteCallback(callback: Any): ResourceId { + let resourceId = ResourceHolder.instance().registerAndHold(callback) + this.heldResources.add(resourceId) + this.writeInt32(resourceId) + this.writePointer(0) + this.writePointer(0) + this.writePointer(0) + this.writePointer(0) + return resourceId + } + public func holdAndWriteCallback(callback: Any, hold: KPointer, release: KPointer, call: KPointer, callSync: KPointer): ResourceId { + let resourceId = ResourceHolder.instance().registerAndHold(callback) + this.heldResources.add(resourceId) + this.writeInt32(resourceId) + this.writePointer(hold) + this.writePointer(release) + this.writePointer(call) + this.writePointer(callSync) + return resourceId + } + public func holdAndWriteCallbackForPromiseVoid(): PromiseAndResourceId { + return holdAndWriteCallbackForPromiseVoid(0, 0, 0, 0) + } + public func holdAndWriteCallbackForPromiseVoid(hold: KPointer, release: KPointer, call: KPointer, callSync: KPointer): PromiseAndResourceId { + var resourceId: ResourceId = 0 + let promise = { => } + return PromiseAndResourceId(promise, resourceId) + } + public func holdAndWriteCallbackForPromise(): PromiseAndResourceId { + return holdAndWriteCallbackForPromise(0, 0, 0) + } + public func holdAndWriteCallbackForPromise(hold: KPointer, release: KPointer, call: KPointer): PromiseAndResourceId { + var resourceId: ResourceId = 0 + let promise = { => } + return PromiseAndResourceId(promise, resourceId) + } + public func writeFunction(value: Any): Unit { + // Improve: + } + public func writeTag(tag: Int32): Unit { + this.checkCapacity(1) + SerializerBase.writeu8(this._buffer, this.position, this._length, tag) + this.position++ + } + public func writeTag(tag: Int8): Unit { + this.checkCapacity(1) + SerializerBase.writeu8(this._buffer, this.position, this._length, Int32(tag)) + this.position++ + } + public func writeNumber(value: ?Float32): Unit { + if (let Some(value) <- value) { + if(value == Float32(Int32(value))) { + this.writeNumber(Int32(value)) + } else { + this.writeTag(Tag.FLOAT32.value) + this.writeInt32(Int64(value.toBits())) + } + } + else { + this.writeTag(Tag.UNDEFINED.value) + } + } + public func writeNumber(value: ?Float64): Unit { + if (let Some(value) <- value) { + if(value == Float64(Int32(value))) { + this.writeNumber(Int32(value)) + } else { + this.writeTag(Tag.FLOAT32.value) + this.writeInt32(Int64(Float32(value).toBits())) + } + } + else { + this.writeTag(Tag.UNDEFINED.value) + } + } + public func writeNumber(value: ?Int32): Unit { + if (let Some(value) <- value) { + this.writeTag(Tag.INT32.value) + this.writeInt32(Int32(value)) + } + else { + this.writeTag(Tag.UNDEFINED.value) + } + } + public func writeNumber(value: ?Int64): Unit { + this.checkCapacity(5) + if (let Some(value) <- value) { + this.writeTag(Tag.INT32.value) + this.writeInt32(Int32(value)) + } + else { + this.writeTag(Tag.UNDEFINED.value) + } + } + public func writeInt8(value: Int8): Unit { + this.checkCapacity(1) + SerializerBase.writeu8(this._buffer, this.position, this._length, Int32(value)) + this.position += 1 + } + public func writeInt8(value: Int32): Unit { + this.checkCapacity(1) + SerializerBase.writeu8(this._buffer, this.position, this._length, Int32(value)) + this.position += 1 + } + public func writeInt32(value: Int32): Unit { + this.checkCapacity(4) + let arr = Array(4, repeat: 0) + value.writeLittleEndian(arr) + for (idx in 0..4) { + SerializerBase.writeu8(this._buffer, this.position + Int32(idx), this._length, Int32(arr[idx])) + } + this.position += 4 + } + public func writeInt32(value: Int64): Unit { + this.checkCapacity(4) + let arr = Array(4, repeat: 0) + Int32(value).writeLittleEndian(arr) + for (idx in 0..4) { + SerializerBase.writeu8(this._buffer, this.position + Int32(idx), this._length, Int32(arr[idx])) + } + this.position += 4 + } + public func writeInt64(value: Int64): Unit { + this.checkCapacity(8) + let arr = Array(8, repeat: 0) + value.writeLittleEndian(arr) + for (idx in 0..8) { + SerializerBase.writeu8(this._buffer, this.position + Int32(idx), this._length, Int32(arr[idx])) + } + this.position += 8 + } + public func writeFloat32(value: Float32): Unit { + this.checkCapacity(4) + this.position += 4 + } + public func writePointer(ptr: UInt64): Unit { + this.checkCapacity(8) + let arr = Array(8, repeat: 0) + ptr.writeLittleEndian(arr) + for (idx in 0..8) { + SerializerBase.writeu8(this._buffer, this.position + Int32(idx), this._length, Int32(arr[idx])) + } + this.position += 8 + } + public func writeBoolean(value: ?Bool): Unit { + this.checkCapacity(1) + if(let Some(value) <- value) { + SerializerBase.writeu8(this._buffer, this.position, this._length, if (value) {1} else {0}) + } + else { + SerializerBase.writeu8(this._buffer, this.position, this._length, RuntimeType.UNDEFINED.ordinal) + } + this.position++ + } + public func writeMaterialized(value: Object): Unit { + // Improve: + } + public func writeCallbackResource(resource: CallbackResource) { + this.writeInt32(resource.resourceId) + this.writePointer(resource.hold) + this.writePointer(resource.release) + } + public func writeString(value: String): Unit { + this.checkCapacity(Int32(4 + value.size * 4 + 1)) // length, data + let encodedLength = InteropNativeModule._ManagedStringWrite(value, this.asBuffer(), this._length, this.position + 4) + this.writeInt32(encodedLength) + this.position += encodedLength + } + public func writeBuffer(_buffer: Array) { + // let resourceId = ResourceHolder.instance().registerAndHold(_buffer) + // this.writeCallbackResource(CallbackResource(resourceId, 0, 0)) + // unsafe { + // let ptr = acquireArrayRawData(_buffer).pointer + // this.writePointer(UInt64(ptr.toUIntNative())) + // this.writeInt64(_buffer.size) + // } + } + public func holdAndWriteObject(obj: Any): ResourceId { + return this.holdAndWriteObject(obj, 0, 0) + } + public func holdAndWriteObject(obj: Any, hold: pointer, release: pointer): ResourceId { + let resourceId = ResourceHolder.instance().registerAndHold(obj) + this.addHeldResource(resourceId) + this.writeInt32(resourceId) + this.writePointer(hold) + this.writePointer(release) + return resourceId + } +} + +public open class DateCustomSerializer <: CustomSerializer { + public DateCustomSerializer() { + super(["Date"]) + } + public func serialize(serializer: SerializerBase, value: Ark_CustomObject, kind: String): Unit { + serializer.writeString("{}") + } +} + +public open class Ark_CustomObject { + init() { + SerializerBase.registerCustomSerializer(DateCustomSerializer()) + } +} diff --git a/ets1.2/interop/src/cangjie/Tag.cj b/ets1.2/interop/src/cangjie/Tag.cj new file mode 100644 index 0000000000000000000000000000000000000000..8c5cc317f9721d5cad36b5cae262e759eb1eac4c --- /dev/null +++ b/ets1.2/interop/src/cangjie/Tag.cj @@ -0,0 +1,29 @@ +/* + * Copyright (c) 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. + */ +package Interop + +public open class Tag { + public static var UNDEFINED: Tag = Tag(101) + public static var INT32: Tag = Tag(102) + public static var FLOAT32: Tag = Tag(103) + public static var STRING: Tag = Tag(104) + public static var LENGTH: Tag = Tag(105) + public static var RESOURCE: Tag = Tag(106) + public static var OBJECT: Tag = Tag(107) + public var value: Int8 + Tag (arg0: Int8) { + value = arg0 + } +} diff --git a/ets1.2/interop/src/cangjie/cjpm.toml b/ets1.2/interop/src/cangjie/cjpm.toml new file mode 100644 index 0000000000000000000000000000000000000000..54130b37780ecff31ac2a85fef444d20ecc77c30 --- /dev/null +++ b/ets1.2/interop/src/cangjie/cjpm.toml @@ -0,0 +1,25 @@ +# Copyright (c) 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. + +[dependencies] +[package] + cjc-version = "0.56.4" + compile-option = "" + description = "config file for cj build" + link-option = "" + name = "Interop" + output-type = "static" + src-dir = "." + target-dir = "./build/cj" + version = "1.0.0" + package-configuration = {} diff --git a/ets1.2/interop/src/cpp/DeserializerBase.h b/ets1.2/interop/src/cpp/DeserializerBase.h new file mode 100644 index 0000000000000000000000000000000000000000..105036dfdb4bd1e634294a4d5f80ad0f0f97cbcb --- /dev/null +++ b/ets1.2/interop/src/cpp/DeserializerBase.h @@ -0,0 +1,640 @@ +/* + * Copyright (c) 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. + */ +#ifndef _DESERIALIZER_BASE_H_ +#define _DESERIALIZER_BASE_H_ + +#include +#include +#include +#include +#include + +#include "interop-types.h" +#include "interop-logging.h" +#include "interop-utils.h" +#include "koala-types.h" + +void holdManagedCallbackResource(InteropInt32); +void releaseManagedCallbackResource(InteropInt32); + +#ifdef __arm__ +#define KOALA_NO_UNALIGNED_ACCESS 1 +#endif + +inline const char *tagName(InteropTag tag) +{ + switch (tag) + { + case InteropTag::INTEROP_TAG_UNDEFINED: + return "UNDEFINED"; + case InteropTag::INTEROP_TAG_INT32: + return "INT32"; + case InteropTag::INTEROP_TAG_FLOAT32: + return "FLOAT32"; + case InteropTag::INTEROP_TAG_LENGTH: + return "LENGTH"; + case InteropTag::INTEROP_TAG_RESOURCE: + return "RESOURCE"; + case InteropTag::INTEROP_TAG_STRING: + return "STRING"; + case InteropTag::INTEROP_TAG_OBJECT: + return "OBJECT"; + } + INTEROP_FATAL("Fatal error"); +} + +inline const char *tagNameExact(InteropTag tag) +{ + switch (tag) + { + case InteropTag::INTEROP_TAG_UNDEFINED: + return "INTEROP_TAG_UNDEFINED"; + case InteropTag::INTEROP_TAG_INT32: + return "INTEROP_TAG_INT32"; + case InteropTag::INTEROP_TAG_FLOAT32: + return "INTEROP_TAG_FLOAT32"; + case InteropTag::INTEROP_TAG_LENGTH: + return "INTEROP_TAG_LENGTH"; + case InteropTag::INTEROP_TAG_RESOURCE: + return "INTEROP_TAG_RESOURCE"; + case InteropTag::INTEROP_TAG_STRING: + return "INTEROP_TAG_STRING"; + case InteropTag::INTEROP_TAG_OBJECT: + return "INTEROP_TAG_OBJECT"; + } + INTEROP_FATAL("Fatal error"); +} + +inline InteropFunction makeArkFunctionFromId(InteropInt32 id) { + InteropFunction result; + result.id = id; + return result; +} + +inline const char *getUnitName(int value) +{ + switch (value) + { + case 0: + return "px"; + case 1: + return "vp"; + case 2: + return "fp"; + case 3: + return "%"; + case 4: + return "lpx"; + default: + return ""; + } +} + +template +inline void convertor(T value) = delete; + +// Improve: restore full printing! +template +inline void WriteToString(std::string *result, T value) = delete; + +template <> +inline void WriteToString(std::string *result, const InteropEmpty &value) +{ + result->append("{"); + result->append(".dummy=" + std::to_string(value.dummy)); + result->append("}"); +} + +struct Error +{ + std::string message; + Error(const std::string &message) : message(message) {} +}; + +template <> +inline void WriteToString(std::string *result, InteropTag value) +{ + result->append(".tag="); + result->append(tagName(value)); +} + +template <> +inline void WriteToString(std::string *result, InteropNativePointer value) +{ + result->append("0x" + std::to_string((uint64_t)value)); +} + +template <> +inline void WriteToString(std::string *result, const InteropNativePointer* value) +{ + result->append("0x" + std::to_string((uint64_t)(*value))); +} + +template <> +inline void WriteToString(std::string *result, InteropNodeHandle value) +{ + result->append("0x" + std::to_string((uint64_t)value)); +} + +template <> +inline void WriteToString(std::string *result, InteropFunction value) +{ + result->append("{"); + result->append(".id=" + std::to_string(value.id)); + result->append("}"); +} + +template <> +inline void WriteToString(std::string *result, const InteropFunction* value) +{ + result->append("{"); + result->append(".id=" + std::to_string(value->id)); + result->append("}"); +} + +template <> +inline void WriteToString(std::string *result, const InteropMaterialized *value) +{ + char hex[20]; + interop_snprintf(hex, sizeof(hex), "0x%llx", (long long)value->ptr); + result->append("\""); + result->append("Materialized "); + result->append(hex); + result->append("\""); +} + +// Improve: generate! +template<> +inline void WriteToString(std::string *result, const InteropCallbackResource *value) +{ + result->append("{"); + result->append(".resourceId=" + std::to_string(value->resourceId)); + result->append(", .hold=0"); + result->append(", .release=0"); + result->append("}"); +} + +class DeserializerBase; + +template <> +inline void WriteToString(std::string *result, InteropUndefined value) +{ + result->append("{}"); +} +template <> +inline void WriteToString(std::string *result, const InteropUndefined *value) +{ + result->append("{}"); +} +template <> +inline void WriteToString(std::string *result, InteropVoid value) +{ + result->append("{}"); +} +template <> +inline void WriteToString(std::string *result, const InteropVoid *value) +{ + result->append("{}"); +} +template <> +inline void WriteToString(std::string *result, const InteropCustomObject *value) +{ + if (strcmp(value->kind, "NativeErrorFunction") == 0) + { + result->append("() => {} /* Improve: Function*/"); + return; + } + result->append("{"); + result->append(".kind=\""); + result->append(value->kind); + result->append("\"}"); +} +template <> +inline void WriteToString(std::string *result, const InteropObject *value) +{ + result->append("{"); + result->append(".resource="); + WriteToString(result, &(value->resource)); + result->append("}"); +} +template <> +inline void WriteToString(std::string *result, const InteropObject value) +{ + WriteToString(result, &value); +} + +struct CustomDeserializer +{ + virtual ~CustomDeserializer() {} + virtual bool supports(const std::string &kind) { return false; } + virtual InteropCustomObject deserialize(DeserializerBase *deserializer, const std::string &kind) + { + InteropCustomObject result; + interop_strcpy(result.kind, sizeof(result.kind), "error"); + return result; + } + CustomDeserializer *next = nullptr; +}; + +class DeserializerBase +{ +protected: + uint8_t *data; + int32_t length; + int32_t position; + std::vector toClean; + + static CustomDeserializer *customDeserializers; + +public: + DeserializerBase(KSerializerBuffer data, int32_t length) + : data(reinterpret_cast(data)), length(length), position(0) {} + + DeserializerBase(uint8_t* data, int32_t length) + : data(data), length(length), position(0) {} + + ~DeserializerBase() + { + for (auto data : toClean) + { + free(data); + } + } + + static void registerCustomDeserializer(CustomDeserializer *deserializer) + { + if (DeserializerBase::customDeserializers == nullptr) + { + DeserializerBase::customDeserializers = deserializer; + } + else + { + auto *current = DeserializerBase::customDeserializers; + while (current->next != nullptr) + current = current->next; + current->next = deserializer; + } + } + + template + void resizeArray(T *array, int32_t length) + { + void *value = nullptr; + if (length > 0) + { + value = malloc(length * sizeof(E)); + if (!value) { + INTEROP_FATAL("Cannot allocate memory"); + } + interop_memset(value, length * sizeof(E), 0, length * sizeof(E)); + toClean.push_back(value); + } + array->length = length; + array->array = reinterpret_cast(value); + } + + template + void resizeMap(T *map, int32_t length) + { + void *keys = nullptr; + void *values = nullptr; + if (length > 0) + { + keys = malloc(length * sizeof(K)); + if (!keys) { + INTEROP_FATAL("Cannot allocate memory"); + } + interop_memset(keys, length * sizeof(K), 0, length * sizeof(K)); + toClean.push_back(keys); + + values = malloc(length * sizeof(V)); + if (!values) { + INTEROP_FATAL("Cannot allocate memory"); + } + interop_memset(values, length * sizeof(V), 0, length * sizeof(V)); + toClean.push_back(values); + } + map->size = length; + map->keys = reinterpret_cast(keys); + map->values = reinterpret_cast(values); + } + + int32_t currentPosition() const { return this->position; } + + void check(int32_t count) + { + if (position + count > length) { + fprintf(stderr, "Incorrect serialized data, check for %d, buffer %d position %d\n", count, length, position); + ASSERT(false); + abort(); + } + } + + InteropCustomObject readCustomObject(std::string kind) + { + auto *current = DeserializerBase::customDeserializers; + while (current) + { + if (current->supports(kind)) + return current->deserialize(this, kind); + current = current->next; + } + LOGE("Unsupported custom deserialization for %s\n", kind.c_str()); + auto tag = readTag(); + if (tag == INTEROP_TAG_UNDEFINED) LOGE("Undefined interop tag"); + // Skip undefined tag!. + InteropCustomObject result; + interop_strcpy(result.kind, sizeof(result.kind), "Error"); + interop_strcat(result.kind, sizeof(result.kind), kind.c_str()); + return result; + } + + InteropCallbackResource readCallbackResource() { + InteropCallbackResource result = {}; + result.resourceId = readInt32(); + result.hold = reinterpret_cast(readPointerOrDefault(reinterpret_cast(holdManagedCallbackResource))); + result.release = reinterpret_cast(readPointerOrDefault(reinterpret_cast(releaseManagedCallbackResource))); + return result; + } + + InteropObject readObject() { + InteropObject obj; + obj.resource = readCallbackResource(); + return obj; + } + + int8_t readInt8() + { + check(1); + int8_t value = *(data + position); + position += 1; + return value; + } + InteropTag readTag() + { + return (InteropTag)readInt8(); + } + InteropBoolean readBoolean() + { + check(1); + int8_t value = *(data + position); + position += 1; + return value; + } + InteropInt32 readInt32() + { + check(sizeof(InteropInt32)); +#ifdef KOALA_NO_UNALIGNED_ACCESS + InteropInt32 value; + interop_memcpy(&value, sizeof(InteropInt32), data + position, sizeof(InteropInt32)); +#else + auto value = *(InteropInt32 *)(data + position); +#endif + position += sizeof(InteropInt32); + return value; + } + InteropInt64 readInt64() + { + check(sizeof(InteropInt64)); +#ifdef KOALA_NO_UNALIGNED_ACCESS + InteropInt64 value; + interop_memcpy(&value, sizeof(InteropInt64), data + position, sizeof(InteropInt64)); +#else + auto value = *(InteropInt64 *)(data + position); +#endif + position += sizeof(InteropInt64); + return value; + } + InteropUInt64 readUInt64() + { + check(sizeof(InteropUInt64)); +#ifdef KOALA_NO_UNALIGNED_ACCESS + InteropInt64 value; + interop_memcpy(&value, sizeof(InteropUInt64), data + position, sizeof(InteropUInt64)); +#else + auto value = *(InteropUInt64 *)(data + position); +#endif + position += sizeof(InteropUInt64); + return value; + } + InteropFloat32 readFloat32() + { + check(sizeof(InteropFloat32)); +#ifdef KOALA_NO_UNALIGNED_ACCESS + InteropFloat32 value; + interop_memcpy(&value, sizeof(InteropFloat32), data + position, sizeof(InteropFloat32)); +#else + auto value = *(InteropFloat32 *)(data + position); +#endif + position += sizeof(InteropFloat32); + return value; + } + InteropFloat64 readFloat64() + { + check(sizeof(InteropFloat64)); +#ifdef KOALA_NO_UNALIGNED_ACCESS + InteropFloat64 value; + interop_memcpy(&value, sizeof(InteropFloat64), data + position, sizeof(InteropFloat64)); +#else + auto value = *(InteropFloat64 *)(data + position); +#endif + position += sizeof(InteropFloat64); + return value; + } + InteropNativePointer readPointer() + { + check(sizeof(InteropInt64)); +#ifdef KOALA_NO_UNALIGNED_ACCESS + InteropInt64 value = 0; + interop_memcpy(&value, sizeof(InteropInt64), data + position, sizeof(InteropInt64)); +#else + InteropInt64 value = *(int64_t *)(data + position); +#endif + position += sizeof(InteropInt64); + return reinterpret_cast(static_cast(value)); + } + InteropNativePointer readPointerOrDefault(InteropNativePointer defaultValue) + { + const InteropNativePointer value = this->readPointer(); + return value ? value : defaultValue; + } + InteropNumber readNumber() + { + check(5); + InteropNumber result; + result.tag = readTag(); + if (result.tag == InteropTag::INTEROP_TAG_INT32) + { + result.i32 = readInt32(); + } + else if (result.tag == InteropTag::INTEROP_TAG_FLOAT32) + { + result.f32 = readFloat32(); + } + else + { + INTEROP_FATAL("Fatal error"); + } + return result; + } + InteropBuffer readBuffer() + { + InteropCallbackResource resource = readCallbackResource(); + InteropNativePointer data = readPointer(); + InteropInt64 length = readInt64(); + return InteropBuffer { resource, (void*)data, length }; + } + + InteropString readString() + { + InteropString result; + InteropInt32 length = readInt32(); + check(length); + // We refer to string data in-place. + result.chars = (const char *)(data + position); + result.length = length - 1; + this->position += length; + return result; + } + + InteropFunction readFunction() + { + InteropFunction result; + result.id = readInt32(); + return result; + } + + InteropMaterialized readMaterialized() + { + InteropMaterialized result; + result.ptr = readPointer(); + return result; + } + + InteropUndefined readUndefined() + { + return InteropUndefined(); + } +}; +template <> +inline void WriteToString(std::string *result, InteropBoolean value) +{ + result->append(value ? "true" : "false"); +} +template <> +inline void WriteToString(std::string *result, InteropInt32 value) +{ + result->append(std::to_string(value)); +} +template <> +inline void WriteToString(std::string *result, const InteropInt32* value) +{ + result->append(std::to_string(*value)); +} +template <> +inline void WriteToString(std::string *result, InteropUInt64 value) +{ + result->append(std::to_string(value)); +} +template <> +inline void WriteToString(std::string *result, InteropInt64 value) +{ + result->append(std::to_string(value)); +} +template <> +inline void WriteToString(std::string *result, InteropUInt32 value) +{ + result->append(std::to_string(value)); +} +template <> +inline void WriteToString(std::string *result, InteropFloat32 value) +{ +#if (defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && (__MAC_OS_X_VERSION_MAX_ALLOWED < 130300L)) + // to_chars() is not available on older macOS. + char buf[20]; + interop_snprintf(buf, sizeof buf, "%f", value); + result->append(buf); +#else + std::string storage; + storage.resize(20); + // We use to_chars() to avoid locale issues. + auto rc = std::to_chars(storage.data(), storage.data() + storage.size(), value); + storage.resize(rc.ptr - storage.data()); + result->append(storage); +#endif +} +template <> +inline void WriteToString(std::string *result, InteropFloat64 value) +{ +#if (defined(__MAC_OS_X_VERSION_MAX_ALLOWED) && (__MAC_OS_X_VERSION_MAX_ALLOWED < 130300L)) + // to_chars() is not available on older macOS. + char buf[20]; + interop_snprintf(buf, sizeof buf, "%f", value); + result->append(buf); +#else + std::string storage; + storage.resize(20); + // We use to_chars() to avoid locale issues. + auto rc = std::to_chars(storage.data(), storage.data() + storage.size(), value); + storage.resize(rc.ptr - storage.data()); + result->append(storage); +#endif +} +template <> +inline void WriteToString(std::string* result, const InteropBuffer* value) { + result->append("{.data=nullptr, .length="); + result->append(std::to_string(value->length)); + result->append("}"); +} +template <> +inline void WriteToString(std::string* result, InteropBuffer value) { + result->append("{.data=nullptr, .length="); + result->append(std::to_string(value.length)); + result->append("}"); +} +template <> +inline void WriteToString(std::string *result, const InteropString *value) +{ + result->append("{"); + if (value->chars) { + result->append(".chars=\""); + result->append(value->chars); + result->append("\""); + } else { + result->append(".chars=\"\""); + } + result->append(", .length="); + WriteToString(result, value->length); + result->append("}"); +} + +template <> +inline void WriteToString(std::string *result, const InteropNumber *value) +{ + result->append("{.tag=" + std::to_string(value->tag) + ", "); + + if (value->tag == INTEROP_TAG_FLOAT32) + { + std::string valueString; + result->append(".f32="); + WriteToString(result, value->f32); + } else { + result->append(".i32=" + std::to_string(value->i32)); + } + + result->append("}"); +} + +#endif // _DESERIALIZER_BASE_H_ diff --git a/ets1.2/interop/src/cpp/SerializerBase.h b/ets1.2/interop/src/cpp/SerializerBase.h new file mode 100644 index 0000000000000000000000000000000000000000..c501eb05e7cd353d9b3cb48cdc8a6418563ed4a0 --- /dev/null +++ b/ets1.2/interop/src/cpp/SerializerBase.h @@ -0,0 +1,255 @@ +/* + * Copyright (c) 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. + */ + +#ifndef _SERIALIZER_BASE_H +#define _SERIALIZER_BASE_H + +#include +#include +#include +#include +#include +#include +#include + +#include "callback-resource.h" +#include "interop-types.h" +#include "koala-types.h" +#include "interop-logging.h" +#include "interop-utils.h" + +#ifdef __arm__ +#define KOALA_NO_UNALIGNED_ACCESS 1 +#endif + +template +inline InteropRuntimeType runtimeType(const T& value) = delete; + +template <> +inline InteropRuntimeType runtimeType(const InteropCustomObject& value) { + return INTEROP_RUNTIME_OBJECT; +} + +template <> +inline InteropRuntimeType runtimeType(const InteropMaterialized& value) { + return INTEROP_RUNTIME_OBJECT; +} + +static const std::size_t buffer_size = 1024 * 1024; // 1 MB +static std::size_t offset = 0; +alignas(std::max_align_t) static char buffer[buffer_size]; + +template +T* allocArray(const std::array& ref) { + std::size_t space = sizeof(buffer) - offset; + void* ptr = buffer + offset; + void* aligned_ptr = std::align(alignof(T), sizeof(T) * size, ptr, space); + ASSERT(aligned_ptr != nullptr && "Insufficient space or alignment failed!"); + offset = (char*)aligned_ptr + sizeof(T) * size - buffer; + T* array = reinterpret_cast(aligned_ptr); + for (size_t i = 0; i < size; ++i) { + new (&array[i]) T(ref[i]); + } + return array; +} + +class SerializerBase { +private: + uint8_t* data; + uint32_t dataLength; + uint32_t position; + bool ownData; + CallbackResourceHolder* resourceHolder; + void resize(uint32_t newLength) { + ASSERT(ownData); + ASSERT(newLength > dataLength); + auto* newData = reinterpret_cast(malloc(newLength)); + if (!newData) { + INTEROP_FATAL("Cannot allocate memory"); + } + interop_memcpy(newData, newLength, data, position); + free(data); + data = newData; + dataLength = newLength; + } +public: + SerializerBase(CallbackResourceHolder* resourceHolder = nullptr): + position(0), ownData(true), resourceHolder(resourceHolder) { + this->dataLength = 256; + this->data = reinterpret_cast(malloc(this->dataLength)); + if (!this->data) { + INTEROP_FATAL("Cannot allocate memory"); + } + } + + SerializerBase(uint8_t* data, uint32_t dataLength, CallbackResourceHolder* resourceHolder = nullptr): + data(data), dataLength(dataLength), position(0), ownData(false), resourceHolder(resourceHolder) { + } + + SerializerBase(KSerializerBuffer data, uint32_t dataLength, CallbackResourceHolder* resourceHolder = nullptr): + data(reinterpret_cast(data)), dataLength(dataLength), position(0), ownData(false), resourceHolder(resourceHolder) { + } + + virtual ~SerializerBase() { + if (ownData) { + free(data); + } + } + + SerializerBase(const SerializerBase&) = delete; + SerializerBase& operator=(const SerializerBase&) = delete; + + void* release() { + ownData = false; + return data; + } + int length() { + return position; + } + + inline void check(int more) { + if (position + more > dataLength) { + if (ownData) { + resize((position + more) * 3 / 2 + 2); + } else { + INTEROP_FATAL("Buffer overrun: %d > %d\n", position + more, dataLength); + } + } + } + + void writeInt8(InteropInt8 value) { + check(1); + *((InteropInt8*)(data + position)) = value; + position += 1; + } + + void writeInt32(InteropInt32 value) { + check(sizeof(value)); +#ifdef KOALA_NO_UNALIGNED_ACCESS + interop_memcpy(data + position, dataLength, &value, sizeof(value)); +#else + *((InteropInt32*)(data + position)) = value; +#endif + position += sizeof(value); + } + + void writeInt64(InteropInt64 value) { + check(sizeof(value)); +#ifdef KOALA_NO_UNALIGNED_ACCESS + interop_memcpy(data + position, dataLength, &value, sizeof(value)); +#else + *((InteropInt64*)(data + position)) = value; +#endif + position += sizeof(value); + } + + void writeUInt64(InteropUInt64 value) { + check(sizeof(value)); +#ifdef KOALA_NO_UNALIGNED_ACCESS + interop_memcpy(data + position, dataLength, &value, sizeof(value)); +#else + *((InteropUInt64*)(data + position)) = value; +#endif + position += sizeof(value); + } + + void writeFloat32(InteropFloat32 value) { + check(sizeof(value)); +#ifdef KOALA_NO_UNALIGNED_ACCESS + interop_memcpy(data + position, dataLength, &value, sizeof(value)); +#else + *((InteropFloat32*)(data + position)) = value; +#endif + position += sizeof(value); + } + + void writeFloat64(InteropFloat64 value) { + check(sizeof(value)); +#ifdef KOALA_NO_UNALIGNED_ACCESS + interop_memcpy(data + position, dataLength, &value, sizeof(value)); +#else + *((InteropFloat64*)(data + position)) = value; +#endif + position += 8; + } + + void writePointer(InteropNativePointer value) { + int64_t value64 = static_cast(reinterpret_cast(value)); + check(sizeof(value64)); +#ifdef KOALA_NO_UNALIGNED_ACCESS + interop_memcpy(data + position, dataLength, &value64, sizeof(value64)); +#else + *((int64_t*)(data + position)) = value64; +#endif + position += sizeof(value64); + } + + void writeNumber(InteropNumber value) { + writeInt8(value.tag); + if (value.tag == InteropTag::INTEROP_TAG_INT32) { + writeInt32(value.i32); + } else if (value.tag == InteropTag::INTEROP_TAG_FLOAT32) { + writeFloat32(value.f32); + } else { + INTEROP_FATAL("Unknown tag number"); + } + } + + void writeString(InteropString value) { + writeInt32(value.length + 1); + check(value.length + 1); + interop_strcpy((char*)(data + position), dataLength, value.chars); + position += value.length + 1; + } + + void writeBoolean(InteropBoolean value) { + writeInt8(value); + } + + void writeCallbackResource(const InteropCallbackResource resource) { + writeInt32(resource.resourceId); + writePointer(reinterpret_cast(resource.hold)); + writePointer(reinterpret_cast(resource.release)); + if (this->resourceHolder != nullptr) { + this->resourceHolder->holdCallbackResource(&resource); + } + } + + void writeObject(InteropObject any) { + writeCallbackResource(any.resource); + } + + void writeCustomObject(std::string type, InteropCustomObject value) { + // Improve: implement + } + + void writeBuffer(InteropBuffer buffer) { + writeCallbackResource(buffer.resource); + writePointer((void*)buffer.data); + writeInt64(buffer.length); + } + + KInteropReturnBuffer toReturnBuffer() { + if (this->ownData) { + KInteropReturnBuffer buffer {this->length(), this->release(), [](KNativePointer data, KInt length) { free(data); }}; + // Improve: fix memory issues + return buffer; + } else { + return {this->length(), this->data, nullptr}; + } + } +}; + +#endif // _SERIALIZER_BASE_H \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/ani/convertors-ani.cc b/ets1.2/interop/src/cpp/ani/convertors-ani.cc new file mode 100644 index 0000000000000000000000000000000000000000..42c1c0a8135c237c48bd706e5e781ca90c873979 --- /dev/null +++ b/ets1.2/interop/src/cpp/ani/convertors-ani.cc @@ -0,0 +1,203 @@ +/* + * 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 "convertors-ani.h" +#include "signatures.h" +#include "interop-types.h" + +static const char* callCallbackFromNative = "callCallbackFromNative"; +static const char* callCallbackFromNativeSig = "ili:i"; + +const bool registerByOne = true; + +static bool registerNatives(ani_env *env, const ani_class clazz, const std::vector> impls) { + std::vector methods; + methods.reserve(impls.size()); + bool result = true; + for (const auto &[name, type, func, flag] : impls) { + ani_native_function method; + method.name = name.c_str(); + method.pointer = func; + method.signature = nullptr; + if (registerByOne) { + result &= env->Class_BindStaticNativeMethods(clazz, &method, 1) == ANI_OK; + ani_boolean isError = false; + CHECK_ANI_FATAL(env->ExistUnhandledError(&isError)); + if (isError) { + CHECK_ANI_FATAL(env->DescribeError()); + CHECK_ANI_FATAL(env->ResetError()); + } + } + else { + methods.push_back(method); + } + } + if (!registerByOne) { + result = env->Class_BindStaticNativeMethods(clazz, methods.data(), static_cast(methods.size())) == ANI_OK; + } + return registerByOne ? true : result; +} + +bool registerAllModules(ani_env *aniEnv) { + auto moduleNames = AniExports::getInstance()->getModules(); + for (auto it = moduleNames.begin(); it != moduleNames.end(); ++it) { + std::string classpath = AniExports::getInstance()->getClasspath(*it); + ani_class nativeModule = nullptr; + CHECK_ANI_FATAL(aniEnv->FindClass(classpath.c_str(), &nativeModule)); + if (nativeModule == nullptr) { + LOGE("Cannot find managed class %s", classpath.c_str()); + continue; + } + if (!registerNatives(aniEnv, nativeModule, AniExports::getInstance()->getMethods(*it))) { + return false; + } + } + return true; +} + +ANI_EXPORT ani_status ANI_Constructor(ani_vm *vm, uint32_t *result) { + LOGE("Use ANI") + ani_env* aniEnv = nullptr; + *result = 1; + CHECK_ANI_FATAL(vm->GetEnv(/* version */ 1, (ani_env**)&aniEnv)); + if (!registerAllModules(aniEnv)) { + LOGE("Failed to register ANI modules"); + return ANI_ERROR; + } + ani_boolean hasError = false; + CHECK_ANI_FATAL(aniEnv->ExistUnhandledError(&hasError)); + if (hasError) { + CHECK_ANI_FATAL(aniEnv->DescribeError()); + CHECK_ANI_FATAL(aniEnv->ResetError()); + } + auto interopClassName = AniExports::getInstance()->getClasspath("InteropNativeModule"); + ani_class interopClass = nullptr; + CHECK_ANI_FATAL(aniEnv->FindClass(interopClassName.c_str(), &interopClass)); + if (interopClass == nullptr) { + LOGE("Can not find InteropNativeModule class to set callback dispatcher"); + CHECK_ANI_FATAL(aniEnv->ExistUnhandledError(&hasError)); + if (hasError) { + CHECK_ANI_FATAL(aniEnv->DescribeError()); + CHECK_ANI_FATAL(aniEnv->ResetError()); + } + return ANI_OK; + } + if (!setKoalaANICallbackDispatcher(aniEnv, interopClass, callCallbackFromNative, callCallbackFromNativeSig)) { + LOGE("Failed to set ANI callback dispatcher"); + return ANI_ERROR; + } + return ANI_OK; +} + +AniExports* AniExports::getInstance() { + static AniExports *instance = nullptr; + if (instance == nullptr) { + instance = new AniExports(); + } + return instance; +} + +std::vector AniExports::getModules() { + std::vector result; + for (auto it = implementations.begin(); it != implementations.end(); ++it) { + result.push_back(it->first); + } + return result; +} + +const std::vector>& AniExports::getMethods(const std::string& module) { + auto it = implementations.find(module); + if (it == implementations.end()) { + LOGE("Module %s is not registered", module.c_str()); + } + return it->second; +} + +void AniExports::addMethod(const char* module, const char *name, const char *type, void *impl, int flags) { + auto it = implementations.find(module); + if (it == implementations.end()) { + it = implementations.insert(std::make_pair(module, std::vector>())).first; + } + it->second.push_back(std::make_tuple(name, convertType(name, type), impl, flags)); +} + +void AniExports::setClasspath(const char* module, const char *classpath) { + auto it = classpaths.find(module); + if (it == classpaths.end()) { + classpaths.insert(std::make_pair(module, classpath)); + } else { + LOGE("Classpath for module %s was redefined", module); + } +} + +static std::map g_defaultClasspaths = { + {"InteropNativeModule", "@koalaui.interop.InteropNativeModule.InteropNativeModule"}, + // Improve: leave just InteropNativeModule, define others via KOALA_ETS_INTEROP_MODULE_CLASSPATH + {"TestNativeModule", "arkui.framework.arkts.TestNativeModule.TestNativeModule"}, + {"ArkUINativeModule", "arkui.framework.arkts.ArkUINativeModule.ArkUINativeModule"}, + {"ArkUIGeneratedNativeModule", "arkui.framework.arkts.ArkUIGeneratedNativeModule.ArkUIGeneratedNativeModule"}, +}; + +const std::string& AniExports::getClasspath(const std::string& module) { + auto it = classpaths.find(module); + if (it != classpaths.end()) { + return it->second; + } + auto defaultClasspath = g_defaultClasspaths.find(module); + if (defaultClasspath != g_defaultClasspaths.end()) { + return defaultClasspath->second; + } + INTEROP_FATAL("Classpath for module %s was not registered", module.c_str()); +} + +static struct { + ani_class clazz = nullptr; + ani_static_method method = nullptr; +} g_koalaANICallbackDispatcher; + +static thread_local ani_env* currentContext = nullptr; + +bool setKoalaANICallbackDispatcher( + ani_env* aniEnv, + ani_class clazz, + const char* dispatcherMethodName, + const char* dispatcherMethodSig +) { + currentContext = aniEnv; + g_koalaANICallbackDispatcher.clazz = clazz; + CHECK_ANI_FATAL(aniEnv->Class_FindStaticMethod( + clazz, dispatcherMethodName, dispatcherMethodSig, + &g_koalaANICallbackDispatcher.method + )); + if (g_koalaANICallbackDispatcher.method == nullptr) { + return false; + } + return true; +} + +void getKoalaANICallbackDispatcher(ani_class* clazz, ani_static_method* method) { + *clazz = g_koalaANICallbackDispatcher.clazz; + *method = g_koalaANICallbackDispatcher.method; +} + +ani_env* getKoalaANIContext(void* hint) { + if (currentContext) { + return currentContext; + } else { + return reinterpret_cast(hint); + } +} \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/ani/convertors-ani.h b/ets1.2/interop/src/cpp/ani/convertors-ani.h new file mode 100644 index 0000000000000000000000000000000000000000..27ca269e058830446746d9e552ac161bc948d260 --- /dev/null +++ b/ets1.2/interop/src/cpp/ani/convertors-ani.h @@ -0,0 +1,1878 @@ +/* + * 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. + */ + +#ifdef KOALA_ANI + +#include +#include +#include +#include +#include +#include + +#include "ani.h" +#include "koala-types.h" +#include "interop-logging.h" +#include "interop-utils.h" + +#define CHECK_ANI_FATAL(result) \ +do { \ + ani_status ___res___ = (result); \ + if (___res___ != ANI_OK) { \ + INTEROP_FATAL("ANI function failed (status: %d) at " __FILE__ ": %d", ___res___, __LINE__); \ + } \ +} \ +while (0) + +template +struct InteropTypeConverter { + using InteropType = T; + static T convertFrom(ani_env* env, InteropType value) = delete; + static InteropType convertTo(ani_env* env, T value) = delete; + static void release(ani_env* env, InteropType value, T converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ani_byte; + static inline KByte convertFrom(ani_env* env, InteropType value) { + return value; + } + static inline InteropType convertTo(ani_env* env, KByte value) { + return value; + } + static inline void release(ani_env* env, InteropType value, KByte converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ani_boolean; + static inline KBoolean convertFrom(ani_env* env, InteropType value) { + return value; + } + static inline InteropType convertTo(ani_env* env, KBoolean value) { + return value; + } + static inline void release(ani_env* env, InteropType value, KBoolean converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ani_int; + static inline KInt convertFrom(ani_env* env, InteropType value) { + return value; + } + static inline InteropType convertTo(ani_env* env, KInt value) { + return value; + } + static inline void release(ani_env* env, InteropType value, KInt converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ani_int; + static inline KUInt convertFrom(ani_env* env, InteropType value) { + return value; + } + static inline InteropType convertTo(ani_env* env, KUInt value) { + return value; + } + static inline void release(ani_env* env, InteropType value, KUInt converted) {} +}; + + +template<> +struct InteropTypeConverter { + using InteropType = ani_float; + static inline KFloat convertFrom(ani_env* env, InteropType value) { + return value; + } + static inline InteropType convertTo(ani_env* env, KFloat value) { + return value; + } + static inline void release(ani_env* env, InteropType value, KFloat converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ani_double; + static inline KDouble convertFrom(ani_env* env, InteropType value) { + return value; + } + static inline InteropType convertTo(ani_env* env, KDouble value) { + return value; + } + static inline void release(ani_env* env, InteropType value, KDouble converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ani_long; + static inline KLong convertFrom(ani_env* env, InteropType value) { + return value; + } + static inline InteropType convertTo(ani_env* env, KLong value) { + return value; + } + static inline void release(ani_env* env, InteropType value, KLong converted) {} +}; + + +template<> +struct InteropTypeConverter { + using InteropType = ani_object; + static inline KVMObjectHandle convertFrom(ani_env* env, InteropType value) { + return reinterpret_cast(value); + } + static inline InteropType convertTo(ani_env* env, KVMObjectHandle value) { + return reinterpret_cast(value); + } + static inline void release(ani_env* env, InteropType value, KVMObjectHandle converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ani_arraybuffer; + static inline KInteropBuffer convertFrom(ani_env* env, InteropType value) { + void* data {}; + size_t len {}; + CHECK_ANI_FATAL(env->ArrayBuffer_GetInfo(value, &data, &len)); + return {static_cast(len), data, 0, nullptr}; + } + + static inline InteropType convertTo(ani_env* env, KInteropBuffer value) { + void* data {}; + ani_arraybuffer result; + CHECK_ANI_FATAL(env->CreateArrayBuffer(value.length, &data, &result)); + interop_memcpy(data, value.length, value.data, value.length); + value.dispose(value.resourceId); + return result; + } + static inline void release(ani_env* env, InteropType value, KInteropBuffer converted) { + if (converted.dispose) { + converted.dispose(converted.resourceId); + } + } +}; + +template<> +struct InteropTypeConverter { + using InteropType = ani_long; + static KSerializerBuffer convertFrom(ani_env* env, InteropType value) { + return reinterpret_cast(static_cast(value)); + } + static InteropType convertTo(ani_env* env, KSerializerBuffer value) = delete; + static inline void release(ani_env* env, InteropType value, KSerializerBuffer converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ani_fixedarray_byte; + static inline KInteropReturnBuffer convertFrom(ani_env* env, InteropType value) = delete; + static inline InteropType convertTo(ani_env* env, KInteropReturnBuffer value) { + ani_fixedarray_byte result; + CHECK_ANI_FATAL(env->FixedArray_New_Byte(value.length, &result)); + CHECK_ANI_FATAL(env->FixedArray_SetRegion_Byte(result, 0, value.length, reinterpret_cast(value.data))); + value.dispose(value.data, value.length); + return result; + }; + static inline void release(ani_env* env, InteropType value, KInteropReturnBuffer converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ani_string; + static KStringPtr convertFrom(ani_env* env, InteropType value) { + if (value == nullptr) return KStringPtr(); + KStringPtr result; + // Notice that we use UTF length for buffer size, but counter is expressed in number of Unicode chars. + ani_size lengthUtf8 = 0; + CHECK_ANI_FATAL(env->String_GetUTF8Size(value, &lengthUtf8)); + result.resize(lengthUtf8); + ani_size count = 0; + CHECK_ANI_FATAL(env->String_GetUTF8SubString(value, 0, lengthUtf8, result.data(), lengthUtf8 + 1, &count)); + result.data()[lengthUtf8] = 0; + return result; + } + static InteropType convertTo(ani_env* env, const KStringPtr& value) { + ani_string result = nullptr; + int length = value.length(); + CHECK_ANI_FATAL(env->String_NewUTF8(value.c_str(), length > 0 ? length - 1 /* drop zero terminator */ : 0, &result)); + return result; + } + static void release(ani_env* env, InteropType value, const KStringPtr& converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ani_long; + static KNativePointer convertFrom(ani_env* env, InteropType value) { + return reinterpret_cast(value); + } + static InteropType convertTo(ani_env* env, KNativePointer value) { + return reinterpret_cast(value); + } + static void release(ani_env* env, InteropType value, KNativePointer converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ani_array_int; + static KInt* convertFrom(ani_env* env, InteropType value) { + if (!value) return nullptr; + ani_size length = 0; + CHECK_ANI_FATAL(env->Array_GetLength(value, &length)); + KInt* data = new KInt[length]; + CHECK_ANI_FATAL(env->Array_GetRegion_Int(value, 0, length, (ani_int*)data)); + return data; + } + static InteropType convertTo(ani_env* env, KInt* value) = delete; + static void release(ani_env* env, InteropType value, KInt* converted) { + if (converted) { + ani_size length = 0; + CHECK_ANI_FATAL(env->Array_GetLength(value, &length)); + CHECK_ANI_FATAL(env->Array_SetRegion_Int(value, 0, length, (ani_int*)converted)); + } + delete [] converted; + } +}; + +template<> +struct InteropTypeConverter { + using InteropType = ani_array_float; + static KFloat* convertFrom(ani_env* env, InteropType value) { + if (!value) return nullptr; + ani_size length = 0; + CHECK_ANI_FATAL(env->Array_GetLength(value, &length)); + KFloat* data = new KFloat[length]; + CHECK_ANI_FATAL(env->Array_GetRegion_Float(value, 0, length, (ani_float*)data)); + return data; + } + static InteropType convertTo(ani_env* env, KFloat* value) = delete; + static void release(ani_env* env, InteropType value, KFloat* converted) { + if (converted) { + ani_size length = 0; + CHECK_ANI_FATAL(env->Array_GetLength(value, &length)); + CHECK_ANI_FATAL(env->Array_SetRegion_Float(value, 0, length, (ani_float*)converted)); + } + delete [] converted; + } +}; + +template<> +struct InteropTypeConverter { + using InteropType = ani_array_byte; + static KByte* convertFrom(ani_env* env, InteropType value) { + if (!value) return nullptr; + ani_size length = 0; + CHECK_ANI_FATAL(env->Array_GetLength(value, &length)); + KByte* data = new KByte[length]; + if (length > 0) { + CHECK_ANI_FATAL(env->Array_GetRegion_Byte(value, 0, length, (ani_byte*)data)); + } + return data; + } + static InteropType convertTo(ani_env* env, KByte* value) = delete; + static void release(ani_env* env, InteropType value, KByte* converted) { + if (converted) { + ani_size length = 0; + CHECK_ANI_FATAL(env->Array_GetLength(value, &length)); + if (length > 0) { + CHECK_ANI_FATAL(env->Array_SetRegion_Byte(value, 0, length, (ani_byte*)converted)); + } + } + delete[] converted; + } +}; + +template <> struct InteropTypeConverter { + using InteropType = ani_double; + static KInteropNumber convertFrom(ani_env *env, InteropType value) { + return KInteropNumber::fromDouble(value); + } + static InteropType convertTo(ani_env *env, KInteropNumber value) { + return value.asDouble(); + } + static void release(ani_env *env, InteropType value, + KInteropNumber converted) {} +}; + +template +inline typename InteropTypeConverter::InteropType makeResult(ani_env* env, Type value) { + return InteropTypeConverter::convertTo(env, value); +} + +template +inline Type getArgument(ani_env* env, typename InteropTypeConverter::InteropType arg) { + return InteropTypeConverter::convertFrom(env, arg); +} + +template +inline void releaseArgument(ani_env* env, typename InteropTypeConverter::InteropType arg, Type& data) { + InteropTypeConverter::release(env, arg, data); +} + +template +struct DirectInteropTypeConverter { + using InteropType = T; + static T convertFrom(InteropType value) { return value; } + static InteropType convertTo(T value) { return value; } +}; + +template<> +struct DirectInteropTypeConverter { + using InteropType = ani_long; + static KNativePointer convertFrom(InteropType value) { + return reinterpret_cast(value); + } + static InteropType convertTo(KNativePointer value) { + return reinterpret_cast(value); + } +}; + +template<> +struct DirectInteropTypeConverter { + using InteropType = ani_long; + static KSerializerBuffer convertFrom(InteropType value) { + return reinterpret_cast(static_cast(value)); + } + static InteropType convertTo(KSerializerBuffer value) = delete; +}; + +template <> +struct DirectInteropTypeConverter { + using InteropType = ani_double; + static KInteropNumber convertFrom(InteropType value) { + return KInteropNumber::fromDouble(value); + } + static InteropType convertTo(KInteropNumber value) { + return value.asDouble(); + } +}; + +#define ANI_SLOW_NATIVE_FLAG 1 + +class AniExports { + std::unordered_map>> implementations; + std::unordered_map classpaths; + +public: + static AniExports* getInstance(); + + std::vector getModules(); + void addMethod(const char* module, const char* name, const char* type, void* impl, int flags); + const std::vector>& getMethods(const std::string& module); + + void setClasspath(const char* module, const char* classpath); + const std::string& getClasspath(const std::string& module); +}; + +#define KOALA_QUOTE0(x) #x +#define KOALA_QUOTE(x) KOALA_QUOTE0(x) + +#ifdef _MSC_VER +#define MAKE_ANI_EXPORT(module, name, type, flag) \ + static void __init_##name() { \ + AniExports::getInstance()->addMethod(KOALA_QUOTE(module), "_"#name, type, reinterpret_cast(Ani_##name), flag); \ + } \ + namespace { \ + struct __Init_##name { \ + __Init_##name() { __init_##name(); } \ + } __Init_##name##_v; \ + } +#define KOALA_ANI_INTEROP_MODULE_CLASSPATH(module, classpath) \ + static void __init_classpath_##module() { \ + AniExports::getInstance()->setClasspath(KOALA_QUOTE(module), "L" classpath ";"); \ + } \ + namespace { \ + struct __Init_classpath_##module { \ + __Init_classpath_##module() { __init_classpath_##module(); } \ + } __Init_classpath_##module##_v; \ + } +#else +#define MAKE_ANI_EXPORT(module, name, type, flag) \ + __attribute__((constructor)) \ + static void __init_ani_##name() { \ + AniExports::getInstance()->addMethod(KOALA_QUOTE(module), "_"#name, type, reinterpret_cast(Ani_##name), flag); \ + } +#define KOALA_ANI_INTEROP_MODULE_CLASSPATH(module, classpath) \ + __attribute__((constructor)) \ + static void __init_ani_classpath_##module() { \ + AniExports::getInstance()->setClasspath(KOALA_QUOTE(module), "L" classpath ";"); \ + } +#endif + +#define KOALA_INTEROP_0(name, Ret) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz) { \ + KOALA_MAYBE_LOG(name) \ + return makeResult(env, impl_##name()); \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret, 0) + +#define KOALA_INTEROP_1(name, Ret, P0) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + auto rv = makeResult(env, impl_##name(p0)); \ + releaseArgument(env, _p0, p0); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0, 0) + +#define KOALA_INTEROP_2(name, Ret, P0, P1) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + auto rv = makeResult(env, impl_##name(p0, p1)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1, 0) + +#define KOALA_INTEROP_3(name, Ret, P0, P1, P2) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2, 0) + +#define KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3, 0) + +#define KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4, 0) + +#define KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) \ +InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5, 0) + +#define KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5, p6)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6, 0) + +#define KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7, 0) + +#define KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + return rv; \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8, 0) + +#define KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9, 0) + +#define KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10, 0) + +#define KOALA_INTEROP_12(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11, 0) + +#define KOALA_INTEROP_13(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + P12 p12 = getArgument(env, _p12); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + releaseArgument(env, _p12, p12); \ + return rv; \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12, 0) + +#define KOALA_INTEROP_14(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12, \ + InteropTypeConverter::InteropType _p13) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + P12 p12 = getArgument(env, _p12); \ + P13 p13 = getArgument(env, _p13); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + releaseArgument(env, _p12, p12); \ + releaseArgument(env, _p13, p13); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12 "|" #P13, 0) + +#define KOALA_INTEROP_V0(name) \ + void Ani_##name(ani_env *env, ani_class clazz) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(); \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void", 0) + +#define KOALA_INTEROP_V1(name, P0) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + impl_##name(p0); \ + releaseArgument(env, _p0, p0); \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0, 0) + +#define KOALA_INTEROP_V2(name, P0, P1) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + impl_##name(p0, p1); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1, 0) + +#define KOALA_INTEROP_V3(name, P0, P1, P2) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + impl_##name(p0, p1, p2); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2, 0) + +#define KOALA_INTEROP_V4(name, P0, P1, P2, P3) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + impl_##name(p0, p1, p2, p3); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ +} \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3, 0) + +#define KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + impl_##name(p0, p1, p2, p3, p4); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ +} \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4, 0) + +#define KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + impl_##name(p0, p1, p2, p3, p4, p5); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5, 0) + +#define KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6, 0) + +#define KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7, 0) + +#define KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8, 0) + +#define KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ +} \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9, 0) + +#define KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10, 0) + +#define KOALA_INTEROP_V12(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ +} \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11, 0) + +#define KOALA_INTEROP_V13(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + P12 p12 = getArgument(env, _p12); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + releaseArgument(env, _p12, p12); \ +} \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12, 0) + +#define KOALA_INTEROP_V14(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12, \ + InteropTypeConverter::InteropType _p13) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + P12 p12 = getArgument(env, _p12); \ + P13 p13 = getArgument(env, _p13); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + releaseArgument(env, _p12, p12); \ + releaseArgument(env, _p13, p13); \ +} \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12 "|" #P13, 0) + +#define KOALA_INTEROP_V15(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12, \ + InteropTypeConverter::InteropType _p13, \ + InteropTypeConverter::InteropType _p14) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + P12 p12 = getArgument(env, _p12); \ + P13 p13 = getArgument(env, _p13); \ + P14 p14 = getArgument(env, _p14); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + releaseArgument(env, _p12, p12); \ + releaseArgument(env, _p13, p13); \ + releaseArgument(env, _p14, p14); \ +} \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12 "|" #P13 "|" #P14, 0) + +#define KOALA_INTEROP_CTX_0(name, Ret) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz) { \ + KOALA_MAYBE_LOG(name) \ + KVMContext ctx = (KVMContext)env; \ + auto rv = makeResult(env, impl_##name(ctx)); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret, ANI_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_1(name, Ret, P0) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + KVMContext ctx = (KVMContext)env; \ + auto rv = makeResult(env, impl_##name(ctx, p0)); \ + releaseArgument(env, _p0, p0); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0, ANI_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_2(name, Ret, P0, P1) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + KVMContext ctx = (KVMContext)env; \ + auto rv = makeResult(env, impl_##name(ctx, p0, p1)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1, ANI_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_3(name, Ret, P0, P1, P2) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + KVMContext ctx = (KVMContext)env; \ + auto rv = makeResult(env, impl_##name(ctx, p0, p1, p2)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2, ANI_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_4(name, Ret, P0, P1, P2, P3) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + KVMContext ctx = (KVMContext)env; \ + auto rv = makeResult(env, impl_##name(ctx, p0, p1, p2, p3)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3, ANI_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_5(name, Ret, P0, P1, P2, P3, P4) \ + InteropTypeConverter::InteropType Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + KVMContext ctx = (KVMContext)env; \ + auto rv = makeResult(env, impl_##name(ctx, p0, p1, p2, p3, p4)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + return rv; \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4, ANI_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_V0(name) \ + void Ani_##name(ani_env *env, ani_class clazz) { \ + KOALA_MAYBE_LOG(name) \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx); \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void", ANI_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_V1(name, P0) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx, p0); \ + releaseArgument(env, _p0, p0); \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0, ANI_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_V2(name, P0, P1) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx, p0, p1); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1, ANI_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_V3(name, P0, P1, P2) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx, p0, p1, p2); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2, ANI_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_V4(name, P0, P1, P2, P3) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx, p0, p1, p2, p3); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3, ANI_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_V5(name, P0, P1, P2, P3, P4) \ + void Ani_##name(ani_env *env, ani_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx, p0, p1, p2, p3, p4); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + } \ +MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4, ANI_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_DIRECT_0(name, Ret) \ + inline InteropTypeConverter::InteropType Ani_##name( \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name()); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret, 0) +#define KOALA_INTEROP_DIRECT_1(name, Ret, P0) \ + inline InteropTypeConverter::InteropType Ani_##name( \ + InteropTypeConverter::InteropType p0 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0))); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0, 0) +#define KOALA_INTEROP_DIRECT_2(name, Ret, P0, P1) \ + inline InteropTypeConverter::InteropType Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1))); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1, 0) +#define KOALA_INTEROP_DIRECT_3(name, Ret, P0, P1, P2) \ + inline InteropTypeConverter::InteropType Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2))); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2, 0) +#define KOALA_INTEROP_DIRECT_4(name, Ret, P0, P1, P2, P3) \ + inline InteropTypeConverter::InteropType Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3))); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3, 0) +#define KOALA_INTEROP_DIRECT_5(name, Ret, P0, P1, P2, P3, P4) \ + inline InteropTypeConverter::InteropType Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4))); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4, 0) +#define KOALA_INTEROP_DIRECT_6(name, Ret, P0, P1, P2, P3, P4, P5) \ + inline InteropTypeConverter::InteropType Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5))); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5, 0) +#define KOALA_INTEROP_DIRECT_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ + inline InteropTypeConverter::InteropType Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6))); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6, 0) +#define KOALA_INTEROP_DIRECT_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ + inline InteropTypeConverter::InteropType Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6, \ + InteropTypeConverter::InteropType p7 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6), DirectInteropTypeConverter::convertFrom(p7))); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7, 0) +#define KOALA_INTEROP_DIRECT_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + inline InteropTypeConverter::InteropType Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6, \ + InteropTypeConverter::InteropType p7, \ + InteropTypeConverter::InteropType p8 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6), DirectInteropTypeConverter::convertFrom(p7), DirectInteropTypeConverter::convertFrom(p8))); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8, 0) +#define KOALA_INTEROP_DIRECT_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + inline InteropTypeConverter::InteropType Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6, \ + InteropTypeConverter::InteropType p7, \ + InteropTypeConverter::InteropType p8, \ + InteropTypeConverter::InteropType p9 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6), DirectInteropTypeConverter::convertFrom(p7), DirectInteropTypeConverter::convertFrom(p8), DirectInteropTypeConverter::convertFrom(p9))); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9, 0) +#define KOALA_INTEROP_DIRECT_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + inline InteropTypeConverter::InteropType Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6, \ + InteropTypeConverter::InteropType p7, \ + InteropTypeConverter::InteropType p8, \ + InteropTypeConverter::InteropType p9, \ + InteropTypeConverter::InteropType p10 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6), DirectInteropTypeConverter::convertFrom(p7), DirectInteropTypeConverter::convertFrom(p8), DirectInteropTypeConverter::convertFrom(p9), DirectInteropTypeConverter::convertFrom(p10))); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10, 0) +#define KOALA_INTEROP_DIRECT_V0(name) \ + inline void Ani_##name( \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void", 0) +#define KOALA_INTEROP_DIRECT_V1(name, P0) \ + inline void Ani_##name( \ + InteropTypeConverter::InteropType p0 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0)); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0, 0) +#define KOALA_INTEROP_DIRECT_V2(name, P0, P1) \ + inline void Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1)); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1, 0) +#define KOALA_INTEROP_DIRECT_V3(name, P0, P1, P2) \ + inline void Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2)); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2, 0) +#define KOALA_INTEROP_DIRECT_V4(name, P0, P1, P2, P3) \ + inline void Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3)); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2 "|" #P3, 0) +#define KOALA_INTEROP_DIRECT_V5(name, P0, P1, P2, P3, P4) \ + inline void Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4)); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4, 0) +#define KOALA_INTEROP_DIRECT_V6(name, P0, P1, P2, P3, P4, P5) \ + inline void Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5)); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5, 0) +#define KOALA_INTEROP_DIRECT_V7(name, P0, P1, P2, P3, P4, P5, P6) \ + inline void Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6)); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6, 0) +#define KOALA_INTEROP_DIRECT_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ + inline void Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6, \ + InteropTypeConverter::InteropType p7 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6), DirectInteropTypeConverter::convertFrom(p7)); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7, 0) +#define KOALA_INTEROP_DIRECT_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + inline void Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6, \ + InteropTypeConverter::InteropType p7, \ + InteropTypeConverter::InteropType p8 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6), DirectInteropTypeConverter::convertFrom(p7), DirectInteropTypeConverter::convertFrom(p8)); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8, 0) +#define KOALA_INTEROP_DIRECT_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + inline void Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6, \ + InteropTypeConverter::InteropType p7, \ + InteropTypeConverter::InteropType p8, \ + InteropTypeConverter::InteropType p9 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6), DirectInteropTypeConverter::convertFrom(p7), DirectInteropTypeConverter::convertFrom(p8), DirectInteropTypeConverter::convertFrom(p9)); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9, 0) +#define KOALA_INTEROP_DIRECT_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + inline void Ani_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6, \ + InteropTypeConverter::InteropType p7, \ + InteropTypeConverter::InteropType p8, \ + InteropTypeConverter::InteropType p9, \ + InteropTypeConverter::InteropType p10 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6), DirectInteropTypeConverter::convertFrom(p7), DirectInteropTypeConverter::convertFrom(p8), DirectInteropTypeConverter::convertFrom(p9), DirectInteropTypeConverter::convertFrom(p10)); \ + } \ + MAKE_ANI_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10, 0) + +bool setKoalaANICallbackDispatcher( + ani_env* ani_env, + ani_class clazz, + const char* dispatcherMethodName, + const char* dispactherMethodSig +); +void getKoalaANICallbackDispatcher(ani_class* clazz, ani_static_method* method); +ani_env* getKoalaANIContext(void* hint); + +// Improve: maybe use CreateArrayBufferExternal here instead, no need for allocations. +#define KOALA_INTEROP_CALL_VOID(venv, id, length, args) \ +{ \ + ani_class clazz = nullptr; \ + ani_static_method method = nullptr; \ + getKoalaANICallbackDispatcher(&clazz, &method); \ + ani_env* env = getKoalaANIContext(venv); \ + ani_int result = 0; \ + long long args_casted = reinterpret_cast(args); \ + CHECK_ANI_FATAL(env->Class_CallStaticMethod_Int(clazz, method, &result, id, args_casted, length)); \ +} + +#define KOALA_INTEROP_CALL_INT(venv, id, length, args) \ +{ \ + ani_class clazz = nullptr; \ + ani_static_method method = nullptr; \ + getKoalaANICallbackDispatcher(&clazz, &method); \ + ani_env* env = getKoalaANIContext(venv); \ + ani_int result = 0; \ + long long args_casted = reinterpret_cast(args); \ + CHECK_ANI_FATAL(env->Class_CallStaticMethod_Int(clazz, method, &result, id, args_casted, length)); \ + return result; \ +} + +#define KOALA_INTEROP_CALL_VOID_INTS32(venv, id, argc, args) KOALA_INTEROP_CALL_VOID(venv, id, (argc) * sizeof(int32_t), args) +#define KOALA_INTEROP_CALL_INT_INTS32(venv, id, argc, args) KOALA_INTEROP_CALL_INT(venv, id, (argc) * sizeof(int32_t), args) + +#define KOALA_INTEROP_THROW(vmContext, object, ...) \ + do { \ + ani_env* env = reinterpret_cast(vmContext); \ + CHECK_ANI_FATAL(env->ThrowError(object)); \ + return __VA_ARGS__; \ + } while (0) + +#define KOALA_INTEROP_THROW_STRING(vmContext, message, ...) \ + do { \ + ani_env* env = reinterpret_cast(vmContext); \ + ani_class errorClass {}; \ + CHECK_ANI_FATAL(env->FindClass("escompat.Error", &errorClass)); \ + ani_method errorCtor {}; \ + CHECK_ANI_FATAL(env->Class_FindMethod(errorClass, "", \ + "C{std.core.String}C{escompat.ErrorOptions}:", &errorCtor)); \ + ani_string messageObject{}; \ + CHECK_ANI_FATAL(env->String_NewUTF8(message, interop_strlen(message), &messageObject)); \ + ani_ref undefined{}; \ + CHECK_ANI_FATAL(env->GetUndefined(&undefined)); \ + ani_object throwObject{}; \ + CHECK_ANI_FATAL(env->Object_New(errorClass, errorCtor, &throwObject, messageObject, undefined)); \ + CHECK_ANI_FATAL(env->ThrowError(static_cast(throwObject))); \ + return __VA_ARGS__; \ + } while (0) + +#endif // KOALA_ANI diff --git a/ets1.2/interop/src/cpp/ani/panda/ani.h b/ets1.2/interop/src/cpp/ani/panda/ani.h new file mode 100644 index 0000000000000000000000000000000000000000..2b88b1a115990814ebb1790ae176bde63ef79535 --- /dev/null +++ b/ets1.2/interop/src/cpp/ani/panda/ani.h @@ -0,0 +1,8302 @@ +/** + * 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. + */ + +#ifndef __ANI_H__ +#define __ANI_H__ +// NOLINTBEGIN + +#ifdef __cplusplus +#include +#include +#include +#else +#include +#include +#include +#endif + +#define ANI_VERSION_1 1 + +#define ANI_FALSE 0 +#define ANI_TRUE 1 + +// Logger interface: +// typedef void (*ani_logger)(FILE *stream, int log_level, const char *component, const char *message); +// ani_option: +// 'option': "--logger" +// 'extra': ani_logger +// where 'log_level' can have the following values: +#define ANI_LOGLEVEL_FATAL 0 +#define ANI_LOGLEVEL_ERROR 1 +#define ANI_LOGLEVEL_WARNING 2 +#define ANI_LOGLEVEL_INFO 3 +#define ANI_LOGLEVEL_DEBUG 4 + +typedef size_t ani_size; + +// Primitive types: +typedef uint8_t ani_boolean; +typedef uint16_t ani_char; +typedef int8_t ani_byte; +typedef int16_t ani_short; +typedef int32_t ani_int; +typedef int64_t ani_long; +typedef float ani_float; +typedef double ani_double; + +// Reference types: +#ifdef __cplusplus +class __ani_ref {}; +class __ani_module : public __ani_ref {}; +class __ani_namespace : public __ani_ref {}; +class __ani_object : public __ani_ref {}; +class __ani_fn_object : public __ani_object {}; +class __ani_enum_item : public __ani_object {}; +class __ani_error : public __ani_object {}; +class __ani_tuple_value : public __ani_object {}; +class __ani_type : public __ani_object {}; +class __ani_arraybuffer : public __ani_object {}; +class __ani_string : public __ani_object {}; +class __ani_class : public __ani_type {}; +class __ani_enum : public __ani_type {}; +class __ani_array : public __ani_object {}; +class __ani_array_boolean : public __ani_array {}; +class __ani_array_char : public __ani_array {}; +class __ani_array_byte : public __ani_array {}; +class __ani_array_short : public __ani_array {}; +class __ani_array_int : public __ani_array {}; +class __ani_array_long : public __ani_array {}; +class __ani_array_float : public __ani_array {}; +class __ani_array_double : public __ani_array {}; +class __ani_array_ref : public __ani_array {}; +class __ani_fixedarray : public __ani_object {}; +class __ani_fixedarray_boolean : public __ani_fixedarray {}; +class __ani_fixedarray_char : public __ani_fixedarray {}; +class __ani_fixedarray_byte : public __ani_fixedarray {}; +class __ani_fixedarray_short : public __ani_fixedarray {}; +class __ani_fixedarray_int : public __ani_fixedarray {}; +class __ani_fixedarray_long : public __ani_fixedarray {}; +class __ani_fixedarray_float : public __ani_fixedarray {}; +class __ani_fixedarray_double : public __ani_fixedarray {}; +class __ani_fixedarray_ref : public __ani_fixedarray {}; +typedef __ani_ref *ani_ref; +typedef __ani_module *ani_module; +typedef __ani_namespace *ani_namespace; +typedef __ani_object *ani_object; +typedef __ani_fn_object *ani_fn_object; +typedef __ani_enum_item *ani_enum_item; +typedef __ani_error *ani_error; +typedef __ani_tuple_value *ani_tuple_value; +typedef __ani_type *ani_type; +typedef __ani_arraybuffer *ani_arraybuffer; +typedef __ani_string *ani_string; +typedef __ani_class *ani_class; +typedef __ani_enum *ani_enum; +typedef __ani_array *ani_array; +typedef __ani_array_boolean *ani_array_boolean; +typedef __ani_array_char *ani_array_char; +typedef __ani_array_byte *ani_array_byte; +typedef __ani_array_short *ani_array_short; +typedef __ani_array_int *ani_array_int; +typedef __ani_array_long *ani_array_long; +typedef __ani_array_float *ani_array_float; +typedef __ani_array_double *ani_array_double; +typedef __ani_array_ref *ani_array_ref; +typedef __ani_fixedarray *ani_fixedarray; +typedef __ani_fixedarray_boolean *ani_fixedarray_boolean; +typedef __ani_fixedarray_char *ani_fixedarray_char; +typedef __ani_fixedarray_byte *ani_fixedarray_byte; +typedef __ani_fixedarray_short *ani_fixedarray_short; +typedef __ani_fixedarray_int *ani_fixedarray_int; +typedef __ani_fixedarray_long *ani_fixedarray_long; +typedef __ani_fixedarray_float *ani_fixedarray_float; +typedef __ani_fixedarray_double *ani_fixedarray_double; +typedef __ani_fixedarray_ref *ani_fixedarray_ref; +#else // __cplusplus +struct __ani_ref; +typedef struct __ani_ref *ani_ref; +typedef ani_ref ani_module; +typedef ani_ref ani_namespace; +typedef ani_ref ani_object; +typedef ani_object ani_fn_object; +typedef ani_object ani_enum_item; +typedef ani_object ani_error; +typedef ani_object ani_tuple_value; +typedef ani_object ani_type; +typedef ani_object ani_arraybuffer; +typedef ani_object ani_string; +typedef ani_type ani_class; +typedef ani_type ani_enum; +typedef ani_object ani_array; +typedef ani_array ani_array_boolean; +typedef ani_array ani_array_char; +typedef ani_array ani_array_byte; +typedef ani_array ani_array_short; +typedef ani_array ani_array_int; +typedef ani_array ani_array_long; +typedef ani_array ani_array_float; +typedef ani_array ani_array_double; +typedef ani_array ani_array_ref; +typedef ani_object ani_fixedarray; +typedef ani_fixedarray ani_fixedarray_boolean; +typedef ani_fixedarray ani_fixedarray_char; +typedef ani_fixedarray ani_fixedarray_byte; +typedef ani_fixedarray ani_fixedarray_short; +typedef ani_fixedarray ani_fixedarray_int; +typedef ani_fixedarray ani_fixedarray_long; +typedef ani_fixedarray ani_fixedarray_float; +typedef ani_fixedarray ani_fixedarray_double; +typedef ani_fixedarray ani_fixedarray_ref; +#endif // __cplusplus + +struct __ani_wref; +typedef struct __ani_wref *ani_wref; + +struct __ani_variable; +typedef struct __ani_variable *ani_variable; + +struct __ani_function; +typedef struct __ani_function *ani_function; + +struct __ani_field; +typedef struct __ani_field *ani_field; + +struct __ani_static_field; +typedef struct __ani_satic_field *ani_static_field; + +struct __ani_method; +typedef struct __ani_method *ani_method; + +struct __ani_static_method; +typedef struct __ani_static_method *ani_static_method; + +struct __ani_resolver; +typedef struct __ani_resolver *ani_resolver; + +typedef union { + ani_boolean z; + ani_char c; + ani_byte b; + ani_short s; + ani_int i; + ani_long l; + ani_float f; + ani_double d; + ani_ref r; +} ani_value; + +typedef struct { + const char *name; + const char *signature; + const void *pointer; +} ani_native_function; + +#ifdef __cplusplus +typedef struct __ani_vm ani_vm; +typedef struct __ani_env ani_env; +#else +typedef const struct __ani_vm_api *ani_vm; +typedef const struct __ani_interaction_api *ani_env; +#endif + +typedef enum { + ANI_OK, + ANI_ERROR, + ANI_INVALID_ARGS, + ANI_INVALID_TYPE, + ANI_INVALID_DESCRIPTOR, + ANI_INCORRECT_REF, + ANI_PENDING_ERROR, + ANI_NOT_FOUND, + ANI_ALREADY_BINDED, + ANI_OUT_OF_REF, + ANI_OUT_OF_MEMORY, + ANI_OUT_OF_RANGE, + ANI_BUFFER_TO_SMALL, + ANI_INVALID_VERSION, + ANI_AMBIGUOUS, + // NOTE: Add necessary status codes +} ani_status; + +typedef struct { + const char *option; + void *extra; +} ani_option; + +typedef struct { + size_t nr_options; + const ani_option *options; +} ani_options; + +struct __ani_vm_api { + void *reserved0; + void *reserved1; + void *reserved2; + void *reserved3; + + ani_status (*DestroyVM)(ani_vm *vm); + ani_status (*GetEnv)(ani_vm *vm, uint32_t version, ani_env **result); + ani_status (*AttachCurrentThread)(ani_vm *vm, const ani_options *options, uint32_t version, ani_env **result); + ani_status (*DetachCurrentThread)(ani_vm *vm); +}; + +#define ANI_EXPORT __attribute__((visibility("default"))) + +#ifdef __cplusplus +extern "C" { +#endif + +ANI_EXPORT ani_status ANI_CreateVM(const ani_options *options, uint32_t version, ani_vm **result); +ANI_EXPORT ani_status ANI_GetCreatedVMs(ani_vm **vms_buffer, ani_size vms_buffer_length, ani_size *result); + +// Prototypes of exported functions for a shared library. +ANI_EXPORT ani_status ANI_Constructor(ani_vm *vm, uint32_t *result); +ANI_EXPORT ani_status ANI_Destructor(ani_vm *vm); + +#ifdef __cplusplus +} +#endif + +struct __ani_interaction_api { + void *reserved0; + void *reserved1; + void *reserved2; + void *reserved3; + + /** + * @brief Retrieves the version information. + * + * This function retrieves the version information and stores it in the result parameter. + * + * @param[in] env A pointer to the environment structure. + * @param[out] result A pointer to a variable where the version information will be stored. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*GetVersion)(ani_env *env, uint32_t *result); + + /** + * @brief Retrieves the Virtual Machine (VM) instance. + * + * This function retrieves the VM instance and stores it in the result parameter. + * + * @param[in] env A pointer to the environment structure. + * @param[out] result A pointer to the VM instance to be populated. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*GetVM)(ani_env *env, ani_vm **result); + + /** + * @brief Creates a new object of a specified class using a constructor method. + * + * This function creates a new object of the given class and calls the specified constructor method with variadic + * arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class of the object to create. + * @param[in] method The constructor method to invoke. + * @param[in] ... Variadic arguments to pass to the constructor method. + * @param[out] result A pointer to store the object return value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_New)(ani_env *env, ani_class cls, ani_method method, ani_object *result, ...); + + /** + * @brief Creates a new object of a specified class using a constructor method (array-based). + * + * This function creates a new object of the given class and calls the specified constructor method with arguments + * provided in an array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class of the object to create. + * @param[in] method The constructor method to invoke. + * @param[in] args An array of arguments to pass to the constructor method. + * @param[out] result A pointer to store the object return value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_New_A)(ani_env *env, ani_class cls, ani_method method, ani_object *result, + const ani_value *args); + + /** + * @brief Creates a new object of a specified class using a constructor method (variadic arguments). + * + * This function creates a new object of the given class and calls the specified constructor method with a `va_list` + * of arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class of the object to create. + * @param[in] method The constructor method to invoke. + * @param[in] args A `va_list` of arguments to pass to the constructor method. + * @param[out] result A pointer to store the object return value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_New_V)(ani_env *env, ani_class cls, ani_method method, ani_object *result, va_list args); + + /** + * @brief Retrieves the type of a given object. + * + * This function retrieves the type of the specified object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object whose type is to be retrieved. + * @param[out] result A pointer to store the retrieved type. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetType)(ani_env *env, ani_object object, ani_type *result); + + /** + * @brief Checks if an object is an instance of a specified type. + * + * This function checks whether the given object is an instance of the specified type. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object to check. + * @param[in] type The type to compare against. + * @param[out] result A pointer to store the boolean result (true if the object is an instance of the type, false + * otherwise). + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_InstanceOf)(ani_env *env, ani_object object, ani_type type, ani_boolean *result); + + /** + * @brief Retrieves the superclass of a specified type. + * + * This function retrieves the superclass of a given type and stores it in the result parameter. + * + * @param[in] env A pointer to the environment structure. + * @param[in] type The type for which to retrieve the superclass. + * @param[out] result A pointer to the superclass to be populated. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Type_GetSuperClass)(ani_env *env, ani_type type, ani_class *result); + + /** + * @brief Determines if one type is assignable from another. + * + * This function checks if a type is assignable from another and stores the result in the output parameter. + * + * @param[in] env A pointer to the environment structure. + * @param[in] from_type The source type. + * @param[in] to_type The target type. + * @param[out] result A pointer to a boolean indicating assignability. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Type_IsAssignableFrom)(ani_env *env, ani_type from_type, ani_type to_type, ani_boolean *result); + + /** + * @brief Finds a module by its descriptor. + * + * This function locates a module based on its descriptor and stores it in the result parameter. + * + * @param[in] env A pointer to the environment structure. + * @param[in] module_descriptor The descriptor of the module to find. + * @param[out] result A pointer to the module to be populated. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FindModule)(ani_env *env, const char *module_descriptor, ani_module *result); + + /** + * @brief Finds a namespace by its descriptor. + * + * This function locates a namespace based on its descriptor and stores it in the result parameter. + * + * @param[in] env A pointer to the environment structure. + * @param[in] namespace_descriptor The descriptor of the namespace to find. + * @param[out] result A pointer to the namespace to be populated. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FindNamespace)(ani_env *env, const char *namespace_descriptor, ani_namespace *result); + + /** + * @brief Finds a class by its descriptor. + * + * This function locates a class based on its descriptor and stores it in the result parameter. + * + * @param[in] env A pointer to the environment structure. + * @param[in] class_descriptor The descriptor of the class to find. + * @param[out] result A pointer to the class to be populated. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FindClass)(ani_env *env, const char *class_descriptor, ani_class *result); + + /** + * @brief Finds an enum by its descriptor. + * + * This function locates an enum based on its descriptor and stores it in the result parameter. + * + * @param[in] env A pointer to the environment structure. + * @param[in] enum_descriptor The descriptor of the enum to find. + * @param[out] result A pointer to the enum to be populated. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FindEnum)(ani_env *env, const char *enum_descriptor, ani_enum *result); + + /** + * @brief Finds a namespace within a module by its descriptor. + * + * This function locates a namespace within the specified module based on its descriptor. + * + * @param[in] env A pointer to the environment structure. + * @param[in] module The module to search within. + * @param[in] namespace_descriptor The descriptor of the namespace to find. + * @param[out] result A pointer to the namespace object. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Module_FindNamespace)(ani_env *env, ani_module module, const char *namespace_descriptor, + ani_namespace *result); + + /** + * @brief Finds a class within a module by its descriptor. + * + * This function locates a class within the specified module based on its descriptor. + * + * @param[in] env A pointer to the environment structure. + * @param[in] module The module to search within. + * @param[in] class_descriptor The descriptor of the class to find. + * @param[out] result A pointer to the class object. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Module_FindClass)(ani_env *env, ani_module module, const char *class_descriptor, ani_class *result); + + /** + * @brief Finds an enum within a module by its descriptor. + * + * This function locates an enum within the specified module based on its descriptor. + * + * @param[in] env A pointer to the environment structure. + * @param[in] module The module to search within. + * @param[in] enum_descriptor The descriptor of the enum to find. + * @param[out] result A pointer to the enum object. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Module_FindEnum)(ani_env *env, ani_module module, const char *enum_descriptor, ani_enum *result); + + /** + * @brief Finds a function within a module by its name and signature. + * + * This function locates a function within the specified module based on its name and signature. + * + * @param[in] env A pointer to the environment structure. + * @param[in] module The module to search within. + * @param[in] name The name of the function to find. + * @param[in] signature The signature of the function to find. + * @param[out] result A pointer to the function object. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Module_FindFunction)(ani_env *env, ani_module module, const char *name, const char *signature, + ani_function *result); + + /** + * @brief Finds a variable within a module by its name. + * + * This function locates a variable within the specified module based on its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] module The module to search within. + * @param[in] name The name of the variable to find. + * @param[out] result A pointer to the variable object. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Module_FindVariable)(ani_env *env, ani_module module, const char *name, ani_variable *result); + + /** + * @brief Finds a namespace within another namespace by its descriptor. + * + * This function locates a namespace within the specified parent namespace based on its descriptor. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ns The parent namespace to search within. + * @param[in] namespace_descriptor The descriptor of the namespace to find. + * @param[out] result A pointer to the namespace object. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Namespace_FindNamespace)(ani_env *env, ani_namespace ns, const char *namespace_descriptor, + ani_namespace *result); + + /** + * @brief Finds a class within a namespace by its descriptor. + * + * This function locates a class within the specified namespace based on its descriptor. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ns The namespace to search within. + * @param[in] class_descriptor The descriptor of the class to find. + * @param[out] result A pointer to the class object. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Namespace_FindClass)(ani_env *env, ani_namespace ns, const char *class_descriptor, ani_class *result); + + /** + * @brief Finds an enum within a namespace by its descriptor. + * + * This function locates an enum within the specified namespace based on its descriptor. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ns The namespace to search within. + * @param[in] enum_descriptor The descriptor of the enum to find. + * @param[out] result A pointer to the enum object. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Namespace_FindEnum)(ani_env *env, ani_namespace ns, const char *enum_descriptor, ani_enum *result); + + /** + * @brief Finds a function within a namespace by its name and signature. + * + * This function locates a function within the specified namespace based on its name and signature. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ns The namespace to search within. + * @param[in] name The name of the function to find. + * @param[in] signature The signature of the function to find. + * @param[out] result A pointer to the function object. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Namespace_FindFunction)(ani_env *env, ani_namespace ns, const char *name, const char *signature, + ani_function *result); + + /** + * @brief Finds a variable within a namespace by its name. + * + * This function locates a variable within the specified namespace based on its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ns The namespace to search within. + * @param[in] name The name of the variable to find. + * @param[out] result A pointer to the variable object. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Namespace_FindVariable)(ani_env *env, ani_namespace ns, const char *name, ani_variable *result); + + /** + * @brief Binds native functions to a module. + * + * This function binds an array of native functions to the specified module. + * + * @param[in] env A pointer to the environment structure. + * @param[in] module The module to which the native functions will be bound. + * @param[in] functions A pointer to an array of native functions to bind. + * @param[in] nr_functions The number of native functions in the array. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Module_BindNativeFunctions)(ani_env *env, ani_module module, const ani_native_function *functions, + ani_size nr_functions); + + /** + * @brief Binds native functions to a namespace. + * + * This function binds an array of native functions to the specified namespace. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ns The namespace to which the native functions will be bound. + * @param[in] functions A pointer to an array of native functions to bind. + * @param[in] nr_functions The number of native functions in the array. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Namespace_BindNativeFunctions)(ani_env *env, ani_namespace ns, const ani_native_function *functions, + ani_size nr_functions); + + /** + * @brief Binds native methods to a class. + * + * This function binds an array of native methods to the specified class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class to which the native methods will be bound. + * @param[in] methods A pointer to an array of native methods to bind. + * @param[in] nr_methods The number of native methods in the array. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_BindNativeMethods)(ani_env *env, ani_class cls, const ani_native_function *methods, + ani_size nr_methods); + + /** + * @brief Deletes a local reference. + * + * This function deletes a specified local reference to free up resources. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ref The reference to be deleted. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Reference_Delete)(ani_env *env, ani_ref ref); + + /** + * @brief Ensures enough local references are available. + * + * This function checks and ensures that the specified number of local references can be created. + * + * @param[in] env A pointer to the environment structure. + * @param[in] nr_refs The number of local references to ensure availability for. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*EnsureEnoughReferences)(ani_env *env, ani_size nr_refs); + + /** + * @brief Creates a new local scope for references. + * + * This function creates a local scope for references with a specified capacity. + * + * @param[in] env A pointer to the environment structure. + * @param[in] nr_refs The maximum number of references that can be created in this scope. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*CreateLocalScope)(ani_env *env, ani_size nr_refs); + + /** + * @brief Destroys the current local scope. + * + * This function destroys the current local scope and frees all references within it. + * + * @param[in] env A pointer to the environment structure. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*DestroyLocalScope)(ani_env *env); + + /** + * @brief Creates a new escape local scope. + * + * This function creates a local scope for references with escape functionality, allowing objects to escape this + * scope. + * + * @param[in] env A pointer to the environment structure. + * @param[in] nr_refs The maximum number of references that can be created in this scope. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*CreateEscapeLocalScope)(ani_env *env, ani_size nr_refs); + + /** + * @brief Destroys the current escape local scope. + * + * This function destroys the current escape local scope and allows escaping references to be retrieved. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ref The reference to be escaped from the current scope. + * @param[out] result A pointer to the resulting reference that has escaped the scope. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*DestroyEscapeLocalScope)(ani_env *env, ani_ref ref, ani_ref *result); + + /** + * @brief Throws an error. + * + * This function throws the specified error in the current environment. + * + * @param[in] env A pointer to the environment structure. + * @param[in] err The error to throw. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*ThrowError)(ani_env *env, ani_error err); + + /** + * @brief Checks if there are unhandled errors. + * + * This function determines if there are unhandled errors in the current environment. + * + * @param[in] env A pointer to the environment structure. + * @param[out] result A pointer to a boolean indicating if unhandled errors exist. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*ExistUnhandledError)(ani_env *env, ani_boolean *result); + + /** + * @brief Retrieves the current unhandled error. + * + * This function fetches the unhandled error in the environment. + * + * @param[in] env A pointer to the environment structure. + * @param[out] result A pointer to store the unhandled error. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*GetUnhandledError)(ani_env *env, ani_error *result); + + /** + * @brief Resets the current error state. + * + * This function clears the error state in the current environment. + * + * @param[in] env A pointer to the environment structure. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*ResetError)(ani_env *env); + + /** + * @brief Provides a description of the current error. + * + * This function prints the stack trace or other debug information for the current error. + * + * @param[in] env A pointer to the environment structure. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*DescribeError)(ani_env *env); // NOTE: Print stacktrace for debugging? + + /** + * @brief Aborts execution with a message. + * + * This function terminates execution with the specified error message. + * + * @param[in] env A pointer to the environment structure. + * @param[in] message The error message to display on termination. + * @return Does not return; the process terminates. + */ + ani_status (*Abort)(ani_env *env, const char *message); + + /** + * @brief Retrieves a null reference. + * + * This function provides a null reference in the specified result. + * + * @param[in] env A pointer to the environment structure. + * @param[out] result A pointer to store the null reference. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*GetNull)(ani_env *env, ani_ref *result); + + /** + * @brief Retrieves an undefined reference. + * + * This function provides an undefined reference in the specified result. + * + * @param[in] env A pointer to the environment structure. + * @param[out] result A pointer to store the undefined reference. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*GetUndefined)(ani_env *env, ani_ref *result); + + /** + * @brief Checks if a reference is null. + * + * This function determines if the specified reference is null. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ref The reference to check. + * @param[out] result A pointer to a boolean indicating if the reference is null. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Reference_IsNull)(ani_env *env, ani_ref ref, ani_boolean *result); + + /** + * @brief Checks if a reference is undefined. + * + * This function determines if the specified reference is undefined. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ref The reference to check. + * @param[out] result A pointer to a boolean indicating if the reference is undefined. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Reference_IsUndefined)(ani_env *env, ani_ref ref, ani_boolean *result); + + /** + * @brief Checks if a reference is nullish value (null or undefined). + * + * This function determines if the specified reference is either null or undefined. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ref The reference to check. + * @param[out] result A pointer to a boolean indicating if the reference is nullish value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Reference_IsNullishValue)(ani_env *env, ani_ref ref, ani_boolean *result); + + /** + * @brief Compares two references for equality. + * + * This function checks if two references are equal. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ref0 The first reference to compare. + * @param[in] ref1 The second reference to compare. + * @param[out] result A pointer to a boolean indicating if the references are equal. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Reference_Equals)(ani_env *env, ani_ref ref0, ani_ref ref1, ani_boolean *result); + + /** + * @brief Compares two references for strict equality. + * + * This function checks if two references are strictly equal. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ref0 The first reference to compare. + * @param[in] ref1 The second reference to compare. + * @param[out] result A pointer to a boolean indicating if the references are strictly equal. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Reference_StrictEquals)(ani_env *env, ani_ref ref0, ani_ref ref1, ani_boolean *result); + + /** + * @brief Creates a new UTF-16 string. + * + * This function creates a new string from the provided UTF-16 encoded data. + * + * @param[in] env A pointer to the environment structure. + * @param[in] utf16_string A pointer to the UTF-16 encoded string data. + * @param[in] utf16_size The size of the UTF-16 string in code units. + * @param[out] result A pointer to store the created string. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*String_NewUTF16)(ani_env *env, const uint16_t *utf16_string, ani_size utf16_size, ani_string *result); + + /** + * @brief Retrieves the size of a UTF-16 string. + * + * This function retrieves the size (in code units) of the specified UTF-16 string. + * + * @param[in] env A pointer to the environment structure. + * @param[in] string The UTF-16 string to measure. + * @param[out] result A pointer to store the size of the string. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*String_GetUTF16Size)(ani_env *env, ani_string string, ani_size *result); + + /** + * @brief Retrieves the UTF-16 encoded data of a string. + * + * This function copies the UTF-16 encoded data of the string into the provided buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] string The string to retrieve data from. + * @param[out] utf16_buffer A buffer to store the UTF-16 encoded data. + * @param[in] utf16_buffer_size The size of the buffer in code units. + * @param[out] result A pointer to store the number of code units written. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*String_GetUTF16)(ani_env *env, ani_string string, uint16_t *utf16_buffer, ani_size utf16_buffer_size, + ani_size *result); + + /** + * @brief Retrieves a substring of a UTF-16 string. + * + * This function copies a portion of the UTF-16 string into the provided buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] string The string to retrieve data from. + * @param[in] substr_offset The starting offset of the substring. + * @param[in] substr_size The size of the substring in code units. + * @param[out] utf16_buffer A buffer to store the substring. + * @param[in] utf16_buffer_size The size of the buffer in code units. + * @param[out] result A pointer to store the number of code units written. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*String_GetUTF16SubString)(ani_env *env, ani_string string, ani_size substr_offset, + ani_size substr_size, uint16_t *utf16_buffer, ani_size utf16_buffer_size, + ani_size *result); + + /** + * @brief Creates a new UTF-8 string. + * + * This function creates a new string from the provided UTF-8 encoded data. + * + * @param[in] env A pointer to the environment structure. + * @param[in] utf8_string A pointer to the UTF-8 encoded string data. + * @param[in] utf8_size The size of the UTF-8 string in bytes. + * @param[out] result A pointer to store the created string. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*String_NewUTF8)(ani_env *env, const char *utf8_string, ani_size utf8_size, ani_string *result); + + /** + * @brief Retrieves the size of a UTF-8 string. + * + * This function retrieves the size (in bytes) of the specified UTF-8 string. + * + * @param[in] env A pointer to the environment structure. + * @param[in] string The UTF-8 string to measure. + * @param[out] result A pointer to store the size of the string. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*String_GetUTF8Size)(ani_env *env, ani_string string, ani_size *result); + + /** + * @brief Retrieves the UTF-8 encoded data of a string. + * + * This function copies the UTF-8 encoded data of the string into the provided buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] string The string to retrieve data from. + * @param[out] utf8_buffer A buffer to store the UTF-8 encoded data. + * @param[in] utf8_buffer_size The size of the buffer in bytes. + * @param[out] result A pointer to store the number of bytes written. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*String_GetUTF8)(ani_env *env, ani_string string, char *utf8_buffer, ani_size utf8_buffer_size, + ani_size *result); + + /** + * @brief Retrieves a substring of a UTF-8 string. + * + * This function copies a portion of the UTF-8 string into the provided buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] string The string to retrieve data from. + * @param[in] substr_offset The starting offset of the substring. + * @param[in] substr_size The size of the substring in bytes. + * @param[out] utf8_buffer A buffer to store the substring. + * @param[in] utf8_buffer_size The size of the buffer in bytes. + * @param[out] result A pointer to store the number of bytes written. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*String_GetUTF8SubString)(ani_env *env, ani_string string, ani_size substr_offset, ani_size substr_size, + char *utf8_buffer, ani_size utf8_buffer_size, ani_size *result); + + /** + * @brief Retrieves the length of an array. + * + * This function retrieves the length of the specified array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array whose length is to be retrieved. + * @param[out] result A pointer to store the length of the array. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_GetLength)(ani_env *env, ani_array array, ani_size *result); + + /** + * @brief Creates a new array of booleans. + * + * This function creates a new array of the specified length for boolean values. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the array to be created. + * @param[out] result A pointer to store the created array. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_New_Boolean)(ani_env *env, ani_size length, ani_array_boolean *result); + + /** + * @brief Creates a new array of characters. + * + * This function creates a new array of the specified length for character values. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the array to be created. + * @param[out] result A pointer to store the created array. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_New_Char)(ani_env *env, ani_size length, ani_array_char *result); + + /** + * @brief Creates a new array of bytes. + * + * This function creates a new array of the specified length for byte values. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the array to be created. + * @param[out] result A pointer to store the created array. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_New_Byte)(ani_env *env, ani_size length, ani_array_byte *result); + + /** + * @brief Creates a new array of shorts. + * + * This function creates a new array of the specified length for short integer values. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the array to be created. + * @param[out] result A pointer to store the created array. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_New_Short)(ani_env *env, ani_size length, ani_array_short *result); + + /** + * @brief Creates a new array of integers. + * + * This function creates a new array of the specified length for integer values. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the array to be created. + * @param[out] result A pointer to store the created array. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_New_Int)(ani_env *env, ani_size length, ani_array_int *result); + + /** + * @brief Creates a new array of long integers. + * + * This function creates a new array of the specified length for long integer values. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the array to be created. + * @param[out] result A pointer to store the created array. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_New_Long)(ani_env *env, ani_size length, ani_array_long *result); + + /** + * @brief Creates a new array of floats. + * + * This function creates a new array of the specified length for float values. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the array to be created. + * @param[out] result A pointer to store the created array. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_New_Float)(ani_env *env, ani_size length, ani_array_float *result); + + /** + * @brief Creates a new array of doubles. + * + * This function creates a new array of the specified length for double values. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the array to be created. + * @param[out] result A pointer to store the created array. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_New_Double)(ani_env *env, ani_size length, ani_array_double *result); + + /** + * @brief Retrieves a region of boolean values from an array. + * + * This function retrieves a portion of the specified boolean array into a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to retrieve values from. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to retrieve. + * @param[out] native_buffer A buffer to store the retrieved boolean values. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_GetRegion_Boolean)(ani_env *env, ani_array_boolean array, ani_size offset, ani_size length, + ani_boolean *native_buffer); + + /** + * @brief Retrieves a region of character values from an array. + * + * This function retrieves a portion of the specified character array into a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to retrieve values from. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to retrieve. + * @param[out] native_buffer A buffer to store the retrieved character values. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_GetRegion_Char)(ani_env *env, ani_array_char array, ani_size offset, ani_size length, + ani_char *native_buffer); + + /** + * @brief Retrieves a region of byte values from an array. + * + * This function retrieves a portion of the specified byte array into a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to retrieve values from. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to retrieve. + * @param[out] native_buffer A buffer to store the retrieved byte values. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_GetRegion_Byte)(ani_env *env, ani_array_byte array, ani_size offset, ani_size length, + ani_byte *native_buffer); + + /** + * @brief Retrieves a region of short values from an array. + * + * This function retrieves a portion of the specified short array into a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to retrieve values from. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to retrieve. + * @param[out] native_buffer A buffer to store the retrieved short values. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_GetRegion_Short)(ani_env *env, ani_array_short array, ani_size offset, ani_size length, + ani_short *native_buffer); + + /** + * @brief Retrieves a region of integer values from an array. + * + * This function retrieves a portion of the specified integer array into a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to retrieve values from. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to retrieve. + * @param[out] native_buffer A buffer to store the retrieved integer values. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_GetRegion_Int)(ani_env *env, ani_array_int array, ani_size offset, ani_size length, + ani_int *native_buffer); + + /** + * @brief Retrieves a region of long integer values from an array. + * + * This function retrieves a portion of the specified long integer array into a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to retrieve values from. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to retrieve. + * @param[out] native_buffer A buffer to store the retrieved long integer values. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_GetRegion_Long)(ani_env *env, ani_array_long array, ani_size offset, ani_size length, + ani_long *native_buffer); + + /** + * @brief Retrieves a region of float values from an array. + * + * This function retrieves a portion of the specified float array into a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to retrieve values from. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to retrieve. + * @param[out] native_buffer A buffer to store the retrieved float values. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_GetRegion_Float)(ani_env *env, ani_array_float array, ani_size offset, ani_size length, + ani_float *native_buffer); + + /** + * @brief Retrieves a region of double values from an array. + * + * This function retrieves a portion of the specified double array into a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to retrieve values from. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to retrieve. + * @param[out] native_buffer A buffer to store the retrieved double values. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_GetRegion_Double)(ani_env *env, ani_array_double array, ani_size offset, ani_size length, + ani_double *native_buffer); + + /** + * @brief Sets a region of boolean values in an array. + * + * This function sets a portion of the specified boolean array using a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to set values in. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to set. + * @param[in] native_buffer A buffer containing the boolean values to set. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_SetRegion_Boolean)(ani_env *env, ani_array_boolean array, ani_size offset, ani_size length, + const ani_boolean *native_buffer); + + /** + * @brief Sets a region of character values in an array. + * + * This function sets a portion of the specified character array using a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to set values in. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to set. + * @param[in] native_buffer A buffer containing the character values to set. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_SetRegion_Char)(ani_env *env, ani_array_char array, ani_size offset, ani_size length, + const ani_char *native_buffer); + + /** + * @brief Sets a region of byte values in an array. + * + * This function sets a portion of the specified byte array using a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to set values in. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to set. + * @param[in] native_buffer A buffer containing the byte values to set. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_SetRegion_Byte)(ani_env *env, ani_array_byte array, ani_size offset, ani_size length, + const ani_byte *native_buffer); + + /** + * @brief Sets a region of short values in an array. + * + * This function sets a portion of the specified short array using a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to set values in. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to set. + * @param[in] native_buffer A buffer containing the short values to set. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_SetRegion_Short)(ani_env *env, ani_array_short array, ani_size offset, ani_size length, + const ani_short *native_buffer); + + /** + * @brief Sets a region of integer values in an array. + * + * This function sets a portion of the specified integer array using a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to set values in. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to set. + * @param[in] native_buffer A buffer containing the integer values to set. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_SetRegion_Int)(ani_env *env, ani_array_int array, ani_size offset, ani_size length, + const ani_int *native_buffer); + + /** + * @brief Sets a region of long integer values in an array. + * + * This function sets a portion of the specified long integer array using a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to set values in. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to set. + * @param[in] native_buffer A buffer containing the long integer values to set. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_SetRegion_Long)(ani_env *env, ani_array_long array, ani_size offset, ani_size length, + const ani_long *native_buffer); + + /** + * @brief Sets a region of float values in an array. + * + * This function sets a portion of the specified float array using a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to set values in. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to set. + * @param[in] native_buffer A buffer containing the float values to set. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_SetRegion_Float)(ani_env *env, ani_array_float array, ani_size offset, ani_size length, + const ani_float *native_buffer); + + /** + * @brief Sets a region of double values in an array. + * + * This function sets a portion of the specified double array using a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to set values in. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to set. + * @param[in] native_buffer A buffer containing the double values to set. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_SetRegion_Double)(ani_env *env, ani_array_double array, ani_size offset, ani_size length, + const ani_double *native_buffer); + + /** + * @brief Creates a new array of references. + * + * This function creates a new array of references, optionally initializing it with an array of references. + * + * @param[in] env A pointer to the environment structure. + * @param[in] type The type of the elements of the array. + * @param[in] length The length of the array to be created. + * @param[in] initial_element An optional reference to initialize the array. Can be null. + * @param[out] result A pointer to store the created array of references. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_New_Ref)(ani_env *env, ani_type type, ani_size length, ani_ref initial_element, + ani_array_ref *result); + + /** + * @brief Sets a reference at a specific index in an array. + * + * This function sets the value of a reference at the specified index in the array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array of references to modify. + * @param[in] index The index at which to set the reference. + * @param[in] ref The reference to set at the specified index. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_Set_Ref)(ani_env *env, ani_array_ref array, ani_size index, ani_ref ref); + + /** + * @brief Retrieves a reference from a specific index in an array. + * + * This function retrieves the value of a reference at the specified index in the array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array of references to query. + * @param[in] index The index from which to retrieve the reference. + * @param[out] result A pointer to store the retrieved reference. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_Get_Ref)(ani_env *env, ani_array_ref array, ani_size index, ani_ref *result); + + /** + * @brief Creates a new array + * + * This function creates a new array of the specified length. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the array to be created. + * @param[in] initial_element Element the array will be initialized with + * @param[out] result A pointer to store the created array. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_New)(ani_env *env, ani_size length, ani_ref initial_element, ani_array *result); + + /** + * @brief Sets a value to an array. + * + * This function sets a value to array from an ani_ref value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to retrieve values from. + * @param[in] index The index of element to retrieve. + * @param[in] ref Value to set + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_Set)(ani_env *env, ani_array array, ani_size index, ani_ref ref); + + /** + * @brief Retrieves a value from an array. + * + * This function retrieves a value from array into an ani_ref pointer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to retrieve values from. + * @param[in] index The index of element to retrieve. + * @param[out] result A pointer to store the retrieved value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_Get)(ani_env *env, ani_array array, ani_size index, ani_ref *result); + + /** + * @brief Push a value to the end of array. + * + * This function pushes value from an ani_ref to the end of array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array to retrieve values from. + * @param[in] ref Value to set + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_Push)(ani_env *env, ani_array array, ani_ref ref); + + /** + * @brief Retrieves the last element and erases it from array. + * + * This function retrieves the last element and erases it from array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array whose last element is to be retrieved. + * @param[out] result A pointer to store the last element of the array. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Array_Pop)(ani_env *env, ani_array array, ani_ref *result); + + /** + * @brief Retrieves the length of an fixedarray. + * + * This function retrieves the length of the specified array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray whose length is to be retrieved. + * @param[out] result A pointer to store the length of the fixedarray. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_GetLength)(ani_env *env, ani_fixedarray array, ani_size *result); + + /** + * @brief Creates a new fixedarray of booleans. + * + * This function creates a new fixedarray of the specified length for boolean values. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the fixedarray to be created. + * @param[out] result A pointer to store the created fixedarray. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_New_Boolean)(ani_env *env, ani_size length, ani_fixedarray_boolean *result); + + /** + * @brief Creates a new fixedarray of characters. + * + * This function creates a new fixedarray of the specified length for character values. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the fixedarray to be created. + * @param[out] result A pointer to store the created fixedarray. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_New_Char)(ani_env *env, ani_size length, ani_fixedarray_char *result); + + /** + * @brief Creates a new fixedarray of bytes. + * + * This function creates a new fixedarray of the specified length for byte values. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the fixedarray to be created. + * @param[out] result A pointer to store the created fixedarray. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_New_Byte)(ani_env *env, ani_size length, ani_fixedarray_byte *result); + + /** + * @brief Creates a new fixedarray of shorts. + * + * This function creates a new fixedarray of the specified length for short integer values. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the fixedarray to be created. + * @param[out] result A pointer to store the created fixedarray. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_New_Short)(ani_env *env, ani_size length, ani_fixedarray_short *result); + + /** + * @brief Creates a new fixedarray of integers. + * + * This function creates a new fixedarray of the specified length for integer values. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the fixedarray to be created. + * @param[out] result A pointer to store the created fixedarray. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_New_Int)(ani_env *env, ani_size length, ani_fixedarray_int *result); + + /** + * @brief Creates a new fixedarray of long integers. + * + * This function creates a new fixedarray of the specified length for long integer values. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the fixedarray to be created. + * @param[out] result A pointer to store the created fixedarray. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_New_Long)(ani_env *env, ani_size length, ani_fixedarray_long *result); + + /** + * @brief Creates a new fixedarray of floats. + * + * This function creates a new fixedarray of the specified length for float values. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the fixedarray to be created. + * @param[out] result A pointer to store the created fixedarray. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_New_Float)(ani_env *env, ani_size length, ani_fixedarray_float *result); + + /** + * @brief Creates a new fixedarray of doubles. + * + * This function creates a new fixedarray of the specified length for double values. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the fixedarray to be created. + * @param[out] result A pointer to store the created fixedarray. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_New_Double)(ani_env *env, ani_size length, ani_fixedarray_double *result); + + /** + * @brief Retrieves a region of boolean values from an fixedarray. + * + * This function retrieves a portion of the specified boolean fixedarray into a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray to retrieve values from. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to retrieve. + * @param[out] native_buffer A buffer to store the retrieved boolean values. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_GetRegion_Boolean)(ani_env *env, ani_fixedarray_boolean array, ani_size offset, + ani_size length, ani_boolean *native_buffer); + + /** + * @brief Retrieves a region of character values from an fixedarray. + * + * This function retrieves a portion of the specified character fixedarray into a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray to retrieve values from. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to retrieve. + * @param[out] native_buffer A buffer to store the retrieved character values. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_GetRegion_Char)(ani_env *env, ani_fixedarray_char array, ani_size offset, ani_size length, + ani_char *native_buffer); + + /** + * @brief Retrieves a region of byte values from an fixedarray. + * + * This function retrieves a portion of the specified byte fixedarray into a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray to retrieve values from. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to retrieve. + * @param[out] native_buffer A buffer to store the retrieved byte values. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_GetRegion_Byte)(ani_env *env, ani_fixedarray_byte array, ani_size offset, ani_size length, + ani_byte *native_buffer); + + /** + * @brief Retrieves a region of short values from an fixedarray. + * + * This function retrieves a portion of the specified short fixedarray into a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray to retrieve values from. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to retrieve. + * @param[out] native_buffer A buffer to store the retrieved short values. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_GetRegion_Short)(ani_env *env, ani_fixedarray_short array, ani_size offset, ani_size length, + ani_short *native_buffer); + + /** + * @brief Retrieves a region of integer values from an fixedarray. + * + * This function retrieves a portion of the specified integer fixedarray into a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray to retrieve values from. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to retrieve. + * @param[out] native_buffer A buffer to store the retrieved integer values. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_GetRegion_Int)(ani_env *env, ani_fixedarray_int array, ani_size offset, ani_size length, + ani_int *native_buffer); + + /** + * @brief Retrieves a region of long integer values from an fixedarray. + * + * This function retrieves a portion of the specified long integer fixedarray into a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray to retrieve values from. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to retrieve. + * @param[out] native_buffer A buffer to store the retrieved long integer values. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_GetRegion_Long)(ani_env *env, ani_fixedarray_long array, ani_size offset, ani_size length, + ani_long *native_buffer); + + /** + * @brief Retrieves a region of float values from an fixedarray. + * + * This function retrieves a portion of the specified float fixedarray into a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray to retrieve values from. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to retrieve. + * @param[out] native_buffer A buffer to store the retrieved float values. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_GetRegion_Float)(ani_env *env, ani_fixedarray_float array, ani_size offset, ani_size length, + ani_float *native_buffer); + + /** + * @brief Retrieves a region of double values from an fixedarray. + * + * This function retrieves a portion of the specified double fixedarray into a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray to retrieve values from. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to retrieve. + * @param[out] native_buffer A buffer to store the retrieved double values. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_GetRegion_Double)(ani_env *env, ani_fixedarray_double array, ani_size offset, + ani_size length, ani_double *native_buffer); + + /** + * @brief Sets a region of boolean values in an fixedarray. + * + * This function sets a portion of the specified boolean fixedarray using a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray to set values in. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to set. + * @param[in] native_buffer A buffer containing the boolean values to set. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_SetRegion_Boolean)(ani_env *env, ani_fixedarray_boolean array, ani_size offset, + ani_size length, const ani_boolean *native_buffer); + + /** + * @brief Sets a region of character values in an fixedarray. + * + * This function sets a portion of the specified character fixedarray using a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray to set values in. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to set. + * @param[in] native_buffer A buffer containing the character values to set. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_SetRegion_Char)(ani_env *env, ani_fixedarray_char array, ani_size offset, ani_size length, + const ani_char *native_buffer); + + /** + * @brief Sets a region of byte values in an fixedarray. + * + * This function sets a portion of the specified byte fixedarray using a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray to set values in. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to set. + * @param[in] native_buffer A buffer containing the byte values to set. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_SetRegion_Byte)(ani_env *env, ani_fixedarray_byte array, ani_size offset, ani_size length, + const ani_byte *native_buffer); + + /** + * @brief Sets a region of short values in an fixedarray. + * + * This function sets a portion of the specified short fixedarray using a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray to set values in. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to set. + * @param[in] native_buffer A buffer containing the short values to set. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_SetRegion_Short)(ani_env *env, ani_fixedarray_short array, ani_size offset, ani_size length, + const ani_short *native_buffer); + + /** + * @brief Sets a region of integer values in an fixedarray. + * + * This function sets a portion of the specified integer fixedarray using a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray to set values in. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to set. + * @param[in] native_buffer A buffer containing the integer values to set. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_SetRegion_Int)(ani_env *env, ani_fixedarray_int array, ani_size offset, ani_size length, + const ani_int *native_buffer); + + /** + * @brief Sets a region of long integer values in an fixedarray. + * + * This function sets a portion of the specified long integer fixedarray using a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray to set values in. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to set. + * @param[in] native_buffer A buffer containing the long integer values to set. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_SetRegion_Long)(ani_env *env, ani_fixedarray_long array, ani_size offset, ani_size length, + const ani_long *native_buffer); + + /** + * @brief Sets a region of float values in an fixedarray. + * + * This function sets a portion of the specified float fixedarray using a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray to set values in. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to set. + * @param[in] native_buffer A buffer containing the float values to set. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_SetRegion_Float)(ani_env *env, ani_fixedarray_float array, ani_size offset, ani_size length, + const ani_float *native_buffer); + + /** + * @brief Sets a region of double values in an fixedarray. + * + * This function sets a portion of the specified double fixedarray using a native buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray to set values in. + * @param[in] offset The starting offset of the region. + * @param[in] length The number of elements to set. + * @param[in] native_buffer A buffer containing the double values to set. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_SetRegion_Double)(ani_env *env, ani_fixedarray_double array, ani_size offset, + ani_size length, const ani_double *native_buffer); + + /** + * @brief Creates a new fixedarray of references. + * + * This function creates a new fixedarray of references, optionally initializing it with an initial_element ref. + * + * @param[in] env A pointer to the environment structure. + * @param[in] type The type of the elements of the fixedarray. + * @param[in] length The length of the fixedarray to be created. + * @param[in] initial_element An optional reference to initialize the fixedarray. Can be null. + * @param[out] result A pointer to store the created fixedarray of references. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_New_Ref)(ani_env *env, ani_type type, ani_size length, ani_ref initial_element, + ani_fixedarray_ref *result); + + /** + * @brief Sets a reference at a specific index in an fixedarray. + * + * This function sets the value of a reference at the specified index in the fixedarray. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The array of references to modify. + * @param[in] index The index at which to set the reference. + * @param[in] ref The reference to set at the specified index. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_Set_Ref)(ani_env *env, ani_fixedarray_ref array, ani_size index, ani_ref ref); + + /** + * @brief Retrieves a reference from a specific index in an fixedarray. + * + * This function retrieves the value of a reference at the specified index in the fixedarray. + * + * @param[in] env A pointer to the environment structure. + * @param[in] array The fixedarray of references to query. + * @param[in] index The index from which to retrieve the reference. + * @param[out] result A pointer to store the retrieved reference. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FixedArray_Get_Ref)(ani_env *env, ani_fixedarray_ref array, ani_size index, ani_ref *result); + + /** + * @brief Retrieves an enum item by its name. + * + * This function retrieves an enum item associated with the specified name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] enm The enum to search within. + * @param[in] name The name of the enum item to retrieve. + * @param[out] result A pointer to store the retrieved enum item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Enum_GetEnumItemByName)(ani_env *env, ani_enum enm, const char *name, ani_enum_item *result); + + /** + * @brief Retrieves an enum item by its index. + * + * This function retrieves an enum item located at the specified index. + * + * @param[in] env A pointer to the environment structure. + * @param[in] enm The enum to search within. + * @param[in] index The index of the enum item to retrieve. + * @param[out] result A pointer to store the retrieved enum item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Enum_GetEnumItemByIndex)(ani_env *env, ani_enum enm, ani_size index, ani_enum_item *result); + + /** + * @brief Retrieves the enum associated with an enum item. + * + * This function retrieves the enum to which the specified enum item belongs. + * + * @param[in] env A pointer to the environment structure. + * @param[in] enum_item The enum item whose associated enum is to be retrieved. + * @param[out] result A pointer to store the retrieved enum. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*EnumItem_GetEnum)(ani_env *env, ani_enum_item enum_item, ani_enum *result); + + /** + * @brief Retrieves the integer value of an enum item. + * + * This function retrieves the integer representing the value of the specified enum item. + * + * @param[in] env A pointer to the environment structure. + * @param[in] enum_item The enum item whose underlying value is to be retrieved. + * @param[out] result A pointer to store the retrieved integer. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*EnumItem_GetValue_Int)(ani_env *env, ani_enum_item enum_item, ani_int *result); + + /** + * @brief Retrieves the string value of an enum item. + * + * This function retrieves the string representing the value of the specified enum item. + * + * @param[in] env A pointer to the environment structure. + * @param[in] enum_item The enum item whose underlying value is to be retrieved. + * @param[out] result A pointer to store the retrieved string. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*EnumItem_GetValue_String)(ani_env *env, ani_enum_item enum_item, ani_string *result); + + /** + * @brief Retrieves the name of an enum item. + * + * This function retrieves the name associated with the specified enum item. + * + * @param[in] env A pointer to the environment structure. + * @param[in] enum_item The enum item whose name is to be retrieved. + * @param[out] result A pointer to store the retrieved name. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*EnumItem_GetName)(ani_env *env, ani_enum_item enum_item, ani_string *result); + + /** + * @brief Retrieves the index of an enum item. + * + * This function retrieves the index of the specified enum item within its enum. + * + * @param[in] env A pointer to the environment structure. + * @param[in] enum_item The enum item whose index is to be retrieved. + * @param[out] result A pointer to store the retrieved index. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*EnumItem_GetIndex)(ani_env *env, ani_enum_item enum_item, ani_size *result); + + /** + * @brief Invokes a functional object. + * + * This function invokes a functional object (e.g., a function or callable object) with the specified arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The functional object to invoke. + * @param[in] argc The number of arguments being passed to the functional object. + * @param[in] argv A pointer to an array of references representing the arguments. Can be null if `argc` is 0. + * @param[out] result A pointer to store the result of the invocation. Must be non null. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*FunctionalObject_Call)(ani_env *env, ani_fn_object fn, ani_size argc, ani_ref *argv, ani_ref *result); + + /** + * @brief Sets a boolean value to a variable. + * + * This function assigns a boolean value to the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to modify. + * @param[in] value The boolean value to assign to the variable. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_SetValue_Boolean)(ani_env *env, ani_variable variable, ani_boolean value); + + /** + * @brief Sets a character value to a variable. + * + * This function assigns a character value to the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to modify. + * @param[in] value The character value to assign to the variable. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_SetValue_Char)(ani_env *env, ani_variable variable, ani_char value); + + /** + * @brief Sets a byte value to a variable. + * + * This function assigns a byte value to the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to modify. + * @param[in] value The byte value to assign to the variable. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_SetValue_Byte)(ani_env *env, ani_variable variable, ani_byte value); + + /** + * @brief Sets a short value to a variable. + * + * This function assigns a short integer value to the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to modify. + * @param[in] value The short integer value to assign to the variable. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_SetValue_Short)(ani_env *env, ani_variable variable, ani_short value); + + /** + * @brief Sets an integer value to a variable. + * + * This function assigns an integer value to the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to modify. + * @param[in] value The integer value to assign to the variable. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_SetValue_Int)(ani_env *env, ani_variable variable, ani_int value); + + /** + * @brief Sets a long value to a variable. + * + * This function assigns a long integer value to the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to modify. + * @param[in] value The long integer value to assign to the variable. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_SetValue_Long)(ani_env *env, ani_variable variable, ani_long value); + + /** + * @brief Sets a float value to a variable. + * + * This function assigns a float value to the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to modify. + * @param[in] value The float value to assign to the variable. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_SetValue_Float)(ani_env *env, ani_variable variable, ani_float value); + + /** + * @brief Sets a double value to a variable. + * + * This function assigns a double value to the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to modify. + * @param[in] value The double value to assign to the variable. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_SetValue_Double)(ani_env *env, ani_variable variable, ani_double value); + + /** + * @brief Sets a reference value to a variable. + * + * This function assigns a reference value to the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to modify. + * @param[in] value The reference value to assign to the variable. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_SetValue_Ref)(ani_env *env, ani_variable variable, ani_ref value); + + /** + * @brief Retrieves a boolean value from a variable. + * + * This function fetches a boolean value from the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to query. + * @param[out] result A pointer to store the retrieved boolean value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_GetValue_Boolean)(ani_env *env, ani_variable variable, ani_boolean *result); + + /** + * @brief Retrieves a character value from a variable. + * + * This function fetches a character value from the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to query. + * @param[out] result A pointer to store the retrieved character value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_GetValue_Char)(ani_env *env, ani_variable variable, ani_char *result); + + /** + * @brief Retrieves a byte value from a variable. + * + * This function fetches a byte value from the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to query. + * @param[out] result A pointer to store the retrieved byte value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_GetValue_Byte)(ani_env *env, ani_variable variable, ani_byte *result); + + /** + * @brief Retrieves a short value from a variable. + * + * This function fetches a short integer value from the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to query. + * @param[out] result A pointer to store the retrieved short integer value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_GetValue_Short)(ani_env *env, ani_variable variable, ani_short *result); + + /** + * @brief Retrieves an integer value from a variable. + * + * This function fetches an integer value from the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to query. + * @param[out] result A pointer to store the retrieved integer value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_GetValue_Int)(ani_env *env, ani_variable variable, ani_int *result); + + /** + * @brief Retrieves a long value from a variable. + * + * This function fetches a long integer value from the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to query. + * @param[out] result A pointer to store the retrieved long integer value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_GetValue_Long)(ani_env *env, ani_variable variable, ani_long *result); + + /** + * @brief Retrieves a float value from a variable. + * + * This function fetches a float value from the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to query. + * @param[out] result A pointer to store the retrieved float value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_GetValue_Float)(ani_env *env, ani_variable variable, ani_float *result); + + /** + * @brief Retrieves a double value from a variable. + * + * This function fetches a double value from the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to query. + * @param[out] result A pointer to store the retrieved double value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_GetValue_Double)(ani_env *env, ani_variable variable, ani_double *result); + + /** + * @brief Retrieves a reference value from a variable. + * + * This function fetches a reference value from the specified variable. + * + * @param[in] env A pointer to the environment structure. + * @param[in] variable The variable to query. + * @param[out] result A pointer to store the retrieved reference value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Variable_GetValue_Ref)(ani_env *env, ani_variable variable, ani_ref *result); + + /** + * @brief Calls a function and retrieves a boolean result. + * + * This function calls the specified function with variadic arguments and retrieves a boolean result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the boolean result. + * @param[in] ... Variadic arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Boolean)(ani_env *env, ani_function fn, ani_boolean *result, ...); + + /** + * @brief Calls a function and retrieves a boolean result (array-based). + * + * This function calls the specified function with arguments provided in an array and retrieves a boolean result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the boolean result. + * @param[in] args A pointer to an array of arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Boolean_A)(ani_env *env, ani_function fn, ani_boolean *result, const ani_value *args); + + /** + * @brief Calls a function and retrieves a boolean result (variadic arguments). + * + * This function calls the specified function with arguments provided in a `va_list` and retrieves a boolean result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the boolean result. + * @param[in] args A `va_list` containing the arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Boolean_V)(ani_env *env, ani_function fn, ani_boolean *result, va_list args); + + /** + * @brief Calls a function and retrieves a character result. + * + * This function calls the specified function with variadic arguments and retrieves a character result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the character result. + * @param[in] ... Variadic arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Char)(ani_env *env, ani_function fn, ani_char *result, ...); + + /** + * @brief Calls a function and retrieves a character result (array-based). + * + * This function calls the specified function with arguments provided in an array and retrieves a character result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the character result. + * @param[in] args A pointer to an array of arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Char_A)(ani_env *env, ani_function fn, ani_char *result, const ani_value *args); + + /** + * @brief Calls a function and retrieves a character result (variadic arguments). + * + * This function calls the specified function with arguments provided in a `va_list` and retrieves a character + * result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the character result. + * @param[in] args A `va_list` containing the arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Char_V)(ani_env *env, ani_function fn, ani_char *result, va_list args); + + /** + * @brief Calls a function and retrieves a byte result. + * + * This function calls the specified function with variadic arguments and retrieves a byte result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the byte result. + * @param[in] ... Variadic arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Byte)(ani_env *env, ani_function fn, ani_byte *result, ...); + + /** + * @brief Calls a function and retrieves a byte result (array-based). + * + * This function calls the specified function with arguments provided in an array and retrieves a byte result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the byte result. + * @param[in] args A pointer to an array of arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Byte_A)(ani_env *env, ani_function fn, ani_byte *result, const ani_value *args); + + /** + * @brief Calls a function and retrieves a byte result (variadic arguments). + * + * This function calls the specified function with arguments provided in a `va_list` and retrieves a byte result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the byte result. + * @param[in] args A `va_list` containing the arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Byte_V)(ani_env *env, ani_function fn, ani_byte *result, va_list args); + + /** + * @brief Calls a function and retrieves a short result. + * + * This function calls the specified function with variadic arguments and retrieves a short result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the short result. + * @param[in] ... Variadic arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Short)(ani_env *env, ani_function fn, ani_short *result, ...); + + /** + * @brief Calls a function and retrieves a short result (array-based). + * + * This function calls the specified function with arguments provided in an array and retrieves a short result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the short result. + * @param[in] args A pointer to an array of arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Short_A)(ani_env *env, ani_function fn, ani_short *result, const ani_value *args); + + /** + * @brief Calls a function and retrieves a short result (variadic arguments). + * + * This function calls the specified function with arguments provided in a `va_list` and retrieves a short result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the short result. + * @param[in] args A `va_list` containing the arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Short_V)(ani_env *env, ani_function fn, ani_short *result, va_list args); + + /** + * @brief Calls a function and retrieves an integer result. + * + * This function calls the specified function with variadic arguments and retrieves an integer result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the integer result. + * @param[in] ... Variadic arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Int)(ani_env *env, ani_function fn, ani_int *result, ...); + + /** + * @brief Calls a function and retrieves an integer result (array-based). + * + * This function calls the specified function with arguments provided in an array and retrieves an integer result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the integer result. + * @param[in] args A pointer to an array of arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Int_A)(ani_env *env, ani_function fn, ani_int *result, const ani_value *args); + + /** + * @brief Calls a function and retrieves an integer result (variadic arguments). + * + * This function calls the specified function with arguments provided in a `va_list` and retrieves an integer + * result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the integer result. + * @param[in] args A `va_list` containing the arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Int_V)(ani_env *env, ani_function fn, ani_int *result, va_list args); + + /** + * @brief Calls a function and retrieves a long result. + * + * This function calls the specified function with variadic arguments and retrieves a long result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the long result. + * @param[in] ... Variadic arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Long)(ani_env *env, ani_function fn, ani_long *result, ...); + + /** + * @brief Calls a function and retrieves a long result (array-based). + * + * This function calls the specified function with arguments provided in an array and retrieves a long result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the long result. + * @param[in] args A pointer to an array of arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Long_A)(ani_env *env, ani_function fn, ani_long *result, const ani_value *args); + + /** + * @brief Calls a function and retrieves a long result (variadic arguments). + * + * This function calls the specified function with arguments provided in a `va_list` and retrieves a long result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the long result. + * @param[in] args A `va_list` containing the arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Long_V)(ani_env *env, ani_function fn, ani_long *result, va_list args); + + /** + * @brief Calls a function and retrieves a float result. + * + * This function calls the specified function with variadic arguments and retrieves a float result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the float result. + * @param[in] ... Variadic arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Float)(ani_env *env, ani_function fn, ani_float *result, ...); + + /** + * @brief Calls a function and retrieves a float result (array-based). + * + * This function calls the specified function with arguments provided in an array and retrieves a float result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the float result. + * @param[in] args A pointer to an array of arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Float_A)(ani_env *env, ani_function fn, ani_float *result, const ani_value *args); + + /** + * @brief Calls a function and retrieves a float result (variadic arguments). + * + * This function calls the specified function with arguments provided in a `va_list` and retrieves a float result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the float result. + * @param[in] args A `va_list` containing the arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Float_V)(ani_env *env, ani_function fn, ani_float *result, va_list args); + + /** + * @brief Calls a function and retrieves a double result. + * + * This function calls the specified function with variadic arguments and retrieves a double result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the double result. + * @param[in] ... Variadic arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Double)(ani_env *env, ani_function fn, ani_double *result, ...); + + /** + * @brief Calls a function and retrieves a double result (array-based). + * + * This function calls the specified function with arguments provided in an array and retrieves a double result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the double result. + * @param[in] args A pointer to an array of arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Double_A)(ani_env *env, ani_function fn, ani_double *result, const ani_value *args); + + /** + * @brief Calls a function and retrieves a double result (variadic arguments). + * + * This function calls the specified function with arguments provided in a `va_list` and retrieves a double result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the double result. + * @param[in] args A `va_list` containing the arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Double_V)(ani_env *env, ani_function fn, ani_double *result, va_list args); + + /** + * @brief Calls a function and retrieves a reference result. + * + * This function calls the specified function with variadic arguments and retrieves a reference result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the reference result. + * @param[in] ... Variadic arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Ref)(ani_env *env, ani_function fn, ani_ref *result, ...); + + /** + * @brief Calls a function and retrieves a reference result (array-based). + * + * This function calls the specified function with arguments provided in an array and retrieves a reference result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the reference result. + * @param[in] args A pointer to an array of arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Ref_A)(ani_env *env, ani_function fn, ani_ref *result, const ani_value *args); + + /** + * @brief Calls a function and retrieves a reference result (variadic arguments). + * + * This function calls the specified function with arguments provided in a `va_list` and retrieves a reference + * result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[out] result A pointer to store the reference result. + * @param[in] args A `va_list` containing the arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Ref_V)(ani_env *env, ani_function fn, ani_ref *result, va_list args); + + /** + * @brief Calls a function without returning a result. + * + * This function calls the specified function with variadic arguments and does not return a result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[in] ... Variadic arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Void)(ani_env *env, ani_function fn, ...); + + /** + * @brief Calls a function without returning a result (array-based). + * + * This function calls the specified function with arguments provided in an array and does not return a result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[in] args A pointer to an array of arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Void_A)(ani_env *env, ani_function fn, const ani_value *args); + + /** + * @brief Calls a function without returning a result (variadic arguments). + * + * This function calls the specified function with arguments provided in a `va_list` and does not return a result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] fn The function to call. + * @param[in] args A `va_list` containing the arguments to pass to the function. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Function_Call_Void_V)(ani_env *env, ani_function fn, va_list args); + + /** + * @brief Finds a field from by its name. + * + * This function locates a field based on its name and stores it in the result parameter. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class to query. + * @param[in] name The name of the field to find. + * @param[out] result A pointer to the field to be populated. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_FindField)(ani_env *env, ani_class cls, const char *name, ani_field *result); + + /** + * @brief Finds a static field by its name. + * + * This function locates a static field based on its name and stores it in the result parameter. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class to query. + * @param[in] name The name of the static field to find. + * @param[out] result A pointer to the static field to be populated. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_FindStaticField)(ani_env *env, ani_class cls, const char *name, ani_static_field *result); + + /** + * @brief Finds a method from by its name and signature. + * + * This function locates a method based on its name and signature and stores it in the result parameter. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class to query. + * @param[in] name The name of the method to find. + * @param[in] signature The signature of the method to find. + * @param[out] result A pointer to the method to be populated. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_FindMethod)(ani_env *env, ani_class cls, const char *name, const char *signature, + ani_method *result); + + /** + * @brief Finds a static method from by its name and signature. + * + * This function locates a static method based on its name and signature and stores it in the result parameter. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class to query. + * @param[in] name The name of the static method to find. + * @param[in] signature The signature of the static method to find. + * @param[out] result A pointer to the static method to be populated. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_FindStaticMethod)(ani_env *env, ani_class cls, const char *name, const char *signature, + ani_static_method *result); + + /** + * @brief Finds a setter method from by its name. + * + * This function locates a setter method based on its name and stores it in the result parameter. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class to query. + * @param[in] name The name of the property whose setter is to be found. + * @param[out] result A pointer to the method to be populated. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_FindSetter)(ani_env *env, ani_class cls, const char *name, ani_method *result); + + /** + * @brief Finds a getter method from by its name. + * + * This function locates a getter method based on its name and stores it in the result parameter. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class to query. + * @param[in] name The name of the property whose getter is to be found. + * @param[out] result A pointer to the method to be populated. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_FindGetter)(ani_env *env, ani_class cls, const char *name, ani_method *result); + + /** + * @brief Finds an indexable getter method from by its signature. + * + * This function locates an indexable getter method based on its signature and stores it in the result parameter. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class to query. + * @param[in] signature The signature of the indexable getter to find. + * @param[out] result A pointer to the method to be populated. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_FindIndexableGetter)(ani_env *env, ani_class cls, const char *signature, ani_method *result); + + /** + * @brief Finds an indexable setter method from by its signature. + * + * This function locates an indexable setter method based on its signature and stores it in the result parameter. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class to query. + * @param[in] signature The signature of the indexable setter to find. + * @param[out] result A pointer to the method to be populated. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_FindIndexableSetter)(ani_env *env, ani_class cls, const char *signature, ani_method *result); + + /** + * @brief Finds an iterator method. + * + * This function locates an iterator method + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class to query. + * @param[out] result A pointer to the method to be populated. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_FindIterator)(ani_env *env, ani_class cls, ani_method *result); + + /** + * @brief Retrieves a boolean value from a static field of a class. + * + * This function retrieves the boolean value of the specified static field from the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to retrieve. + * @param[out] result A pointer to store the retrieved boolean value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticField_Boolean)(ani_env *env, ani_class cls, ani_static_field field, + ani_boolean *result); + + /** + * @brief Retrieves a character value from a static field of a class. + * + * This function retrieves the character value of the specified static field from the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to retrieve. + * @param[out] result A pointer to store the retrieved character value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticField_Char)(ani_env *env, ani_class cls, ani_static_field field, ani_char *result); + + /** + * @brief Retrieves a byte value from a static field of a class. + * + * This function retrieves the byte value of the specified static field from the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to retrieve. + * @param[out] result A pointer to store the retrieved byte value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticField_Byte)(ani_env *env, ani_class cls, ani_static_field field, ani_byte *result); + + /** + * @brief Retrieves a short value from a static field of a class. + * + * This function retrieves the short value of the specified static field from the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to retrieve. + * @param[out] result A pointer to store the retrieved short value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticField_Short)(ani_env *env, ani_class cls, ani_static_field field, ani_short *result); + + /** + * @brief Retrieves an integer value from a static field of a class. + * + * This function retrieves the integer value of the specified static field from the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to retrieve. + * @param[out] result A pointer to store the retrieved integer value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticField_Int)(ani_env *env, ani_class cls, ani_static_field field, ani_int *result); + + /** + * @brief Retrieves a long value from a static field of a class. + * + * This function retrieves the long value of the specified static field from the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to retrieve. + * @param[out] result A pointer to store the retrieved long value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticField_Long)(ani_env *env, ani_class cls, ani_static_field field, ani_long *result); + + /** + * @brief Retrieves a float value from a static field of a class. + * + * This function retrieves the float value of the specified static field from the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to retrieve. + * @param[out] result A pointer to store the retrieved float value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticField_Float)(ani_env *env, ani_class cls, ani_static_field field, ani_float *result); + + /** + * @brief Retrieves a double value from a static field of a class. + * + * This function retrieves the double value of the specified static field from the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to retrieve. + * @param[out] result A pointer to store the retrieved double value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticField_Double)(ani_env *env, ani_class cls, ani_static_field field, ani_double *result); + + /** + * @brief Retrieves a reference value from a static field of a class. + * + * This function retrieves the reference value of the specified static field from the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to retrieve. + * @param[out] result A pointer to store the retrieved reference value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticField_Ref)(ani_env *env, ani_class cls, ani_static_field field, ani_ref *result); + + /** + * @brief Sets a boolean value to a static field of a class. + * + * This function assigns a boolean value to the specified static field of the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to modify. + * @param[in] value The boolean value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticField_Boolean)(ani_env *env, ani_class cls, ani_static_field field, ani_boolean value); + + /** + * @brief Sets a character value to a static field of a class. + * + * This function assigns a character value to the specified static field of the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to modify. + * @param[in] value The character value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticField_Char)(ani_env *env, ani_class cls, ani_static_field field, ani_char value); + + /** + * @brief Sets a byte value to a static field of a class. + * + * This function assigns a byte value to the specified static field of the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to modify. + * @param[in] value The byte value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticField_Byte)(ani_env *env, ani_class cls, ani_static_field field, ani_byte value); + + /** + * @brief Sets a short value to a static field of a class. + * + * This function assigns a short value to the specified static field of the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to modify. + * @param[in] value The short value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticField_Short)(ani_env *env, ani_class cls, ani_static_field field, ani_short value); + + /** + * @brief Sets an integer value to a static field of a class. + * + * This function assigns an integer value to the specified static field of the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to modify. + * @param[in] value The integer value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticField_Int)(ani_env *env, ani_class cls, ani_static_field field, ani_int value); + + /** + * @brief Sets a long value to a static field of a class. + * + * This function assigns a long value to the specified static field of the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to modify. + * @param[in] value The long value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticField_Long)(ani_env *env, ani_class cls, ani_static_field field, ani_long value); + + /** + * @brief Sets a float value to a static field of a class. + * + * This function assigns a float value to the specified static field of the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to modify. + * @param[in] value The float value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticField_Float)(ani_env *env, ani_class cls, ani_static_field field, ani_float value); + + /** + * @brief Sets a double value to a static field of a class. + * + * This function assigns a double value to the specified static field of the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to modify. + * @param[in] value The double value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticField_Double)(ani_env *env, ani_class cls, ani_static_field field, ani_double value); + + /** + * @brief Sets a reference value to a static field of a class. + * + * This function assigns a reference value to the specified static field of the given class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] field The static field to modify. + * @param[in] value The reference value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticField_Ref)(ani_env *env, ani_class cls, ani_static_field field, ani_ref value); + + /** + * @brief Retrieves a boolean value from a static field of a class by its name. + * + * This function retrieves the boolean value of the specified static field from the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to retrieve. + * @param[out] result A pointer to store the retrieved boolean value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticFieldByName_Boolean)(ani_env *env, ani_class cls, const char *name, + ani_boolean *result); + + /** + * @brief Retrieves a character value from a static field of a class by its name. + * + * This function retrieves the character value of the specified static field from the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to retrieve. + * @param[out] result A pointer to store the retrieved character value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticFieldByName_Char)(ani_env *env, ani_class cls, const char *name, ani_char *result); + + /** + * @brief Retrieves a byte value from a static field of a class by its name. + * + * This function retrieves the byte value of the specified static field from the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to retrieve. + * @param[out] result A pointer to store the retrieved byte value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticFieldByName_Byte)(ani_env *env, ani_class cls, const char *name, ani_byte *result); + + /** + * @brief Retrieves a short value from a static field of a class by its name. + * + * This function retrieves the short value of the specified static field from the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to retrieve. + * @param[out] result A pointer to store the retrieved short value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticFieldByName_Short)(ani_env *env, ani_class cls, const char *name, ani_short *result); + + /** + * @brief Retrieves an integer value from a static field of a class by its name. + * + * This function retrieves the integer value of the specified static field from the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to retrieve. + * @param[out] result A pointer to store the retrieved integer value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticFieldByName_Int)(ani_env *env, ani_class cls, const char *name, ani_int *result); + + /** + * @brief Retrieves a long value from a static field of a class by its name. + * + * This function retrieves the long value of the specified static field from the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to retrieve. + * @param[out] result A pointer to store the retrieved long value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticFieldByName_Long)(ani_env *env, ani_class cls, const char *name, ani_long *result); + + /** + * @brief Retrieves a float value from a static field of a class by its name. + * + * This function retrieves the float value of the specified static field from the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to retrieve. + * @param[out] result A pointer to store the retrieved float value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticFieldByName_Float)(ani_env *env, ani_class cls, const char *name, ani_float *result); + + /** + * @brief Retrieves a double value from a static field of a class by its name. + * + * This function retrieves the double value of the specified static field from the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to retrieve. + * @param[out] result A pointer to store the retrieved double value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticFieldByName_Double)(ani_env *env, ani_class cls, const char *name, ani_double *result); + + /** + * @brief Retrieves a reference value from a static field of a class by its name. + * + * This function retrieves the reference value of the specified static field from the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to retrieve. + * @param[out] result A pointer to store the retrieved reference value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_GetStaticFieldByName_Ref)(ani_env *env, ani_class cls, const char *name, ani_ref *result); + + /** + * @brief Sets a boolean value to a static field of a class by its name. + * + * This function assigns a boolean value to the specified static field of the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to modify. + * @param[in] value The boolean value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticFieldByName_Boolean)(ani_env *env, ani_class cls, const char *name, ani_boolean value); + + /** + * @brief Sets a character value to a static field of a class by its name. + * + * This function assigns a character value to the specified static field of the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to modify. + * @param[in] value The character value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticFieldByName_Char)(ani_env *env, ani_class cls, const char *name, ani_char value); + + /** + * @brief Sets a byte value to a static field of a class by its name. + * + * This function assigns a byte value to the specified static field of the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to modify. + * @param[in] value The byte value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticFieldByName_Byte)(ani_env *env, ani_class cls, const char *name, ani_byte value); + + /** + * @brief Sets a short value to a static field of a class by its name. + * + * This function assigns a short value to the specified static field of the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to modify. + * @param[in] value The short value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticFieldByName_Short)(ani_env *env, ani_class cls, const char *name, ani_short value); + + /** + * @brief Sets an integer value to a static field of a class by its name. + * + * This function assigns an integer value to the specified static field of the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to modify. + * @param[in] value The integer value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticFieldByName_Int)(ani_env *env, ani_class cls, const char *name, ani_int value); + + /** + * @brief Sets a long value to a static field of a class by its name. + * + * This function assigns a long value to the specified static field of the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to modify. + * @param[in] value The long value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticFieldByName_Long)(ani_env *env, ani_class cls, const char *name, ani_long value); + + /** + * @brief Sets a float value to a static field of a class by its name. + * + * This function assigns a float value to the specified static field of the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to modify. + * @param[in] value The float value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticFieldByName_Float)(ani_env *env, ani_class cls, const char *name, ani_float value); + + /** + * @brief Sets a double value to a static field of a class by its name. + * + * This function assigns a double value to the specified static field of the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to modify. + * @param[in] value The double value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticFieldByName_Double)(ani_env *env, ani_class cls, const char *name, ani_double value); + + /** + * @brief Sets a reference value to a static field of a class by its name. + * + * This function assigns a reference value to the specified static field of the given class by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static field. + * @param[in] name The name of the static field to modify. + * @param[in] value The reference value to assign. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_SetStaticFieldByName_Ref)(ani_env *env, ani_class cls, const char *name, ani_ref value); + + /** + * @brief Calls a static method with a boolean return type. + * + * This function calls the specified static method of a class and retrieves a boolean result using variadic + * arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the boolean result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Boolean)(ani_env *env, ani_class cls, ani_static_method method, + ani_boolean *result, ...); + + /** + * @brief Calls a static method with a boolean return type (array-based). + * + * This function calls the specified static method of a class and retrieves a boolean result using arguments from an + * array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the boolean result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Boolean_A)(ani_env *env, ani_class cls, ani_static_method method, + ani_boolean *result, const ani_value *args); + + /** + * @brief Calls a static method with a boolean return type (variadic arguments). + * + * This function calls the specified static method of a class and retrieves a boolean result using a `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the boolean result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Boolean_V)(ani_env *env, ani_class cls, ani_static_method method, + ani_boolean *result, va_list args); + + /** + * @brief Calls a static method with a character return type. + * + * This function calls the specified static method of a class and retrieves a character result using variadic + * arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the character result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Char)(ani_env *env, ani_class cls, ani_static_method method, ani_char *result, + ...); + + /** + * @brief Calls a static method with a character return type (array-based). + * + * This function calls the specified static method of a class and retrieves a character result using arguments from + * an array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the character result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Char_A)(ani_env *env, ani_class cls, ani_static_method method, ani_char *result, + const ani_value *args); + + /** + * @brief Calls a static method with a character return type (variadic arguments). + * + * This function calls the specified static method of a class and retrieves a character result using a `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the character result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Char_V)(ani_env *env, ani_class cls, ani_static_method method, ani_char *result, + va_list args); + + /** + * @brief Calls a static method with a byte return type. + * + * This function calls the specified static method of a class and retrieves a byte result using variadic arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the byte result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Byte)(ani_env *env, ani_class cls, ani_static_method method, ani_byte *result, + ...); + + /** + * @brief Calls a static method with a byte return type (array-based). + * + * This function calls the specified static method of a class and retrieves a byte result using arguments from an + * array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the byte result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Byte_A)(ani_env *env, ani_class cls, ani_static_method method, ani_byte *result, + const ani_value *args); + + /** + * @brief Calls a static method with a byte return type (variadic arguments). + * + * This function calls the specified static method of a class and retrieves a byte result using a `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the byte result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Byte_V)(ani_env *env, ani_class cls, ani_static_method method, ani_byte *result, + va_list args); + + /** + * @brief Calls a static method with a short return type. + * + * This function calls the specified static method of a class and retrieves a short result using variadic arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the short result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Short)(ani_env *env, ani_class cls, ani_static_method method, ani_short *result, + ...); + + /** + * @brief Calls a static method with a short return type (array-based). + * + * This function calls the specified static method of a class and retrieves a short result using arguments from an + * array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the short result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Short_A)(ani_env *env, ani_class cls, ani_static_method method, + ani_short *result, const ani_value *args); + + /** + * @brief Calls a static method with a short return type (variadic arguments). + * + * This function calls the specified static method of a class and retrieves a short result using a `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the short result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Short_V)(ani_env *env, ani_class cls, ani_static_method method, + ani_short *result, va_list args); + + /** + * @brief Calls a static method with an integer return type. + * + * This function calls the specified static method of a class and retrieves an integer result using variadic + * arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the integer result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Int)(ani_env *env, ani_class cls, ani_static_method method, ani_int *result, + ...); + + /** + * @brief Calls a static method with an integer return type (array-based). + * + * This function calls the specified static method of a class and retrieves an integer result using arguments from + * an array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the integer result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Int_A)(ani_env *env, ani_class cls, ani_static_method method, ani_int *result, + const ani_value *args); + + /** + * @brief Calls a static method with an integer return type (variadic arguments). + * + * This function calls the specified static method of a class and retrieves an integer result using a `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the integer result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Int_V)(ani_env *env, ani_class cls, ani_static_method method, ani_int *result, + va_list args); + + /** + * @brief Calls a static method with a long return type. + * + * This function calls the specified static method of a class and retrieves a long result using variadic arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the long result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Long)(ani_env *env, ani_class cls, ani_static_method method, ani_long *result, + ...); + + /** + * @brief Calls a static method with a long return type (array-based). + * + * This function calls the specified static method of a class and retrieves a long result using arguments from an + * array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the long result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Long_A)(ani_env *env, ani_class cls, ani_static_method method, ani_long *result, + const ani_value *args); + + /** + * @brief Calls a static method with a long return type (variadic arguments). + * + * This function calls the specified static method of a class and retrieves a long result using a `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the long result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Long_V)(ani_env *env, ani_class cls, ani_static_method method, ani_long *result, + va_list args); + + /** + * @brief Calls a static method with a float return type. + * + * This function calls the specified static method of a class and retrieves a float result using variadic arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the float result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Float)(ani_env *env, ani_class cls, ani_static_method method, ani_float *result, + ...); + + /** + * @brief Calls a static method with a float return type (array-based). + * + * This function calls the specified static method of a class and retrieves a float result using arguments from an + * array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the float result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Float_A)(ani_env *env, ani_class cls, ani_static_method method, + ani_float *result, const ani_value *args); + + /** + * @brief Calls a static method with a float return type (variadic arguments). + * + * This function calls the specified static method of a class and retrieves a float result using a `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the float result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Float_V)(ani_env *env, ani_class cls, ani_static_method method, + ani_float *result, va_list args); + + /** + * @brief Calls a static method with a double return type. + * + * This function calls the specified static method of a class and retrieves a double result using variadic + * arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the double result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Double)(ani_env *env, ani_class cls, ani_static_method method, + ani_double *result, ...); + + /** + * @brief Calls a static method with a double return type (array-based). + * + * This function calls the specified static method of a class and retrieves a double result using arguments from an + * array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the double result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Double_A)(ani_env *env, ani_class cls, ani_static_method method, + ani_double *result, const ani_value *args); + + /** + * @brief Calls a static method with a double return type (variadic arguments). + * + * This function calls the specified static method of a class and retrieves a double result using a `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the double result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Double_V)(ani_env *env, ani_class cls, ani_static_method method, + ani_double *result, va_list args); + + /** + * @brief Calls a static method with a reference return type. + * + * This function calls the specified static method of a class and retrieves a reference result using variadic + * arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the reference result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Ref)(ani_env *env, ani_class cls, ani_static_method method, ani_ref *result, + ...); + + /** + * @brief Calls a static method with a reference return type (array-based). + * + * This function calls the specified static method of a class and retrieves a reference result using arguments from + * an array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the reference result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Ref_A)(ani_env *env, ani_class cls, ani_static_method method, ani_ref *result, + const ani_value *args); + + /** + * @brief Calls a static method with a reference return type (variadic arguments). + * + * This function calls the specified static method of a class and retrieves a reference result using a `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[out] result A pointer to store the reference result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Ref_V)(ani_env *env, ani_class cls, ani_static_method method, ani_ref *result, + va_list args); + + /** + * @brief Calls a static method with no return value. + * + * This function calls the specified static method of a class using variadic arguments. The method does not return a + * value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Void)(ani_env *env, ani_class cls, ani_static_method method, ...); + + /** + * @brief Calls a static method with no return value (array-based). + * + * This function calls the specified static method of a class using arguments from an array. The method does not + * return a value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Void_A)(ani_env *env, ani_class cls, ani_static_method method, + const ani_value *args); + + /** + * @brief Calls a static method with no return value (variadic arguments). + * + * This function calls the specified static method of a class using a `va_list`. The method does not return a value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] method The static method to call. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethod_Void_V)(ani_env *env, ani_class cls, ani_static_method method, va_list args); + + /** + * @brief Calls a static method by name with a boolean return type. + * + * This function calls the specified static method of a class by its name and retrieves a boolean result using + * variadic arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the boolean result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Boolean)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_boolean *result, ...); + + /** + * @brief Calls a static method by name with a boolean return type (array-based). + * + * This function calls the specified static method of a class by its name and retrieves a boolean result using + * arguments from an array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the boolean result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Boolean_A)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_boolean *result, + const ani_value *args); + + /** + * @brief Calls a static method by name with a boolean return type (variadic arguments). + * + * This function calls the specified static method of a class by its name and retrieves a boolean result using a + * `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the boolean result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Boolean_V)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_boolean *result, va_list args); + + /** + * @brief Calls a static method by name with a char return type. + * + * This function calls the specified static method of a class by its name and retrieves a char result using variadic + * arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the char result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Char)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_char *result, ...); + + /** + * @brief Calls a static method by name with a char return type (array-based). + * + * This function calls the specified static method of a class by its name and retrieves a char result using + * arguments from an array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the char result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Char_A)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_char *result, const ani_value *args); + + /** + * @brief Calls a static method by name with a char return type (variadic arguments). + * + * This function calls the specified static method of a class by its name and retrieves a char result using a + * `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the char result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Char_V)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_char *result, va_list args); + + /** + * @brief Calls a static method by name with a byte return type. + * + * This function calls the specified static method of a class by its name and retrieves a byte result using variadic + * arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the byte result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Byte)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_byte *result, ...); + + /** + * @brief Calls a static method by name with a byte return type (array-based). + * + * This function calls the specified static method of a class by its name and retrieves a byte result using + * arguments from an array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the byte result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Byte_A)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_byte *result, const ani_value *args); + + /** + * @brief Calls a static method by name with a byte return type (variadic arguments). + * + * This function calls the specified static method of a class by its name and retrieves a byte result using a + * `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the byte result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Byte_V)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_byte *result, va_list args); + + /** + * @brief Calls a static method by name with a short return type. + * + * This function calls the specified static method of a class by its name and retrieves a short result using + * variadic arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the short result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Short)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_short *result, ...); + + /** + * @brief Calls a static method by name with a short return type (array-based). + * + * This function calls the specified static method of a class by its name and retrieves a short result using + * arguments from an array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the short result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Short_A)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_short *result, const ani_value *args); + + /** + * @brief Calls a static method by name with a short return type (variadic arguments). + * + * This function calls the specified static method of a class by its name and retrieves a short result using a + * `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the short result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Short_V)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_short *result, va_list args); + + /** + * @brief Calls a static method by name with a integer return type. + * + * This function calls the specified static method of a class by its name and retrieves a integer result using + * variadic arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the integer result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Int)(ani_env *env, ani_class cls, const char *name, const char *signature, + ani_int *result, ...); + + /** + * @brief Calls a static method by name with a integer return type (array-based). + * + * This function calls the specified static method of a class by its name and retrieves a integer result using + * arguments from an array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the integer result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Int_A)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_int *result, const ani_value *args); + + /** + * @brief Calls a static method by name with a integer return type (variadic arguments). + * + * This function calls the specified static method of a class by its name and retrieves a integer result using a + * `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the integer result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Int_V)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_int *result, va_list args); + + /** + * @brief Calls a static method by name with a long return type. + * + * This function calls the specified static method of a class by its name and retrieves a long result using variadic + * arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the long result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Long)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_long *result, ...); + + /** + * @brief Calls a static method by name with a long return type (array-based). + * + * This function calls the specified static method of a class by its name and retrieves a long result using + * arguments from an array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the long result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Long_A)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_long *result, const ani_value *args); + + /** + * @brief Calls a static method by name with a long return type (variadic arguments). + * + * This function calls the specified static method of a class by its name and retrieves a long result using a + * `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the long result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Long_V)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_long *result, va_list args); + + /** + * @brief Calls a static method by name with a float return type. + * + * This function calls the specified static method of a class by its name and retrieves a float result using + * variadic arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the float result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Float)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_float *result, ...); + + /** + * @brief Calls a static method by name with a float return type (array-based). + * + * This function calls the specified static method of a class by its name and retrieves a float result using + * arguments from an array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the float result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Float_A)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_float *result, const ani_value *args); + + /** + * @brief Calls a static method by name with a float return type (variadic arguments). + * + * This function calls the specified static method of a class by its name and retrieves a float result using a + * `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the float result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Float_V)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_float *result, va_list args); + + /** + * @brief Calls a static method by name with a double return type. + * + * This function calls the specified static method of a class by its name and retrieves a double result using + * variadic arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the double result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Double)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_double *result, ...); + + /** + * @brief Calls a static method by name with a double return type (array-based). + * + * This function calls the specified static method of a class by its name and retrieves a double result using + * arguments from an array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the double result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Double_A)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_double *result, + const ani_value *args); + + /** + * @brief Calls a static method by name with a double return type (variadic arguments). + * + * This function calls the specified static method of a class by its name and retrieves a double result using a + * `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the double result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Double_V)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_double *result, va_list args); + + /** + * @brief Calls a static method by name with a reference return type. + * + * This function calls the specified static method of a class by its name and retrieves a reference result using + * variadic arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the reference result. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Ref)(ani_env *env, ani_class cls, const char *name, const char *signature, + ani_ref *result, ...); + + /** + * @brief Calls a static method by name with a reference return type (array-based). + * + * This function calls the specified static method of a class by its name and retrieves a reference result using + * arguments from an array. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the reference result. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Ref_A)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_ref *result, const ani_value *args); + + /** + * @brief Calls a static method by name with a reference return type (variadic arguments). + * + * This function calls the specified static method of a class by its name and retrieves a reference result using a + * `va_list`. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[out] result A pointer to store the reference result. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Ref_V)(ani_env *env, ani_class cls, const char *name, + const char *signature, ani_ref *result, va_list args); + + /** + * @brief Calls a static method by name with no return value. + * + * This function calls the specified static method of a class by its name using variadic arguments. The method does + * not return a value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Void)(ani_env *env, ani_class cls, const char *name, + const char *signature, ...); + + /** + * @brief Calls a static method by name with no return value (array-based). + * + * This function calls the specified static method of a class by its name using arguments from an array. The method + * does not return a value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Void_A)(ani_env *env, ani_class cls, const char *name, + const char *signature, const ani_value *args); + + /** + * @brief Calls a static method by name with no return value (variadic arguments). + * + * This function calls the specified static method of a class by its name using a `va_list`. The method does not + * return a value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class containing the static method. + * @param[in] name The name of the static method to call. + * @param[in] signature The signature of the static method to call. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_CallStaticMethodByName_Void_V)(ani_env *env, ani_class cls, const char *name, + const char *signature, va_list args); + + /** + * @brief Retrieves a boolean value from a field of an object. + * + * This function retrieves the boolean value of the specified field from the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to retrieve the boolean value from. + * @param[out] result A pointer to store the retrieved boolean value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetField_Boolean)(ani_env *env, ani_object object, ani_field field, ani_boolean *result); + + /** + * @brief Retrieves a char value from a field of an object. + * + * This function retrieves the char value of the specified field from the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to retrieve the char value from. + * @param[out] result A pointer to store the retrieved char value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetField_Char)(ani_env *env, ani_object object, ani_field field, ani_char *result); + + /** + * @brief Retrieves a byte value from a field of an object. + * + * This function retrieves the byte value of the specified field from the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to retrieve the byte value from. + * @param[out] result A pointer to store the retrieved byte value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetField_Byte)(ani_env *env, ani_object object, ani_field field, ani_byte *result); + + /** + * @brief Retrieves a short value from a field of an object. + * + * This function retrieves the short value of the specified field from the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to retrieve the short value from. + * @param[out] result A pointer to store the retrieved short value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetField_Short)(ani_env *env, ani_object object, ani_field field, ani_short *result); + + /** + * @brief Retrieves a integer value from a field of an object. + * + * This function retrieves the integer value of the specified field from the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to retrieve the integer value from. + * @param[out] result A pointer to store the retrieved integer value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetField_Int)(ani_env *env, ani_object object, ani_field field, ani_int *result); + + /** + * @brief Retrieves a long value from a field of an object. + * + * This function retrieves the long value of the specified field from the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to retrieve the long value from. + * @param[out] result A pointer to store the retrieved long value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetField_Long)(ani_env *env, ani_object object, ani_field field, ani_long *result); + + /** + * @brief Retrieves a float value from a field of an object. + * + * This function retrieves the float value of the specified field from the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to retrieve the float value from. + * @param[out] result A pointer to store the retrieved float value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetField_Float)(ani_env *env, ani_object object, ani_field field, ani_float *result); + + /** + * @brief Retrieves a double value from a field of an object. + * + * This function retrieves the double value of the specified field from the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to retrieve the double value from. + * @param[out] result A pointer to store the retrieved double value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetField_Double)(ani_env *env, ani_object object, ani_field field, ani_double *result); + + /** + * @brief Retrieves a reference value from a field of an object. + * + * This function retrieves the reference value of the specified field from the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to retrieve the reference value from. + * @param[out] result A pointer to store the retrieved reference value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetField_Ref)(ani_env *env, ani_object object, ani_field field, ani_ref *result); + + /** + * @brief Sets a boolean value to a field of an object. + * + * This function assigns a boolean value to the specified field of the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to set the boolean value to. + * @param[in] value The boolean value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetField_Boolean)(ani_env *env, ani_object object, ani_field field, ani_boolean value); + + /** + * @brief Sets a char value to a field of an object. + * + * This function assigns a char value to the specified field of the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to set the char value to. + * @param[in] value The char value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetField_Char)(ani_env *env, ani_object object, ani_field field, ani_char value); + + /** + * @brief Sets a byte value to a field of an object. + * + * This function assigns a byte value to the specified field of the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to set the byte value to. + * @param[in] value The byte value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetField_Byte)(ani_env *env, ani_object object, ani_field field, ani_byte value); + + /** + * @brief Sets a short value to a field of an object. + * + * This function assigns a short value to the specified field of the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to set the short value to. + * @param[in] value The short value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetField_Short)(ani_env *env, ani_object object, ani_field field, ani_short value); + + /** + * @brief Sets a integer value to a field of an object. + * + * This function assigns a integer value to the specified field of the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to set the integer value to. + * @param[in] value The integer value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetField_Int)(ani_env *env, ani_object object, ani_field field, ani_int value); + + /** + * @brief Sets a long value to a field of an object. + * + * This function assigns a long value to the specified field of the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to set the long value to. + * @param[in] value The long value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetField_Long)(ani_env *env, ani_object object, ani_field field, ani_long value); + + /** + * @brief Sets a float value to a field of an object. + * + * This function assigns a float value to the specified field of the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to set the float value to. + * @param[in] value The float value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetField_Float)(ani_env *env, ani_object object, ani_field field, ani_float value); + + /** + * @brief Sets a double value to a field of an object. + * + * This function assigns a double value to the specified field of the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to set the double value to. + * @param[in] value The double value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetField_Double)(ani_env *env, ani_object object, ani_field field, ani_double value); + + /** + * @brief Sets a reference value to a field of an object. + * + * This function assigns a reference value to the specified field of the given object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] field The field to set the reference value to. + * @param[in] value The reference value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetField_Ref)(ani_env *env, ani_object object, ani_field field, ani_ref value); + + /** + * @brief Retrieves a boolean value from a field of an object by its name. + * + * This function retrieves the boolean value of the specified field from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to retrieve the boolean value from. + * @param[out] result A pointer to store the retrieved boolean value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetFieldByName_Boolean)(ani_env *env, ani_object object, const char *name, ani_boolean *result); + + /** + * @brief Retrieves a char value from a field of an object by its name. + * + * This function retrieves the char value of the specified field from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to retrieve the char value from. + * @param[out] result A pointer to store the retrieved char value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetFieldByName_Char)(ani_env *env, ani_object object, const char *name, ani_char *result); + + /** + * @brief Retrieves a byte value from a field of an object by its name. + * + * This function retrieves the byte value of the specified field from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to retrieve the byte value from. + * @param[out] result A pointer to store the retrieved byte value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetFieldByName_Byte)(ani_env *env, ani_object object, const char *name, ani_byte *result); + + /** + * @brief Retrieves a short value from a field of an object by its name. + * + * This function retrieves the short value of the specified field from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to retrieve the short value from. + * @param[out] result A pointer to store the retrieved short value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetFieldByName_Short)(ani_env *env, ani_object object, const char *name, ani_short *result); + + /** + * @brief Retrieves a integer value from a field of an object by its name. + * + * This function retrieves the integer value of the specified field from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to retrieve the integer value from. + * @param[out] result A pointer to store the retrieved integer value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetFieldByName_Int)(ani_env *env, ani_object object, const char *name, ani_int *result); + + /** + * @brief Retrieves a long value from a field of an object by its name. + * + * This function retrieves the long value of the specified field from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to retrieve the long value from. + * @param[out] result A pointer to store the retrieved long value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetFieldByName_Long)(ani_env *env, ani_object object, const char *name, ani_long *result); + + /** + * @brief Retrieves a float value from a field of an object by its name. + * + * This function retrieves the float value of the specified field from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to retrieve the float value from. + * @param[out] result A pointer to store the retrieved float value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetFieldByName_Float)(ani_env *env, ani_object object, const char *name, ani_float *result); + + /** + * @brief Retrieves a double value from a field of an object by its name. + * + * This function retrieves the double value of the specified field from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to retrieve the double value from. + * @param[out] result A pointer to store the retrieved double value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetFieldByName_Double)(ani_env *env, ani_object object, const char *name, ani_double *result); + + /** + * @brief Retrieves a reference value from a field of an object by its name. + * + * This function retrieves the reference value of the specified field from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to retrieve the reference value from. + * @param[out] result A pointer to store the retrieved reference value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetFieldByName_Ref)(ani_env *env, ani_object object, const char *name, ani_ref *result); + + /** + * @brief Sets a boolean value to a field of an object by its name. + * + * This function assigns a boolean value to the specified field of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to set the boolean value to. + * @param[in] value The boolean value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetFieldByName_Boolean)(ani_env *env, ani_object object, const char *name, ani_boolean value); + + /** + * @brief Sets a char value to a field of an object by its name. + * + * This function assigns a char value to the specified field of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to set the char value to. + * @param[in] value The char value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetFieldByName_Char)(ani_env *env, ani_object object, const char *name, ani_char value); + + /** + * @brief Sets a byte value to a field of an object by its name. + * + * This function assigns a byte value to the specified field of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to set the byte value to. + * @param[in] value The byte value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetFieldByName_Byte)(ani_env *env, ani_object object, const char *name, ani_byte value); + + /** + * @brief Sets a short value to a field of an object by its name. + * + * This function assigns a short value to the specified field of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to set the short value to. + * @param[in] value The short value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetFieldByName_Short)(ani_env *env, ani_object object, const char *name, ani_short value); + + /** + * @brief Sets a integer value to a field of an object by its name. + * + * This function assigns a integer value to the specified field of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to set the integer value to. + * @param[in] value The integer value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetFieldByName_Int)(ani_env *env, ani_object object, const char *name, ani_int value); + + /** + * @brief Sets a long value to a field of an object by its name. + * + * This function assigns a long value to the specified field of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to set the long value to. + * @param[in] value The long value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetFieldByName_Long)(ani_env *env, ani_object object, const char *name, ani_long value); + + /** + * @brief Sets a float value to a field of an object by its name. + * + * This function assigns a float value to the specified field of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to set the float value to. + * @param[in] value The float value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetFieldByName_Float)(ani_env *env, ani_object object, const char *name, ani_float value); + + /** + * @brief Sets a double value to a field of an object by its name. + * + * This function assigns a double value to the specified field of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to set the double value to. + * @param[in] value The double value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetFieldByName_Double)(ani_env *env, ani_object object, const char *name, ani_double value); + + /** + * @brief Sets a reference value to a field of an object by its name. + * + * This function assigns a reference value to the specified field of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the field. + * @param[in] name The name of the field to set the reference value to. + * @param[in] value The reference value to assign to the field. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetFieldByName_Ref)(ani_env *env, ani_object object, const char *name, ani_ref value); + + /** + * @brief Retrieves a boolean value from a property of an object by its name. + * + * This function retrieves the boolean value of the specified property from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to retrieve the boolean value from. + * @param[out] result A pointer to store the retrieved boolean value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetPropertyByName_Boolean)(ani_env *env, ani_object object, const char *name, + ani_boolean *result); + + /** + * @brief Retrieves a char value from a property of an object by its name. + * + * This function retrieves the char value of the specified property from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to retrieve the char value from. + * @param[out] result A pointer to store the retrieved char value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetPropertyByName_Char)(ani_env *env, ani_object object, const char *name, ani_char *result); + + /** + * @brief Retrieves a byte value from a property of an object by its name. + * + * This function retrieves the byte value of the specified property from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to retrieve the byte value from. + * @param[out] result A pointer to store the retrieved byte value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetPropertyByName_Byte)(ani_env *env, ani_object object, const char *name, ani_byte *result); + + /** + * @brief Retrieves a short value from a property of an object by its name. + * + * This function retrieves the short value of the specified property from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to retrieve the short value from. + * @param[out] result A pointer to store the retrieved short value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetPropertyByName_Short)(ani_env *env, ani_object object, const char *name, ani_short *result); + + /** + * @brief Retrieves a integer value from a property of an object by its name. + * + * This function retrieves the integer value of the specified property from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to retrieve the integer value from. + * @param[out] result A pointer to store the retrieved integer value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetPropertyByName_Int)(ani_env *env, ani_object object, const char *name, ani_int *result); + + /** + * @brief Retrieves a long value from a property of an object by its name. + * + * This function retrieves the long value of the specified property from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to retrieve the long value from. + * @param[out] result A pointer to store the retrieved long value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetPropertyByName_Long)(ani_env *env, ani_object object, const char *name, ani_long *result); + + /** + * @brief Retrieves a float value from a property of an object by its name. + * + * This function retrieves the float value of the specified property from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to retrieve the float value from. + * @param[out] result A pointer to store the retrieved float value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetPropertyByName_Float)(ani_env *env, ani_object object, const char *name, ani_float *result); + + /** + * @brief Retrieves a double value from a property of an object by its name. + * + * This function retrieves the double value of the specified property from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to retrieve the double value from. + * @param[out] result A pointer to store the retrieved double value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetPropertyByName_Double)(ani_env *env, ani_object object, const char *name, + ani_double *result); + + /** + * @brief Retrieves a reference value from a property of an object by its name. + * + * This function retrieves the reference value of the specified property from the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to retrieve the reference value from. + * @param[out] result A pointer to store the retrieved reference value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_GetPropertyByName_Ref)(ani_env *env, ani_object object, const char *name, ani_ref *result); + + /** + * @brief Sets a boolean value to a property of an object by its name. + * + * This function assigns a boolean value to the specified property of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to set the boolean value to. + * @param[in] value The boolean value to assign to the property. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetPropertyByName_Boolean)(ani_env *env, ani_object object, const char *name, + ani_boolean value); + + /** + * @brief Sets a char value to a property of an object by its name. + * + * This function assigns a char value to the specified property of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to set the char value to. + * @param[in] value The char value to assign to the property. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetPropertyByName_Char)(ani_env *env, ani_object object, const char *name, ani_char value); + + /** + * @brief Sets a byte value to a property of an object by its name. + * + * This function assigns a byte value to the specified property of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to set the byte value to. + * @param[in] value The byte value to assign to the property. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetPropertyByName_Byte)(ani_env *env, ani_object object, const char *name, ani_byte value); + + /** + * @brief Sets a short value to a property of an object by its name. + * + * This function assigns a short value to the specified property of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to set the short value to. + * @param[in] value The short value to assign to the property. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetPropertyByName_Short)(ani_env *env, ani_object object, const char *name, ani_short value); + + /** + * @brief Sets a integer value to a property of an object by its name. + * + * This function assigns a integer value to the specified property of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to set the integer value to. + * @param[in] value The integer value to assign to the property. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetPropertyByName_Int)(ani_env *env, ani_object object, const char *name, ani_int value); + + /** + * @brief Sets a long value to a property of an object by its name. + * + * This function assigns a long value to the specified property of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to set the long value to. + * @param[in] value The long value to assign to the property. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetPropertyByName_Long)(ani_env *env, ani_object object, const char *name, ani_long value); + + /** + * @brief Sets a float value to a property of an object by its name. + * + * This function assigns a float value to the specified property of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to set the float value to. + * @param[in] value The float value to assign to the property. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetPropertyByName_Float)(ani_env *env, ani_object object, const char *name, ani_float value); + + /** + * @brief Sets a double value to a property of an object by its name. + * + * This function assigns a double value to the specified property of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to set the double value to. + * @param[in] value The double value to assign to the property. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetPropertyByName_Double)(ani_env *env, ani_object object, const char *name, ani_double value); + + /** + * @brief Sets a reference value to a property of an object by its name. + * + * This function assigns a reference value to the specified property of the given object by its name. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object containing the property. + * @param[in] name The name of the property to set the reference value to. + * @param[in] value The reference value to assign to the property. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_SetPropertyByName_Ref)(ani_env *env, ani_object object, const char *name, ani_ref value); + + /** + * @brief Calls a method on an object and retrieves a boolean return value. + * + * This function calls the specified method of an object using variadic arguments and retrieves a boolean result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the boolean return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Boolean)(ani_env *env, ani_object object, ani_method method, ani_boolean *result, + ...); + + /** + * @brief Calls a method on an object and retrieves a boolean return value (array-based). + * + * This function calls the specified method of an object using arguments provided in an array and retrieves a + * boolean result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the boolean return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Boolean_A)(ani_env *env, ani_object object, ani_method method, ani_boolean *result, + const ani_value *args); + + /** + * @brief Calls a method on an object and retrieves a boolean return value (variadic arguments). + * + * This function calls the specified method of an object using a `va_list` and retrieves a boolean result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the boolean return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Boolean_V)(ani_env *env, ani_object object, ani_method method, ani_boolean *result, + va_list args); + + /** + * @brief Calls a method on an object and retrieves a char return value. + * + * This function calls the specified method of an object using variadic arguments and retrieves a char result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the char return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Char)(ani_env *env, ani_object object, ani_method method, ani_char *result, ...); + + /** + * @brief Calls a method on an object and retrieves a char return value (array-based). + * + * This function calls the specified method of an object using arguments provided in an array and retrieves a char + * result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the char return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Char_A)(ani_env *env, ani_object object, ani_method method, ani_char *result, + const ani_value *args); + + /** + * @brief Calls a method on an object and retrieves a char return value (variadic arguments). + * + * This function calls the specified method of an object using a `va_list` and retrieves a char result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the char return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Char_V)(ani_env *env, ani_object object, ani_method method, ani_char *result, + va_list args); + + /** + * @brief Calls a method on an object and retrieves a byte return value. + * + * This function calls the specified method of an object using variadic arguments and retrieves a byte result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the byte return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Byte)(ani_env *env, ani_object object, ani_method method, ani_byte *result, ...); + + /** + * @brief Calls a method on an object and retrieves a byte return value (array-based). + * + * This function calls the specified method of an object using arguments provided in an array and retrieves a byte + * result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the byte return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Byte_A)(ani_env *env, ani_object object, ani_method method, ani_byte *result, + const ani_value *args); + + /** + * @brief Calls a method on an object and retrieves a byte return value (variadic arguments). + * + * This function calls the specified method of an object using a `va_list` and retrieves a byte result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the byte return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Byte_V)(ani_env *env, ani_object object, ani_method method, ani_byte *result, + va_list args); + + /** + * @brief Calls a method on an object and retrieves a short return value. + * + * This function calls the specified method of an object using variadic arguments and retrieves a short result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the short return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Short)(ani_env *env, ani_object object, ani_method method, ani_short *result, ...); + + /** + * @brief Calls a method on an object and retrieves a short return value (array-based). + * + * This function calls the specified method of an object using arguments provided in an array and retrieves a short + * result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the short return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Short_A)(ani_env *env, ani_object object, ani_method method, ani_short *result, + const ani_value *args); + + /** + * @brief Calls a method on an object and retrieves a short return value (variadic arguments). + * + * This function calls the specified method of an object using a `va_list` and retrieves a short result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the short return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Short_V)(ani_env *env, ani_object object, ani_method method, ani_short *result, + va_list args); + + /** + * @brief Calls a method on an object and retrieves a integer return value. + * + * This function calls the specified method of an object using variadic arguments and retrieves a integer result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the integer return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Int)(ani_env *env, ani_object object, ani_method method, ani_int *result, ...); + + /** + * @brief Calls a method on an object and retrieves a integer return value (array-based). + * + * This function calls the specified method of an object using arguments provided in an array and retrieves a + * integer result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the integer return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Int_A)(ani_env *env, ani_object object, ani_method method, ani_int *result, + const ani_value *args); + + /** + * @brief Calls a method on an object and retrieves a integer return value (variadic arguments). + * + * This function calls the specified method of an object using a `va_list` and retrieves a integer result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the integer return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Int_V)(ani_env *env, ani_object object, ani_method method, ani_int *result, + va_list args); + + /** + * @brief Calls a method on an object and retrieves a long return value. + * + * This function calls the specified method of an object using variadic arguments and retrieves a long result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the long return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Long)(ani_env *env, ani_object object, ani_method method, ani_long *result, ...); + + /** + * @brief Calls a method on an object and retrieves a long return value (array-based). + * + * This function calls the specified method of an object using arguments provided in an array and retrieves a long + * result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the long return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Long_A)(ani_env *env, ani_object object, ani_method method, ani_long *result, + const ani_value *args); + + /** + * @brief Calls a method on an object and retrieves a long return value (variadic arguments). + * + * This function calls the specified method of an object using a `va_list` and retrieves a long result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the long return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Long_V)(ani_env *env, ani_object object, ani_method method, ani_long *result, + va_list args); + + /** + * @brief Calls a method on an object and retrieves a float return value. + * + * This function calls the specified method of an object using variadic arguments and retrieves a float result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the float return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Float)(ani_env *env, ani_object object, ani_method method, ani_float *result, ...); + + /** + * @brief Calls a method on an object and retrieves a float return value (array-based). + * + * This function calls the specified method of an object using arguments provided in an array and retrieves a float + * result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the float return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Float_A)(ani_env *env, ani_object object, ani_method method, ani_float *result, + const ani_value *args); + + /** + * @brief Calls a method on an object and retrieves a float return value (variadic arguments). + * + * This function calls the specified method of an object using a `va_list` and retrieves a float result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the float return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Float_V)(ani_env *env, ani_object object, ani_method method, ani_float *result, + va_list args); + + /** + * @brief Calls a method on an object and retrieves a double return value. + * + * This function calls the specified method of an object using variadic arguments and retrieves a double result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the double return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Double)(ani_env *env, ani_object object, ani_method method, ani_double *result, ...); + + /** + * @brief Calls a method on an object and retrieves a double return value (array-based). + * + * This function calls the specified method of an object using arguments provided in an array and retrieves a double + * result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the double return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Double_A)(ani_env *env, ani_object object, ani_method method, ani_double *result, + const ani_value *args); + + /** + * @brief Calls a method on an object and retrieves a double return value (variadic arguments). + * + * This function calls the specified method of an object using a `va_list` and retrieves a double result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the double return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Double_V)(ani_env *env, ani_object object, ani_method method, ani_double *result, + va_list args); + + /** + * @brief Calls a method on an object and retrieves a reference return value. + * + * This function calls the specified method of an object using variadic arguments and retrieves a reference result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the reference return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Ref)(ani_env *env, ani_object object, ani_method method, ani_ref *result, ...); + + /** + * @brief Calls a method on an object and retrieves a reference return value (array-based). + * + * This function calls the specified method of an object using arguments provided in an array and retrieves a + * reference result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the reference return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Ref_A)(ani_env *env, ani_object object, ani_method method, ani_ref *result, + const ani_value *args); + + /** + * @brief Calls a method on an object and retrieves a reference return value (variadic arguments). + * + * This function calls the specified method of an object using a `va_list` and retrieves a reference result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[out] result A pointer to store the reference return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Ref_V)(ani_env *env, ani_object object, ani_method method, ani_ref *result, + va_list args); + + /** + * @brief Calls a method on an object with no return value. + * + * This function calls the specified method of an object using variadic arguments. The method does not return a + * value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Void)(ani_env *env, ani_object object, ani_method method, ...); + + /** + * @brief Calls a method on an object with no return value (array-based). + * + * This function calls the specified method of an object using arguments provided in an array. The method does not + * return a value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Void_A)(ani_env *env, ani_object object, ani_method method, const ani_value *args); + + /** + * @brief Calls a method on an object with no return value (variadic arguments). + * + * This function calls the specified method of an object using a `va_list`. The method does not return a value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] method The method to call. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethod_Void_V)(ani_env *env, ani_object object, ani_method method, va_list args); + + /** + * @brief Calls a method by name on an object and retrieves a boolean return value. + * + * This function calls the specified method by its name and signature on an object using variadic arguments and + * retrieves a boolean result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the boolean return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Boolean)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_boolean *result, ...); + + /** + * @brief Calls a method by name on an object and retrieves a boolean return value (array-based). + * + * This function calls the specified method by its name and signature on an object using arguments provided in an + * array and retrieves a boolean result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the boolean return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Boolean_A)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_boolean *result, const ani_value *args); + + /** + * @brief Calls a method by name on an object and retrieves a boolean return value (variadic arguments). + * + * This function calls the specified method by its name and signature on an object using a `va_list` and retrieves a + * boolean result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the boolean return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Boolean_V)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_boolean *result, va_list args); + + /** + * @brief Calls a method by name on an object and retrieves a char return value. + * + * This function calls the specified method by its name and signature on an object using variadic arguments and + * retrieves a char result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the char return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Char)(ani_env *env, ani_object object, const char *name, const char *signature, + ani_char *result, ...); + + /** + * @brief Calls a method by name on an object and retrieves a char return value (array-based). + * + * This function calls the specified method by its name and signature on an object using arguments provided in an + * array and retrieves a char result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the char return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Char_A)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_char *result, const ani_value *args); + + /** + * @brief Calls a method by name on an object and retrieves a char return value (variadic arguments). + * + * This function calls the specified method by its name and signature on an object using a `va_list` and retrieves a + * char result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the char return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Char_V)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_char *result, va_list args); + + /** + * @brief Calls a method by name on an object and retrieves a byte return value. + * + * This function calls the specified method by its name and signature on an object using variadic arguments and + * retrieves a byte result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the byte return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Byte)(ani_env *env, ani_object object, const char *name, const char *signature, + ani_byte *result, ...); + + /** + * @brief Calls a method by name on an object and retrieves a byte return value (array-based). + * + * This function calls the specified method by its name and signature on an object using arguments provided in an + * array and retrieves a byte result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the byte return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Byte_A)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_byte *result, const ani_value *args); + + /** + * @brief Calls a method by name on an object and retrieves a byte return value (variadic arguments). + * + * This function calls the specified method by its name and signature on an object using a `va_list` and retrieves a + * byte result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the byte return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Byte_V)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_byte *result, va_list args); + + /** + * @brief Calls a method by name on an object and retrieves a short return value. + * + * This function calls the specified method by its name and signature on an object using variadic arguments and + * retrieves a short result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the short return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Short)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_short *result, ...); + + /** + * @brief Calls a method by name on an object and retrieves a short return value (array-based). + * + * This function calls the specified method by its name and signature on an object using arguments provided in an + * array and retrieves a short result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the short return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Short_A)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_short *result, const ani_value *args); + + /** + * @brief Calls a method by name on an object and retrieves a short return value (variadic arguments). + * + * This function calls the specified method by its name and signature on an object using a `va_list` and retrieves a + * short result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the short return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Short_V)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_short *result, va_list args); + + /** + * @brief Calls a method by name on an object and retrieves a integer return value. + * + * This function calls the specified method by its name and signature on an object using variadic arguments and + * retrieves a integer result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the integer return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Int)(ani_env *env, ani_object object, const char *name, const char *signature, + ani_int *result, ...); + + /** + * @brief Calls a method by name on an object and retrieves a integer return value (array-based). + * + * This function calls the specified method by its name and signature on an object using arguments provided in an + * array and retrieves a integer result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the integer return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Int_A)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_int *result, const ani_value *args); + + /** + * @brief Calls a method by name on an object and retrieves a integer return value (variadic arguments). + * + * This function calls the specified method by its name and signature on an object using a `va_list` and retrieves a + * integer result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the integer return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Int_V)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_int *result, va_list args); + + /** + * @brief Calls a method by name on an object and retrieves a long return value. + * + * This function calls the specified method by its name and signature on an object using variadic arguments and + * retrieves a long result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the long return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Long)(ani_env *env, ani_object object, const char *name, const char *signature, + ani_long *result, ...); + + /** + * @brief Calls a method by name on an object and retrieves a long return value (array-based). + * + * This function calls the specified method by its name and signature on an object using arguments provided in an + * array and retrieves a long result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the long return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Long_A)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_long *result, const ani_value *args); + + /** + * @brief Calls a method by name on an object and retrieves a long return value (variadic arguments). + * + * This function calls the specified method by its name and signature on an object using a `va_list` and retrieves a + * long result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the long return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Long_V)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_long *result, va_list args); + + /** + * @brief Calls a method by name on an object and retrieves a float return value. + * + * This function calls the specified method by its name and signature on an object using variadic arguments and + * retrieves a float result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the float return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Float)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_float *result, ...); + + /** + * @brief Calls a method by name on an object and retrieves a float return value (array-based). + * + * This function calls the specified method by its name and signature on an object using arguments provided in an + * array and retrieves a float result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the float return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Float_A)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_float *result, const ani_value *args); + + /** + * @brief Calls a method by name on an object and retrieves a float return value (variadic arguments). + * + * This function calls the specified method by its name and signature on an object using a `va_list` and retrieves a + * float result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the float return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Float_V)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_float *result, va_list args); + + /** + * @brief Calls a method by name on an object and retrieves a double return value. + * + * This function calls the specified method by its name and signature on an object using variadic arguments and + * retrieves a double result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the double return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Double)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_double *result, ...); + + /** + * @brief Calls a method by name on an object and retrieves a double return value (array-based). + * + * This function calls the specified method by its name and signature on an object using arguments provided in an + * array and retrieves a double result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the double return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Double_A)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_double *result, const ani_value *args); + + /** + * @brief Calls a method by name on an object and retrieves a double return value (variadic arguments). + * + * This function calls the specified method by its name and signature on an object using a `va_list` and retrieves a + * double result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the double return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Double_V)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_double *result, va_list args); + + /** + * @brief Calls a method by name on an object and retrieves a reference return value. + * + * This function calls the specified method by its name and signature on an object using variadic arguments and + * retrieves a reference result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the reference return value. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Ref)(ani_env *env, ani_object object, const char *name, const char *signature, + ani_ref *result, ...); + + /** + * @brief Calls a method by name on an object and retrieves a reference return value (array-based). + * + * This function calls the specified method by its name and signature on an object using arguments provided in an + * array and retrieves a reference result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the reference return value. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Ref_A)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_ref *result, const ani_value *args); + + /** + * @brief Calls a method by name on an object and retrieves a reference return value (variadic arguments). + * + * This function calls the specified method by its name and signature on an object using a `va_list` and retrieves a + * reference result. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[out] result A pointer to store the reference return value. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Ref_V)(ani_env *env, ani_object object, const char *name, + const char *signature, ani_ref *result, va_list args); + + /** + * @brief Calls a method by name on an object with no return value. + * + * This function calls the specified method by its name and signature on an object using variadic arguments. The + * method does not return a value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[in] ... Variadic arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Void)(ani_env *env, ani_object object, const char *name, const char *signature, + ...); + + /** + * @brief Calls a method by name on an object with no return value (array-based). + * + * This function calls the specified method by its name and signature on an object using arguments provided in an + * array. The method does not return a value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[in] args An array of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Void_A)(ani_env *env, ani_object object, const char *name, + const char *signature, const ani_value *args); + + /** + * @brief Calls a method by name on an object with no return value (variadic arguments). + * + * This function calls the specified method by its name and signature on an object using a `va_list`. The method + * does not return a value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] object The object on which the method is to be called. + * @param[in] name The name of the method to call. + * @param[in] signature The signature of the method to call. + * @param[in] args A `va_list` of arguments to pass to the method. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Object_CallMethodByName_Void_V)(ani_env *env, ani_object object, const char *name, + const char *signature, va_list args); + + /** + * @brief Retrieves the number of items in a tuple value. + * + * This function retrieves the total number of items in the specified tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value whose number of items is to be retrieved. + * @param[out] result A pointer to store the number of items. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_GetNumberOfItems)(ani_env *env, ani_tuple_value tuple_value, ani_size *result); + + /** + * @brief Retrieves a boolean item from a tuple value. + * + * This function retrieves the boolean value of the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[out] result A pointer to store the boolean value of the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_GetItem_Boolean)(ani_env *env, ani_tuple_value tuple_value, ani_size index, + ani_boolean *result); + + /** + * @brief Retrieves a char item from a tuple value. + * + * This function retrieves the char value of the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[out] result A pointer to store the char value of the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_GetItem_Char)(ani_env *env, ani_tuple_value tuple_value, ani_size index, ani_char *result); + + /** + * @brief Retrieves a byte item from a tuple value. + * + * This function retrieves the byte value of the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[out] result A pointer to store the byte value of the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_GetItem_Byte)(ani_env *env, ani_tuple_value tuple_value, ani_size index, ani_byte *result); + + /** + * @brief Retrieves a short item from a tuple value. + * + * This function retrieves the short value of the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[out] result A pointer to store the short value of the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_GetItem_Short)(ani_env *env, ani_tuple_value tuple_value, ani_size index, + ani_short *result); + + /** + * @brief Retrieves a integer item from a tuple value. + * + * This function retrieves the integer value of the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[out] result A pointer to store the integer value of the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_GetItem_Int)(ani_env *env, ani_tuple_value tuple_value, ani_size index, ani_int *result); + + /** + * @brief Retrieves a long item from a tuple value. + * + * This function retrieves the long value of the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[out] result A pointer to store the long value of the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_GetItem_Long)(ani_env *env, ani_tuple_value tuple_value, ani_size index, ani_long *result); + + /** + * @brief Retrieves a float item from a tuple value. + * + * This function retrieves the float value of the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[out] result A pointer to store the float value of the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_GetItem_Float)(ani_env *env, ani_tuple_value tuple_value, ani_size index, + ani_float *result); + + /** + * @brief Retrieves a double item from a tuple value. + * + * This function retrieves the double value of the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[out] result A pointer to store the double value of the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_GetItem_Double)(ani_env *env, ani_tuple_value tuple_value, ani_size index, + ani_double *result); + + /** + * @brief Retrieves a reference item from a tuple value. + * + * This function retrieves the reference value of the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[out] result A pointer to store the reference value of the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_GetItem_Ref)(ani_env *env, ani_tuple_value tuple_value, ani_size index, ani_ref *result); + + /** + * @brief Sets a boolean value to an item in a tuple value. + * + * This function assigns a boolean value to the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[in] value The boolean value to assign to the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_SetItem_Boolean)(ani_env *env, ani_tuple_value tuple_value, ani_size index, + ani_boolean value); + + /** + * @brief Sets a char value to an item in a tuple value. + * + * This function assigns a char value to the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[in] value The char value to assign to the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_SetItem_Char)(ani_env *env, ani_tuple_value tuple_value, ani_size index, ani_char value); + + /** + * @brief Sets a byte value to an item in a tuple value. + * + * This function assigns a byte value to the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[in] value The byte value to assign to the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_SetItem_Byte)(ani_env *env, ani_tuple_value tuple_value, ani_size index, ani_byte value); + + /** + * @brief Sets a short value to an item in a tuple value. + * + * This function assigns a short value to the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[in] value The short value to assign to the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_SetItem_Short)(ani_env *env, ani_tuple_value tuple_value, ani_size index, ani_short value); + + /** + * @brief Sets a integer value to an item in a tuple value. + * + * This function assigns a integer value to the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[in] value The integer value to assign to the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_SetItem_Int)(ani_env *env, ani_tuple_value tuple_value, ani_size index, ani_int value); + + /** + * @brief Sets a long value to an item in a tuple value. + * + * This function assigns a long value to the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[in] value The long value to assign to the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_SetItem_Long)(ani_env *env, ani_tuple_value tuple_value, ani_size index, ani_long value); + + /** + * @brief Sets a float value to an item in a tuple value. + * + * This function assigns a float value to the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[in] value The float value to assign to the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_SetItem_Float)(ani_env *env, ani_tuple_value tuple_value, ani_size index, ani_float value); + + /** + * @brief Sets a double value to an item in a tuple value. + * + * This function assigns a double value to the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[in] value The double value to assign to the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_SetItem_Double)(ani_env *env, ani_tuple_value tuple_value, ani_size index, + ani_double value); + + /** + * @brief Sets a reference value to an item in a tuple value. + * + * This function assigns a reference value to the item at the specified index in the tuple value. + * + * @param[in] env A pointer to the environment structure. + * @param[in] tuple_value The tuple value containing the item. + * @param[in] index The index of the item. + * @param[in] value The reference value to assign to the item. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*TupleValue_SetItem_Ref)(ani_env *env, ani_tuple_value tuple_value, ani_size index, ani_ref value); + + /** + * @brief Creates a global reference. + * + * This function creates a global reference from a local reference. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ref The local reference to convert to a global reference. + * @param[out] result A pointer to store the created global reference. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*GlobalReference_Create)(ani_env *env, ani_ref ref, ani_ref *result); + + /** + * @brief Deletes a global reference. + * + * This function deletes the specified global reference, releasing all associated resources. + * + * @param[in] env A pointer to the environment structure. + * @param[in] gref The global reference to delete. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*GlobalReference_Delete)(ani_env *env, ani_ref gref); + + /** + * @brief Creates a weak reference. + * + * This function creates a weak reference from a local reference. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ref The local reference to convert to a weak reference. + * @param[out] result A pointer to store the created weak reference. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*WeakReference_Create)(ani_env *env, ani_ref ref, ani_wref *result); + + /** + * @brief Deletes a weak reference. + * + * This function deletes the specified weak reference, releasing all associated resources. + * + * @param[in] env A pointer to the environment structure. + * @param[in] wref The weak reference to delete. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*WeakReference_Delete)(ani_env *env, ani_wref wref); + + /** + * @brief Retrieves the local reference associated with a weak reference. + * + * This function retrieves the local reference that corresponds to the specified weak reference. + * + * @param[in] env A pointer to the environment structure. + * @param[in] wref The weak reference to query. + * @param[out] was_released_result A pointer to boolean flag which indicates that wref is GC collected. + * @param[out] ref_result A pointer to store the retrieved local reference. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*WeakReference_GetReference)(ani_env *env, ani_wref wref, ani_boolean *was_released_result, + ani_ref *ref_result); + + /** + * @brief Creates a new array buffer. + * + * This function creates a new array buffer with the specified length and returns a pointer to the allocated data. + * + * @param[in] env A pointer to the environment structure. + * @param[in] length The length of the array buffer in bytes. + * @param[out] data_result A pointer to store the allocated data of the array buffer. + * @param[out] arraybuffer_result A pointer to store the created array buffer object. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*CreateArrayBuffer)(ani_env *env, size_t length, void **data_result, + ani_arraybuffer *arraybuffer_result); + + /** + * @brief Retrieves information about an array buffer. + * + * This function retrieves the data pointer and length of the specified array buffer. + * + * @param[in] env A pointer to the environment structure. + * @param[in] arraybuffer The array buffer to query. + * @param[out] data_result A pointer to store the data of the array buffer. + * @param[out] length_result A pointer to store the length of the array buffer in bytes. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*ArrayBuffer_GetInfo)(ani_env *env, ani_arraybuffer arraybuffer, void **data_result, + size_t *length_result); + + /** + * @brief Creates a new Promise. + * + * This function creates a new promise and a resolver to manage it. + * + * @param[in] env A pointer to the environment structure. + * @param[out] result_resolver A pointer to store the created resolver. + * @param[out] result_promise A pointer to store the created promise. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Promise_New)(ani_env *env, ani_resolver *result_resolver, ani_object *result_promise); + + /** + * @brief Resolves a promise. + * + * This function resolves a promise by way of the resolver with which it is associated + * and queues promise `then` callbacks. + * + * @param[in] env A pointer to the environment structure. + * @param[in] resolver A resolver whose associated promise to resolve. + * @param[in] resolution A reference with which to resolve the promise. + * @return Returns a status code of type `ani_status` indicating success or failure. + * The `resolver` is freed upon successful completion. + */ + ani_status (*PromiseResolver_Resolve)(ani_env *env, ani_resolver resolver, ani_ref resolution); + + /** + * @brief Rejects a promise. + * + * This function rejects a promise by way of the resolver with which it is associated + * and queues promise `catch` callbacks. + * + * @param[in] env A pointer to the environment structure. + * @param[in] resolver A resolver whose associated promise to resolve. + * @param[in] rejection An error with which to reject the promise. + * @return Returns a status code of type `ani_status` indicating success or failure. + * The `resolver` is freed upon successful completion. + */ + ani_status (*PromiseResolver_Reject)(ani_env *env, ani_resolver resolver, ani_error rejection); + + /** + * @brief Checks if Any reference is an instance of a specified Any type. + * + * This function checks whether the given Any reference is an instance of the specified Any type. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ref The reference to check. + * @param[in] type The type to compare against. + * @param[out] result A pointer to store the boolean result (true if the reference is an instance of the type, + * false otherwise). + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Any_InstanceOf)(ani_env *env, ani_ref ref, ani_ref type, ani_boolean *result); + + /** + * @brief Gets a property of an Any reference by name. + * + * This function retrieves the value of a named property from the given Any reference. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ref The reference from which to retrieve the property. + * @param[in] name The name of the property to retrieve. + * @param[out] result A pointer to store the retrieved property value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Any_GetProperty)(ani_env *env, ani_ref ref, const char *name, ani_ref *result); + + /** + * @brief Sets a property of an Any reference by name. + * + * This function sets the value of a named property on the given Any reference. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ref The reference on which to set the property. + * @param[in] name The name of the property to set. + * @param[in] value The value to assign to the property. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Any_SetProperty)(ani_env *env, ani_ref ref, const char *name, ani_ref value); + + /** + * @brief Gets an element of an Any reference by index. + * + * This function retrieves the value at a specific index from the given Any reference. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ref The reference from which to retrieve the element. + * @param[in] index The index of the element to retrieve. + * @param[out] result A pointer to store the retrieved value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Any_GetByIndex)(ani_env *env, ani_ref ref, ani_size index, ani_ref *result); + + /** + * @brief Sets an element of an Any reference by index. + * + * This function sets the value at a specific index on the given Any reference. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ref The reference on which to set the element. + * @param[in] index The index of the element to set. + * @param[in] value The value to assign to the specified index. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Any_SetByIndex)(ani_env *env, ani_ref ref, ani_size index, ani_ref value); + + /** + * @brief Gets a property of an Any reference by key reference. + * + * This function retrieves the value of a property using another Any reference as the key. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ref The reference from which to retrieve the property. + * @param[in] key The key reference used to access the property. + * @param[out] result A pointer to store the retrieved property value. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Any_GetByValue)(ani_env *env, ani_ref ref, ani_ref key, ani_ref *result); + + /** + * @brief Sets a property of an Any reference by key reference. + * + * This function sets the value of a property using another Any reference as the key. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ref The reference on which to set the property. + * @param[in] key The key reference used to access the property. + * @param[in] value The value to assign to the specified key. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Any_SetByValue)(ani_env *env, ani_ref ref, ani_ref key, ani_ref value); + + /** + * @brief Calls an Any reference as a function. + * + * This function invokes the given Any reference if it represents a callable object. + * + * @param[in] env A pointer to the environment structure. + * @param[in] func The function reference to invoke. + * @param[in] argc The number of arguments. + * @param[in] argv An array of argument references. + * @param[out] result A pointer to store the function call result. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Any_Call)(ani_env *env, ani_ref func, ani_size argc, ani_ref *argv, ani_ref *result); + + /** + * @brief Calls a method of an Any reference by name. + * + * This function invokes a named method on the given Any reference. + * + * @param[in] env A pointer to the environment structure. + * @param[in] self The object reference on which to invoke the method. + * @param[in] name The name of the method to invoke. + * @param[in] argc The number of arguments. + * @param[in] argv An array of argument references. + * @param[out] result A pointer to store the method call result. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Any_CallMethod)(ani_env *env, ani_ref self, const char *name, ani_size argc, ani_ref *argv, + ani_ref *result); + + /** + * @brief Constructs a new object using an Any reference as a constructor. + * + * This function creates a new object using the given constructor reference and arguments. + * + * @param[in] env A pointer to the environment structure. + * @param[in] ctor The constructor function reference. + * @param[in] argc The number of arguments. + * @param[in] argv An array of argument references. + * @param[out] result A pointer to store the created object reference. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Any_New)(ani_env *env, ani_ref ctor, ani_size argc, ani_ref *argv, ani_ref *result); + + /** + * @brief Binds static native methods to a class. + * + * This function binds an array of static native methods to the specified class. + * + * @param[in] env A pointer to the environment structure. + * @param[in] cls The class to which the native methods will be bound. + * @param[in] methods A pointer to an array of static native methods to bind. + * @param[in] nr_methods The number of static native methods in the array. + * @return Returns a status code of type `ani_status` indicating success or failure. + */ + ani_status (*Class_BindStaticNativeMethods)(ani_env *env, ani_class cls, const ani_native_function *methods, + ani_size nr_methods); +}; + +// C++ API +struct __ani_vm { + const struct __ani_vm_api *c_api; + +#ifdef __cplusplus + ani_status DestroyVM() + { + return c_api->DestroyVM(this); + } + ani_status GetEnv(uint32_t version, ani_env **result) + { + return c_api->GetEnv(this, version, result); + } + ani_status AttachCurrentThread(const ani_options *options, uint32_t version, ani_env **result) + { + return c_api->AttachCurrentThread(this, options, version, result); + } + ani_status DetachCurrentThread() + { + return c_api->DetachCurrentThread(this); + } +#endif // __cplusplus +}; + +struct __ani_env { + const struct __ani_interaction_api *c_api; + +#ifdef __cplusplus + ani_status GetVersion(uint32_t *result) + { + return c_api->GetVersion(this, result); + } + ani_status GetVM(ani_vm **result) + { + return c_api->GetVM(this, result); + } + ani_status Object_New(ani_class cls, ani_method method, ani_object *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_New_V(this, cls, method, result, args); + va_end(args); + return status; + } + ani_status Object_New_A(ani_class cls, ani_method method, ani_object *result, const ani_value *args) + { + return c_api->Object_New_A(this, cls, method, result, args); + } + ani_status Object_New_V(ani_class cls, ani_method method, ani_object *result, va_list args) + { + return c_api->Object_New_V(this, cls, method, result, args); + } + ani_status Object_GetType(ani_object object, ani_type *result) + { + return c_api->Object_GetType(this, object, result); + } + ani_status Object_InstanceOf(ani_object object, ani_type type, ani_boolean *result) + { + return c_api->Object_InstanceOf(this, object, type, result); + } + ani_status Type_GetSuperClass(ani_type type, ani_class *result) + { + return c_api->Type_GetSuperClass(this, type, result); + } + ani_status Type_IsAssignableFrom(ani_type from_type, ani_type to_type, ani_boolean *result) + { + return c_api->Type_IsAssignableFrom(this, from_type, to_type, result); + } + ani_status FindModule(const char *module_descriptor, ani_module *result) + { + return c_api->FindModule(this, module_descriptor, result); + } + ani_status FindNamespace(const char *namespace_descriptor, ani_namespace *result) + { + return c_api->FindNamespace(this, namespace_descriptor, result); + } + ani_status FindClass(const char *class_descriptor, ani_class *result) + { + return c_api->FindClass(this, class_descriptor, result); + } + ani_status FindEnum(const char *enum_descriptor, ani_enum *result) + { + return c_api->FindEnum(this, enum_descriptor, result); + } + ani_status Module_FindNamespace(ani_module module, const char *namespace_descriptor, ani_namespace *result) + { + return c_api->Module_FindNamespace(this, module, namespace_descriptor, result); + } + ani_status Module_FindClass(ani_module module, const char *class_descriptor, ani_class *result) + { + return c_api->Module_FindClass(this, module, class_descriptor, result); + } + ani_status Module_FindEnum(ani_module module, const char *enum_descriptor, ani_enum *result) + { + return c_api->Module_FindEnum(this, module, enum_descriptor, result); + } + ani_status Module_FindFunction(ani_module module, const char *name, const char *signature, ani_function *result) + { + return c_api->Module_FindFunction(this, module, name, signature, result); + } + ani_status Module_FindVariable(ani_module module, const char *name, ani_variable *result) + { + return c_api->Module_FindVariable(this, module, name, result); + } + ani_status Namespace_FindNamespace(ani_namespace ns, const char *namespace_descriptor, ani_namespace *result) + { + return c_api->Namespace_FindNamespace(this, ns, namespace_descriptor, result); + } + ani_status Namespace_FindClass(ani_namespace ns, const char *class_descriptor, ani_class *result) + { + return c_api->Namespace_FindClass(this, ns, class_descriptor, result); + } + ani_status Namespace_FindEnum(ani_namespace ns, const char *enum_descriptor, ani_enum *result) + { + return c_api->Namespace_FindEnum(this, ns, enum_descriptor, result); + } + ani_status Namespace_FindFunction(ani_namespace ns, const char *name, const char *signature, ani_function *result) + { + return c_api->Namespace_FindFunction(this, ns, name, signature, result); + } + ani_status Namespace_FindVariable(ani_namespace ns, const char *name, ani_variable *result) + { + return c_api->Namespace_FindVariable(this, ns, name, result); + } + ani_status Module_BindNativeFunctions(ani_module module, const ani_native_function *functions, + ani_size nr_functions) + { + return c_api->Module_BindNativeFunctions(this, module, functions, nr_functions); + } + ani_status Namespace_BindNativeFunctions(ani_namespace ns, const ani_native_function *functions, + ani_size nr_functions) + { + return c_api->Namespace_BindNativeFunctions(this, ns, functions, nr_functions); + } + ani_status Class_BindNativeMethods(ani_class cls, const ani_native_function *methods, ani_size nr_methods) + { + return c_api->Class_BindNativeMethods(this, cls, methods, nr_methods); + } + ani_status Reference_Delete(ani_ref ref) + { + return c_api->Reference_Delete(this, ref); + } + ani_status EnsureEnoughReferences(ani_size nr_refs) + { + return c_api->EnsureEnoughReferences(this, nr_refs); + } + ani_status CreateLocalScope(ani_size nr_refs) + { + return c_api->CreateLocalScope(this, nr_refs); + } + ani_status DestroyLocalScope() + { + return c_api->DestroyLocalScope(this); + } + ani_status CreateEscapeLocalScope(ani_size nr_refs) + { + return c_api->CreateEscapeLocalScope(this, nr_refs); + } + ani_status DestroyEscapeLocalScope(ani_ref ref, ani_ref *result) + { + return c_api->DestroyEscapeLocalScope(this, ref, result); + } + ani_status ThrowError(ani_error err) + { + return c_api->ThrowError(this, err); + } + ani_status ExistUnhandledError(ani_boolean *result) + { + return c_api->ExistUnhandledError(this, result); + } + ani_status GetUnhandledError(ani_error *result) + { + return c_api->GetUnhandledError(this, result); + } + ani_status ResetError() + { + return c_api->ResetError(this); + } + ani_status DescribeError() + { + return c_api->DescribeError(this); + } + ani_status Abort(const char *message) + { + return c_api->Abort(this, message); + } + ani_status GetNull(ani_ref *result) + { + return c_api->GetNull(this, result); + } + ani_status GetUndefined(ani_ref *result) + { + return c_api->GetUndefined(this, result); + } + ani_status Reference_IsNull(ani_ref ref, ani_boolean *result) + { + return c_api->Reference_IsNull(this, ref, result); + } + ani_status Reference_IsUndefined(ani_ref ref, ani_boolean *result) + { + return c_api->Reference_IsUndefined(this, ref, result); + } + ani_status Reference_IsNullishValue(ani_ref ref, ani_boolean *result) + { + return c_api->Reference_IsNullishValue(this, ref, result); + } + ani_status Reference_Equals(ani_ref ref0, ani_ref ref1, ani_boolean *result) + { + return c_api->Reference_Equals(this, ref0, ref1, result); + } + ani_status Reference_StrictEquals(ani_ref ref0, ani_ref ref1, ani_boolean *result) + { + return c_api->Reference_StrictEquals(this, ref0, ref1, result); + } + ani_status String_NewUTF16(const uint16_t *utf16_string, ani_size utf16_size, ani_string *result) + { + return c_api->String_NewUTF16(this, utf16_string, utf16_size, result); + } + ani_status String_GetUTF16Size(ani_string string, ani_size *result) + { + return c_api->String_GetUTF16Size(this, string, result); + } + ani_status String_GetUTF16(ani_string string, uint16_t *utf16_buffer, ani_size utf16_buffer_size, ani_size *result) + { + return c_api->String_GetUTF16(this, string, utf16_buffer, utf16_buffer_size, result); + } + ani_status String_GetUTF16SubString(ani_string string, ani_size substr_offset, ani_size substr_size, + uint16_t *utf16_buffer, ani_size utf16_buffer_size, ani_size *result) + { + return c_api->String_GetUTF16SubString(this, string, substr_offset, substr_size, utf16_buffer, + utf16_buffer_size, result); + } + ani_status String_NewUTF8(const char *utf8_string, ani_size utf8_size, ani_string *result) + { + return c_api->String_NewUTF8(this, utf8_string, utf8_size, result); + } + ani_status String_GetUTF8Size(ani_string string, ani_size *result) + { + return c_api->String_GetUTF8Size(this, string, result); + } + ani_status String_GetUTF8(ani_string string, char *utf8_buffer, ani_size utf8_buffer_size, ani_size *result) + { + return c_api->String_GetUTF8(this, string, utf8_buffer, utf8_buffer_size, result); + } + ani_status String_GetUTF8SubString(ani_string string, ani_size substr_offset, ani_size substr_size, + char *utf8_buffer, ani_size utf8_buffer_size, ani_size *result) + { + return c_api->String_GetUTF8SubString(this, string, substr_offset, substr_size, utf8_buffer, utf8_buffer_size, + result); + } + ani_status Array_GetLength(ani_array array, ani_size *result) + { + return c_api->Array_GetLength(this, array, result); + } + ani_status Array_New_Boolean(ani_size length, ani_array_boolean *result) + { + return c_api->Array_New_Boolean(this, length, result); + } + ani_status Array_New_Char(ani_size length, ani_array_char *result) + { + return c_api->Array_New_Char(this, length, result); + } + ani_status Array_New_Byte(ani_size length, ani_array_byte *result) + { + return c_api->Array_New_Byte(this, length, result); + } + ani_status Array_New_Short(ani_size length, ani_array_short *result) + { + return c_api->Array_New_Short(this, length, result); + } + ani_status Array_New_Int(ani_size length, ani_array_int *result) + { + return c_api->Array_New_Int(this, length, result); + } + ani_status Array_New_Long(ani_size length, ani_array_long *result) + { + return c_api->Array_New_Long(this, length, result); + } + ani_status Array_New_Float(ani_size length, ani_array_float *result) + { + return c_api->Array_New_Float(this, length, result); + } + ani_status Array_New_Double(ani_size length, ani_array_double *result) + { + return c_api->Array_New_Double(this, length, result); + } + ani_status Array_GetRegion_Boolean(ani_array_boolean array, ani_size offset, ani_size length, + ani_boolean *native_buffer) + { + return c_api->Array_GetRegion_Boolean(this, array, offset, length, native_buffer); + } + ani_status Array_GetRegion_Char(ani_array_char array, ani_size offset, ani_size length, ani_char *native_buffer) + { + return c_api->Array_GetRegion_Char(this, array, offset, length, native_buffer); + } + ani_status Array_GetRegion_Byte(ani_array_byte array, ani_size offset, ani_size length, ani_byte *native_buffer) + { + return c_api->Array_GetRegion_Byte(this, array, offset, length, native_buffer); + } + ani_status Array_GetRegion_Short(ani_array_short array, ani_size offset, ani_size length, ani_short *native_buffer) + { + return c_api->Array_GetRegion_Short(this, array, offset, length, native_buffer); + } + ani_status Array_GetRegion_Int(ani_array_int array, ani_size offset, ani_size length, ani_int *native_buffer) + { + return c_api->Array_GetRegion_Int(this, array, offset, length, native_buffer); + } + ani_status Array_GetRegion_Long(ani_array_long array, ani_size offset, ani_size length, ani_long *native_buffer) + { + return c_api->Array_GetRegion_Long(this, array, offset, length, native_buffer); + } + ani_status Array_GetRegion_Float(ani_array_float array, ani_size offset, ani_size length, ani_float *native_buffer) + { + return c_api->Array_GetRegion_Float(this, array, offset, length, native_buffer); + } + ani_status Array_GetRegion_Double(ani_array_double array, ani_size offset, ani_size length, + ani_double *native_buffer) + { + return c_api->Array_GetRegion_Double(this, array, offset, length, native_buffer); + } + ani_status Array_SetRegion_Boolean(ani_array_boolean array, ani_size offset, ani_size length, + const ani_boolean *native_buffer) + { + return c_api->Array_SetRegion_Boolean(this, array, offset, length, native_buffer); + } + ani_status Array_SetRegion_Char(ani_array_char array, ani_size offset, ani_size length, + const ani_char *native_buffer) + { + return c_api->Array_SetRegion_Char(this, array, offset, length, native_buffer); + } + ani_status Array_SetRegion_Byte(ani_array_byte array, ani_size offset, ani_size length, + const ani_byte *native_buffer) + { + return c_api->Array_SetRegion_Byte(this, array, offset, length, native_buffer); + } + ani_status Array_SetRegion_Short(ani_array_short array, ani_size offset, ani_size length, + const ani_short *native_buffer) + { + return c_api->Array_SetRegion_Short(this, array, offset, length, native_buffer); + } + ani_status Array_SetRegion_Int(ani_array_int array, ani_size offset, ani_size length, const ani_int *native_buffer) + { + return c_api->Array_SetRegion_Int(this, array, offset, length, native_buffer); + } + ani_status Array_SetRegion_Long(ani_array_long array, ani_size offset, ani_size length, + const ani_long *native_buffer) + { + return c_api->Array_SetRegion_Long(this, array, offset, length, native_buffer); + } + ani_status Array_SetRegion_Float(ani_array_float array, ani_size offset, ani_size length, + const ani_float *native_buffer) + { + return c_api->Array_SetRegion_Float(this, array, offset, length, native_buffer); + } + ani_status Array_SetRegion_Double(ani_array_double array, ani_size offset, ani_size length, + const ani_double *native_buffer) + { + return c_api->Array_SetRegion_Double(this, array, offset, length, native_buffer); + } + ani_status Array_New_Ref(ani_type type, ani_size length, ani_ref initial_element, ani_array_ref *result) + { + return c_api->Array_New_Ref(this, type, length, initial_element, result); + } + ani_status Array_Set_Ref(ani_array_ref array, ani_size index, ani_ref ref) + { + return c_api->Array_Set_Ref(this, array, index, ref); + } + ani_status Array_Get_Ref(ani_array_ref array, ani_size index, ani_ref *result) + { + return c_api->Array_Get_Ref(this, array, index, result); + } + ani_status Array_New(ani_size length, ani_ref initial_element, ani_array *result) + { + return c_api->Array_New(this, length, initial_element, result); + } + ani_status Array_Set(ani_array array, ani_size index, ani_ref ref) + { + return c_api->Array_Set(this, array, index, ref); + } + ani_status Array_Get(ani_array array, ani_size index, ani_ref *result) + { + return c_api->Array_Get(this, array, index, result); + } + ani_status Array_Push(ani_array array, ani_ref ref) + { + return c_api->Array_Push(this, array, ref); + } + ani_status Array_Pop(ani_array array, ani_ref *result) + { + return c_api->Array_Pop(this, array, result); + } + ani_status FixedArray_GetLength(ani_fixedarray array, ani_size *result) + { + return c_api->FixedArray_GetLength(this, array, result); + } + ani_status FixedArray_New_Boolean(ani_size length, ani_fixedarray_boolean *result) + { + return c_api->FixedArray_New_Boolean(this, length, result); + } + ani_status FixedArray_New_Char(ani_size length, ani_fixedarray_char *result) + { + return c_api->FixedArray_New_Char(this, length, result); + } + ani_status FixedArray_New_Byte(ani_size length, ani_fixedarray_byte *result) + { + return c_api->FixedArray_New_Byte(this, length, result); + } + ani_status FixedArray_New_Short(ani_size length, ani_fixedarray_short *result) + { + return c_api->FixedArray_New_Short(this, length, result); + } + ani_status FixedArray_New_Int(ani_size length, ani_fixedarray_int *result) + { + return c_api->FixedArray_New_Int(this, length, result); + } + ani_status FixedArray_New_Long(ani_size length, ani_fixedarray_long *result) + { + return c_api->FixedArray_New_Long(this, length, result); + } + ani_status FixedArray_New_Float(ani_size length, ani_fixedarray_float *result) + { + return c_api->FixedArray_New_Float(this, length, result); + } + ani_status FixedArray_New_Double(ani_size length, ani_fixedarray_double *result) + { + return c_api->FixedArray_New_Double(this, length, result); + } + ani_status FixedArray_GetRegion_Boolean(ani_fixedarray_boolean array, ani_size offset, ani_size length, + ani_boolean *native_buffer) + { + return c_api->FixedArray_GetRegion_Boolean(this, array, offset, length, native_buffer); + } + ani_status FixedArray_GetRegion_Char(ani_fixedarray_char array, ani_size offset, ani_size length, + ani_char *native_buffer) + { + return c_api->FixedArray_GetRegion_Char(this, array, offset, length, native_buffer); + } + ani_status FixedArray_GetRegion_Byte(ani_fixedarray_byte array, ani_size offset, ani_size length, + ani_byte *native_buffer) + { + return c_api->FixedArray_GetRegion_Byte(this, array, offset, length, native_buffer); + } + ani_status FixedArray_GetRegion_Short(ani_fixedarray_short array, ani_size offset, ani_size length, + ani_short *native_buffer) + { + return c_api->FixedArray_GetRegion_Short(this, array, offset, length, native_buffer); + } + ani_status FixedArray_GetRegion_Int(ani_fixedarray_int array, ani_size offset, ani_size length, + ani_int *native_buffer) + { + return c_api->FixedArray_GetRegion_Int(this, array, offset, length, native_buffer); + } + ani_status FixedArray_GetRegion_Long(ani_fixedarray_long array, ani_size offset, ani_size length, + ani_long *native_buffer) + { + return c_api->FixedArray_GetRegion_Long(this, array, offset, length, native_buffer); + } + ani_status FixedArray_GetRegion_Float(ani_fixedarray_float array, ani_size offset, ani_size length, + ani_float *native_buffer) + { + return c_api->FixedArray_GetRegion_Float(this, array, offset, length, native_buffer); + } + ani_status FixedArray_GetRegion_Double(ani_fixedarray_double array, ani_size offset, ani_size length, + ani_double *native_buffer) + { + return c_api->FixedArray_GetRegion_Double(this, array, offset, length, native_buffer); + } + ani_status FixedArray_SetRegion_Boolean(ani_fixedarray_boolean array, ani_size offset, ani_size length, + const ani_boolean *native_buffer) + { + return c_api->FixedArray_SetRegion_Boolean(this, array, offset, length, native_buffer); + } + ani_status FixedArray_SetRegion_Char(ani_fixedarray_char array, ani_size offset, ani_size length, + const ani_char *native_buffer) + { + return c_api->FixedArray_SetRegion_Char(this, array, offset, length, native_buffer); + } + ani_status FixedArray_SetRegion_Byte(ani_fixedarray_byte array, ani_size offset, ani_size length, + const ani_byte *native_buffer) + { + return c_api->FixedArray_SetRegion_Byte(this, array, offset, length, native_buffer); + } + ani_status FixedArray_SetRegion_Short(ani_fixedarray_short array, ani_size offset, ani_size length, + const ani_short *native_buffer) + { + return c_api->FixedArray_SetRegion_Short(this, array, offset, length, native_buffer); + } + ani_status FixedArray_SetRegion_Int(ani_fixedarray_int array, ani_size offset, ani_size length, + const ani_int *native_buffer) + { + return c_api->FixedArray_SetRegion_Int(this, array, offset, length, native_buffer); + } + ani_status FixedArray_SetRegion_Long(ani_fixedarray_long array, ani_size offset, ani_size length, + const ani_long *native_buffer) + { + return c_api->FixedArray_SetRegion_Long(this, array, offset, length, native_buffer); + } + ani_status FixedArray_SetRegion_Float(ani_fixedarray_float array, ani_size offset, ani_size length, + const ani_float *native_buffer) + { + return c_api->FixedArray_SetRegion_Float(this, array, offset, length, native_buffer); + } + ani_status FixedArray_SetRegion_Double(ani_fixedarray_double array, ani_size offset, ani_size length, + const ani_double *native_buffer) + { + return c_api->FixedArray_SetRegion_Double(this, array, offset, length, native_buffer); + } + ani_status FixedArray_New_Ref(ani_type type, ani_size length, ani_ref initial_element, ani_fixedarray_ref *result) + { + return c_api->FixedArray_New_Ref(this, type, length, initial_element, result); + } + ani_status FixedArray_Set_Ref(ani_fixedarray_ref array, ani_size index, ani_ref ref) + { + return c_api->FixedArray_Set_Ref(this, array, index, ref); + } + ani_status FixedArray_Get_Ref(ani_fixedarray_ref array, ani_size index, ani_ref *result) + { + return c_api->FixedArray_Get_Ref(this, array, index, result); + } + ani_status Enum_GetEnumItemByName(ani_enum enm, const char *name, ani_enum_item *result) + { + return c_api->Enum_GetEnumItemByName(this, enm, name, result); + } + ani_status Enum_GetEnumItemByIndex(ani_enum enm, ani_size index, ani_enum_item *result) + { + return c_api->Enum_GetEnumItemByIndex(this, enm, index, result); + } + ani_status EnumItem_GetEnum(ani_enum_item enum_item, ani_enum *result) + { + return c_api->EnumItem_GetEnum(this, enum_item, result); + } + ani_status EnumItem_GetValue_Int(ani_enum_item enum_item, ani_int *result) + { + return c_api->EnumItem_GetValue_Int(this, enum_item, result); + } + ani_status EnumItem_GetValue_String(ani_enum_item enum_item, ani_string *result) + { + return c_api->EnumItem_GetValue_String(this, enum_item, result); + } + ani_status EnumItem_GetName(ani_enum_item enum_item, ani_string *result) + { + return c_api->EnumItem_GetName(this, enum_item, result); + } + ani_status EnumItem_GetIndex(ani_enum_item enum_item, ani_size *result) + { + return c_api->EnumItem_GetIndex(this, enum_item, result); + } + ani_status FunctionalObject_Call(ani_fn_object fn, ani_size argc, ani_ref *argv, ani_ref *result) + { + return c_api->FunctionalObject_Call(this, fn, argc, argv, result); + } + ani_status Variable_SetValue_Boolean(ani_variable variable, ani_boolean value) + { + return c_api->Variable_SetValue_Boolean(this, variable, value); + } + ani_status Variable_SetValue_Char(ani_variable variable, ani_char value) + { + return c_api->Variable_SetValue_Char(this, variable, value); + } + ani_status Variable_SetValue_Byte(ani_variable variable, ani_byte value) + { + return c_api->Variable_SetValue_Byte(this, variable, value); + } + ani_status Variable_SetValue_Short(ani_variable variable, ani_short value) + { + return c_api->Variable_SetValue_Short(this, variable, value); + } + ani_status Variable_SetValue_Int(ani_variable variable, ani_int value) + { + return c_api->Variable_SetValue_Int(this, variable, value); + } + ani_status Variable_SetValue_Long(ani_variable variable, ani_long value) + { + return c_api->Variable_SetValue_Long(this, variable, value); + } + ani_status Variable_SetValue_Float(ani_variable variable, ani_float value) + { + return c_api->Variable_SetValue_Float(this, variable, value); + } + ani_status Variable_SetValue_Double(ani_variable variable, ani_double value) + { + return c_api->Variable_SetValue_Double(this, variable, value); + } + ani_status Variable_SetValue_Ref(ani_variable variable, ani_ref value) + { + return c_api->Variable_SetValue_Ref(this, variable, value); + } + ani_status Variable_GetValue_Boolean(ani_variable variable, ani_boolean *result) + { + return c_api->Variable_GetValue_Boolean(this, variable, result); + } + ani_status Variable_GetValue_Char(ani_variable variable, ani_char *result) + { + return c_api->Variable_GetValue_Char(this, variable, result); + } + ani_status Variable_GetValue_Byte(ani_variable variable, ani_byte *result) + { + return c_api->Variable_GetValue_Byte(this, variable, result); + } + ani_status Variable_GetValue_Short(ani_variable variable, ani_short *result) + { + return c_api->Variable_GetValue_Short(this, variable, result); + } + ani_status Variable_GetValue_Int(ani_variable variable, ani_int *result) + { + return c_api->Variable_GetValue_Int(this, variable, result); + } + ani_status Variable_GetValue_Long(ani_variable variable, ani_long *result) + { + return c_api->Variable_GetValue_Long(this, variable, result); + } + ani_status Variable_GetValue_Float(ani_variable variable, ani_float *result) + { + return c_api->Variable_GetValue_Float(this, variable, result); + } + ani_status Variable_GetValue_Double(ani_variable variable, ani_double *result) + { + return c_api->Variable_GetValue_Double(this, variable, result); + } + ani_status Variable_GetValue_Ref(ani_variable variable, ani_ref *result) + { + return c_api->Variable_GetValue_Ref(this, variable, result); + } + ani_status Function_Call_Boolean(ani_function fn, ani_boolean *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Function_Call_Boolean_V(this, fn, result, args); + va_end(args); + return status; + } + ani_status Function_Call_Boolean_A(ani_function fn, ani_boolean *result, const ani_value *args) + { + return c_api->Function_Call_Boolean_A(this, fn, result, args); + } + ani_status Function_Call_Boolean_V(ani_function fn, ani_boolean *result, va_list args) + { + return c_api->Function_Call_Boolean_V(this, fn, result, args); + } + ani_status Function_Call_Char(ani_function fn, ani_char *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Function_Call_Char_V(this, fn, result, args); + va_end(args); + return status; + } + ani_status Function_Call_Char_A(ani_function fn, ani_char *result, const ani_value *args) + { + return c_api->Function_Call_Char_A(this, fn, result, args); + } + ani_status Function_Call_Char_V(ani_function fn, ani_char *result, va_list args) + { + return c_api->Function_Call_Char_V(this, fn, result, args); + } + ani_status Function_Call_Byte(ani_function fn, ani_byte *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Function_Call_Byte_V(this, fn, result, args); + va_end(args); + return status; + } + ani_status Function_Call_Byte_A(ani_function fn, ani_byte *result, const ani_value *args) + { + return c_api->Function_Call_Byte_A(this, fn, result, args); + } + ani_status Function_Call_Byte_V(ani_function fn, ani_byte *result, va_list args) + { + return c_api->Function_Call_Byte_V(this, fn, result, args); + } + ani_status Function_Call_Short(ani_function fn, ani_short *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Function_Call_Short_V(this, fn, result, args); + va_end(args); + return status; + } + ani_status Function_Call_Short_A(ani_function fn, ani_short *result, const ani_value *args) + { + return c_api->Function_Call_Short_A(this, fn, result, args); + } + ani_status Function_Call_Short_V(ani_function fn, ani_short *result, va_list args) + { + return c_api->Function_Call_Short_V(this, fn, result, args); + } + ani_status Function_Call_Int(ani_function fn, ani_int *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Function_Call_Int_V(this, fn, result, args); + va_end(args); + return status; + } + ani_status Function_Call_Int_A(ani_function fn, ani_int *result, const ani_value *args) + { + return c_api->Function_Call_Int_A(this, fn, result, args); + } + ani_status Function_Call_Int_V(ani_function fn, ani_int *result, va_list args) + { + return c_api->Function_Call_Int_V(this, fn, result, args); + } + ani_status Function_Call_Long(ani_function fn, ani_long *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Function_Call_Long_V(this, fn, result, args); + va_end(args); + return status; + } + ani_status Function_Call_Long_A(ani_function fn, ani_long *result, const ani_value *args) + { + return c_api->Function_Call_Long_A(this, fn, result, args); + } + ani_status Function_Call_Long_V(ani_function fn, ani_long *result, va_list args) + { + return c_api->Function_Call_Long_V(this, fn, result, args); + } + ani_status Function_Call_Float(ani_function fn, ani_float *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Function_Call_Float_V(this, fn, result, args); + va_end(args); + return status; + } + ani_status Function_Call_Float_A(ani_function fn, ani_float *result, const ani_value *args) + { + return c_api->Function_Call_Float_A(this, fn, result, args); + } + ani_status Function_Call_Float_V(ani_function fn, ani_float *result, va_list args) + { + return c_api->Function_Call_Float_V(this, fn, result, args); + } + ani_status Function_Call_Double(ani_function fn, ani_double *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Function_Call_Double_V(this, fn, result, args); + va_end(args); + return status; + } + ani_status Function_Call_Double_A(ani_function fn, ani_double *result, const ani_value *args) + { + return c_api->Function_Call_Double_A(this, fn, result, args); + } + ani_status Function_Call_Double_V(ani_function fn, ani_double *result, va_list args) + { + return c_api->Function_Call_Double_V(this, fn, result, args); + } + ani_status Function_Call_Ref(ani_function fn, ani_ref *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Function_Call_Ref_V(this, fn, result, args); + va_end(args); + return status; + } + ani_status Function_Call_Ref_A(ani_function fn, ani_ref *result, const ani_value *args) + { + return c_api->Function_Call_Ref_A(this, fn, result, args); + } + ani_status Function_Call_Ref_V(ani_function fn, ani_ref *result, va_list args) + { + return c_api->Function_Call_Ref_V(this, fn, result, args); + } + ani_status Function_Call_Void(ani_function fn, ...) + { + va_list args; + va_start(args, fn); + ani_status status = c_api->Function_Call_Void_V(this, fn, args); + va_end(args); + return status; + } + ani_status Function_Call_Void_A(ani_function fn, const ani_value *args) + { + return c_api->Function_Call_Void_A(this, fn, args); + } + ani_status Function_Call_Void_V(ani_function fn, va_list args) + { + return c_api->Function_Call_Void_V(this, fn, args); + } + ani_status Class_FindField(ani_class cls, const char *name, ani_field *result) + { + return c_api->Class_FindField(this, cls, name, result); + } + ani_status Class_FindStaticField(ani_class cls, const char *name, ani_static_field *result) + { + return c_api->Class_FindStaticField(this, cls, name, result); + } + ani_status Class_FindMethod(ani_class cls, const char *name, const char *signature, ani_method *result) + { + return c_api->Class_FindMethod(this, cls, name, signature, result); + } + ani_status Class_FindStaticMethod(ani_class cls, const char *name, const char *signature, ani_static_method *result) + { + return c_api->Class_FindStaticMethod(this, cls, name, signature, result); + } + ani_status Class_FindSetter(ani_class cls, const char *name, ani_method *result) + { + return c_api->Class_FindSetter(this, cls, name, result); + } + ani_status Class_FindGetter(ani_class cls, const char *name, ani_method *result) + { + return c_api->Class_FindGetter(this, cls, name, result); + } + ani_status Class_FindIndexableGetter(ani_class cls, const char *signature, ani_method *result) + { + return c_api->Class_FindIndexableGetter(this, cls, signature, result); + } + ani_status Class_FindIndexableSetter(ani_class cls, const char *signature, ani_method *result) + { + return c_api->Class_FindIndexableSetter(this, cls, signature, result); + } + ani_status Class_FindIterator(ani_class cls, ani_method *result) + { + return c_api->Class_FindIterator(this, cls, result); + } + ani_status Class_GetStaticField_Boolean(ani_class cls, ani_static_field field, ani_boolean *result) + { + return c_api->Class_GetStaticField_Boolean(this, cls, field, result); + } + ani_status Class_GetStaticField_Char(ani_class cls, ani_static_field field, ani_char *result) + { + return c_api->Class_GetStaticField_Char(this, cls, field, result); + } + ani_status Class_GetStaticField_Byte(ani_class cls, ani_static_field field, ani_byte *result) + { + return c_api->Class_GetStaticField_Byte(this, cls, field, result); + } + ani_status Class_GetStaticField_Short(ani_class cls, ani_static_field field, ani_short *result) + { + return c_api->Class_GetStaticField_Short(this, cls, field, result); + } + ani_status Class_GetStaticField_Int(ani_class cls, ani_static_field field, ani_int *result) + { + return c_api->Class_GetStaticField_Int(this, cls, field, result); + } + ani_status Class_GetStaticField_Long(ani_class cls, ani_static_field field, ani_long *result) + { + return c_api->Class_GetStaticField_Long(this, cls, field, result); + } + ani_status Class_GetStaticField_Float(ani_class cls, ani_static_field field, ani_float *result) + { + return c_api->Class_GetStaticField_Float(this, cls, field, result); + } + ani_status Class_GetStaticField_Double(ani_class cls, ani_static_field field, ani_double *result) + { + return c_api->Class_GetStaticField_Double(this, cls, field, result); + } + ani_status Class_GetStaticField_Ref(ani_class cls, ani_static_field field, ani_ref *result) + { + return c_api->Class_GetStaticField_Ref(this, cls, field, result); + } + ani_status Class_SetStaticField_Boolean(ani_class cls, ani_static_field field, ani_boolean value) + { + return c_api->Class_SetStaticField_Boolean(this, cls, field, value); + } + ani_status Class_SetStaticField_Char(ani_class cls, ani_static_field field, ani_char value) + { + return c_api->Class_SetStaticField_Char(this, cls, field, value); + } + ani_status Class_SetStaticField_Byte(ani_class cls, ani_static_field field, ani_byte value) + { + return c_api->Class_SetStaticField_Byte(this, cls, field, value); + } + ani_status Class_SetStaticField_Short(ani_class cls, ani_static_field field, ani_short value) + { + return c_api->Class_SetStaticField_Short(this, cls, field, value); + } + ani_status Class_SetStaticField_Int(ani_class cls, ani_static_field field, ani_int value) + { + return c_api->Class_SetStaticField_Int(this, cls, field, value); + } + ani_status Class_SetStaticField_Long(ani_class cls, ani_static_field field, ani_long value) + { + return c_api->Class_SetStaticField_Long(this, cls, field, value); + } + ani_status Class_SetStaticField_Float(ani_class cls, ani_static_field field, ani_float value) + { + return c_api->Class_SetStaticField_Float(this, cls, field, value); + } + ani_status Class_SetStaticField_Double(ani_class cls, ani_static_field field, ani_double value) + { + return c_api->Class_SetStaticField_Double(this, cls, field, value); + } + ani_status Class_SetStaticField_Ref(ani_class cls, ani_static_field field, ani_ref value) + { + return c_api->Class_SetStaticField_Ref(this, cls, field, value); + } + ani_status Class_GetStaticFieldByName_Boolean(ani_class cls, const char *name, ani_boolean *result) + { + return c_api->Class_GetStaticFieldByName_Boolean(this, cls, name, result); + } + ani_status Class_GetStaticFieldByName_Char(ani_class cls, const char *name, ani_char *result) + { + return c_api->Class_GetStaticFieldByName_Char(this, cls, name, result); + } + ani_status Class_GetStaticFieldByName_Byte(ani_class cls, const char *name, ani_byte *result) + { + return c_api->Class_GetStaticFieldByName_Byte(this, cls, name, result); + } + ani_status Class_GetStaticFieldByName_Short(ani_class cls, const char *name, ani_short *result) + { + return c_api->Class_GetStaticFieldByName_Short(this, cls, name, result); + } + ani_status Class_GetStaticFieldByName_Int(ani_class cls, const char *name, ani_int *result) + { + return c_api->Class_GetStaticFieldByName_Int(this, cls, name, result); + } + ani_status Class_GetStaticFieldByName_Long(ani_class cls, const char *name, ani_long *result) + { + return c_api->Class_GetStaticFieldByName_Long(this, cls, name, result); + } + ani_status Class_GetStaticFieldByName_Float(ani_class cls, const char *name, ani_float *result) + { + return c_api->Class_GetStaticFieldByName_Float(this, cls, name, result); + } + ani_status Class_GetStaticFieldByName_Double(ani_class cls, const char *name, ani_double *result) + { + return c_api->Class_GetStaticFieldByName_Double(this, cls, name, result); + } + ani_status Class_GetStaticFieldByName_Ref(ani_class cls, const char *name, ani_ref *result) + { + return c_api->Class_GetStaticFieldByName_Ref(this, cls, name, result); + } + ani_status Class_SetStaticFieldByName_Boolean(ani_class cls, const char *name, ani_boolean value) + { + return c_api->Class_SetStaticFieldByName_Boolean(this, cls, name, value); + } + ani_status Class_SetStaticFieldByName_Char(ani_class cls, const char *name, ani_char value) + { + return c_api->Class_SetStaticFieldByName_Char(this, cls, name, value); + } + ani_status Class_SetStaticFieldByName_Byte(ani_class cls, const char *name, ani_byte value) + { + return c_api->Class_SetStaticFieldByName_Byte(this, cls, name, value); + } + ani_status Class_SetStaticFieldByName_Short(ani_class cls, const char *name, ani_short value) + { + return c_api->Class_SetStaticFieldByName_Short(this, cls, name, value); + } + ani_status Class_SetStaticFieldByName_Int(ani_class cls, const char *name, ani_int value) + { + return c_api->Class_SetStaticFieldByName_Int(this, cls, name, value); + } + ani_status Class_SetStaticFieldByName_Long(ani_class cls, const char *name, ani_long value) + { + return c_api->Class_SetStaticFieldByName_Long(this, cls, name, value); + } + ani_status Class_SetStaticFieldByName_Float(ani_class cls, const char *name, ani_float value) + { + return c_api->Class_SetStaticFieldByName_Float(this, cls, name, value); + } + ani_status Class_SetStaticFieldByName_Double(ani_class cls, const char *name, ani_double value) + { + return c_api->Class_SetStaticFieldByName_Double(this, cls, name, value); + } + ani_status Class_SetStaticFieldByName_Ref(ani_class cls, const char *name, ani_ref value) + { + return c_api->Class_SetStaticFieldByName_Ref(this, cls, name, value); + } + ani_status Class_CallStaticMethod_Boolean(ani_class cls, ani_static_method method, ani_boolean *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethod_Boolean_V(this, cls, method, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethod_Boolean_A(ani_class cls, ani_static_method method, ani_boolean *result, + const ani_value *args) + { + return c_api->Class_CallStaticMethod_Boolean_A(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Boolean_V(ani_class cls, ani_static_method method, ani_boolean *result, + va_list args) + { + return c_api->Class_CallStaticMethod_Boolean_V(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Char(ani_class cls, ani_static_method method, ani_char *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethod_Char_V(this, cls, method, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethod_Char_A(ani_class cls, ani_static_method method, ani_char *result, + const ani_value *args) + { + return c_api->Class_CallStaticMethod_Char_A(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Char_V(ani_class cls, ani_static_method method, ani_char *result, va_list args) + { + return c_api->Class_CallStaticMethod_Char_V(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Byte(ani_class cls, ani_static_method method, ani_byte *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethod_Byte_V(this, cls, method, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethod_Byte_A(ani_class cls, ani_static_method method, ani_byte *result, + const ani_value *args) + { + return c_api->Class_CallStaticMethod_Byte_A(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Byte_V(ani_class cls, ani_static_method method, ani_byte *result, va_list args) + { + return c_api->Class_CallStaticMethod_Byte_V(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Short(ani_class cls, ani_static_method method, ani_short *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethod_Short_V(this, cls, method, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethod_Short_A(ani_class cls, ani_static_method method, ani_short *result, + const ani_value *args) + { + return c_api->Class_CallStaticMethod_Short_A(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Short_V(ani_class cls, ani_static_method method, ani_short *result, va_list args) + { + return c_api->Class_CallStaticMethod_Short_V(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Int(ani_class cls, ani_static_method method, ani_int *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethod_Int_V(this, cls, method, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethod_Int_A(ani_class cls, ani_static_method method, ani_int *result, + const ani_value *args) + { + return c_api->Class_CallStaticMethod_Int_A(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Int_V(ani_class cls, ani_static_method method, ani_int *result, va_list args) + { + return c_api->Class_CallStaticMethod_Int_V(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Long(ani_class cls, ani_static_method method, ani_long *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethod_Long_V(this, cls, method, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethod_Long_A(ani_class cls, ani_static_method method, ani_long *result, + const ani_value *args) + { + return c_api->Class_CallStaticMethod_Long_A(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Long_V(ani_class cls, ani_static_method method, ani_long *result, va_list args) + { + return c_api->Class_CallStaticMethod_Long_V(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Float(ani_class cls, ani_static_method method, ani_float *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethod_Float_V(this, cls, method, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethod_Float_A(ani_class cls, ani_static_method method, ani_float *result, + const ani_value *args) + { + return c_api->Class_CallStaticMethod_Float_A(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Float_V(ani_class cls, ani_static_method method, ani_float *result, va_list args) + { + return c_api->Class_CallStaticMethod_Float_V(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Double(ani_class cls, ani_static_method method, ani_double *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethod_Double_V(this, cls, method, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethod_Double_A(ani_class cls, ani_static_method method, ani_double *result, + const ani_value *args) + { + return c_api->Class_CallStaticMethod_Double_A(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Double_V(ani_class cls, ani_static_method method, ani_double *result, + va_list args) + { + return c_api->Class_CallStaticMethod_Double_V(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Ref(ani_class cls, ani_static_method method, ani_ref *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethod_Ref_V(this, cls, method, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethod_Ref_A(ani_class cls, ani_static_method method, ani_ref *result, + const ani_value *args) + { + return c_api->Class_CallStaticMethod_Ref_A(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Ref_V(ani_class cls, ani_static_method method, ani_ref *result, va_list args) + { + return c_api->Class_CallStaticMethod_Ref_V(this, cls, method, result, args); + } + ani_status Class_CallStaticMethod_Void(ani_class cls, ani_static_method method, ...) + { + va_list args; + va_start(args, method); + ani_status status = c_api->Class_CallStaticMethod_Void_V(this, cls, method, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethod_Void_A(ani_class cls, ani_static_method method, const ani_value *args) + { + return c_api->Class_CallStaticMethod_Void_A(this, cls, method, args); + } + ani_status Class_CallStaticMethod_Void_V(ani_class cls, ani_static_method method, va_list args) + { + return c_api->Class_CallStaticMethod_Void_V(this, cls, method, args); + } + ani_status Class_CallStaticMethodByName_Boolean(ani_class cls, const char *name, const char *signature, + ani_boolean *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethodByName_Boolean_V(this, cls, name, signature, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethodByName_Boolean_A(ani_class cls, const char *name, const char *signature, + ani_boolean *result, const ani_value *args) + { + return c_api->Class_CallStaticMethodByName_Boolean_A(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Boolean_V(ani_class cls, const char *name, const char *signature, + ani_boolean *result, va_list args) + { + return c_api->Class_CallStaticMethodByName_Boolean_V(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Char(ani_class cls, const char *name, const char *signature, + ani_char *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethodByName_Char_V(this, cls, name, signature, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethodByName_Char_A(ani_class cls, const char *name, const char *signature, + ani_char *result, const ani_value *args) + { + return c_api->Class_CallStaticMethodByName_Char_A(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Char_V(ani_class cls, const char *name, const char *signature, + ani_char *result, va_list args) + { + return c_api->Class_CallStaticMethodByName_Char_V(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Byte(ani_class cls, const char *name, const char *signature, + ani_byte *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethodByName_Byte_V(this, cls, name, signature, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethodByName_Byte_A(ani_class cls, const char *name, const char *signature, + ani_byte *result, const ani_value *args) + { + return c_api->Class_CallStaticMethodByName_Byte_A(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Byte_V(ani_class cls, const char *name, const char *signature, + ani_byte *result, va_list args) + { + return c_api->Class_CallStaticMethodByName_Byte_V(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Short(ani_class cls, const char *name, const char *signature, + ani_short *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethodByName_Short_V(this, cls, name, signature, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethodByName_Short_A(ani_class cls, const char *name, const char *signature, + ani_short *result, const ani_value *args) + { + return c_api->Class_CallStaticMethodByName_Short_A(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Short_V(ani_class cls, const char *name, const char *signature, + ani_short *result, va_list args) + { + return c_api->Class_CallStaticMethodByName_Short_V(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Int(ani_class cls, const char *name, const char *signature, ani_int *result, + ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethodByName_Int_V(this, cls, name, signature, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethodByName_Int_A(ani_class cls, const char *name, const char *signature, + ani_int *result, const ani_value *args) + { + return c_api->Class_CallStaticMethodByName_Int_A(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Int_V(ani_class cls, const char *name, const char *signature, + ani_int *result, va_list args) + { + return c_api->Class_CallStaticMethodByName_Int_V(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Long(ani_class cls, const char *name, const char *signature, + ani_long *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethodByName_Long_V(this, cls, name, signature, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethodByName_Long_A(ani_class cls, const char *name, const char *signature, + ani_long *result, const ani_value *args) + { + return c_api->Class_CallStaticMethodByName_Long_A(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Long_V(ani_class cls, const char *name, const char *signature, + ani_long *result, va_list args) + { + return c_api->Class_CallStaticMethodByName_Long_V(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Float(ani_class cls, const char *name, const char *signature, + ani_float *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethodByName_Float_V(this, cls, name, signature, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethodByName_Float_A(ani_class cls, const char *name, const char *signature, + ani_float *result, const ani_value *args) + { + return c_api->Class_CallStaticMethodByName_Float_A(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Float_V(ani_class cls, const char *name, const char *signature, + ani_float *result, va_list args) + { + return c_api->Class_CallStaticMethodByName_Float_V(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Double(ani_class cls, const char *name, const char *signature, + ani_double *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethodByName_Double_V(this, cls, name, signature, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethodByName_Double_A(ani_class cls, const char *name, const char *signature, + ani_double *result, const ani_value *args) + { + return c_api->Class_CallStaticMethodByName_Double_A(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Double_V(ani_class cls, const char *name, const char *signature, + ani_double *result, va_list args) + { + return c_api->Class_CallStaticMethodByName_Double_V(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Ref(ani_class cls, const char *name, const char *signature, ani_ref *result, + ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Class_CallStaticMethodByName_Ref_V(this, cls, name, signature, result, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethodByName_Ref_A(ani_class cls, const char *name, const char *signature, + ani_ref *result, const ani_value *args) + { + return c_api->Class_CallStaticMethodByName_Ref_A(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Ref_V(ani_class cls, const char *name, const char *signature, + ani_ref *result, va_list args) + { + return c_api->Class_CallStaticMethodByName_Ref_V(this, cls, name, signature, result, args); + } + ani_status Class_CallStaticMethodByName_Void(ani_class cls, const char *name, const char *signature, ...) + { + va_list args; + va_start(args, signature); + ani_status status = c_api->Class_CallStaticMethodByName_Void_V(this, cls, name, signature, args); + va_end(args); + return status; + } + ani_status Class_CallStaticMethodByName_Void_A(ani_class cls, const char *name, const char *signature, + const ani_value *args) + { + return c_api->Class_CallStaticMethodByName_Void_A(this, cls, name, signature, args); + } + ani_status Class_CallStaticMethodByName_Void_V(ani_class cls, const char *name, const char *signature, va_list args) + { + return c_api->Class_CallStaticMethodByName_Void_V(this, cls, name, signature, args); + } + ani_status Object_GetField_Boolean(ani_object object, ani_field field, ani_boolean *result) + { + return c_api->Object_GetField_Boolean(this, object, field, result); + } + ani_status Object_GetField_Char(ani_object object, ani_field field, ani_char *result) + { + return c_api->Object_GetField_Char(this, object, field, result); + } + ani_status Object_GetField_Byte(ani_object object, ani_field field, ani_byte *result) + { + return c_api->Object_GetField_Byte(this, object, field, result); + } + ani_status Object_GetField_Short(ani_object object, ani_field field, ani_short *result) + { + return c_api->Object_GetField_Short(this, object, field, result); + } + ani_status Object_GetField_Int(ani_object object, ani_field field, ani_int *result) + { + return c_api->Object_GetField_Int(this, object, field, result); + } + ani_status Object_GetField_Long(ani_object object, ani_field field, ani_long *result) + { + return c_api->Object_GetField_Long(this, object, field, result); + } + ani_status Object_GetField_Float(ani_object object, ani_field field, ani_float *result) + { + return c_api->Object_GetField_Float(this, object, field, result); + } + ani_status Object_GetField_Double(ani_object object, ani_field field, ani_double *result) + { + return c_api->Object_GetField_Double(this, object, field, result); + } + ani_status Object_GetField_Ref(ani_object object, ani_field field, ani_ref *result) + { + return c_api->Object_GetField_Ref(this, object, field, result); + } + ani_status Object_SetField_Boolean(ani_object object, ani_field field, ani_boolean value) + { + return c_api->Object_SetField_Boolean(this, object, field, value); + } + ani_status Object_SetField_Char(ani_object object, ani_field field, ani_char value) + { + return c_api->Object_SetField_Char(this, object, field, value); + } + ani_status Object_SetField_Byte(ani_object object, ani_field field, ani_byte value) + { + return c_api->Object_SetField_Byte(this, object, field, value); + } + ani_status Object_SetField_Short(ani_object object, ani_field field, ani_short value) + { + return c_api->Object_SetField_Short(this, object, field, value); + } + ani_status Object_SetField_Int(ani_object object, ani_field field, ani_int value) + { + return c_api->Object_SetField_Int(this, object, field, value); + } + ani_status Object_SetField_Long(ani_object object, ani_field field, ani_long value) + { + return c_api->Object_SetField_Long(this, object, field, value); + } + ani_status Object_SetField_Float(ani_object object, ani_field field, ani_float value) + { + return c_api->Object_SetField_Float(this, object, field, value); + } + ani_status Object_SetField_Double(ani_object object, ani_field field, ani_double value) + { + return c_api->Object_SetField_Double(this, object, field, value); + } + ani_status Object_SetField_Ref(ani_object object, ani_field field, ani_ref value) + { + return c_api->Object_SetField_Ref(this, object, field, value); + } + ani_status Object_GetFieldByName_Boolean(ani_object object, const char *name, ani_boolean *result) + { + return c_api->Object_GetFieldByName_Boolean(this, object, name, result); + } + ani_status Object_GetFieldByName_Char(ani_object object, const char *name, ani_char *result) + { + return c_api->Object_GetFieldByName_Char(this, object, name, result); + } + ani_status Object_GetFieldByName_Byte(ani_object object, const char *name, ani_byte *result) + { + return c_api->Object_GetFieldByName_Byte(this, object, name, result); + } + ani_status Object_GetFieldByName_Short(ani_object object, const char *name, ani_short *result) + { + return c_api->Object_GetFieldByName_Short(this, object, name, result); + } + ani_status Object_GetFieldByName_Int(ani_object object, const char *name, ani_int *result) + { + return c_api->Object_GetFieldByName_Int(this, object, name, result); + } + ani_status Object_GetFieldByName_Long(ani_object object, const char *name, ani_long *result) + { + return c_api->Object_GetFieldByName_Long(this, object, name, result); + } + ani_status Object_GetFieldByName_Float(ani_object object, const char *name, ani_float *result) + { + return c_api->Object_GetFieldByName_Float(this, object, name, result); + } + ani_status Object_GetFieldByName_Double(ani_object object, const char *name, ani_double *result) + { + return c_api->Object_GetFieldByName_Double(this, object, name, result); + } + ani_status Object_GetFieldByName_Ref(ani_object object, const char *name, ani_ref *result) + { + return c_api->Object_GetFieldByName_Ref(this, object, name, result); + } + ani_status Object_SetFieldByName_Boolean(ani_object object, const char *name, ani_boolean value) + { + return c_api->Object_SetFieldByName_Boolean(this, object, name, value); + } + ani_status Object_SetFieldByName_Char(ani_object object, const char *name, ani_char value) + { + return c_api->Object_SetFieldByName_Char(this, object, name, value); + } + ani_status Object_SetFieldByName_Byte(ani_object object, const char *name, ani_byte value) + { + return c_api->Object_SetFieldByName_Byte(this, object, name, value); + } + ani_status Object_SetFieldByName_Short(ani_object object, const char *name, ani_short value) + { + return c_api->Object_SetFieldByName_Short(this, object, name, value); + } + ani_status Object_SetFieldByName_Int(ani_object object, const char *name, ani_int value) + { + return c_api->Object_SetFieldByName_Int(this, object, name, value); + } + ani_status Object_SetFieldByName_Long(ani_object object, const char *name, ani_long value) + { + return c_api->Object_SetFieldByName_Long(this, object, name, value); + } + ani_status Object_SetFieldByName_Float(ani_object object, const char *name, ani_float value) + { + return c_api->Object_SetFieldByName_Float(this, object, name, value); + } + ani_status Object_SetFieldByName_Double(ani_object object, const char *name, ani_double value) + { + return c_api->Object_SetFieldByName_Double(this, object, name, value); + } + ani_status Object_SetFieldByName_Ref(ani_object object, const char *name, ani_ref value) + { + return c_api->Object_SetFieldByName_Ref(this, object, name, value); + } + ani_status Object_GetPropertyByName_Boolean(ani_object object, const char *name, ani_boolean *result) + { + return c_api->Object_GetPropertyByName_Boolean(this, object, name, result); + } + ani_status Object_GetPropertyByName_Char(ani_object object, const char *name, ani_char *result) + { + return c_api->Object_GetPropertyByName_Char(this, object, name, result); + } + ani_status Object_GetPropertyByName_Byte(ani_object object, const char *name, ani_byte *result) + { + return c_api->Object_GetPropertyByName_Byte(this, object, name, result); + } + ani_status Object_GetPropertyByName_Short(ani_object object, const char *name, ani_short *result) + { + return c_api->Object_GetPropertyByName_Short(this, object, name, result); + } + ani_status Object_GetPropertyByName_Int(ani_object object, const char *name, ani_int *result) + { + return c_api->Object_GetPropertyByName_Int(this, object, name, result); + } + ani_status Object_GetPropertyByName_Long(ani_object object, const char *name, ani_long *result) + { + return c_api->Object_GetPropertyByName_Long(this, object, name, result); + } + ani_status Object_GetPropertyByName_Float(ani_object object, const char *name, ani_float *result) + { + return c_api->Object_GetPropertyByName_Float(this, object, name, result); + } + ani_status Object_GetPropertyByName_Double(ani_object object, const char *name, ani_double *result) + { + return c_api->Object_GetPropertyByName_Double(this, object, name, result); + } + ani_status Object_GetPropertyByName_Ref(ani_object object, const char *name, ani_ref *result) + { + return c_api->Object_GetPropertyByName_Ref(this, object, name, result); + } + ani_status Object_SetPropertyByName_Boolean(ani_object object, const char *name, ani_boolean value) + { + return c_api->Object_SetPropertyByName_Boolean(this, object, name, value); + } + ani_status Object_SetPropertyByName_Char(ani_object object, const char *name, ani_char value) + { + return c_api->Object_SetPropertyByName_Char(this, object, name, value); + } + ani_status Object_SetPropertyByName_Byte(ani_object object, const char *name, ani_byte value) + { + return c_api->Object_SetPropertyByName_Byte(this, object, name, value); + } + ani_status Object_SetPropertyByName_Short(ani_object object, const char *name, ani_short value) + { + return c_api->Object_SetPropertyByName_Short(this, object, name, value); + } + ani_status Object_SetPropertyByName_Int(ani_object object, const char *name, ani_int value) + { + return c_api->Object_SetPropertyByName_Int(this, object, name, value); + } + ani_status Object_SetPropertyByName_Long(ani_object object, const char *name, ani_long value) + { + return c_api->Object_SetPropertyByName_Long(this, object, name, value); + } + ani_status Object_SetPropertyByName_Float(ani_object object, const char *name, ani_float value) + { + return c_api->Object_SetPropertyByName_Float(this, object, name, value); + } + ani_status Object_SetPropertyByName_Double(ani_object object, const char *name, ani_double value) + { + return c_api->Object_SetPropertyByName_Double(this, object, name, value); + } + ani_status Object_SetPropertyByName_Ref(ani_object object, const char *name, ani_ref value) + { + return c_api->Object_SetPropertyByName_Ref(this, object, name, value); + } + ani_status Object_CallMethod_Boolean(ani_object object, ani_method method, ani_boolean *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethod_Boolean_V(this, object, method, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethod_Boolean_A(ani_object object, ani_method method, ani_boolean *result, + const ani_value *args) + { + return c_api->Object_CallMethod_Boolean_A(this, object, method, result, args); + } + ani_status Object_CallMethod_Boolean_V(ani_object object, ani_method method, ani_boolean *result, va_list args) + { + return c_api->Object_CallMethod_Boolean_V(this, object, method, result, args); + } + ani_status Object_CallMethod_Char(ani_object object, ani_method method, ani_char *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethod_Char_V(this, object, method, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethod_Char_A(ani_object object, ani_method method, ani_char *result, const ani_value *args) + { + return c_api->Object_CallMethod_Char_A(this, object, method, result, args); + } + ani_status Object_CallMethod_Char_V(ani_object object, ani_method method, ani_char *result, va_list args) + { + return c_api->Object_CallMethod_Char_V(this, object, method, result, args); + } + ani_status Object_CallMethod_Byte(ani_object object, ani_method method, ani_byte *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethod_Byte_V(this, object, method, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethod_Byte_A(ani_object object, ani_method method, ani_byte *result, const ani_value *args) + { + return c_api->Object_CallMethod_Byte_A(this, object, method, result, args); + } + ani_status Object_CallMethod_Byte_V(ani_object object, ani_method method, ani_byte *result, va_list args) + { + return c_api->Object_CallMethod_Byte_V(this, object, method, result, args); + } + ani_status Object_CallMethod_Short(ani_object object, ani_method method, ani_short *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethod_Short_V(this, object, method, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethod_Short_A(ani_object object, ani_method method, ani_short *result, const ani_value *args) + { + return c_api->Object_CallMethod_Short_A(this, object, method, result, args); + } + ani_status Object_CallMethod_Short_V(ani_object object, ani_method method, ani_short *result, va_list args) + { + return c_api->Object_CallMethod_Short_V(this, object, method, result, args); + } + ani_status Object_CallMethod_Int(ani_object object, ani_method method, ani_int *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethod_Int_V(this, object, method, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethod_Int_A(ani_object object, ani_method method, ani_int *result, const ani_value *args) + { + return c_api->Object_CallMethod_Int_A(this, object, method, result, args); + } + ani_status Object_CallMethod_Int_V(ani_object object, ani_method method, ani_int *result, va_list args) + { + return c_api->Object_CallMethod_Int_V(this, object, method, result, args); + } + ani_status Object_CallMethod_Long(ani_object object, ani_method method, ani_long *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethod_Long_V(this, object, method, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethod_Long_A(ani_object object, ani_method method, ani_long *result, const ani_value *args) + { + return c_api->Object_CallMethod_Long_A(this, object, method, result, args); + } + ani_status Object_CallMethod_Long_V(ani_object object, ani_method method, ani_long *result, va_list args) + { + return c_api->Object_CallMethod_Long_V(this, object, method, result, args); + } + ani_status Object_CallMethod_Float(ani_object object, ani_method method, ani_float *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethod_Float_V(this, object, method, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethod_Float_A(ani_object object, ani_method method, ani_float *result, const ani_value *args) + { + return c_api->Object_CallMethod_Float_A(this, object, method, result, args); + } + ani_status Object_CallMethod_Float_V(ani_object object, ani_method method, ani_float *result, va_list args) + { + return c_api->Object_CallMethod_Float_V(this, object, method, result, args); + } + ani_status Object_CallMethod_Double(ani_object object, ani_method method, ani_double *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethod_Double_V(this, object, method, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethod_Double_A(ani_object object, ani_method method, ani_double *result, + const ani_value *args) + { + return c_api->Object_CallMethod_Double_A(this, object, method, result, args); + } + ani_status Object_CallMethod_Double_V(ani_object object, ani_method method, ani_double *result, va_list args) + { + return c_api->Object_CallMethod_Double_V(this, object, method, result, args); + } + ani_status Object_CallMethod_Ref(ani_object object, ani_method method, ani_ref *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethod_Ref_V(this, object, method, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethod_Ref_A(ani_object object, ani_method method, ani_ref *result, const ani_value *args) + { + return c_api->Object_CallMethod_Ref_A(this, object, method, result, args); + } + ani_status Object_CallMethod_Ref_V(ani_object object, ani_method method, ani_ref *result, va_list args) + { + return c_api->Object_CallMethod_Ref_V(this, object, method, result, args); + } + ani_status Object_CallMethod_Void(ani_object object, ani_method method, ...) + { + va_list args; + va_start(args, method); + ani_status status = c_api->Object_CallMethod_Void_V(this, object, method, args); + va_end(args); + return status; + } + ani_status Object_CallMethod_Void_A(ani_object object, ani_method method, const ani_value *args) + { + return c_api->Object_CallMethod_Void_A(this, object, method, args); + } + ani_status Object_CallMethod_Void_V(ani_object object, ani_method method, va_list args) + { + return c_api->Object_CallMethod_Void_V(this, object, method, args); + } + ani_status Object_CallMethodByName_Boolean(ani_object object, const char *name, const char *signature, + ani_boolean *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethodByName_Boolean_V(this, object, name, signature, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethodByName_Boolean_A(ani_object object, const char *name, const char *signature, + ani_boolean *result, const ani_value *args) + { + return c_api->Object_CallMethodByName_Boolean_A(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Boolean_V(ani_object object, const char *name, const char *signature, + ani_boolean *result, va_list args) + { + return c_api->Object_CallMethodByName_Boolean_V(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Char(ani_object object, const char *name, const char *signature, + ani_char *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethodByName_Char_V(this, object, name, signature, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethodByName_Char_A(ani_object object, const char *name, const char *signature, + ani_char *result, const ani_value *args) + { + return c_api->Object_CallMethodByName_Char_A(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Char_V(ani_object object, const char *name, const char *signature, + ani_char *result, va_list args) + { + return c_api->Object_CallMethodByName_Char_V(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Byte(ani_object object, const char *name, const char *signature, + ani_byte *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethodByName_Byte_V(this, object, name, signature, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethodByName_Byte_A(ani_object object, const char *name, const char *signature, + ani_byte *result, const ani_value *args) + { + return c_api->Object_CallMethodByName_Byte_A(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Byte_V(ani_object object, const char *name, const char *signature, + ani_byte *result, va_list args) + { + return c_api->Object_CallMethodByName_Byte_V(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Short(ani_object object, const char *name, const char *signature, + ani_short *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethodByName_Short_V(this, object, name, signature, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethodByName_Short_A(ani_object object, const char *name, const char *signature, + ani_short *result, const ani_value *args) + { + return c_api->Object_CallMethodByName_Short_A(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Short_V(ani_object object, const char *name, const char *signature, + ani_short *result, va_list args) + { + return c_api->Object_CallMethodByName_Short_V(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Int(ani_object object, const char *name, const char *signature, ani_int *result, + ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethodByName_Int_V(this, object, name, signature, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethodByName_Int_A(ani_object object, const char *name, const char *signature, + ani_int *result, const ani_value *args) + { + return c_api->Object_CallMethodByName_Int_A(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Int_V(ani_object object, const char *name, const char *signature, + ani_int *result, va_list args) + { + return c_api->Object_CallMethodByName_Int_V(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Long(ani_object object, const char *name, const char *signature, + ani_long *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethodByName_Long_V(this, object, name, signature, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethodByName_Long_A(ani_object object, const char *name, const char *signature, + ani_long *result, const ani_value *args) + { + return c_api->Object_CallMethodByName_Long_A(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Long_V(ani_object object, const char *name, const char *signature, + ani_long *result, va_list args) + { + return c_api->Object_CallMethodByName_Long_V(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Float(ani_object object, const char *name, const char *signature, + ani_float *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethodByName_Float_V(this, object, name, signature, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethodByName_Float_A(ani_object object, const char *name, const char *signature, + ani_float *result, const ani_value *args) + { + return c_api->Object_CallMethodByName_Float_A(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Float_V(ani_object object, const char *name, const char *signature, + ani_float *result, va_list args) + { + return c_api->Object_CallMethodByName_Float_V(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Double(ani_object object, const char *name, const char *signature, + ani_double *result, ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethodByName_Double_V(this, object, name, signature, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethodByName_Double_A(ani_object object, const char *name, const char *signature, + ani_double *result, const ani_value *args) + { + return c_api->Object_CallMethodByName_Double_A(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Double_V(ani_object object, const char *name, const char *signature, + ani_double *result, va_list args) + { + return c_api->Object_CallMethodByName_Double_V(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Ref(ani_object object, const char *name, const char *signature, ani_ref *result, + ...) + { + va_list args; + va_start(args, result); + ani_status status = c_api->Object_CallMethodByName_Ref_V(this, object, name, signature, result, args); + va_end(args); + return status; + } + ani_status Object_CallMethodByName_Ref_A(ani_object object, const char *name, const char *signature, + ani_ref *result, const ani_value *args) + { + return c_api->Object_CallMethodByName_Ref_A(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Ref_V(ani_object object, const char *name, const char *signature, + ani_ref *result, va_list args) + { + return c_api->Object_CallMethodByName_Ref_V(this, object, name, signature, result, args); + } + ani_status Object_CallMethodByName_Void(ani_object object, const char *name, const char *signature, ...) + { + va_list args; + va_start(args, signature); + ani_status status = c_api->Object_CallMethodByName_Void_V(this, object, name, signature, args); + va_end(args); + return status; + } + ani_status Object_CallMethodByName_Void_A(ani_object object, const char *name, const char *signature, + const ani_value *args) + { + return c_api->Object_CallMethodByName_Void_A(this, object, name, signature, args); + } + ani_status Object_CallMethodByName_Void_V(ani_object object, const char *name, const char *signature, va_list args) + { + return c_api->Object_CallMethodByName_Void_V(this, object, name, signature, args); + } + ani_status TupleValue_GetNumberOfItems(ani_tuple_value tuple_value, ani_size *result) + { + return c_api->TupleValue_GetNumberOfItems(this, tuple_value, result); + } + ani_status TupleValue_GetItem_Boolean(ani_tuple_value tuple_value, ani_size index, ani_boolean *result) + { + return c_api->TupleValue_GetItem_Boolean(this, tuple_value, index, result); + } + ani_status TupleValue_GetItem_Char(ani_tuple_value tuple_value, ani_size index, ani_char *result) + { + return c_api->TupleValue_GetItem_Char(this, tuple_value, index, result); + } + ani_status TupleValue_GetItem_Byte(ani_tuple_value tuple_value, ani_size index, ani_byte *result) + { + return c_api->TupleValue_GetItem_Byte(this, tuple_value, index, result); + } + ani_status TupleValue_GetItem_Short(ani_tuple_value tuple_value, ani_size index, ani_short *result) + { + return c_api->TupleValue_GetItem_Short(this, tuple_value, index, result); + } + ani_status TupleValue_GetItem_Int(ani_tuple_value tuple_value, ani_size index, ani_int *result) + { + return c_api->TupleValue_GetItem_Int(this, tuple_value, index, result); + } + ani_status TupleValue_GetItem_Long(ani_tuple_value tuple_value, ani_size index, ani_long *result) + { + return c_api->TupleValue_GetItem_Long(this, tuple_value, index, result); + } + ani_status TupleValue_GetItem_Float(ani_tuple_value tuple_value, ani_size index, ani_float *result) + { + return c_api->TupleValue_GetItem_Float(this, tuple_value, index, result); + } + ani_status TupleValue_GetItem_Double(ani_tuple_value tuple_value, ani_size index, ani_double *result) + { + return c_api->TupleValue_GetItem_Double(this, tuple_value, index, result); + } + ani_status TupleValue_GetItem_Ref(ani_tuple_value tuple_value, ani_size index, ani_ref *result) + { + return c_api->TupleValue_GetItem_Ref(this, tuple_value, index, result); + } + ani_status TupleValue_SetItem_Boolean(ani_tuple_value tuple_value, ani_size index, ani_boolean value) + { + return c_api->TupleValue_SetItem_Boolean(this, tuple_value, index, value); + } + ani_status TupleValue_SetItem_Char(ani_tuple_value tuple_value, ani_size index, ani_char value) + { + return c_api->TupleValue_SetItem_Char(this, tuple_value, index, value); + } + ani_status TupleValue_SetItem_Byte(ani_tuple_value tuple_value, ani_size index, ani_byte value) + { + return c_api->TupleValue_SetItem_Byte(this, tuple_value, index, value); + } + ani_status TupleValue_SetItem_Short(ani_tuple_value tuple_value, ani_size index, ani_short value) + { + return c_api->TupleValue_SetItem_Short(this, tuple_value, index, value); + } + ani_status TupleValue_SetItem_Int(ani_tuple_value tuple_value, ani_size index, ani_int value) + { + return c_api->TupleValue_SetItem_Int(this, tuple_value, index, value); + } + ani_status TupleValue_SetItem_Long(ani_tuple_value tuple_value, ani_size index, ani_long value) + { + return c_api->TupleValue_SetItem_Long(this, tuple_value, index, value); + } + ani_status TupleValue_SetItem_Float(ani_tuple_value tuple_value, ani_size index, ani_float value) + { + return c_api->TupleValue_SetItem_Float(this, tuple_value, index, value); + } + ani_status TupleValue_SetItem_Double(ani_tuple_value tuple_value, ani_size index, ani_double value) + { + return c_api->TupleValue_SetItem_Double(this, tuple_value, index, value); + } + ani_status TupleValue_SetItem_Ref(ani_tuple_value tuple_value, ani_size index, ani_ref value) + { + return c_api->TupleValue_SetItem_Ref(this, tuple_value, index, value); + } + ani_status GlobalReference_Create(ani_ref ref, ani_ref *result) + { + return c_api->GlobalReference_Create(this, ref, result); + } + ani_status GlobalReference_Delete(ani_ref ref) + { + return c_api->GlobalReference_Delete(this, ref); + } + ani_status WeakReference_Create(ani_ref ref, ani_wref *result) + { + return c_api->WeakReference_Create(this, ref, result); + } + ani_status WeakReference_Delete(ani_wref wref) + { + return c_api->WeakReference_Delete(this, wref); + } + ani_status WeakReference_GetReference(ani_wref wref, ani_boolean *was_released_result, ani_ref *ref_result) + { + return c_api->WeakReference_GetReference(this, wref, was_released_result, ref_result); + } + ani_status CreateArrayBuffer(size_t length, void **data_result, ani_arraybuffer *arraybuffer_result) + { + return c_api->CreateArrayBuffer(this, length, data_result, arraybuffer_result); + } + ani_status ArrayBuffer_GetInfo(ani_arraybuffer arraybuffer, void **data_result, size_t *length_result) + { + return c_api->ArrayBuffer_GetInfo(this, arraybuffer, data_result, length_result); + } + ani_status Promise_New(ani_resolver *result_resolver, ani_object *result_promise) + { + return c_api->Promise_New(this, result_resolver, result_promise); + } + ani_status PromiseResolver_Resolve(ani_resolver resolver, ani_ref resolution) + { + return c_api->PromiseResolver_Resolve(this, resolver, resolution); + } + ani_status PromiseResolver_Reject(ani_resolver resolver, ani_error rejection) + { + return c_api->PromiseResolver_Reject(this, resolver, rejection); + } + ani_status Any_InstanceOf(ani_ref ref, ani_ref type, ani_boolean *result) + { + return c_api->Any_InstanceOf(this, ref, type, result); + } + ani_status Any_GetProperty(ani_ref ref, const char *name, ani_ref *result) + { + return c_api->Any_GetProperty(this, ref, name, result); + } + ani_status Any_SetProperty(ani_ref ref, const char *name, ani_ref value) + { + return c_api->Any_SetProperty(this, ref, name, value); + } + ani_status Any_GetByIndex(ani_ref ref, ani_size index, ani_ref *result) + { + return c_api->Any_GetByIndex(this, ref, index, result); + } + ani_status Any_SetByIndex(ani_ref ref, ani_size index, ani_ref value) + { + return c_api->Any_SetByIndex(this, ref, index, value); + } + ani_status Any_GetByValue(ani_ref ref, ani_ref key, ani_ref *result) + { + return c_api->Any_GetByValue(this, ref, key, result); + } + ani_status Any_SetByValue(ani_ref ref, ani_ref key, ani_ref value) + { + return c_api->Any_SetByValue(this, ref, key, value); + } + ani_status Any_Call(ani_ref func, ani_size argc, ani_ref *argv, ani_ref *result) + { + return c_api->Any_Call(this, func, argc, argv, result); + } + ani_status Any_CallMethod(ani_ref self, const char *name, ani_size argc, ani_ref *argv, ani_ref *result) + { + return c_api->Any_CallMethod(this, self, name, argc, argv, result); + } + ani_status Any_New(ani_ref ctor, ani_size argc, ani_ref *argv, ani_ref *result) + { + return c_api->Any_New(this, ctor, argc, argv, result); + } + ani_status Class_BindStaticNativeMethods(ani_class cls, const ani_native_function *methods, ani_size nr_methods) + { + return c_api->Class_BindStaticNativeMethods(this, cls, methods, nr_methods); + } +#endif // __cplusplus +}; + +// NOLINTEND +#endif // __ANI_H__ diff --git a/ets1.2/interop/src/cpp/callback-resource.cc b/ets1.2/interop/src/cpp/callback-resource.cc new file mode 100644 index 0000000000000000000000000000000000000000..3c00d5925d453cb8207f035b2baa0b9dce4205c8 --- /dev/null +++ b/ets1.2/interop/src/cpp/callback-resource.cc @@ -0,0 +1,144 @@ +/* + * Copyright (c) 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. +*/ + +#undef KOALA_INTEROP_MODULE +#define KOALA_INTEROP_MODULE InteropNativeModule +#include "common-interop.h" +#include "interop-types.h" +#include "callback-resource.h" +#include "SerializerBase.h" +#include "interop-utils.h" +#include +#include +#include +#include + +static bool needReleaseFront = false; +static std::deque callbackEventsQueue; +static std::deque> callbackCallSubqueue; +static std::deque callbackResourceSubqueue; + +static std::atomic currentDeferred(nullptr); + +static KVMDeferred* takeCurrent(KNativePointer waitContext) { + KVMDeferred* current; + do { + current = currentDeferred.load(); + } while (!currentDeferred.compare_exchange_strong(current, nullptr)); + return current; +} + +void notifyWaiter() { + auto current = takeCurrent(nullptr); + if (current) + current->resolve(current, nullptr, 0); +} + +KVMObjectHandle impl_CallbackAwait(KVMContext vmContext, KNativePointer waitContext) { + KVMObjectHandle result = nullptr; + auto* current = takeCurrent(waitContext); + if (current) { + current->reject(current, "Wrong"); + } + auto next = CreateDeferred(vmContext, &result); + KVMDeferred* null = nullptr; + while (!currentDeferred.compare_exchange_strong(null, next)) {} + return result; +} +KOALA_INTEROP_CTX_1(CallbackAwait, KVMObjectHandle, KNativePointer) + +void impl_UnblockCallbackWait(KNativePointer waitContext) { + auto current = takeCurrent(waitContext); + if (current) current->resolve(current, nullptr, 0); +} +KOALA_INTEROP_V1(UnblockCallbackWait, KNativePointer) + +void enqueueCallback(int apiKind, const CallbackBuffer* event) { + callbackEventsQueue.push_back(Event_CallCallback); + callbackCallSubqueue.push_back({ apiKind, *event }); + notifyWaiter(); +} + +void holdManagedCallbackResource(InteropInt32 resourceId) { + callbackEventsQueue.push_back(Event_HoldManagedResource); + callbackResourceSubqueue.push_back(resourceId); + notifyWaiter(); +} + +void releaseManagedCallbackResource(InteropInt32 resourceId) { + callbackEventsQueue.push_back(Event_ReleaseManagedResource); + callbackResourceSubqueue.push_back(resourceId); + notifyWaiter(); +} + +KInt impl_CheckCallbackEvent(KSerializerBuffer buffer, KInt size) { + KByte* result = (KByte*)buffer; + if (needReleaseFront) + { + switch (callbackEventsQueue.front()) + { + case Event_CallCallback: + callbackCallSubqueue.front().second.resourceHolder.release(); + callbackCallSubqueue.pop_front(); + break; + case Event_HoldManagedResource: + case Event_ReleaseManagedResource: + callbackResourceSubqueue.pop_front(); + break; + default: + INTEROP_FATAL("Unknown event kind"); + } + callbackEventsQueue.pop_front(); + needReleaseFront = false; + } + if (callbackEventsQueue.empty()) { + return 0; + } + + SerializerBase serializer(result, size); + const CallbackEventKind frontEventKind = callbackEventsQueue.front(); + serializer.writeInt32(frontEventKind); + + switch (frontEventKind) + { + case Event_CallCallback: { + std::pair &callback = callbackCallSubqueue.front(); + serializer.writeInt32(callback.first); + interop_memcpy(result + serializer.length(), size - serializer.length(), callback.second.buffer, sizeof(CallbackBuffer::buffer)); + break; + } + case Event_HoldManagedResource: + case Event_ReleaseManagedResource: { + const InteropInt32 resourceId = callbackResourceSubqueue.front(); + interop_memcpy(result + serializer.length(), size - serializer.length(), &resourceId, sizeof(InteropInt32)); + break; + } + default: + INTEROP_FATAL("Unknown event kind"); + } + needReleaseFront = true; + return 1; +} +KOALA_INTEROP_DIRECT_2(CheckCallbackEvent, KInt, KSerializerBuffer, KInt) + +void impl_ReleaseCallbackResource(InteropInt32 resourceId) { + releaseManagedCallbackResource(resourceId); +} +KOALA_INTEROP_V1(ReleaseCallbackResource, KInt) + +void impl_HoldCallbackResource(InteropInt32 resourceId) { + holdManagedCallbackResource(resourceId); +} +KOALA_INTEROP_V1(HoldCallbackResource, KInt) diff --git a/ets1.2/interop/src/cpp/callback-resource.h b/ets1.2/interop/src/cpp/callback-resource.h new file mode 100644 index 0000000000000000000000000000000000000000..9e0b841962d9f1f9cf57dc7cdc2aca252990cf45 --- /dev/null +++ b/ets1.2/interop/src/cpp/callback-resource.h @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +#ifndef _INTEROP_CALLBACK_RESOURCE_H +#define _INTEROP_CALLBACK_RESOURCE_H + +#include +#include "interop-types.h" + +#ifdef KOALA_WINDOWS +#define DLL_EXPORT __declspec(dllexport) +#else +#define DLL_EXPORT __attribute__ ((visibility ("default"))) +#endif + +class CallbackResourceHolder { +private: + std::vector heldResources; +public: + void holdCallbackResource(const InteropCallbackResource* resource) { + resource->hold(resource->resourceId); + this->heldResources.push_back(*resource); + } + void release() { + for (auto resource : this->heldResources) { + resource.release(resource.resourceId); + } + this->heldResources.clear(); + } +}; + +struct CallbackBuffer { + uint8_t buffer[4096]; + CallbackResourceHolder resourceHolder; +}; + +enum CallbackEventKind { + Event_CallCallback = 0, + Event_HoldManagedResource = 1, + Event_ReleaseManagedResource = 2, +}; + +extern "C" DLL_EXPORT void enqueueCallback(int apiKind, const CallbackBuffer* event); +extern "C" DLL_EXPORT void holdManagedCallbackResource(InteropInt32 resourceId); +extern "C" DLL_EXPORT void releaseManagedCallbackResource(InteropInt32 resourceId); + +#endif diff --git a/ets1.2/interop/src/cpp/cangjie/convertors-cj.cc b/ets1.2/interop/src/cpp/cangjie/convertors-cj.cc new file mode 100644 index 0000000000000000000000000000000000000000..ebb0dac2fe62c664629e6124b04491a8da2393c8 --- /dev/null +++ b/ets1.2/interop/src/cpp/cangjie/convertors-cj.cc @@ -0,0 +1,14 @@ +/* + * Copyright (c) 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. +*/ \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/cangjie/convertors-cj.h b/ets1.2/interop/src/cpp/cangjie/convertors-cj.h new file mode 100644 index 0000000000000000000000000000000000000000..9611a0358488e0951df982957f888065b6fa3904 --- /dev/null +++ b/ets1.2/interop/src/cpp/cangjie/convertors-cj.h @@ -0,0 +1,943 @@ +/* + * 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. + */ + +#ifndef CONVERTORS_CJ_H +#define CONVERTORS_CJ_H + +#include +#include +#include +#include + +#include "koala-types.h" +#include "interop-logging.h" + +#define KOALA_INTEROP_EXPORT extern "C" + +#define MAKE_CJ_EXPORT(name, type, flag) \ + __attribute__((constructor)) \ + static void __init_ets_##name() { \ + CJExports::getInstance()->addImpl("_"#name, type, reinterpret_cast(Ark_##name), flag); \ + } + +class CJExports { + std::vector> implementations; + +public: + static CJExports* getInstance(); + + void addImpl(const char* name, const char* type, void* impl); + const std::vector>& getImpls() { + return implementations; + } +}; + +template +struct InteropTypeConverter { + using InteropType = T; + static inline T convertFrom(InteropType value) { return value; } + static inline InteropType convertTo(T value) { return value; } +}; + +template +inline T getArgument(typename InteropTypeConverter::InteropType arg) { + return InteropTypeConverter::convertFrom(arg); +} + +template +inline typename InteropTypeConverter::InteropType makeResult(T value) { + return InteropTypeConverter::convertTo(value); +} + +template<> +struct InteropTypeConverter { + using InteropType = KDouble; + static inline KInteropNumber convertFrom(InteropType value) { + return KInteropNumber::fromDouble(value); + } + static inline InteropType convertTo(KInteropNumber value) { + return value.asDouble(); + } +}; + +template<> +struct InteropTypeConverter { + using InteropType = char*; + static KStringPtr convertFrom(InteropType value) { + return KStringPtr(value); + } + static InteropType convertTo(const KStringPtr& value) { + return value.data(); + } +}; + +// Improve: Rewrite all others to typed convertors. + +#define KOALA_INTEROP_0(name, Ret) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name() { \ + KOALA_MAYBE_LOG(name) \ + return makeResult(impl_##name()); \ +} +// MAKE_CJ_EXPORT(name, #Ret, 0) + +#define KOALA_INTEROP_1(name, Ret, P0) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name(InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + return makeResult(impl_##name(p0)); \ +} +// MAKE_CJ_EXPORT(name, #Ret "|" #P0, 0) + +#define KOALA_INTEROP_2(name, Ret, P0, P1) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + return makeResult(impl_##name(p0, p1)); \ +} +// MAKE_CJ_EXPORT(name, #Ret "|" #P0 "|" #P1, 0) + +#define KOALA_INTEROP_3(name, Ret, P0, P1, P2) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + return makeResult(impl_##name(p0, p1, p2)); \ +} +// MAKE_CJ_EXPORT(name, #Ret "|" #P0 "|" #P1 "|" #P2, 0) + +#define KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + return makeResult(impl_##name(p0, p1, p2, p3)); \ +} +// MAKE_CJ_EXPORT(name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3, 0) + +#define KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4)); \ +} +// MAKE_CJ_EXPORT(name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4, 0) + +#define KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5)); \ +} +// MAKE_CJ_EXPORT(name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5, 0) + +#define KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6)); \ +} +// MAKE_CJ_EXPORT(name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6, 0) + +#define KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7)); \ +} +// MAKE_CJ_EXPORT(name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7, 0) + +#define KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8)); \ +} +// MAKE_CJ_EXPORT(name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8, 0) + +#define KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)); \ +} +// MAKE_CJ_EXPORT(name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9, 0) + +#define KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)); \ +} +// MAKE_CJ_EXPORT(name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10, 0) + +#define KOALA_INTEROP_12(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)); \ +} +// MAKE_CJ_EXPORT(name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11, 0) + +#define KOALA_INTEROP_13(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + P12 p12 = getArgument(_p12); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)); \ +} +// MAKE_CJ_EXPORT(name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12, 0) + +#define KOALA_INTEROP_14(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12, \ + InteropTypeConverter::InteropType _p13 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + P12 p12 = getArgument(_p12); \ + P13 p13 = getArgument(_p13); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)); \ +} +// MAKE_CJ_EXPORT(name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12 "|" #P13, 0) + +#define KOALA_INTEROP_V0(name) \ +KOALA_INTEROP_EXPORT void name() { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(); \ + return; \ +} + +#define KOALA_INTEROP_V1(name, P0) \ +KOALA_INTEROP_EXPORT void name(typename InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + impl_##name(p0); \ + return; \ +} + +#define KOALA_INTEROP_V2(name, P0, P1) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + impl_##name(p0, p1); \ + return; \ +} + +#define KOALA_INTEROP_V3(name, P0, P1, P2) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + impl_##name(p0, p1, p2); \ + return; \ +} + +#define KOALA_INTEROP_V4(name, P0, P1, P2, P3) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + impl_##name(p0, p1, p2, p3); \ + return; \ +} + +#define KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + impl_##name(p0, p1, p2, p3, p4); \ + return; \ +} + +#define KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + impl_##name(p0, p1, p2, p3, p4, p5); \ + return; \ +} + +#define KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5, \ + typename InteropTypeConverter::InteropType _p6 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6); \ + return; \ +} + +#define KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5, \ + typename InteropTypeConverter::InteropType _p6, \ + typename InteropTypeConverter::InteropType _p7 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7); \ + return; \ +} + +#define KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5, \ + typename InteropTypeConverter::InteropType _p6, \ + typename InteropTypeConverter::InteropType _p7, \ + typename InteropTypeConverter::InteropType _p8 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8); \ + return; \ +} + +#define KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5, \ + typename InteropTypeConverter::InteropType _p6, \ + typename InteropTypeConverter::InteropType _p7, \ + typename InteropTypeConverter::InteropType _p8, \ + typename InteropTypeConverter::InteropType _p9 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); \ + return; \ +} + +#define KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5, \ + typename InteropTypeConverter::InteropType _p6, \ + typename InteropTypeConverter::InteropType _p7, \ + typename InteropTypeConverter::InteropType _p8, \ + typename InteropTypeConverter::InteropType _p9, \ + typename InteropTypeConverter::InteropType _p10 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); \ + return; \ +} + +#define KOALA_INTEROP_V12(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5, \ + typename InteropTypeConverter::InteropType _p6, \ + typename InteropTypeConverter::InteropType _p7, \ + typename InteropTypeConverter::InteropType _p8, \ + typename InteropTypeConverter::InteropType _p9, \ + typename InteropTypeConverter::InteropType _p10, \ + typename InteropTypeConverter::InteropType _p11 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); \ + return; \ +} + +#define KOALA_INTEROP_V13(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5, \ + typename InteropTypeConverter::InteropType _p6, \ + typename InteropTypeConverter::InteropType _p7, \ + typename InteropTypeConverter::InteropType _p8, \ + typename InteropTypeConverter::InteropType _p9, \ + typename InteropTypeConverter::InteropType _p10, \ + typename InteropTypeConverter::InteropType _p11, \ + typename InteropTypeConverter::InteropType _p12 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + P12 p12 = getArgument(_p12); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); \ + return; \ +} + +#define KOALA_INTEROP_V14(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5, \ + typename InteropTypeConverter::InteropType _p6, \ + typename InteropTypeConverter::InteropType _p7, \ + typename InteropTypeConverter::InteropType _p8, \ + typename InteropTypeConverter::InteropType _p9, \ + typename InteropTypeConverter::InteropType _p10, \ + typename InteropTypeConverter::InteropType _p11, \ + typename InteropTypeConverter::InteropType _p12, \ + typename InteropTypeConverter::InteropType _p13 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + P12 p12 = getArgument(_p12); \ + P13 p13 = getArgument(_p13); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); \ + return; \ +} + +#define KOALA_INTEROP_CTX_0(name, Ret) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name() { \ + KOALA_MAYBE_LOG(name) \ + KVMContext ctx = (KVMContext)0; \ + return makeResult(impl_##name(ctx)); \ +} + +#define KOALA_INTEROP_CTX_1(name, Ret, P0) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name(InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + KVMContext ctx = (KVMContext)0; \ + return makeResult(impl_##name(ctx, p0)); \ +} + +#define KOALA_INTEROP_CTX_2(name, Ret, P0, P1) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name(InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + KVMContext ctx = (KVMContext)0; \ + return makeResult(impl_##name(ctx, p0, p1)); \ +} + + +#define KOALA_INTEROP_CTX_3(name, Ret, P0, P1, P2) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + KVMContext ctx = (KVMContext)0; \ + return makeResult(impl_##name(ctx, p0, p1, p2)); \ +} + +#define KOALA_INTEROP_CTX_4(name, Ret, P0, P1, P2, P3) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + KVMContext ctx = (KVMContext)0; \ + return makeResult(impl_##name(ctx, p0, p1, p2, p3)); \ +} + +#define KOALA_INTEROP_CTX_5(name, Ret, P0, P1, P2, P3, P4) \ +KOALA_INTEROP_EXPORT InteropTypeConverter::InteropType name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + KVMContext ctx = (KVMContext)0; \ + return makeResult(impl_##name(ctx, p0, p1, p2, p3, p4)); \ +} + +#define KOALA_INTEROP_CALL_INT(venv, id, length, args) \ +{ \ + int32_t rv = 0; \ + return rv; \ +} +#define KOALA_INTEROP_CALL_VOID(venv, id, length, args) \ +{ \ +} + + +#define KOALA_INTEROP_CALL_VOID_INTS32(venv, id, argc, args) KOALA_INTEROP_CALL_VOID(venv, id, (argc) * sizeof(int32_t), args) +#define KOALA_INTEROP_CALL_INT_INTS32(venv, id, argc, args) KOALA_INTEROP_CALL_INT(venv, id, (argc) * sizeof(int32_t), args) + + +#define KOALA_INTEROP_CTX_V1(name, P0) \ +KOALA_INTEROP_EXPORT void name(InteropTypeConverter::InteropType _p0) {\ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + impl_##name(nullptr, p0); \ +} + +#define KOALA_INTEROP_CTX_V2(name, P0, P1) \ +KOALA_INTEROP_EXPORT void name(InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + impl_##name(nullptr, p0, p1); \ +} + +#define KOALA_INTEROP_CTX_V3(name, P0, P1, P2) \ +KOALA_INTEROP_EXPORT void name(InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + impl_##name(nullptr, p0, p1, p2); \ +} + +#define KOALA_INTEROP_CTX_V4(name, P0, P1, P2, P3) \ +KOALA_INTEROP_EXPORT void name(InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + impl_##name(nullptr, p0, p1, p2, p3); \ +} + +#define KOALA_INTEROP_CTX_V5(name, P0, P1, P2, P3, P4) \ +KOALA_INTEROP_EXPORT void name(InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + impl_##name(nullptr, p0, p1, p2, p3, p4); \ +} + + #define KOALA_INTEROP_DIRECT_0(name, Ret) \ + KOALA_INTEROP_0(name, Ret) +#define KOALA_INTEROP_DIRECT_1(name, Ret, P0) \ + KOALA_INTEROP_1(name, Ret, P0) +#define KOALA_INTEROP_DIRECT_2(name, Ret, P0, P1) \ + KOALA_INTEROP_2(name, Ret, P0, P1) +#define KOALA_INTEROP_DIRECT_3(name, Ret, P0, P1, P2) \ + KOALA_INTEROP_3(name, Ret, P0, P1, P2) +#define KOALA_INTEROP_DIRECT_4(name, Ret, P0, P1, P2, P3) \ + KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) +#define KOALA_INTEROP_DIRECT_5(name, Ret, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) +#define KOALA_INTEROP_DIRECT_6(name, Ret, P0, P1, P2, P3, P4, P5) \ + KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) +#define KOALA_INTEROP_DIRECT_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) +#define KOALA_INTEROP_DIRECT_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) +#define KOALA_INTEROP_DIRECT_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) +#define KOALA_INTEROP_DIRECT_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) +#define KOALA_INTEROP_DIRECT_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) +#define KOALA_INTEROP_DIRECT_V0(name) \ + KOALA_INTEROP_V0(name) +#define KOALA_INTEROP_DIRECT_V1(name, P0) \ + KOALA_INTEROP_V1(name, P0) +#define KOALA_INTEROP_DIRECT_V2(name, P0, P1) \ + KOALA_INTEROP_V2(name, P0, P1) +#define KOALA_INTEROP_DIRECT_V3(name, P0, P1, P2) \ + KOALA_INTEROP_V3(name, P0, P1, P2) +#define KOALA_INTEROP_DIRECT_V4(name, P0, P1, P2, P3) \ + KOALA_INTEROP_V4(name, P0, P1, P2, P3) +#define KOALA_INTEROP_DIRECT_V5(name, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) +#define KOALA_INTEROP_DIRECT_V6(name, P0, P1, P2, P3, P4, P5) \ + KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) +#define KOALA_INTEROP_DIRECT_V7(name, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) +#define KOALA_INTEROP_DIRECT_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) +#define KOALA_INTEROP_DIRECT_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) +#define KOALA_INTEROP_DIRECT_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) +#define KOALA_INTEROP_DIRECT_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) + +#define KOALA_INTEROP_THROW(vmContext, object, ...) \ + do { \ + /* Improve: implement*/ ASSERT(false); \ + return __VA_ARGS__; \ + } while (0) + +#define KOALA_INTEROP_THROW_STRING(vmContext, message, ...) \ + do { \ + /* Improve: implement*/ ASSERT(false); \ + return __VA_ARGS__; \ + } while (0) + +#endif // CONVERTORS_CJ_H \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/common-interop.cc b/ets1.2/interop/src/cpp/common-interop.cc new file mode 100644 index 0000000000000000000000000000000000000000..7003f568e822951c9e31c1bde7d3f2be37ec61fd --- /dev/null +++ b/ets1.2/interop/src/cpp/common-interop.cc @@ -0,0 +1,781 @@ +/* + * 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 + +#ifndef KOALA_INTEROP_MEM_ANALYZER +#include +#endif + +#ifdef KOALA_INTEROP_MODULE +#undef KOALA_INTEROP_MODULE +#endif + +#define KOALA_INTEROP_MODULE InteropNativeModule +#include "common-interop.h" +#include "interop-logging.h" +#include "dynamic-loader.h" +#include "interop-utils.h" + +#ifdef KOALA_FOREIGN_NAPI +#ifndef KOALA_FOREIGN_NAPI_OHOS +#include +#else +#include +#include +#endif +#endif + +#if KOALA_INTEROP_PROFILER +#include "profiler.h" + +InteropProfiler* InteropProfiler::_instance = nullptr; + +#endif + +using std::string; + +#ifndef KOALA_INTEROP_MEM_ANALYZER +static std::atomic mallocCounter{0}; +#endif + +#if defined(KOALA_NAPI) || defined(KOALA_ANI) +// Callback dispatcher MOVED to convertors-napi.cc. +// Let's keep platform-specific parts of the code together + +typedef void (*hold_t)(KInt); + +KInteropBuffer impl_MaterializeBuffer(KNativePointer data, KLong length, KInt resourceId, KNativePointer holdPtr, KNativePointer releasePtr) { + auto hold = reinterpret_cast(holdPtr); + auto release = reinterpret_cast(releasePtr); + hold(resourceId); + return KInteropBuffer { length, data, resourceId, release }; +} +KOALA_INTEROP_5(MaterializeBuffer, KInteropBuffer, KNativePointer, KLong, KInt, KNativePointer, KNativePointer) + +KNativePointer impl_GetNativeBufferPointer(KInteropBuffer buffer) { + return buffer.data; +} +KOALA_INTEROP_1(GetNativeBufferPointer, KNativePointer, KInteropBuffer) + +#endif + +#ifdef KOALA_ETS_NAPI +#include "etsapi.h" + +static struct { + ets_class clazz = nullptr; + ets_method method = nullptr; +} g_koalaEtsNapiCallbackDispatcher; + +bool setKoalaEtsNapiCallbackDispatcher( + EtsEnv* etsEnv, + ets_class clazz, + const char* dispatcherMethodName, + const char* dispactherMethodSig +) { + g_koalaEtsNapiCallbackDispatcher.clazz = clazz; + etsEnv->NewGlobalRef(clazz); + ets_method method = etsEnv->GetStaticp_method( + clazz, dispatcherMethodName, dispactherMethodSig + ); + if (method == nullptr) { + return false; + } + g_koalaEtsNapiCallbackDispatcher.method = method; + return true; +} + +void getKoalaEtsNapiCallbackDispatcher(ets_class* clazz, ets_method* method) { + *clazz = g_koalaEtsNapiCallbackDispatcher.clazz; + *method = g_koalaEtsNapiCallbackDispatcher.method; +} +#endif + + +// Improve: move callback dispetchers to convertors-.cc. +#ifdef KOALA_JNI +#include "jni.h" +static struct { + jclass clazz = nullptr; + jmethodID method = nullptr; +} g_koalaJniCallbackDispatcher; + +bool setKoalaJniCallbackDispatcher( + JNIEnv* jniEnv, + jclass clazz, + const char* dispatcherMethodName, + const char* dispactherMethodSig +) { + g_koalaJniCallbackDispatcher.clazz = clazz; + jniEnv->NewGlobalRef(clazz); + jmethodID method = jniEnv->GetStaticMethodID( + clazz, dispatcherMethodName, dispactherMethodSig + ); + if (method == nullptr) { + return false; + } + g_koalaJniCallbackDispatcher.method = method; + return true; +} + +void getKoalaJniCallbackDispatcher(jclass* clazz, jmethodID* method) { + *clazz = g_koalaJniCallbackDispatcher.clazz; + *method = g_koalaJniCallbackDispatcher.method; +} +#endif + +KInt impl_StringLength(KNativePointer ptr) { + string* s = reinterpret_cast(ptr); + return s->length(); +} +KOALA_INTEROP_1(StringLength, KInt, KNativePointer) + +void impl_StringData(KNativePointer ptr, KByte* bytes, KInt size) { + string* s = reinterpret_cast(ptr); + if (s) { + interop_memcpy(bytes, size, s->c_str(), size); + } +} +KOALA_INTEROP_V3(StringData, KNativePointer, KByte*, KInt) + + +#ifdef KOALA_JNI +// For Java only yet. +KInteropBuffer impl_StringDataBytes(KVMContext vmContext, KNativePointer ptr) { + string* s = reinterpret_cast(ptr); + KInteropBuffer result = { (int32_t)s->length(), (void*)s->c_str()}; + return result; +} +KOALA_INTEROP_CTX_1(StringDataBytes, KInteropBuffer, KNativePointer) +#endif + +KNativePointer impl_StringMake(const KStringPtr& str) { + return new string(str.c_str()); +} +KOALA_INTEROP_1(StringMake, KNativePointer, KStringPtr) + +// For slow runtimes w/o fast encoders. +KInt impl_ManagedStringWrite(const KStringPtr& string, KSerializerBuffer buffer, KInt bufferSize, KInt offset) { + interop_memcpy((uint8_t*)buffer + offset, bufferSize, string.c_str(), string.length() + 1); + return string.length() + 1; +} +KOALA_INTEROP_4(ManagedStringWrite, KInt, KStringPtr, KSerializerBuffer, KInt, KInt) + +void stringFinalizer(string* ptr) { + delete ptr; +} +KNativePointer impl_GetStringFinalizer() { + return fnPtr(stringFinalizer); +} +KOALA_INTEROP_0(GetStringFinalizer, KNativePointer) + +void impl_InvokeFinalizer(KNativePointer obj, KNativePointer finalizer) { + auto finalizer_f = reinterpret_cast(finalizer); + finalizer_f(obj); +} +KOALA_INTEROP_V2(InvokeFinalizer, KNativePointer, KNativePointer) + +KInt impl_GetPtrVectorSize(KNativePointer ptr) { + return reinterpret_cast*>(ptr)->size(); +} +KOALA_INTEROP_1(GetPtrVectorSize, KInt, KNativePointer) + +KNativePointer impl_GetPtrVectorElement(KNativePointer ptr, KInt index) { + auto vector = reinterpret_cast*>(ptr); + auto element = vector->at(index); + return nativePtr(element); +} +KOALA_INTEROP_2(GetPtrVectorElement, KNativePointer, KNativePointer, KInt) + +inline KUInt unpackUInt(const KByte* bytes) { + return (bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24)); +} + +KNativePointer impl_GetGroupedLog(KInt index) { + return new std::string(GetDefaultLogger()->getGroupedLog(index)); +} +KOALA_INTEROP_1(GetGroupedLog, KNativePointer, KInt) + +void impl_StartGroupedLog(KInt index) { + GetDefaultLogger()->startGroupedLog(index); +} +KOALA_INTEROP_V1(StartGroupedLog, KInt) + +void impl_StopGroupedLog(KInt index) { + GetDefaultLogger()->stopGroupedLog(index); +} +KOALA_INTEROP_V1(StopGroupedLog, KInt) + +void impl_AppendGroupedLog(KInt index, const KStringPtr& message) { + if (GetDefaultLogger()->needGroupedLog(index)) + GetDefaultLogger()->appendGroupedLog(index, message.c_str()); +} +KOALA_INTEROP_V2(AppendGroupedLog, KInt, KStringPtr) + +void impl_PrintGroupedLog(KInt index) { +#ifdef KOALA_OHOS + LOGI("%" LOG_PUBLIC "s", GetDefaultLogger()->getGroupedLog(index)); +#else + fprintf(stdout, "%s\n", GetDefaultLogger()->getGroupedLog(index)); + fflush(stdout); +#endif +} +KOALA_INTEROP_V1(PrintGroupedLog, KInt) + +int32_t callCallback(KVMContext context, int32_t methodId, uint8_t* argsData, int32_t argsLength) { +#if KOALA_USE_NODE_VM || KOALA_USE_HZ_VM || KOALA_USE_PANDA_VM || KOALA_USE_JAVA_VM || KOALA_CJ + KOALA_INTEROP_CALL_INT(context, methodId, argsLength, argsData); + return 0; +#else + return 0; +#endif +} + +struct ForeignVMContext { + KVMContext vmContext; + int32_t (*callSync)(KVMContext vmContext, int32_t callback, uint8_t* data, int32_t length); +}; +typedef KInt (*LoadVirtualMachine_t)(KInt vmKind, const char* bootFiles, const char* userFiles, const char* libraryPath, const struct ForeignVMContext* foreignVM); +typedef KNativePointer (*StartApplication_t)(const char* appUrl, const char* appParams, int32_t loopIterationr); +typedef KBoolean (*RunApplication_t)(const KInt arg0, const KInt arg1); +typedef const char* (*EmitEvent_t)(const KInt type, const KInt target, const KInt arg0, const KInt arg1); +typedef void (*RestartWith_t)(const char* page); +typedef const char* (*LoadView_t)(const char* className, const char* params); + +void* getImpl(const char* path, const char* name) { + static void* lib = nullptr; + if (!lib && name) { + auto name = +#ifndef KOALA_OHOS // dlopen on OHOS doesn't like paths + std::string(path) + "/" + +#endif + libName("vmloader"); + lib = loadLibrary(name); + if (!lib) { + fprintf(stderr, "Ensure vmloader library %s was built\n", name.c_str()); + } + } + return findSymbol(lib, name); +} + +KInt impl_LoadVirtualMachine(KVMContext vmContext, KInt vmKind, const KStringPtr& bootFiles, const KStringPtr& userFiles, const KStringPtr& libraryPath) { + const char* envClassPath = std::getenv("PANDA_CLASS_PATH"); + if (envClassPath) { + LOGI("CLASS PATH updated from env var PANDA_CLASS_PATH, %" LOG_PUBLIC "s", envClassPath); + } + const char* bootFilesPath = envClassPath ? envClassPath : bootFiles.c_str(); + const char* nativeLibPath = envClassPath ? envClassPath : libraryPath.c_str(); + + static LoadVirtualMachine_t impl = nullptr; + if (!impl) impl = reinterpret_cast(getImpl(nativeLibPath, "LoadVirtualMachine")); + if (!impl) KOALA_INTEROP_THROW_STRING(vmContext, "Cannot load VM", -1); + const ForeignVMContext foreignVM = { + vmContext, &callCallback + }; + return impl(vmKind, bootFilesPath, userFiles.c_str(), nativeLibPath, &foreignVM); +} +KOALA_INTEROP_CTX_4(LoadVirtualMachine, KInt, KInt, KStringPtr, KStringPtr, KStringPtr) + +KNativePointer impl_StartApplication(const KStringPtr& appUrl, const KStringPtr& appParams, KInt loopIterations) { + static StartApplication_t impl = nullptr; + if (!impl) impl = reinterpret_cast(getImpl(nullptr, "StartApplication")); + return impl(appUrl.c_str(), appParams.c_str(), loopIterations); +} +KOALA_INTEROP_3(StartApplication, KNativePointer, KStringPtr, KStringPtr, KInt) + +KBoolean impl_RunApplication(const KInt arg0, const KInt arg1) { + static RunApplication_t impl = nullptr; + if (!impl) impl = reinterpret_cast(getImpl(nullptr, "RunApplication")); + return impl(arg0, arg1); +} +KOALA_INTEROP_2(RunApplication, KBoolean, KInt, KInt) + +KStringPtr impl_EmitEvent(KVMContext vmContext, KInt type, KInt target, KInt arg0, KInt arg1) { + static EmitEvent_t impl = nullptr; + if (!impl) impl = reinterpret_cast(getImpl(nullptr, "EmitEvent")); + const char* out = impl(type, target, arg0, arg1); + auto size = std::string(out).size(); + KStringPtr result(out, size, true); + return result; +} +KOALA_INTEROP_CTX_4(EmitEvent, KStringPtr, KInt, KInt, KInt, KInt) + +void impl_RestartWith(const KStringPtr& page) { + static RestartWith_t impl = nullptr; + if (!impl) impl = reinterpret_cast(getImpl(nullptr, "RestartWith")); + impl(page.c_str()); +} +KOALA_INTEROP_V1(RestartWith, KStringPtr) + +#ifdef KOALA_ANI +KStringPtr impl_LoadView(const KStringPtr& className, const KStringPtr& params) { + static LoadView_t impl = nullptr; + if (!impl) impl = reinterpret_cast(getImpl(nullptr, "LoadView")); + const char* result = impl(className.c_str(), params.c_str()); + return KStringPtr(result, interop_strlen(result), true); +} +KOALA_INTEROP_2(LoadView, KStringPtr, KStringPtr, KStringPtr) +#endif // KOALA_ANI + +KNativePointer impl_Malloc(KLong length) { + const auto ptr = static_cast(malloc(length)); + if (ptr == nullptr) { + INTEROP_FATAL("Memory allocation failed!"); + } +#ifndef KOALA_INTEROP_MEM_ANALYZER + mallocCounter.fetch_add(1, std::memory_order_release); +#endif + return ptr; +} +KOALA_INTEROP_DIRECT_1(Malloc, KNativePointer, KLong) + +void malloc_finalize(KNativePointer data) { + if (data) { + free(data); +#ifndef KOALA_INTEROP_MEM_ANALYZER + if (mallocCounter.fetch_sub(1, std::memory_order_release) == 0) { + INTEROP_FATAL("Double-free detected!"); + } +#endif + } +} + +KNativePointer impl_GetMallocFinalizer() { + return reinterpret_cast(malloc_finalize); +} +KOALA_INTEROP_DIRECT_0(GetMallocFinalizer, KNativePointer) + +void impl_Free(KNativePointer data) { + malloc_finalize(data); +} +KOALA_INTEROP_DIRECT_V1(Free, KNativePointer) + +KInt impl_ReadByte(KNativePointer data, KLong index, KLong length) { + if (index >= length) INTEROP_FATAL("impl_ReadByte: index %lld is equal or greater than length %lld", (long long)index, (long long) length); + uint8_t* ptr = reinterpret_cast(data); + return ptr[index]; +} +KOALA_INTEROP_DIRECT_3(ReadByte, KInt, KNativePointer, KLong, KLong) + +void impl_WriteByte(KNativePointer data, KInt index, KLong length, KInt value) { + if (index >= length) INTEROP_FATAL("impl_WriteByte: index %lld is equal or greater than length %lld", (long long)index, (long long) length); + uint8_t* ptr = reinterpret_cast(data); + ptr[index] = value; +} +KOALA_INTEROP_DIRECT_V4(WriteByte, KNativePointer, KLong, KLong, KInt) + +void impl_CopyArray(KNativePointer data, KLong length, KByte* array) { + if (!array || !data) { + INTEROP_FATAL("CopyArray called with incorrect nullptr args (array, data):(%p, %p)", array, data); + } + + interop_memcpy(data, length, array, length); +} +KOALA_INTEROP_V3(CopyArray, KNativePointer, KLong, KByte*) + +static const int API_KIND_MAX = 100; +static Callback_Caller_t g_callbackCaller[API_KIND_MAX] = { 0 }; +static Callback_Caller_Sync_t g_callbackCallerSync[API_KIND_MAX] = { 0 }; + +#define CHECK_VALID_API_KIND(apiKind) \ + if (apiKind < 0 || apiKind > API_KIND_MAX) \ + INTEROP_FATAL("Maximum api kind is %d, received %d", API_KIND_MAX, apiKind); +#define CHECK_HAS_CALLBACK_CALLER(apiKind, callbackCallers) \ + CHECK_VALID_API_KIND(apiKind); \ + if (callbackCallers[apiKind] == nullptr) \ + INTEROP_FATAL("Callback caller for api kind %d was not set", apiKind) +#define CHECK_HAS_NOT_CALLBACK_CALLER(apiKind, callbackCallers) \ + CHECK_VALID_API_KIND(apiKind); \ + if (callbackCallers[apiKind] != nullptr) \ + INTEROP_FATAL("Callback caller for api kind %d already was set", apiKind); + +void setCallbackCaller(int apiKind, Callback_Caller_t callbackCaller) { + CHECK_HAS_NOT_CALLBACK_CALLER(apiKind, g_callbackCaller); + g_callbackCaller[apiKind] = callbackCaller; +} + +void impl_CallCallback(KInt apiKind, KInt callbackKind, KSerializerBuffer args, KInt argsSize) { + CHECK_HAS_CALLBACK_CALLER(apiKind, g_callbackCaller); + g_callbackCaller[apiKind](callbackKind, args, argsSize); +} +KOALA_INTEROP_V4(CallCallback, KInt, KInt, KSerializerBuffer, KInt) + +void setCallbackCallerSync(int apiKind, Callback_Caller_Sync_t callbackCallerSync) { + CHECK_HAS_NOT_CALLBACK_CALLER(apiKind, g_callbackCallerSync); + g_callbackCallerSync[apiKind] = callbackCallerSync; +} + +void impl_CallCallbackSync(KVMContext vmContext, KInt apiKind, KInt callbackKind, KSerializerBuffer args, KInt argsSize) { + CHECK_HAS_CALLBACK_CALLER(apiKind, g_callbackCallerSync); + g_callbackCallerSync[apiKind](vmContext, callbackKind, args, argsSize); +} +KOALA_INTEROP_CTX_V4(CallCallbackSync, KInt, KInt, KSerializerBuffer, KInt) + +void impl_CallCallbackResourceHolder(KNativePointer holder, KInt resourceId) { + reinterpret_cast(holder)(resourceId); +} +KOALA_INTEROP_V2(CallCallbackResourceHolder, KNativePointer, KInt) + +void impl_CallCallbackResourceReleaser(KNativePointer releaser, KInt resourceId) { + reinterpret_cast(releaser)(resourceId); +} +KOALA_INTEROP_V2(CallCallbackResourceReleaser, KNativePointer, KInt) + +KInt impl_CallForeignVM(KNativePointer foreignContextRaw, KInt function, KSerializerBuffer data, KInt length) { + const ForeignVMContext* foreignContext = (const ForeignVMContext*)foreignContextRaw; + // Improve: set actuall callbacks caller/holder/releaser. + /* + *(int64_t*)(data + 8) = impl_CallCallbackSync; + *(int64_t*)(data + 16) = 0; + *(int64_t*)(data + 24) = 0; */ + return foreignContext->callSync(foreignContext->vmContext, function, reinterpret_cast(data), length); +} +KOALA_INTEROP_4(CallForeignVM, KInt, KNativePointer, KInt, KSerializerBuffer, KInt) + +#ifdef KOALA_FOREIGN_NAPI +KVMContext g_foreignVMContext = nullptr; +#endif +void impl_SetForeignVMContext(KNativePointer foreignVMContextRaw) { +#ifdef KOALA_FOREIGN_NAPI + if (foreignVMContextRaw == nullptr) { + g_foreignVMContext = nullptr; + } else { + auto foreignContext = (const ForeignVMContext*)foreignVMContextRaw; + g_foreignVMContext = foreignContext->vmContext; + } +#endif + + /* supress unused private fields */ + (void)foreignVMContextRaw; +} +KOALA_INTEROP_V1(SetForeignVMContext, KNativePointer) + +#ifndef __QUOTE + #define __QUOTE(x) #x +#endif + +#define QUOTE(x) __QUOTE(x) + +void impl_NativeLog(const KStringPtr& str) { +#ifdef KOALA_OHOS + LOGI("%{public}s: %{public}s", QUOTE(INTEROP_LIBRARY_NAME), str.c_str()); +#else + fprintf(stdout, "%s: %s\n", QUOTE(INTEROP_LIBRARY_NAME), str.c_str()); + fflush(stdout); +#endif +} +KOALA_INTEROP_V1(NativeLog, KStringPtr) + +void resolveDeferred(KVMDeferred* deferred, uint8_t* argsData, int32_t argsLength) { +#ifdef KOALA_NAPI + auto status = napi_call_threadsafe_function((napi_threadsafe_function)deferred->handler, deferred, napi_tsfn_nonblocking); + if (status != napi_ok) LOGE("cannot call thread-safe function; status=%d", status); + if (deferred->handler) { + napi_release_threadsafe_function((napi_threadsafe_function)deferred->handler, napi_tsfn_release); + deferred->handler = nullptr; + } +#endif +#ifdef KOALA_ANI + ani_vm* vm = (ani_vm*)deferred->context; + ani_env* env = nullptr; + ani_status status = vm->GetEnv(ANI_VERSION_1, &env); + if (env == nullptr || status != ANI_OK) { + status = vm->AttachCurrentThread(nullptr, ANI_VERSION_1, &env); + CHECK_ANI_FATAL(status); + } + ani_ref undef = nullptr; + status = env->GetUndefined(&undef); + CHECK_ANI_FATAL(status); + status = env->PromiseResolver_Resolve((ani_resolver)deferred->handler, undef); + CHECK_ANI_FATAL(status); +#endif +} + +void rejectDeferred(KVMDeferred* deferred, const char* message) { +#ifdef KOALA_NAPI + if (deferred->handler) { + napi_release_threadsafe_function((napi_threadsafe_function)deferred->handler, napi_tsfn_release); + deferred->handler = nullptr; + } +#endif +#ifdef KOALA_ANI + if (deferred->handler) { + ani_vm* vm = (ani_vm*)deferred->context; + ani_env* env = nullptr; + ani_status status = vm->GetEnv(ANI_VERSION_1, &env); + if (env == nullptr || status != ANI_OK) { + status = vm->AttachCurrentThread(nullptr, ANI_VERSION_1, &env); + CHECK_ANI_FATAL(status); + } + status = env->PromiseResolver_Reject((ani_resolver)deferred->handler, nullptr); + CHECK_ANI_FATAL(status); + deferred->handler = nullptr; + } +#endif + +} + +#ifdef KOALA_NAPI +void resolveDeferredImpl(napi_env env, napi_value js_callback, KVMDeferred* deferred, void* data) { + napi_value undefined = nullptr; + napi_get_undefined(env, &undefined); + auto status = napi_resolve_deferred(env, (napi_deferred)deferred->context, undefined); + if (status != napi_ok) LOGE("cannot resolve deferred; status=%d", status); + delete deferred; +} +#endif + +KVMDeferred* CreateDeferred(KVMContext vmContext, KVMObjectHandle* promiseHandle) { + KVMDeferred* deferred = new KVMDeferred(); + deferred->resolve = resolveDeferred; + deferred->reject = rejectDeferred; +#ifdef KOALA_NAPI + // Improve: move to interop! + napi_env env = (napi_env)vmContext; + napi_value promise; + napi_value resourceName; + napi_create_string_utf8(env, "Async", 5, &resourceName); + auto status = napi_create_promise(env, (napi_deferred*)&deferred->context, &promise); + if (status != napi_ok) LOGE("cannot make a promise; status=%d", status); + status = napi_create_threadsafe_function(env, + nullptr, + nullptr, + resourceName, + 0, + 1, + nullptr, + nullptr, + deferred, + (napi_threadsafe_function_call_js)resolveDeferredImpl, + (napi_threadsafe_function*)&deferred->handler); + if (status != napi_ok) LOGE("cannot make threadsafe function; status=%d", status); + *promiseHandle = (KVMObjectHandle)promise; +#endif +#ifdef KOALA_ANI + ani_env* env = (ani_env*)vmContext; + ani_object promise = nullptr; + ani_resolver resolver = nullptr; + ani_status status = env->Promise_New(&resolver, &promise); + deferred->handler = resolver; + CHECK_ANI_FATAL(status); + *promiseHandle = (KVMObjectHandle)promise; + ani_vm* vm = nullptr; + status = env->GetVM(&vm); + CHECK_ANI_FATAL(status); + deferred->context = vm; +#endif + return deferred; +} + +class KoalaWork { +protected: + InteropVMContext vmContext; +#ifdef KOALA_FOREIGN_NAPI + KVMContext foreignVMContext; +#endif + void* vmWork; + void* handle; + void (*execute)(void* handle); + void (*complete)(void* handle); +public: + KoalaWork(InteropVMContext vmContext, + InteropNativePointer handle, + void (*execute)(InteropNativePointer handle), + void (*complete)(InteropNativePointer handle)); + void Queue(); + void Execute(); + void Cancel(); + void Complete(); +}; +static void DoQueue(void* handle) { + ((KoalaWork*)handle)->Queue(); +} +static void DoCancel(void* handle) { + ((KoalaWork*)handle)->Cancel(); +} + +InteropAsyncWork koalaCreateWork( + InteropVMContext vmContext, + InteropNativePointer handle, + void (*execute)(InteropNativePointer handle), + void (*complete)(InteropNativePointer handle) +) { + return { + new KoalaWork(vmContext, handle, execute, complete), + DoQueue, + DoCancel, + }; +} + +const InteropAsyncWorker* GetAsyncWorker() { + static InteropAsyncWorker worker = { + koalaCreateWork + }; + return &worker; +} + +#if defined(KOALA_NAPI) +static void DoExecute(napi_env env, void* handle) { + ((KoalaWork*)handle)->Execute(); +} +static void DoComplete(napi_env env, napi_status status, void* handle) { + ((KoalaWork*)handle)->Complete(); +} +KoalaWork::KoalaWork(InteropVMContext vmContext, + InteropNativePointer handle, + void (*execute)(InteropNativePointer handle), + void (*complete)(InteropNativePointer handle) +): vmContext(vmContext), handle(handle), execute(execute), complete(complete) { + napi_env env = (napi_env)vmContext; + napi_value resourceName = nullptr; + napi_create_string_utf8(env, "KoalaAsyncOperation", NAPI_AUTO_LENGTH, &resourceName); + napi_create_async_work(env, nullptr, resourceName, DoExecute, DoComplete, this, (napi_async_work*)&vmWork); + /* supress unused private fields */ + (void)vmContext; + (void)vmWork; +} +void KoalaWork::Queue() { + napi_env env = (napi_env)vmContext; + napi_queue_async_work(env, (napi_async_work)vmWork); +} +void KoalaWork::Execute() { + execute(handle); +} +void KoalaWork::Cancel() { + napi_env env = (napi_env)vmContext; + napi_cancel_async_work(env, (napi_async_work)vmWork); +} +void KoalaWork::Complete() { + complete(handle); + delete this; +} +#else +#ifdef KOALA_FOREIGN_NAPI +static void DoExecute(napi_env env, void* handle) { + ((KoalaWork*)handle)->Execute(); +} +static void DoComplete(napi_env env, napi_status status, void* handle) { + ((KoalaWork*)handle)->Complete(); +} +#endif +KoalaWork::KoalaWork(InteropVMContext vmContext, + InteropNativePointer handle, + void (*execute)(InteropNativePointer handle), + void (*complete)(InteropNativePointer handle) +): vmContext(vmContext), handle(handle), execute(execute), complete(complete) { +#ifdef KOALA_FOREIGN_NAPI + if (g_foreignVMContext == nullptr) + INTEROP_FATAL("Can not launch async work while foreign VM context is not available. Please ensure you have called SetForeignVMContext"); + foreignVMContext = g_foreignVMContext; + napi_env env = (napi_env)foreignVMContext; + napi_value resourceName = nullptr; + napi_create_string_utf8(env, "KoalaAsyncOperation", NAPI_AUTO_LENGTH, &resourceName); + napi_create_async_work(env, nullptr, resourceName, DoExecute, DoComplete, this, (napi_async_work*)&vmWork); +#endif + /* supress unused private fields */ + (void)vmContext; + (void)vmWork; +} +void KoalaWork::Queue() { +#ifdef KOALA_FOREIGN_NAPI + napi_env env = (napi_env)foreignVMContext; + napi_queue_async_work(env, (napi_async_work)vmWork); +#else + Execute(); + Complete(); +#endif +} +void KoalaWork::Execute() { + execute(handle); +} +void KoalaWork::Cancel() { +#ifdef KOALA_FOREIGN_NAPI + napi_env env = (napi_env)foreignVMContext; + napi_cancel_async_work(env, (napi_async_work)vmWork); +#else + INTEROP_FATAL("Cancelling async work is disabled for any VM except of Node"); +#endif +} +void KoalaWork::Complete() { + complete(handle); + delete this; +} +#endif + + +#if defined(KOALA_ETS_NAPI) || defined(KOALA_ANI) +KStringPtr impl_Utf8ToString(KVMContext vmContext, KNativePointer data, KInt offset, KInt length) { + KStringPtr result((const char*)data + offset, length, false); + return result; +} +KOALA_INTEROP_CTX_3(Utf8ToString, KStringPtr, KNativePointer, KInt, KInt) +#elif defined(KOALA_NAPI) || defined(KOALA_JNI) || defined(KOALA_CJ) +// Allocate, so CTX versions. +KStringPtr impl_Utf8ToString(KVMContext vmContext, KByte* data, KInt offset, KInt length) { + KStringPtr result((const char*)(data + offset), length, false); + return result; +} +KOALA_INTEROP_CTX_3(Utf8ToString, KStringPtr, KByte*, KInt, KInt) +#endif + +#if defined(KOALA_NAPI) || defined(KOALA_ANI) +KStringPtr impl_RawUtf8ToString(KVMContext vmContext, KNativePointer data) { + auto string = (const char*)data; + KStringPtr result(string, interop_strlen(string), false); + return result; +} +KOALA_INTEROP_CTX_1(RawUtf8ToString, KStringPtr, KNativePointer) +#endif + +#if defined(KOALA_NAPI) || defined(KOALA_JNI) || defined(KOALA_CJ) || defined(KOALA_ETS_NAPI) || defined(KOALA_ANI) || defined(KOALA_KOTLIN) +KStringPtr impl_StdStringToString(KVMContext vmContext, KNativePointer stringPtr) { + std::string* string = reinterpret_cast(stringPtr); + KStringPtr result(string->c_str(), string->size(), false); + return result; +} +KOALA_INTEROP_CTX_1(StdStringToString, KStringPtr, KNativePointer) + +KInteropReturnBuffer impl_RawReturnData(KVMContext vmContext, KInt v1, KInt v2) { + void* data = new int8_t[v1]; + interop_memset(data, v1, v2, v1); + KInteropReturnBuffer buffer = { v1, data, [](KNativePointer ptr, KInt) { delete[] (int8_t*)ptr; }}; + return buffer; +} +KOALA_INTEROP_CTX_2(RawReturnData, KInteropReturnBuffer, KInt, KInt) + +KInteropNumber impl_IncrementNumber(KInteropNumber number) { + if (number.tag == 102) + number.i32++; + else + number.f32 += 1.f; + return number; +} +KOALA_INTEROP_1(IncrementNumber, KInteropNumber, KInteropNumber) + +void impl_ReportMemLeaks() { +#ifndef KOALA_INTEROP_MEM_ANALYZER + const auto count = mallocCounter.load(std::memory_order_acquire); + if (count > 0) { + fprintf(stderr, "Memory leaks detected: %d blocks\n", count); + } else { + fprintf(stderr, "No memory leaks\n"); + } +#endif +} +KOALA_INTEROP_V0(ReportMemLeaks) + +#endif \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/common-interop.h b/ets1.2/interop/src/cpp/common-interop.h new file mode 100644 index 0000000000000000000000000000000000000000..1d106656c281928c57c2b9b99df5b5b3853df342 --- /dev/null +++ b/ets1.2/interop/src/cpp/common-interop.h @@ -0,0 +1,77 @@ +/* + * 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. + */ + +#ifndef COMMON_INTEROP_BASE_H +#define COMMON_INTEROP_BASE_H + +#include + +#include "koala-types.h" + +#define KOALA_INTEROP_PROFILER 0 +#define KOALA_INTEROP_TRACER 0 + +#if KOALA_INTEROP_PROFILER +#include "profiler.h" +#define KOALA_INTEROP_LOGGER(name) InteropMethodCall logger(#name); +#endif + +#if KOALA_INTEROP_TRACER +#include "tracer.h" +#define KOALA_INTEROP_LOGGER(name) InteropMethodCall logger(#name); +#endif + + +#ifdef KOALA_INTEROP_LOGGER +#define KOALA_MAYBE_LOG(name) KOALA_INTEROP_LOGGER(name); +#else +#define KOALA_MAYBE_LOG(name) +#endif + +#ifdef KOALA_WINDOWS +#define DLL_EXPORT __declspec(dllexport) +#else +#define DLL_EXPORT __attribute__ ((visibility ("default"))) +#endif + +typedef void (*Callback_Caller_t)(KInt callbackKind, KSerializerBuffer argsData, KInt argsLength); +typedef void (*Callback_Caller_Sync_t)(KVMContext vmContext, KInt callbackKind, KSerializerBuffer argsData, KInt argsLength); +extern "C" DLL_EXPORT void setCallbackCaller(int apiKind, Callback_Caller_t caller); +extern "C" DLL_EXPORT void setCallbackCallerSync(int apiKind, Callback_Caller_Sync_t callerSync); + +extern "C" DLL_EXPORT KVMDeferred* CreateDeferred(KVMContext context, KVMObjectHandle* promise); +extern "C" DLL_EXPORT const InteropAsyncWorker* GetAsyncWorker(); + +#if KOALA_USE_NODE_VM || KOALA_USE_HZ_VM +#include "convertors-napi.h" +#elif KOALA_USE_JSC_VM +#include "convertors-jsc.h" +#elif KOALA_ETS_NAPI +#include "convertors-ets.h" +#elif KOALA_USE_JAVA_VM +#include "convertors-jni.h" +#elif KOALA_WASM +#include "convertors-wasm.h" +#elif KOALA_CJ +#include "convertors-cj.h" +#elif KOALA_ANI +#include "convertors-ani.h" +#elif KOALA_KOTLIN +#include "convertors-kotlin.h" +#else +#error "One of above branches must be taken" +#endif + +#endif // COMMON_INTEROP_BASE_H diff --git a/ets1.2/interop/src/cpp/crashdump.h b/ets1.2/interop/src/cpp/crashdump.h new file mode 100644 index 0000000000000000000000000000000000000000..128f7ba61715fd378f73511dede93f01cd38b7ec --- /dev/null +++ b/ets1.2/interop/src/cpp/crashdump.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 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. + */ + +#ifndef _INTEROP_CRASHDUMP_H +#define _INTEROP_CRASHDUMP_H + +#ifdef KOALA_LINUX +#include +#include + +sighandler_t oldCrashHandler = nullptr; + +static void onCrashHandler(int signo) { + void* stack[20]; + size_t size = backtrace(stack, 20); + backtrace_symbols_fd(stack, size, STDERR_FILENO); + if (oldCrashHandler) oldCrashHandler(signo); +} + +static void installCrashHandlers() { + static bool installed = false; + if (!installed) { + oldCrashHandler = signal(SIGSEGV, onCrashHandler); + installed = true; + } +} +#else +static void installCrashHandlers() {} +#endif + +#endif // _INTEROP_CRASHDUMP_H \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/dynamic-loader.h b/ets1.2/interop/src/cpp/dynamic-loader.h new file mode 100644 index 0000000000000000000000000000000000000000..4eb38df35035cceded928135fc1d63841f3ed2cf --- /dev/null +++ b/ets1.2/interop/src/cpp/dynamic-loader.h @@ -0,0 +1,111 @@ +/* + * Copyright (c) 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. + */ + +#ifndef _DYNAMIC_LOADER_H +#define _DYNAMIC_LOADER_H + +#include +#include "interop-utils.h" + +#ifdef KOALA_WINDOWS +#include +// Here we need to find module where GetArkUINodeAPI() +// function is implemented. +inline void* loadLibrary(const std::string& libPath) { + return LoadLibraryA(libPath.c_str()); +} + +inline const char* libraryError() { + static char error[256]; + interop_snprintf(error, sizeof error, "error %lu", GetLastError()); + return error; +} + +inline void* findSymbol(void* library, const char* name) { + return (void*)GetProcAddress(reinterpret_cast(library), name); +} + +inline std::string libName(const char* lib) { + return std::string(lib) + ".dll"; +} + +#elif defined(KOALA_LINUX) || defined(KOALA_MACOS) || defined(KOALA_OHOS) +#include + +inline void* loadLibrary(const std::string& libPath) { + void* handle = dlopen(libPath.c_str(), RTLD_LOCAL | RTLD_NOW); + if (!handle) { + return nullptr; + } + return handle; +} + +inline const char* libraryError() { + return dlerror(); +} + +inline std::string symbolName(const char* name) { + return name; +} + +inline void* findSymbol(void* library, const char* name) { + return dlsym(library, symbolName(name).c_str()); +} + +inline std::string libName(const char* lib) { + std::string result; + std::string suffix = +#ifdef KOALA_MACOS + ".dylib" +#else + ".so" +#endif + ; + result = "lib" + std::string(lib) + suffix; + return result; +} + +#else + +#include + +inline void* loadLibrary(const std::string& libPath) { + fprintf(stderr, "No loadLibrary() on this platform\n"); + return nullptr; +} + +inline const char* libraryError() { + fprintf(stderr, "No libraryError() on this platform\n"); + return nullptr; +} + +inline std::string symbolName(const char* name) { + fprintf(stderr, "No symbolName() on this platform\n"); + return ""; +} + +inline void* findSymbol(void* library, const char* name) { + fprintf(stderr, "No findSymbol() on this platform\n"); + return nullptr; +} + +inline std::string libName(const char* lib) { + fprintf(stderr, "No libName() on this platform\n"); + return ""; +} + +#endif + +#endif // _DYNAMIC_LOADER_H \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/ets/convertors-ets.cc b/ets1.2/interop/src/cpp/ets/convertors-ets.cc new file mode 100644 index 0000000000000000000000000000000000000000..62ceb1e54b3b042496b776e816d73449f1fd65f6 --- /dev/null +++ b/ets1.2/interop/src/cpp/ets/convertors-ets.cc @@ -0,0 +1,149 @@ +/* + * 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 "convertors-ets.h" +#include "signatures.h" +#include "interop-logging.h" +#include "interop-types.h" + +static const char* callCallbackFromNative = "callCallbackFromNative"; +static const char* callCallbackFromNativeSig = "IJI:I"; + +static const char* FAST_NATIVE_PREFIX = "#F$"; + +const bool registerByOne = true; + +static bool registerNatives(ets_env *env, const ets_class clazz, const std::vector> impls) { + std::vector methods; + methods.reserve(impls.size()); + bool result = true; + for (const auto &[name, type, func, flag] : impls) { + EtsNativeMethod method; + method.name = name.c_str(); + method.func = func; + method.signature = (flag & ETS_SLOW_NATIVE_FLAG) == 0 ? FAST_NATIVE_PREFIX : nullptr; + if (registerByOne) { + result &= env->RegisterNatives(clazz, &method, 1) >= 0; + if (env->ErrorCheck()) { + env->ErrorClear(); + } + } + else { + methods.push_back(method); + } + } + if (!registerByOne) { + result = env->RegisterNatives(clazz, methods.data(), static_cast(methods.size())) >= 0; + } + return registerByOne ? true : result; +} + +bool registerAllModules(ets_env *env) { + auto moduleNames = EtsExports::getInstance()->getModules(); + + for (auto it = moduleNames.begin(); it != moduleNames.end(); ++it) { + std::string className = EtsExports::getInstance()->getClasspath(*it); + ets_class nativeModule = env->FindClass(className.c_str()); + if (nativeModule == nullptr) { + LOGE("Cannot find managed class %s", className.c_str()); + continue; + } + if (!registerNatives(env, nativeModule, EtsExports::getInstance()->getMethods(*it))) { + return false; + } + } + + return true; +} + +extern "C" ETS_EXPORT ets_int ETS_CALL EtsNapiOnLoad(ets_env *env) { + LOGE("Use ETSNAPI") + if (!registerAllModules(env)) { + LOGE("Failed to register ets modules"); + return ETS_ERR; + } + auto interopClasspath = EtsExports::getInstance()->getClasspath("InteropNativeModule"); + auto interopClass = env->FindClass(interopClasspath.c_str()); + if (interopClass == nullptr) { + LOGE("Can not find InteropNativeModule classpath to set callback dispatcher"); + return ETS_ERR; + } + if (!setKoalaEtsNapiCallbackDispatcher(env, interopClass, callCallbackFromNative, callCallbackFromNativeSig)) { + LOGE("Failed to set koala ets callback dispatcher"); + return ETS_ERR; + } + return ETS_NAPI_VERSION_1_0; +} + +EtsExports* EtsExports::getInstance() { + static EtsExports *instance = nullptr; + if (instance == nullptr) { + instance = new EtsExports(); + } + return instance; +} + +std::vector EtsExports::getModules() { + std::vector result; + for (auto it = implementations.begin(); it != implementations.end(); ++it) { + result.push_back(it->first); + } + return result; +} + +const std::vector>& EtsExports::getMethods(const std::string& module) { + auto it = implementations.find(module); + if (it == implementations.end()) { + LOGE("Module %s is not registered", module.c_str()); + } + return it->second; +} + +void EtsExports::addMethod(const char* module, const char *name, const char *type, void *impl, int flags) { + auto it = implementations.find(module); + if (it == implementations.end()) { + it = implementations.insert(std::make_pair(module, std::vector>())).first; + } + it->second.push_back(std::make_tuple(name, convertType(name, type), impl, flags)); +} + +void EtsExports::setClasspath(const char* module, const char *classpath) { + auto it = classpaths.find(module); + if (it == classpaths.end()) { + classpaths.insert(std::make_pair(module, classpath)); + } else { + LOGE("Classpath for module %s was redefined", module); + } +} + +static std::map g_defaultClasspaths = { + {"InteropNativeModule", "@koalaui/interop/InteropNativeModule/InteropNativeModule"}, + // Improve: leave just InteropNativeModule, define others via KOALA_ETS_INTEROP_MODULE_CLASSPATH + {"TestNativeModule", "arkui/generated/arkts/TestNativeModule/TestNativeModule"}, + {"ArkUINativeModule", "arkui/generated/arkts/ArkUINativeModule/ArkUINativeModule"}, + {"ArkUIGeneratedNativeModule", "arkui/generated/arkts/ArkUIGeneratedNativeModule/ArkUIGeneratedNativeModule"}, +}; +const std::string& EtsExports::getClasspath(const std::string& module) { + auto it = classpaths.find(module); + if (it != classpaths.end()) { + return it->second; + } + auto defaultClasspath = g_defaultClasspaths.find(module); + if (defaultClasspath != g_defaultClasspaths.end()) { + return defaultClasspath->second; + } + INTEROP_FATAL("Classpath for module %s was not registered", module.c_str()); +} diff --git a/ets1.2/interop/src/cpp/ets/convertors-ets.h b/ets1.2/interop/src/cpp/ets/convertors-ets.h new file mode 100644 index 0000000000000000000000000000000000000000..efef48798ba19d7e50e59d02c831d343b459612e --- /dev/null +++ b/ets1.2/interop/src/cpp/ets/convertors-ets.h @@ -0,0 +1,1810 @@ +/* + * 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. + */ + +#ifndef CONVERTORS_ETS_H +#define CONVERTORS_ETS_H + +#ifdef KOALA_ETS_NAPI + +#include +#include +#include +#include +#include +#include + +#include "etsapi.h" +#include "koala-types.h" +#include "interop-utils.h" + +template +struct InteropTypeConverter { + using InteropType = T; + static T convertFrom(EtsEnv* env, InteropType value) = delete; + static InteropType convertTo(EtsEnv* env, T value) = delete; + static void release(EtsEnv* env, InteropType value, T converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ets_boolean; + static KBoolean convertFrom(EtsEnv* env, InteropType value) { return value; } + static InteropType convertTo(EtsEnv* env, KBoolean value) { return value; } + static void release(EtsEnv* env, InteropType value, KBoolean converted) {} +}; + + +template<> +struct InteropTypeConverter { + using InteropType = ets_int; + static KInt convertFrom(EtsEnv* env, InteropType value) { return value; } + static InteropType convertTo(EtsEnv* env, KInt value) { return value; } + static void release(EtsEnv* env, InteropType value, KInt converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ets_int; + static KUInt convertFrom(EtsEnv* env, InteropType value) { return value; } + static InteropType convertTo(EtsEnv* env, KUInt value) { return value; } + static void release(EtsEnv* env, InteropType value, KUInt converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ets_byte; + static KByte convertFrom(EtsEnv* env, InteropType value) { return value; } + static InteropType convertTo(EtsEnv* env, KByte value) { return value; } + static void release(EtsEnv* env, InteropType value, KByte converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ets_float; + static KFloat convertFrom(EtsEnv* env, InteropType value) { return value; } + static InteropType convertTo(EtsEnv* env, InteropFloat32 value) { return value; } + static void release(EtsEnv* env, InteropType value, KFloat converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ets_double; + static KDouble convertFrom(EtsEnv* env, InteropType value) { return value; } + static InteropType convertTo(EtsEnv* env, InteropFloat64 value) { return value; } + static void release(EtsEnv* env, InteropType value, KDouble converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ets_long; + static KSerializerBuffer convertFrom(EtsEnv* env, InteropType value) { + return reinterpret_cast(static_cast(value)); + } + static InteropType convertTo(EtsEnv* env, KSerializerBuffer value) = delete; + static void release(EtsEnv* env, InteropType value, KSerializerBuffer converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ets_object; + static KVMObjectHandle convertFrom(EtsEnv* env, InteropType value) { + return reinterpret_cast(value); + } + static InteropType convertTo(EtsEnv* env, KVMObjectHandle value) { + return reinterpret_cast(value); + } + static void release(EtsEnv* env, InteropType value, KVMObjectHandle converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ets_byteArray; + static KInteropBuffer convertFrom(EtsEnv* env, InteropType value) { + if (!value) return KInteropBuffer(); + KInteropBuffer result; + result.data = (KByte*)env->PinByteArray(value); + result.length = env->GetArrayLength(value); + return result; + } + static InteropType convertTo(EtsEnv* env, KInteropBuffer value) { + int bufferLength = value.length; + ets_byteArray array = env->NewByteArray(bufferLength); + KByte* data = (KByte*)env->PinByteArray(array); + interop_memcpy(data, bufferLength, (KByte*)value.data, bufferLength); + env->UnpinByteArray(array); + value.dispose(value.resourceId); + return array; + } + static void release(EtsEnv* env, InteropType value, KInteropBuffer converted) { + env->UnpinByteArray(value); + } +}; + +template<> +struct InteropTypeConverter { + using InteropType = ets_string; + static KStringPtr convertFrom(EtsEnv* env, InteropType value) { + if (value == nullptr) return KStringPtr(); + KStringPtr result; + // Notice that we use UTF length for buffer size, but counter is expressed in number of Unicode chars. + result.resize(env->GetStringUTFLength(value)); + env->GetStringUTFRegion(value, 0, env->GetStringLength(value), result.data()); + return result; + } + static InteropType convertTo(EtsEnv* env, const KStringPtr& value) { + return env->NewStringUTF(value.c_str()); + } + static void release(EtsEnv* env, InteropType value, const KStringPtr& converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ets_long; + static KNativePointer convertFrom(EtsEnv* env, InteropType value) { + return reinterpret_cast(value); + } + static InteropType convertTo(EtsEnv* env, KNativePointer value) { + return reinterpret_cast(value); + } + static void release(EtsEnv* env, InteropType value, KNativePointer converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ets_long; + static KLong convertFrom(EtsEnv* env, InteropType value) { + return value; + } + static InteropType convertTo(EtsEnv* env, KLong value) { + return value; + } + static void release(EtsEnv* env, InteropType value, KLong converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ets_long; + static KULong convertFrom(EtsEnv* env, InteropType value) { + return static_cast(value); + } + static InteropType convertTo(EtsEnv* env, KULong value) { + return static_cast(value); + } + static void release(EtsEnv* env, InteropType value, KULong converted) {} +}; + + +template<> +struct InteropTypeConverter { + using InteropType = ets_intArray; + static KInt* convertFrom(EtsEnv* env, InteropType value) { + if (!value) return nullptr; + return env->PinIntArray(value); + } + static InteropType convertTo(EtsEnv* env, KInt* value) = delete; + static void release(EtsEnv* env, InteropType value, KInt* converted) { + if (value) env->UnpinIntArray(value); + } +}; + +template<> +struct InteropTypeConverter { + using InteropType = ets_floatArray; + static KFloat* convertFrom(EtsEnv* env, InteropType value) { + if (!value) return nullptr; + return env->PinFloatArray(value); + } + static InteropType convertTo(EtsEnv* env, KFloat* value) = delete; + static void release(EtsEnv* env, InteropType value, KFloat* converted) { + if (value) env->UnpinFloatArray(value); + } +}; + +template<> +struct InteropTypeConverter { + using InteropType = ets_byteArray; + static KInteropReturnBuffer convertFrom(EtsEnv* env, InteropType value) = delete; + static InteropType convertTo(EtsEnv* env, KInteropReturnBuffer value) { + int bufferLength = value.length; + ets_byteArray array = env->NewByteArray(bufferLength); + KByte* data = (KByte*)env->PinByteArray(array); + interop_memcpy(data, bufferLength, (KByte*)value.data, bufferLength); + env->UnpinByteArray(array); + value.dispose(value.data, bufferLength); + return array; + }; + static void release(EtsEnv* env, InteropType value, KInteropReturnBuffer converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = ets_byteArray; + static KByte* convertFrom(EtsEnv* env, InteropType value) { + if (!value) return nullptr; + return (KByte*)env->PinByteArray(value); + } + static InteropType convertTo(EtsEnv* env, KByte* value) = delete; + static void release(EtsEnv* env, InteropType value, KByte* converted) { + if (value) env->UnpinByteArray((ets_byteArray)value); + } +}; + +template <> struct InteropTypeConverter { + using InteropType = ets_double; + static KInteropNumber convertFrom(EtsEnv *env, InteropType value) { + return KInteropNumber::fromDouble(value); + } + static InteropType convertTo(EtsEnv *env, KInteropNumber value) { + return value.asDouble(); + } + static void release(EtsEnv *env, InteropType value, KInteropNumber converted) {} +}; + +template +inline typename InteropTypeConverter::InteropType makeResult(EtsEnv* env, Type value) { + return InteropTypeConverter::convertTo(env, value); +} + +template +inline Type getArgument(EtsEnv* env, typename InteropTypeConverter::InteropType arg) { + return InteropTypeConverter::convertFrom(env, arg); +} + +template +inline void releaseArgument(EtsEnv* env, typename InteropTypeConverter::InteropType arg, Type& data) { + InteropTypeConverter::release(env, arg, data); +} + +template +struct DirectInteropTypeConverter { + using InteropType = T; + static T convertFrom(InteropType value) { return value; } + static InteropType convertTo(T value) { return value; } +}; + +template<> +struct DirectInteropTypeConverter { + using InteropType = ets_long; + static KNativePointer convertFrom(InteropType value) { + return reinterpret_cast(value); + } + static InteropType convertTo(KNativePointer value) { + return reinterpret_cast(value); + } +}; + +template<> +struct DirectInteropTypeConverter { + using InteropType = ets_long; + static KSerializerBuffer convertFrom(InteropType value) { + return reinterpret_cast(static_cast(value)); + } + static InteropType convertTo(KSerializerBuffer value) = delete; +}; + +template <> +struct DirectInteropTypeConverter { + using InteropType = ets_double; + static KInteropNumber convertFrom(InteropType value) { + return KInteropNumber::fromDouble(value); + } + static InteropType convertTo(KInteropNumber value) { + return value.asDouble(); + } +}; + +#define ETS_SLOW_NATIVE_FLAG 1 + +class EtsExports { + std::unordered_map>> implementations; + std::unordered_map classpaths; + +public: + static EtsExports* getInstance(); + + std::vector getModules(); + void addMethod(const char* module, const char* name, const char* type, void* impl, int flags); + const std::vector>& getMethods(const std::string& module); + + void setClasspath(const char* module, const char* classpath); + const std::string& getClasspath(const std::string& module); +}; + +#define KOALA_QUOTE0(x) #x +#define KOALA_QUOTE(x) KOALA_QUOTE0(x) + +#ifdef _MSC_VER +#define MAKE_ETS_EXPORT(module, name, type, flag) \ + static void __init_##name() { \ + EtsExports::getInstance()->addMethod(KOALA_QUOTE(module), "_"#name, type, reinterpret_cast(Ark_##name), flag); \ + } \ + namespace { \ + struct __Init_##name { \ + __Init_##name() { __init_##name(); } \ + } __Init_##name##_v; \ + } +#define KOALA_ETS_INTEROP_MODULE_CLASSPATH(module, classpath) \ + static void __init_classpath_##module() { \ + EtsExports::getInstance()->setClasspath(KOALA_QUOTE(module), classpath); \ + } \ + namespace { \ + struct __Init_classpath_##module { \ + __Init_classpath_##module() { __init_classpath_##module(); } \ + } __Init_classpath_##module##_v; \ + } +#else +#define MAKE_ETS_EXPORT(module, name, type, flag) \ + __attribute__((constructor)) \ + static void __init_ets_##name() { \ + EtsExports::getInstance()->addMethod(KOALA_QUOTE(module), "_"#name, type, reinterpret_cast(Ark_##name), flag); \ + } +#define KOALA_ETS_INTEROP_MODULE_CLASSPATH(module, classpath) \ + __attribute__((constructor)) \ + static void __init_ets_classpath_##module() { \ + EtsExports::getInstance()->setClasspath(KOALA_QUOTE(module), classpath); \ + } +#endif + +#define KOALA_INTEROP_0(name, Ret) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz) { \ + KOALA_MAYBE_LOG(name) \ + return makeResult(env, impl_##name()); \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret, 0) + +#define KOALA_INTEROP_1(name, Ret, P0) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + auto rv = makeResult(env, impl_##name(p0)); \ + releaseArgument(env, _p0, p0); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0, 0) + +#define KOALA_INTEROP_2(name, Ret, P0, P1) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + auto rv = makeResult(env, impl_##name(p0, p1)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1, 0) + +#define KOALA_INTEROP_3(name, Ret, P0, P1, P2) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2, 0) + +#define KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3, 0) + +#define KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4, 0) + +#define KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) \ +InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5, 0) + +#define KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5, p6)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6, 0) + +#define KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7, 0) + +#define KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + return rv; \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8, 0) + +#define KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9, 0) + +#define KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10, 0) + +#define KOALA_INTEROP_12(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11, 0) + +#define KOALA_INTEROP_13(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + P12 p12 = getArgument(env, _p12); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + releaseArgument(env, _p12, p12); \ + return rv; \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12, 0) + +#define KOALA_INTEROP_14(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12, \ + InteropTypeConverter::InteropType _p13) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + P12 p12 = getArgument(env, _p12); \ + P13 p13 = getArgument(env, _p13); \ + auto rv = makeResult(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + releaseArgument(env, _p12, p12); \ + releaseArgument(env, _p13, p13); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12 "|" #P13, 0) + +#define KOALA_INTEROP_V0(name) \ + void Ark_##name(EtsEnv *env) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(); \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void", 0) + +#define KOALA_INTEROP_V1(name, P0) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + impl_##name(p0); \ + releaseArgument(env, _p0, p0); \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0, 0) + +#define KOALA_INTEROP_V2(name, P0, P1) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + impl_##name(p0, p1); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1, 0) + +#define KOALA_INTEROP_V3(name, P0, P1, P2) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + impl_##name(p0, p1, p2); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2, 0) + +#define KOALA_INTEROP_V4(name, P0, P1, P2, P3) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + impl_##name(p0, p1, p2, p3); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ +} \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3, 0) + +#define KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + impl_##name(p0, p1, p2, p3, p4); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ +} \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4, 0) + +#define KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + impl_##name(p0, p1, p2, p3, p4, p5); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5, 0) + +#define KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6, 0) + +#define KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7, 0) + +#define KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8, 0) + +#define KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ +} \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9, 0) + +#define KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10, 0) + +#define KOALA_INTEROP_V12(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ +} \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11, 0) + +#define KOALA_INTEROP_V13(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + P12 p12 = getArgument(env, _p12); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + releaseArgument(env, _p12, p12); \ +} \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12, 0) + +#define KOALA_INTEROP_V14(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12, \ + InteropTypeConverter::InteropType _p13) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + P12 p12 = getArgument(env, _p12); \ + P13 p13 = getArgument(env, _p13); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + releaseArgument(env, _p12, p12); \ + releaseArgument(env, _p13, p13); \ +} \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12 "|" #P13, 0) + +#define KOALA_INTEROP_V15(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12, \ + InteropTypeConverter::InteropType _p13, \ + InteropTypeConverter::InteropType _p14) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + P12 p12 = getArgument(env, _p12); \ + P13 p13 = getArgument(env, _p13); \ + P14 p14 = getArgument(env, _p14); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + releaseArgument(env, _p12, p12); \ + releaseArgument(env, _p13, p13); \ + releaseArgument(env, _p14, p14); \ +} \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12 "|" #P13 "|" #P14, 0) + +#define KOALA_INTEROP_CTX_0(name, Ret) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz) { \ + KOALA_MAYBE_LOG(name) \ + KVMContext ctx = (KVMContext)env; \ + auto rv = makeResult(env, impl_##name(ctx)); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret, ETS_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_1(name, Ret, P0) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + KVMContext ctx = (KVMContext)env; \ + auto rv = makeResult(env, impl_##name(ctx, p0)); \ + releaseArgument(env, _p0, p0); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0, ETS_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_2(name, Ret, P0, P1) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + KVMContext ctx = (KVMContext)env; \ + auto rv = makeResult(env, impl_##name(ctx, p0, p1)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1, ETS_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_3(name, Ret, P0, P1, P2) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + KVMContext ctx = (KVMContext)env; \ + auto rv = makeResult(env, impl_##name(ctx, p0, p1, p2)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2, ETS_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_4(name, Ret, P0, P1, P2, P3) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + KVMContext ctx = (KVMContext)env; \ + auto rv = makeResult(env, impl_##name(ctx, p0, p1, p2, p3)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3, ETS_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_5(name, Ret, P0, P1, P2, P3, P4) \ + InteropTypeConverter::InteropType Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + KVMContext ctx = (KVMContext)env; \ + auto rv = makeResult(env, impl_##name(ctx, p0, p1, p2, p3, p4)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + return rv; \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4, ETS_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_V0(name) \ + void Ark_##name(EtsEnv *env, ets_class clazz) { \ + KOALA_MAYBE_LOG(name) \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx); \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void", ETS_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_V1(name, P0) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx, p0); \ + releaseArgument(env, _p0, p0); \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0, ETS_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_V2(name, P0, P1) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx, p0, p1); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1, ETS_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_V3(name, P0, P1, P2) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx, p0, p1, p2); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2, ETS_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_V4(name, P0, P1, P2, P3) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx, p0, p1, p2, p3); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3, ETS_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_CTX_V5(name, P0, P1, P2, P3, P4) \ + void Ark_##name(EtsEnv *env, ets_class clazz, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx, p0, p1, p2, p3, p4); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + } \ +MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4, ETS_SLOW_NATIVE_FLAG) + +#define KOALA_INTEROP_DIRECT_0(name, Ret) \ + inline InteropTypeConverter::InteropType Ark_##name( \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name()); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret, 0) +#define KOALA_INTEROP_DIRECT_1(name, Ret, P0) \ + inline InteropTypeConverter::InteropType Ark_##name( \ + InteropTypeConverter::InteropType p0 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0))); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0, 0) +#define KOALA_INTEROP_DIRECT_2(name, Ret, P0, P1) \ + inline InteropTypeConverter::InteropType Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1))); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1, 0) +#define KOALA_INTEROP_DIRECT_3(name, Ret, P0, P1, P2) \ + inline InteropTypeConverter::InteropType Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2))); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2, 0) +#define KOALA_INTEROP_DIRECT_4(name, Ret, P0, P1, P2, P3) \ + inline InteropTypeConverter::InteropType Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3))); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3, 0) +#define KOALA_INTEROP_DIRECT_5(name, Ret, P0, P1, P2, P3, P4) \ + inline InteropTypeConverter::InteropType Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4))); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4, 0) +#define KOALA_INTEROP_DIRECT_6(name, Ret, P0, P1, P2, P3, P4, P5) \ + inline InteropTypeConverter::InteropType Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5))); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5, 0) +#define KOALA_INTEROP_DIRECT_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ + inline InteropTypeConverter::InteropType Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6))); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6, 0) +#define KOALA_INTEROP_DIRECT_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ + inline InteropTypeConverter::InteropType Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6, \ + InteropTypeConverter::InteropType p7 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6), DirectInteropTypeConverter::convertFrom(p7))); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7, 0) +#define KOALA_INTEROP_DIRECT_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + inline InteropTypeConverter::InteropType Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6, \ + InteropTypeConverter::InteropType p7, \ + InteropTypeConverter::InteropType p8 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6), DirectInteropTypeConverter::convertFrom(p7), DirectInteropTypeConverter::convertFrom(p8))); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8, 0) +#define KOALA_INTEROP_DIRECT_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + inline InteropTypeConverter::InteropType Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6, \ + InteropTypeConverter::InteropType p7, \ + InteropTypeConverter::InteropType p8, \ + InteropTypeConverter::InteropType p9 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6), DirectInteropTypeConverter::convertFrom(p7), DirectInteropTypeConverter::convertFrom(p8), DirectInteropTypeConverter::convertFrom(p9))); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9, 0) +#define KOALA_INTEROP_DIRECT_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + inline InteropTypeConverter::InteropType Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6, \ + InteropTypeConverter::InteropType p7, \ + InteropTypeConverter::InteropType p8, \ + InteropTypeConverter::InteropType p9, \ + InteropTypeConverter::InteropType p10 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + return DirectInteropTypeConverter::convertTo(impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6), DirectInteropTypeConverter::convertFrom(p7), DirectInteropTypeConverter::convertFrom(p8), DirectInteropTypeConverter::convertFrom(p9), DirectInteropTypeConverter::convertFrom(p10))); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10, 0) +#define KOALA_INTEROP_DIRECT_V0(name) \ + inline void Ark_##name( \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void", 0) +#define KOALA_INTEROP_DIRECT_V1(name, P0) \ + inline void Ark_##name( \ + InteropTypeConverter::InteropType p0 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0)); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0, 0) +#define KOALA_INTEROP_DIRECT_V2(name, P0, P1) \ + inline void Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1)); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1, 0) +#define KOALA_INTEROP_DIRECT_V3(name, P0, P1, P2) \ + inline void Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2)); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2, 0) +#define KOALA_INTEROP_DIRECT_V4(name, P0, P1, P2, P3) \ + inline void Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3)); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2 "|" #P3, 0) +#define KOALA_INTEROP_DIRECT_V5(name, P0, P1, P2, P3, P4) \ + inline void Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4)); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4, 0) +#define KOALA_INTEROP_DIRECT_V6(name, P0, P1, P2, P3, P4, P5) \ + inline void Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5)); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5, 0) +#define KOALA_INTEROP_DIRECT_V7(name, P0, P1, P2, P3, P4, P5, P6) \ + inline void Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6)); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6, 0) +#define KOALA_INTEROP_DIRECT_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ + inline void Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6, \ + InteropTypeConverter::InteropType p7 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6), DirectInteropTypeConverter::convertFrom(p7)); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7, 0) +#define KOALA_INTEROP_DIRECT_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + inline void Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6, \ + InteropTypeConverter::InteropType p7, \ + InteropTypeConverter::InteropType p8 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6), DirectInteropTypeConverter::convertFrom(p7), DirectInteropTypeConverter::convertFrom(p8)); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8, 0) +#define KOALA_INTEROP_DIRECT_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + inline void Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6, \ + InteropTypeConverter::InteropType p7, \ + InteropTypeConverter::InteropType p8, \ + InteropTypeConverter::InteropType p9 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6), DirectInteropTypeConverter::convertFrom(p7), DirectInteropTypeConverter::convertFrom(p8), DirectInteropTypeConverter::convertFrom(p9)); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9, 0) +#define KOALA_INTEROP_DIRECT_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + inline void Ark_##name( \ + InteropTypeConverter::InteropType p0, \ + InteropTypeConverter::InteropType p1, \ + InteropTypeConverter::InteropType p2, \ + InteropTypeConverter::InteropType p3, \ + InteropTypeConverter::InteropType p4, \ + InteropTypeConverter::InteropType p5, \ + InteropTypeConverter::InteropType p6, \ + InteropTypeConverter::InteropType p7, \ + InteropTypeConverter::InteropType p8, \ + InteropTypeConverter::InteropType p9, \ + InteropTypeConverter::InteropType p10 \ + ) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(DirectInteropTypeConverter::convertFrom(p0), DirectInteropTypeConverter::convertFrom(p1), DirectInteropTypeConverter::convertFrom(p2), DirectInteropTypeConverter::convertFrom(p3), DirectInteropTypeConverter::convertFrom(p4), DirectInteropTypeConverter::convertFrom(p5), DirectInteropTypeConverter::convertFrom(p6), DirectInteropTypeConverter::convertFrom(p7), DirectInteropTypeConverter::convertFrom(p8), DirectInteropTypeConverter::convertFrom(p9), DirectInteropTypeConverter::convertFrom(p10)); \ + } \ + MAKE_ETS_EXPORT(KOALA_INTEROP_MODULE, name, "void" "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10, 0) + +bool setKoalaEtsNapiCallbackDispatcher( + EtsEnv* etsEnv, + ets_class clazz, + const char* dispatcherMethodName, + const char* dispactherMethodSig +); +void getKoalaEtsNapiCallbackDispatcher(ets_class* clazz, ets_method* method); + +#define KOALA_INTEROP_CALL_VOID(venv, id, length, args) \ +{ \ + ets_class clazz = nullptr; \ + ets_method method = nullptr; \ + getKoalaEtsNapiCallbackDispatcher(&clazz, &method); \ + EtsEnv* etsEnv = reinterpret_cast(vmContext); \ + etsEnv->PushLocalFrame(1); \ + etsEnv->CallStaticIntMethod(clazz, method, id, args, length); \ + etsEnv->PopLocalFrame(nullptr); \ +} + +#define KOALA_INTEROP_CALL_INT(venv, id, length, args) \ +{ \ + ets_class clazz = nullptr; \ + ets_method method = nullptr; \ + getKoalaEtsNapiCallbackDispatcher(&clazz, &method); \ + EtsEnv* etsEnv = reinterpret_cast(venv); \ + etsEnv->PushLocalFrame(1); \ + int32_t rv = etsEnv->CallStaticIntMethod(clazz, method, id, args, length); \ + etsEnv->PopLocalFrame(nullptr); \ + return rv; \ +} + +#define KOALA_INTEROP_CALL_VOID_INTS32(venv, id, argc, args) KOALA_INTEROP_CALL_VOID(venv, id, (argc) * sizeof(int32_t), args) +#define KOALA_INTEROP_CALL_INT_INTS32(venv, id, argc, args) KOALA_INTEROP_CALL_INT(venv, id, (argc) * sizeof(int32_t), args) + +#define KOALA_INTEROP_THROW(vmContext, object, ...) \ + do { \ + EtsEnv* env = reinterpret_cast(vmContext); \ + env->ThrowError(object); \ + return __VA_ARGS__; \ + } while (0) + +#define KOALA_INTEROP_THROW_STRING(vmContext, message, ...) \ + do { \ + EtsEnv* env = reinterpret_cast(vmContext); \ + const static ets_class errorClass = env->FindClass("std/core/Error"); \ + env->ThrowErrorNew(errorClass, message); \ + } while (0) + +#endif // KOALA_ETS_NAPI + +#endif // CONVERTORS_ETS_H \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/ets/etsapi.h b/ets1.2/interop/src/cpp/ets/etsapi.h new file mode 100644 index 0000000000000000000000000000000000000000..41641c97eb5e6588876fa795dd09278ab491a54e --- /dev/null +++ b/ets1.2/interop/src/cpp/ets/etsapi.h @@ -0,0 +1,1545 @@ +/** + * Copyright (c) 2021-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. + */ + +#ifndef PANDA_RUNTIME_INTEROP_ETS_NAPI_H +#define PANDA_RUNTIME_INTEROP_ETS_NAPI_H + +// NOLINTBEGIN(modernize-use-using, readability-identifier-naming, cppcoreguidelines-pro-type-vararg) + +#ifdef __cplusplus +#include +#include +#else +#include +#include +#endif + +// NOLINTBEGIN(cppcoreguidelines-macro-usage) + +// Version Constants +#define ETS_NAPI_VERSION_1_0 0x00010000 + +// General return value constants +#define ETS_OK 0 // success +#define ETS_ERR (-1) // unknown error +#define ETS_ERR_VER (-2) // ETS version error +#define ETS_ERR_NOMEM (-3) // not enough memory +#define ETS_ERR_EXIST (-4) // VM already created +#define ETS_ERR_INVAL (-5) // invalid arguments + +// Boolean Constants +#define ETS_FALSE 0 +#define ETS_TRUE 1 + +// Mode Constants +#define ETS_COMMIT 1 +#define ETS_ABORT 2 + +// NOLINTEND(cppcoreguidelines-macro-usage) + +// Primitive Types +typedef uint8_t ets_boolean; +typedef int8_t ets_byte; +typedef uint16_t ets_char; +typedef int16_t ets_short; +typedef int32_t ets_int; +typedef int64_t ets_long; +typedef float ets_float; +typedef double ets_double; +typedef ets_int ets_size; + +// Reference Types +#ifdef __cplusplus +class __ets_object {}; +class __ets_class : public __ets_object {}; +class __ets_string : public __ets_object {}; +class __ets_array : public __ets_object {}; +class __ets_objectArray : public __ets_array {}; +class __ets_booleanArray : public __ets_array {}; +class __ets_byteArray : public __ets_array {}; +class __ets_charArray : public __ets_array {}; +class __ets_shortArray : public __ets_array {}; +class __ets_intArray : public __ets_array {}; +class __ets_longArray : public __ets_array {}; +class __ets_floatArray : public __ets_array {}; +class __ets_doubleArray : public __ets_array {}; +class __ets_error : public __ets_object {}; + +typedef __ets_object *ets_object; +typedef __ets_class *ets_class; +typedef __ets_string *ets_string; +typedef __ets_array *ets_array; +typedef __ets_objectArray *ets_objectArray; +typedef __ets_booleanArray *ets_booleanArray; +typedef __ets_byteArray *ets_byteArray; +typedef __ets_charArray *ets_charArray; +typedef __ets_shortArray *ets_shortArray; +typedef __ets_intArray *ets_intArray; +typedef __ets_longArray *ets_longArray; +typedef __ets_floatArray *ets_floatArray; +typedef __ets_doubleArray *ets_doubleArray; +typedef __ets_error *ets_error; +typedef __ets_object *ets_weak; + +#else // __cplusplus + +struct __ets_object; +typedef struct __ets_object *ets_object; +typedef ets_object ets_class; +typedef ets_object ets_string; +typedef ets_object ets_error; +typedef ets_object ets_weak; +typedef ets_object ets_array; +typedef ets_array ets_objectArray; +typedef ets_array ets_booleanArray; +typedef ets_array ets_byteArray; +typedef ets_array ets_charArray; +typedef ets_array ets_shortArray; +typedef ets_array ets_intArray; +typedef ets_array ets_longArray; +typedef ets_array ets_floatArray; +typedef ets_array ets_doubleArray; +#endif // __cplusplus + +struct __ets_deferred; +typedef struct __ets_deferred *ets_deferred; + +// Field and Method IDs +struct __ets_method; +struct __ets_field; +typedef struct __ets_method *ets_method; +typedef struct __ets_field *ets_field; + +// The Value Type +typedef union ets_value { + ets_boolean z; + ets_byte b; + ets_char c; + ets_short s; + ets_int i; + ets_long j; + ets_float f; + ets_double d; + ets_object l; +} ets_value; + +// Describe native method by name, signature and function pointer +typedef struct { + const char *name; + const char *signature; + void *func; +} EtsNativeMethod; + +// The object reference types +typedef enum { + ETS_INVALID_REF_TYPE = 0, + ETS_LOCAL_REF_TYPE = 1, + ETS_GLOBAL_REF_TYPE = 2, + ETS_WEAK_GLOBAL_REF_TYPE = 3 +} ets_objectRefType; + +#ifdef __cplusplus +typedef struct __EtsVM EtsVM; +typedef struct __EtsEnv ets_env; +#else +typedef const struct ETS_InvokeInterface *EtsVM; +typedef const struct ETS_NativeInterface *ets_env; +#endif + +// Deprecated types: +typedef ets_env EtsEnv; + +typedef enum { + ETS_OKAY, + ETS_INVALID_ARG, + ETS_GENERIC_FAILURE, + ETS_PENDING_EXCEPTION, + ETS_INVALID_VERSION, // NOTE(v.cherkashin): This status code doesn't match to napi interface. + // Should we probably delete this status code? +} ets_status; + +// clang-format off +// Interface Function Table +struct ETS_NativeInterface { + // NOTE(a.urakov): solve the "Array" naming problem + ets_int (*GetVersion)(EtsEnv *env); +#ifdef ETS_NAPI_DESIGN_FINISHED + ets_class (*DefineClass)(EtsEnv *env, const char *name, ets_object loader, const ets_byte *buf, ets_size bufLen); +#endif + ets_class (*FindClass)(EtsEnv *env, const char *name); +#ifdef ETS_NAPI_DESIGN_FINISHED + ets_method (*FromReflectedMethod)(EtsEnv *env, ets_object method); + ets_field (*FromReflectedField)(EtsEnv *env, ets_object field); + ets_object (*ToReflectedMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ets_boolean isStatic); +#endif + ets_class (*GetSuperclass)(EtsEnv *env, ets_class cls); + ets_boolean (*IsAssignableFrom)(EtsEnv *env, ets_class cls1, ets_class cls2); +#ifdef ETS_NAPI_DESIGN_FINISHED + ets_object (*ToReflectedField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_boolean isStatic); +#endif + ets_int (*ThrowError)(EtsEnv *env, ets_error obj); + ets_int (*ThrowErrorNew)(EtsEnv *env, ets_class cls, const char *message); + ets_error (*ErrorOccurred)(EtsEnv *env); + void (*ErrorDescribe)(EtsEnv *env); + void (*ErrorClear)(EtsEnv *env); + void (*FatalError)(EtsEnv *env, const char *message); + ets_int (*PushLocalFrame)(EtsEnv *env, ets_int capacity); + ets_object (*PopLocalFrame)(EtsEnv *env, ets_object result); + ets_object (*NewGlobalRef)(EtsEnv *env, ets_object obj); + void (*DeleteGlobalRef)(EtsEnv *env, ets_object globalRef); + void (*DeleteLocalRef)(EtsEnv *env, ets_object localRef); + ets_boolean (*IsSameObject)(EtsEnv *env, ets_object ref1, ets_object ref2); + ets_object (*NewLocalRef)(EtsEnv *env, ets_object ref); + ets_int (*EnsureLocalCapacity)(EtsEnv *env, ets_int capacity); + ets_object (*AllocObject)(EtsEnv *env, ets_class cls); + ets_object (*NewObject)(EtsEnv *env, ets_class cls, ets_method p_method, ...); + ets_object (*NewObjectList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); + ets_object (*NewObjectArray)(EtsEnv *env, ets_class cls, ets_method p_method, const ets_value *args); + ets_class (*GetObjectClass)(EtsEnv *env, ets_object obj); + ets_boolean (*IsInstanceOf)(EtsEnv *env, ets_object obj, ets_class cls); + ets_method (*Getp_method)(EtsEnv *env, ets_class cls, const char *name, const char *sig); + ets_object (*CallObjectMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); + ets_object (*CallObjectMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); + ets_object (*CallObjectMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); + ets_boolean (*CallBooleanMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); + ets_boolean (*CallBooleanMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); + ets_boolean (*CallBooleanMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); + ets_byte (*CallByteMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); + ets_byte (*CallByteMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); + ets_byte (*CallByteMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); + ets_char (*CallCharMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); + ets_char (*CallCharMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); + ets_char (*CallCharMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); + ets_short (*CallShortMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); + ets_short (*CallShortMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); + ets_short (*CallShortMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); + ets_int (*CallIntMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); + ets_int (*CallIntMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); + ets_int (*CallIntMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); + ets_long (*CallLongMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); + ets_long (*CallLongMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); + ets_long (*CallLongMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); + ets_float (*CallFloatMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); + ets_float (*CallFloatMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); + ets_float (*CallFloatMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); + ets_double (*CallDoubleMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); + ets_double (*CallDoubleMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); + ets_double (*CallDoubleMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); + void (*CallVoidMethod)(EtsEnv *env, ets_object obj, ets_method p_method, ...); + void (*CallVoidMethodList)(EtsEnv *env, ets_object obj, ets_method p_method, va_list args); + void (*CallVoidMethodArray)(EtsEnv *env, ets_object obj, ets_method p_method, const ets_value *args); + + ets_object (*CallNonvirtualObjectMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); + ets_object (*CallNonvirtualObjectMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + va_list args); + ets_object (*CallNonvirtualObjectMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + const ets_value *args); + ets_boolean (*CallNonvirtualBooleanMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); + ets_boolean (*CallNonvirtualBooleanMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + va_list args); + ets_boolean (*CallNonvirtualBooleanMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + const ets_value *args); + ets_byte (*CallNonvirtualByteMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); + ets_byte (*CallNonvirtualByteMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + va_list args); + ets_byte (*CallNonvirtualByteMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + const ets_value *args); + ets_char (*CallNonvirtualCharMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); + ets_char (*CallNonvirtualCharMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + va_list args); + ets_char (*CallNonvirtualCharMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + const ets_value *args); + ets_short (*CallNonvirtualShortMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); + ets_short (*CallNonvirtualShortMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + va_list args); + ets_short (*CallNonvirtualShortMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + const ets_value *args); + ets_int (*CallNonvirtualIntMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); + ets_int (*CallNonvirtualIntMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + va_list args); + ets_int (*CallNonvirtualIntMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + const ets_value *args); + ets_long (*CallNonvirtualLongMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); + ets_long (*CallNonvirtualLongMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + va_list args); + ets_long (*CallNonvirtualLongMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + const ets_value *args); + ets_float (*CallNonvirtualFloatMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); + ets_float (*CallNonvirtualFloatMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + va_list args); + ets_float (*CallNonvirtualFloatMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + const ets_value *args); + ets_double (*CallNonvirtualDoubleMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); + ets_double (*CallNonvirtualDoubleMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + va_list args); + ets_double (*CallNonvirtualDoubleMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + const ets_value *args); + void (*CallNonvirtualVoidMethod)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, ...); + void (*CallNonvirtualVoidMethodList)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, va_list args); + void (*CallNonvirtualVoidMethodArray)(EtsEnv *env, ets_object obj, ets_class cls, ets_method p_method, + const ets_value *args); + ets_field (*Getp_field)(EtsEnv *env, ets_class cls, const char *name, const char *sig); + ets_object (*GetObjectField)(EtsEnv *env, ets_object obj, ets_field p_field); + ets_boolean (*GetBooleanField)(EtsEnv *env, ets_object obj, ets_field p_field); + ets_byte (*GetByteField)(EtsEnv *env, ets_object obj, ets_field p_field); + ets_char (*GetCharField)(EtsEnv *env, ets_object obj, ets_field p_field); + ets_short (*GetShortField)(EtsEnv *env, ets_object obj, ets_field p_field); + ets_int (*GetIntField)(EtsEnv *env, ets_object obj, ets_field p_field); + ets_long (*GetLongField)(EtsEnv *env, ets_object obj, ets_field p_field); + ets_float (*GetFloatField)(EtsEnv *env, ets_object obj, ets_field p_field); + ets_double (*GetDoubleField)(EtsEnv *env, ets_object obj, ets_field p_field); + void (*SetObjectField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_object value); + void (*SetBooleanField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_boolean value); + void (*SetByteField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_byte value); + void (*SetCharField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_char value); + void (*SetShortField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_short value); + void (*SetIntField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_int value); + void (*SetLongField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_long value); + void (*SetFloatField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_float value); + void (*SetDoubleField)(EtsEnv *env, ets_object obj, ets_field p_field, ets_double value); + ets_method (*GetStaticp_method)(EtsEnv *env, ets_class cls, const char *name, const char *sig); + ets_object (*CallStaticObjectMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); + ets_object (*CallStaticObjectMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); + ets_object (*CallStaticObjectMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); + ets_boolean (*CallStaticBooleanMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); + ets_boolean (*CallStaticBooleanMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); + ets_boolean (*CallStaticBooleanMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); + ets_byte (*CallStaticByteMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); + ets_byte (*CallStaticByteMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); + ets_byte (*CallStaticByteMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); + ets_char (*CallStaticCharMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); + ets_char (*CallStaticCharMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); + ets_char (*CallStaticCharMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); + ets_short (*CallStaticShortMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); + ets_short (*CallStaticShortMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); + ets_short (*CallStaticShortMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); + ets_int (*CallStaticIntMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); + ets_int (*CallStaticIntMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); + ets_int (*CallStaticIntMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); + ets_long (*CallStaticLongMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); + ets_long (*CallStaticLongMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); + ets_long (*CallStaticLongMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); + ets_float (*CallStaticFloatMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); + ets_float (*CallStaticFloatMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); + ets_float (*CallStaticFloatMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); + ets_double (*CallStaticDoubleMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); + ets_double (*CallStaticDoubleMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); + ets_double (*CallStaticDoubleMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); + void (*CallStaticVoidMethod)(EtsEnv *env, ets_class cls, ets_method p_method, ...); + void (*CallStaticVoidMethodList)(EtsEnv *env, ets_class cls, ets_method p_method, va_list args); + void (*CallStaticVoidMethodArray)(EtsEnv *env, ets_class cls, ets_method p_method, ets_value *args); + ets_field (*GetStaticp_field)(EtsEnv *env, ets_class cls, const char *name, const char *sig); + ets_object (*GetStaticObjectField)(EtsEnv *env, ets_class cls, ets_field p_field); + ets_boolean (*GetStaticBooleanField)(EtsEnv *env, ets_class cls, ets_field p_field); + ets_byte (*GetStaticByteField)(EtsEnv *env, ets_class cls, ets_field p_field); + ets_char (*GetStaticCharField)(EtsEnv *env, ets_class cls, ets_field p_field); + ets_short (*GetStaticShortField)(EtsEnv *env, ets_class cls, ets_field p_field); + ets_int (*GetStaticIntField)(EtsEnv *env, ets_class cls, ets_field p_field); + ets_long (*GetStaticLongField)(EtsEnv *env, ets_class cls, ets_field p_field); + ets_float (*GetStaticFloatField)(EtsEnv *env, ets_class cls, ets_field p_field); + ets_double (*GetStaticDoubleField)(EtsEnv *env, ets_class cls, ets_field p_field); + void (*SetStaticObjectField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_object value); + void (*SetStaticBooleanField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_boolean value); + void (*SetStaticByteField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_byte value); + void (*SetStaticCharField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_char value); + void (*SetStaticShortField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_short value); + void (*SetStaticIntField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_int value); + void (*SetStaticLongField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_long value); + void (*SetStaticFloatField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_float value); + void (*SetStaticDoubleField)(EtsEnv *env, ets_class cls, ets_field p_field, ets_double value); + ets_string (*NewString)(EtsEnv *env, const ets_char *unicodeChars, ets_size len); + ets_size (*GetStringLength)(EtsEnv *env, ets_string string); + const ets_char *(*GetStringChars)(EtsEnv *env, ets_string string, ets_boolean *isCopy); + void (*ReleaseStringChars)(EtsEnv *env, ets_string string, const ets_char *chars); + ets_string (*NewStringUTF)(EtsEnv *env, const char *bytes); + ets_size (*GetStringUTFLength)(EtsEnv *env, ets_string string); + const char *(*GetStringUTFChars)(EtsEnv *env, ets_string string, ets_boolean *isCopy); + void (*ReleaseStringUTFChars)(EtsEnv *env, ets_string string, const char *utf); + ets_size (*GetArrayLength)(EtsEnv *env, ets_array array); + ets_objectArray (*NewObjectsArray)(EtsEnv *env, ets_size length, ets_class element_class, + ets_object initial_element); + ets_object (*GetObjectArrayElement)(EtsEnv *env, ets_objectArray array, ets_size index); + void (*SetObjectArrayElement)(EtsEnv *env, ets_objectArray array, ets_size index, ets_object value); + ets_booleanArray (*NewBooleanArray)(EtsEnv *env, ets_size length); + ets_byteArray (*NewByteArray)(EtsEnv *env, ets_size length); + ets_charArray (*NewCharArray)(EtsEnv *env, ets_size length); + ets_shortArray (*NewShortArray)(EtsEnv *env, ets_size length); + ets_intArray (*NewIntArray)(EtsEnv *env, ets_size length); + ets_longArray (*NewLongArray)(EtsEnv *env, ets_size length); + ets_floatArray (*NewFloatArray)(EtsEnv *env, ets_size length); + ets_doubleArray (*NewDoubleArray)(EtsEnv *env, ets_size length); + ets_boolean *(*PinBooleanArray)(EtsEnv *env, ets_booleanArray array); + ets_byte *(*PinByteArray)(EtsEnv *env, ets_byteArray array); + ets_char *(*PinCharArray)(EtsEnv *env, ets_charArray array); + ets_short *(*PinShortArray)(EtsEnv *env, ets_shortArray array); + ets_int *(*PinIntArray)(EtsEnv *env, ets_intArray array); + ets_long *(*PinLongArray)(EtsEnv *env, ets_longArray array); + ets_float *(*PinFloatArray)(EtsEnv *env, ets_floatArray array); + ets_double *(*PinDoubleArray)(EtsEnv *env, ets_doubleArray array); + void (*UnpinBooleanArray)(EtsEnv *env, ets_booleanArray array); + void (*UnpinByteArray)(EtsEnv *env, ets_byteArray array); + void (*UnpinCharArray)(EtsEnv *env, ets_charArray array); + void (*UnpinShortArray)(EtsEnv *env, ets_shortArray array); + void (*UnpinIntArray)(EtsEnv *env, ets_intArray array); + void (*UnpinLongArray)(EtsEnv *env, ets_longArray array); + void (*UnpinFloatArray)(EtsEnv *env, ets_floatArray array); + void (*UnpinDoubleArray)(EtsEnv *env, ets_doubleArray array); + void (*GetBooleanArrayRegion)(EtsEnv *env, ets_booleanArray array, ets_size start, ets_size len, ets_boolean *buf); + void (*GetByteArrayRegion)(EtsEnv *env, ets_byteArray array, ets_size start, ets_size len, ets_byte *buf); + void (*GetCharArrayRegion)(EtsEnv *env, ets_charArray array, ets_size start, ets_size len, ets_char *buf); + void (*GetShortArrayRegion)(EtsEnv *env, ets_shortArray array, ets_size start, ets_size len, ets_short *buf); + void (*GetIntArrayRegion)(EtsEnv *env, ets_intArray array, ets_size start, ets_size len, ets_int *buf); + void (*GetLongArrayRegion)(EtsEnv *env, ets_longArray array, ets_size start, ets_size len, ets_long *buf); + void (*GetFloatArrayRegion)(EtsEnv *env, ets_floatArray array, ets_size start, ets_size len, ets_float *buf); + void (*GetDoubleArrayRegion)(EtsEnv *env, ets_doubleArray array, ets_size start, ets_size len, ets_double *buf); + void (*SetBooleanArrayRegion)(EtsEnv *env, ets_booleanArray array, ets_size start, ets_size len, + const ets_boolean *buf); + void (*SetByteArrayRegion)(EtsEnv *env, ets_byteArray array, ets_size start, ets_size len, const ets_byte *buf); + void (*SetCharArrayRegion)(EtsEnv *env, ets_charArray array, ets_size start, ets_size len, const ets_char *buf); + void (*SetShortArrayRegion)(EtsEnv *env, ets_shortArray array, ets_size start, ets_size len, const ets_short *buf); + void (*SetIntArrayRegion)(EtsEnv *env, ets_intArray array, ets_size start, ets_size len, const ets_int *buf); + void (*SetLongArrayRegion)(EtsEnv *env, ets_longArray array, ets_size start, ets_size len, const ets_long *buf); + void (*SetFloatArrayRegion)(EtsEnv *env, ets_floatArray array, ets_size start, ets_size len, const ets_float *buf); + void (*SetDoubleArrayRegion)(EtsEnv *env, ets_doubleArray array, ets_size start, ets_size len, + const ets_double *buf); + ets_int (*RegisterNatives)(EtsEnv *env, ets_class cls, const EtsNativeMethod *methods, ets_int nMethods); + ets_int (*UnregisterNatives)(EtsEnv *env, ets_class cls); + ets_int (*GetEtsVM)(EtsEnv *env, EtsVM **vm); + void (*GetStringRegion)(EtsEnv *env, ets_string str, ets_size start, ets_size len, ets_char *buf); + void (*GetStringUTFRegion)(EtsEnv *env, ets_string str, ets_size start, ets_size len, char *buf); + ets_weak (*NewWeakGlobalRef)(EtsEnv *env, ets_object obj); + void (*DeleteWeakGlobalRef)(EtsEnv *env, ets_weak obj); + ets_boolean (*ErrorCheck)(EtsEnv *env); +#ifdef ETS_NAPI_DESIGN_FINISHED + ets_object (*NewDirectByteBuffer)(EtsEnv *env, void *address, ets_long capacity); + void *(*GetDirectBufferAddress)(EtsEnv *env, ets_object buf); + ets_long (*GetDirectBufferCapacity)(EtsEnv *env, ets_object buf); +#endif + ets_objectRefType (*GetObjectRefType)(EtsEnv *env, ets_object obj); + + /* 227 methods */ + + // Promise API + ets_status (*PromiseCreate)(EtsEnv *env, ets_deferred *deferred, ets_object *promise); + ets_status (*DeferredResolve)(EtsEnv *env, ets_deferred deferred, ets_object resolution); + ets_status (*DeferredReject)(EtsEnv *env, ets_deferred deferred, ets_object rejection); +}; +// clang-format on + +// Invocation API Functions +typedef enum { + ETS_LOG_LEVEL, + ETS_MOBILE_LOG, + ETS_BOOT_FILE, + ETS_AOT_FILE, + ETS_ARK_FILE, + ETS_JIT, + ETS_NO_JIT, + ETS_AOT, + ETS_NO_AOT, + ETS_GC_TRIGGER_TYPE, + ETS_GC_TYPE, + ETS_RUN_GC_IN_PLACE, + ETS_INTERPRETER_TYPE, + ETS_NATIVE_LIBRARY_PATH, + ETS_VERIFICATION_MODE +} EtsOptionType; + +typedef struct EtsVMOption { + EtsOptionType option; + const void *extraInfo; +} EtsVMOption; + +typedef struct EtsVMInitArgs { + ets_int version; + ets_int nOptions; + EtsVMOption *options; +} EtsVMInitArgs; + +typedef enum { + ETS_MOBILE_LOG_LEVEL_UNKNOWN = 0, + ETS_MOBILE_LOG_LEVEL_DEFAULT, + ETS_MOBILE_LOG_LEVEL_VERBOSE, + ETS_MOBILE_LOG_LEVEL_DEBUG, + ETS_MOBILE_LOG_LEVEL_INFO, + ETS_MOBILE_LOG_LEVEL_WARN, + ETS_MOBILE_LOG_LEVEL_ERROR, + ETS_MOBILE_LOG_LEVEL_FATAL, + ETS_MOBILE_LOG_LEVEL_SILENT +} EtsMobileLogggerLevel; + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef _MSC_VER +#define ETS_EXPORT __declspec(dllexport) +#else +#define ETS_EXPORT __attribute__((visibility("default"))) +#endif +#define ETS_IMPORT +#define ETS_CALL + +ETS_EXPORT ets_int ETS_GetDefaultVMInitArgs(EtsVMInitArgs *vmArgs); +ETS_EXPORT ets_int ETS_GetCreatedVMs(EtsVM **vmBuf, ets_size bufLen, ets_size *nVms); +ETS_EXPORT ets_int ETS_CreateVM(EtsVM **pVm, EtsEnv **pEnv, EtsVMInitArgs *vmArgs); + +#ifdef __cplusplus +} +#endif + +struct ETS_InvokeInterface { + ets_int (*DestroyEtsVM)(EtsVM *vm); + ets_int (*GetEnv)(EtsVM *vm, EtsEnv **pEnv, ets_int version); +}; + +struct __EtsVM { + // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes) + const struct ETS_InvokeInterface *invoke_interface; + +#ifdef __cplusplus + ets_int DestroyEtsVM() + { + return invoke_interface->DestroyEtsVM(this); + } + + ets_int GetEnv(EtsEnv **pEnv, ets_int version) + { + return invoke_interface->GetEnv(this, pEnv, version); + } +#endif +}; + +struct __EtsEnv { + // NOLINTNEXTLINE(misc-non-private-member-variables-in-classes) + const struct ETS_NativeInterface *native_interface; + +#ifdef __cplusplus + + ets_int GetVersion() + { + return native_interface->GetVersion(this); + } + // DefineClass, + ets_class FindClass(const char *name) + { + return native_interface->FindClass(this, name); + } + // FromReflectedMethod, + // FromReflectedField, + // ToReflectedMethod, + ets_class GetSuperclass(ets_class cls) + { + return native_interface->GetSuperclass(this, cls); + } + ets_boolean IsAssignableFrom(ets_class cls1, ets_class cls2) + { + return native_interface->IsAssignableFrom(this, cls1, cls2); + } + // ToReflectedField, + ets_int ThrowError(ets_error obj) + { + return native_interface->ThrowError(this, obj); + } + ets_int ThrowErrorNew(ets_class cls, const char *message) + { + return native_interface->ThrowErrorNew(this, cls, message); + } + ets_error ErrorOccurred() + { + return native_interface->ErrorOccurred(this); + } + void ErrorDescribe() + { + native_interface->ErrorDescribe(this); + } + void ErrorClear() + { + native_interface->ErrorClear(this); + } + void FatalError(const char *message) + { + native_interface->FatalError(this, message); + } + ets_int PushLocalFrame(ets_int capacity) + { + return native_interface->PushLocalFrame(this, capacity); + } + ets_object PopLocalFrame(ets_object result) + { + return native_interface->PopLocalFrame(this, result); + } + ets_object NewGlobalRef(ets_object obj) + { + return native_interface->NewGlobalRef(this, obj); + } + void DeleteGlobalRef(ets_object globalRef) + { + native_interface->DeleteGlobalRef(this, globalRef); + } + void DeleteLocalRef(ets_object localRef) + { + native_interface->DeleteLocalRef(this, localRef); + } + ets_boolean IsSameObject(ets_object ref1, ets_object ref2) + { + return native_interface->IsSameObject(this, ref1, ref2); + } + ets_object NewLocalRef(ets_object ref) + { + return native_interface->NewLocalRef(this, ref); + } + ets_int EnsureLocalCapacity(ets_int capacity) + { + return native_interface->EnsureLocalCapacity(this, capacity); + } + ets_object AllocObject(ets_class cls) + { + return native_interface->AllocObject(this, cls); + } + ets_object NewObject(ets_class cls, ets_method p_method, ...) + { + va_list args; + va_start(args, p_method); + ets_object ret = native_interface->NewObjectList(this, cls, p_method, args); + va_end(args); + return ret; + } + ets_object NewObjectList(ets_class cls, ets_method p_method, va_list args) + { + return native_interface->NewObjectList(this, cls, p_method, args); + } + ets_object NewObjectArray(ets_class cls, ets_method p_method, const ets_value *args) + { + return native_interface->NewObjectArray(this, cls, p_method, args); + } + ets_class GetObjectClass(ets_object obj) + { + return native_interface->GetObjectClass(this, obj); + } + ets_boolean IsInstanceOf(ets_object obj, ets_class cls) + { + return native_interface->IsInstanceOf(this, obj, cls); + } + ets_method Getp_method(ets_class cls, const char *name, const char *sig) + { + return native_interface->Getp_method(this, cls, name, sig); + } + ets_object CallObjectMethod(ets_object obj, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_object res = native_interface->CallObjectMethodList(this, obj, method_id, args); + va_end(args); + return res; + } + ets_object CallObjectMethodList(ets_object obj, ets_method method_id, va_list args) + { + return native_interface->CallObjectMethodList(this, obj, method_id, args); + } + ets_object CallObjectMethodArray(ets_object obj, ets_method method_id, const ets_value *args) + { + return native_interface->CallObjectMethodArray(this, obj, method_id, args); + } + ets_boolean CallBooleanMethod(ets_object obj, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_boolean res = native_interface->CallBooleanMethodList(this, obj, method_id, args); + va_end(args); + return res; + } + ets_boolean CallBooleanMethodList(ets_object obj, ets_method method_id, va_list args) + { + return native_interface->CallBooleanMethodList(this, obj, method_id, args); + } + ets_boolean CallBooleanMethodArray(ets_object obj, ets_method method_id, const ets_value *args) + { + return native_interface->CallBooleanMethodArray(this, obj, method_id, args); + } + ets_byte CallByteMethod(ets_object obj, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_byte res = native_interface->CallByteMethodList(this, obj, method_id, args); + va_end(args); + return res; + } + ets_byte CallByteMethodList(ets_object obj, ets_method method_id, va_list args) + { + return native_interface->CallByteMethodList(this, obj, method_id, args); + } + ets_byte CallByteMethodArray(ets_object obj, ets_method method_id, const ets_value *args) + { + return native_interface->CallByteMethodArray(this, obj, method_id, args); + } + ets_char CallCharMethod(ets_object obj, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_char res = native_interface->CallCharMethodList(this, obj, method_id, args); + va_end(args); + return res; + } + ets_char CallCharMethodList(ets_object obj, ets_method method_id, va_list args) + { + return native_interface->CallCharMethodList(this, obj, method_id, args); + } + ets_char CallCharMethodArray(ets_object obj, ets_method method_id, const ets_value *args) + { + return native_interface->CallCharMethodArray(this, obj, method_id, args); + } + ets_short CallShortMethod(ets_object obj, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_short res = native_interface->CallShortMethodList(this, obj, method_id, args); + va_end(args); + return res; + } + ets_short CallShortMethodList(ets_object obj, ets_method method_id, va_list args) + { + return native_interface->CallShortMethodList(this, obj, method_id, args); + } + ets_short CallShortMethodArray(ets_object obj, ets_method method_id, const ets_value *args) + { + return native_interface->CallShortMethodArray(this, obj, method_id, args); + } + ets_int CallIntMethod(ets_object obj, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_int res = native_interface->CallIntMethodList(this, obj, method_id, args); + va_end(args); + return res; + } + ets_int CallIntMethodList(ets_object obj, ets_method method_id, va_list args) + { + return native_interface->CallIntMethodList(this, obj, method_id, args); + } + ets_int CallIntMethodArray(ets_object obj, ets_method method_id, const ets_value *args) + { + return native_interface->CallIntMethodArray(this, obj, method_id, args); + } + ets_long CallLongMethod(ets_object obj, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_long res = native_interface->CallLongMethodList(this, obj, method_id, args); + va_end(args); + return res; + } + ets_long CallLongMethodList(ets_object obj, ets_method method_id, va_list args) + { + return native_interface->CallLongMethodList(this, obj, method_id, args); + } + ets_long CallLongMethodArray(ets_object obj, ets_method method_id, const ets_value *args) + { + return native_interface->CallLongMethodArray(this, obj, method_id, args); + } + ets_float CallFloatMethod(ets_object obj, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_float res = native_interface->CallFloatMethodList(this, obj, method_id, args); + va_end(args); + return res; + } + ets_float CallFloatMethodList(ets_object obj, ets_method method_id, va_list args) + { + return native_interface->CallFloatMethodList(this, obj, method_id, args); + } + ets_float CallFloatMethodArray(ets_object obj, ets_method method_id, const ets_value *args) + { + return native_interface->CallFloatMethodArray(this, obj, method_id, args); + } + ets_double CallDoubleMethod(ets_object obj, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_double res = native_interface->CallDoubleMethodList(this, obj, method_id, args); + va_end(args); + return res; + } + ets_double CallDoubleMethodList(ets_object obj, ets_method method_id, va_list args) + { + return native_interface->CallDoubleMethodList(this, obj, method_id, args); + } + ets_double CallDoubleMethodArray(ets_object obj, ets_method method_id, const ets_value *args) + { + return native_interface->CallDoubleMethodArray(this, obj, method_id, args); + } + void CallVoidMethod(ets_object obj, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + native_interface->CallVoidMethodList(this, obj, method_id, args); + va_end(args); + } + void CallVoidMethodList(ets_object obj, ets_method method_id, va_list args) + { + native_interface->CallVoidMethodList(this, obj, method_id, args); + } + void CallVoidMethodArray(ets_object obj, ets_method method_id, const ets_value *args) + { + native_interface->CallVoidMethodArray(this, obj, method_id, args); + } + ets_object CallNonvirtualObjectMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_object res = native_interface->CallNonvirtualObjectMethodList(this, obj, cls, method_id, args); + va_end(args); + return res; + } + ets_object CallNonvirtualObjectMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallNonvirtualObjectMethodList(this, obj, cls, method_id, args); + } + ets_object CallNonvirtualObjectMethodArray(ets_object obj, ets_class cls, ets_method method_id, + const ets_value *args) + { + return native_interface->CallNonvirtualObjectMethodArray(this, obj, cls, method_id, args); + } + ets_boolean CallNonvirtualBooleanMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_boolean res = native_interface->CallNonvirtualBooleanMethodList(this, obj, cls, method_id, args); + va_end(args); + return res; + } + ets_boolean CallNonvirtualBooleanMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallNonvirtualBooleanMethodList(this, obj, cls, method_id, args); + } + ets_boolean CallNonvirtualBooleanMethodArray(ets_object obj, ets_class cls, ets_method method_id, + const ets_value *args) + { + return native_interface->CallNonvirtualBooleanMethodArray(this, obj, cls, method_id, args); + } + ets_byte CallNonvirtualByteMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_byte res = native_interface->CallNonvirtualByteMethodList(this, obj, cls, method_id, args); + va_end(args); + return res; + } + ets_byte CallNonvirtualByteMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallNonvirtualByteMethodList(this, obj, cls, method_id, args); + } + ets_byte CallNonvirtualByteMethodArray(ets_object obj, ets_class cls, ets_method method_id, const ets_value *args) + { + return native_interface->CallNonvirtualByteMethodArray(this, obj, cls, method_id, args); + } + ets_char CallNonvirtualCharMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_char res = native_interface->CallNonvirtualCharMethodList(this, obj, cls, method_id, args); + va_end(args); + return res; + } + ets_char CallNonvirtualCharMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallNonvirtualCharMethodList(this, obj, cls, method_id, args); + } + ets_char CallNonvirtualCharMethodArray(ets_object obj, ets_class cls, ets_method method_id, const ets_value *args) + { + return native_interface->CallNonvirtualCharMethodArray(this, obj, cls, method_id, args); + } + ets_short CallNonvirtualShortMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_short res = native_interface->CallNonvirtualShortMethodList(this, obj, cls, method_id, args); + va_end(args); + return res; + } + ets_short CallNonvirtualShortMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallNonvirtualShortMethodList(this, obj, cls, method_id, args); + } + ets_short CallNonvirtualShortMethodArray(ets_object obj, ets_class cls, ets_method method_id, const ets_value *args) + { + return native_interface->CallNonvirtualShortMethodArray(this, obj, cls, method_id, args); + } + ets_int CallNonvirtualIntMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_int res = native_interface->CallNonvirtualIntMethodList(this, obj, cls, method_id, args); + va_end(args); + return res; + } + ets_int CallNonvirtualIntMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallNonvirtualIntMethodList(this, obj, cls, method_id, args); + } + ets_int CallNonvirtualIntMethodArray(ets_object obj, ets_class cls, ets_method method_id, const ets_value *args) + { + return native_interface->CallNonvirtualIntMethodArray(this, obj, cls, method_id, args); + } + ets_long CallNonvirtualLongMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_long res = native_interface->CallNonvirtualLongMethodList(this, obj, cls, method_id, args); + va_end(args); + return res; + } + ets_long CallNonvirtualLongMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallNonvirtualLongMethodList(this, obj, cls, method_id, args); + } + ets_long CallNonvirtualLongMethodArray(ets_object obj, ets_class cls, ets_method method_id, const ets_value *args) + { + return native_interface->CallNonvirtualLongMethodArray(this, obj, cls, method_id, args); + } + ets_float CallNonvirtualFloatMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_float res = native_interface->CallNonvirtualFloatMethodList(this, obj, cls, method_id, args); + va_end(args); + return res; + } + ets_float CallNonvirtualFloatMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallNonvirtualFloatMethodList(this, obj, cls, method_id, args); + } + ets_float CallNonvirtualFloatMethodArray(ets_object obj, ets_class cls, ets_method method_id, const ets_value *args) + { + return native_interface->CallNonvirtualFloatMethodArray(this, obj, cls, method_id, args); + } + ets_double CallNonvirtualDoubleMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_double res = native_interface->CallNonvirtualDoubleMethodList(this, obj, cls, method_id, args); + va_end(args); + return res; + } + ets_double CallNonvirtualDoubleMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallNonvirtualDoubleMethodList(this, obj, cls, method_id, args); + } + ets_double CallNonvirtualDoubleMethodArray(ets_object obj, ets_class cls, ets_method method_id, + const ets_value *args) + { + return native_interface->CallNonvirtualDoubleMethodArray(this, obj, cls, method_id, args); + } + void CallNonvirtualVoidMethod(ets_object obj, ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + native_interface->CallNonvirtualVoidMethodList(this, obj, cls, method_id, args); + va_end(args); + } + void CallNonvirtualVoidMethodList(ets_object obj, ets_class cls, ets_method method_id, va_list args) + { + native_interface->CallNonvirtualVoidMethodList(this, obj, cls, method_id, args); + } + void CallNonvirtualVoidMethodArray(ets_object obj, ets_class cls, ets_method method_id, const ets_value *args) + { + native_interface->CallNonvirtualVoidMethodArray(this, obj, cls, method_id, args); + } + ets_field Getp_field(ets_class cls, const char *name, const char *sig) + { + return native_interface->Getp_field(this, cls, name, sig); + } + ets_object GetObjectField(ets_object obj, ets_field p_field) + { + return native_interface->GetObjectField(this, obj, p_field); + } + ets_boolean GetBooleanField(ets_object obj, ets_field p_field) + { + return native_interface->GetBooleanField(this, obj, p_field); + } + ets_byte GetByteField(ets_object obj, ets_field p_field) + { + return native_interface->GetByteField(this, obj, p_field); + } + ets_char GetCharField(ets_object obj, ets_field p_field) + { + return native_interface->GetCharField(this, obj, p_field); + } + ets_short GetShortField(ets_object obj, ets_field p_field) + { + return native_interface->GetShortField(this, obj, p_field); + } + ets_int GetIntField(ets_object obj, ets_field p_field) + { + return native_interface->GetIntField(this, obj, p_field); + } + ets_long GetLongField(ets_object obj, ets_field p_field) + { + return native_interface->GetLongField(this, obj, p_field); + } + ets_float GetFloatField(ets_object obj, ets_field p_field) + { + return native_interface->GetFloatField(this, obj, p_field); + } + ets_double GetDoubleField(ets_object obj, ets_field p_field) + { + return native_interface->GetDoubleField(this, obj, p_field); + } + void SetObjectField(ets_object obj, ets_field p_field, ets_object value) + { + return native_interface->SetObjectField(this, obj, p_field, value); + } + void SetBooleanField(ets_object obj, ets_field p_field, ets_boolean value) + { + return native_interface->SetBooleanField(this, obj, p_field, value); + } + void SetByteField(ets_object obj, ets_field p_field, ets_byte value) + { + return native_interface->SetByteField(this, obj, p_field, value); + } + void SetCharField(ets_object obj, ets_field p_field, ets_char value) + { + return native_interface->SetCharField(this, obj, p_field, value); + } + void SetShortField(ets_object obj, ets_field p_field, ets_short value) + { + return native_interface->SetShortField(this, obj, p_field, value); + } + void SetIntField(ets_object obj, ets_field p_field, ets_int value) + { + return native_interface->SetIntField(this, obj, p_field, value); + } + void SetLongField(ets_object obj, ets_field p_field, ets_long value) + { + return native_interface->SetLongField(this, obj, p_field, value); + } + void SetFloatField(ets_object obj, ets_field p_field, ets_float value) + { + return native_interface->SetFloatField(this, obj, p_field, value); + } + void SetDoubleField(ets_object obj, ets_field p_field, ets_double value) + { + return native_interface->SetDoubleField(this, obj, p_field, value); + } + ets_method GetStaticp_method(ets_class cls, const char *name, const char *sig) + { + return native_interface->GetStaticp_method(this, cls, name, sig); + } + ets_object CallStaticObjectMethod(ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_object res = native_interface->CallStaticObjectMethodList(this, cls, method_id, args); + va_end(args); + return res; + } + ets_object CallStaticObjectMethodList(ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallStaticObjectMethodList(this, cls, method_id, args); + } + ets_object CallStaticObjectMethodArray(ets_class cls, ets_method method_id, ets_value *args) + { + return native_interface->CallStaticObjectMethodArray(this, cls, method_id, args); + } + ets_boolean CallStaticBooleanMethod(ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_boolean res = native_interface->CallStaticBooleanMethodList(this, cls, method_id, args); + va_end(args); + return res; + } + ets_boolean CallStaticBooleanMethodList(ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallStaticBooleanMethodList(this, cls, method_id, args); + } + ets_boolean CallStaticBooleanMethodArray(ets_class cls, ets_method method_id, ets_value *args) + { + return native_interface->CallStaticBooleanMethodArray(this, cls, method_id, args); + } + ets_byte CallStaticByteMethod(ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_byte res = native_interface->CallStaticByteMethodList(this, cls, method_id, args); + va_end(args); + return res; + } + ets_byte CallStaticByteMethodList(ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallStaticByteMethodList(this, cls, method_id, args); + } + ets_byte CallStaticByteMethodArray(ets_class cls, ets_method method_id, ets_value *args) + { + return native_interface->CallStaticByteMethodArray(this, cls, method_id, args); + } + ets_char CallStaticCharMethod(ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_char res = native_interface->CallStaticCharMethodList(this, cls, method_id, args); + va_end(args); + return res; + } + ets_char CallStaticCharMethodList(ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallStaticCharMethodList(this, cls, method_id, args); + } + ets_char CallStaticCharMethodArray(ets_class cls, ets_method method_id, ets_value *args) + { + return native_interface->CallStaticCharMethodArray(this, cls, method_id, args); + } + ets_short CallStaticShortMethod(ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_short res = native_interface->CallStaticShortMethodList(this, cls, method_id, args); + va_end(args); + return res; + } + ets_short CallStaticShortMethodList(ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallStaticShortMethodList(this, cls, method_id, args); + } + ets_short CallStaticShortMethodArray(ets_class cls, ets_method method_id, ets_value *args) + { + return native_interface->CallStaticShortMethodArray(this, cls, method_id, args); + } + ets_int CallStaticIntMethod(ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_int res = native_interface->CallStaticIntMethodList(this, cls, method_id, args); + va_end(args); + return res; + } + ets_int CallStaticIntMethodList(ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallStaticIntMethodList(this, cls, method_id, args); + } + ets_int CallStaticIntMethodArray(ets_class cls, ets_method method_id, ets_value *args) + { + return native_interface->CallStaticIntMethodArray(this, cls, method_id, args); + } + ets_long CallStaticLongMethod(ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_long res = native_interface->CallStaticLongMethodList(this, cls, method_id, args); + va_end(args); + return res; + } + ets_long CallStaticLongMethodList(ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallStaticLongMethodList(this, cls, method_id, args); + } + ets_long CallStaticLongMethodArray(ets_class cls, ets_method method_id, ets_value *args) + { + return native_interface->CallStaticLongMethodArray(this, cls, method_id, args); + } + ets_float CallStaticFloatMethod(ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_float res = native_interface->CallStaticFloatMethodList(this, cls, method_id, args); + va_end(args); + return res; + } + ets_float CallStaticFloatMethodList(ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallStaticFloatMethodList(this, cls, method_id, args); + } + ets_float CallStaticFloatMethodArray(ets_class cls, ets_method method_id, ets_value *args) + { + return native_interface->CallStaticFloatMethodArray(this, cls, method_id, args); + } + ets_double CallStaticDoubleMethod(ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + ets_double res = native_interface->CallStaticDoubleMethodList(this, cls, method_id, args); + va_end(args); + return res; + } + ets_double CallStaticDoubleMethodList(ets_class cls, ets_method method_id, va_list args) + { + return native_interface->CallStaticDoubleMethodList(this, cls, method_id, args); + } + ets_double CallStaticDoubleMethodArray(ets_class cls, ets_method method_id, ets_value *args) + { + return native_interface->CallStaticDoubleMethodArray(this, cls, method_id, args); + } + void CallStaticVoidMethod(ets_class cls, ets_method method_id, ...) + { + va_list args; + va_start(args, method_id); + native_interface->CallStaticVoidMethodList(this, cls, method_id, args); + va_end(args); + } + void CallStaticVoidMethodList(ets_class cls, ets_method method_id, va_list args) + { + native_interface->CallStaticVoidMethodList(this, cls, method_id, args); + } + void CallStaticVoidMethodArray(ets_class cls, ets_method method_id, ets_value *args) + { + native_interface->CallStaticVoidMethodArray(this, cls, method_id, args); + } + ets_field GetStaticp_field(ets_class cls, const char *name, const char *sig) + { + return native_interface->GetStaticp_field(this, cls, name, sig); + } + ets_object GetStaticObjectField(ets_class cls, ets_field p_field) + { + return native_interface->GetStaticObjectField(this, cls, p_field); + } + ets_boolean GetStaticBooleanField(ets_class cls, ets_field p_field) + { + return native_interface->GetStaticBooleanField(this, cls, p_field); + } + ets_byte GetStaticByteField(ets_class cls, ets_field p_field) + { + return native_interface->GetStaticByteField(this, cls, p_field); + } + ets_char GetStaticCharField(ets_class cls, ets_field p_field) + { + return native_interface->GetStaticCharField(this, cls, p_field); + } + ets_short GetStaticShortField(ets_class cls, ets_field p_field) + { + return native_interface->GetStaticShortField(this, cls, p_field); + } + ets_int GetStaticIntField(ets_class cls, ets_field p_field) + { + return native_interface->GetStaticIntField(this, cls, p_field); + } + ets_long GetStaticLongField(ets_class cls, ets_field p_field) + { + return native_interface->GetStaticLongField(this, cls, p_field); + } + ets_float GetStaticFloatField(ets_class cls, ets_field p_field) + { + return native_interface->GetStaticFloatField(this, cls, p_field); + } + ets_double GetStaticDoubleField(ets_class cls, ets_field p_field) + { + return native_interface->GetStaticDoubleField(this, cls, p_field); + } + void SetStaticObjectField(ets_class cls, ets_field p_field, ets_object value) + { + return native_interface->SetStaticObjectField(this, cls, p_field, value); + } + void SetStaticBooleanField(ets_class cls, ets_field p_field, ets_boolean value) + { + return native_interface->SetStaticBooleanField(this, cls, p_field, value); + } + void SetStaticByteField(ets_class cls, ets_field p_field, ets_byte value) + { + return native_interface->SetStaticByteField(this, cls, p_field, value); + } + void SetStaticCharField(ets_class cls, ets_field p_field, ets_char value) + { + return native_interface->SetStaticCharField(this, cls, p_field, value); + } + void SetStaticShortField(ets_class cls, ets_field p_field, ets_short value) + { + return native_interface->SetStaticShortField(this, cls, p_field, value); + } + void SetStaticIntField(ets_class cls, ets_field p_field, ets_int value) + { + return native_interface->SetStaticIntField(this, cls, p_field, value); + } + void SetStaticLongField(ets_class cls, ets_field p_field, ets_long value) + { + return native_interface->SetStaticLongField(this, cls, p_field, value); + } + void SetStaticFloatField(ets_class cls, ets_field p_field, ets_float value) + { + return native_interface->SetStaticFloatField(this, cls, p_field, value); + } + void SetStaticDoubleField(ets_class cls, ets_field p_field, ets_double value) + { + return native_interface->SetStaticDoubleField(this, cls, p_field, value); + } + ets_string NewString(const ets_char *unicode_chars, ets_size len) + { + return native_interface->NewString(this, unicode_chars, len); + } + ets_size GetStringLength(ets_string string) + { + return native_interface->GetStringLength(this, string); + } + const ets_char *GetStringChars(ets_string string, ets_boolean *is_copy) + { + return native_interface->GetStringChars(this, string, is_copy); + } + void ReleaseStringChars(ets_string string, const ets_char *chars) + { + native_interface->ReleaseStringChars(this, string, chars); + } + ets_string NewStringUTF(const char *bytes) + { + return native_interface->NewStringUTF(this, bytes); + } + ets_size GetStringUTFLength(ets_string string) + { + return native_interface->GetStringUTFLength(this, string); + } + const char *GetStringUTFChars(ets_string string, ets_boolean *is_copy) + { + return native_interface->GetStringUTFChars(this, string, is_copy); + } + void ReleaseStringUTFChars(ets_string string, const char *chars) + { + native_interface->ReleaseStringUTFChars(this, string, chars); + } + ets_size GetArrayLength(ets_array array) + { + return native_interface->GetArrayLength(this, array); + } + ets_objectArray NewObjectsArray(ets_size length, ets_class element_class, ets_object initial_element) + { + return native_interface->NewObjectsArray(this, length, element_class, initial_element); + } + ets_object GetObjectArrayElement(ets_objectArray array, ets_size index) + { + return native_interface->GetObjectArrayElement(this, array, index); + } + + void SetObjectArrayElement(ets_objectArray array, ets_size index, ets_object value) + { + native_interface->SetObjectArrayElement(this, array, index, value); + } + + // SetObjectArrayElement, + ets_booleanArray NewBooleanArray(ets_size length) + { + return native_interface->NewBooleanArray(this, length); + } + ets_byteArray NewByteArray(ets_size length) + { + return native_interface->NewByteArray(this, length); + } + ets_charArray NewCharArray(ets_size length) + { + return native_interface->NewCharArray(this, length); + } + ets_shortArray NewShortArray(ets_size length) + { + return native_interface->NewShortArray(this, length); + } + ets_intArray NewIntArray(ets_size length) + { + return native_interface->NewIntArray(this, length); + } + ets_longArray NewLongArray(ets_size length) + { + return native_interface->NewLongArray(this, length); + } + ets_floatArray NewFloatArray(ets_size length) + { + return native_interface->NewFloatArray(this, length); + } + ets_doubleArray NewDoubleArray(ets_size length) + { + return native_interface->NewDoubleArray(this, length); + } + ets_boolean *PinBooleanArray(ets_booleanArray array) + { + return native_interface->PinBooleanArray(this, array); + } + ets_byte *PinByteArray(ets_byteArray array) + { + return native_interface->PinByteArray(this, array); + } + ets_char *PinCharArray(ets_charArray array) + { + return native_interface->PinCharArray(this, array); + } + ets_short *PinShortArray(ets_shortArray array) + { + return native_interface->PinShortArray(this, array); + } + ets_int *PinIntArray(ets_intArray array) + { + return native_interface->PinIntArray(this, array); + } + ets_long *PinLongArray(ets_longArray array) + { + return native_interface->PinLongArray(this, array); + } + ets_float *PinFloatArray(ets_floatArray array) + { + return native_interface->PinFloatArray(this, array); + } + ets_double *PinDoubleArray(ets_doubleArray array) + { + return native_interface->PinDoubleArray(this, array); + } + void UnpinBooleanArray(ets_booleanArray array) + { + return native_interface->UnpinBooleanArray(this, array); + } + void UnpinByteArray(ets_byteArray array) + { + return native_interface->UnpinByteArray(this, array); + } + void UnpinCharArray(ets_charArray array) + { + return native_interface->UnpinCharArray(this, array); + } + void UnpinShortArray(ets_shortArray array) + { + return native_interface->UnpinShortArray(this, array); + } + void UnpinIntArray(ets_intArray array) + { + return native_interface->UnpinIntArray(this, array); + } + void UnpinLongArray(ets_longArray array) + { + return native_interface->UnpinLongArray(this, array); + } + void UnpinFloatArray(ets_floatArray array) + { + return native_interface->UnpinFloatArray(this, array); + } + void UnpinDoubleArray(ets_doubleArray array) + { + return native_interface->UnpinDoubleArray(this, array); + } + void GetBooleanArrayRegion(ets_booleanArray array, ets_size start, ets_size len, ets_boolean *buf) + { + return native_interface->GetBooleanArrayRegion(this, array, start, len, buf); + } + void GetByteArrayRegion(ets_byteArray array, ets_size start, ets_size len, ets_byte *buf) + { + return native_interface->GetByteArrayRegion(this, array, start, len, buf); + } + void GetCharArrayRegion(ets_charArray array, ets_size start, ets_size len, ets_char *buf) + { + return native_interface->GetCharArrayRegion(this, array, start, len, buf); + } + void GetShortArrayRegion(ets_shortArray array, ets_size start, ets_size len, ets_short *buf) + { + return native_interface->GetShortArrayRegion(this, array, start, len, buf); + } + void GetIntArrayRegion(ets_intArray array, ets_size start, ets_size len, ets_int *buf) + { + return native_interface->GetIntArrayRegion(this, array, start, len, buf); + } + void GetLongArrayRegion(ets_longArray array, ets_size start, ets_size len, ets_long *buf) + { + return native_interface->GetLongArrayRegion(this, array, start, len, buf); + } + void GetFloatArrayRegion(ets_floatArray array, ets_size start, ets_size len, ets_float *buf) + { + return native_interface->GetFloatArrayRegion(this, array, start, len, buf); + } + void GetDoubleArrayRegion(ets_doubleArray array, ets_size start, ets_size len, ets_double *buf) + { + return native_interface->GetDoubleArrayRegion(this, array, start, len, buf); + } + void SetBooleanArrayRegion(ets_booleanArray array, ets_size start, ets_size length, const ets_boolean *buf) + { + native_interface->SetBooleanArrayRegion(this, array, start, length, buf); + } + void SetByteArrayRegion(ets_byteArray array, ets_size start, ets_size length, const ets_byte *buf) + { + native_interface->SetByteArrayRegion(this, array, start, length, buf); + } + void SetCharArrayRegion(ets_charArray array, ets_size start, ets_size length, const ets_char *buf) + { + native_interface->SetCharArrayRegion(this, array, start, length, buf); + } + void SetShortArrayRegion(ets_shortArray array, ets_size start, ets_size length, const ets_short *buf) + { + native_interface->SetShortArrayRegion(this, array, start, length, buf); + } + void SetIntArrayRegion(ets_intArray array, ets_size start, ets_size length, const ets_int *buf) + { + native_interface->SetIntArrayRegion(this, array, start, length, buf); + } + void SetLongArrayRegion(ets_longArray array, ets_size start, ets_size length, const ets_long *buf) + { + native_interface->SetLongArrayRegion(this, array, start, length, buf); + } + void SetFloatArrayRegion(ets_floatArray array, ets_size start, ets_size length, const ets_float *buf) + { + native_interface->SetFloatArrayRegion(this, array, start, length, buf); + } + void SetDoubleArrayRegion(ets_doubleArray array, ets_size start, ets_size length, const ets_double *buf) + { + native_interface->SetDoubleArrayRegion(this, array, start, length, buf); + } + ets_int RegisterNatives(ets_class cls, const EtsNativeMethod *methods, ets_int nMethods) + { + return native_interface->RegisterNatives(this, cls, methods, nMethods); + } + ets_int UnregisterNatives(ets_class cls) + { + return native_interface->UnregisterNatives(this, cls); + } + ets_int GetEtsVM(EtsVM **vm) + { + return native_interface->GetEtsVM(this, vm); + } + void GetStringRegion(ets_string str, ets_size start, ets_size len, ets_char *buf) + { + native_interface->GetStringRegion(this, str, start, len, buf); + } + void GetStringUTFRegion(ets_string str, ets_size start, ets_size len, char *buf) + { + native_interface->GetStringUTFRegion(this, str, start, len, buf); + } + ets_weak NewWeakGlobalRef(ets_object obj) + { + return native_interface->NewWeakGlobalRef(this, obj); + } + void DeleteWeakGlobalRef(ets_weak obj) + { + native_interface->DeleteWeakGlobalRef(this, obj); + } + ets_boolean ErrorCheck() + { + return native_interface->ErrorCheck(this); + } + // NewDirectByteBuffer, + // GetDirectBufferAddress, + // GetDirectBufferCapacity, + ets_objectRefType GetObjectRefType(ets_object obj) + { + return native_interface->GetObjectRefType(this, obj); + } + + // Promise + ets_status PromiseCreate(ets_deferred *deferred, ets_object *promise) + { + return native_interface->PromiseCreate(this, deferred, promise); + } + ets_status DeferredResolve(ets_deferred deferred, ets_object resolution) + { + return native_interface->DeferredResolve(this, deferred, resolution); + } + ets_status DeferredReject(ets_deferred deferred, ets_object rejection) + { + return native_interface->DeferredReject(this, deferred, rejection); + } +#endif +}; + +// NOLINTEND(modernize-use-using, readability-identifier-naming, cppcoreguidelines-pro-type-vararg) + +#endif // PANDA_RUNTIME_INTEROP_ETS_NAPI_H diff --git a/ets1.2/interop/src/cpp/interop-logging.cc b/ets1.2/interop/src/cpp/interop-logging.cc new file mode 100644 index 0000000000000000000000000000000000000000..9f04c822476e6386ad9996e91c72ef6153c9aa94 --- /dev/null +++ b/ets1.2/interop/src/cpp/interop-logging.cc @@ -0,0 +1,91 @@ +/* + * Copyright (c) 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. + */ +#include +#include +#include + +#include "interop-logging.h" +#include "interop-utils.h" + +namespace { + +struct Log { + std::string log; + bool isActive = true; +}; + +std::vector groupedLogs; + +void startGroupedLog(int index) { + if (index >= static_cast(groupedLogs.size())) { + groupedLogs.resize(index + 1); + for (int i = 0; i <= index; i++) { + if (!groupedLogs[i]) groupedLogs[i] = new Log(); + } + } + groupedLogs[index]->isActive = true; + groupedLogs[index]->log.clear(); +} + +void stopGroupedLog(int index) { + if (index < static_cast(groupedLogs.size())) { + groupedLogs[index]->isActive = false; + } +} + +void appendGroupedLog(int index, const char* str) { + if (index < static_cast(groupedLogs.size())) { + groupedLogs[index]->log.append(str); + } +} + +const char* getGroupedLog(int index) { + if (index < static_cast(groupedLogs.size())) { + const char* result = groupedLogs[index]->log.c_str(); + return result; + } + return ""; +} + +int needGroupedLog(int index) { + if (index < static_cast(groupedLogs.size())) { + return groupedLogs[index]->isActive; + } + return 0; +} + +const GroupLogger defaultInstance = { + startGroupedLog, + stopGroupedLog, + appendGroupedLog, + getGroupedLog, + needGroupedLog, +}; + +} // namespace + +const GroupLogger* GetDefaultLogger() { + return &defaultInstance; +} + +extern "C" [[noreturn]] void InteropLogFatal(const char* format, ...) { + va_list args; + va_start(args, format); + char buffer[4096]; + interop_vsnprintf(buffer, sizeof(buffer) - 1, format, args); + LOGE("FATAL: %s", buffer); + va_end(args); + abort(); +} \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/interop-logging.h b/ets1.2/interop/src/cpp/interop-logging.h new file mode 100644 index 0000000000000000000000000000000000000000..61b49069987c266a238ddeb8347d51385908c2de --- /dev/null +++ b/ets1.2/interop/src/cpp/interop-logging.h @@ -0,0 +1,62 @@ +/* + * Copyright (c) 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. + */ +#ifndef _INTEROP_LGGING_H +#define _INTEROP_LGGING_H + +#ifdef __cplusplus + #include + #include + #include +#else + #include + #include + #include +#endif + +#if defined(KOALA_OHOS) +#include "oh_sk_log.h" +#define LOG(msg) OH_SK_LOG_INFO(msg); +#define LOGI(msg, ...) OH_SK_LOG_INFO_A(msg, ##__VA_ARGS__); +#define LOGE(msg, ...) OH_SK_LOG_ERROR_A(msg, ##__VA_ARGS__); +#define LOG_PUBLIC "{public}" +#else +#define LOG(msg) fprintf(stdout, msg "\n"); +#define LOGI(msg, ...) fprintf(stdout, msg "\n", ##__VA_ARGS__); +#define LOGE(msg, ...) fprintf(stderr, msg "\n", ##__VA_ARGS__); +#define LOG_PUBLIC "" +#endif + +#if defined(KOALA_WINDOWS) +#define INTEROP_API_EXPORT __declspec(dllexport) +#else +#define INTEROP_API_EXPORT __attribute__((visibility("default"))) +#endif + +#ifndef ASSERT + #define ASSERT(expression) assert(expression) +#endif + +// Grouped logs. Keep consistent with type in ServiceGroupLogger +typedef struct GroupLogger { + void (*startGroupedLog)(int kind); + void (*stopGroupedLog)(int kind); + void (*appendGroupedLog)(int kind, const char* str); + const char* (*getGroupedLog)(int kind); + int (*needGroupedLog)(int kind); +} GroupLogger; + +extern "C" INTEROP_API_EXPORT const GroupLogger* GetDefaultLogger(); + +#endif // _INTEROP_LOGGING_H \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/interop-types.h b/ets1.2/interop/src/cpp/interop-types.h new file mode 100644 index 0000000000000000000000000000000000000000..cabdbc450bd4718ba4dd765ea0d5ddce991a4424 --- /dev/null +++ b/ets1.2/interop/src/cpp/interop-types.h @@ -0,0 +1,164 @@ +/* + * Copyright (c) 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. +*/ + +#ifndef _INTEROP_TYPES_H_ +#define _INTEROP_TYPES_H_ + +#ifdef __cplusplus + #include +#else + #include +#endif + +#ifdef __cplusplus +extern "C" [[noreturn]] +#endif +void InteropLogFatal(const char* format, ...); +#define INTEROP_FATAL(msg, ...) do { InteropLogFatal(msg, ##__VA_ARGS__); } while (0) + +typedef enum InteropTag +{ + INTEROP_TAG_UNDEFINED = 101, + INTEROP_TAG_INT32 = 102, + INTEROP_TAG_FLOAT32 = 103, + INTEROP_TAG_STRING = 104, + INTEROP_TAG_LENGTH = 105, + INTEROP_TAG_RESOURCE = 106, + INTEROP_TAG_OBJECT = 107, +} InteropTag; + +typedef enum InteropRuntimeType +{ + INTEROP_RUNTIME_UNEXPECTED = -1, + INTEROP_RUNTIME_NUMBER = 1, + INTEROP_RUNTIME_STRING = 2, + INTEROP_RUNTIME_OBJECT = 3, + INTEROP_RUNTIME_BOOLEAN = 4, + INTEROP_RUNTIME_UNDEFINED = 5, + INTEROP_RUNTIME_BIGINT = 6, + INTEROP_RUNTIME_FUNCTION = 7, + INTEROP_RUNTIME_SYMBOL = 8, + INTEROP_RUNTIME_MATERIALIZED = 9, +} InteropRuntimeType; + +typedef float InteropFloat32; +typedef double InteropFloat64; +typedef int32_t InteropInt32; +typedef unsigned int InteropUInt32; // Improve: update unsigned int +typedef int64_t InteropInt64; +typedef uint64_t InteropUInt64; +typedef int8_t InteropInt8; +typedef uint8_t InteropUInt8; +typedef int64_t InteropDate; +typedef int8_t InteropBoolean; +typedef const char* InteropCharPtr; +typedef void* InteropNativePointer; + +struct _InteropVMContext; +typedef struct _InteropVMContext* InteropVMContext; +struct _InteropPipelineContext; +typedef struct _InteropPipelineContext* InteropPipelineContext; +struct _InteropVMObject; +typedef struct _InteropVMObject* InteropVMObject; +struct _InteropNode; +typedef struct _InteropNode* InteropNodeHandle; +typedef struct InteropDeferred { + void* handler; + void* context; + void (*resolve)(struct InteropDeferred* thiz, uint8_t* data, int32_t length); + void (*reject)(struct InteropDeferred* thiz, const char* message); +} InteropDeferred; + +// Binary layout of InteropString must match that of KStringPtrImpl. +typedef struct InteropString { + const char* chars; + InteropInt32 length; +} InteropString; + +typedef struct InteropEmpty { + InteropInt32 dummy; // Empty structs are forbidden in C. +} InteropEmpty; + +typedef struct InteropNumber { + InteropInt8 tag; + union { + InteropFloat32 f32; + InteropInt32 i32; + }; +} InteropNumber; + +typedef struct InteropCustomObject { + char kind[20]; + InteropInt32 id; + // Data of custom object. + union { + InteropInt32 ints[4]; + InteropFloat32 floats[4]; + void* pointers[4]; + InteropString string; + }; +} InteropCustomObject; + +typedef struct InteropUndefined { + InteropInt32 dummy; // Empty structs are forbidden in C. +} InteropUndefined; + +typedef struct InteropVoid { + InteropInt32 dummy; // Empty structs are forbidden in C. +} InteropVoid; + +typedef struct InteropFunction { + InteropInt32 id; +} InteropFunction; +typedef InteropFunction InteropCallback; +typedef InteropFunction InteropErrorCallback; + +typedef struct InteropMaterialized { + InteropNativePointer ptr; +} InteropMaterialized; + +typedef struct InteropCallbackResource { + InteropInt32 resourceId; + void (*hold)(InteropInt32 resourceId); + void (*release)(InteropInt32 resourceId); +} InteropCallbackResource; + +typedef struct InteropBuffer { + InteropCallbackResource resource; + InteropNativePointer data; + InteropInt64 length; +} InteropBuffer; + +typedef struct InteropAsyncWork { + InteropNativePointer workId; + void (*queue)(InteropNativePointer workId); + void (*cancel)(InteropNativePointer workId); +} InteropAsyncWork; + +typedef struct InteropAsyncWorker { + InteropAsyncWork (*createWork)( + InteropVMContext context, + InteropNativePointer handle, + void (*execute)(InteropNativePointer handle), + void (*complete)(InteropNativePointer handle) + ); +} InteropAsyncWorker; +typedef const InteropAsyncWorker* InteropAsyncWorkerPtr; + +typedef struct InteropObject { + InteropCallbackResource resource; +} InteropObject; + +#endif // _INTEROP_TYPES_H_ diff --git a/ets1.2/interop/src/cpp/interop-utils.h b/ets1.2/interop/src/cpp/interop-utils.h new file mode 100644 index 0000000000000000000000000000000000000000..49fb00cc0e281a52ef6a6b3c5164731431b3d43c --- /dev/null +++ b/ets1.2/interop/src/cpp/interop-utils.h @@ -0,0 +1,102 @@ +/* + * 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. + */ + +#ifndef _INTEROP_UTILS_H_ +#define _INTEROP_UTILS_H_ + +#include +#include + +#ifdef __STDC_LIB_EXT1__ + #include "securec.h" + #define USE_SAFE(name, ...) name##_s(__VA_ARGS__) +#else + /* handle possible unsafe case */ + #define USE_SAFE(name, ...) name(__VA_ARGS__) +#endif + +inline char *interop_strcpy(char *dest, size_t destsz, const char *src) +{ +#ifdef __STDC_LIB_EXT1__ + return reinterpret_cast(USE_SAFE(strcpy, dest, reinterpret_cast(destsz), src)); +#else + /* handle possible unsafe case */ + return USE_SAFE(strcpy, dest, src); +#endif +} + +inline char *interop_strcat(char *dest, size_t destsz, const char *src) +{ +#ifdef __STDC_LIB_EXT1__ + return reinterpret_cast(USE_SAFE(strcat, dest, reinterpret_cast(destsz), src)); +#else + /* handle possible unsafe case */ + return USE_SAFE(strcat, dest, src); +#endif +} + +inline void *interop_memcpy(void *dest, size_t destsz, const void *src, size_t count) +{ +#ifdef __STDC_LIB_EXT1__ + return reinterpret_cast(USE_SAFE(memcpy, dest, reinterpret_cast(destsz), src, count)); +#else + /* handle possible unsafe case */ + return USE_SAFE(memcpy, dest, src, count); +#endif +} + +inline void *interop_memset(void *dest, size_t destsz, int ch, size_t count) +{ +#ifdef __STDC_LIB_EXT1__ + return reinterpret_cast(USE_SAFE(memset, dest, reinterpret_cast(destsz), ch, count)) +#else + /* handle possible unsafe case */ + return USE_SAFE(memset, dest, ch, count); +#endif +} + +template +inline int interop_sprintf(char *buffer, size_t bufsz, const char *format, T... args) +{ +#ifdef __STDC_LIB_EXT1__ + return USE_SAFE(sprintf, buffer, reinterpret_cast(bufsz), format, args...); +#else + /* handle possible unsafe case */ + return USE_SAFE(sprintf, buffer, format, args...); +#endif +} + +template +inline int interop_snprintf(char *buffer, size_t bufsz, const char *format, T... args) +{ + return USE_SAFE(snprintf, buffer, bufsz, format, args...); +} + +inline int interop_vsnprintf(char *buffer, size_t bufsz, const char *format, va_list vlist) +{ + return USE_SAFE(vsnprintf, buffer, bufsz, format, vlist); +} + +inline size_t interop_strlen(const char *str) +{ +#ifdef __STDC_LIB_EXT1__ + return USE_SAFE(strnlen, str, UINT_MAX); +#else + /* handle possible unsafe case */ + return USE_SAFE(strlen, str); +#endif +} + +#endif // _INTEROP_UTILS_H_ \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/jni/convertors-jni.cc b/ets1.2/interop/src/cpp/jni/convertors-jni.cc new file mode 100644 index 0000000000000000000000000000000000000000..683625b09e9e7cac39905f70d84ee8f2c7ddbd45 --- /dev/null +++ b/ets1.2/interop/src/cpp/jni/convertors-jni.cc @@ -0,0 +1,107 @@ +/* + * Copyright (c) 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. + */ + + +#define KOALA_INTEROP_MODULE +#include "convertors-jni.h" +#include "signatures.h" +#include "interop-logging.h" +#include "interop-types.h" + +static const char* nativeModule = "org/koalaui/arkoala/InteropNativeModule"; +static const char* nativeModulePrefix = "org/koalaui/arkoala/"; +static const char* callCallbackFromNative = "callCallbackFromNative"; +static const char* callCallbackFromNativeSig = "(I[BI)I"; + +const bool registerByOne = true; + +static bool registerNatives(JNIEnv *env, jclass clazz, const std::vector> impls) { + size_t numMethods = impls.size(); + JNINativeMethod *methods = new JNINativeMethod[numMethods]; + bool result = true; + for (size_t i = 0; i < numMethods; i++) + { + methods[i].name = (char *)std::get<0>(impls[i]).c_str(); + methods[i].signature = (char *)std::get<1>(impls[i]).c_str(); + methods[i].fnPtr = std::get<2>(impls[i]); + if (registerByOne) { + result &= (env->RegisterNatives(clazz, methods + i, 1) >= 0); + if (env->ExceptionCheck()) { + env->ExceptionDescribe(); + env->ExceptionClear(); + result = false; + } + } + } + return registerByOne ? true : env->RegisterNatives(clazz, methods, numMethods) >= 0; +} + +constexpr bool splitPerModule = true; + +JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) { + JNIEnv *env; + if (vm->GetEnv(reinterpret_cast(&env), JNI_VERSION_1_8) != JNI_OK) { + return JNI_ERR; + } + auto modules = JniExports::getInstance()->getModules(); + jclass defaultNativeModule = env->FindClass(nativeModule); + for (auto it = modules.begin(); it != modules.end(); ++it) { + std::string className = std::string(nativeModulePrefix) + *it; + jclass nativeModule = + (!splitPerModule) ? defaultNativeModule : env->FindClass(className.c_str()); + if (nativeModule == nullptr) { + LOGE("Cannot find managed class %s", className.c_str()); + continue; + } + registerNatives(env, nativeModule, JniExports::getInstance()->getMethods(*it)); + } + if (!setKoalaJniCallbackDispatcher(env, defaultNativeModule, callCallbackFromNative, callCallbackFromNativeSig)) return JNI_ERR; + return JNI_VERSION_1_8; +} + +JniExports *JniExports::getInstance() +{ + static JniExports *instance = nullptr; + if (instance == nullptr) + { + instance = new JniExports(); + } + return instance; +} + +std::vector JniExports::getModules() { + std::vector result; + for (auto it = implementations.begin(); it != implementations.end(); ++it) { + result.push_back(it->first); + } + return result; +} + +const std::vector>& JniExports::getMethods(const std::string& module) { + auto it = implementations.find(module); + if (it == implementations.end()) { + LOGE("Module %s is not registered", module.c_str()); + INTEROP_FATAL("Fatal error: not registered module %s", module.c_str()); + } + return it->second; +} + +void JniExports::addMethod(const char* module, const char *name, const char *type, void *impl) { + auto it = implementations.find(module); + if (it == implementations.end()) { + it = implementations.insert(std::make_pair(module, std::vector>())).first; + } + it->second.push_back(std::make_tuple(name, convertType(name, type), impl)); +} diff --git a/ets1.2/interop/src/cpp/jni/convertors-jni.h b/ets1.2/interop/src/cpp/jni/convertors-jni.h new file mode 100644 index 0000000000000000000000000000000000000000..e80ab9f9ab872e1e46f7403884423ea9fe443160 --- /dev/null +++ b/ets1.2/interop/src/cpp/jni/convertors-jni.h @@ -0,0 +1,1520 @@ +/* + * Copyright (c) 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. + */ + +#ifndef CONVERTORS_JNI_H +#define CONVERTORS_JNI_H + +#ifdef KOALA_JNI + +#include + +#include +#include +#include +#include +#include + +#include "koala-types.h" +#include "interop-utils.h" + +#define KOALA_JNI_CALL(type) extern "C" JNIEXPORT type JNICALL + +class JniExports { + std::unordered_map>> implementations; + +public: + static JniExports* getInstance(); + + std::vector getModules(); + void addMethod(const char* module, const char* name, const char* type, void* impl); + const std::vector>& getMethods(const std::string& module); +}; + +#define KOALA_QUOTE0(x) #x +#define KOALA_QUOTE(x) KOALA_QUOTE0(x) + +#ifdef _MSC_VER +#define MAKE_JNI_EXPORT(module, name, type) \ + static void __init_##name() { \ + JniExports::getInstance()->addMethod(KOALA_QUOTE(module), "_"#name, type, reinterpret_cast(Java_org_##name)); \ + } \ + namespace { \ + struct __Init_##name { \ + __Init_##name() { __init_##name(); } \ + } __Init_##name##_v; \ + } +#else +#define MAKE_JNI_EXPORT(module, name, type) \ + __attribute__((constructor)) \ + static void __init_jni_##name() { \ + JniExports::getInstance()->addMethod(KOALA_QUOTE(module), "_"#name, type, reinterpret_cast(Java_org_##name)); \ + } +#endif + +template +struct InteropTypeConverter { + using InteropType = T; + static T convertFrom(JNIEnv* env, InteropType value) { return value; } + static InteropType convertTo(JNIEnv* env, T value) { return value; } + static void release(JNIEnv* env, InteropType value, T converted) {} +}; + +template +struct SlowInteropTypeConverter { + using InteropType = T; + static inline T convertFrom(JNIEnv* env, InteropType value) { return value; } + static inline InteropType convertTo(JNIEnv* env, T value) { return value; } + static void release(JNIEnv* env, InteropType value, T converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = jstring; + static inline KStringPtr convertFrom0(JNIEnv* env, InteropType value) { + if (value == nullptr) return KStringPtr(); + jboolean isCopy; + // Improve: use GetStringCritical() instead and utf-8 encode manually. + const char* str_value = env->GetStringUTFChars(value, &isCopy); + int len = env->GetStringUTFLength(value); + KStringPtr result(str_value, len, false); + return result; + } + static KStringPtr convertFrom(JNIEnv* env, InteropType value) { + if (value == nullptr) return KStringPtr(); + KStringPtr result; + // Notice that we use UTF length for buffer size, but counter is expressed in number of Unicode chars. + result.resize( env->GetStringUTFLength(value)); + env->GetStringUTFRegion(value, 0, env->GetStringLength(value), result.data()); + return result; + } + static InteropType convertTo(JNIEnv* env, KStringPtr value) { + return env->NewStringUTF(value.c_str()); + } + static inline void release(JNIEnv* env, InteropType value, const KStringPtr& converted) { + } +}; + +template<> +struct SlowInteropTypeConverter { + using InteropType = jobject; + static inline KVMObjectHandle convertFrom(JNIEnv* env, InteropType value) { + return reinterpret_cast(value); + } + static InteropType convertTo(JNIEnv* env, KVMObjectHandle value) { + return reinterpret_cast(value); + } + static inline void release(JNIEnv* env, InteropType value, KVMObjectHandle converted) { + } +}; + +template<> +struct SlowInteropTypeConverter { + using InteropType = jstring; + static inline KStringPtr convertFrom(JNIEnv* env, InteropType value) { + if (value == nullptr) return KStringPtr(); + jboolean isCopy; + const char* str_value = env->GetStringUTFChars(value, &isCopy); + int len = env->GetStringLength(value); + KStringPtr result(str_value, len, false); + return result; + } + static InteropType convertTo(JNIEnv* env, KStringPtr value) { + return env->NewStringUTF(value.c_str()); + } + static inline void release(JNIEnv* env, InteropType value, const KStringPtr& converted) { + env->ReleaseStringUTFChars(value, converted.data()); + } +}; + +template<> +struct SlowInteropTypeConverter { + using InteropType = jarray; + static inline KInteropBuffer convertFrom(JNIEnv* env, InteropType value) { + if (value == nullptr) return KInteropBuffer(); + KInteropBuffer result({env->GetArrayLength(value), reinterpret_cast(env->GetPrimitiveArrayCritical(value, nullptr))}); + return result; + } + static InteropType convertTo(JNIEnv* env, KInteropBuffer value) { + int bufferLength = value.length; + jarray result = env->NewByteArray(bufferLength); + void* data = env->GetPrimitiveArrayCritical(result, nullptr); + interop_memcpy(data, bufferLength, value.data, bufferLength); + env->ReleasePrimitiveArrayCritical(result, data, 0); + return result; + } + static inline void release(JNIEnv* env, InteropType value, const KInteropBuffer& converted) { + env->ReleasePrimitiveArrayCritical(value, converted.data, 0); + } +}; + +template<> +struct SlowInteropTypeConverter { + using InteropType = jarray; + static inline KInteropReturnBuffer convertFrom(JNIEnv* env, InteropType value) = delete; + static InteropType convertTo(JNIEnv* env, KInteropReturnBuffer value) { + int bufferLength = value.length; + jarray result = env->NewByteArray(bufferLength); + void* data = env->GetPrimitiveArrayCritical(result, nullptr); + interop_memcpy(data, bufferLength, value.data, bufferLength); + env->ReleasePrimitiveArrayCritical(result, data, 0); + value.dispose(value.data, bufferLength); + return result; + } + static inline void release(JNIEnv* env, InteropType value, const KInteropReturnBuffer& converted) = delete; +}; + +template<> +struct InteropTypeConverter { + using InteropType = jbyteArray; + static inline KByte* convertFrom(JNIEnv* env, InteropType value) { + return value ? reinterpret_cast(env->GetPrimitiveArrayCritical(value, nullptr)) : nullptr; + } + static InteropType convertTo(JNIEnv* env, KByte* value) = delete; + static inline void release(JNIEnv* env, InteropType value, KByte* converted) { + if (converted) env->ReleasePrimitiveArrayCritical(value, converted, 0); + } +}; + +template<> +struct SlowInteropTypeConverter { + using InteropType = jbyteArray; + static inline KByte* convertFrom(JNIEnv* env, InteropType value) { + return value ? reinterpret_cast(env->GetByteArrayElements(value, nullptr)) : nullptr; + } + static InteropType convertTo(JNIEnv* env, KByte* value) = delete; + static inline void release(JNIEnv* env, InteropType value, KByte* converted) { + if (converted) env->ReleaseByteArrayElements(value, reinterpret_cast(converted), 0); + } +}; + +template<> +struct InteropTypeConverter { + using InteropType = jintArray; + static KInt* convertFrom(JNIEnv* env, InteropType value) { + return value ? reinterpret_cast(env->GetPrimitiveArrayCritical(value, nullptr)) : nullptr; + } + static InteropType convertTo(JNIEnv* env, KInt* value) = delete; + static void release(JNIEnv* env, InteropType value, KInt* converted) { + env->ReleasePrimitiveArrayCritical(value, converted, 0); + } +}; + +template<> +struct SlowInteropTypeConverter { + using InteropType = jintArray; + static KInt* convertFrom(JNIEnv* env, InteropType value) { + return value ? reinterpret_cast(env->GetIntArrayElements(value, nullptr)) : nullptr; + } + static InteropType convertTo(JNIEnv* env, KInt* value) = delete; + static void release(JNIEnv* env, InteropType value, KInt* converted) { + env->ReleaseIntArrayElements(value, reinterpret_cast(converted), 0); + } +}; + +template<> +struct InteropTypeConverter { + using InteropType = jfloatArray; + static KFloat* convertFrom(JNIEnv* env, InteropType value) { + return value ? reinterpret_cast(env->GetPrimitiveArrayCritical(value, nullptr)) : nullptr; + } + static InteropType convertTo(JNIEnv* env, KFloat* value) = delete; + static void release(JNIEnv* env, InteropType value, KFloat* converted) { + env->ReleasePrimitiveArrayCritical(value, converted, 0); + } +}; + +template<> +struct SlowInteropTypeConverter { + using InteropType = jfloatArray; + static KFloat* convertFrom(JNIEnv* env, InteropType value) { + return value ? reinterpret_cast(env->GetFloatArrayElements(value, nullptr)) : nullptr; + } + static InteropType convertTo(JNIEnv* env, KFloat* value) = delete; + static void release(JNIEnv* env, InteropType value, KFloat* converted) { + env->ReleaseFloatArrayElements(value, reinterpret_cast(converted), 0); + } +}; + +template<> +struct InteropTypeConverter { + using InteropType = jlong; + static KNativePointer convertFrom(JNIEnv* env, InteropType value) { + return reinterpret_cast(value); + } + static InteropType convertTo(JNIEnv* env, KNativePointer value) { + return reinterpret_cast(value); + } + static inline void release(JNIEnv* env, InteropType value, KNativePointer converted) {} +}; + +template<> +struct SlowInteropTypeConverter { + using InteropType = jlong; + static KNativePointer convertFrom(JNIEnv* env, InteropType value) { + return reinterpret_cast(value); + } + static InteropType convertTo(JNIEnv* env, KNativePointer value) { + return reinterpret_cast(value); + } + static void release(JNIEnv* env, InteropType value, KNativePointer converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = jdouble; + static KInteropNumber convertFrom(JNIEnv* env, InteropType value) { + return KInteropNumber::fromDouble(value); + } + static InteropType convertTo(JNIEnv* env, KInteropNumber value) { + return value.asDouble(); + } + static inline void release(JNIEnv* env, InteropType value, KInteropNumber converted) {} +}; + +template<> +struct SlowInteropTypeConverter { + using InteropType = jdouble; + static KInteropNumber convertFrom(JNIEnv* env, InteropType value) { + return KInteropNumber::fromDouble(value); + } + static InteropType convertTo(JNIEnv* env, KInteropNumber value) { + return value.asDouble(); + } + static void release(JNIEnv* env, InteropType value, KInteropNumber converted) {} +}; + +template +inline Type getArgument(JNIEnv* env, typename InteropTypeConverter::InteropType arg) { + return InteropTypeConverter::convertFrom(env, arg); +} + +template +inline void releaseArgument(JNIEnv* env, typename InteropTypeConverter::InteropType arg, Type& data) { + InteropTypeConverter::release(env, arg, data); +} + +#ifndef KOALA_INTEROP_MODULE +#error KOALA_INTEROP_MODULE is undefined +#endif + +#define KOALA_INTEROP_0(name, Ret) \ + KOALA_JNI_CALL(InteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance) { \ + KOALA_MAYBE_LOG(name) \ + return InteropTypeConverter::convertTo(env, impl_##name()); \ + } \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret) + +#define KOALA_INTEROP_1(name, Ret, P0) \ + KOALA_JNI_CALL(InteropTypeConverter::InteropType) \ + Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + auto rv = InteropTypeConverter::convertTo(env, impl_##name(p0)); \ + releaseArgument(env, _p0, p0); \ + return rv; \ + } \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0) + +#define KOALA_INTEROP_2(name, Ret, P0, P1) \ + KOALA_JNI_CALL(InteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + auto rv = InteropTypeConverter::convertTo(env, impl_##name(p0, p1)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + return rv; \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1) + +#define KOALA_INTEROP_3(name, Ret, P0, P1, P2) \ + KOALA_JNI_CALL(InteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + auto rv = InteropTypeConverter::convertTo(env, impl_##name(p0, p1, p2)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + return rv; \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2) + +#define KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) \ + KOALA_JNI_CALL(InteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + auto rv = InteropTypeConverter::convertTo(env, impl_##name(p0, p1, p2, p3)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + return rv; \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3) + +#define KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) \ + KOALA_JNI_CALL(InteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + auto rv = InteropTypeConverter::convertTo(env, impl_##name(p0, p1, p2, p3, p4)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + return rv; \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4) + +#define KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) \ + KOALA_JNI_CALL(InteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + auto rv = InteropTypeConverter::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + return rv; \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5) + +#define KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_JNI_CALL(InteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + auto rv = InteropTypeConverter::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5, p6)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + return rv; \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6) + +#define KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_JNI_CALL(InteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + auto rv = InteropTypeConverter::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + return rv; \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7) + +#define KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_JNI_CALL(InteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + auto rv = InteropTypeConverter::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + return rv; \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8) + +#define KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_JNI_CALL(InteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + auto rv = InteropTypeConverter::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + return rv; \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9) + +#define KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_JNI_CALL(InteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + auto rv = InteropTypeConverter::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + return rv; \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10) + +#define KOALA_INTEROP_12(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \ + KOALA_JNI_CALL(InteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + auto rv = InteropTypeConverter::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + return rv; \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11) + +#define KOALA_INTEROP_13(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \ + KOALA_JNI_CALL(InteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + P12 p12 = getArgument(env, _p12); \ + auto rv = InteropTypeConverter::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + releaseArgument(env, _p12, p12); \ + return rv; \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9"|" #P10 "|" #P11 "|" #P12) + +#define KOALA_INTEROP_14(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \ + KOALA_JNI_CALL(InteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12, \ + InteropTypeConverter::InteropType _p13) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + P12 p12 = getArgument(env, _p12); \ + P13 p13 = getArgument(env, _p13); \ + auto rv = InteropTypeConverter::convertTo(env, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + releaseArgument(env, _p12, p12); \ + releaseArgument(env, _p13, p13); \ + return rv; \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9"|" #P10 "|" #P11 "|" #P12 "|" #P13) + + +#define KOALA_INTEROP_V0(name) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(); \ + } \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void") + +#define KOALA_INTEROP_V1(name, P0) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + impl_##name(p0); \ + releaseArgument(env, _p0, p0); \ + } \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0) + +#define KOALA_INTEROP_V2(name, P0, P1) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + impl_##name(p0, p1); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1) + +#define KOALA_INTEROP_V3(name, P0, P1, P2) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + impl_##name(p0, p1, p2); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2) + +#define KOALA_INTEROP_V4(name, P0, P1, P2, P3) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + impl_##name(p0, p1, p2, p3); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3) + +#define KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + impl_##name(p0, p1, p2, p3, p4); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4) + +#define KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + impl_##name(p0, p1, p2, p3, p4, p5); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5) + +#define KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6) + +#define KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7) + +#define KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8) + +#define KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9) + +#define KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10) + +#define KOALA_INTEROP_V12(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11) + +#define KOALA_INTEROP_V13(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + P12 p12 = getArgument(env, _p12); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + releaseArgument(env, _p12, p12); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12) + +#define KOALA_INTEROP_V14(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12, \ + InteropTypeConverter::InteropType _p13) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + P12 p12 = getArgument(env, _p12); \ + P13 p13 = getArgument(env, _p13); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + releaseArgument(env, _p12, p12); \ + releaseArgument(env, _p13, p13); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12 "|" #P13) + +#define KOALA_INTEROP_V15(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12, \ + InteropTypeConverter::InteropType _p13, \ + InteropTypeConverter::InteropType _p14) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + P5 p5 = getArgument(env, _p5); \ + P6 p6 = getArgument(env, _p6); \ + P7 p7 = getArgument(env, _p7); \ + P8 p8 = getArgument(env, _p8); \ + P9 p9 = getArgument(env, _p9); \ + P10 p10 = getArgument(env, _p10); \ + P11 p11 = getArgument(env, _p11); \ + P12 p12 = getArgument(env, _p12); \ + P13 p13 = getArgument(env, _p13); \ + P14 p14 = getArgument(env, _p14); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + releaseArgument(env, _p5, p5); \ + releaseArgument(env, _p6, p6); \ + releaseArgument(env, _p7, p7); \ + releaseArgument(env, _p8, p8); \ + releaseArgument(env, _p9, p9); \ + releaseArgument(env, _p10, p10); \ + releaseArgument(env, _p11, p11); \ + releaseArgument(env, _p12, p12); \ + releaseArgument(env, _p13, p13); \ + releaseArgument(env, _p14, p14); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4 "|" #P5 "|" #P6 "|" #P7 "|" #P8 "|" #P9 "|" #P10 "|" #P11 "|" #P12 "|" #P13 "|" #P14) + +#define KOALA_INTEROP_CTX_0(name, Ret) \ + KOALA_JNI_CALL(SlowInteropTypeConverter::InteropType) \ + Java_org_##name(JNIEnv* env, jclass instance) { \ + KOALA_MAYBE_LOG(name) \ + KVMContext ctx = (KVMContext)env; \ + auto rv = SlowInteropTypeConverter::convertTo(env, impl_##name(ctx)); \ + return rv; \ + } \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret) + +#define KOALA_INTEROP_CTX_1(name, Ret, P0) \ + KOALA_JNI_CALL(SlowInteropTypeConverter::InteropType) \ + Java_org_##name(JNIEnv* env, jclass instance, \ + SlowInteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + KVMContext ctx = (KVMContext)env; \ + auto rv = SlowInteropTypeConverter::convertTo(env, impl_##name(ctx, p0)); \ + releaseArgument(env, _p0, p0); \ + return rv; \ + } \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0) + +#define KOALA_INTEROP_CTX_2(name, Ret, P0, P1) \ + KOALA_JNI_CALL(SlowInteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \ + SlowInteropTypeConverter::InteropType _p0, \ + SlowInteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + KVMContext ctx = (KVMContext)env; \ + auto rv = SlowInteropTypeConverter::convertTo(env, impl_##name(ctx, p0, p1)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + return rv; \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1) + +#define KOALA_INTEROP_CTX_3(name, Ret, P0, P1, P2) \ + KOALA_JNI_CALL(SlowInteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \ + SlowInteropTypeConverter::InteropType _p0, \ + SlowInteropTypeConverter::InteropType _p1, \ + SlowInteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + KVMContext ctx = (KVMContext)env; \ + auto rv = SlowInteropTypeConverter::convertTo(env, impl_##name(ctx, p0, p1, p2)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + return rv; \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2) + +#define KOALA_INTEROP_CTX_4(name, Ret, P0, P1, P2, P3) \ + KOALA_JNI_CALL(SlowInteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \ + SlowInteropTypeConverter::InteropType _p0, \ + SlowInteropTypeConverter::InteropType _p1, \ + SlowInteropTypeConverter::InteropType _p2, \ + SlowInteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + KVMContext ctx = (KVMContext)env; \ + auto rv = SlowInteropTypeConverter::convertTo(env, impl_##name(ctx, p0, p1, p2, p3)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + return rv; \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3) + +#define KOALA_INTEROP_CTX_5(name, Ret, P0, P1, P2, P3, P4) \ + KOALA_JNI_CALL(SlowInteropTypeConverter::InteropType) Java_org_##name(JNIEnv* env, jclass instance, \ + SlowInteropTypeConverter::InteropType _p0, \ + SlowInteropTypeConverter::InteropType _p1, \ + SlowInteropTypeConverter::InteropType _p2, \ + SlowInteropTypeConverter::InteropType _p3, \ + SlowInteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + KVMContext ctx = (KVMContext)env; \ + auto rv = SlowInteropTypeConverter::convertTo(env, impl_##name(ctx, p0, p1, p2, p3, p4)); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ + return rv; \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, #Ret "|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4) + +#define KOALA_INTEROP_CTX_V0(name) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance) { \ + KOALA_MAYBE_LOG(name) \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx); \ + } \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void") + +#define KOALA_INTEROP_CTX_V1(name, P0) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + SlowInteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx, p0); \ + releaseArgument(env, _p0, p0); \ + } \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0) + +#define KOALA_INTEROP_CTX_V2(name, P0, P1) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + SlowInteropTypeConverter::InteropType _p0, \ + SlowInteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx, p0, p1); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1) + +#define KOALA_INTEROP_CTX_V3(name, P0, P1, P2) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + SlowInteropTypeConverter::InteropType _p0, \ + SlowInteropTypeConverter::InteropType _p1, \ + SlowInteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx, p0, p1, p2); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2) + +#define KOALA_INTEROP_CTX_V4(name, P0, P1, P2, P3) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + SlowInteropTypeConverter::InteropType _p0, \ + SlowInteropTypeConverter::InteropType _p1, \ + SlowInteropTypeConverter::InteropType _p2, \ + SlowInteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx, p0, p1, p2, p3); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3) + +#define KOALA_INTEROP_CTX_V5(name, P0, P1, P2, P3, P4) \ + KOALA_JNI_CALL(void) Java_org_##name(JNIEnv* env, jclass instance, \ + SlowInteropTypeConverter::InteropType _p0, \ + SlowInteropTypeConverter::InteropType _p1, \ + SlowInteropTypeConverter::InteropType _p2, \ + SlowInteropTypeConverter::InteropType _p3, \ + SlowInteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(env, _p0); \ + P1 p1 = getArgument(env, _p1); \ + P2 p2 = getArgument(env, _p2); \ + P3 p3 = getArgument(env, _p3); \ + P4 p4 = getArgument(env, _p4); \ + KVMContext ctx = (KVMContext)env; \ + impl_##name(ctx, p0, p1, p2, p3, p4); \ + releaseArgument(env, _p0, p0); \ + releaseArgument(env, _p1, p1); \ + releaseArgument(env, _p2, p2); \ + releaseArgument(env, _p3, p3); \ + releaseArgument(env, _p4, p4); \ +} \ +MAKE_JNI_EXPORT(KOALA_INTEROP_MODULE, name, "void|" #P0 "|" #P1 "|" #P2 "|" #P3 "|" #P4) + +#define KOALA_INTEROP_DIRECT_0(name, Ret) \ + KOALA_INTEROP_0(name, Ret) +#define KOALA_INTEROP_DIRECT_1(name, Ret, P0) \ + KOALA_INTEROP_1(name, Ret, P0) +#define KOALA_INTEROP_DIRECT_2(name, Ret, P0, P1) \ + KOALA_INTEROP_2(name, Ret, P0, P1) +#define KOALA_INTEROP_DIRECT_3(name, Ret, P0, P1, P2) \ + KOALA_INTEROP_3(name, Ret, P0, P1, P2) +#define KOALA_INTEROP_DIRECT_4(name, Ret, P0, P1, P2, P3) \ + KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) +#define KOALA_INTEROP_DIRECT_5(name, Ret, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) +#define KOALA_INTEROP_DIRECT_6(name, Ret, P0, P1, P2, P3, P4, P5) \ + KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) +#define KOALA_INTEROP_DIRECT_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) +#define KOALA_INTEROP_DIRECT_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) +#define KOALA_INTEROP_DIRECT_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) +#define KOALA_INTEROP_DIRECT_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) +#define KOALA_INTEROP_DIRECT_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) +#define KOALA_INTEROP_DIRECT_V0(name) \ + KOALA_INTEROP_V0(name) +#define KOALA_INTEROP_DIRECT_V1(name, P0) \ + KOALA_INTEROP_V1(name, P0) +#define KOALA_INTEROP_DIRECT_V2(name, P0, P1) \ + KOALA_INTEROP_V2(name, P0, P1) +#define KOALA_INTEROP_DIRECT_V3(name, P0, P1, P2) \ + KOALA_INTEROP_V3(name, P0, P1, P2) +#define KOALA_INTEROP_DIRECT_V4(name, P0, P1, P2, P3) \ + KOALA_INTEROP_V4(name, P0, P1, P2, P3) +#define KOALA_INTEROP_DIRECT_V5(name, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) +#define KOALA_INTEROP_DIRECT_V6(name, P0, P1, P2, P3, P4, P5) \ + KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) +#define KOALA_INTEROP_DIRECT_V7(name, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) +#define KOALA_INTEROP_DIRECT_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) +#define KOALA_INTEROP_DIRECT_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) +#define KOALA_INTEROP_DIRECT_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) +#define KOALA_INTEROP_DIRECT_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) + +bool setKoalaJniCallbackDispatcher( + JNIEnv* env, + jclass clazz, + const char* dispatcherMethodName, + const char* dispactherMethodSig +); +void getKoalaJniCallbackDispatcher(jclass* clazz, jmethodID* method); + +#define KOALA_INTEROP_CALL_VOID(venv, id, length, args) \ +{ \ + jclass clazz = nullptr; \ + jmethodID method = nullptr; \ + getKoalaJniCallbackDispatcher(&clazz, &method); \ + JNIEnv* jniEnv = reinterpret_cast(venv); \ + jniEnv->PushLocalFrame(1); \ + jbyteArray args_jni = jniEnv->NewByteArray(length); \ + jniEnv->SetByteArrayRegion(args_jni, 0, length, reinterpret_cast(args)); \ + jniEnv->CallStaticIntMethod(clazz, method, id, args_jni, length); \ + jniEnv->GetByteArrayRegion(args_jni, 0, length, reinterpret_cast(args)); \ + jniEnv->PopLocalFrame(nullptr); \ +} + +#define KOALA_INTEROP_CALL_INT(venv, id, length, args) \ +{ \ + jclass clazz = nullptr; \ + jmethodID method = nullptr; \ + getKoalaJniCallbackDispatcher(&clazz, &method); \ + JNIEnv* jniEnv = reinterpret_cast(venv); \ + jniEnv->PushLocalFrame(1); \ + jbyteArray args_jni = jniEnv->NewByteArray(length); \ + jniEnv->SetByteArrayRegion(args_jni, 0, length, reinterpret_cast(args)); \ + int32_t rv = jniEnv->CallStaticIntMethod(clazz, method, id, args_jni, length); \ + jniEnv->GetByteArrayRegion(args_jni, 0, length, reinterpret_cast(args)); \ + jniEnv->PopLocalFrame(nullptr); \ + return rv; \ +} + +#define KOALA_INTEROP_CALL_VOID_INTS32(venv, id, argc, args) KOALA_INTEROP_CALL_VOID(venv, id, (argc) * sizeof(int32_t), args) +#define KOALA_INTEROP_CALL_INT_INTS32(venv, id, argc, args) KOALA_INTEROP_CALL_INT(venv, id, (argc) * sizeof(int32_t), args) + +#define KOALA_INTEROP_THROW(vmContext, object, ...) \ + do { \ + JNIEnv* env = reinterpret_cast(vmContext); \ + env->Throw(object); \ + return __VA_ARGS__; \ + } while (0) + +#define KOALA_INTEROP_THROW_STRING(vmContext, message, ...) \ + do { \ + JNIEnv* env = reinterpret_cast(vmContext); \ + const static jclass errorClass = env->FindClass("java/lang/RuntimeException"); \ + env->ThrowNew(errorClass, message); \ + } while (0) + +#endif // KOALA_JNI_CALL + +#endif // CONVERTORS_JNI_H \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/jsc/convertors-jsc.cc b/ets1.2/interop/src/cpp/jsc/convertors-jsc.cc new file mode 100644 index 0000000000000000000000000000000000000000..7245991c75710c03d07fc8eab367530a5ae92f71 --- /dev/null +++ b/ets1.2/interop/src/cpp/jsc/convertors-jsc.cc @@ -0,0 +1,303 @@ +/* + * 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 <_types/_uint32_t.h> +#include <_types/_uint8_t.h> +#include + +#include "convertors-jsc.h" + +#include "interop-logging.h" +#include "interop-utils.h" + +// See https://github.com/BabylonJS/BabylonNative/blob/master/Dependencies/napi/napi-direct/source/js_native_api_javascriptcore.cc +// for convertors logic. + + +KInt* getInt32Elements(JSContextRef context, const JSValueRef arguments) { + return getTypedElements(context, arguments); +} + +uint32_t* getUInt32Elements(JSContextRef context, const JSValueRef arguments) { + return getTypedElements(context, arguments); +} + +float* getFloat32Elements(JSContextRef context, const JSValueRef arguments) { + return getTypedElements(context, arguments); +} + +KByte* getByteElements(JSContextRef context, const JSValueRef arguments) { + return getTypedElements(context, arguments); +} + +KStringArray getKStringArray(JSContextRef context, const JSValueRef arguments) { + return getTypedElements(context, arguments); +} + +KUShort* getUShortElements(JSContextRef context, const JSValueRef arguments) { + return getTypedElements(context, arguments); +} + +KShort* getShortElements(JSContextRef context, const JSValueRef arguments) { + return getTypedElements(context, arguments); +} + +int32_t getInt32(JSContextRef context, JSValueRef value) { + JSValueRef exception {}; + if (JSValueIsNull(context, value)) { + return 0; + } + if (JSValueIsUndefined(context, value)) { + ASSERT(false); + return 0; + } + double result = JSValueToNumber(context, value, &exception); + return static_cast(result); +} + +uint32_t getUInt32(JSContextRef context, JSValueRef value) { + JSValueRef exception {}; + if (JSValueIsNull(context, value)) { + return 0; + } + if (JSValueIsUndefined(context, value)) { + ASSERT(false); + return 0; + } + double result = JSValueToNumber(context, value, &exception); + return static_cast(result); +} + +uint8_t getUInt8(JSContextRef context, JSValueRef value) { + JSValueRef exception {}; + if (JSValueIsNull(context, value)) { + return 0; + } + if (JSValueIsUndefined(context, value)) { + ASSERT(false); + return 0; + } + double result = JSValueToNumber(context, value, &exception); + return static_cast(result); +} + +/* +static JSStringRef bigintToArrayCastFuncName = JSStringCreateWithUTF8CString("__JSC__castFromBigInt"); +static JSStringRef bigintToArrayCastFuncParams[] = { JSStringCreateWithUTF8CString("ptr") }; +static JSStringRef bigintToArrayCastFuncBody = JSStringCreateWithUTF8CString( + "return new Uint32Array([ptr & 0xFFFFFFFFn, (ptr >> 32n) & 0xFFFFFFFFn]);" +); + +static JSStringRef arrayToBigintCastFuncName = JSStringCreateWithUTF8CString("__JSC__castToBigInt"); +static JSStringRef arrayToBigintCastFuncParams[] = { JSStringCreateWithUTF8CString("ptr") }; +static JSStringRef arrayToBigintCastFuncBody = JSStringCreateWithUTF8CString( + "return BigInt(ptr[1]) << 32n | BigInt(ptr[0])" +); +*/ + +#ifdef KOALA_JSC_USE_CALLBACK_CAST + +static JSStringRef bigIntFromPartsFuncName = JSStringCreateWithUTF8CString("__JSC__bigIntFromParts"); +static JSStringRef bigIntFromPartsFuncParams[] = { JSStringCreateWithUTF8CString("hi"), JSStringCreateWithUTF8CString("lo") }; +static JSStringRef bigIntFromPartsFuncBody = JSStringCreateWithUTF8CString( + "return BigInt(hi) << 32n | BigInt(lo);" +); + +static JSObjectRef getGlobalCallback(JSContextRef context, JSStringRef name, JSStringRef params[], JSStringRef body) { + JSObjectRef globalThis = JSContextGetGlobalObject(context); + JSValueRef propname = JSValueMakeString(context, name); + JSValueRef castFunc = JSObjectGetPropertyForKey(context, globalThis, propname, nullptr); + if (JSValueIsUndefined(context, castFunc)) { + JSObjectRef castFuncObj = JSObjectMakeFunction(context, name, 1, params, body, nullptr, 0, nullptr); + JSPropertyAttributes attributes = kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontEnum; + JSObjectSetPropertyForKey(context, globalThis, propname, castFuncObj, attributes, nullptr); + return castFuncObj; + } + return JSValueToObject(context, castFunc, nullptr); +} + +static JSObjectRef getBigIntFromParts(JSContextRef context) { + return getGlobalCallback(context, bigIntFromPartsFuncName, bigIntFromPartsFuncParams, bigIntFromPartsFuncBody); +} + +#endif + +static JSValueRef u64ToBigInt(JSContextRef context, uint64_t value) { + JSValueRef bigint; +#ifdef KOALA_JSC_USE_CALLBACK_CAST + // Improve: benchmark this + JSObjectRef bigIntFromParts = getBigIntFromParts(context); + JSValueRef parts[2] = { + JSValueMakeNumber(context, (double) (value >> 32)), + JSValueMakeNumber(context, (double) (value & 0xFFFFFFFF)), + }; + bigint = JSObjectCallAsFunction(context, bigIntFromParts, nullptr, 2, parts, nullptr); +#else + char buffer[128] = {0}; + interop_snprintf(buffer, sizeof(buffer) - 1, "%zun", static_cast(value)); + JSStringRef script = JSStringCreateWithUTF8CString(buffer); + bigint = JSEvaluateScript(context, script, nullptr, nullptr, 0, nullptr); + JSStringRelease(script); +#endif + return bigint; +} + +static uint64_t bigIntToU64(JSContextRef ctx, JSValueRef value) { + char buf[128]; + JSStringRef strRef = JSValueToStringCopy(ctx, value, nullptr); + size_t len = JSStringGetUTF8CString(strRef, buf, sizeof(buf)); + JSStringRelease(strRef); + ASSERT(len < sizeof(buf)); + char* suf; + uint64_t numValue = std::strtoull(buf, &suf, 10); + ASSERT(*suf == '\0'); + return numValue; +} + +KNativePointer getPointer(JSContextRef context, JSValueRef value) { + uint64_t raw = bigIntToU64(context, value); + return reinterpret_cast(static_cast(raw)); +} + +KNativePointerArray getPointerElements(JSContextRef context, JSValueRef value) { + if (JSValueIsNull(context, value) || JSValueIsUndefined(context, value)) { + return nullptr; + } + + ASSERT(JSValueIsObject(context, value)); + ASSERT(JSValueGetTypedArrayType(context, value, nullptr) == kJSTypedArrayTypeBigUint64Array); + + JSObjectRef typedArray = JSValueToObject(context, value, nullptr); + return reinterpret_cast(JSObjectGetTypedArrayBytesPtr(context, typedArray, nullptr)); +} + +KFloat getFloat(JSContextRef context, JSValueRef value) { + JSValueRef exception {}; + if (JSValueIsNull(context, value)) { + return 0; + } + if (JSValueIsUndefined(context, value)) { + ASSERT(false); + return 0; + } + double result = JSValueToNumber(context, value, &exception); + return static_cast(result); +} + +KDouble getDouble(JSContextRef context, JSValueRef value) { + JSValueRef exception {}; + if (JSValueIsNull(context, value)) { + return 0; + } + if (JSValueIsUndefined(context, value)) { + ASSERT(false); + return 0; + } + return JSValueToNumber(context, value, &exception); +} + +KShort getShort(JSContextRef context, JSValueRef value) { + JSValueRef exception {}; + if (JSValueIsNull(context, value)) { + return 0; + } + if (JSValueIsUndefined(context, value)) { + ASSERT(false); + return 0; + } + double result = JSValueToNumber(context, value, &exception); + return static_cast(result); +} + +KUShort getUShort(JSContextRef context, JSValueRef value) { + JSValueRef exception {}; + if (JSValueIsNull(context, value)) { + return 0; + } + if (JSValueIsUndefined(context, value)) { + ASSERT(false); + return 0; + } + double result = JSValueToNumber(context, value, &exception); + return static_cast(result); +} + +KStringPtr getString(JSContextRef context, JSValueRef value) { + if (JSValueIsNull(context, value)) { + return KStringPtr(); + } + if (JSValueIsUndefined(context, value)) { + return KStringPtr(); + } + KStringPtr result; + JSStringRef valueString = JSValueToStringCopy(context, value, NULL); + size_t size = JSStringGetMaximumUTF8CStringSize(valueString); + result.resize(size); + JSStringGetUTF8CString(valueString, result.data(), size); + JSStringRelease(valueString); + return result; +} + +KBoolean getBoolean(JSContextRef context, JSValueRef value) { + bool result = JSValueToBoolean(context, value); + return static_cast(result); +} + +JSValueRef makeInt32(JSContextRef context, int32_t value) { + return JSValueMakeNumber(context, value); +} + +JSValueRef makeUInt32(JSContextRef context, uint32_t value) { + return JSValueMakeNumber(context, value); +} + +JSValueRef makePointer(JSContextRef context, KNativePointer value) { + return u64ToBigInt(context, static_cast(reinterpret_cast(value))); +} + +JSValueRef makeFloat(JSContextRef context, KFloat value) { + return JSValueMakeNumber(context, value); +} + +JSValueRef makeDouble(JSContextRef context, KDouble value) { + return JSValueMakeNumber(context, value); +} + +JSValueRef makeBoolean(JSContextRef context, KBoolean value) { + return JSValueMakeBoolean(context, value); +} + +JSValueRef makeVoid(JSContextRef context) { + return JSValueMakeUndefined(context); +} + +Exports* Exports::getInstance() { + static Exports *instance = nullptr; + if (instance == nullptr) { + instance = new Exports(); + } + return instance; +} + +void InitExports(JSGlobalContextRef globalContext) { + JSObjectRef globalObject = JSContextGetGlobalObject(globalContext); + for (auto impl: Exports::getInstance()->getImpls()) { + JSStringRef functionName = JSStringCreateWithUTF8CString(impl.first.c_str()); + JSObjectRef functionObject = JSObjectMakeFunctionWithCallback(globalContext, functionName, impl.second); + JSObjectSetProperty(globalContext, globalObject, functionName, functionObject, kJSPropertyAttributeNone, nullptr); + JSStringRelease(functionName); + } +} diff --git a/ets1.2/interop/src/cpp/jsc/convertors-jsc.h b/ets1.2/interop/src/cpp/jsc/convertors-jsc.h new file mode 100644 index 0000000000000000000000000000000000000000..8ad7a4284950464c40aef715ae98bb7f2601b23a --- /dev/null +++ b/ets1.2/interop/src/cpp/jsc/convertors-jsc.h @@ -0,0 +1,786 @@ +/* + * 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. + */ + +#ifndef CONVERTORS_JSC_H +#define CONVERTORS_JSC_H + +#if defined(linux) +#include // For IDE completion +#else +#include +#endif +#include <_types/_uint8_t.h> +#include +#include +#include + +#include "koala-types.h" +#include "interop-logging.h" + +template +inline ElemType* getTypedElements(JSContextRef context, const JSValueRef arguments) { + if (JSValueIsNull(context, arguments)) { + return nullptr; + } + if (JSValueIsUndefined(context, arguments)) { + ASSERT(false); + return nullptr; + } + JSValueRef exception {}; + ElemType* data = reinterpret_cast(JSObjectGetTypedArrayBytesPtr(context, + JSValueToObject(context, arguments, &exception), &exception)); + return data; +} + +template +inline ElemType* getTypedElements(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) { + ASSERT(index < argumentCount); + return getTypedElements(context, arguments[index]); +} + +uint8_t* getUInt8Elements(JSContextRef context, const JSValueRef arguments); +int32_t* getInt32Elements(JSContextRef context, const JSValueRef arguments); +uint32_t* getUInt32Elements(JSContextRef context, const JSValueRef arguments); +float* getFloat32Elements(JSContextRef context, const JSValueRef arguments); +KByte* getByteElements(JSContextRef context, const JSValueRef arguments); +KUShort* getUShortElements(JSContextRef context, const JSValueRef arguments); +KShort* getShortElements(JSContextRef context, const JSValueRef arguments); +KNativePointerArray getPointerElements(JSContextRef context, const JSValueRef arguments); +KStringArray getKStringArray(JSContextRef context, const JSValueRef arguments); + +uint8_t getUInt8(JSContextRef context, JSValueRef value); +int32_t getInt32(JSContextRef context, JSValueRef value); +uint32_t getUInt32(JSContextRef context, JSValueRef value); +KNativePointer getPointer(JSContextRef context, JSValueRef value); +KFloat getFloat(JSContextRef context, JSValueRef value); +KDouble getDouble(JSContextRef context, JSValueRef value); +KStringPtr getString(JSContextRef context, JSValueRef value); +KBoolean getBoolean(JSContextRef context, JSValueRef value); +KStringPtr getString(JSContextRef context, JSValueRef value); + +template +inline Type getArgument(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) = delete; + +template <> +inline int32_t getArgument(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) { + ASSERT(index < argumentCount); + return getInt32(context, arguments[index]); +} + +template <> +inline uint32_t getArgument(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) { + ASSERT(index < argumentCount); + return getUInt32(context, arguments[index]); +} + +template <> +inline uint8_t getArgument(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) { + ASSERT(index < argumentCount); + return getUInt8(context, arguments[index]); +} + +template <> +inline KNativePointer getArgument(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) { + ASSERT(index < argumentCount); + return getPointer(context, arguments[index]); +} + +template <> +inline KFloat getArgument(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) { + ASSERT(index < argumentCount); + return getFloat(context, arguments[index]); +} + +template<> +inline KDouble getArgument(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) { + ASSERT(index < argumentCount); + return getDouble(context, arguments[index]); +} + +template <> +inline KStringPtr getArgument(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) { + ASSERT(index < argumentCount); + return getString(context, arguments[index]); +} + +template <> +inline KBoolean getArgument(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) { + ASSERT(index < argumentCount); + return getBoolean(context, arguments[index]); +} + +template <> +inline KInt* getArgument(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) { + ASSERT(index < argumentCount); + return getInt32Elements(context, arguments[index]); +} + +template <> +inline float* getArgument(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) { + ASSERT(index < argumentCount); + return getFloat32Elements(context, arguments[index]); +} + +template <> +inline KByte* getArgument(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) { + ASSERT(index < argumentCount); + return getByteElements(context, arguments[index]); +} + +template <> +inline KStringArray getArgument(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) { + ASSERT(index < argumentCount); + return getKStringArray(context, arguments[index]); +} + +template <> +inline KUShort* getArgument(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) { + ASSERT(index < argumentCount); + return getUShortElements(context, arguments[index]); +} + +template <> +inline KNativePointerArray getArgument(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) { + ASSERT(index < argumentCount); + return getPointerElements(context, arguments[index]); +} + +template <> +inline KShort* getArgument(JSContextRef context, size_t argumentCount, const JSValueRef arguments[], int index) { + ASSERT(index < argumentCount); + return getShortElements(context, arguments[index]); +} + +JSValueRef makeInt32(JSContextRef context, int32_t value); +JSValueRef makeUInt32(JSContextRef context, uint32_t value); +JSValueRef makePointer(JSContextRef context, KNativePointer value); +JSValueRef makeFloat(JSContextRef context, KFloat value); +JSValueRef makeDouble(JSContextRef context, KDouble value); +JSValueRef makeBoolean(JSContextRef context, KBoolean value); +JSValueRef makeVoid(JSContextRef context); + +template +inline JSValueRef makeResult(JSContextRef context, Type value) = delete; + +template <> +inline JSValueRef makeResult(JSContextRef context, int32_t value) { + return makeInt32(context, value); +} + +template <> +inline JSValueRef makeResult(JSContextRef context, uint32_t value) { + return makeUInt32(context, value); +} + +template <> +inline JSValueRef makeResult(JSContextRef context, KNativePointer value) { + return makePointer(context, value); +} + +template <> +inline JSValueRef makeResult(JSContextRef context, KFloat value) { + return makeFloat(context, value); +} + +template <> +inline JSValueRef makeResult(JSContextRef context, KDouble value) { + return makeDouble(context, value); +} + +template <> +inline JSValueRef makeResult(JSContextRef context, KBoolean value) { + return makeBoolean(context, value); +} + +typedef JSValueRef (*jsc_type_t)(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception); + +class Exports { + std::vector> implementations; + +public: + static Exports* getInstance(); + + void addImpl(const char* name, jsc_type_t impl) { + implementations.push_back(std::make_pair(name, impl)); + } + + const std::vector>& getImpls() { + return implementations; + } +}; + +void InitExports(JSGlobalContextRef globalContext); + +#define MAKE_JSC_EXPORT(name) \ + __attribute__((constructor)) \ + static void __init_##name() { \ + Exports::getInstance()->addImpl("_"#name, Jsc_##name); \ + } + +#define MAKE_JSC_EXPORT_V1(name) \ + __attribute__((constructor)) \ + static void __init_##name() { \ + Exports::getInstance()->addImpl(#name, Jsc_##name); \ + } + +#define KOALA_INTEROP_0(name, Ret) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + return makeResult(ctx, impl_##name()); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_1(name, Ret, P0) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + return makeResult(ctx, impl_##name(p0)); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_2(name, Ret, P0, P1) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + return makeResult(ctx, impl_##name(p0, p1)); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_3(name, Ret, P0, P1, P2) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + return makeResult(ctx, impl_##name(p0,p1,p2)); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + return makeResult(ctx, impl_##name(p0,p1,p2,p3)); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + return makeResult(ctx, impl_##name(p0,p1,p2,p3,p4)); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + return makeResult(ctx, impl_##name(p0,p1,p2,p3,p4,p5)); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + P6 p6 = getArgument(ctx, argumentCount, arguments, 6); \ + return makeResult(ctx, impl_##name(p0,p1,p2,p3,p4,p5,p6)); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + P6 p6 = getArgument(ctx, argumentCount, arguments, 6); \ + P7 p7 = getArgument(ctx, argumentCount, arguments, 7); \ + return makeResult(ctx, impl_##name(p0,p1,p2,p3,p4,p5,p6,p7)); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + P6 p6 = getArgument(ctx, argumentCount, arguments, 6); \ + P7 p7 = getArgument(ctx, argumentCount, arguments, 7); \ + P8 p8 = getArgument(ctx, argumentCount, arguments, 8); \ + return makeResult(ctx, impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8)); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + P6 p6 = getArgument(ctx, argumentCount, arguments, 6); \ + P7 p7 = getArgument(ctx, argumentCount, arguments, 7); \ + P8 p8 = getArgument(ctx, argumentCount, arguments, 8); \ + P9 p9 = getArgument(ctx, argumentCount, arguments, 9); \ + return makeResult(ctx, impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9)); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + P6 p6 = getArgument(ctx, argumentCount, arguments, 6); \ + P7 p7 = getArgument(ctx, argumentCount, arguments, 7); \ + P8 p8 = getArgument(ctx, argumentCount, arguments, 8); \ + P9 p9 = getArgument(ctx, argumentCount, arguments, 9); \ + P10 p10 = getArgument(ctx, argumentCount, arguments, 10); \ + return makeResult(ctx, impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10)); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_12(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + P6 p6 = getArgument(ctx, argumentCount, arguments, 6); \ + P7 p7 = getArgument(ctx, argumentCount, arguments, 7); \ + P8 p8 = getArgument(ctx, argumentCount, arguments, 8); \ + P9 p9 = getArgument(ctx, argumentCount, arguments, 9); \ + P10 p10 = getArgument(ctx, argumentCount, arguments, 10); \ + P11 p11 = getArgument(ctx, argumentCount, arguments, 11); \ + return makeResult(ctx, impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11)); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_13(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + P6 p6 = getArgument(ctx, argumentCount, arguments, 6); \ + P7 p7 = getArgument(ctx, argumentCount, arguments, 7); \ + P8 p8 = getArgument(ctx, argumentCount, arguments, 8); \ + P9 p9 = getArgument(ctx, argumentCount, arguments, 9); \ + P10 p10 = getArgument(ctx, argumentCount, arguments, 10); \ + P11 p11 = getArgument(ctx, argumentCount, arguments, 11); \ + P12 p12 = getArgument(ctx, argumentCount, arguments, 12); \ + return makeResult(ctx, impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12)); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_14(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + P6 p6 = getArgument(ctx, argumentCount, arguments, 6); \ + P7 p7 = getArgument(ctx, argumentCount, arguments, 7); \ + P8 p8 = getArgument(ctx, argumentCount, arguments, 8); \ + P9 p9 = getArgument(ctx, argumentCount, arguments, 9); \ + P10 p10 = getArgument(ctx, argumentCount, arguments, 10); \ + P11 p11 = getArgument(ctx, argumentCount, arguments, 11); \ + P12 p12 = getArgument(ctx, argumentCount, arguments, 12); \ + P13 p13 = getArgument(ctx, argumentCount, arguments, 13); \ + return makeResult(ctx, impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13)); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_V0(name) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(); \ + return makeVoid(ctx); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_V1(name, P0) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + impl_##name(p0); \ + return makeVoid(ctx); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_V2(name, P0, P1) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + impl_##name(p0,p1); \ + return makeVoid(ctx); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_V3(name, P0, P1, P2) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + impl_##name(p0,p1,p2); \ + return makeVoid(ctx); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_V4(name, P0, P1, P2, P3) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + impl_##name(p0,p1,p2,p3); \ + return makeVoid(ctx); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + impl_##name(p0,p1,p2,p3,p4); \ + return makeVoid(ctx); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + impl_##name(p0,p1,p2,p3,p4,p5); \ + return makeVoid(ctx); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + P6 p6 = getArgument(ctx, argumentCount, arguments, 6); \ + impl_##name(p0,p1,p2,p3,p4,p5,p6); \ + return makeVoid(ctx); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + P6 p6 = getArgument(ctx, argumentCount, arguments, 6); \ + P7 p7 = getArgument(ctx, argumentCount, arguments, 7); \ + impl_##name(p0,p1,p2,p3,p4,p5,p6,p7); \ + return makeVoid(ctx); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + P6 p6 = getArgument(ctx, argumentCount, arguments, 6); \ + P7 p7 = getArgument(ctx, argumentCount, arguments, 7); \ + P8 p8 = getArgument(ctx, argumentCount, arguments, 8); \ + impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8); \ + return makeVoid(ctx); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + P6 p6 = getArgument(ctx, argumentCount, arguments, 6); \ + P7 p7 = getArgument(ctx, argumentCount, arguments, 7); \ + P8 p8 = getArgument(ctx, argumentCount, arguments, 8); \ + P9 p9 = getArgument(ctx, argumentCount, arguments, 9); \ + impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9); \ + return makeVoid(ctx); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + P6 p6 = getArgument(ctx, argumentCount, arguments, 6); \ + P7 p7 = getArgument(ctx, argumentCount, arguments, 7); \ + P8 p8 = getArgument(ctx, argumentCount, arguments, 8); \ + P9 p9 = getArgument(ctx, argumentCount, arguments, 9); \ + P10 p10 = getArgument(ctx, argumentCount, arguments, 10); \ + impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10); \ + return makeVoid(ctx); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_V12(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + P6 p6 = getArgument(ctx, argumentCount, arguments, 6); \ + P7 p7 = getArgument(ctx, argumentCount, arguments, 7); \ + P8 p8 = getArgument(ctx, argumentCount, arguments, 8); \ + P9 p9 = getArgument(ctx, argumentCount, arguments, 9); \ + P10 p10 = getArgument(ctx, argumentCount, arguments, 10); \ + P11 p11 = getArgument(ctx, argumentCount, arguments, 11); \ + impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11); \ + return makeVoid(ctx); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_V13(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + P6 p6 = getArgument(ctx, argumentCount, arguments, 6); \ + P7 p7 = getArgument(ctx, argumentCount, arguments, 7); \ + P8 p8 = getArgument(ctx, argumentCount, arguments, 8); \ + P9 p9 = getArgument(ctx, argumentCount, arguments, 9); \ + P10 p10 = getArgument(ctx, argumentCount, arguments, 10); \ + P11 p11 = getArgument(ctx, argumentCount, arguments, 11); \ + P12 p12 = getArgument(ctx, argumentCount, arguments, 12); \ + impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12); \ + return makeVoid(ctx); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_V14(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + P4 p4 = getArgument(ctx, argumentCount, arguments, 4); \ + P5 p5 = getArgument(ctx, argumentCount, arguments, 5); \ + P6 p6 = getArgument(ctx, argumentCount, arguments, 6); \ + P7 p7 = getArgument(ctx, argumentCount, arguments, 7); \ + P8 p8 = getArgument(ctx, argumentCount, arguments, 8); \ + P9 p9 = getArgument(ctx, argumentCount, arguments, 9); \ + P10 p10 = getArgument(ctx, argumentCount, arguments, 10); \ + P11 p11 = getArgument(ctx, argumentCount, arguments, 11); \ + P12 p12 = getArgument(ctx, argumentCount, arguments, 12); \ + P13 p13 = getArgument(ctx, argumentCount, arguments, 13); \ + impl_##name(p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13); \ + return makeVoid(ctx); \ + } \ + MAKE_JSC_EXPORT(name) + +// Improve: implement properly +#define KOALA_INTEROP_CTX_3(name, Ret, P0, P1, P2) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef *exception) \ + { \ + printf("Improve: implement KOALA_INTEROP_CTX_3 for jsc"); \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + return makeResult(ctx, impl_##name(nullptr, p0, p1, p2)); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_CTX_4(name, Ret, P0, P1, P2, P4) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef *exception) \ + { \ + printf("Improve: implement KOALA_INTEROP_CTX_4 for jsc"); \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + return makeResult(ctx, impl_##name(nullptr, p0, p1, p2, p3)); \ + } \ + MAKE_JSC_EXPORT(name) + +// Improve: implement properly +#define KOALA_INTEROP_CTX_V3(name, P0, P1, P2) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + printf("Improve: implement KOALA_INTEROP_CTX_V3 for jsc"); \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + impl_##name(nullptr, p0, p1, p2); \ + return makeVoid(ctx); \ + } \ + MAKE_JSC_EXPORT(name) + +#define KOALA_INTEROP_CTX_V4(name, P0, P1, P2, P3) \ + JSValueRef Jsc_##name(JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception) { \ + printf("Improve: implement KOALA_INTEROP_CTX_V4 for jsc"); \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(ctx, argumentCount, arguments, 0); \ + P1 p1 = getArgument(ctx, argumentCount, arguments, 1); \ + P2 p2 = getArgument(ctx, argumentCount, arguments, 2); \ + P3 p3 = getArgument(ctx, argumentCount, arguments, 3); \ + impl_##name(nullptr, p0, p1, p2, p3); \ + return makeVoid(ctx); \ + } \ + MAKE_JSC_EXPORT(name) + + #define KOALA_INTEROP_DIRECT_0(name, Ret) \ + KOALA_INTEROP_0(name, Ret) +#define KOALA_INTEROP_DIRECT_1(name, Ret, P0) \ + KOALA_INTEROP_1(name, Ret, P0) +#define KOALA_INTEROP_DIRECT_2(name, Ret, P0, P1) \ + KOALA_INTEROP_2(name, Ret, P0, P1) +#define KOALA_INTEROP_DIRECT_3(name, Ret, P0, P1, P2) \ + KOALA_INTEROP_3(name, Ret, P0, P1, P2) +#define KOALA_INTEROP_DIRECT_4(name, Ret, P0, P1, P2, P3) \ + KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) +#define KOALA_INTEROP_DIRECT_5(name, Ret, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) +#define KOALA_INTEROP_DIRECT_6(name, Ret, P0, P1, P2, P3, P4, P5) \ + KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) +#define KOALA_INTEROP_DIRECT_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) +#define KOALA_INTEROP_DIRECT_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) +#define KOALA_INTEROP_DIRECT_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) +#define KOALA_INTEROP_DIRECT_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) +#define KOALA_INTEROP_DIRECT_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) +#define KOALA_INTEROP_DIRECT_V0(name) \ + KOALA_INTEROP_V0(name) +#define KOALA_INTEROP_DIRECT_V1(name, P0) \ + KOALA_INTEROP_V1(name, P0) +#define KOALA_INTEROP_DIRECT_V2(name, P0, P1) \ + KOALA_INTEROP_V2(name, P0, P1) +#define KOALA_INTEROP_DIRECT_V3(name, P0, P1, P2) \ + KOALA_INTEROP_V3(name, P0, P1, P2) +#define KOALA_INTEROP_DIRECT_V4(name, P0, P1, P2, P3) \ + KOALA_INTEROP_V4(name, P0, P1, P2, P3) +#define KOALA_INTEROP_DIRECT_V5(name, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) +#define KOALA_INTEROP_DIRECT_V6(name, P0, P1, P2, P3, P4, P5) \ + KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) +#define KOALA_INTEROP_DIRECT_V7(name, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) +#define KOALA_INTEROP_DIRECT_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) +#define KOALA_INTEROP_DIRECT_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) +#define KOALA_INTEROP_DIRECT_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) +#define KOALA_INTEROP_DIRECT_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) + +#define KOALA_INTEROP_THROW(vmContext, object, ...) \ + do { \ + /* Improve: implement*/ ASSERT(false); \ + return __VA_ARGS__; \ + } while (0) + +#define KOALA_INTEROP_THROW_STRING(vmContext, message, ...) \ + do { \ + ASSERT(false); /* Improve: implement*/ \ + return __VA_ARGS__; \ + } while (0) + +#endif // CONVERTORS_JSC_H \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/kotlin/cinterop-interop_native_module.def b/ets1.2/interop/src/cpp/kotlin/cinterop-interop_native_module.def new file mode 100644 index 0000000000000000000000000000000000000000..57e8fa3db4d165e819592c4624e423621b418a70 --- /dev/null +++ b/ets1.2/interop/src/cpp/kotlin/cinterop-interop_native_module.def @@ -0,0 +1 @@ +headers = cinterop-interop_native_module.h diff --git a/ets1.2/interop/src/cpp/kotlin/cinterop-interop_native_module.h b/ets1.2/interop/src/cpp/kotlin/cinterop-interop_native_module.h new file mode 100644 index 0000000000000000000000000000000000000000..f0ce25b7e4001bc5af66d01c00ad97e39f7ad4e2 --- /dev/null +++ b/ets1.2/interop/src/cpp/kotlin/cinterop-interop_native_module.h @@ -0,0 +1,64 @@ +/* + * 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. + */ +#ifndef CINTEROP_INTEROP_NATIVE_MODULE_H +#define CINTEROP_INTEROP_NATIVE_MODULE_H + +// This header is intended to be used only in Kotlin Native cinterop headers. +// Do not include it elsewhere. + +#include "kotlin-cinterop.h" + +KOALA_INTEROP_1(GetGroupedLog, KNativePointer, KInt) +KOALA_INTEROP_V1(StartGroupedLog, KInt) +KOALA_INTEROP_V1(StopGroupedLog, KInt) +KOALA_INTEROP_V2(AppendGroupedLog, KInt, KStringPtr) +KOALA_INTEROP_V1(PrintGroupedLog, KInt) +KOALA_INTEROP_0(GetStringFinalizer, KNativePointer) +KOALA_INTEROP_V2(InvokeFinalizer, KNativePointer, KNativePointer) +KOALA_INTEROP_1(IncrementNumber, KInteropNumber, KInteropNumber) +KOALA_INTEROP_2(GetPtrVectorElement, KNativePointer, KNativePointer, KInt) +KOALA_INTEROP_1(StringLength, KInt, KNativePointer) +KOALA_INTEROP_V3(StringData, KNativePointer, KByte*, KInt) +KOALA_INTEROP_1(StringMake, KNativePointer, KStringPtr) +KOALA_INTEROP_1(GetPtrVectorSize, KInt, KNativePointer) +KOALA_INTEROP_4(ManagedStringWrite, KInt, KStringPtr, KSerializerBuffer, KInt, KInt) +KOALA_INTEROP_V1(NativeLog, KStringPtr) +KOALA_INTEROP_CTX_3(Utf8ToString, KStringPtr, KNativePointer, KInt, KInt) +KOALA_INTEROP_CTX_1(StdStringToString, KStringPtr, KNativePointer) +KOALA_INTEROP_DIRECT_2(CheckCallbackEvent, KInt, KSerializerBuffer, KInt) +KOALA_INTEROP_V1(ReleaseCallbackResource, KInt) +KOALA_INTEROP_V1(HoldCallbackResource, KInt) +KOALA_INTEROP_V4(CallCallback, KInt, KInt, KSerializerBuffer, KInt) +KOALA_INTEROP_CTX_V4(CallCallbackSync, KInt, KInt, KSerializerBuffer, KInt) +KOALA_INTEROP_V2(CallCallbackResourceHolder, KNativePointer, KInt) +KOALA_INTEROP_V2(CallCallbackResourceReleaser, KNativePointer, KInt) +KOALA_INTEROP_CTX_4(LoadVirtualMachine, KInt, KInt, KStringPtr, KStringPtr, KStringPtr) +KOALA_INTEROP_2(RunApplication, KBoolean, KInt, KInt) +KOALA_INTEROP_2(StartApplication, KNativePointer, KStringPtr, KStringPtr) +KOALA_INTEROP_CTX_4(EmitEvent, KStringPtr, KInt, KInt, KInt, KInt) +KOALA_INTEROP_4(CallForeignVM, KInt, KNativePointer, KInt, KSerializerBuffer, KInt) +KOALA_INTEROP_V1(SetForeignVMContext, KNativePointer) +KOALA_INTEROP_V1(RestartWith, KStringPtr) +KOALA_INTEROP_DIRECT_3(ReadByte, KInt, KNativePointer, KLong, KLong) +KOALA_INTEROP_DIRECT_V4(WriteByte, KNativePointer, KLong, KLong, KInt) +KOALA_INTEROP_DIRECT_1(Malloc, KNativePointer, KLong) +KOALA_INTEROP_DIRECT_0(GetMallocFinalizer, KNativePointer) +KOALA_INTEROP_DIRECT_V1(Free, KNativePointer) +KOALA_INTEROP_V3(CopyArray, KNativePointer, KLong, KByte*) +KOALA_INTEROP_V0(ReportMemLeaks) + +KOALA_INTEROP_V1(SetKoalaKotlinCallbackDispatcher, KNativePointer) + +#endif // CINTEROP_INTEROP_NATIVE_MODULE_H diff --git a/ets1.2/interop/src/cpp/kotlin/convertors-kotlin.cc b/ets1.2/interop/src/cpp/kotlin/convertors-kotlin.cc new file mode 100644 index 0000000000000000000000000000000000000000..00c8a994f0adfe677850dd7b7a97abf7d0804bfe --- /dev/null +++ b/ets1.2/interop/src/cpp/kotlin/convertors-kotlin.cc @@ -0,0 +1,34 @@ +/* + * 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. + */ + +#include "koala-types.h" +#include "common-interop.h" +#include "interop-logging.h" + +typedef KInt (*KoalaCallbackDispatcher_t)(KInt id, KInt length, KSerializerBuffer buffer); +static KoalaCallbackDispatcher_t g_koalaKotlinCallbackDispatcher = nullptr; + +void callKoalaKotlinCallbackVoid(KInt id, KInt length, KSerializerBuffer buffer) { + g_koalaKotlinCallbackDispatcher(id, length, buffer); +} + +KInt callKoalaKotlinCallbackInt(KInt id, KInt length, KSerializerBuffer buffer) { + return g_koalaKotlinCallbackDispatcher(id, length, buffer); +} + +void impl_SetKoalaKotlinCallbackDispatcher(KNativePointer ptr) { + g_koalaKotlinCallbackDispatcher = reinterpret_cast(ptr); +} +KOALA_INTEROP_V1(SetKoalaKotlinCallbackDispatcher, KNativePointer) diff --git a/ets1.2/interop/src/cpp/kotlin/convertors-kotlin.h b/ets1.2/interop/src/cpp/kotlin/convertors-kotlin.h new file mode 100644 index 0000000000000000000000000000000000000000..d2ffceb39c4c403f6924f2e11ce4eba832d3dc80 --- /dev/null +++ b/ets1.2/interop/src/cpp/kotlin/convertors-kotlin.h @@ -0,0 +1,1429 @@ +/* + * 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. + */ + +#ifndef CONVERTORS_KOTLIN_H +#define CONVERTORS_KOTLIN_H + +#ifdef KOALA_KOTLIN + +#include +#include +#include +#include + +#include "koala-types.h" +#include "interop-logging.h" +#include "interop-utils.h" + +struct KotlinInteropBuffer { + int32_t length; + void *data; +}; + +template +struct InteropTypeConverter { + using InteropType = T; + static T convertFrom(InteropType value) = delete; + static InteropType convertTo(T value) = delete; + static void release(InteropType value, T converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = uint8_t; + static inline KByte convertFrom(InteropType value) { + return value; + } + static inline InteropType convertTo(KByte value) { + return value; + } + static inline void release(InteropType value, KByte converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = int8_t; + static inline KBoolean convertFrom(InteropType value) { + return value; + } + static inline InteropType convertTo(KBoolean value) { + return value; + } + static inline void release(InteropType value, KBoolean converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = int32_t; + static inline KInt convertFrom(InteropType value) { + return value; + } + static inline InteropType convertTo(KInt value) { + return value; + } + static inline void release(InteropType value, KInt converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = uint32_t; + static inline KUInt convertFrom(InteropType value) { + return value; + } + static inline InteropType convertTo(KUInt value) { + return value; + } + static inline void release(InteropType value, KUInt converted) {} +}; + + +template<> +struct InteropTypeConverter { + using InteropType = float; + static inline KFloat convertFrom(InteropType value) { + return value; + } + static inline InteropType convertTo(KFloat value) { + return value; + } + static inline void release(InteropType value, KFloat converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = double; + static inline KDouble convertFrom(InteropType value) { + return value; + } + static inline InteropType convertTo(KDouble value) { + return value; + } + static inline void release(InteropType value, KDouble converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = int64_t; + static inline KLong convertFrom(InteropType value) { + return value; + } + static inline InteropType convertTo(KLong value) { + return value; + } + static inline void release(InteropType value, KLong converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = void*; + static inline KVMObjectHandle convertFrom(InteropType value) { + return reinterpret_cast(value); + } + static inline InteropType convertTo(KVMObjectHandle value) { + return reinterpret_cast(value); + } + static inline void release(InteropType value, KVMObjectHandle converted) {} +}; + +// Improve: do we really need this converter? +template<> +struct InteropTypeConverter { + using InteropType = KotlinInteropBuffer; + static inline KInteropBuffer convertFrom(InteropType value) { + KInteropBuffer result = { 0 }; + result.data = value.data; + result.length = value.length; + return result; + } + static inline InteropType convertTo(KInteropBuffer value) { + // Improve: can we use KInteropBuffer::data without copying? + void *data = nullptr; + if (value.length > 0) { + data = malloc(value.length); + if (!data) { + INTEROP_FATAL("Cannot allocate memory"); + } + interop_memcpy(data, value.length, value.data, value.length); + } + InteropType result = { + .length = static_cast(value.length), + .data = data, + }; + value.dispose(value.resourceId); + return result; + } + static inline void release(InteropType value, KInteropBuffer converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = void*; + static KSerializerBuffer convertFrom(InteropType value) { + return reinterpret_cast(value); + } + static InteropType convertTo(KSerializerBuffer value) = delete; + static inline void release(InteropType value, KSerializerBuffer converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = KotlinInteropBuffer; + static inline KInteropReturnBuffer convertFrom(InteropType value) = delete; + static inline InteropType convertTo(KInteropReturnBuffer value) { + InteropType result = { + .length = value.length, + .data = value.data, + }; + return result; + }; + static inline void release(InteropType value, KInteropReturnBuffer converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = const char*; + static KStringPtr convertFrom(InteropType value) { + return KStringPtr(value); + } + static InteropType convertTo(const KStringPtr& value) { + // Improve: can we return KStringPtr::_value without copying? + if (!value.c_str()) { + return nullptr; + } + size_t bufferSize = value.length() + 1; + char *result = reinterpret_cast(malloc(bufferSize)); + if (!result) { + INTEROP_FATAL("Cannot allocate memory"); + } + interop_strcpy(result, bufferSize, value.c_str()); + return result; + } + static void release(InteropType value, const KStringPtr& converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = void*; + static KNativePointer convertFrom(InteropType value) { + return value; + } + static InteropType convertTo(KNativePointer value) { + return value; + } + static void release(InteropType value, KNativePointer converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = KInt*; + static KInt* convertFrom(InteropType value) { + return value; + } + static InteropType convertTo(KInt* value) = delete; + static void release(InteropType value, KInt* converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = KFloat*; + static KFloat* convertFrom(InteropType value) { + return value; + } + static InteropType convertTo(KFloat* value) = delete; + static void release(InteropType value, KFloat* converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = KByte*; + static KByte* convertFrom(InteropType value) { + return value; + } + static InteropType convertTo(KByte* value) = delete; + static void release(InteropType value, KByte* converted) {} +}; + +template <> struct InteropTypeConverter { + using InteropType = double; + static KInteropNumber convertFrom(InteropType value) { + return KInteropNumber::fromDouble(value); + } + static InteropType convertTo(KInteropNumber value) { + return value.asDouble(); + } + static void release(InteropType value, KInteropNumber converted) {} +}; + +template +inline typename InteropTypeConverter::InteropType makeResult(Type value) { + return InteropTypeConverter::convertTo(value); +} + +template +inline Type getArgument(typename InteropTypeConverter::InteropType arg) { + return InteropTypeConverter::convertFrom(arg); +} + +template +inline void releaseArgument(typename InteropTypeConverter::InteropType arg, Type& data) { + InteropTypeConverter::release(arg, data); +} + +#define KOALA_QUOTE0(x) #x +#define KOALA_QUOTE(x) KOALA_QUOTE0(x) + +#define KOTLIN_EXPORT extern "C" + +#define KOTLIN_PREFIX(name) kotlin_##name + +#define KOALA_INTEROP_0(name, Ret) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)() { \ + KOALA_MAYBE_LOG(name) \ + return makeResult(impl_##name()); \ + } + +#define KOALA_INTEROP_1(name, Ret, P0) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + auto rv = makeResult(impl_##name(p0)); \ + releaseArgument(_p0, p0); \ + return rv; \ + } + +#define KOALA_INTEROP_2(name, Ret, P0, P1) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + auto rv = makeResult(impl_##name(p0, p1)); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + return rv; \ + } + +#define KOALA_INTEROP_3(name, Ret, P0, P1, P2) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + auto rv = makeResult(impl_##name(p0, p1, p2)); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + return rv; \ + } + +#define KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + auto rv = makeResult(impl_##name(p0, p1, p2, p3)); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + return rv; \ + } + +#define KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + auto rv = makeResult(impl_##name(p0, p1, p2, p3, p4)); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + return rv; \ + } + +#define KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + auto rv = makeResult(impl_##name(p0, p1, p2, p3, p4, p5)); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + return rv; \ + } + +#define KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + auto rv = makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6)); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + releaseArgument(_p6, p6); \ + return rv; \ + } + +#define KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + auto rv = makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7)); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + releaseArgument(_p6, p6); \ + releaseArgument(_p7, p7); \ + return rv; \ + } + +#define KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + auto rv = makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8)); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + releaseArgument(_p6, p6); \ + releaseArgument(_p7, p7); \ + releaseArgument(_p8, p8); \ + return rv; \ + } + +#define KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + auto rv = makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + releaseArgument(_p6, p6); \ + releaseArgument(_p7, p7); \ + releaseArgument(_p8, p8); \ + releaseArgument(_p9, p9); \ + return rv; \ + } + +#define KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + auto rv = makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + releaseArgument(_p6, p6); \ + releaseArgument(_p7, p7); \ + releaseArgument(_p8, p8); \ + releaseArgument(_p9, p9); \ + releaseArgument(_p10, p10); \ + return rv; \ + } + +#define KOALA_INTEROP_12(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + auto rv = makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + releaseArgument(_p6, p6); \ + releaseArgument(_p7, p7); \ + releaseArgument(_p8, p8); \ + releaseArgument(_p9, p9); \ + releaseArgument(_p10, p10); \ + releaseArgument(_p11, p11); \ + return rv; \ + } + +#define KOALA_INTEROP_13(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + P12 p12 = getArgument(_p12); \ + auto rv = makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + releaseArgument(_p6, p6); \ + releaseArgument(_p7, p7); \ + releaseArgument(_p8, p8); \ + releaseArgument(_p9, p9); \ + releaseArgument(_p10, p10); \ + releaseArgument(_p11, p11); \ + releaseArgument(_p12, p12); \ + return rv; \ + } + +#define KOALA_INTEROP_14(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12, \ + InteropTypeConverter::InteropType _p13) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + P12 p12 = getArgument(_p12); \ + P13 p13 = getArgument(_p13); \ + auto rv = makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + releaseArgument(_p6, p6); \ + releaseArgument(_p7, p7); \ + releaseArgument(_p8, p8); \ + releaseArgument(_p9, p9); \ + releaseArgument(_p10, p10); \ + releaseArgument(_p11, p11); \ + releaseArgument(_p12, p12); \ + releaseArgument(_p13, p13); \ + return rv; \ + } + +#define KOALA_INTEROP_V0(name) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)() { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(); \ + } + +#define KOALA_INTEROP_V1(name, P0) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + impl_##name(p0); \ + releaseArgument(_p0, p0); \ + } + +#define KOALA_INTEROP_V2(name, P0, P1) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + impl_##name(p0, p1); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + } + +#define KOALA_INTEROP_V3(name, P0, P1, P2) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + impl_##name(p0, p1, p2); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + } + +#define KOALA_INTEROP_V4(name, P0, P1, P2, P3) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + impl_##name(p0, p1, p2, p3); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ +} + +#define KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + impl_##name(p0, p1, p2, p3, p4); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ +} + +#define KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + impl_##name(p0, p1, p2, p3, p4, p5); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + } + +#define KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + releaseArgument(_p6, p6); \ + } + +#define KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + releaseArgument(_p6, p6); \ + releaseArgument(_p7, p7); \ + } + +#define KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + releaseArgument(_p6, p6); \ + releaseArgument(_p7, p7); \ + releaseArgument(_p8, p8); \ + } + +#define KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + releaseArgument(_p6, p6); \ + releaseArgument(_p7, p7); \ + releaseArgument(_p8, p8); \ + releaseArgument(_p9, p9); \ +} + +#define KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + releaseArgument(_p6, p6); \ + releaseArgument(_p7, p7); \ + releaseArgument(_p8, p8); \ + releaseArgument(_p9, p9); \ + releaseArgument(_p10, p10); \ + } + +#define KOALA_INTEROP_V12(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + releaseArgument(_p6, p6); \ + releaseArgument(_p7, p7); \ + releaseArgument(_p8, p8); \ + releaseArgument(_p9, p9); \ + releaseArgument(_p10, p10); \ + releaseArgument(_p11, p11); \ +} + +#define KOALA_INTEROP_V13(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + P12 p12 = getArgument(_p12); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + releaseArgument(_p6, p6); \ + releaseArgument(_p7, p7); \ + releaseArgument(_p8, p8); \ + releaseArgument(_p9, p9); \ + releaseArgument(_p10, p10); \ + releaseArgument(_p11, p11); \ + releaseArgument(_p12, p12); \ +} + +#define KOALA_INTEROP_V14(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12, \ + InteropTypeConverter::InteropType _p13) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + P12 p12 = getArgument(_p12); \ + P13 p13 = getArgument(_p13); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + releaseArgument(_p6, p6); \ + releaseArgument(_p7, p7); \ + releaseArgument(_p8, p8); \ + releaseArgument(_p9, p9); \ + releaseArgument(_p10, p10); \ + releaseArgument(_p11, p11); \ + releaseArgument(_p12, p12); \ + releaseArgument(_p13, p13); \ +} + +#define KOALA_INTEROP_V15(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12, \ + InteropTypeConverter::InteropType _p13, \ + InteropTypeConverter::InteropType _p14) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + P12 p12 = getArgument(_p12); \ + P13 p13 = getArgument(_p13); \ + P14 p14 = getArgument(_p14); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + releaseArgument(_p5, p5); \ + releaseArgument(_p6, p6); \ + releaseArgument(_p7, p7); \ + releaseArgument(_p8, p8); \ + releaseArgument(_p9, p9); \ + releaseArgument(_p10, p10); \ + releaseArgument(_p11, p11); \ + releaseArgument(_p12, p12); \ + releaseArgument(_p13, p13); \ + releaseArgument(_p14, p14); \ +} + +#define KOALA_INTEROP_CTX_0(name, Ret) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)() { \ + KOALA_MAYBE_LOG(name) \ + KVMContext ctx = (KVMContext)nullptr; \ + auto rv = makeResult(impl_##name(ctx)); \ + return rv; \ + } + +#define KOALA_INTEROP_CTX_1(name, Ret, P0) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + KVMContext ctx = (KVMContext)nullptr; \ + auto rv = makeResult(impl_##name(ctx, p0)); \ + releaseArgument(_p0, p0); \ + return rv; \ + } + +#define KOALA_INTEROP_CTX_2(name, Ret, P0, P1) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + KVMContext ctx = (KVMContext)nullptr; \ + auto rv = makeResult(impl_##name(ctx, p0, p1)); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + return rv; \ + } + +#define KOALA_INTEROP_CTX_3(name, Ret, P0, P1, P2) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + KVMContext ctx = (KVMContext)nullptr; \ + auto rv = makeResult(impl_##name(ctx, p0, p1, p2)); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + return rv; \ + } + +#define KOALA_INTEROP_CTX_4(name, Ret, P0, P1, P2, P3) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + KVMContext ctx = (KVMContext)nullptr; \ + auto rv = makeResult(impl_##name(ctx, p0, p1, p2, p3)); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + return rv; \ + } + +#define KOALA_INTEROP_CTX_5(name, Ret, P0, P1, P2, P3, P4) \ + KOTLIN_EXPORT InteropTypeConverter::InteropType KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + KVMContext ctx = (KVMContext)nullptr; \ + auto rv = makeResult(impl_##name(ctx, p0, p1, p2, p3, p4)); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + return rv; \ + } + +#define KOALA_INTEROP_CTX_V0(name) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)() { \ + KOALA_MAYBE_LOG(name) \ + KVMContext ctx = (KVMContext)nullptr; \ + impl_##name(ctx); \ + } + +#define KOALA_INTEROP_CTX_V1(name, P0) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + KVMContext ctx = (KVMContext)nullptr; \ + impl_##name(ctx, p0); \ + releaseArgument(_p0, p0); \ + } + +#define KOALA_INTEROP_CTX_V2(name, P0, P1) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + KVMContext ctx = (KVMContext)nullptr; \ + impl_##name(ctx, p0, p1); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + } + +#define KOALA_INTEROP_CTX_V3(name, P0, P1, P2) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + KVMContext ctx = (KVMContext)nullptr; \ + impl_##name(ctx, p0, p1, p2); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + } + +#define KOALA_INTEROP_CTX_V4(name, P0, P1, P2, P3) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + KVMContext ctx = (KVMContext)nullptr; \ + impl_##name(ctx, p0, p1, p2, p3); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + } + +#define KOALA_INTEROP_CTX_V5(name, P0, P1, P2, P3, P4) \ + KOTLIN_EXPORT void KOTLIN_PREFIX(name)( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + KVMContext ctx = (KVMContext)nullptr; \ + impl_##name(ctx, p0, p1, p2, p3, p4); \ + releaseArgument(_p0, p0); \ + releaseArgument(_p1, p1); \ + releaseArgument(_p2, p2); \ + releaseArgument(_p3, p3); \ + releaseArgument(_p4, p4); \ + } + +#define KOALA_INTEROP_DIRECT_0(name, Ret) \ + KOALA_INTEROP_0(name, Ret) +#define KOALA_INTEROP_DIRECT_1(name, Ret, P0) \ + KOALA_INTEROP_1(name, Ret, P0) +#define KOALA_INTEROP_DIRECT_2(name, Ret, P0, P1) \ + KOALA_INTEROP_2(name, Ret, P0, P1) +#define KOALA_INTEROP_DIRECT_3(name, Ret, P0, P1, P2) \ + KOALA_INTEROP_3(name, Ret, P0, P1, P2) +#define KOALA_INTEROP_DIRECT_4(name, Ret, P0, P1, P2, P3) \ + KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) +#define KOALA_INTEROP_DIRECT_5(name, Ret, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) +#define KOALA_INTEROP_DIRECT_6(name, Ret, P0, P1, P2, P3, P4, P5) \ + KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) +#define KOALA_INTEROP_DIRECT_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) +#define KOALA_INTEROP_DIRECT_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) +#define KOALA_INTEROP_DIRECT_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) +#define KOALA_INTEROP_DIRECT_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) +#define KOALA_INTEROP_DIRECT_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) +#define KOALA_INTEROP_DIRECT_V0(name) \ + KOALA_INTEROP_V0(name) +#define KOALA_INTEROP_DIRECT_V1(name, P0) \ + KOALA_INTEROP_V1(name, P0) +#define KOALA_INTEROP_DIRECT_V2(name, P0, P1) \ + KOALA_INTEROP_V2(name, P0, P1) +#define KOALA_INTEROP_DIRECT_V3(name, P0, P1, P2) \ + KOALA_INTEROP_V3(name, P0, P1, P2) +#define KOALA_INTEROP_DIRECT_V4(name, P0, P1, P2, P3) \ + KOALA_INTEROP_V4(name, P0, P1, P2, P3) +#define KOALA_INTEROP_DIRECT_V5(name, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) +#define KOALA_INTEROP_DIRECT_V6(name, P0, P1, P2, P3, P4, P5) \ + KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) +#define KOALA_INTEROP_DIRECT_V7(name, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) +#define KOALA_INTEROP_DIRECT_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) +#define KOALA_INTEROP_DIRECT_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) +#define KOALA_INTEROP_DIRECT_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) +#define KOALA_INTEROP_DIRECT_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) + +void callKoalaKotlinCallbackVoid(KInt id, KInt length, KSerializerBuffer buffer); +KInt callKoalaKotlinCallbackInt(KInt id, KInt length, KSerializerBuffer buffer); + +#define KOALA_INTEROP_CALL_VOID(venv, id, length, args) \ +{ \ + callKoalaKotlinCallbackVoid(id, length, reinterpret_cast(args)); \ +} + +#define KOALA_INTEROP_CALL_INT(venv, id, length, args) \ +{ \ + KInt result = callKoalaKotlinCallbackInt(id, length, reinterpret_cast(args)); \ + return result; \ +} + +#define KOALA_INTEROP_CALL_VOID_INTS32(venv, id, argc, args) KOALA_INTEROP_CALL_VOID(venv, id, (argc) * sizeof(int32_t), args) +#define KOALA_INTEROP_CALL_INT_INTS32(venv, id, argc, args) KOALA_INTEROP_CALL_INT(venv, id, (argc) * sizeof(int32_t), args) + +// Improve: +#define KOALA_INTEROP_THROW(vmContext, object, ...) \ + do { \ + KOALA_MAYBE_LOG("KOALA_INTEROP_THROW") \ + std::terminate(); \ + } while (0) + +// Improve: +#define KOALA_INTEROP_THROW_STRING(vmContext, message, ...) \ + do { \ + KOALA_MAYBE_LOG("KOALA_INTEROP_THROW_STRING") \ + KOALA_MAYBE_LOG(message) \ + std::terminate(); \ + } while (0) + +#endif // KOALA_KOTLIN + +#endif // CONVERTORS_KOTLIN_H \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/kotlin/kotlin-cinterop.h b/ets1.2/interop/src/cpp/kotlin/kotlin-cinterop.h new file mode 100644 index 0000000000000000000000000000000000000000..f5094f285347076ce55388c407708cf4dfb6c319 --- /dev/null +++ b/ets1.2/interop/src/cpp/kotlin/kotlin-cinterop.h @@ -0,0 +1,183 @@ +/* + * 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. + */ + +// This header is intended to be used only in Kotlin Native cinterop headers. +// Do not include it elsewhere. + +#ifndef _KOTLIN_CINTEROP_H +#define _KOTLIN_CINTEROP_H + +#include + +struct KotlinInteropBuffer { + int32_t length; + void *data; +}; + +// All type aliases below are defined using macros so as not to collide with their Kotlin counterparts. +#define KInteropReturnBuffer struct KotlinInteropBuffer +#define KInteropBuffer struct KotlinInteropBuffer + +#define KBoolean int8_t +#define KByte uint8_t +#define KShort int16_t +#define KUShort uint16_t +#define KInt int32_t +#define KUInt uint32_t +#define KLong int64_t +#define KULong uint64_t +#define KFloat float +#define KDouble double +#define KInteropNumber double +#define KStringPtr const char * +#define KSerializerBuffer void * +#define KNativePointer void * +#define KByteArray uint8_t * +#define KIntArray int32_t * +#define KFloatArray float * + +#define KOALA_INTEROP_FUNCTION_DECLARATION(name, Ret, ...) \ + Ret kotlin_##name(__VA_ARGS__); + +#define KOALA_INTEROP_VOID_FUNCTION_DECLARATION(name, ...) \ + KOALA_INTEROP_FUNCTION_DECLARATION(name, void, __VA_ARGS__) + +// NORMAL +#define KOALA_INTEROP_0(name, Ret) \ + KOALA_INTEROP_FUNCTION_DECLARATION(name, Ret) +#define KOALA_INTEROP_1(name, Ret, P0) \ + KOALA_INTEROP_FUNCTION_DECLARATION(name, Ret, P0) +#define KOALA_INTEROP_2(name, Ret, P0, P1) \ + KOALA_INTEROP_FUNCTION_DECLARATION(name, Ret, P0, P1) +#define KOALA_INTEROP_3(name, Ret, P0, P1, P2) \ + KOALA_INTEROP_FUNCTION_DECLARATION(name, Ret, P0, P1, P2) +#define KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) \ + KOALA_INTEROP_FUNCTION_DECLARATION(name, Ret, P0, P1, P2, P3) +#define KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_FUNCTION_DECLARATION(name, Ret, P0, P1, P2, P3, P4) +#define KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) \ + KOALA_INTEROP_FUNCTION_DECLARATION(name, Ret, P0, P1, P2, P3, P4, P5) +#define KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_INTEROP_FUNCTION_DECLARATION(name, Ret, P0, P1, P2, P3, P4, P5, P6) +#define KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_INTEROP_FUNCTION_DECLARATION(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) +#define KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_INTEROP_FUNCTION_DECLARATION(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) +#define KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_INTEROP_FUNCTION_DECLARATION(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) +#define KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_INTEROP_FUNCTION_DECLARATION(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) +#define KOALA_INTEROP_V0(name) \ + KOALA_INTEROP_VOID_FUNCTION_DECLARATION(name) +#define KOALA_INTEROP_V1(name, P0) \ + KOALA_INTEROP_VOID_FUNCTION_DECLARATION(name, P0) +#define KOALA_INTEROP_V2(name, P0, P1) \ + KOALA_INTEROP_VOID_FUNCTION_DECLARATION(name, P0, P1) +#define KOALA_INTEROP_V3(name, P0, P1, P2) \ + KOALA_INTEROP_VOID_FUNCTION_DECLARATION(name, P0, P1, P2) +#define KOALA_INTEROP_V4(name, P0, P1, P2, P3) \ + KOALA_INTEROP_VOID_FUNCTION_DECLARATION(name, P0, P1, P2, P3) +#define KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_VOID_FUNCTION_DECLARATION(name, P0, P1, P2, P3, P4) +#define KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) \ + KOALA_INTEROP_VOID_FUNCTION_DECLARATION(name, P0, P1, P2, P3, P4, P5) +#define KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_INTEROP_VOID_FUNCTION_DECLARATION(name, P0, P1, P2, P3, P4, P5, P6) +#define KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_INTEROP_VOID_FUNCTION_DECLARATION(name, P0, P1, P2, P3, P4, P5, P6, P7) +#define KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_INTEROP_VOID_FUNCTION_DECLARATION(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) +#define KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_INTEROP_VOID_FUNCTION_DECLARATION(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) +#define KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_INTEROP_VOID_FUNCTION_DECLARATION(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) + +// CTX +#define KOALA_INTEROP_CTX_0(name, Ret) \ + KOALA_INTEROP_0(name, Ret) +#define KOALA_INTEROP_CTX_1(name, Ret, P0) \ + KOALA_INTEROP_1(name, Ret, P0) +#define KOALA_INTEROP_CTX_2(name, Ret, P0, P1) \ + KOALA_INTEROP_2(name, Ret, P0, P1) +#define KOALA_INTEROP_CTX_3(name, Ret, P0, P1, P2) \ + KOALA_INTEROP_3(name, Ret, P0, P1, P2) +#define KOALA_INTEROP_CTX_4(name, Ret, P0, P1, P2, P3) \ + KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) +#define KOALA_INTEROP_CTX_5(name, Ret, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) +#define KOALA_INTEROP_CTX_V0(name) \ + KOALA_INTEROP_V0(name) +#define KOALA_INTEROP_CTX_V1(name, P0) \ + KOALA_INTEROP_V1(name, P0) +#define KOALA_INTEROP_CTX_V2(name, P0, P1) \ + KOALA_INTEROP_V2(name, P0, P1) +#define KOALA_INTEROP_CTX_V3(name, P0, P1, P2) \ + KOALA_INTEROP_V3(name, P0, P1, P2) +#define KOALA_INTEROP_CTX_V4(name, P0, P1, P2, P3) \ + KOALA_INTEROP_V4(name, P0, P1, P2, P3) +#define KOALA_INTEROP_CTX_V5(name, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) + +// DIRECT +#define KOALA_INTEROP_DIRECT_0(name, Ret) \ + KOALA_INTEROP_0(name, Ret) +#define KOALA_INTEROP_DIRECT_1(name, Ret, P0) \ + KOALA_INTEROP_1(name, Ret, P0) +#define KOALA_INTEROP_DIRECT_2(name, Ret, P0, P1) \ + KOALA_INTEROP_2(name, Ret, P0, P1) +#define KOALA_INTEROP_DIRECT_3(name, Ret, P0, P1, P2) \ + KOALA_INTEROP_3(name, Ret, P0, P1, P2) +#define KOALA_INTEROP_DIRECT_4(name, Ret, P0, P1, P2, P3) \ + KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) +#define KOALA_INTEROP_DIRECT_5(name, Ret, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) +#define KOALA_INTEROP_DIRECT_6(name, Ret, P0, P1, P2, P3, P4, P5) \ + KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) +#define KOALA_INTEROP_DIRECT_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) +#define KOALA_INTEROP_DIRECT_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) +#define KOALA_INTEROP_DIRECT_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) +#define KOALA_INTEROP_DIRECT_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) +#define KOALA_INTEROP_DIRECT_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) +#define KOALA_INTEROP_DIRECT_V0(name) \ + KOALA_INTEROP_V0(name) +#define KOALA_INTEROP_DIRECT_V1(name, P0) \ + KOALA_INTEROP_V1(name, P0) +#define KOALA_INTEROP_DIRECT_V2(name, P0, P1) \ + KOALA_INTEROP_V2(name, P0, P1) +#define KOALA_INTEROP_DIRECT_V3(name, P0, P1, P2) \ + KOALA_INTEROP_V3(name, P0, P1, P2) +#define KOALA_INTEROP_DIRECT_V4(name, P0, P1, P2, P3) \ + KOALA_INTEROP_V4(name, P0, P1, P2, P3) +#define KOALA_INTEROP_DIRECT_V5(name, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) +#define KOALA_INTEROP_DIRECT_V6(name, P0, P1, P2, P3, P4, P5) \ + KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) +#define KOALA_INTEROP_DIRECT_V7(name, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) +#define KOALA_INTEROP_DIRECT_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) +#define KOALA_INTEROP_DIRECT_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) +#define KOALA_INTEROP_DIRECT_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) +#define KOALA_INTEROP_DIRECT_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) + +#endif /* _KOTLIN_CINTEROP_H */ diff --git a/ets1.2/interop/src/cpp/kotlin/kotlin_vmloader_wrapper.h b/ets1.2/interop/src/cpp/kotlin/kotlin_vmloader_wrapper.h new file mode 100644 index 0000000000000000000000000000000000000000..980a5abdc3d5f875d6cecaae2c76654ffc3f8e41 --- /dev/null +++ b/ets1.2/interop/src/cpp/kotlin/kotlin_vmloader_wrapper.h @@ -0,0 +1,44 @@ +#ifndef KOTLIN_VMLOADER_WRAPPER_H +#define KOTLIN_VMLOADER_WRAPPER_H + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef __cplusplus +typedef bool kotlin_KBoolean; +#else +typedef _Bool kotlin_KBoolean; +#endif +typedef unsigned short kotlin_KChar; +typedef signed char kotlin_KByte; +typedef short kotlin_KShort; +typedef int kotlin_KInt; +typedef long long kotlin_KLong; +typedef unsigned char kotlin_KUByte; +typedef unsigned short kotlin_KUShort; +typedef unsigned int kotlin_KUInt; +typedef unsigned long long kotlin_KULong; +typedef float kotlin_KFloat; +typedef double kotlin_KDouble; +typedef float __attribute__ ((__vector_size__ (16))) kotlin_KVector128; +typedef void* kotlin_KNativePtr; +struct kotlin_KType; +typedef struct kotlin_KType kotlin_KType; + +typedef struct { + kotlin_KNativePtr pinned; +} kotlin_kref_VMLoaderApplication; +typedef struct { + kotlin_KNativePtr pinned; +} kotlin_kref_PeerNodeStub; + +typedef kotlin_kref_VMLoaderApplication (*application_create_t)(const char* appUrl, const char* appParams); +typedef kotlin_KBoolean (*application_enter_t)(kotlin_kref_VMLoaderApplication app); +typedef kotlin_kref_PeerNodeStub (*application_start_t)(kotlin_kref_VMLoaderApplication app); + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* KOTLIN_VMLOADER_WRAPPER_H */ diff --git a/ets1.2/interop/src/cpp/napi/convertors-napi.cc b/ets1.2/interop/src/cpp/napi/convertors-napi.cc new file mode 100644 index 0000000000000000000000000000000000000000..f0b49b53b35b33dc81a4dd3eb01f26ce3c7bf288 --- /dev/null +++ b/ets1.2/interop/src/cpp/napi/convertors-napi.cc @@ -0,0 +1,404 @@ +/* + * 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 + +#include "interop-logging.h" +#undef KOALA_INTEROP_MODULE +#define KOALA_INTEROP_MODULE InteropNativeModule +#include "convertors-napi.h" + + +// Adapter for NAPI_MODULE +#define NODE_API_MODULE_ADAPTER(modname, regfunc) \ + static napi_value __napi_##regfunc(napi_env env, napi_value exports) { \ + return Napi::RegisterModule(env, exports, regfunc); \ + } \ + NAPI_MODULE(modname, __napi_##regfunc) + +napi_valuetype getValueTypeChecked(napi_env env, napi_value value) { + napi_valuetype type; + napi_status status = napi_typeof(env, value, &type); + KOALA_NAPI_THROW_IF_FAILED(env, status, napi_undefined); + return type; +} + +bool isTypedArray(napi_env env, napi_value value) { + bool result = false; + napi_status status = napi_is_typedarray(env, value, &result); + KOALA_NAPI_THROW_IF_FAILED(env, status, false); + return result; +} + +KBoolean getBoolean(napi_env env, napi_value value) { + if (getValueTypeChecked(env, value) == napi_valuetype::napi_boolean) { + bool result = false; + napi_get_value_bool(env, value, &result); + return static_cast(result); + } + return static_cast(getInt32(env, value) != 0); +} + +KInt getInt32(napi_env env, napi_value value) { + if (getValueTypeChecked(env, value) != napi_valuetype::napi_number) { + napi_throw_error(env, nullptr, "Expected Number"); + return 0; + } + int32_t result = false; + napi_get_value_int32(env, value, &result); + return static_cast(result); +} + +KUInt getUInt32(napi_env env, napi_value value) { + if (getValueTypeChecked(env, value) != napi_valuetype::napi_number) { + napi_throw_error(env, nullptr, "Expected Number"); + return 0; + } + uint32_t result = false; + napi_get_value_uint32(env, value, &result); + return static_cast(result); +} + +KFloat getFloat32(napi_env env, napi_value value) { + if (getValueTypeChecked(env, value) != napi_valuetype::napi_number) { + napi_throw_error(env, nullptr, "Expected Number"); + return 0.0f; + } + double result = false; + napi_get_value_double(env, value, &result); + return static_cast(static_cast(result)); +} + +KDouble getFloat64(napi_env env, napi_value value) { + if (getValueTypeChecked(env, value) != napi_valuetype::napi_number) { + napi_throw_error(env, nullptr, "Expected Number"); + return 0.0; + } + double result = false; + napi_get_value_double(env, value, &result); + return static_cast(result); +} + +KStringPtr getString(napi_env env, napi_value value) { + KStringPtr result {}; + napi_valuetype valueType = getValueTypeChecked(env, value); + if (valueType == napi_valuetype::napi_null || valueType == napi_valuetype::napi_undefined) { + return result; + } + + if (valueType != napi_valuetype::napi_string) { + napi_throw_error(env, nullptr, "Expected String"); + return result; + } + + size_t length = 0; + napi_status status = napi_get_value_string_utf8(env, value, nullptr, 0, &length); + if (status != 0) return result; + result.resize(length); + status = napi_get_value_string_utf8(env, value, result.data(), length + 1, nullptr); + return result; +} + +KNativePointer getPointerSlow(napi_env env, napi_value value) { + napi_valuetype valueType = getValueTypeChecked(env, value); + if (valueType == napi_valuetype::napi_external) { + KNativePointer result = nullptr; + napi_status status = napi_get_value_external(env, value, &result); + KOALA_NAPI_THROW_IF_FAILED(env, status, nullptr); + return result; + } + + if (valueType != napi_valuetype::napi_bigint) { + napi_throw_error(env, nullptr, "cannot be coerced to pointer"); + return nullptr; + } + + bool isWithinRange = true; + uint64_t ptrU64 = 0; + napi_status status = napi_get_value_bigint_uint64(env, value, &ptrU64, &isWithinRange); + KOALA_NAPI_THROW_IF_FAILED(env, status, nullptr); + if (!isWithinRange) { + napi_throw_error(env, nullptr, "cannot be coerced to uint64, value is too large"); + return nullptr; + } + return reinterpret_cast(ptrU64); +} + +KLong getInt64(napi_env env, napi_value value) { + if (getValueTypeChecked(env, value) == napi_valuetype::napi_number) { + int64_t result = 0; + if (napi_get_value_int64(env, value, &result) != napi_ok) { + napi_throw_error(env, nullptr, "cannot be coerced to int64"); + return -1; + } + return static_cast(result); + } + if (getValueTypeChecked(env, value) == napi_valuetype::napi_bigint) { + bool isWithinRange = true; + int64_t ptr64 = 0; + if (napi_get_value_bigint_int64(env, value, &ptr64, &isWithinRange) != napi_ok) { + napi_throw_error(env, nullptr, "cannot be coerced to int64"); + return -1; + } + if (!isWithinRange) { + napi_throw_error(env, nullptr, "cannot be coerced to int64, value is too large"); + return -1; + } + return static_cast(ptr64); + } + napi_throw_error(env, nullptr, "cannot be coerced to int64"); + return -1; +} + +KULong getUInt64(napi_env env, napi_value value) { + if (getValueTypeChecked(env, value) != napi_valuetype::napi_bigint) { + napi_throw_error(env, nullptr, "cannot be coerced to uint64"); + return -1; + } + + bool isWithinRange = true; + uint64_t ptr64 = 0; + napi_get_value_bigint_uint64(env, value, &ptr64, &isWithinRange); + if (!isWithinRange) { + napi_throw_error(env, nullptr, "cannot be coerced to uint64, value is too large"); + return -1; + } + return static_cast(ptr64); +} + +napi_value makeString(napi_env env, const KStringPtr& value) { + napi_value result; + napi_status status; + status = napi_create_string_utf8(env, value.isNull() ? "" : value.data(), value.length(), &result); + KOALA_NAPI_THROW_IF_FAILED(env, status, result); + return result; +} + +napi_value makeString(napi_env env, const std::string& value) { + napi_value result; + napi_status status; + status = napi_create_string_utf8(env, value.c_str(), value.length(), &result); + KOALA_NAPI_THROW_IF_FAILED(env, status, result); + return result; +} + +napi_value makeBoolean(napi_env env, int8_t value) { + napi_value result; + napi_status status; + status = napi_get_boolean(env, value != 0, &result); + KOALA_NAPI_THROW_IF_FAILED(env, status, result); + return result; +} + +napi_value makeInt32(napi_env env, int32_t value) { + napi_value result; + napi_status status; + status = napi_create_int32(env, value, &result); + KOALA_NAPI_THROW_IF_FAILED(env, status, result); + return result; +} + +napi_value makeUInt32(napi_env env, uint32_t value) { + napi_value result; + napi_status status; + status = napi_create_uint32(env, value, &result); + KOALA_NAPI_THROW_IF_FAILED(env, status, result); + return result; +} + +napi_value makeInt64(napi_env env, int64_t value) { + napi_value result; + napi_status status; + status = napi_create_bigint_int64(env, value, &result); + KOALA_NAPI_THROW_IF_FAILED(env, status, result); + return result; +} + +napi_value makeUInt64(napi_env env, uint64_t value) { + napi_value result; + napi_status status; + status = napi_create_bigint_uint64(env, value, &result); + KOALA_NAPI_THROW_IF_FAILED(env, status, result); + return result; +} + +napi_value makeFloat32(napi_env env, float value) { + napi_value result; + napi_status status; + status = napi_create_double(env, value, &result); + KOALA_NAPI_THROW_IF_FAILED(env, status, result); + return result; +} + +napi_value makeFloat64(napi_env env, double value) { + napi_value result; + napi_status status; + status = napi_create_double(env, value, &result); + KOALA_NAPI_THROW_IF_FAILED(env, status, result); + return result; +} + +napi_value makePointer(napi_env env, void* value) { + napi_value result; + napi_status status; + status = napi_create_bigint_uint64(env, static_cast(reinterpret_cast(value)), &result); + KOALA_NAPI_THROW_IF_FAILED(env, status, result); + return result; +} + +napi_value makeVoid(napi_env env) { + napi_value result; + napi_status status; + status = napi_get_undefined(env, &result); + KOALA_NAPI_THROW_IF_FAILED(env, status, result); + return result; +} + +napi_value makeObject(napi_env env, napi_value object) { + napi_value result; + napi_status status; + status = napi_create_object(env, &result); + KOALA_NAPI_THROW_IF_FAILED(env, status, result); + return result; +} + +#if _MSC_VER >= 1932 // Visual Studio 2022 version 17.2+ +# pragma comment(linker, "/alternatename:__imp___std_init_once_complete=__imp_InitOnceComplete") +# pragma comment(linker, "/alternatename:__imp___std_init_once_begin_initialize=__imp_InitOnceBeginInitialize") +#endif + +Exports* Exports::getInstance() { + static Exports *instance = nullptr; + if (instance == nullptr) { + instance = new Exports(); + } + return instance; +} + +std::vector Exports::getModules() { + std::vector result; + for (auto it = implementations.begin(); it != implementations.end(); ++it) { + result.push_back(it->first); + } + return result; +} + +void Exports::addMethod(const char* module, const char* name, napi_type_t impl) { + auto it = implementations.find(module); + if (it == implementations.end()) { + it = implementations.insert(std::make_pair(module, std::vector>())).first; + } + it->second.push_back(std::make_pair(name, impl)); + +} + +const std::vector>& Exports::getMethods(const std::string& module) { + auto it = implementations.find(module); + if (it == implementations.end()) { + LOGE("Module %s is not registered", module.c_str()); + INTEROP_FATAL("Fatal error"); + } + return it->second; +} + +// +// Callback dispatcher +// +// Improve: Should we get rid of explicit Node_* declrations and hide the naming convention behind the macro definitions? + +static napi_ref g_koalaNapiCallbackDispatcher = nullptr; + +// Improve: shall we pass name in globalThis instead of object reference? +napi_value Node_SetCallbackDispatcher(napi_env env, napi_callback_info cbinfo) { + fprintf(stderr, "Node_SetCallbackDispatcher!\n"); + + CallbackInfo info(env, cbinfo); + napi_value dispatcher = info[0]; + napi_value result = makeVoid(env); + napi_status status = napi_create_reference(env, dispatcher, 1, &g_koalaNapiCallbackDispatcher); + KOALA_NAPI_THROW_IF_FAILED(env, status, result); + + return result; +} +MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, SetCallbackDispatcher) + +napi_value Node_CleanCallbackDispatcher(napi_env env, napi_callback_info cbinfo) { + napi_value result = makeVoid(env); + if (g_koalaNapiCallbackDispatcher) { + napi_status status = napi_delete_reference(env, g_koalaNapiCallbackDispatcher); + g_koalaNapiCallbackDispatcher = nullptr; + KOALA_NAPI_THROW_IF_FAILED(env, status, result); + } + return result; +} +MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, CleanCallbackDispatcher) + +napi_value getKoalaNapiCallbackDispatcher(napi_env env) { + if (!g_koalaNapiCallbackDispatcher) { + abort(); + } + napi_value value; + napi_status status = napi_get_reference_value(env, g_koalaNapiCallbackDispatcher, &value); + KOALA_NAPI_THROW_IF_FAILED(env, status, makeVoid(env)); + return value; +} + +// +// Module initialization +// + +using ModuleRegisterCallback = napi_value (*)(napi_env env, napi_value exports); + +/** + * Sets a new callback and returns its previous value. + */ +ModuleRegisterCallback ProvideModuleRegisterCallback(ModuleRegisterCallback value = nullptr) { + static const ModuleRegisterCallback DEFAULT_CB = [](napi_env env, napi_value exports) { return exports; }; + static ModuleRegisterCallback curCallback = DEFAULT_CB; + + ModuleRegisterCallback prevCallback = curCallback; + curCallback = value ? value : DEFAULT_CB; + return prevCallback; +} + +static constexpr bool splitModules = true; + +static napi_value InitModule(napi_env env, napi_value exports) { + // LOG("InitModule: " QUOTE(INTEROP_LIBRARY_NAME)); + Exports* inst = Exports::getInstance(); + napi_status status; + napi_value target = exports; + for (const auto &module : inst->getModules()) { + if (splitModules) { + status = napi_create_object(env, &target); + KOALA_NAPI_THROW_IF_FAILED(env, status, exports); + status = napi_set_named_property(env, exports, module.c_str(), target); + KOALA_NAPI_THROW_IF_FAILED(env, status, exports); + } + + for (const auto &impl : inst->getMethods(module)) { + napi_value implFunc; + status = napi_create_function(env, impl.first.c_str(), NAPI_AUTO_LENGTH, impl.second, nullptr, &implFunc); + KOALA_NAPI_THROW_IF_FAILED(env, status, exports); + status = napi_set_named_property(env, target, impl.first.c_str(), implFunc); + KOALA_NAPI_THROW_IF_FAILED(env, status, exports); + } + } + return ProvideModuleRegisterCallback()(env, exports); +} + +NAPI_MODULE(INTEROP_LIBRARY_NAME, InitModule) diff --git a/ets1.2/interop/src/cpp/napi/convertors-napi.h b/ets1.2/interop/src/cpp/napi/convertors-napi.h new file mode 100644 index 0000000000000000000000000000000000000000..d1551ad4addffb7f2b741f09d1f6066827865af1 --- /dev/null +++ b/ets1.2/interop/src/cpp/napi/convertors-napi.h @@ -0,0 +1,1440 @@ +/* + * 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. + */ + +#ifndef _CONVERTORS_NAPI_H_ +#define _CONVERTORS_NAPI_H_ + +#ifdef KOALA_NAPI + +#include +#include +#include + +#ifndef KOALA_NAPI_OHOS +#include +#else +#include +#include +#endif +#include "koala-types.h" +#include "interop-types.h" + +// Improve: switch to more generic convertors eventually. +template +struct InteropTypeConverter { + using InteropType = T; + static T convertFrom(napi_env env, InteropType value) { return value; } + static InteropType convertTo(napi_env env, T value) { return value; } + static void release(napi_env env, InteropType value, T converted) {} +}; + +template +inline typename InteropTypeConverter::InteropType makeResult(napi_env env, Type value) { + return InteropTypeConverter::convertTo(env, value); +} + +template +inline Type getArgument(napi_env env, typename InteropTypeConverter::InteropType arg) { + return InteropTypeConverter::convertFrom(env, arg); +} + +template +inline void releaseArgument(napi_env env, typename InteropTypeConverter::InteropType arg, Type data) { + InteropTypeConverter::release(env, arg, data); +} + + +napi_value makeString(napi_env env, KStringPtr value); +napi_value makeString(napi_env env, const std::string& value); +napi_value makeBoolean(napi_env env, KBoolean value); +napi_value makeInt32(napi_env env, int32_t value); +napi_value makeUInt32(napi_env env, uint32_t value); +napi_value makeInt64(napi_env env, int64_t value); +napi_value makeUInt64(napi_env env, uint64_t value); +napi_value makeFloat32(napi_env env, float value); +napi_value makeFloat64(napi_env env, double value); +napi_value makePointer(napi_env env, void* value); +napi_value makeVoid(napi_env env); + +void* getPointerSlow(napi_env env, napi_value value); + +inline void* getPointer(napi_env env, napi_value value) { + bool isWithinRange = true; + uint64_t ptrU64 = 0; + napi_status status = napi_get_value_bigint_uint64(env, value, &ptrU64, &isWithinRange); + if (status != 0 || !isWithinRange) + return getPointerSlow(env, value); + else + return reinterpret_cast(ptrU64); +} +void* getSerializerBufferPointer(napi_env env, napi_value value); + +template<> +struct InteropTypeConverter { + using InteropType = napi_value; + static KInteropBuffer convertFrom(napi_env env, InteropType value) { + KInteropBuffer result {}; + bool isArrayBuffer = false; + napi_is_arraybuffer(env, value, &isArrayBuffer); + if (isArrayBuffer) { + napi_get_arraybuffer_info(env, value, &result.data, reinterpret_cast(&result.length)); + } else { + bool isDataView = false; + napi_is_dataview(env, value, &isDataView); + if (isDataView) { + napi_get_dataview_info(env, value, reinterpret_cast(&result.length), &result.data, nullptr, nullptr); + } + } + return result; + } + static InteropType convertTo(napi_env env, KInteropBuffer value) { + KInteropBuffer* copy = new KInteropBuffer(value); + napi_value result; + napi_status status = napi_create_external_arraybuffer( + env, + value.data, + value.length, + [](napi_env env, void* finalize_data, void* finalize_hint) { + KInteropBuffer* buffer = reinterpret_cast(finalize_hint); + buffer->dispose(buffer->resourceId); + delete buffer; + }, + (void*)copy, + &result + ); + if (status != napi_ok) { + // do smth here + } + return result; + }; + static void release(napi_env env, InteropType value, KInteropBuffer converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = napi_value; + static KStringPtr convertFrom(napi_env env, InteropType value) { + if (value == nullptr) return KStringPtr(); + KStringPtr result; + size_t length = 0; + napi_status status = napi_get_value_string_utf8(env, value, nullptr, 0, &length); + if (status != 0) return result; + result.resize(length); + status = napi_get_value_string_utf8(env, value, result.data(), length + 1, nullptr); + return result; + } + static InteropType convertTo(napi_env env, const KStringPtr& value) { + napi_value result; + napi_create_string_utf8(env, value.c_str(), value.length(), &result); + return result; + } + static void release(napi_env env, InteropType value, const KStringPtr& converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = napi_value; + static KInteropNumber convertFrom(napi_env env, InteropType interopValue) { + double value = 0.0; + napi_get_value_double(env, interopValue, &value); + return KInteropNumber::fromDouble(value); + } + static InteropType convertTo(napi_env env, KInteropNumber value) { + napi_value result; + napi_create_double(env, value.asDouble(), &result); + return result; + } + static void release(napi_env env, InteropType value, KInteropNumber converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = napi_value; + static KSerializerBuffer convertFrom(napi_env env, InteropType value) { + return (KSerializerBuffer)getSerializerBufferPointer(env, value); // Improve: we are receiving Uint8Array from the native side + } + static InteropType convertTo(napi_env env, KSerializerBuffer value) { + return makePointer(env, value); + } + static void release(napi_env env, InteropType value, KSerializerBuffer converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = napi_value; + static inline KVMObjectHandle convertFrom(napi_env env, InteropType value) { + return reinterpret_cast(value); + } + static InteropType convertTo(napi_env env, KVMObjectHandle value) { + return reinterpret_cast(value); + } + static inline void release(napi_env env, InteropType value, KVMObjectHandle converted) { + } +}; + +template<> +struct InteropTypeConverter { + using InteropType = napi_value; + static inline KInteropReturnBuffer convertFrom(napi_env env, InteropType value) = delete; + static void disposer(napi_env env, void* data, void* hint) { + KInteropReturnBuffer* bufferCopy = (KInteropReturnBuffer*)hint; + bufferCopy->dispose(bufferCopy->data, bufferCopy->length); + delete bufferCopy; + } + static InteropType convertTo(napi_env env, KInteropReturnBuffer value) { + napi_value result = nullptr; + napi_value arrayBuffer = nullptr; + auto clone = new KInteropReturnBuffer(); + *clone = value; + napi_create_external_arraybuffer(env, value.data, value.length, disposer, clone, &arrayBuffer); + napi_create_typedarray(env, napi_uint8_array, value.length, arrayBuffer, 0, &result); + return result; + } + static inline void release(napi_env env, InteropType value, const KInteropReturnBuffer& converted) = delete; +}; + + +#define KOALA_INTEROP_THROW(vmContext, object, ...) \ + do { \ + napi_env env = (napi_env)vmContext; \ + napi_handle_scope scope = nullptr; \ + napi_open_handle_scope(env, &scope); \ + napi_throw(env, object); \ + napi_close_handle_scope(env, scope); \ + return __VA_ARGS__; \ + } while (0) + +#define KOALA_INTEROP_THROW_STRING(vmContext, message, ...) \ + do { \ + napi_env env = (napi_env)vmContext; \ + napi_handle_scope scope = nullptr; \ + napi_open_handle_scope(env, &scope); \ + napi_throw_error(env, nullptr, message); \ + napi_close_handle_scope(env, scope); \ + return __VA_ARGS__; \ + } while (0) + +#define NAPI_ASSERT_INDEX(info, index, result) \ + do { \ + if (static_cast(index) >= info.Length()) { \ + napi_throw_error(info.Env(), nullptr, "No such element");\ + return result; \ + } \ + } while (0) + +// Helpers from node-addon-api +#define KOALA_NAPI_THROW_IF_FAILED(env, status, ...) \ + if ((status) != napi_ok) { \ + const napi_extended_error_info* errorInfo; \ + napi_get_last_error_info(env, &errorInfo); \ + napi_throw_error(env, nullptr, errorInfo->error_message); \ + return __VA_ARGS__; \ + } +#define KOALA_NAPI_THROW_IF_FAILED_VOID(env, status) \ + if ((status) != napi_ok) { \ + const napi_extended_error_info* errorInfo; \ + napi_get_last_error_info(env, &errorInfo); \ + napi_throw_error(env, nullptr, errorInfo->error_message); \ + return; \ + } + +class CallbackInfo { +public: + CallbackInfo(napi_env env, napi_callback_info info) : _env(env) { + size_t size = 0; + napi_status status; + status = napi_get_cb_info(env, info, &size, nullptr, nullptr, nullptr); + KOALA_NAPI_THROW_IF_FAILED_VOID(env, status); + if (size > 0) { + args.resize(size); // Improve: statically allocate small array for common case with few arguments passed + status = napi_get_cb_info(env, info, &size, args.data(), nullptr, nullptr); + KOALA_NAPI_THROW_IF_FAILED_VOID(env, status); + } + } + + napi_value operator[](size_t idx) const { + if (idx >= Length()) { + napi_value result; + napi_get_undefined(_env, &result); + return result; + } + return args[idx]; + } + + napi_env Env() const { + return _env; + } + + size_t Length() const { + return args.size(); + } +private: + napi_env _env; + // napi_callback_info _info; + std::vector args; +}; + +template +inline napi_typedarray_type getNapiType() = delete; + +template <> +inline napi_typedarray_type getNapiType() { + return napi_float32_array; +} + +template <> +inline napi_typedarray_type getNapiType() { + return napi_float64_array; +} + +template <> +inline napi_typedarray_type getNapiType() { + return napi_int8_array; +} + +template <> +inline napi_typedarray_type getNapiType() { + return napi_uint8_array; +} + +template <> +inline napi_typedarray_type getNapiType() { + return napi_int16_array; +} + +template <> +inline napi_typedarray_type getNapiType() { + return napi_uint16_array; +} + +template <> +inline napi_typedarray_type getNapiType() { + return napi_int32_array; +} + +template <> +inline napi_typedarray_type getNapiType() { + return napi_uint32_array; +} + +template <> +inline napi_typedarray_type getNapiType() { + return napi_biguint64_array; +} + +napi_valuetype getValueTypeChecked(napi_env env, napi_value value); +bool isTypedArray(napi_env env, napi_value value); + +template +inline ElemType* getTypedElements(napi_env env, napi_value value) { + napi_valuetype valueType = getValueTypeChecked(env, value); + if (valueType == napi_null) { + return nullptr; + } + if (!isTypedArray(env, value)) { + napi_throw_error(env, nullptr, "Expected TypedArray"); + return nullptr; + } + napi_value arrayBuffer; + void* data = nullptr; + size_t byteLength; + size_t byteOffset; + napi_typedarray_type type; + napi_status status = napi_get_typedarray_info(env, + value, + &type, + &byteLength, + &data, + &arrayBuffer, + &byteOffset); + KOALA_NAPI_THROW_IF_FAILED(env, status, nullptr); + if (type != getNapiType()) { + printf("Array type mismatch. Expected %d got %d\n", getNapiType(), type); + napi_throw_error(env, nullptr, "Array type mismatch"); + return nullptr; + } + return reinterpret_cast(data); +} + +template +inline ElemType* getTypedElements(const CallbackInfo& info, int index) { + NAPI_ASSERT_INDEX(info, index, nullptr); + return getTypedElements(info.Env(), info[index]); +} + +inline uint8_t* getUInt8Elements(const CallbackInfo& info, int index) { + return getTypedElements(info, index); +} + +inline int8_t* getInt8Elements(const CallbackInfo& info, int index) { + return getTypedElements(info, index); +} + +inline uint16_t* getUInt16Elements(const CallbackInfo& info, int index) { + return getTypedElements(info, index); +} + +inline int16_t* getInt16Elements(const CallbackInfo& info, int index) { + return getTypedElements(info, index); +} + +inline uint32_t* getUInt32Elements(const CallbackInfo& info, int index) { + return getTypedElements(info, index); +} + +inline uint32_t* getUInt32Elements(napi_env env, napi_value value) { + return getTypedElements(env, value); +} + +inline int32_t* getInt32Elements(const CallbackInfo& info, int index) { + return getTypedElements(info, index); +} + +inline float* getFloat32Elements(const CallbackInfo& info, int index) { + return getTypedElements(info, index); +} + +inline double* getFloat64Elements(const CallbackInfo& info, int index) { + return getTypedElements(info, index); +} + +inline KNativePointer* getPointerElements(const CallbackInfo& info, int index) { + return getTypedElements(info, index); +} + +inline void* getSerializerBufferPointer(napi_env env, napi_value value) { + return getTypedElements(env, value); +} + +KInt getInt32(napi_env env, napi_value value); +inline int32_t getInt32(const CallbackInfo& info, int index) { + NAPI_ASSERT_INDEX(info, index, 0); + return getInt32(info.Env(), info[index]); +} +KUInt getUInt32(napi_env env, napi_value value); +inline uint32_t getUInt32(const CallbackInfo& info, int index) { + NAPI_ASSERT_INDEX(info, index, 0); + return getUInt32(info.Env(), info[index]); +} +KFloat getFloat32(napi_env env, napi_value value); +inline float getFloat32(const CallbackInfo& info, int index) { + NAPI_ASSERT_INDEX(info, index, 0.0f); + return getFloat32(info.Env(), info[index]); +} +KDouble getFloat64(napi_env env, napi_value value); +inline KDouble getFloat64(const CallbackInfo& info, int index) { + NAPI_ASSERT_INDEX(info, index, 0.0); + return getFloat64(info.Env(), info[index]); +} +KStringPtr getString(napi_env env, napi_value value); +inline KStringPtr getString(const CallbackInfo& info, int index) { + NAPI_ASSERT_INDEX(info, index, KStringPtr()); + return getString(info.Env(), info[index]); +} +inline void* getPointer(const CallbackInfo& info, int index) { + NAPI_ASSERT_INDEX(info, index, nullptr); + return getPointer(info.Env(), info[index]); +} +KULong getUInt64(napi_env env, napi_value value); +inline KULong getUInt64(const CallbackInfo& info, int index) { + NAPI_ASSERT_INDEX(info, index, 0); + return getUInt64(info.Env(), info[index]); +} +KLong getInt64(napi_env env, napi_value value); +inline KLong getInt64(const CallbackInfo& info, int index) { + NAPI_ASSERT_INDEX(info, index, 0); + return getInt64(info.Env(), info[index]); +} +KBoolean getBoolean(napi_env env, napi_value value); +inline KBoolean getBoolean(const CallbackInfo& info, int index) { + NAPI_ASSERT_INDEX(info, index, false); + return getBoolean(info.Env(), info[index]); +} +template +inline Type getArgument(const CallbackInfo& info, int index) = delete; + +template <> +inline KBoolean getArgument(const CallbackInfo& info, int index) { + return getBoolean(info, index); +} + +template <> +inline KUInt getArgument(const CallbackInfo& info, int index) { + return getUInt32(info, index); +} + +template <> +inline KInt getArgument(const CallbackInfo& info, int index) { + return getInt32(info, index); +} + +template <> +inline KInteropNumber getArgument(const CallbackInfo& info, int index) { + NAPI_ASSERT_INDEX(info, index, { 0 }); + return getArgument(info.Env(), info[index]); +} + +template <> +inline KSerializerBuffer getArgument(const CallbackInfo& info, int index) { + NAPI_ASSERT_INDEX(info, index, nullptr); + return getArgument(info.Env(), info[index]); +} + +template <> +inline KInteropBuffer getArgument(const CallbackInfo& info, int index) { + NAPI_ASSERT_INDEX(info, index, {}); + return getArgument((napi_env)info.Env(), (napi_value)info[index]); +} + +template <> +inline KFloat getArgument(const CallbackInfo& info, int index) { + return getFloat32(info, index); +} + +template <> +inline KDouble getArgument(const CallbackInfo& info, int index) { + return getFloat64(info, index); +} + +template <> +inline KNativePointer getArgument(const CallbackInfo& info, int index) { + return getPointer(info, index); +} + +template <> +inline KLong getArgument(const CallbackInfo& info, int index) { + return getInt64(info, index); +} + +template <> +inline KULong getArgument(const CallbackInfo& info, int index) { + return getUInt64(info, index); +} + +template <> +inline KNativePointerArray getArgument(const CallbackInfo& info, int index) { + return getPointerElements(info, index); +} + +template <> +inline uint8_t* getArgument(const CallbackInfo& info, int index) { + return getUInt8Elements(info, index); +} + +template <> +inline const uint8_t* getArgument(const CallbackInfo& info, int index) { + return getUInt8Elements(info, index); +} + +template <> +inline int8_t* getArgument(const CallbackInfo& info, int index) { + return getInt8Elements(info, index); +} + +template <> +inline int16_t* getArgument(const CallbackInfo& info, int index) { + return getInt16Elements(info, index); +} + +template <> +inline uint16_t* getArgument(const CallbackInfo& info, int index) { + return getUInt16Elements(info, index); +} + +template <> +inline int32_t* getArgument(const CallbackInfo& info, int index) { + return getInt32Elements(info, index); +} + +template <> +inline uint32_t* getArgument(const CallbackInfo& info, int index) { + return getUInt32Elements(info, index); +} + +template <> +inline float* getArgument(const CallbackInfo& info, int index) { + return getFloat32Elements(info, index); +} + +template <> +inline KStringPtr getArgument(const CallbackInfo& info, int index) { + return getString(info, index); +} + +inline napi_value makeVoid(const CallbackInfo& info) { + return makeVoid(info.Env()); +} + +template +inline napi_value makeResult(const CallbackInfo& info, Type value) = delete; + +template <> +inline napi_value makeResult(const CallbackInfo& info, KBoolean value) { + return makeBoolean(info.Env(), value); +} + +template <> +inline napi_value makeResult(const CallbackInfo& info, int32_t value) { + return makeInt32(info.Env(), value); +} + +template <> +inline napi_value makeResult(const CallbackInfo& info, uint32_t value) { + return makeUInt32(info.Env(), value); +} + +template <> +inline napi_value makeResult(const CallbackInfo& info, int64_t value) { + return makeInt64(info.Env(), value); +} + +template <> +inline napi_value makeResult(const CallbackInfo& info, uint64_t value) { + return makeUInt64(info.Env(), value); +} + +template <> +inline napi_value makeResult(const CallbackInfo& info, float value) { + return makeFloat32(info.Env(), value); +} + +template <> +inline napi_value makeResult(const CallbackInfo& info, double value) { + return makeFloat64(info.Env(), value); +} + +template <> +inline napi_value makeResult(const CallbackInfo& info, KNativePointer value) { + return makePointer(info.Env(), value); +} + +template <> +inline napi_value makeResult(const CallbackInfo& info, KVMObjectHandle value) { + return InteropTypeConverter::convertTo(info.Env(), value); +} + +template <> +inline napi_value makeResult(const CallbackInfo& info, KStringPtr value) { + return InteropTypeConverter::convertTo(info.Env(), value); +} + +template <> +inline napi_value makeResult(const CallbackInfo& info, KInteropBuffer value) { + return InteropTypeConverter::convertTo(info.Env(), value); +} + +template <> +inline napi_value makeResult(const CallbackInfo& info, KInteropReturnBuffer value) { + return InteropTypeConverter::convertTo(info.Env(), value); +} + +template <> +inline napi_value makeResult(const CallbackInfo& info, KInteropNumber value) { + return InteropTypeConverter::convertTo(info.Env(), value); +} + +typedef napi_value (*napi_type_t)(napi_env, napi_callback_info); + +class Exports { + std::unordered_map>> implementations; + +public: + static Exports* getInstance(); + + std::vector getModules(); + void addMethod(const char* module, const char* name, napi_type_t impl); + const std::vector>& getMethods(const std::string& module); +}; + +#define __QUOTE(x) #x +#define QUOTE(x) __QUOTE(x) + +#ifdef _MSC_VER +#define MAKE_NODE_EXPORT(module, name) \ + static void __init_##name() { \ + Exports::getInstance()->addMethod(QUOTE(module), "_"#name, Node_##name); \ + } \ + namespace { \ + struct __Init_##name { \ + __Init_##name() { __init_##name(); } \ + } __Init_##name##_v; \ + } +#else +#define MAKE_NODE_EXPORT(module, name) \ + __attribute__((constructor)) \ + static void __init_##name() { \ + Exports::getInstance()->addMethod(QUOTE(module), "_"#name, Node_##name); \ + } +#endif + +#ifndef KOALA_INTEROP_MODULE +#error KOALA_INTEROP_MODULE is undefined +#endif + +#define MAKE_INTEROP_NODE_EXPORT(name) MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_0(name, Ret) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + return makeResult(info, impl_##name()); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_1(name, Ret, P0) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + return makeResult(info, impl_##name(p0)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_2(name, Ret, P0, P1) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + return makeResult(info, impl_##name(p0, p1)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_3(name, Ret, P0, P1, P2) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + return makeResult(info, impl_##name(p0, p1, p2)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + return makeResult(info, impl_##name(p0, p1, p2, p3)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + return makeResult(info, impl_##name(p0, p1, p2, p3, p4)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + return makeResult(info, impl_##name(p0, p1, p2, p3, p4, p5)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + P6 p6 = getArgument(info, 6); \ + return makeResult(info, impl_##name(p0, p1, p2, p3, p4, p5, p6)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + P6 p6 = getArgument(info, 6); \ + P7 p7 = getArgument(info, 7); \ + return makeResult(info, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + P6 p6 = getArgument(info, 6); \ + P7 p7 = getArgument(info, 7); \ + P8 p8 = getArgument(info, 8); \ + return makeResult(info, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + P6 p6 = getArgument(info, 6); \ + P7 p7 = getArgument(info, 7); \ + P8 p8 = getArgument(info, 8); \ + P9 p9 = getArgument(info, 9); \ + return makeResult(info, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + P6 p6 = getArgument(info, 6); \ + P7 p7 = getArgument(info, 7); \ + P8 p8 = getArgument(info, 8); \ + P9 p9 = getArgument(info, 9); \ + P10 p10 = getArgument(info, 10); \ + return makeResult(info, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_12(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + P6 p6 = getArgument(info, 6); \ + P7 p7 = getArgument(info, 7); \ + P8 p8 = getArgument(info, 8); \ + P9 p9 = getArgument(info, 9); \ + P10 p10 = getArgument(info, 10); \ + P11 p11 = getArgument(info, 11); \ + return makeResult(info, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_13(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + P6 p6 = getArgument(info, 6); \ + P7 p7 = getArgument(info, 7); \ + P8 p8 = getArgument(info, 8); \ + P9 p9 = getArgument(info, 9); \ + P10 p10 = getArgument(info, 10); \ + P11 p11 = getArgument(info, 11); \ + P12 p12 = getArgument(info, 12); \ + return makeResult(info, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_14(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + P6 p6 = getArgument(info, 6); \ + P7 p7 = getArgument(info, 7); \ + P8 p8 = getArgument(info, 8); \ + P9 p9 = getArgument(info, 9); \ + P10 p10 = getArgument(info, 10); \ + P11 p11 = getArgument(info, 11); \ + P12 p12 = getArgument(info, 12); \ + P13 p13 = getArgument(info, 13); \ + return makeResult(info, impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_V0(name) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + impl_##name(); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_V1(name, P0) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + impl_##name(p0); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_V2(name, P0, P1) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + impl_##name(p0, p1); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_V3(name, P0, P1, P2) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + impl_##name(p0, p1, p2); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_V4(name, P0, P1, P2, P3) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + impl_##name(p0, p1, p2, p3); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + impl_##name(p0, p1, p2, p3, p4); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + impl_##name(p0, p1, p2, p3, p4, p5); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + P6 p6 = getArgument(info, 6); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + P6 p6 = getArgument(info, 6); \ + P7 p7 = getArgument(info, 7); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(impl_##name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + P6 p6 = getArgument(info, 6); \ + P7 p7 = getArgument(info, 7); \ + P8 p8 = getArgument(info, 8); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + P6 p6 = getArgument(info, 6); \ + P7 p7 = getArgument(info, 7); \ + P8 p8 = getArgument(info, 8); \ + P9 p9 = getArgument(info, 9); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(impl_##name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + P6 p6 = getArgument(info, 6); \ + P7 p7 = getArgument(info, 7); \ + P8 p8 = getArgument(info, 8); \ + P9 p9 = getArgument(info, 9); \ + P10 p10 = getArgument(info, 10); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_V12(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(impl_##name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + P6 p6 = getArgument(info, 6); \ + P7 p7 = getArgument(info, 7); \ + P8 p8 = getArgument(info, 8); \ + P9 p9 = getArgument(info, 9); \ + P10 p10 = getArgument(info, 10); \ + P11 p11 = getArgument(info, 11); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_V13(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(impl_##name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + P6 p6 = getArgument(info, 6); \ + P7 p7 = getArgument(info, 7); \ + P8 p8 = getArgument(info, 8); \ + P9 p9 = getArgument(info, 9); \ + P10 p10 = getArgument(info, 10); \ + P11 p11 = getArgument(info, 11); \ + P12 p12 = getArgument(info, 12); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_V14(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + P6 p6 = getArgument(info, 6); \ + P7 p7 = getArgument(info, 7); \ + P8 p8 = getArgument(info, 8); \ + P9 p9 = getArgument(info, 9); \ + P10 p10 = getArgument(info, 10); \ + P11 p11 = getArgument(info, 11); \ + P12 p12 = getArgument(info, 12); \ + P13 p13 = getArgument(info, 13); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_V15(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + P5 p5 = getArgument(info, 5); \ + P6 p6 = getArgument(info, 6); \ + P7 p7 = getArgument(info, 7); \ + P8 p8 = getArgument(info, 8); \ + P9 p9 = getArgument(info, 9); \ + P10 p10 = getArgument(info, 10); \ + P11 p11 = getArgument(info, 11); \ + P12 p12 = getArgument(info, 12); \ + P13 p13 = getArgument(info, 13); \ + P14 p14 = getArgument(info, 14); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_CTX_0(name, Ret) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(impl_##name) \ + CallbackInfo info(env, cbinfo); \ + KVMContext ctx = reinterpret_cast((napi_env)info.Env()); \ + return makeResult(info, impl_##name(ctx)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_CTX_1(name, Ret, P0) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(impl_##name) \ + CallbackInfo info(env, cbinfo); \ + KVMContext ctx = reinterpret_cast((napi_env)info.Env()); \ + P0 p0 = getArgument(info, 0); \ + return makeResult(info, impl_##name(ctx, p0)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_CTX_2(name, Ret, P0, P1) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + KVMContext ctx = reinterpret_cast((napi_env)info.Env()); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + return makeResult(info, impl_##name(ctx, p0, p1)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_CTX_3(name, Ret, P0, P1, P2) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + KVMContext ctx = reinterpret_cast((napi_env)info.Env()); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + return makeResult(info, impl_##name(ctx, p0, p1, p2)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_CTX_4(name, Ret, P0, P1, P2, P3) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + KVMContext ctx = reinterpret_cast((napi_env)info.Env()); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + return makeResult(info, impl_##name(ctx, p0, p1, p2, p3)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_CTX_5(name, Ret, P0, P1, P2, P3, P4) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + KVMContext ctx = reinterpret_cast((napi_env)info.Env()); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + return makeResult(info, impl_##name(ctx, p0, p1, p2, p3, p4)); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_CTX_V0(name) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + KVMContext ctx = reinterpret_cast((napi_env)info.Env()); \ + impl_##name(ctx); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + + +#define KOALA_INTEROP_CTX_V1(name, P0) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + KVMContext ctx = reinterpret_cast((napi_env)info.Env()); \ + P0 p0 = getArgument(info, 0); \ + impl_##name(ctx, p0); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_CTX_V2(name, P0, P1) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + KVMContext ctx = reinterpret_cast((napi_env)info.Env()); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + impl_##name(ctx, p0, p1); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_CTX_V3(name, P0, P1, P2) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + KVMContext ctx = reinterpret_cast((napi_env)info.Env()); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + impl_##name(ctx, p0, p1, p2); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_CTX_V4(name, P0, P1, P2, P3) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + KVMContext ctx = reinterpret_cast((napi_env)info.Env()); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + impl_##name(ctx, p0, p1, p2, p3); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define KOALA_INTEROP_CTX_V5(name, P0, P1, P2, P3, P4) \ + napi_value Node_##name(napi_env env, napi_callback_info cbinfo) { \ + KOALA_MAYBE_LOG(name) \ + CallbackInfo info(env, cbinfo); \ + KVMContext ctx = reinterpret_cast((napi_env)info.Env()); \ + P0 p0 = getArgument(info, 0); \ + P1 p1 = getArgument(info, 1); \ + P2 p2 = getArgument(info, 2); \ + P3 p3 = getArgument(info, 3); \ + P4 p4 = getArgument(info, 4); \ + impl_##name(ctx, p0, p1, p2, p3, p4); \ + return makeVoid(info); \ + } \ + MAKE_NODE_EXPORT(KOALA_INTEROP_MODULE, name) + +#define NODEJS_GET_AND_THROW_LAST_ERROR(env) \ + do { \ + const napi_extended_error_info *error_info; \ + napi_get_last_error_info((env), &error_info); \ + bool is_pending; \ + napi_is_exception_pending((env), &is_pending); \ + /* If an exception is already pending, don't rethrow it */ \ + if (!is_pending) { \ + const char* error_message = error_info->error_message != NULL ? \ + error_info->error_message : \ + "empty error message"; \ + napi_throw_error((env), NULL, error_message); \ + } \ + } while (0) + + #define KOALA_INTEROP_DIRECT_0(name, Ret) \ + KOALA_INTEROP_0(name, Ret) +#define KOALA_INTEROP_DIRECT_1(name, Ret, P0) \ + KOALA_INTEROP_1(name, Ret, P0) +#define KOALA_INTEROP_DIRECT_2(name, Ret, P0, P1) \ + KOALA_INTEROP_2(name, Ret, P0, P1) +#define KOALA_INTEROP_DIRECT_3(name, Ret, P0, P1, P2) \ + KOALA_INTEROP_3(name, Ret, P0, P1, P2) +#define KOALA_INTEROP_DIRECT_4(name, Ret, P0, P1, P2, P3) \ + KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) +#define KOALA_INTEROP_DIRECT_5(name, Ret, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) +#define KOALA_INTEROP_DIRECT_6(name, Ret, P0, P1, P2, P3, P4, P5) \ + KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) +#define KOALA_INTEROP_DIRECT_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) +#define KOALA_INTEROP_DIRECT_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) +#define KOALA_INTEROP_DIRECT_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) +#define KOALA_INTEROP_DIRECT_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) +#define KOALA_INTEROP_DIRECT_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) +#define KOALA_INTEROP_DIRECT_V0(name) \ + KOALA_INTEROP_V0(name) +#define KOALA_INTEROP_DIRECT_V1(name, P0) \ + KOALA_INTEROP_V1(name, P0) +#define KOALA_INTEROP_DIRECT_V2(name, P0, P1) \ + KOALA_INTEROP_V2(name, P0, P1) +#define KOALA_INTEROP_DIRECT_V3(name, P0, P1, P2) \ + KOALA_INTEROP_V3(name, P0, P1, P2) +#define KOALA_INTEROP_DIRECT_V4(name, P0, P1, P2, P3) \ + KOALA_INTEROP_V4(name, P0, P1, P2, P3) +#define KOALA_INTEROP_DIRECT_V5(name, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) +#define KOALA_INTEROP_DIRECT_V6(name, P0, P1, P2, P3, P4, P5) \ + KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) +#define KOALA_INTEROP_DIRECT_V7(name, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) +#define KOALA_INTEROP_DIRECT_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) +#define KOALA_INTEROP_DIRECT_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) +#define KOALA_INTEROP_DIRECT_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) +#define KOALA_INTEROP_DIRECT_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) + +napi_value getKoalaNapiCallbackDispatcher(napi_env env); +// Improve: can/shall we cache bridge reference? + +#define KOALA_INTEROP_CALL_VOID(venv, id, length, args) \ +{ \ + napi_env env = reinterpret_cast(venv); \ + napi_value bridge = getKoalaNapiCallbackDispatcher(env), \ + global = nullptr, return_val = nullptr; \ + napi_handle_scope scope = nullptr; \ + napi_open_handle_scope(env, &scope); \ + napi_status status = napi_get_global(env, &global); \ + napi_value node_args[3]; \ + napi_create_int32(env, id, &node_args[0]); \ + napi_value buffer = nullptr; \ + napi_create_external_arraybuffer(env, \ + args, length, \ + [](napi_env, void* data, void* hint) {}, nullptr, &buffer); \ + napi_create_typedarray(env, napi_uint8_array, length, buffer, 0, &node_args[1]); \ + napi_create_int32(env, length, &node_args[2]); \ + status = napi_call_function(env, global, bridge, 3, node_args, &return_val); \ + if (status != napi_ok) NODEJS_GET_AND_THROW_LAST_ERROR((env)); \ + napi_close_handle_scope(env, scope); \ +} + +#define KOALA_INTEROP_CALL_INT(venv, id, length, args) \ +{ \ + napi_env env = reinterpret_cast(venv); \ + napi_value bridge = getKoalaNapiCallbackDispatcher(env), \ + global = nullptr, return_val = nullptr; \ + napi_handle_scope scope = nullptr; \ + napi_open_handle_scope(env, &scope); \ + napi_status status = napi_get_global(env, &global); \ + napi_value node_args[3]; \ + napi_create_int32(env, id, &node_args[0]); \ + napi_value buffer = nullptr; \ + napi_create_external_arraybuffer(env, \ + args, length, \ + [](napi_env, void* data, void* hint) {}, nullptr, &buffer); \ + napi_create_typedarray(env, napi_uint8_array, length, buffer, 0, &node_args[1]); \ + napi_create_int32(env, length, &node_args[2]); \ + status = napi_call_function(env, global, bridge, 3, node_args, &return_val); \ + if (status != napi_ok) NODEJS_GET_AND_THROW_LAST_ERROR((env)); \ + int result; \ + status = napi_get_value_int32(env, return_val, &result); \ + napi_close_handle_scope(env, scope); \ + return result; \ +} + +#define KOALA_INTEROP_CALL_VOID_INTS32(venv, id, argc, args) KOALA_INTEROP_CALL_VOID(venv, id, (argc) * sizeof(int32_t), args) +#define KOALA_INTEROP_CALL_INT_INTS32(venv, id, argc, args) KOALA_INTEROP_CALL_INT(venv, id, (argc) * sizeof(int32_t), args) + +#endif // KOALA_NAPI + +#endif // _CONVERTORS_NAPI_H_ \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/napi/win-dynamic-node.cc b/ets1.2/interop/src/cpp/napi/win-dynamic-node.cc new file mode 100644 index 0000000000000000000000000000000000000000..6709d3c3465e9c5d6e40bcc502586a17ea80703b --- /dev/null +++ b/ets1.2/interop/src/cpp/napi/win-dynamic-node.cc @@ -0,0 +1,688 @@ +/* + * Copyright (c) 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. + */ + +#ifdef __cplusplus + #include + #include +#else + #include + #include +#endif + +#include +#include "node_api.h" + +#define NAPI_CDECL __cdecl + +#define NAPI_FUNCTIONS(op) \ + op(napi_module_register) \ + op(napi_create_function) \ + op(napi_set_named_property) \ + op(napi_create_string_utf8) \ + op(napi_add_env_cleanup_hook) \ + op(napi_get_last_error_info) \ + op(napi_get_value_bigint_int64) \ + op(napi_get_value_bigint_uint64) \ + op(napi_create_object) \ + op(napi_get_arraybuffer_info) \ + op(napi_create_bigint_uint64) \ + op(napi_is_typedarray) \ + op(napi_add_finalizer) \ + op(napi_get_typedarray_info) \ + op(napi_set_property) \ + op(napi_get_value_bool) \ + op(napi_coerce_to_string) \ + op(napi_get_value_uint32) \ + op(napi_get_value_int32) \ + op(napi_throw) \ + op(napi_get_cb_info) \ + op(napi_create_error) \ + op(napi_get_value_string_utf8) \ + op(napi_define_properties) \ + op(napi_delete_reference) \ + op(napi_get_reference_value) \ + op(napi_open_handle_scope) \ + op(napi_close_handle_scope) \ + op(napi_open_escapable_handle_scope) \ + op(napi_close_escapable_handle_scope) \ + op(napi_is_exception_pending) \ + op(napi_create_type_error) \ + op(napi_escape_handle) \ + op(napi_get_and_clear_last_exception) \ + op(napi_fatal_error) \ + op(napi_create_double) \ + op(napi_typeof) \ + op(napi_get_property) \ + op(napi_get_named_property) \ + op(napi_create_reference) \ + op(napi_get_global) \ + op(napi_has_property) \ + op(napi_get_undefined) \ + op(napi_get_value_double) \ + op(napi_close_callback_scope) \ + op(napi_async_destroy) \ + op(napi_call_function) \ + op(napi_get_value_external) \ + op(napi_throw_error) \ + op(napi_create_int32) \ + op(napi_create_external_arraybuffer) \ + op(napi_create_typedarray) \ + op(napi_create_string_latin1) \ + op(napi_create_async_work) \ + op(napi_delete_async_work) \ + op(napi_queue_async_work) \ + op(napi_resolve_deferred) \ + op(napi_reject_deferred) \ + op(napi_create_promise) \ + op(napi_create_threadsafe_function) \ + op(napi_acquire_threadsafe_function) \ + op(napi_release_threadsafe_function) \ + op(napi_call_threadsafe_function) \ + op(napi_is_dataview) \ + op(napi_is_arraybuffer) \ + op(napi_get_dataview_info) \ + op(napi_get_value_int64) \ + op(napi_get_boolean) \ + op(napi_create_uint32) \ + op(napi_create_bigint_int64) \ + op(napi_cancel_async_work) \ + +#define DECL_NAPI_IMPL(fn_name, ...) decltype(&fn_name) p_##fn_name; + +NAPI_FUNCTIONS(DECL_NAPI_IMPL) + +bool LoadNapiFunctions() { + static bool isLoaded = false; + if (isLoaded) return true; + HMODULE nodeModule = GetModuleHandle(NULL); + FARPROC fn_addr = GetProcAddress(nodeModule, "napi_module_register"); + + if (fn_addr == NULL) { + nodeModule = GetModuleHandleA("node.dll"); + if (nodeModule == NULL) return false; + fn_addr = GetProcAddress(nodeModule, "napi_module_register"); + if (fn_addr == NULL) { + return false; + } + } + bool apiLoadFailed = false; + +#define GET_NAPI_IMPL(fn_name) \ + fn_addr = GetProcAddress(nodeModule, #fn_name); \ + if (fn_addr == NULL) apiLoadFailed = true; \ + p_##fn_name = (decltype(p_##fn_name))fn_addr; + + // Assign the addresses of the needed functions to the "p*" named pointers. + NAPI_FUNCTIONS(GET_NAPI_IMPL); + + // If any required APIs failed to load, return false + if (apiLoadFailed) return false; + + isLoaded = true; + + return true; +} + +NAPI_EXTERN void NAPI_CDECL +napi_module_register(napi_module* mod) { + LoadNapiFunctions(); + p_napi_module_register(mod); +} + +NAPI_EXTERN napi_status NAPI_CDECL +napi_get_last_error_info(napi_env env, const napi_extended_error_info** result) { + LoadNapiFunctions(); + return p_napi_get_last_error_info(env, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_bigint_int64( + napi_env env, napi_value value, int64_t* result, bool* lossless) { + LoadNapiFunctions(); + return p_napi_get_value_bigint_int64(env, value, result, lossless); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_bigint_uint64( + napi_env env, napi_value value, uint64_t* result, bool* lossless) { + LoadNapiFunctions(); + return p_napi_get_value_bigint_uint64(env, value, result, lossless); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_create_object(napi_env env, napi_value* result) { + LoadNapiFunctions(); + return p_napi_create_object(env, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_get_arraybuffer_info(napi_env env, napi_value arraybuffer, void** data, size_t* byte_length) { + LoadNapiFunctions(); + return p_napi_get_arraybuffer_info(env, arraybuffer, data, byte_length); +} + +NAPI_EXTERN napi_status NAPI_CDECL +napi_create_bigint_uint64(napi_env env, uint64_t value, napi_value* result) { + LoadNapiFunctions(); + return p_napi_create_bigint_uint64(env, value, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_is_typedarray(napi_env env, napi_value value, bool* result) { + LoadNapiFunctions(); + return p_napi_is_typedarray(env, value, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL +napi_add_finalizer(napi_env env, + napi_value js_object, + void* finalize_data, + napi_finalize finalize_cb, + void* finalize_hint, + napi_ref* result) { + LoadNapiFunctions(); + return p_napi_add_finalizer(env, js_object, finalize_data, finalize_cb, finalize_hint, result); +} + + +NAPI_EXTERN napi_status NAPI_CDECL +napi_get_typedarray_info(napi_env env, + napi_value typedarray, + napi_typedarray_type* type, + size_t* length, + void** data, + napi_value* arraybuffer, + size_t* byte_offset) { + LoadNapiFunctions(); + return p_napi_get_typedarray_info(env, typedarray, type, length, data, arraybuffer, byte_offset); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_set_property(napi_env env, + napi_value object, + napi_value key, + napi_value value) { + LoadNapiFunctions(); + return p_napi_set_property(env, object, key, value); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_bool(napi_env env, + napi_value value, + bool* result) { + LoadNapiFunctions(); + return p_napi_get_value_bool(env, value, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_coerce_to_string(napi_env env, + napi_value value, + napi_value* result) { + LoadNapiFunctions(); + return p_napi_coerce_to_string(env, value, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_int32(napi_env env, + napi_value value, + int32_t* result) { + LoadNapiFunctions(); + return p_napi_get_value_int32(env, value, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_get_cb_info( + napi_env env, + napi_callback_info cbinfo, + size_t* argc, + napi_value* argv, + napi_value* this_arg, + void** data) { + LoadNapiFunctions(); + return p_napi_get_cb_info(env, cbinfo, argc, argv, this_arg, data); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_utf8(napi_env env, + const char* str, + size_t length, + napi_value* result) { + LoadNapiFunctions(); + return p_napi_create_string_utf8(env, str, length, result); +} + + +NAPI_EXTERN napi_status NAPI_CDECL napi_throw(napi_env env, napi_value error) { + LoadNapiFunctions(); + return p_napi_throw(env, error); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_create_error(napi_env env, + napi_value code, + napi_value msg, + napi_value* result) { + LoadNapiFunctions(); + return p_napi_create_error(env, code, msg, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_string_utf8( + napi_env env, napi_value value, char* buf, size_t bufsize, size_t* result) { + LoadNapiFunctions(); + return p_napi_get_value_string_utf8(env, value, buf, bufsize, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL +napi_define_properties(napi_env env, + napi_value object, + size_t property_count, + const napi_property_descriptor* properties) { + LoadNapiFunctions(); + return p_napi_define_properties(env, object, property_count, properties); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_delete_reference(napi_env env, + napi_ref ref) { + LoadNapiFunctions(); + return p_napi_delete_reference(env, ref); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_get_reference_value(napi_env env, + napi_ref ref, + napi_value* result) { + LoadNapiFunctions(); + return p_napi_get_reference_value(env, ref, result); +} +NAPI_EXTERN napi_status NAPI_CDECL +napi_open_handle_scope(napi_env env, napi_handle_scope* result) { + LoadNapiFunctions(); + return p_napi_open_handle_scope(env, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL +napi_close_handle_scope(napi_env env, napi_handle_scope scope) { + LoadNapiFunctions(); + return p_napi_close_handle_scope(env, scope); +} +NAPI_EXTERN napi_status NAPI_CDECL napi_open_escapable_handle_scope( + napi_env env, napi_escapable_handle_scope* result) { + return p_napi_open_escapable_handle_scope(env, result); +} +NAPI_EXTERN napi_status NAPI_CDECL napi_close_escapable_handle_scope( + napi_env env, napi_escapable_handle_scope scope) { + LoadNapiFunctions(); + return p_napi_close_escapable_handle_scope(env, scope); +} +NAPI_EXTERN napi_status NAPI_CDECL napi_is_exception_pending(napi_env env, + bool* result) { + LoadNapiFunctions(); + return p_napi_is_exception_pending(env, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_get_property(napi_env env, + napi_value object, + napi_value key, + napi_value* result) { + LoadNapiFunctions(); + return p_napi_get_property(env, object, key, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_uint32(napi_env env, + napi_value value, + uint32_t* result) { + LoadNapiFunctions(); + return p_napi_get_value_uint32(env, value, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_typeof(napi_env env, + napi_value value, + napi_valuetype* result) { + LoadNapiFunctions(); + return p_napi_typeof(env, value, result); +} +NAPI_EXTERN napi_status NAPI_CDECL +napi_get_and_clear_last_exception(napi_env env, napi_value* result) { + LoadNapiFunctions(); + return p_napi_get_and_clear_last_exception(env, result); +} +NAPI_EXTERN NAPI_NO_RETURN void NAPI_CDECL +napi_fatal_error(const char* location, + size_t location_len, + const char* message, + size_t message_len) { + LoadNapiFunctions(); + p_napi_fatal_error(location, location_len, message, message_len); + // Not reachable, but not represented in type signature. + exit(0); +} +NAPI_EXTERN napi_status NAPI_CDECL +napi_get_value_external(napi_env env, napi_value value, void** result) { + LoadNapiFunctions(); + return p_napi_get_value_external(env, value, result); +} +NAPI_EXTERN napi_status NAPI_CDECL napi_create_double(napi_env env, + double value, + napi_value* result) { + LoadNapiFunctions(); + return p_napi_create_double(env, value, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_create_type_error(napi_env env, + napi_value code, + napi_value msg, + napi_value* result) { + LoadNapiFunctions(); + return p_napi_create_type_error(env, code, msg, result); +} +NAPI_EXTERN napi_status NAPI_CDECL napi_get_named_property(napi_env env, + napi_value object, + const char* utf8name, + napi_value* result) { + LoadNapiFunctions(); + return p_napi_get_named_property(env, object, utf8name, result); +} +NAPI_EXTERN napi_status NAPI_CDECL +napi_create_reference(napi_env env, + napi_value value, + uint32_t initial_refcount, + napi_ref* result) { + LoadNapiFunctions(); + return p_napi_create_reference(env, value, initial_refcount, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL +napi_escape_handle(napi_env env, + napi_escapable_handle_scope scope, + napi_value escapee, + napi_value* result); +NAPI_EXTERN napi_status NAPI_CDECL napi_get_global(napi_env env, + napi_value* result) { + + LoadNapiFunctions(); + return p_napi_get_global(env, result); +} +NAPI_EXTERN napi_status NAPI_CDECL napi_has_property(napi_env env, + napi_value object, + napi_value key, + bool* result) { + LoadNapiFunctions(); + return p_napi_has_property(env, object, key, result); +} +NAPI_EXTERN napi_status NAPI_CDECL napi_create_function(napi_env env, + const char* utf8name, + size_t length, + napi_callback cb, + void* data, + napi_value* result) { + LoadNapiFunctions(); + return p_napi_create_function(env, utf8name, length, cb, data, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL +napi_escape_handle(napi_env env, + napi_escapable_handle_scope scope, + napi_value escapee, + napi_value* result) { + LoadNapiFunctions(); + return p_napi_escape_handle(env, scope, escapee, result); +} +NAPI_EXTERN napi_status NAPI_CDECL napi_get_undefined(napi_env env, + napi_value* result) { + LoadNapiFunctions(); + return p_napi_get_undefined(env, result); +} +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_double(napi_env env, + napi_value value, + double* result) { + LoadNapiFunctions(); + return p_napi_get_value_double(env, value, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL +napi_close_callback_scope(napi_env env, napi_callback_scope scope) { + LoadNapiFunctions(); + return p_napi_close_callback_scope(env, scope); +} + +NAPI_EXTERN napi_status NAPI_CDECL +napi_async_destroy(napi_env env, napi_async_context async_context) { + LoadNapiFunctions(); + return p_napi_async_destroy(env, async_context); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_call_function(napi_env env, + napi_value recv, + napi_value func, + size_t argc, + const napi_value* argv, + napi_value* result) { + LoadNapiFunctions(); + return p_napi_call_function(env, recv, func, argc, argv, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_throw_error(napi_env env, + const char* code, + const char* msg) + { + LoadNapiFunctions(); + return p_napi_throw_error(env, code, msg); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_create_int32(napi_env env, + int32_t value, + napi_value* result) + { + LoadNapiFunctions(); + return p_napi_create_int32(env, value, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_create_external_arraybuffer( + napi_env env, + void* external_data, + size_t byte_length, + napi_finalize finalize_cb, + void* finalize_hint, + napi_value* result) +{ + LoadNapiFunctions(); + return p_napi_create_external_arraybuffer(env, external_data, byte_length, finalize_cb, finalize_hint, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_create_typedarray( + napi_env env, + napi_typedarray_type type, + size_t length, + napi_value array_buffer, + size_t byte_offset, + napi_value* result +) +{ + LoadNapiFunctions(); + return p_napi_create_typedarray(env, type, length, array_buffer, byte_offset, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_create_string_latin1( + napi_env env, + const char* str, + size_t length, + napi_value* result +) +{ + LoadNapiFunctions(); + return p_napi_create_string_latin1(env, str, length, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_create_async_work( + napi_env env, + napi_value async_resource, + napi_value async_resource_name, + napi_async_execute_callback execute, + napi_async_complete_callback complete, + void* data, + napi_async_work* result +) +{ + LoadNapiFunctions(); + return p_napi_create_async_work(env, async_resource, async_resource_name, execute, complete, data, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_delete_async_work( + napi_env env, + napi_async_work work +) +{ + LoadNapiFunctions(); + return p_napi_delete_async_work(env, work); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_queue_async_work( + napi_env env, + napi_async_work work +) +{ + LoadNapiFunctions(); + return p_napi_queue_async_work(env, work); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_create_promise( + napi_env env, + napi_deferred* deferred, + napi_value* promise) +{ + LoadNapiFunctions(); + return p_napi_create_promise(env, deferred, promise); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_resolve_deferred( + napi_env env, + napi_deferred deferred, + napi_value resolution) +{ + LoadNapiFunctions(); + return p_napi_resolve_deferred(env, deferred, resolution); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_reject_deferred( + napi_env env, + napi_deferred deferred, + napi_value rejection) +{ + LoadNapiFunctions(); + return p_napi_reject_deferred(env, deferred, rejection); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_create_threadsafe_function( + napi_env env, + napi_value func, + napi_value async_resource, + napi_value async_resource_name, + size_t max_queue_size, + size_t initial_thread_count, + void* thread_finalize_data, + napi_finalize thread_finalize_cb, + void* context, + napi_threadsafe_function_call_js call_js_cb, + napi_threadsafe_function* result) +{ + LoadNapiFunctions(); + return p_napi_create_threadsafe_function(env, func, async_resource, async_resource_name, max_queue_size, initial_thread_count, thread_finalize_data, thread_finalize_cb, context, call_js_cb, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL +napi_acquire_threadsafe_function(napi_threadsafe_function func) +{ + LoadNapiFunctions(); + return p_napi_acquire_threadsafe_function(func); +} + +NAPI_EXTERN napi_status NAPI_CDECL +napi_release_threadsafe_function(napi_threadsafe_function func, napi_threadsafe_function_release_mode mode) +{ + LoadNapiFunctions(); + return p_napi_release_threadsafe_function(func, mode); +} + +NAPI_EXTERN napi_status NAPI_CDECL +napi_call_threadsafe_function( + napi_threadsafe_function func, + void* data, + napi_threadsafe_function_call_mode is_blocking) +{ + LoadNapiFunctions(); + return p_napi_call_threadsafe_function(func, data, is_blocking); +} + +NAPI_EXTERN napi_status NAPI_CDECL +napi_is_dataview(napi_env env, + napi_value value, + bool* result) { + LoadNapiFunctions(); + return p_napi_is_dataview(env, value, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL +napi_is_arraybuffer(napi_env env, + napi_value value, + bool* result) { + LoadNapiFunctions(); + return p_napi_is_arraybuffer(env, value, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL +napi_get_dataview_info(napi_env env, + napi_value dataview, + size_t* bytelength, + void** data, + napi_value* arraybuffer, + size_t* byte_offset) { + LoadNapiFunctions(); + return p_napi_get_dataview_info(env, dataview, bytelength, data, arraybuffer, byte_offset); +} + +NAPI_EXTERN napi_status NAPI_CDECL +napi_set_named_property(napi_env env, + napi_value object, + const char* utf8name, + napi_value value) { + LoadNapiFunctions(); + return p_napi_set_named_property(env, object, utf8name, value); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_get_value_int64(napi_env env, + napi_value value, + int64_t* result) +{ + LoadNapiFunctions(); + return p_napi_get_value_int64(env, value, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_get_boolean(napi_env env, + bool value, + napi_value* result) +{ +LoadNapiFunctions(); +return p_napi_get_boolean(env, value, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_create_uint32(napi_env env, + uint32_t value, + napi_value* result) +{ +LoadNapiFunctions(); +return p_napi_create_uint32(env, value, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_create_bigint_int64(napi_env env, + int64_t value, + napi_value* result) +{ + LoadNapiFunctions(); + return p_napi_create_bigint_int64(env, value, result); +} + +NAPI_EXTERN napi_status NAPI_CDECL napi_cancel_async_work(napi_env env, + napi_async_work work) +{ + LoadNapiFunctions(); + return p_napi_cancel_async_work(env, work); +} \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/ohos/hilog/log.h b/ets1.2/interop/src/cpp/ohos/hilog/log.h new file mode 100644 index 0000000000000000000000000000000000000000..7452137c280d212fc271cca2f31466f0dc11bd6f --- /dev/null +++ b/ets1.2/interop/src/cpp/ohos/hilog/log.h @@ -0,0 +1,286 @@ +/* + * Copyright (c) 2021-2022 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. + */ + +#ifndef HIVIEWDFX_HILOG_H +#define HIVIEWDFX_HILOG_H +/** + * @addtogroup HiLog + * @{ + * + * @brief Provides logging functions. + * + * For example, you can use these functions to output logs of the specified log type, service domain, log tag, + * and log level. + * + * @syscap SystemCapability.HiviewDFX.HiLog + * + * @since 8 + */ + +/** + * @file log.h + * + * @brief Defines the logging functions of the HiLog module. + * + * Before outputting logs, you must define the service domain, and log tag, use the function with + * the specified log type and level, and specify the privacy identifier.\n + *
  • Service domain: used to identify the subsystem and module of a service. Its value is a hexadecimal + * integer ranging from 0x0 to 0xFFFF. \n + *
  • Log tag: a string used to identify the class, file, or service.
    • \n + *
  • Log level: DEBUG, INFO, WARN, ERROR, and FATAL
    • \n + *
  • Parameter format: a printf format string that starts with a % character, including format specifiers + * and variable parameters.
    • \n + *
  • Privacy identifier: {public} or {private} added between the % character and the format specifier in + * each parameter. Note that each parameter has a privacy identifier. If no privacy identifier is added, + * the parameter is considered to be private.
\n + * + * Sample code:\n + * Defining the service domain and log tag:\n + * #include \n + * #define LOG_DOMAIN 0x0201\n + * #define LOG_TAG "MY_TAG"\n + * Outputting logs:\n + * HILOG_WARN({@link LOG_APP}, "Failed to visit %{private}s, reason:%{public}d.", url, errno);\n + * Output result:\n + * 05-06 15:01:06.870 1051 1051 W 0201/MY_TAG: Failed to visit , reason:503.\n + * + * @since 8 + */ +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @brief Defines the service domain for a log file. + * + * The service domain is used to identify the subsystem and module of a service. Its value is a hexadecimal integer + * ranging from 0x0 to 0xFFFF. If the value is beyond the range, its significant bits are automatically truncated. \n + * + * @since 8 + */ +#ifndef LOG_DOMAIN +#define LOG_DOMAIN 0 +#endif + +/** + * @brief Defines a string constant used to identify the class, file, or service. + * + * @since 8 + */ +#ifndef LOG_TAG +#define LOG_TAG NULL +#endif + +/** + * @brief Enumerates log types. + * + * Currently, LOG_APP is available. \n + * + * @since 8 + */ +typedef enum { + /** Third-party application logs */ + LOG_APP = 0, +} LogType; + +/** + * @brief Enumerates log levels. + * + * You are advised to select log levels based on their respective usage scenarios:\n + *
  • DEBUG: used for debugging and disabled from commercial releases
    • \n + *
  • INFO: used for logging important system running status and steps in key processes
    • \n + *
  • WARN: used for logging unexpected exceptions that have little impact on user experience and can + * automatically recover. Logs at this level are generally output when such exceptions are detected and + * captured.
    • \n + *
  • ERROR: used for logging malfunction that affects user experience and cannot automatically + * recover
    • \n + *
  • FATAL: used for logging major exceptions that have severely affected user experience and should + * not occur.
\n + * + * @since 8 + */ +typedef enum { + /** Debug level to be used by {@link OH_LOG_DEBUG} */ + LOG_DEBUG = 3, + /** Informational level to be used by {@link OH_LOG_INFO} */ + LOG_INFO = 4, + /** Warning level to be used by {@link OH_LOG_WARN} */ + LOG_WARN = 5, + /** Error level to be used by {@link OH_LOG_ERROR} */ + LOG_ERROR = 6, + /** Fatal level to be used by {@link OH_LOG_FATAL} */ + LOG_FATAL = 7, +} LogLevel; + +/** + * @brief Outputs logs. + * + * You can use this function to output logs based on the specified log type, log level, service domain, log tag, + * and variable parameters determined by the format specifier and privacy identifier in the printf format. + * + * @param type Indicates the log type. The type for third-party applications is defined by {@link LOG_APP}. + * @param level Indicates the log level, which can be LOG_DEBUG, LOG_INFO, LOG_WARN, + * LOG_ERROR, and LOG_FATAL. + * @param domain Indicates the service domain of logs. Its value is a hexadecimal integer ranging from 0x0 to 0xFFFF. + * @param tag Indicates the log tag, which is a string used to identify the class, file, or service behavior. + * @param fmt Indicates the format string, which is an enhancement of a printf format string and supports the privacy + * identifier. Specifically, {public} or {private} is added between the % character and the format specifier + * in each parameter. \n + * @param ... Indicates a list of parameters. The number and type of parameters must map onto the format specifiers + * in the format string. + * @return Returns 0 or a larger value if the operation is successful; returns a value smaller + * than 0 otherwise. + * @since 8 + */ +int OH_LOG_Print(LogType type, LogLevel level, unsigned int domain, const char *tag, const char *fmt, ...) + __attribute__((__format__(os_log, 5, 6))); + +/** + * @brief Checks whether logs of the specified service domain, log tag, and log level can be output. + * + * @param domain Indicates the service domain of logs. + * @param tag Indicates the log tag. + * @param level Indicates the log level. + * @return Returns true if the specified logs can be output; returns false otherwise. + * @since 8 + */ +bool OH_LOG_IsLoggable(unsigned int domain, const char *tag, LogLevel level); + +/** + * @brief Outputs debug logs. This is a function-like macro. + * + * Before calling this function, define the log service domain and log tag. Generally, you need to define them at + * the beginning of the source file. \n + * + * @param type Indicates the log type. The type for third-party applications is defined by {@link LOG_APP}. + * @param fmt Indicates the format string, which is an enhancement of a printf format string and supports the + * privacy identifier. Specifically, {public} or {private} is added between the % character and the format specifier + * in each parameter. \n + * @param ... Indicates a list of parameters. The number and type of parameters must map onto the format specifiers + * in the format string. + * @see OH_LOG_Print + * @since 8 + */ +#define OH_LOG_DEBUG(type, ...) ((void)OH_LOG_Print((type), LOG_DEBUG, LOG_DOMAIN, LOG_TAG, __VA_ARGS__)) + +/** + * @brief Outputs informational logs. This is a function-like macro. + * + * Before calling this function, define the log service domain and log tag. Generally, you need to define them + * at the beginning of the source file. \n + * + * @param type Indicates the log type. The type for third-party applications is defined by {@link LOG_APP}. + * @param fmt Indicates the format string, which is an enhancement of a printf format string and supports the privacy + * identifier. Specifically, {public} or {private} is added between the % character and the format specifier in + * each parameter. \n + * @param ... Indicates a list of parameters. The number and type of parameters must map onto the format specifiers + * in the format string. + * @see OH_LOG_Print + * @since 8 + */ +#define OH_LOG_INFO(type, ...) ((void)OH_LOG_Print((type), LOG_INFO, LOG_DOMAIN, LOG_TAG, __VA_ARGS__)) + +/** + * @brief Outputs warning logs. This is a function-like macro. + * + * Before calling this function, define the log service domain and log tag. Generally, you need to define them + * at the beginning of the source file. \n + * + * @param type Indicates the log type. The type for third-party applications is defined by {@link LOG_APP}. + * @param fmt Indicates the format string, which is an enhancement of a printf format string and supports the + * privacy identifier. Specifically, {public} or {private} is added between the % character and the format specifier + * in each parameter. \n + * @param ... Indicates a list of parameters. The number and type of parameters must map onto the format specifiers + * in the format string. + * @see OH_LOG_Print + * @since 8 + */ +#define OH_LOG_WARN(type, ...) ((void)OH_LOG_Print((type), LOG_WARN, LOG_DOMAIN, LOG_TAG, __VA_ARGS__)) + +/** + * @brief Outputs error logs. This is a function-like macro. + * + * Before calling this function, define the log service domain and log tag. Generally, you need to define + * them at the beginning of the source file. \n + * + * @param type Indicates the log type. The type for third-party applications is defined by {@link LOG_APP}. + * @param fmt Indicates the format string, which is an enhancement of a printf format string and supports the privacy + * identifier. Specifically, {public} or {private} is added between the % character and the format specifier in each + * parameter. \n + * @param ... Indicates a list of parameters. The number and type of parameters must map onto the format specifiers + * in the format string. + * @see OH_LOG_Print + * @since 8 + */ +#define OH_LOG_ERROR(type, ...) ((void)OH_LOG_Print((type), LOG_ERROR, LOG_DOMAIN, LOG_TAG, __VA_ARGS__)) + +/** + * @brief Outputs fatal logs. This is a function-like macro. + * + * Before calling this function, define the log service domain and log tag. Generally, you need to define them at + * the beginning of the source file. \n + * + * @param type Indicates the log type. The type for third-party applications is defined by {@link LOG_APP}. + * @param fmt Indicates the format string, which is an enhancement of a printf format string and supports the privacy + * identifier. Specifically, {public} or {private} is added between the % character and the format specifier in + * each parameter. \n + * @param ... Indicates a list of parameters. The number and type of parameters must map onto the format specifiers + * in the format string. + * @see OH_LOG_Print + * @since 8 + */ +#define OH_LOG_FATAL(type, ...) ((void)OH_LOG_Print((type), LOG_FATAL, LOG_DOMAIN, LOG_TAG, __VA_ARGS__)) + +/** + * @brief Defines the function pointer type for the user-defined log processing function. + * + * @param type Indicates the log type. The type for third-party applications is defined by {@link LOG_APP}. + * @param level Indicates the log level, which can be LOG_DEBUG, LOG_INFO, LOG_WARN, + * LOG_ERROR, and LOG_FATAL. + * @param domain Indicates the service domain of logs. Its value is a hexadecimal integer ranging from 0x0 to 0xFFFF. + * @param tag Indicates the log tag, which is a string used to identify the class, file, or service behavior. + * @param msg Indicates the log message itself, which is a formatted log string. + * @since 11 + */ +typedef void (*LogCallback)(const LogType type, const LogLevel level, const unsigned int domain, const char *tag, + const char *msg); + +/** + * @brief Set the user-defined log processing function. + * + * After calling this function, the callback function implemented by the user can receive all hilogs of the + * current process. + * Note that it will not change the default behavior of hilog logs of the current process, no matter whether this + * interface is called or not. \n + * + * @param callback Indicates the callback function implemented by the user. If you do not need to process hilog logs, + * you can transfer a null pointer. + * @since 11 + */ +void OH_LOG_SetCallback(LogCallback callback); + +#ifdef __cplusplus +} +#endif +/** @} */ + +#ifdef HILOG_RAWFORMAT +#include "hilog/log_inner.h" +#endif + +#endif // HIVIEWDFX_HILOG_C_H diff --git a/ets1.2/interop/src/cpp/ohos/oh_sk_log.cc b/ets1.2/interop/src/cpp/ohos/oh_sk_log.cc new file mode 100644 index 0000000000000000000000000000000000000000..a6ed96d11f8b2868b113af43012616ba8bf49c7e --- /dev/null +++ b/ets1.2/interop/src/cpp/ohos/oh_sk_log.cc @@ -0,0 +1,69 @@ +/* + * 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 +#include +#include +#include +#include "oh_sk_log.h" +#include "interop-utils.h" + +static const char* KOALAUI_OHOS_LOG_ROOT = "/data/storage/el2/base/files/logs"; + +#define APPLY_LOG_FILE_PATTERN(buf, bufLen, t, ms, pid) \ + interop_sprintf(buf, bufLen, "%s/%d_%d_%d_%lld.pid%d.log", \ + KOALAUI_OHOS_LOG_ROOT, (t).tm_year + 1900, (t).tm_mon + 1, (t).tm_mday, (ms).tv_sec, pid) + +const char* oh_sk_log_type_str(oh_sk_log_type type) { + switch (type) { + case Log_Debug: return "D"; + case Log_Info: return "I"; + case Log_Warn: return "W"; + case Log_Error: return "E"; + case Log_Fatal: return "F"; + } +} + +void oh_sk_file_log(oh_sk_log_type type, const char* msg, ...) { + time_t t = time(nullptr); + struct tm lt = *localtime(&t); + struct timeval ms{}; + gettimeofday(&ms, nullptr); + + static char* path = nullptr; + if (!path) { + size_t len = interop_strlen(KOALAUI_OHOS_LOG_ROOT) + 100; + path = new char[len]; + APPLY_LOG_FILE_PATTERN(path, len, lt, ms, getpid()); + mkdir(KOALAUI_OHOS_LOG_ROOT, 0777); + } + + std::unique_ptr file(fopen(path, "a"), fclose); + if (!file) return; + + fprintf(file.get(), "%02d-%02d %02d:%02d:%02d.%03lld %s koala: ", + lt.tm_mon + 1, lt.tm_mday, lt.tm_hour, lt.tm_min, lt.tm_sec, ms.tv_usec / 1000, + oh_sk_log_type_str(type)); + + va_list args; + va_start(args, msg); + vfprintf(file.get(), msg, args); + va_end(args); + + fprintf(file.get(), "\n"); +} diff --git a/ets1.2/interop/src/cpp/ohos/oh_sk_log.h b/ets1.2/interop/src/cpp/ohos/oh_sk_log.h new file mode 100644 index 0000000000000000000000000000000000000000..b268d0c46090778b184b3797f16479fc6696961d --- /dev/null +++ b/ets1.2/interop/src/cpp/ohos/oh_sk_log.h @@ -0,0 +1,60 @@ +/* + * 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. + */ + +#ifndef OH_SK_LOG_H +#define OH_SK_LOG_H + +#include + +typedef enum { + Log_Debug, + Log_Info, + Log_Warn, + Log_Error, + Log_Fatal +} oh_sk_log_type; + +void oh_sk_file_log(oh_sk_log_type type, const char* msg, ...); +const char* oh_sk_log_type_str(oh_sk_log_type type); + +#ifdef OH_SK_LOG_TO_FILE + +#define OH_SK_LOG_INFO(msg) oh_sk_file_log(oh_sk_log_type::Log_Info, msg) +#define OH_SK_LOG_INFO_A(msg, ...) oh_sk_file_log(oh_sk_log_type::Log_Info, msg, ##__VA_ARGS__) +#define OH_SK_LOG_ERROR(msg) oh_sk_file_log(oh_sk_log_type::Log_Error, msg) +#define OH_SK_LOG_ERROR_A(msg, ...) oh_sk_file_log(oh_sk_log_type::Log_Error, msg, ##__VA_ARGS__) +#define OH_SK_LOG_DEBUG(msg) oh_sk_file_log(oh_sk_log_type::Log_Debug, msg) +#define OH_SK_LOG_DEBUG_A(msg, ...) oh_sk_file_log(oh_sk_log_type::Log_Debug, msg, ##__VA_ARGS__) +#define OH_SK_LOG_WARN(msg) oh_sk_file_log(oh_sk_log_type::Log_Warn, msg) +#define OH_SK_LOG_WARN_A(msg, ...) oh_sk_file_log(oh_sk_log_type::Log_Warn, msg, ##__VA_ARGS__) +#define OH_SK_LOG_FATAL(msg) oh_sk_file_log(oh_sk_log_type::Log_Fatal, msg) +#define OH_SK_LOG_FATAL_A(msg, ...) oh_sk_file_log(oh_sk_log_type::Log_Fatal, msg, ##__VA_ARGS__) + +#else + +#define OH_SK_LOG_INFO(msg) OH_LOG_Print(LOG_APP, LOG_INFO, 0xFF00, "Koala", msg) +#define OH_SK_LOG_INFO_A(msg, ...) OH_LOG_Print(LOG_APP, LOG_INFO, 0xFF00, "Koala", msg, ##__VA_ARGS__) +#define OH_SK_LOG_ERROR(msg) OH_LOG_Print(LOG_APP, LOG_ERROR, 0xFF00, "Koala", msg) +#define OH_SK_LOG_ERROR_A(msg, ...) OH_LOG_Print(LOG_APP, LOG_ERROR, 0xFF00, "Koala", msg, ##__VA_ARGS__) +#define OH_SK_LOG_DEBUG(msg) OH_LOG_Print(LOG_APP, LOG_DEBUG, 0xFF00, "Koala", msg) +#define OH_SK_LOG_DEBUG_A(msg, ...) OH_LOG_Print(LOG_APP, LOG_DEBUG, 0xFF00, "Koala", msg, ##__VA_ARGS__) +#define OH_SK_LOG_WARN(msg) OH_LOG_Print(LOG_APP, LOG_WARN, 0xFF00, "Koala", msg) +#define OH_SK_LOG_WARN_A(msg, ...) OH_LOG_Print(LOG_APP, LOG_WARN, 0xFF00, "Koala", msg, ##__VA_ARGS__) +#define OH_SK_LOG_FATAL(msg) OH_LOG_Print(LOG_APP, LOG_FATAL, 0xFF00, "Koala", msg) +#define OH_SK_LOG_FATAL_A(msg, ...) OH_LOG_Print(LOG_APP, LOG_FATAL, 0xFF00, "Koala", msg, ##__VA_ARGS__) + +#endif + +#endif // OH_SK_LOG_H \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/profiler.h b/ets1.2/interop/src/cpp/profiler.h new file mode 100644 index 0000000000000000000000000000000000000000..9fc1c77a7655d09ff2619a946cd174f4bb0e2184 --- /dev/null +++ b/ets1.2/interop/src/cpp/profiler.h @@ -0,0 +1,100 @@ +/* + * 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. + */ + +#ifndef _KOALA_PROFILER_ +#define _KOALA_PROFILER_ + +#include +#include + +#include +#include +#include +#include +#include + +#include "interop-utils.h" + +struct InteropProfilerRecord { + int64_t time; + int64_t count; + InteropProfilerRecord(int64_t time, int64_t count) : time(time), count(count) {} +}; + +class InteropProfiler { + private: + std::unordered_map records; + static InteropProfiler* _instance; + InteropProfiler() {} + + public: + static InteropProfiler* instance() { + if (!_instance) _instance = new InteropProfiler(); + return _instance; + } + + void record(const char* name, int64_t ns) { + auto it = records.find(name); + if (it == records.end()) { + records.insert({name, InteropProfilerRecord(ns, 1)}); + } else { + it->second.time += ns; + it->second.count++; + } + } + + std::string report() { + std::vector> elems(records.begin(), records.end()); + std::sort(elems.begin(), elems.end(), + [](const std::pair&a, const std::pair&b) { + return b.second.time < a.second.time; + }); + int64_t total = 0; + std::for_each(elems.begin(), elems.end(), [&total](const std::pair&a) { + total += a.second.time; + }); + std::string result; + std::for_each(elems.begin(), elems.end(), [total, &result](const std::pair&a) { + auto ns = a.second.time; + auto count = a.second.count; + char buffer[1024]; + interop_snprintf(buffer, sizeof buffer, "for %s[%lld]: %.01f%% (%lld)\n", a.first.c_str(), (long long)count, (double)ns / total * 100.0, (long long)ns); + result += buffer; + }); + return result; + } + + void reset() { + records.clear(); + } +}; + + +class InteropMethodCall { + private: + const char* name; + std::chrono::steady_clock::time_point begin; + public: + InteropMethodCall(const char* name) : name(name) { + begin = std::chrono::steady_clock::now(); + } + ~InteropMethodCall() { + auto end = std::chrono::steady_clock::now(); + int64_t ns = std::chrono::duration_cast(end - begin).count(); + InteropProfiler::instance()->record(name, ns); + } +}; + +#endif // _KOALA_PROFILER_ \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/tracer.h b/ets1.2/interop/src/cpp/tracer.h new file mode 100644 index 0000000000000000000000000000000000000000..3211e6d685c819860cfa1dd4fb481c785241e0d2 --- /dev/null +++ b/ets1.2/interop/src/cpp/tracer.h @@ -0,0 +1,45 @@ +/* + * Copyright (c) 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. +*/ + +#ifndef _KOALA_TRACER_ +#define _KOALA_TRACER_ + +#ifdef KOALA_OHOS +#include +#define KOALA_TRACE(msg, str) OH_LOG_Print(LOG_APP, LOG_INFO, 0xFF00, "Koala", msg, str) +// Also do +// hdc shell hilog -p off +// hdc shell hilog -Q pidoff +// to see the output. +#define KOALA_TRACE_PUBLIC "%{public}s" +#else +#include +#define KOALA_TRACE(msg, str) fprintf(stderr, "Koala: " msg "\n", str) +#define KOALA_TRACE_PUBLIC "%s" +#endif + +class InteropMethodCall { + private: + const char* name; + public: + InteropMethodCall(const char* name) : name(name) { + KOALA_TRACE(">>> " KOALA_TRACE_PUBLIC, name); + } + ~InteropMethodCall() { + KOALA_TRACE("<<< " KOALA_TRACE_PUBLIC, name); + } +}; + +#endif // _KOALA_TRACER_ \ No newline at end of file diff --git a/ets1.2/interop/src/cpp/types/koala-types.h b/ets1.2/interop/src/cpp/types/koala-types.h new file mode 100644 index 0000000000000000000000000000000000000000..0c5bd658fc468409c5cf7ed5add19a3a2af9f8d1 --- /dev/null +++ b/ets1.2/interop/src/cpp/types/koala-types.h @@ -0,0 +1,273 @@ +/* + * Copyright (c) 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. + */ + +#ifndef _KOALA_TYPES_H +#define _KOALA_TYPES_H + +#include +#include +#include +#include + +#include "interop-types.h" +#include "interop-utils.h" + +#ifdef _MSC_VER +#define KOALA_EXECUTE(name, code) \ + static void __init_##name() { \ + code; \ + } \ + namespace { \ + struct __Init_##name { \ + __Init_##name() { __init_##name(); } \ + } __Init_##name##_v; \ + } +#else +#define KOALA_EXECUTE(name, code) \ + __attribute__((constructor)) \ + static void __init_jni_##name() { \ + code; \ + } +#endif + +struct KStringPtrImpl { + KStringPtrImpl(const uint8_t* str) : _value(nullptr), _owned(true) { + int len = str ? interop_strlen((const char*)str) : 0; + assign((const char*)str, len); + } + KStringPtrImpl(const char* str) : _value(nullptr), _owned(true) { + int len = str ? interop_strlen(str) : 0; + assign(str, len); + } + KStringPtrImpl(const char* str, int len, bool owned) : _value(nullptr), _owned(owned) { + assign(str, len); + } + KStringPtrImpl(const uint8_t* str, int len, bool owned) : _value(nullptr), _owned(owned) { + assign((const char*)str, len); + } + KStringPtrImpl() : _value(nullptr), _length(0), _owned(true) {} + + KStringPtrImpl(const KStringPtrImpl& other) = delete; + KStringPtrImpl& operator=(const KStringPtrImpl& other) = delete; + + KStringPtrImpl(InteropString value): KStringPtrImpl(value.chars, value.length, true) {} + + KStringPtrImpl(KStringPtrImpl&& other) { + this->_value = other.release(); + this->_owned = other._owned; + other._owned = false; + this->_length = other._length; + } + + ~KStringPtrImpl() { if (_value && _owned) free(_value); } + + bool isNull() const { return _value == nullptr; } + const char* c_str() const { return _value; } + char* data() const { return _value; } + int length() const { return _length; } + + void resize(int size) { + _length = size; + if (!_owned) return; + // Ignore old content. + if (_value && _owned) free(_value); + _value = reinterpret_cast(malloc(size + 1)); + if (!_value) { + INTEROP_FATAL("Cannot allocate memory"); + } + _value[size] = 0; + } + + void assign(const char* data) { + assign(data, data ? interop_strlen(data) : 0); + } + + void assign(const char* data, int len) { + if (_value && _owned) free(_value); + if (data) { + if (_owned) { + _value = reinterpret_cast(malloc(len + 1)); + if (!_value) { + INTEROP_FATAL("Cannot allocate memory"); + } + interop_memcpy(_value, len, data, len); + _value[len] = 0; + } else { + _value = const_cast(data); + } + } else { + _value = nullptr; + } + _length = len; + } + + protected: + char* release() { + char* result = this->_value; + this->_value = nullptr; + return result; + } + private: + char* _value; + int _length; + bool _owned; +}; + +struct KInteropNumber { + int8_t tag; + union { + int32_t i32; + float f32; + }; + KInteropNumber() { + this->tag = 0; + this->i32 = 0; + } + KInteropNumber(int32_t value) { + this->tag = INTEROP_TAG_INT32; + this->i32 = value; + } + KInteropNumber(float value) { + this->tag = INTEROP_TAG_FLOAT32; + this->f32 = value; + } + KInteropNumber(InteropNumber value) { + this->tag = value.tag; + this->i32 = value.i32; + } + InteropNumber toCType() { + InteropNumber result; + result.tag = this->tag; + result.i32 = this->i32; + return result; + } + static inline KInteropNumber fromDouble(double value) { + KInteropNumber result; + // Improve: boundary check + if (value == std::floor(value)) { + result.tag = INTEROP_TAG_INT32; + result.i32 = static_cast(value); + } else { + result.tag = INTEROP_TAG_FLOAT32; + result.f32 = (float)value; + } + return result; + } + inline double asDouble() { + if (tag == INTEROP_TAG_INT32) + return (double)i32; + else + return (double)f32; + } + inline int32_t asInt32() { + if (tag == INTEROP_TAG_INT32) + return i32; + else + return (int32_t)f32; + } +}; + +typedef InteropBoolean KBoolean; +typedef InteropUInt8 KByte; +typedef int16_t KChar; +typedef int16_t KShort; +typedef uint16_t KUShort; +typedef InteropInt32 KInt; +typedef InteropUInt32 KUInt; +typedef InteropInt64 KLong; +typedef InteropUInt64 KULong; +typedef InteropFloat32 KFloat; +typedef InteropFloat64 KDouble; +typedef InteropNativePointer KNativePointer; +typedef KStringPtrImpl KStringPtr; + +typedef KFloat* KFloatArray; +typedef const uint8_t* KStringArray; +typedef KNativePointer* KNativePointerArray; + +struct KSerializerBufferOpaque { + explicit operator KByte* () { + return reinterpret_cast(this); + } +}; +typedef KSerializerBufferOpaque* KSerializerBuffer; + +struct KInteropBuffer { + + KInteropBuffer(KLong len = 0, KNativePointer ptr = nullptr, KInt resId = 0, void (*dis)(KInt) = nullptr) + : length(len), data(ptr), resourceId(resId), dispose(dis) {} + + /** + * Takes ownership of given InteropBuffer + */ + KInteropBuffer(InteropBuffer value) { + length = value.length; + data = value.data; + resourceId = value.resource.resourceId; + dispose = value.resource.release; + } + + KLong length; + KNativePointer data; + + KInt resourceId; + void (*dispose)( KInt /* resourceId for now */); +}; + +struct KInteropReturnBuffer { + KInt length; + KNativePointer data; + void (*dispose)(KNativePointer data, KInt length); +}; + +typedef _InteropVMContext *KVMContext; + +// BEWARE: this MUST never be used in user code, only in very rare service code. +struct _KVMObject; +typedef _KVMObject *KVMObjectHandle; + +typedef struct KVMDeferred { + + KVMDeferred() {} + KVMDeferred(InteropDeferred value) { + handler = value.handler; + context = value.context; + resolve = reinterpret_cast(value.resolve); + reject = reinterpret_cast(value.reject); + } + + void* handler; + void* context; + void (*resolve)(KVMDeferred* thiz, uint8_t* data, int32_t length); + void (*reject)(KVMDeferred* thiz, const char* message); +} KVMDeferred; + +template T* ptr(KNativePointer ptr) { + return reinterpret_cast(ptr); +} + +template T& ref(KNativePointer ptr) { + return *reinterpret_cast(ptr); +} + +inline KNativePointer nativePtr(void* pointer) { + return reinterpret_cast(pointer); +} + +template KNativePointer fnPtr(void (*pointer)(T*)) { + return reinterpret_cast(pointer); +} + +#endif /* _KOALA_TYPES_H */ diff --git a/ets1.2/interop/src/cpp/types/signatures.cc b/ets1.2/interop/src/cpp/types/signatures.cc new file mode 100644 index 0000000000000000000000000000000000000000..a796ba76032fac54b6511d17c957b0f18d508d1b --- /dev/null +++ b/ets1.2/interop/src/cpp/types/signatures.cc @@ -0,0 +1,164 @@ +/* + * Copyright (c) 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. + */ + +#ifdef __cplusplus + #include + #include +#else + #include + #include +#endif + +#include + +#include "signatures.h" +#include "interop-types.h" + +// For types with the same name on ets and jni +#define KOALA_INTEROP_TYPEDEF(func, lang, CPP_TYPE, SIG_TYPE, CODE_TYPE) \ + if (std::strcmp(func, "sigType") == 0) if (type == (CPP_TYPE)) return SIG_TYPE; \ + if (std::strcmp(func, "codeType") == 0) if (type == (CPP_TYPE)) return CODE_TYPE; + +// For types with distinct names on ets and jni +#define KOALA_INTEROP_TYPEDEF_LS(func, lang, CPP_TYPE, ETS_SIG_TYPE, ETS_CODE_TYPE, JNI_SIG_TYPE, JNI_CODE_TYPE) \ + if (std::strcmp(func, "sigType") == 0 && std::strcmp(lang, "ets") == 0) if (type == (CPP_TYPE)) return ETS_SIG_TYPE; \ + if (std::strcmp(func, "codeType") == 0 && std::strcmp(lang, "ets") == 0) if (type == (CPP_TYPE)) return ETS_CODE_TYPE; \ + if (std::strcmp(func, "sigType") == 0 && std::strcmp(lang, "jni") == 0) if (type == (CPP_TYPE)) return JNI_SIG_TYPE; \ + if (std::strcmp(func, "codeType") == 0 && std::strcmp(lang, "jni") == 0) if (type == (CPP_TYPE)) return JNI_CODE_TYPE; + +#define KOALA_INTEROP_TYPEDEFS(func, lang) \ + KOALA_INTEROP_TYPEDEF(func, lang, "void", "V", "void") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KBoolean", "Z", "boolean") \ + KOALA_INTEROP_TYPEDEF(func, lang, "OH_Boolean", "Z", "boolean") \ + KOALA_INTEROP_TYPEDEF(func, lang, "Ark_Boolean", "Z", "boolean") \ + KOALA_INTEROP_TYPEDEF(func, lang, "int32_t", "I", "int") \ + KOALA_INTEROP_TYPEDEF(func, lang, "uint32_t", "I", "int") \ + KOALA_INTEROP_TYPEDEF(func, lang, "int", "I", "int") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KInt", "I", "int") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KUInt", "I", "int") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KLong", "J", "long") \ + KOALA_INTEROP_TYPEDEF(func, lang, "OH_Int32", "I", "int") \ + KOALA_INTEROP_TYPEDEF(func, lang, "OH_Int64", "J", "long") \ + KOALA_INTEROP_TYPEDEF(func, lang, "Ark_Int32", "I", "int") \ + KOALA_INTEROP_TYPEDEF(func, lang, "Ark_Int64", "J", "long") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KNativePointer", "J", "long") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KSerializerBuffer", "J", "long") \ + KOALA_INTEROP_TYPEDEF(func, lang, "Ark_NativePointer", "J", "long") \ + KOALA_INTEROP_TYPEDEF(func, lang, "OH_NativePointer", "J", "long") \ + KOALA_INTEROP_TYPEDEF(func, lang, "float", "F", "float") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KFloat", "F", "float") \ + KOALA_INTEROP_TYPEDEF(func, lang, "Ark_Float32", "F", "float") \ + KOALA_INTEROP_TYPEDEF(func, lang, "double", "D", "double") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KDouble", "D", "double") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KInteropNumber", "D", "double") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KVMObjectHandle", "Ljava/lang/Object;", "Object") \ + KOALA_INTEROP_TYPEDEF(func, lang, "uint8_t*", "[B", "byte[]") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KByte*", "[B", "byte[]") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KInteropBuffer", "[B", "byte[]") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KShort*", "[S", "short[]") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KUShort*", "[S", "short[]") \ + KOALA_INTEROP_TYPEDEF(func, lang, "int32_t*", "[I", "int[]") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KInt*", "[I", "int[]") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KNativePointerArray", "[J", "long[]") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KInteropReturnBuffer", "[B", "byte[]") \ + KOALA_INTEROP_TYPEDEF(func, lang, "float*", "[F", "float[]") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KFloatArray", "[F", "float[]") \ + KOALA_INTEROP_TYPEDEF(func, lang, "KFloat*", "[F", "float[]") \ + KOALA_INTEROP_TYPEDEF_LS(func, lang, "KStringPtr", "Lstd/core/String;", "String", "Ljava/lang/String;", "String") \ + KOALA_INTEROP_TYPEDEF_LS(func, lang, "KStringArray", "[Lstd/core/String;", "String[]", "[Ljava/lang/String;", "String[]") + +std::string sigType(const std::string &type) { +#if KOALA_USE_PANDA_VM + KOALA_INTEROP_TYPEDEFS("sigType", "ets") +#elif KOALA_USE_JAVA_VM + KOALA_INTEROP_TYPEDEFS("sigType", "jni") +#endif + INTEROP_FATAL("Unhandled type: %s\n", type.c_str()); + return type; +} + +std::string codeType(const std::string &type) { +#if KOALA_USE_PANDA_VM + KOALA_INTEROP_TYPEDEFS("codeType", "ets") +#elif KOALA_USE_JAVA_VM + KOALA_INTEROP_TYPEDEFS("codeType", "jni") +#endif + INTEROP_FATAL("Unhandled type: %s\n", type.c_str()); + return ""; +} + +std::string convertType(const char* name, const char* koalaType) { + std::string result; + size_t current = 0, last = 0; + std::string input(koalaType); + std::vector tokens; + while ((current = input.find('|', last)) != std::string::npos) + { + auto token = input.substr(last, current - last); + tokens.push_back(token); + last = current + 1; + } + tokens.push_back(input.substr(last, input.length() - last)); + +#if KOALA_USE_PANDA_VM + + for (int i = 1; i < static_cast(tokens.size()); i++) + { + result.append(sigType(tokens[i])); + } + result.append(":"); + result.append(sigType(tokens[0])); + +#elif KOALA_USE_JAVA_VM + + result.append("("); + for (int i = 1; i < static_cast(tokens.size()); i++) + { + result.append(sigType(tokens[i])); + } + result.append(")"); + result.append(sigType(tokens[0])); + +#endif + +#ifdef KOALA_BUILD_FOR_SIGNATURES + #ifdef KOALA_USE_PANDA_VM + std::string params; + for (int i = 1; i < static_cast(tokens.size()); i++) + { + params.append("arg"); + params.append(std::to_string(i)); + params.append(": "); + params.append(codeType(tokens[i])); + if (i < static_cast(tokens.size() - 1)) + params.append(", "); + } + fprintf(stderr, " static native %s(%s): %s;\n", name, params.c_str(), codeType(tokens[0]).c_str()); + #elif KOALA_USE_JAVA_VM + std::string params; + for (int i = 1; i < static_cast(tokens.size()); i++) + { + params.append(codeType(tokens[i])); + params.append(" arg"); + params.append(std::to_string(i)); + if (i < static_cast(tokens.size() - 1)) + params.append(", "); + } + fprintf(stderr, " public static native %s %s(%s);\n", codeType(tokens[0]).c_str(), name, params.c_str()); + #endif +#endif + + return result; +} diff --git a/ets1.2/interop/src/cpp/types/signatures.h b/ets1.2/interop/src/cpp/types/signatures.h new file mode 100644 index 0000000000000000000000000000000000000000..05ddf1cc8df0cf621f9403fbbc3caa43e33bc2e8 --- /dev/null +++ b/ets1.2/interop/src/cpp/types/signatures.h @@ -0,0 +1,25 @@ +/* + * Copyright (c) 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. + */ + +#ifndef _SIGNATURES_H +#define _SIGNATURES_H + +#include + +std::string sigType(const std::string &type); +std::string codeType(const std::string &type); +std::string convertType(const char* name, const char* koalaType); + +#endif // _SIGNATURES_H diff --git a/ets1.2/interop/src/cpp/vmloader.cc b/ets1.2/interop/src/cpp/vmloader.cc new file mode 100644 index 0000000000000000000000000000000000000000..6a5cf93c12c986eeff240538444c60f57cc76986 --- /dev/null +++ b/ets1.2/interop/src/cpp/vmloader.cc @@ -0,0 +1,1194 @@ +/* + * Copyright (c) 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. + */ + +#include +#include +#include +#include +#include + +#include "interop-logging.h" +#include "dynamic-loader.h" +#include "koala-types.h" +#include "interop-utils.h" + +// DO NOT USE KOALA INTEROP MECHANISMS IN THIS FILE! + +#ifdef KOALA_JNI +#include "jni.h" +#endif + +#ifdef KOALA_ETS_NAPI +#include "etsapi.h" +#endif + +#ifdef KOALA_ANI +#include "ani.h" +#endif + +#ifdef KOALA_KOTLIN +#include "kotlin_vmloader_wrapper.h" +#endif + +#if defined(KOALA_LINUX) || defined(KOALA_MACOS) || defined(KOALA_OHOS) +#include "sys/stat.h" +#include "dirent.h" +#endif + +#define OHOS_USER_LIBS "/data/storage/el1/bundle/libs" +#ifdef KOALA_OHOS_ARM32 +#define USE_SYSTEM_ARKVM 1 +#elif KOALA_OHOS_ARM64 +#define USE_SYSTEM_ARKVM 1 +#else +#define USE_SYSTEM_ARKVM 0 +#endif + +#if USE_SYSTEM_ARKVM +#define SYSTEM_ARK_STDLIB_PATH "/system/etc/etsstdlib.abc" +#endif + +#ifndef KOALA_USE_PANDA_VM +#ifdef KOALA_ANI +#define KOALA_USE_PANDA_VM 1 +#endif +#ifdef KOALA_ETS_NAPI +#define KOALA_USE_PANDA_VM 1 +#endif +#endif + +void traverseDir(const std::string& root, std::vector& paths, std::string suffix, const std::vector& fallbackPaths = {}); + +struct VMLibInfo { + const char* sdkPath; + const char* platform; + const char* lib; +}; + +#ifdef KOALA_JNI +const VMLibInfo javaVMLib = { + getenv("JAVA_HOME"), + #if defined(KOALA_LINUX) || defined(KOALA_MACOS) + "lib/server" + #elif KOALA_WINDOWS + "bin/server" + #else + #error "Unknown platform" + #endif + , + "jvm" +}; +#endif + +#if defined(KOALA_ETS_NAPI) || defined(KOALA_ANI) +const VMLibInfo pandaVMLib = { + // sdkPath + #if defined(KOALA_OHOS) + #ifdef KOALA_OHOS_ARM32 + "/system/lib" + #elif KOALA_OHOS_ARM64 + "/system/lib64" + #else + OHOS_USER_LIBS + #endif + #else + getenv("PANDA_HOME") + #endif + , + + // platform + #ifdef KOALA_LINUX + #ifdef KOALA_LINUX_ARM64 + "linux_arm64_host_tools/lib" + #else + "linux_host_tools/lib" + #endif + #elif KOALA_MACOS + "macos_host_tools/lib" + #elif KOALA_WINDOWS + "_host_tools/lib" + #elif KOALA_OHOS_ARM64 + "arm64" + #elif KOALA_OHOS_ARM32 + "arm" + #else + #error "Unknown platform" + #endif + , + + // lib + "arkruntime" +}; +#endif + +#ifdef KOALA_KOTLIN +const VMLibInfo kotlinLib = { + .sdkPath = nullptr, + .platform = nullptr, + .lib = "kotlin_koala", +}; +#endif + +struct VMInitArgs { + int version; + int nOptions; + void* options; +}; + +#define JAVA_VM_KIND 1 +#define PANDA_VM_KIND 2 +#define ES2PANDA_KIND 3 +#define PANDA_ANI_VM_KIND 4 +#define KOTLIN_KIND 5 + +struct ForeignVMContext { + void* currentVMContext; + int32_t (*callSync)(void* vmContext, int32_t callback, int8_t* data, int32_t length); +}; + +struct VMEntry { + int vmKind; + void* env; + void* app; + void* create; + void* start; + void* enter; + void* emitEvent; + void* restartWith; + void* loadView; + ForeignVMContext foreignVMContext; + std::string userFilesAbcPaths; +}; + +VMEntry g_vmEntry = {}; + +typedef int (*createVM_t)(void** pVM, void** pEnv, void* vmInitArgs); + +#ifdef KOALA_WINDOWS +#define DLL_EXPORT __declspec(dllexport) +#else +#define DLL_EXPORT __attribute__ ((visibility ("default"))) +#endif + +int loadES2Panda(const char* appClassPath, const char* appLibPath) { + fprintf(stderr, "native: es2panda %s\n", appClassPath); + return 0; +} + +#ifdef KOALA_ETS_NAPI +namespace { + +enum PandaLog2MobileLog : int { + UNKNOWN = 0, + DEFAULT, + VERBOSE, + DEBUG, + INFO, + WARN, + ERROR, + FATAL, + SILENT, +}; + +int ArkMobileLog(int id, int level, const char *component, const char *fmt, const char *msg) +{ + switch (level) { + case PandaLog2MobileLog::DEFAULT: + case PandaLog2MobileLog::VERBOSE: + case PandaLog2MobileLog::DEBUG: + case PandaLog2MobileLog::INFO: + case PandaLog2MobileLog::SILENT: + LOGI("ArkRuntime [%" LOG_PUBLIC "s]: %" LOG_PUBLIC "s", component, msg); + break; + case PandaLog2MobileLog::UNKNOWN: + case PandaLog2MobileLog::WARN: + case PandaLog2MobileLog::ERROR: + case PandaLog2MobileLog::FATAL: + default: + LOGE("ArkRuntime [%" LOG_PUBLIC "s]: %" LOG_PUBLIC "s", component, msg); + break; + } + return 0; +} + +} +#endif + +#ifdef KOALA_ANI + +static void AniMobileLog([[maybe_unused]] FILE *stream, int level, + const char *component, const char *msg) +{ + switch (level) { + case ANI_LOGLEVEL_INFO: + case ANI_LOGLEVEL_DEBUG: + LOGI("ArkRuntime [%" LOG_PUBLIC "s]: %" LOG_PUBLIC "s", component, msg); + break; + case ANI_LOGLEVEL_FATAL: + case ANI_LOGLEVEL_ERROR: + case ANI_LOGLEVEL_WARNING: + default: + LOGE("ArkRuntime [%" LOG_PUBLIC "s]: %" LOG_PUBLIC "s", component, msg); + break; + } +} + +static std::string makeClasspath(const std::vector& files) +{ + std::stringstream stream; + for (size_t index = 0, end = files.size(); index < end; ++index) { + if (index > 0) { + stream << ':'; + } + stream << files[index]; + } + return stream.str(); +} + +static std::pair GetBootAndAppPandaFiles(const VMLibInfo* thisVM, const char* bootFilesPath, const char* userFilesPath) +{ + std::vector bootFiles; +#if USE_SYSTEM_ARKVM + bootFiles.push_back(SYSTEM_ARK_STDLIB_PATH); +#elif defined(KOALA_OHOS) + bootFiles.push_back(std::string(OHOS_USER_LIBS) + "/etsstdlib.abc"); +#elif defined(KOALA_LINUX) || defined(KOALA_MACOS) || defined(KOALA_WINDOWS) + bootFiles.push_back(std::string(thisVM->sdkPath) + "/ets/etsstdlib.abc"); +#endif + +#if defined(KOALA_OHOS) + traverseDir("/system/framework", bootFiles, ".abc", { + "etsstdlib_bootabc" + }); +#endif + + std::vector userFiles; + traverseDir(userFilesPath, userFiles, ".abc"); + std::sort(userFiles.begin(), userFiles.end()); + + traverseDir(bootFilesPath, bootFiles, ".abc"); + std::sort(bootFiles.begin(), bootFiles.end()); + + if (bootFiles.empty() || userFiles.empty()) + return {"",""}; + + return { makeClasspath(bootFiles), makeClasspath(userFiles) }; +} + +static std::string GetAOTFiles(const char* appClassPath) +{ + std::vector files; + traverseDir(std::string(appClassPath), files, ".an"); + return makeClasspath(files); +} + +static bool ResetErrorIfExists(ani_env *env) +{ + ani_boolean hasError = ANI_FALSE; + env->ExistUnhandledError(&hasError); + if (hasError == ANI_TRUE) { + env->DescribeError(); + env->ResetError(); + return true; + } + return false; +} + +#endif + +std::string makeLibPath(const char *sdkPath, const char *platform, const char *lib) { + std::string result; + result.reserve(255); + if (sdkPath) { + result.append(sdkPath).append("/"); + } + if (platform) { + result.append(platform).append("/"); + } + result.append(libName(lib)); + return result; +} + +extern "C" DLL_EXPORT KInt LoadVirtualMachine(KInt vmKind, const char* bootFilesDir, const char* userFilesDir, const char* appLibPath, const ForeignVMContext* foreignVMContext) +{ + if (vmKind == ES2PANDA_KIND) { + return loadES2Panda(bootFilesDir, appLibPath); + } + + const VMLibInfo* thisVM = + #ifdef KOALA_JNI + (vmKind == JAVA_VM_KIND) ? &javaVMLib : + #endif + #if defined(KOALA_ETS_NAPI) || defined(KOALA_ANI) + (vmKind == PANDA_VM_KIND || vmKind == PANDA_ANI_VM_KIND) ? &pandaVMLib : + #endif + #ifdef KOALA_KOTLIN + (vmKind == KOTLIN_KIND) ? &kotlinLib : + #endif + nullptr; + + if (!thisVM) { + LOGE("Unknown VM kind: %" LOG_PUBLIC "d\n (possibly %" LOG_PUBLIC "s is compiled without expected flags)", vmKind, __FILE__); + return -1; + } + + LOGI("Starting VM %" LOG_PUBLIC "d with bootFilesDir=%" LOG_PUBLIC "s userFilesDir=%" LOG_PUBLIC "s native=%" LOG_PUBLIC "s", vmKind, bootFilesDir, userFilesDir, appLibPath); + + std::string libPath = +#if USE_SYSTEM_ARKVM + std::string(thisVM->sdkPath) + "/" + libName(thisVM->lib) +#elif defined(KOALA_LINUX) || defined(KOALA_MACOS) || defined(KOALA_WINDOWS) + makeLibPath(thisVM->sdkPath, thisVM->platform, thisVM->lib) +#elif defined(KOALA_OHOS) + std::string(OHOS_USER_LIBS) + "/" + libName(thisVM->lib) +#else + #error "Library path not specified for this platform" +#endif + ; + void *handle = loadLibrary(libPath); + if (!handle) { + LOGE("Cannot load library %" LOG_PUBLIC "s: %" LOG_PUBLIC "s\n", libPath.c_str(), libraryError()); + return -1; + } + + void* vm = nullptr; + void* env = nullptr; + int result = 0; + +#ifdef KOALA_JNI + if (vmKind == JAVA_VM_KIND) { + typedef int (*createVM_t)(void** pVM, void** pEnv, void* vmInitArgs); + createVM_t createVM = (createVM_t)findSymbol(handle, "JNI_CreateJavaVM"); + if (!createVM) { + LOGE("Cannot find %" LOG_PUBLIC "s\n", "JNI_CreateJavaVM"); + return -1; + } + JavaVMInitArgs javaVMArgs; + javaVMArgs.version = JNI_VERSION_10; + javaVMArgs.ignoreUnrecognized = false; + std::vector javaVMOptions; + javaVMOptions = { + {(char*)strdup((std::string("-Djava.class.path=") + bootFilesDir).c_str())}, + {(char*)strdup((std::string("-Djava.library.path=") + appLibPath).c_str())}, + }; + javaVMArgs.nOptions = javaVMOptions.size(); + javaVMArgs.options = javaVMOptions.data(); + g_vmEntry.vmKind = JAVA_VM_KIND; + result = createVM(&vm, &env, &javaVMArgs); + } +#endif + +#if defined(KOALA_ANI) + if (vmKind == PANDA_ANI_VM_KIND) { + g_vmEntry.vmKind = vmKind; + + uint32_t version = ANI_VERSION_1; + size_t nVMs = 0; + typedef int (*getVMs_t)(void** pVM, size_t bufLen, size_t* nVMs); + typedef int (*createVM_t)(const void* args, uint32_t version, void** pVM); + createVM_t createVM = (createVM_t)findSymbol(handle, "ANI_CreateVM"); + getVMs_t getVMs = (getVMs_t)findSymbol(handle, "ANI_GetCreatedVMs"); + result = getVMs ? getVMs(&vm, 1, &nVMs) : 0; + if (nVMs == 0 && result == 0) { + std::vector pandaVMOptions; + + auto [bootFiles, userFiles] = GetBootAndAppPandaFiles(thisVM, bootFilesDir, userFilesDir); + LOGI("ANI: user abc-files \"%" LOG_PUBLIC "s\" from %" LOG_PUBLIC "s", userFiles.c_str(), userFilesDir); + g_vmEntry.userFilesAbcPaths = std::move(userFiles); + + bootFiles = "--ext:--boot-panda-files=" + bootFiles; + LOGI("ANI boot-panda-files option: \"%" LOG_PUBLIC "s\"", bootFiles.c_str()); + pandaVMOptions.push_back({bootFiles.c_str(), nullptr}); + + auto aotFiles = GetAOTFiles(bootFilesDir); + if (!aotFiles.empty()) { + LOGI("ANI AOT files: \"%" LOG_PUBLIC "s\"", aotFiles.c_str()); + aotFiles = "--ext:--aot-files=" + aotFiles; + pandaVMOptions.push_back({aotFiles.c_str(), nullptr}); + } + + pandaVMOptions.push_back({"--ext:--gc-trigger-type=heap-trigger", nullptr}); + std::string nativeLibraryPathOption = + std::string("--ext:--native-library-path=") + appLibPath; + pandaVMOptions.push_back({nativeLibraryPathOption.c_str(), nullptr}); + pandaVMOptions.push_back({"--ext:--verification-mode=on-the-fly", nullptr}); + pandaVMOptions.push_back({"--ext:--compiler-enable-jit=true", nullptr}); + pandaVMOptions.push_back({"--logger", reinterpret_cast(AniMobileLog)}); + pandaVMOptions.push_back({"--ext:--enable-an", nullptr}); + ani_options optionsPtr = {pandaVMOptions.size(), pandaVMOptions.data()}; + + result = createVM(&optionsPtr, version, &vm); + } + + if (result == 0) { + ani_vm* vmInstance = (ani_vm*)vm; + ani_env* pEnv = nullptr; + result = vmInstance->GetEnv(version, &pEnv); + env = static_cast(pEnv); + } + } +#endif /* KOALA_ANI */ + +// For now we use ETS API for VM startup and entry. +#if defined(KOALA_ETS_NAPI) + if (vmKind == PANDA_VM_KIND) { + EtsVMInitArgs pandaVMArgs; + pandaVMArgs.version = ETS_NAPI_VERSION_1_0; + std::vector etsVMOptions; + std::vector files; + traverseDir(std::string(bootFilesDir), files, ".abc"); + std::sort(files.begin(), files.end()); + std::vector files_aot; + traverseDir(std::string(bootFilesDir), files_aot, ".an"); + std::sort(files_aot.begin(), files_aot.end()); + etsVMOptions = { +#if USE_SYSTEM_ARKVM + {EtsOptionType::ETS_BOOT_FILE, SYSTEM_ARK_STDLIB_PATH}, +#elif defined(KOALA_OHOS) + {EtsOptionType::ETS_BOOT_FILE, (std::string(OHOS_USER_LIBS) + "/" + "etsstdlib.abc").c_str() }, + +#elif defined(KOALA_LINUX) || defined(KOALA_MACOS) || defined(KOALA_WINDOWS) + {EtsOptionType::ETS_BOOT_FILE, (char*)strdup((std::string(thisVM->sdkPath) + "/ets/etsstdlib.abc").c_str())}, +#endif + }; + std::string all_files; + for (const std::string& path : files) { + etsVMOptions.push_back({EtsOptionType::ETS_BOOT_FILE, (char*)strdup(path.c_str())}); + if (all_files.size() > 0) all_files.append(":"); + all_files.append(path); + } + LOGI("Using ETSNAPI: classpath \"%" LOG_PUBLIC "s\" from %" LOG_PUBLIC "s", all_files.c_str(), bootFilesDir); + std::string all_files_aot; + for (const std::string& path : files_aot) { + etsVMOptions.push_back({EtsOptionType::ETS_AOT_FILE, (char*)strdup(path.c_str())}); + if (all_files_aot.size() > 0) all_files_aot.append(":"); + all_files_aot.append(path); + } + LOGI("ETSNAPI classpath (aot) \"%" LOG_PUBLIC "s\" from %" LOG_PUBLIC "s", all_files_aot.c_str(), bootFilesDir); + etsVMOptions.push_back({EtsOptionType::ETS_GC_TRIGGER_TYPE, "heap-trigger"}); + etsVMOptions.push_back({EtsOptionType::ETS_NATIVE_LIBRARY_PATH, (char*)strdup(std::string(appLibPath).c_str())}); + etsVMOptions.push_back({EtsOptionType::ETS_VERIFICATION_MODE, "on-the-fly"}); + etsVMOptions.push_back({EtsOptionType::ETS_JIT, nullptr}); + etsVMOptions.push_back({EtsOptionType::ETS_MOBILE_LOG, (void*)ArkMobileLog}); + etsVMOptions.push_back({EtsOptionType::ETS_AOT, nullptr}); + pandaVMArgs.nOptions = etsVMOptions.size(); + pandaVMArgs.options = etsVMOptions.data(); + g_vmEntry.vmKind = vmKind; + + int32_t nVMs = 0; + typedef int (*createVM_t)(void** pVM, void** pEnv, void* vmInitArgs); + typedef int (*getVMs_t)(void** pVM, int32_t bufLen, int32_t* nVMs); + createVM_t createVM = (createVM_t)findSymbol(handle, "ETS_CreateVM"); + getVMs_t getVMs = (getVMs_t)findSymbol(handle, "ETS_GetCreatedVMs"); + result = getVMs ? getVMs(&vm, 1, &nVMs) : 0; + if (nVMs != 0) { + __EtsVM* vmInstance = (__EtsVM*)vm; + EtsEnv* pEnv = nullptr; + vmInstance->GetEnv(&pEnv, ETS_NAPI_VERSION_1_0); + env = static_cast(pEnv); + + } else { + result = createVM(&vm, &env, &pandaVMArgs); + } + } +#endif + +#ifdef KOALA_KOTLIN + if (vmKind == KOTLIN_KIND) { + g_vmEntry.vmKind = vmKind; + (void)vm; + + application_create_t application_create = (application_create_t)findSymbol(handle, "application_create"); + application_start_t application_start = (application_start_t)findSymbol(handle, "application_start"); + application_enter_t application_enter = (application_enter_t)findSymbol(handle, "application_enter"); + g_vmEntry.create = (void*)application_create; + g_vmEntry.start = (void*)application_start; + g_vmEntry.enter = (void*)application_enter; + + result = 0; + } +#endif + + if (result != 0) { + LOGE("Error creating a VM of kind %" LOG_PUBLIC "d: %" LOG_PUBLIC "d\n", vmKind, result); + return result; + } + g_vmEntry.env = env; + g_vmEntry.foreignVMContext = *foreignVMContext; + return 0; +} + +struct AppInfo { + const char* className; + const char* createMethodName; + const char* createMethodSig; + const char* startMethodName; + const char* startMethodSig; + const char* enterMethodName; + const char* enterMethodSig; + const char* emitEventMethodName; + const char* emitEventMethodSig; + const char* restartWithMethodName; + const char* restartWithMethodSig; + const char* loadViewMethodName; + const char* loadViewMethodSig; +}; + +#ifdef KOALA_JNI +const AppInfo javaAppInfo = { + "org/koalaui/arkoala/Application", + "createApplication", + "(Ljava/lang/String;Ljava/lang/String;)Lorg/koalaui/arkoala/Application;", + "start", + "(JI)J", + "enter", + "(IIJ)Z", + "emitEvent", + "(IIII)Ljava/lang/String;", + "UNUSED", + "()V" +}; +#endif + +#ifdef KOALA_ETS_NAPI +const AppInfo pandaAppInfo = { + "arkui/ArkUIEntry/Application", + "createApplication", + "Lstd/core/String;Lstd/core/String;ZI:Larkui/ArkUIEntry/Application;", + "start", + "JI:J", + "enter", + "IIJ:Z", + "emitEvent", + "IIII:Lstd/core/String;", + "UNUSED", + "I:I" +}; +const AppInfo harnessAppInfo = { + "@koalaui/ets-harness/src/EtsHarnessApplication/EtsHarnessApplication", + "createApplication", + "Lstd/core/String;Lstd/core/String;ZI:L@koalaui/ets-harness/src/EtsHarnessApplication/EtsHarnessApplication;", + "start", + "J:J", + "enter", + "IIJ:Z", + "emitEvent", + "IIII:Lstd/core/String;", + "restartWith", + "Lstd/core/String;:V", + }; +#endif +#ifdef KOALA_ANI +const AppInfo harnessAniAppInfo = { + "@koalaui.ets-harness.src.EtsHarnessApplication.EtsHarnessApplication", + "createApplication", + "C{std.core.String}C{std.core.String}C{std.core.String}zi:C{@koalaui.ets-harness.src.EtsHarnessApplication.EtsHarnessApplication}", + "start", + "li:l", + "enter", + "iil:z", + "emitEvent", + "iiii:C{std.core.String}", + "restartWith", + "C{std.core.String}:", + "UNUSED", + "i:i" +}; +const AppInfo aniAppInfo = { + "arkui.ArkUIEntry.Application", + "createApplication", + "C{std.core.String}C{std.core.String}C{std.core.String}zi:C{arkui.ArkUIEntry.Application}", + "start", + "li:l", + "enter", + "il:z", + "emitEvent", + "iiii:C{std.core.String}", + "UNUSED", + "i:i", + "loadView", + "C{std.core.String}C{std.core.String}:C{std.core.String}", +}; +#endif + +#ifdef KOALA_KOTLIN +const AppInfo kotlinAppInfo = { 0 }; +#endif + +extern "C" DLL_EXPORT KNativePointer StartApplication(const char* appUrl, const char* appParams, int32_t loopIterations) +{ + const auto isTestEnv = std::string(appUrl) == "EtsHarness"; + const AppInfo* appInfo = + #ifdef KOALA_JNI + (g_vmEntry.vmKind == JAVA_VM_KIND) ? &javaAppInfo : + #endif + #if defined(KOALA_ETS_NAPI) + (g_vmEntry.vmKind == PANDA_VM_KIND) ? isTestEnv ? &harnessAppInfo : &pandaAppInfo : + #endif + #if defined(KOALA_ANI) + (g_vmEntry.vmKind == PANDA_ANI_VM_KIND) ? isTestEnv ? &harnessAniAppInfo : &aniAppInfo : + #endif + #if defined(KOALA_KOTLIN) + (g_vmEntry.vmKind == KOTLIN_KIND) ? &kotlinAppInfo : + #endif + nullptr; + + if (!appInfo) { + LOGE("No appInfo provided for VM kind %" LOG_PUBLIC "d (recompile vmloader.cc with the missing flags)\n", g_vmEntry.vmKind); + return nullptr; + } + + LOGI("Starting application %" LOG_PUBLIC "s with params %" LOG_PUBLIC "s", appUrl, appParams); +#ifdef KOALA_JNI + if (g_vmEntry.vmKind == JAVA_VM_KIND) { + JNIEnv* jEnv = (JNIEnv*)(g_vmEntry.env); + jclass appClass = jEnv->FindClass(appInfo->className); + if (!appClass) { + LOGE("Cannot load main class %s\n", appInfo->className); + return nullptr; + } + jmethodID create = jEnv->GetStaticMethodID(appClass, appInfo->createMethodName, appInfo->createMethodSig); + if (!create) { + LOGE("Cannot find create method %s\n", appInfo->createMethodName); + return nullptr; + } + auto app = jEnv->NewGlobalRef(jEnv->CallStaticObjectMethod(appClass, create, jEnv->NewStringUTF(appUrl), jEnv->NewStringUTF(appParams))); + g_vmEntry.app = app; + auto start = jEnv->GetMethodID(appClass, appInfo->startMethodName, appInfo->startMethodSig); + if (!start) { + LOGE("Cannot find start method \"%s %s\"\n", appInfo->startMethodName, appInfo->startMethodSig); + return nullptr; + } + g_vmEntry.enter = (void*)(jEnv->GetMethodID(appClass, appInfo->enterMethodName, appInfo->enterMethodSig)); + if (!g_vmEntry.enter) { + LOGE("Cannot find enter method %s\n", appInfo->enterMethodName); + return nullptr; + } + g_vmEntry.emitEvent = (void*)(jEnv->GetMethodID(appClass, appInfo->emitEventMethodName, appInfo->emitEventMethodSig)); + if (!g_vmEntry.emitEvent) { + LOGE("Cannot find emitEvent method %s\n", appInfo->emitEventMethodName); + return nullptr; + } + return reinterpret_cast(jEnv->CallLongMethod( + app, start)); + } +#endif +#if defined(KOALA_ETS_NAPI) + if (g_vmEntry.vmKind == PANDA_VM_KIND) { + EtsEnv* etsEnv = (EtsEnv*)g_vmEntry.env; + ets_class appClass = etsEnv->FindClass(appInfo->className); + if (!appClass) { + LOGE("Cannot load main class %" LOG_PUBLIC "s\n", appInfo->className); + if (etsEnv->ErrorCheck()) { + etsEnv->ErrorDescribe(); + etsEnv->ErrorClear(); + } + return nullptr; + } + ets_method create = etsEnv->GetStaticp_method(appClass, appInfo->createMethodName, appInfo->createMethodSig); + if (!create) { + LOGE("Cannot find create method %" LOG_PUBLIC "s\n", appInfo->createMethodName); + if (etsEnv->ErrorCheck()) { + etsEnv->ErrorDescribe(); + etsEnv->ErrorClear(); + } + return nullptr; + } + auto useNativeLog = false; + auto app = etsEnv->NewGlobalRef(etsEnv->CallStaticObjectMethod( + appClass, create, + etsEnv->NewStringUTF(appUrl), etsEnv->NewStringUTF(appParams), + useNativeLog, + g_vmEntry.vmKind + )); + if (!app) { + LOGE("createApplication returned null"); + if (etsEnv->ErrorCheck()) { + etsEnv->ErrorDescribe(); + etsEnv->ErrorClear(); + return nullptr; + } + return nullptr; + } + g_vmEntry.app = (void*)app; + auto start = etsEnv->Getp_method(appClass, appInfo->startMethodName, appInfo->startMethodSig); + g_vmEntry.enter = (void*)(etsEnv->Getp_method(appClass, appInfo->enterMethodName, nullptr /*appInfo->enterMethodSig */)); + if (!g_vmEntry.enter) { + LOGE("Cannot find enter method %" LOG_PUBLIC "s", appInfo->enterMethodName); + if (etsEnv->ErrorCheck()) { + etsEnv->ErrorDescribe(); + etsEnv->ErrorClear(); + } + return nullptr; + } + if (etsEnv->ErrorCheck()) { + etsEnv->ErrorDescribe(); + etsEnv->ErrorClear(); + return nullptr; + } + g_vmEntry.emitEvent = (void*)(etsEnv->Getp_method(appClass, appInfo->emitEventMethodName, appInfo->emitEventMethodSig)); + if (!g_vmEntry.emitEvent) { + LOGE("Cannot find enter emitEvent %" LOG_PUBLIC "s", appInfo->emitEventMethodSig); + if (etsEnv->ErrorCheck()) { + etsEnv->ErrorDescribe(); + etsEnv->ErrorClear(); + } + return nullptr; + } + if (isTestEnv) { + g_vmEntry.restartWith = (void*)(etsEnv->Getp_method(appClass, appInfo->restartWithMethodName, appInfo->restartWithMethodSig)); + if (!g_vmEntry.restartWith) { + LOGE("Cannot find enter restartWith %" LOG_PUBLIC "s", appInfo->restartWithMethodSig); + if (etsEnv->ErrorCheck()) { + etsEnv->ErrorDescribe(); + etsEnv->ErrorClear(); + } + return nullptr; + } + } + // Improve: pass app entry point! + return reinterpret_cast(etsEnv->CallLongMethod((ets_object)(app), start, &g_vmEntry.foreignVMContext)); + } +#endif +#if defined(KOALA_ANI) + if (g_vmEntry.vmKind == PANDA_ANI_VM_KIND) { + auto *env = reinterpret_cast(g_vmEntry.env); + + ani_class appClass {}; + auto status = env->FindClass(appInfo->className, &appClass); + if (status != ANI_OK) { + LOGE("Cannot load main class %" LOG_PUBLIC "s\n", appInfo->className); + ResetErrorIfExists(env); + return nullptr; + } + ani_static_method create {}; + status = env->Class_FindStaticMethod(appClass, appInfo->createMethodName, appInfo->createMethodSig, &create); + if (status != ANI_OK) { + LOGE("Cannot find create method %" LOG_PUBLIC "s\n", appInfo->createMethodName); + ResetErrorIfExists(env); + return nullptr; + } + + ani_boolean useNativeLog = ANI_FALSE; + ani_string appUrlString {}; + status = env->String_NewUTF8(appUrl, interop_strlen(appUrl), &appUrlString); + if (status != ANI_OK) { + ResetErrorIfExists(env); + return nullptr; + } + + ani_string userPandaFilesPathString {}; + status = env->String_NewUTF8(g_vmEntry.userFilesAbcPaths.c_str(), g_vmEntry.userFilesAbcPaths.size(), &userPandaFilesPathString); + if (status != ANI_OK) { + ResetErrorIfExists(env); + return nullptr; + } + + ani_string appParamsString {}; + status = env->String_NewUTF8(appParams, interop_strlen(appParams), &appParamsString); + if (status != ANI_OK) { + ResetErrorIfExists(env); + return nullptr; + } + + ani_ref appInstance {}; + status = env->Class_CallStaticMethod_Ref(appClass, create, &appInstance, appUrlString, userPandaFilesPathString, appParamsString, + useNativeLog, static_cast(g_vmEntry.vmKind)); + if (status != ANI_OK) { + LOGE("createApplication returned null"); + ResetErrorIfExists(env); + return nullptr; + } + ani_ref app {}; + status = env->GlobalReference_Create(appInstance, &app); + if (status != ANI_OK) { + ResetErrorIfExists(env); + return nullptr; + } + g_vmEntry.app = (void*)app; + + ani_method start {}; + status = env->Class_FindMethod(appClass, appInfo->startMethodName, appInfo->startMethodSig, &start); + if (status != ANI_OK) { + ResetErrorIfExists(env); + return nullptr; + } + ani_method enter {}; + status = env->Class_FindMethod(appClass, appInfo->enterMethodName, nullptr, &enter); + if (status != ANI_OK) { + LOGE("Cannot find `enter` method %" LOG_PUBLIC "s", appInfo->enterMethodName); + ResetErrorIfExists(env); + return nullptr; + } + g_vmEntry.enter = reinterpret_cast(enter); + ani_method emitEvent {}; + status = env->Class_FindMethod(appClass, appInfo->emitEventMethodName, appInfo->emitEventMethodSig, &emitEvent); + if (status != ANI_OK) { + LOGE("Cannot find `emitEvent` method %" LOG_PUBLIC "s", appInfo->emitEventMethodSig); + ResetErrorIfExists(env); + return nullptr; + } + g_vmEntry.emitEvent = reinterpret_cast(emitEvent); + ani_method loadView {}; + status = env->Class_FindMethod(appClass, appInfo->loadViewMethodName, appInfo->loadViewMethodSig, &loadView); + if (status != ANI_OK) { + LOGE("Cannot find `%" LOG_PUBLIC "s` method %" LOG_PUBLIC "s", + appInfo->loadViewMethodName, appInfo->loadViewMethodSig); + ResetErrorIfExists(env); + return nullptr; + } + g_vmEntry.loadView = reinterpret_cast(loadView); + + if (isTestEnv) { + ani_method restartWith {}; + status = env->Class_FindMethod(appClass, appInfo->restartWithMethodName, appInfo->restartWithMethodSig, &restartWith); + if (status != ANI_OK) { + LOGE("Cannot find `restartWith` method sig=%" LOG_PUBLIC "s", appInfo->restartWithMethodSig); + ResetErrorIfExists(env); + return nullptr; + } + g_vmEntry.restartWith = reinterpret_cast(restartWith); + } + + ani_long ptr = 0; + // Improve: pass app entry point! + status = env->Object_CallMethod_Long(static_cast(appInstance), start, &ptr, + reinterpret_cast(&g_vmEntry.foreignVMContext), loopIterations); + if (status != ANI_OK) { + LOGE("Cannot start application"); + ResetErrorIfExists(env); + return nullptr; + } + return reinterpret_cast(ptr); + } +#endif + +#if defined(KOALA_KOTLIN) + if (g_vmEntry.vmKind == KOTLIN_KIND) { + application_create_t application_create = (application_create_t)g_vmEntry.create; + application_start_t application_start = (application_start_t)g_vmEntry.start; + + kotlin_kref_VMLoaderApplication app = application_create(appUrl, appParams); + g_vmEntry.app = app.pinned; + + kotlin_kref_PeerNodeStub root = application_start(app); + return root.pinned; + } +#endif + + return nullptr; +} + +extern "C" DLL_EXPORT KBoolean RunApplication(const KInt arg0, const KInt arg1) { +#ifdef KOALA_JNI + if (g_vmEntry.vmKind == JAVA_VM_KIND) { + JNIEnv* jEnv = (JNIEnv*)(g_vmEntry.env); + auto result = jEnv->CallBooleanMethod( + (jobject)(g_vmEntry.app), + (jmethodID)(g_vmEntry.enter), + (jint)arg0, + (jint)arg1, + (int64_t)(intptr_t)(&g_vmEntry.foreignVMContext) + ); + if (jEnv->ExceptionCheck()) { + jEnv->ExceptionDescribe(); + jEnv->ExceptionClear(); + } + return result; + } +#endif +#if defined(KOALA_ETS_NAPI) + if (g_vmEntry.vmKind == PANDA_VM_KIND) { + EtsEnv* etsEnv = (EtsEnv*)(g_vmEntry.env); + if (!g_vmEntry.enter) { + LOGE("Cannot find enter method"); + return -1; + } + auto result = etsEnv->CallBooleanMethod( + (ets_object)(g_vmEntry.app), + (ets_method)(g_vmEntry.enter), + (ets_int)arg0, + (ets_int)arg1, + (int64_t)(intptr_t)(&g_vmEntry.foreignVMContext) + ); + if (etsEnv->ErrorCheck()) { + LOGE("Calling enter() method gave an error"); + etsEnv->ErrorDescribe(); + etsEnv->ErrorClear(); + } + return result; + } +#endif +#if defined(KOALA_ANI) + if (g_vmEntry.vmKind == PANDA_ANI_VM_KIND) { + ani_env* env = reinterpret_cast(g_vmEntry.env); + if (g_vmEntry.enter == nullptr) { + LOGE("Cannot find enter method"); + return -1; + } + ani_boolean result = ANI_FALSE; + auto status = env->Object_CallMethod_Boolean(reinterpret_cast(g_vmEntry.app), + reinterpret_cast(g_vmEntry.enter), &result, + static_cast(arg0), static_cast(arg1), + reinterpret_cast(&g_vmEntry.foreignVMContext)); + if (status != ANI_OK) { + ResetErrorIfExists(env); + return ANI_FALSE; + } + return result; + } +#endif + +#ifdef KOALA_KOTLIN + if (g_vmEntry.vmKind == KOTLIN_KIND) { + kotlin_kref_VMLoaderApplication app = { .pinned = g_vmEntry.app }; + application_enter_t application_enter = (application_enter_t)g_vmEntry.enter; + return application_enter(app) ? 1 : 0; + } +#endif + + return 1; +} + +extern "C" DLL_EXPORT const char* EmitEvent(const KInt type, const KInt target, const KInt arg0, const KInt arg1) +{ +#ifdef KOALA_JNI + if (g_vmEntry.vmKind == JAVA_VM_KIND) { + JNIEnv* jEnv = (JNIEnv*)(g_vmEntry.env); + if (!g_vmEntry.emitEvent) { + LOGE("Cannot find emitEvent method"); + return "-1"; + } + auto rv = (jstring)jEnv->CallObjectMethod( + (jobject)(g_vmEntry.app), + (jmethodID)(g_vmEntry.emitEvent), + (jint)type, + (jint)target, + (jint)arg0, + (jint)arg1 + ); + if (jEnv->ExceptionCheck()) { + jEnv->ExceptionDescribe(); + jEnv->ExceptionClear(); + } + const char *result = jEnv->GetStringUTFChars(rv, 0); + return result; + } +#endif + +#if defined(KOALA_ETS_NAPI) + if (g_vmEntry.vmKind == PANDA_VM_KIND) { + EtsEnv* etsEnv = (EtsEnv*)(g_vmEntry.env); + if (!g_vmEntry.emitEvent) { + LOGE("Cannot find emitEvent method"); + return "-1"; + } + auto rv = (ets_string)etsEnv->CallObjectMethod( + (ets_object)(g_vmEntry.app), + (ets_method)(g_vmEntry.emitEvent), + (ets_int)type, + (ets_int)target, + (ets_int)arg0, + (ets_int)arg1 + ); + if (etsEnv->ErrorCheck()) { + LOGE("Calling emitEvent() method gave an error"); + etsEnv->ErrorDescribe(); + etsEnv->ErrorClear(); + } + const char *result = etsEnv->GetStringUTFChars(rv, 0); + return result; + } +#endif +#if defined(KOALA_ANI) + if (g_vmEntry.vmKind == PANDA_ANI_VM_KIND) { + ani_env *env = reinterpret_cast(g_vmEntry.env); + if (g_vmEntry.emitEvent == nullptr) { + LOGE("Cannot find emitEvent method"); + return "-1"; + } + ani_ref result {}; + auto status = env->Object_CallMethod_Ref(reinterpret_cast(g_vmEntry.app), + reinterpret_cast(g_vmEntry.emitEvent), + &result, + static_cast(type), + static_cast(target), + static_cast(arg0), + static_cast(arg1)); + if (status != ANI_OK) { + LOGE("Calling emitEvent() method gave an error"); + ResetErrorIfExists(env); + return "-1"; + } + + auto str = static_cast(result); + ani_size sz = 0; + status = env->String_GetUTF8Size(str, &sz); + if (status != ANI_OK) { + ResetErrorIfExists(env); + return "-1"; + } + auto buffer = new char[sz + 1]; + ani_size writtenChars = 0; + status = env->String_GetUTF8(str, buffer, sz + 1, &writtenChars); + if (status != ANI_OK || writtenChars != sz) { + delete [] buffer; + ResetErrorIfExists(env); + return "-1"; + } + return buffer; + } +#endif + return "-1"; +} + +extern "C" DLL_EXPORT void RestartWith(const char* page) +{ +#ifdef KOALA_JNI + if (g_vmEntry.vmKind == JAVA_VM_KIND) { + JNIEnv* jEnv = (JNIEnv*)(g_vmEntry.env); + if (!g_vmEntry.restartWith) { + LOGE("Cannot find restartWith method"); + return; + } + jEnv->CallVoidMethod( + (jobject)(g_vmEntry.app), + (jmethodID)(g_vmEntry.restartWith), + jEnv->NewStringUTF(page) + ); + if (jEnv->ExceptionCheck()) { + jEnv->ExceptionDescribe(); + jEnv->ExceptionClear(); + } + } +#endif +#if defined(KOALA_ETS_NAPI) + if (g_vmEntry.vmKind == PANDA_VM_KIND) { + EtsEnv* etsEnv = (EtsEnv*)(g_vmEntry.env); + if (!g_vmEntry.restartWith) { + LOGE("Cannot find restartWith method"); + return; + } + etsEnv->CallVoidMethod( + (ets_object)(g_vmEntry.app), + (ets_method)(g_vmEntry.restartWith), + etsEnv->NewStringUTF(page) + ); + if (etsEnv->ErrorCheck()) { + LOGE("Calling restartWith() method gave an error"); + etsEnv->ErrorDescribe(); + etsEnv->ErrorClear(); + } + } +#endif +#if defined(KOALA_ANI) + if (g_vmEntry.vmKind == PANDA_ANI_VM_KIND) { + ani_env *env = reinterpret_cast(g_vmEntry.env); + if (!g_vmEntry.restartWith) { + LOGE("Cannot find restartWith method"); + return; + } + ani_string pageString {}; + auto status = env->String_NewUTF8(page, interop_strlen(page), &pageString); + if (status != ANI_OK) { + ResetErrorIfExists(env); + return; + } + status = env->Object_CallMethod_Void(reinterpret_cast(g_vmEntry.app), + reinterpret_cast(g_vmEntry.restartWith), pageString); + if (status != ANI_OK) { + LOGE("Calling restartWith() method gave an error"); + ResetErrorIfExists(env); + } + } +#endif +} + +extern "C" DLL_EXPORT const char* LoadView(const char* className, const char* params) +{ +#if defined(KOALA_ANI) + if (g_vmEntry.vmKind == PANDA_ANI_VM_KIND) { + ani_env *env = reinterpret_cast(g_vmEntry.env); + if (!g_vmEntry.loadView) { + return strdup("Cannot find loadView() method"); + } + ani_string classNameString {}; + auto status = env->String_NewUTF8(className, interop_strlen(className), &classNameString); + if (status != ANI_OK) { + return strdup("Cannot make ANI string"); + } + ani_string paramsString {}; + status = env->String_NewUTF8(params, interop_strlen(params), ¶msString); + if (status != ANI_OK) { + ResetErrorIfExists(env); + return strdup("Cannot make ANI string"); + } + ani_string resultString = nullptr; + status = env->Object_CallMethod_Ref(reinterpret_cast(g_vmEntry.app), + reinterpret_cast(g_vmEntry.loadView), + (ani_ref*)&resultString, + classNameString, paramsString); + if (status != ANI_OK) { + ResetErrorIfExists(env); + return strdup("Calling laodView() method gave an error"); + } + ani_size resultStringLength = 0; + status = env->String_GetUTF8Size(resultString, &resultStringLength); + char* resultChars = (char*)malloc(resultStringLength); + if (!resultChars) { + return strdup("Cannot allocate memory"); + } + status = env->String_GetUTF8(resultString, resultChars, resultStringLength, &resultStringLength); + return resultChars; + } +#endif + return strdup("Unsupported"); +} + +namespace fs = std::filesystem; + +bool ends_with(std::string str, std::string suffix) +{ + return str.size() >= suffix.size() && str.compare(str.size()-suffix.size(), suffix.size(), suffix) == 0; +} + +void traverseDir(const std::string& root, std::vector& paths, std::string suffix, const std::vector& fallbackPaths) +{ + #ifdef KOALA_OHOS_ARM32 + // selinux prohibits any access to "/system/framework" + if (root == "/system/framework") { + for (auto path: fallbackPaths) { + paths.push_back(root + "/" + path + suffix); + } + return; + } + #endif + + if (!fs::exists(root)) { + LOGE("Cannot open dir %" LOG_PUBLIC "s\n", root.c_str()); + return; + } + + #if defined(KOALA_OHOS) + suffix += ".so"; + #endif + + LOGI("Searching in %" LOG_PUBLIC "s\n", root.c_str()); + for (auto &file : fs::recursive_directory_iterator(root)) { + if (ends_with(file.path().string(), suffix) && fs::is_regular_file(file)) { + paths.push_back(file.path().string()); + } + } +} diff --git a/ets1.2/interop/src/cpp/wasm/convertors-wasm.h b/ets1.2/interop/src/cpp/wasm/convertors-wasm.h new file mode 100644 index 0000000000000000000000000000000000000000..d6a1220f6372c72b7f587dcc7c6f1d27fae599a6 --- /dev/null +++ b/ets1.2/interop/src/cpp/wasm/convertors-wasm.h @@ -0,0 +1,1033 @@ +/* + * 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. + */ + +#ifndef CONVERTORS_WASM_H +#define CONVERTORS_WASM_H + +#include "koala-types.h" + +#include +#define KOALA_INTEROP_EXPORT EMSCRIPTEN_KEEPALIVE extern "C" + +#include "interop-logging.h" + +template +struct InteropTypeConverter { + using InteropType = T; + static T convertFrom(InteropType value) = delete; + static InteropType convertTo(T value) = delete; + static void release(InteropType value, T converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = const uint8_t*; + static KStringPtr convertFrom(InteropType value) { + if (value == nullptr) return KStringPtr(); + KStringPtr result; + int len = (value[0] | (value[1] << 8) | (value[2] << 16) | (value[3] << 24)); + return KStringPtr(value + sizeof(int), len, true); + } + static InteropType convertTo(KStringPtr &value) { + return (InteropType)value.c_str(); + }; +}; + +template<> +struct InteropTypeConverter { + using InteropType = bool; + static KBoolean convertFrom(InteropType value) { return value; } + static InteropType convertTo(KBoolean value) { return value; } + static void release(InteropType value, KBoolean converted) {} +}; + + +template<> +struct InteropTypeConverter { + using InteropType = int; + static KInt convertFrom(InteropType value) { return value; } + static InteropType convertTo(KInt value) { return value; } + static void release(InteropType value, KInt converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = uint32_t; + static KUInt convertFrom(InteropType value) { return value; } + static InteropType convertTo(KUInt value) { return value; } + static void release(InteropType value, KUInt converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = uint8_t; + static KByte convertFrom(InteropType value) { return value; } + static InteropType convertTo(KByte value) { return value; } + static void release(InteropType value, KByte converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = float; + static KFloat convertFrom(InteropType value) { return value; } + static InteropType convertTo(InteropFloat32 value) { return value; } + static void release(InteropType value, KFloat converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = double; + static KDouble convertFrom(InteropType value) { return value; } + static InteropType convertTo(InteropFloat64 value) { return value; } + static void release(InteropType value, KDouble converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = void *; + static KNativePointer convertFrom(InteropType value) { + return reinterpret_cast(value); + } + static InteropType convertTo(KNativePointer value) { + return reinterpret_cast(value); + } + static void release(InteropType value, KNativePointer converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = void **; + static KNativePointerArray convertFrom(InteropType value) { + return reinterpret_cast(value); + } + static InteropType convertTo(KNativePointerArray value) { + return reinterpret_cast(value); + } + static void release(InteropType value, KNativePointerArray converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = long; + static KLong convertFrom(InteropType value) { + return value; + } + static InteropType convertTo(KLong value) { + return value; + } + static void release(InteropType value, KLong converted) {} +}; + +template<> +struct InteropTypeConverter { + using InteropType = uint64_t; + static KULong convertFrom(InteropType value) { + return static_cast(value); + } + static InteropType convertTo(KULong value) { + return static_cast(value); + } + static void release(InteropType value, KULong converted) {} +}; + + +template<> +struct InteropTypeConverter { + using InteropType = int32_t*; + static KInt* convertFrom(InteropType value) { + if (!value) return nullptr; + return value; + } + static InteropType convertTo(KInt* value) = delete; + static void release(InteropType value, KInt* converted) { + if (value) delete value; + } +}; + +template<> +struct InteropTypeConverter { + using InteropType = float*; + static KFloat* convertFrom(InteropType value) { + if (!value) return nullptr; + return value; + } + static InteropType convertTo(KFloat* value) = delete; + static void release(InteropType value, KFloat* converted) { + if (value) delete value; + } +}; + +template<> +struct InteropTypeConverter { + using InteropType = unsigned char *; + static KByte* convertFrom(InteropType value) { + if (!value) return nullptr; + return (KByte*)value; + } + static InteropType convertTo(KByte* value) = delete; + static void release(InteropType value, KByte* converted) { + if (value) delete value; + } +}; + +template<> +struct InteropTypeConverter { + using InteropType = unsigned short *; + static KUShort* convertFrom(InteropType value) { + if (!value) return nullptr; + return (KUShort*)value; + } + static InteropType convertTo(KUShort* value) = delete; + static void release(InteropType value, KUShort* converted) { + if (value) delete value; + } +}; + +template<> +struct InteropTypeConverter { + using InteropType = short *; + static KShort* convertFrom(InteropType value) { + if (!value) return nullptr; + return (KShort*)value; + } + static InteropType convertTo(KShort* value) = delete; + static void release(InteropType value, KShort* converted) { + if (value) delete value; + } +}; + +template<> +struct InteropTypeConverter { + using InteropType = const unsigned char *; + static KStringArray convertFrom(InteropType value) { + if (!value) return nullptr; + return (KStringArray)value; + } + static InteropType convertTo(KStringArray value) = delete; + static void release(InteropType value, KStringArray converted) { + if (value) delete value; + } +}; + +template<> +struct InteropTypeConverter { + using InteropType = long; + static KSerializerBuffer convertFrom(InteropType value) { + return reinterpret_cast(static_cast(value)); + } + static InteropType convertTo(KSerializerBuffer value) = delete; + static void release(InteropType value, KSerializerBuffer converted) {} +}; + +template <> struct InteropTypeConverter { + using InteropType = double; + static KInteropNumber convertFrom(InteropType value) { + return KInteropNumber::fromDouble(value); + } + static InteropType convertTo(KInteropNumber value) { + return value.asDouble(); + } + static void release(InteropType value, KInteropNumber converted) {} +}; + +template +inline Type getArgument(typename InteropTypeConverter::InteropType arg) { + return InteropTypeConverter::convertFrom(arg); +} + +template +inline void releaseArgument(typename InteropTypeConverter::InteropType arg, Type& data) { + InteropTypeConverter::release(arg, data); +} + +template +inline typename InteropTypeConverter::InteropType makeResult(T value) { + return InteropTypeConverter::convertTo(value); +} + +// Improve: Rewrite all others to typed convertors. + +#define KOALA_INTEROP_0(name, Ret) \ +KOALA_INTEROP_EXPORT Ret name() { \ + KOALA_MAYBE_LOG(name) \ + return makeResult(impl_##name()); \ +} + +#define KOALA_INTEROP_1(name, Ret, P0) \ +KOALA_INTEROP_EXPORT Ret name(InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + return makeResult(impl_##name(p0)); \ +} + +#define KOALA_INTEROP_2(name, Ret, P0, P1) \ +KOALA_INTEROP_EXPORT Ret name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + return makeResult(impl_##name(p0, p1)); \ +} + +#define KOALA_INTEROP_3(name, Ret, P0, P1, P2) \ +KOALA_INTEROP_EXPORT Ret name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + return makeResult(impl_##name(p0, p1, p2)); \ +} + +#define KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) \ +KOALA_INTEROP_EXPORT Ret name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + return makeResult(impl_##name(p0, p1, p2, p3)); \ +} + +#define KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) \ +KOALA_INTEROP_EXPORT Ret name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4)); \ +} + +#define KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) \ +KOALA_INTEROP_EXPORT Ret name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5)); \ +} + +#define KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ +KOALA_INTEROP_EXPORT Ret name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6)); \ +} + +#define KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ +KOALA_INTEROP_EXPORT Ret name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7)); \ +} + +#define KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ +KOALA_INTEROP_EXPORT Ret name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8)); \ +} + +#define KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ +KOALA_INTEROP_EXPORT Ret name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)); \ +} + +#define KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ +KOALA_INTEROP_EXPORT Ret name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)); \ +} + +#define KOALA_INTEROP_12(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \ +KOALA_INTEROP_EXPORT Ret name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11)); \ +} + +#define KOALA_INTEROP_13(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \ +KOALA_INTEROP_EXPORT Ret name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + P12 p12 = getArgument(_p12); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12)); \ +} + +#define KOALA_INTEROP_14(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \ +KOALA_INTEROP_EXPORT Ret name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3, \ + InteropTypeConverter::InteropType _p4, \ + InteropTypeConverter::InteropType _p5, \ + InteropTypeConverter::InteropType _p6, \ + InteropTypeConverter::InteropType _p7, \ + InteropTypeConverter::InteropType _p8, \ + InteropTypeConverter::InteropType _p9, \ + InteropTypeConverter::InteropType _p10, \ + InteropTypeConverter::InteropType _p11, \ + InteropTypeConverter::InteropType _p12, \ + InteropTypeConverter::InteropType _p13 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + P12 p12 = getArgument(_p12); \ + P13 p13 = getArgument(_p13); \ + return makeResult(impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13)); \ +} + + + +#define KOALA_INTEROP_V0(name) \ +KOALA_INTEROP_EXPORT void name() { \ + KOALA_MAYBE_LOG(name) \ + impl_##name(); \ + return; \ +} + +#define KOALA_INTEROP_V1(name, P0) \ +KOALA_INTEROP_EXPORT void name(typename InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + impl_##name(p0); \ + return; \ +} + +#define KOALA_INTEROP_V2(name, P0, P1) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + impl_##name(p0, p1); \ + return; \ +} + +#define KOALA_INTEROP_V3(name, P0, P1, P2) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + impl_##name(p0, p1, p2); \ + return; \ +} + +#define KOALA_INTEROP_V4(name, P0, P1, P2, P3) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + impl_##name(p0, p1, p2, p3); \ + return; \ +} + +#define KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + impl_##name(p0, p1, p2, p3, p4); \ + return; \ +} + +#define KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + impl_##name(p0, p1, p2, p3, p4, p5); \ + return; \ +} + +#define KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5, \ + typename InteropTypeConverter::InteropType _p6 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6); \ + return; \ +} + +#define KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5, \ + typename InteropTypeConverter::InteropType _p6, \ + typename InteropTypeConverter::InteropType _p7 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7); \ + return; \ +} + +#define KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5, \ + typename InteropTypeConverter::InteropType _p6, \ + typename InteropTypeConverter::InteropType _p7, \ + typename InteropTypeConverter::InteropType _p8 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8); \ + return; \ +} + +#define KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5, \ + typename InteropTypeConverter::InteropType _p6, \ + typename InteropTypeConverter::InteropType _p7, \ + typename InteropTypeConverter::InteropType _p8, \ + typename InteropTypeConverter::InteropType _p9 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); \ + return; \ +} + +#define KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5, \ + typename InteropTypeConverter::InteropType _p6, \ + typename InteropTypeConverter::InteropType _p7, \ + typename InteropTypeConverter::InteropType _p8, \ + typename InteropTypeConverter::InteropType _p9, \ + typename InteropTypeConverter::InteropType _p10 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10); \ + return; \ +} + +#define KOALA_INTEROP_V12(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5, \ + typename InteropTypeConverter::InteropType _p6, \ + typename InteropTypeConverter::InteropType _p7, \ + typename InteropTypeConverter::InteropType _p8, \ + typename InteropTypeConverter::InteropType _p9, \ + typename InteropTypeConverter::InteropType _p10, \ + typename InteropTypeConverter::InteropType _p11 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11); \ + return; \ +} + +#define KOALA_INTEROP_V13(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5, \ + typename InteropTypeConverter::InteropType _p6, \ + typename InteropTypeConverter::InteropType _p7, \ + typename InteropTypeConverter::InteropType _p8, \ + typename InteropTypeConverter::InteropType _p9, \ + typename InteropTypeConverter::InteropType _p10, \ + typename InteropTypeConverter::InteropType _p11, \ + typename InteropTypeConverter::InteropType _p12 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + P12 p12 = getArgument(_p12); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12); \ + return; \ +} + +#define KOALA_INTEROP_V14(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13) \ +KOALA_INTEROP_EXPORT void name( \ + typename InteropTypeConverter::InteropType _p0, \ + typename InteropTypeConverter::InteropType _p1, \ + typename InteropTypeConverter::InteropType _p2, \ + typename InteropTypeConverter::InteropType _p3, \ + typename InteropTypeConverter::InteropType _p4, \ + typename InteropTypeConverter::InteropType _p5, \ + typename InteropTypeConverter::InteropType _p6, \ + typename InteropTypeConverter::InteropType _p7, \ + typename InteropTypeConverter::InteropType _p8, \ + typename InteropTypeConverter::InteropType _p9, \ + typename InteropTypeConverter::InteropType _p10, \ + typename InteropTypeConverter::InteropType _p11, \ + typename InteropTypeConverter::InteropType _p12, \ + typename InteropTypeConverter::InteropType _p13 \ +) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + P4 p4 = getArgument(_p4); \ + P5 p5 = getArgument(_p5); \ + P6 p6 = getArgument(_p6); \ + P7 p7 = getArgument(_p7); \ + P8 p8 = getArgument(_p8); \ + P9 p9 = getArgument(_p9); \ + P10 p10 = getArgument(_p10); \ + P11 p11 = getArgument(_p11); \ + P12 p12 = getArgument(_p12); \ + P13 p13 = getArgument(_p13); \ + impl_##name(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13); \ + return; \ +} + +#define KOALA_INTEROP_CTX_1(name, Ret, P0) \ +KOALA_INTEROP_EXPORT Ret name(InteropTypeConverter::InteropType _p0) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + return makeResult(impl_##name(nullptr, p0)); \ +} + +#define KOALA_INTEROP_CTX_2(name, Ret, P0, P1) \ +KOALA_INTEROP_EXPORT Ret name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + return makeResult(impl_##name(nullptr, p0, p1)); \ +} + +#define KOALA_INTEROP_CTX_3(name, Ret, P0, P1, P2) \ +KOALA_INTEROP_EXPORT Ret name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + return makeResult(impl_##name(nullptr, p0, p1, p2)); \ +} + +#define KOALA_INTEROP_CTX_4(name, Ret, P0, P1, P2, P3) \ +KOALA_INTEROP_EXPORT Ret name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + return makeResult(impl_##name(nullptr, p0, p1, p2, p3)); \ +} + +#define KOALA_INTEROP_CTX_V3(name, P0, P1, P2) \ +KOALA_INTEROP_EXPORT void name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + impl_##name(nullptr, p0, p1, p2); \ +} + +#define KOALA_INTEROP_CTX_V4(name, P0, P1, P2, P3) \ +KOALA_INTEROP_EXPORT void name( \ + InteropTypeConverter::InteropType _p0, \ + InteropTypeConverter::InteropType _p1, \ + InteropTypeConverter::InteropType _p2, \ + InteropTypeConverter::InteropType _p3) { \ + KOALA_MAYBE_LOG(name) \ + P0 p0 = getArgument(_p0); \ + P1 p1 = getArgument(_p1); \ + P2 p2 = getArgument(_p2); \ + P3 p3 = getArgument(_p3); \ + impl_##name(nullptr, p0, p1, p2, p3); \ +} + +#define KOALA_INTEROP_DIRECT_0(name, Ret) \ + KOALA_INTEROP_0(name, Ret) +#define KOALA_INTEROP_DIRECT_1(name, Ret, P0) \ + KOALA_INTEROP_1(name, Ret, P0) +#define KOALA_INTEROP_DIRECT_2(name, Ret, P0, P1) \ + KOALA_INTEROP_2(name, Ret, P0, P1) +#define KOALA_INTEROP_DIRECT_3(name, Ret, P0, P1, P2) \ + KOALA_INTEROP_3(name, Ret, P0, P1, P2) +#define KOALA_INTEROP_DIRECT_4(name, Ret, P0, P1, P2, P3) \ + KOALA_INTEROP_4(name, Ret, P0, P1, P2, P3) +#define KOALA_INTEROP_DIRECT_5(name, Ret, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_5(name, Ret, P0, P1, P2, P3, P4) +#define KOALA_INTEROP_DIRECT_6(name, Ret, P0, P1, P2, P3, P4, P5) \ + KOALA_INTEROP_6(name, Ret, P0, P1, P2, P3, P4, P5) +#define KOALA_INTEROP_DIRECT_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_INTEROP_7(name, Ret, P0, P1, P2, P3, P4, P5, P6) +#define KOALA_INTEROP_DIRECT_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_INTEROP_8(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7) +#define KOALA_INTEROP_DIRECT_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_INTEROP_9(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8) +#define KOALA_INTEROP_DIRECT_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_INTEROP_10(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) +#define KOALA_INTEROP_DIRECT_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_INTEROP_11(name, Ret, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) +#define KOALA_INTEROP_DIRECT_V0(name) \ + KOALA_INTEROP_V0(name) +#define KOALA_INTEROP_DIRECT_V1(name, P0) \ + KOALA_INTEROP_V1(name, P0) +#define KOALA_INTEROP_DIRECT_V2(name, P0, P1) \ + KOALA_INTEROP_V2(name, P0, P1) +#define KOALA_INTEROP_DIRECT_V3(name, P0, P1, P2) \ + KOALA_INTEROP_V3(name, P0, P1, P2) +#define KOALA_INTEROP_DIRECT_V4(name, P0, P1, P2, P3) \ + KOALA_INTEROP_V4(name, P0, P1, P2, P3) +#define KOALA_INTEROP_DIRECT_V5(name, P0, P1, P2, P3, P4) \ + KOALA_INTEROP_V5(name, P0, P1, P2, P3, P4) +#define KOALA_INTEROP_DIRECT_V6(name, P0, P1, P2, P3, P4, P5) \ + KOALA_INTEROP_V6(name, P0, P1, P2, P3, P4, P5) +#define KOALA_INTEROP_DIRECT_V7(name, P0, P1, P2, P3, P4, P5, P6) \ + KOALA_INTEROP_V7(name, P0, P1, P2, P3, P4, P5, P6) +#define KOALA_INTEROP_DIRECT_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) \ + KOALA_INTEROP_V8(name, P0, P1, P2, P3, P4, P5, P6, P7) +#define KOALA_INTEROP_DIRECT_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) \ + KOALA_INTEROP_V9(name, P0, P1, P2, P3, P4, P5, P6, P7, P8) +#define KOALA_INTEROP_DIRECT_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) \ + KOALA_INTEROP_V10(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) +#define KOALA_INTEROP_DIRECT_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) \ + KOALA_INTEROP_V11(name, P0, P1, P2, P3, P4, P5, P6, P7, P8, P9, P10) + +#define KOALA_INTEROP_THROW(vmContext, object, ...) \ + do { \ + ASSERT(false); /* Improve: implement*/ \ + return __VA_ARGS__; \ + } while (0) + +#define KOALA_INTEROP_THROW_STRING(vmContext, message, ...) \ + do { \ + ASSERT(false); /* Improve: implement*/ \ + return __VA_ARGS__; \ + } while (0) + +#endif // CONVERTORS_WASM_H \ No newline at end of file diff --git a/ets1.2/interop/src/interop/DeserializerBase.ts b/ets1.2/interop/src/interop/DeserializerBase.ts new file mode 100644 index 0000000000000000000000000000000000000000..675299b3b0436a0ecc27cee5645a56421b7ab4f1 --- /dev/null +++ b/ets1.2/interop/src/interop/DeserializerBase.ts @@ -0,0 +1,242 @@ +/* + * Copyright (c) 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 { CustomTextDecoder, float32, float64, int32, int64 } from "@koalaui/common" +import { Tags, CallbackResource } from "./SerializerBase"; +import { pointer, KUint8ArrayPtr, KSerializerBuffer } from "./InteropTypes" +import { NativeBuffer } from "./NativeBuffer"; +import { ResourceHolder } from "../arkts/ResourceManager"; +import { InteropNativeModule } from "./InteropNativeModule"; + +export class DeserializerBase { + private position = 0 + private readonly buffer: ArrayBuffer + private readonly length: int32 + private view: DataView + private static textDecoder = new CustomTextDecoder() + private static customDeserializers: CustomDeserializer | undefined = undefined + + static registerCustomDeserializer(deserializer: CustomDeserializer) { + let current = DeserializerBase.customDeserializers + if (current == undefined) { + DeserializerBase.customDeserializers = deserializer + } else { + while (current.next != undefined) { + current = current.next + } + current.next = deserializer + } + } + + constructor(buffer: ArrayBuffer|KSerializerBuffer|KUint8ArrayPtr, length: int32) { + if (typeof buffer != 'object') + throw new Error('Must be used only with ArrayBuffer') + if (buffer && ("buffer" in buffer)) { + buffer = buffer.buffer as ArrayBuffer + } + this.buffer = buffer as ArrayBuffer + this.length = length + this.view = new DataView(this.buffer) + } + + static get( + factory: (args: Uint8Array, length: int32) => T, + args: Uint8Array, length: int32): T { + + // Improve: Use cache + return factory(args, length); + } + + asBuffer(position?: int32, length?: int32): KSerializerBuffer { + return new Uint8Array(this.buffer, position, length) + } + + asArray(position?: int32, length?: int32): Uint8Array { + return new Uint8Array(this.buffer, position, length) + } + + currentPosition(): int32 { + return this.position + } + + resetCurrentPosition(): void { + this.position = 0 + } + + private checkCapacity(value: int32) { + if (value > this.length) { + throw new Error(`${value} is less than remaining buffer length`) + } + } + + readInt8(): int32 { + this.checkCapacity(1) + const value = this.view.getInt8(this.position) + this.position += 1 + return value + } + + readInt32(): int32 { + this.checkCapacity(4) + const value = this.view.getInt32(this.position, true) + this.position += 4 + return value + } + + readInt64(): int64 { + this.checkCapacity(8) + const value = this.view.getBigInt64(this.position, true) + this.position += 8 + return Number(value) + } + + readPointer(): pointer { + this.checkCapacity(8) + const value = this.view.getBigInt64(this.position, true) + this.position += 8 + return value + } + + readFloat32(): float32 { + this.checkCapacity(4) + const value = this.view.getFloat32(this.position, true) + this.position += 4 + return value + } + + readFloat64(): float64 { + this.checkCapacity(8) + const value = this.view.getFloat64(this.position, true) + this.position += 8 + return value + } + + readBoolean(): boolean { + this.checkCapacity(1) + const value = this.view.getInt8(this.position) + this.position += 1 + return value == 1 + } + + readFunction(): any { + // Improve: not exactly correct. + const id = this.readInt32() + return id + } + + readMaterialized(): object { + const ptr = this.readPointer() + return { ptr: ptr } + } + + readString(): string { + const length = this.readInt32() + this.checkCapacity(length) + // read without null-terminated byte + const value = DeserializerBase.textDecoder.decode(this.asArray(this.position, length - 1)); + this.position += length + return value + } + + readCustomObject(kind: string): any { + let current = DeserializerBase.customDeserializers + while (current) { + if (current.supports(kind)) { + return current.deserialize(this, kind) + } + current = current.next + } + // consume tag + const tag = this.readInt8() + return undefined + } + + readNumber(): int32 | undefined { + const tag = this.readInt8() + switch (tag) { + case Tags.UNDEFINED: + return undefined; + case Tags.INT32: + return this.readInt32() + case Tags.FLOAT32: + return this.readFloat32() + default: + throw new Error(`Unknown number tag: ${tag}`) + break + } + } + + readCallbackResource(): CallbackResource { + return { + resourceId: this.readInt32(), + hold: this.readPointer(), + release: this.readPointer(), + } + } + readObject():any { + const resource = this.readCallbackResource() + return ResourceHolder.instance().get(resource.resourceId) + } + + static lengthUnitFromInt(unit: int32): string { + let suffix: string + switch (unit) { + case 0: + suffix = "px" + break + case 1: + suffix = "vp" + break + case 3: + suffix = "%" + break + case 4: + suffix = "lpx" + break + default: + suffix = "" + } + return suffix + } + readBuffer(): ArrayBuffer { + const resource = this.readCallbackResource() + const data = this.readPointer() + const length = this.readInt64() + return InteropNativeModule._MaterializeBuffer(data, BigInt(length), resource.resourceId, resource.hold, resource.release) + } +} + +export abstract class CustomDeserializer { + protected constructor(protected supported: Array) { + } + + supports(kind: string): boolean { + return this.supported.includes(kind) + } + + abstract deserialize(serializer: DeserializerBase, kind: string): any + + next: CustomDeserializer | undefined = undefined +} + +class DateDeserializer extends CustomDeserializer { + constructor() { + super(["Date"]); + } + + deserialize(serializer: DeserializerBase, kind: string): any { + return new Date(serializer.readString()) + } +} +DeserializerBase.registerCustomDeserializer(new DateDeserializer()) diff --git a/ets1.2/interop/src/interop/Finalizable.ts b/ets1.2/interop/src/interop/Finalizable.ts new file mode 100644 index 0000000000000000000000000000000000000000..4fd12c9da41d3b67d27dce1fcb9952427aac3a68 --- /dev/null +++ b/ets1.2/interop/src/interop/Finalizable.ts @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { Wrapper, nullptr } from "./Wrapper" +import { finalizerRegister, finalizerUnregister, Thunk } from "@koalaui/common" +import { InteropNativeModule } from "./InteropNativeModule" +import { pointer } from "./InteropTypes" + +export class NativeThunk implements Thunk { + finalizer: pointer + obj: pointer + name: string|undefined + + constructor(obj: pointer, finalizer: pointer, name?: string) { + this.finalizer = finalizer + this.obj = obj + this.name = name + } + + clean() { + if (this.obj != nullptr) { + this.destroyNative(this.obj, this.finalizer) + } + this.obj = nullptr + } + + destroyNative(ptr: pointer, finalizer: pointer): void { + InteropNativeModule._InvokeFinalizer(ptr, finalizer) + } +} + +/** + * Class with the custom finalizer, usually used to release a native peer. + * Do not use directly, only via subclasses. + */ +export class Finalizable extends Wrapper { + finalizer: pointer + cleaner?: NativeThunk = undefined + managed: boolean + constructor(ptr: pointer, finalizer: pointer, managed: boolean = true) { + super(ptr) + this.finalizer = finalizer + this.managed = managed + const handle = this.createHandle() + + if (this.managed) { + // Improve: reenable exception. + if (this.ptr == nullptr) return // throw new Error("Can't have nullptr ptr ${}") + if (this.finalizer == nullptr) throw new Error("Managed finalizer is 0") + + const thunk = this.makeNativeThunk(ptr, finalizer, handle) + finalizerRegister(this, thunk) + this.cleaner = thunk + } + } + + createHandle(): string | undefined { + return undefined + } + + makeNativeThunk(ptr: pointer, finalizer: pointer, handle: string | undefined): NativeThunk { + return new NativeThunk(ptr, finalizer, handle) + } + + close() { + if (this.ptr == nullptr) { + throw new Error(`Closing a closed object: ` + this.toString()) + } else if (this.cleaner == null) { + throw new Error(`No thunk assigned to ` + this.toString()) + } else { + finalizerUnregister(this) + this.cleaner.clean() + this.cleaner = undefined + this.ptr = nullptr + } + } + + release(): pointer { + finalizerUnregister(this) + if (this.cleaner) + this.cleaner.obj = nullptr + let result = this.ptr + this.ptr = nullptr + return result + } + + resetPeer(pointer: pointer) { + if (this.managed) throw new Error("Can only reset peer for an unmanaged object") + this.ptr = pointer + } + + use(body: (value: Finalizable) => R): R { + let result = body(this) + this.close() + return result + } +} diff --git a/ets1.2/interop/src/interop/InteropNativeModule.ts b/ets1.2/interop/src/interop/InteropNativeModule.ts new file mode 100644 index 0000000000000000000000000000000000000000..0b5fe6119dd8fdc09cf16fef88cc88c4ce7c71ff --- /dev/null +++ b/ets1.2/interop/src/interop/InteropNativeModule.ts @@ -0,0 +1,68 @@ +/* + * Copyright (c) 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 { int32, int64 } from "@koalaui/common"; +import { KPointer, KSerializerBuffer, KStringPtr, KUint8ArrayPtr } from "./InteropTypes"; +import { loadNativeModuleLibrary } from "./loadLibraries"; + +export class InteropNativeModule { + public static _SetCallbackDispatcher(dispatcher: (id: int32, args: Uint8Array, length: int32) => int32): void { throw "method not loaded" } + public static _CleanCallbackDispatcher(): void { throw "method not loaded" } + + public static _GetGroupedLog(index: int32): KPointer { throw "method not loaded" } + public static _StartGroupedLog(index: int32): void { throw "method not loaded" } + public static _StopGroupedLog(index: int32): void { throw "method not loaded" } + public static _AppendGroupedLog(index: int32, message: string): void { throw "method not loaded" } + public static _PrintGroupedLog(index: int32): void { throw "method not loaded" } + public static _GetStringFinalizer(): KPointer { throw "method not loaded" } + public static _IncrementNumber(value: number): number { throw "method not loaded" } + public static _InvokeFinalizer(ptr1: KPointer, ptr2: KPointer): void { throw "method not loaded" } + public static _GetPtrVectorElement(ptr1: KPointer, arg: int32): KPointer { throw "method not loaded" } + public static _StringLength(ptr1: KPointer): int32 { throw "method not loaded" } + public static _StringData(ptr1: KPointer, array: KUint8ArrayPtr, arrayLength: int32): void { throw "method not loaded" } + public static _StringMake(str1: KStringPtr): KPointer { throw "method not loaded" } + public static _GetPtrVectorSize(ptr1: KPointer): int32 { throw "method not loaded" } + public static _ManagedStringWrite(str1: string, array: Uint8Array, arrayLength: int32, arg: int32): int32 { throw "method not loaded" } + public static _NativeLog(str1: string): void { throw "method not loaded" } + public static _Utf8ToString(data: KSerializerBuffer, offset: int32, length: int32): string { throw "method not loaded" } + public static _StdStringToString(cstring: KPointer): string { throw "method not loaded" } + public static _CheckCallbackEvent(buffer: KSerializerBuffer, bufferLength: int32): int32 { throw "method not loaded" } + public static _HoldCallbackResource(resourceId: int32): void { throw "method not loaded" } + public static _ReleaseCallbackResource(resourceId: int32): void { throw "method not loaded" } + public static _CallCallback(apiKind: int32, callbackKind: int32, args: KSerializerBuffer, argsSize: int32): void { throw "method not loaded" } + public static _CallCallbackSync(apiKind: int32, callbackKind: int32, args: KSerializerBuffer, argsSize: int32): void { throw "method not loaded" } + public static _CallCallbackResourceHolder(holder: KPointer, resourceId: int32): void { throw "method not loaded" } + public static _CallCallbackResourceReleaser(releaser: KPointer, resourceId: int32): void { throw "method not loaded" } + public static _CallbackAwait(pipeline: KPointer): Object { throw "method not loaded" } + public static _UnblockCallbackWait(pipeline: KPointer): void { throw "method not loaded" } + public static _MaterializeBuffer(data: KPointer, length: bigint, resourceId: int32, hold: KPointer, release: KPointer): ArrayBuffer { throw "method not loaded" } + public static _GetNativeBufferPointer(data: ArrayBuffer): KPointer { throw "method not loaded" } + + public static _LoadVirtualMachine(arg0: int32, arg1: string, arg2: string, arg3: string): int32 { throw "method not loaded" } + public static _RunApplication(arg0: int32, arg1: int32): number { throw "method not loaded" } + public static _StartApplication(appUrl: string, appParams: string): KPointer { throw "method not loaded" } + public static _EmitEvent(eventType: int32, target: int32, arg0: int32, arg1: int32): string { throw "method not loaded" } + public static _CallForeignVM(foreignContext: KPointer, kind: int32, args: KSerializerBuffer, argsSize: int32): int32 { throw "method not loaded" } + public static _SetForeignVMContext(context: KPointer): void { throw "method not loaded" } + public static _Malloc(length: int64): KPointer { throw "method not loaded" } + public static _GetMallocFinalizer(): KPointer { throw "method not loaded" } + public static _ReadByte(data: KPointer, index: int32, length: bigint): int32 { throw "method not loaded" } + public static _WriteByte(data: KPointer, index: int32, length: bigint, value: int32): void { throw "method not loaded" } + public static _CopyArray(data: KPointer, length: int64, args: KUint8ArrayPtr): void { throw "method not loaded" } +} + +export function loadInteropNativeModule() { + loadNativeModuleLibrary("InteropNativeModule", InteropNativeModule) +} \ No newline at end of file diff --git a/ets1.2/interop/src/interop/InteropOps.ts b/ets1.2/interop/src/interop/InteropOps.ts new file mode 100644 index 0000000000000000000000000000000000000000..41c956408386bd50fb9c80a1fa2a6b5a7b9e2b16 --- /dev/null +++ b/ets1.2/interop/src/interop/InteropOps.ts @@ -0,0 +1,88 @@ +/* + * Copyright (c) 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 { int32 } from "@koalaui/common" +import { withStringResult } from "./Platform" +import { KInt, KStringPtr, KUint8ArrayPtr, pointer } from "./InteropTypes" + +export type CallbackType = (args: Uint8Array, length: int32) => int32 + +class CallbackRecord { + constructor( + public readonly callback: CallbackType, + public readonly autoDisposable: boolean + ) { } +} + +class CallbackRegistry { + + static INSTANCE = new CallbackRegistry() + + private callbacks = new Map() + private id = 1024 + + constructor() { + this.callbacks.set(0, new CallbackRecord( + (args: Uint8Array, length: int32): int32 => { + console.log(`Callback 0 called with args = ${args} and length = ${length}`) + throw new Error(`Null callback called`) + }, false) + ) + } + + wrap(callback: CallbackType, autoDisposable: boolean): int32 { + const id = this.id++ + this.callbacks.set(id, new CallbackRecord(callback, autoDisposable)) + return id + } + + wrapSystem(id: number, callback: CallbackType, autoDisposable: boolean): int32 { + this.callbacks.set(id, new CallbackRecord(callback, autoDisposable)) + return id + } + + call(id: int32, args: Uint8Array, length: int32): int32 { + const record = this.callbacks.get(id) + if (!record) { + console.log(`Callback ${id} is not known`) + // throw new Error(`Disposed or unwrapped callback called (id = ${id})`) + return 0; // Improve: + } + if (record.autoDisposable) { + this.dispose(id) + } + return record.callback(args, length) + } + + dispose(id: int32) { + this.callbacks.delete(id) + } +} + +export function wrapCallback(callback: CallbackType, autoDisposable: boolean = true): int32 { + return CallbackRegistry.INSTANCE.wrap(callback, autoDisposable) +} + +export function wrapSystemCallback(id:number, callback: CallbackType): int32 { + return CallbackRegistry.INSTANCE.wrapSystem(id, callback, false) +} + +export function disposeCallback(id: int32) { + CallbackRegistry.INSTANCE.dispose(id) +} + +export function callCallback(id: int32, args: Uint8Array, length: int32): int32 { + return CallbackRegistry.INSTANCE.call(id, args, length) +} diff --git a/ets1.2/interop/src/interop/InteropTypes.ts b/ets1.2/interop/src/interop/InteropTypes.ts new file mode 100644 index 0000000000000000000000000000000000000000..0aaa80bd75648b71c171e7a80491f48693c1e17c --- /dev/null +++ b/ets1.2/interop/src/interop/InteropTypes.ts @@ -0,0 +1,32 @@ +/* + * Copyright (c) 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 { int32, int64, float32, float64 } from "@koalaui/common" + +export type KStringPtr = int32 | string | null +export type KStringArrayPtr = int32 | Uint8Array | null +export type KInt32ArrayPtr = int32 | Int32Array | null +export type KFloat32ArrayPtr = int32 | Float32Array | null +export type KUint8ArrayPtr = int32 | Uint8Array | null +export type KInt = int32 +export type KUInt = int32 +export type KLong = int64 +export type KFloat = float32 +export type KDouble = float64 +export type KBoolean = int32 +export type KPointer = number | bigint +export type pointer = KPointer +export type KNativePointer = KPointer +export type KInteropReturnBuffer = Uint8Array +export type KSerializerBuffer = KUint8ArrayPtr \ No newline at end of file diff --git a/ets1.2/interop/src/interop/MaterializedBase.ts b/ets1.2/interop/src/interop/MaterializedBase.ts new file mode 100644 index 0000000000000000000000000000000000000000..51135fbaa7beee1e31f48d30b9eebc69c5fa45eb --- /dev/null +++ b/ets1.2/interop/src/interop/MaterializedBase.ts @@ -0,0 +1,20 @@ +/* + * Copyright (c) 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 { Finalizable } from "./Finalizable" + +export interface MaterializedBase { + getPeer(): Finalizable | undefined +} diff --git a/ets1.2/interop/src/interop/NativeBuffer.ts b/ets1.2/interop/src/interop/NativeBuffer.ts new file mode 100644 index 0000000000000000000000000000000000000000..47ded574783d48a6b88b4f5552cde24903f75039 --- /dev/null +++ b/ets1.2/interop/src/interop/NativeBuffer.ts @@ -0,0 +1,56 @@ +/* + * Copyright (c) 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 { pointer } from './InteropTypes' +import { int32, int64 } from '@koalaui/common' +import { InteropNativeModule } from "./InteropNativeModule" +import { Finalizable } from './Finalizable' + +// stub wrapper for KInteropBuffer +// export type NativeBuffer = ArrayBuffer + +export class NativeBuffer { + public data: pointer + public length: int64 + protected finalizable: Finalizable + + constructor(length: int64) + constructor(data: pointer, length: int64, destroy: pointer) + constructor(dataOrLength: pointer | int64, length_?: int64, destroy_?: pointer) { + let data: pointer + let length: int64 + let destroy: pointer + if (length_ === undefined) { + length = dataOrLength as int64 + data = InteropNativeModule._Malloc(length) + destroy = InteropNativeModule._GetMallocFinalizer() + } else { + data = dataOrLength as pointer + length = length_ as int64 + destroy = destroy_ as pointer + } + this.data = data + this.length = length + this.finalizable = new Finalizable(data, destroy) + } + + public readByte(index: int64): int32 { + return InteropNativeModule._ReadByte(this.data, index, BigInt(this.length)) + } + + public writeByte(index: int64, value: int32): void { + InteropNativeModule._WriteByte(this.data, index, BigInt(this.length), value) + } +} \ No newline at end of file diff --git a/ets1.2/interop/src/interop/NativeString.ts b/ets1.2/interop/src/interop/NativeString.ts new file mode 100644 index 0000000000000000000000000000000000000000..3e7affc5638f3d9da1a4ccbe044c0b8482630d80 --- /dev/null +++ b/ets1.2/interop/src/interop/NativeString.ts @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { Finalizable } from "./Finalizable" +import { InteropNativeModule } from "./InteropNativeModule" +import { pointer } from "./InteropTypes" + +export class NativeString extends Finalizable { + constructor(ptr: pointer) { + super(ptr, InteropNativeModule._GetStringFinalizer()) + } + static Make(value: string): NativeString { + return new NativeString(InteropNativeModule._StringMake(value)) + } + toString(): string { + return InteropNativeModule._StdStringToString(this.ptr) + } +} diff --git a/ets1.2/interop/src/interop/Platform.ts b/ets1.2/interop/src/interop/Platform.ts new file mode 100644 index 0000000000000000000000000000000000000000..ff2f7fd66a8004605f1fa41209daddc118562666 --- /dev/null +++ b/ets1.2/interop/src/interop/Platform.ts @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { int32 } from "@koalaui/common" +import { isNullPtr, nullptr, Wrapper } from "./Wrapper" +import { decodeToString } from "#common/wrappers/arrays" +import { setCallbackRegistry } from "#common/wrappers/Callback" +import { KPointer } from "./InteropTypes" + +export abstract class NativeStringBase extends Wrapper { + constructor(ptr: KPointer) { + super(ptr) + } + + protected abstract bytesLength(): int32 + protected abstract getData(data: Uint8Array): void + + toString(): string { + let length = this.bytesLength() + let data = new Uint8Array(length) + this.getData(data) + return decodeToString(data) + } + + abstract close(): void +} + +export abstract class ArrayDecoder { + abstract getArraySize(blob: KPointer): int32 + abstract disposeArray(blob: KPointer): void + abstract getArrayElement(blob: KPointer, index: int32): T + + decode(blob: KPointer): Array { + const size = this.getArraySize(blob) + const result = new Array(size) + for (let index = 0; index < size; index++) { + result[index] = this.getArrayElement(blob, index) + } + this.disposeArray(blob) + return result + } +} + + +// Improve: the semicolons after methods in these interfaces are to +// workaround ArkTS compiler parser bug +export interface CallbackRegistry { + registerCallback(callback: any, obj: any): KPointer; +} + +export interface PlatformDefinedData { + nativeString(ptr: KPointer): NativeStringBase; + nativeStringArrayDecoder(): ArrayDecoder; + callbackRegistry(): CallbackRegistry | undefined; +} + +let platformData: PlatformDefinedData|undefined = undefined + +export function providePlatformDefinedData(platformDataParam: PlatformDefinedData) { + platformData = platformDataParam + let registry = platformDataParam.callbackRegistry() + if (registry) setCallbackRegistry(registry) +} + +export function withStringResult(ptr: KPointer): string|undefined { + if (isNullPtr(ptr)) return undefined + let managedString = platformData!.nativeString(ptr) + let result = managedString?.toString() + managedString?.close() + return result +} + +export function withStringArrayResult(ptr: KPointer): Array { + if (ptr == nullptr) return new Array() + let managedStringArray = platformData!.nativeStringArrayDecoder().decode(ptr) + return managedStringArray.map((nativeString:NativeStringBase) => nativeString.toString()) +} diff --git a/ets1.2/interop/src/interop/SerializerBase.ts b/ets1.2/interop/src/interop/SerializerBase.ts new file mode 100644 index 0000000000000000000000000000000000000000..aa80556045253908148675517fe4959a646b615c --- /dev/null +++ b/ets1.2/interop/src/interop/SerializerBase.ts @@ -0,0 +1,331 @@ +/* + * Copyright (c) 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 { float32, float64, int32, int64 } from "@koalaui/common" +import { pointer, KPointer, KSerializerBuffer } from "./InteropTypes" +import { wrapCallback } from "./InteropOps" +import { InteropNativeModule } from "./InteropNativeModule" +import { ResourceHolder, ResourceId } from "../arkts/ResourceManager" +import { MaterializedBase } from "./MaterializedBase" +import { nullptr } from "./Wrapper" +import { NativeBuffer } from "./NativeBuffer" + +// imports required interfaces (now generation is disabled) +// import { Resource } from "@arkoala/arkui" +/** + * Value representing possible JS runtime object type. + * Must be synced with "enum RuntimeType" in C++. + */ +export enum RuntimeType { + UNEXPECTED = -1, + NUMBER = 1, + STRING = 2, + OBJECT = 3, + BOOLEAN = 4, + UNDEFINED = 5, + BIGINT = 6, + FUNCTION = 7, + SYMBOL = 8, + MATERIALIZED = 9, +} + +/** + * Value representing object type in serialized data. + * Must be synced with "enum Tags" in C++. + */ +export enum Tags { + UNDEFINED = 101, + INT32 = 102, + FLOAT32 = 103, + STRING = 104, + LENGTH = 105, + RESOURCE = 106, + OBJECT = 107, +} + +export function runtimeType(value: any): int32 { + let type = typeof value + if (type == "number") return RuntimeType.NUMBER + if (type == "string") return RuntimeType.STRING + if (type == "undefined") return RuntimeType.UNDEFINED + if (type == "object") return RuntimeType.OBJECT + if (type == "boolean") return RuntimeType.BOOLEAN + if (type == "bigint") return RuntimeType.BIGINT + if (type == "function") return RuntimeType.FUNCTION + if (type == "symbol") return RuntimeType.SYMBOL + + throw new Error(`bug: ${value} is ${type}`) +} + +// Poor man's instanceof, fails on subclasses +export function isInstanceOf(className: string, value: object | undefined): boolean { + return value?.constructor.name === className +} + +export function registerCallback(value: object|undefined): int32 { + return wrapCallback((args: Uint8Array, length: int32) => { + // Improve: deserialize the callback arguments and call the callback + return 42 + }) +} + +export function toPeerPtr(value: object): KPointer { + if (value.hasOwnProperty("peer")) + return unsafeCast(value).getPeer()?.ptr ?? nullptr + else + throw new Error("Value is not a MaterializedBase instance") +} + +export interface CallbackResource { + resourceId: int32 + hold: pointer + release: pointer +} + +/* Serialization extension point */ +export abstract class CustomSerializer { + constructor(protected supported: Array) {} + supports(kind: string): boolean { return this.supported.includes(kind) } + abstract serialize(serializer: SerializerBase, value: any, kind: string): void + next: CustomSerializer | undefined = undefined +} + +export class SerializerBase { + private position = 0 + private buffer: ArrayBuffer + private view: DataView + + private static pool: SerializerBase[] = [ + new SerializerBase(), + new SerializerBase(), + new SerializerBase(), + new SerializerBase(), + new SerializerBase(), + new SerializerBase(), + new SerializerBase(), + new SerializerBase(), + ] + private static poolTop = 0 + + static hold(): SerializerBase { + if (this.poolTop === this.pool.length) { + throw new Error("Pool empty! Release one of taken serializers") + } + return SerializerBase.pool[this.poolTop++] + } + + private static customSerializers: CustomSerializer | undefined = undefined + static registerCustomSerializer(serializer: CustomSerializer) { + if (SerializerBase.customSerializers == undefined) { + SerializerBase.customSerializers = serializer + } else { + let current = SerializerBase.customSerializers + while (current.next != undefined) { current = current.next } + current.next = serializer + } + } + constructor() { + this.buffer = new ArrayBuffer(96) + this.view = new DataView(this.buffer) + } + public release() { + this.releaseResources() + this.position = 0 + if (this !== SerializerBase.pool[SerializerBase.poolTop - 1]) { + throw new Error("Serializers should be release in LIFO order") + } + SerializerBase.poolTop -= 1; + } + asBuffer(): KSerializerBuffer { + return new Uint8Array(this.buffer) + } + length(): int32 { + return this.position + } + getByte(offset: int32): int32 { + return this.view.getUint8(offset) as int32 + } + toArray(): Uint8Array { + return new Uint8Array(this.buffer.slice(0, this.currentPosition())) + } + currentPosition(): int32 { return this.position } + + private checkCapacity(value: int32) { + if (value < 1) { + throw new Error(`${value} is less than 1`) + } + let buffSize = this.buffer.byteLength + if (this.position > buffSize - value) { + const minSize = this.position + value + const resizedSize = Math.max(minSize, Math.round(3 * buffSize / 2)) + let resizedBuffer = new ArrayBuffer(resizedSize) + // Improve: can we grow without new? + // Improve: check the status of ArrayBuffer.transfer function implementation in STS + new Uint8Array(resizedBuffer).set(new Uint8Array(this.buffer)) + this.buffer = resizedBuffer + this.view = new DataView(resizedBuffer) + } + } + private heldResources: ResourceId[] = [] + holdAndWriteCallback(callback: object, hold: KPointer = 0, release: KPointer = 0, call: KPointer = 0, callSync: KPointer = 0): ResourceId { + const resourceId = ResourceHolder.instance().registerAndHold(callback) + this.heldResources.push(resourceId) + this.writeInt32(resourceId) + this.writePointer(hold) + this.writePointer(release) + this.writePointer(call) + this.writePointer(callSync) + return resourceId + } + holdAndWriteCallbackForPromiseVoid(hold: KPointer = 0, release: KPointer = 0, call: KPointer = 0, callSync = 0): [Promise, ResourceId] { + let resourceId: ResourceId = 0 + const promise = new Promise((resolve, reject) => { + const callback = (err: string[]|undefined) => { + if (err !== undefined) + reject(err) + else + resolve() + } + resourceId = this.holdAndWriteCallback(callback, hold, release, call, callSync) + }) + return [promise, resourceId] + } + holdAndWriteCallbackForPromise(hold: KPointer = 0, release: KPointer = 0, call: KPointer = 0): [Promise, ResourceId] { + let resourceId: ResourceId = 0 + const promise = new Promise((resolve, reject) => { + const callback = (value: T|undefined, err: string[]|undefined) => { + if (err !== undefined) + reject(err) + else + resolve(value!) + } + resourceId = this.holdAndWriteCallback(callback, hold, release, call) + }) + return [promise, resourceId] + } + writeCallbackResource(resource: CallbackResource) { + this.writeInt32(resource.resourceId) + this.writePointer(resource.hold) + this.writePointer(resource.release) + } + holdAndWriteObject(obj:any, hold: KPointer = 0, release: KPointer = 0): ResourceId { + const resourceId = ResourceHolder.instance().registerAndHold(obj) + this.heldResources.push(resourceId) + this.writeInt32(resourceId) + this.writePointer(hold) + this.writePointer(release) + return resourceId + } + private releaseResources() { + for (const resourceId of this.heldResources) + InteropNativeModule._ReleaseCallbackResource(resourceId) + // Improve: think about effective array clearing/pushing + this.heldResources = [] + } + writeCustomObject(kind: string, value: any) { + let current = SerializerBase.customSerializers + while (current) { + if (current.supports(kind)) { + current.serialize(this, value, kind) + return + } + current = current.next + } + console.log(`Unsupported custom serialization for ${kind}, write undefined`) + this.writeInt8(Tags.UNDEFINED) + } + writeNumber(value: number|undefined) { + this.checkCapacity(5) + if (value == undefined) { + this.view.setInt8(this.position, Tags.UNDEFINED) + this.position++ + return + } + if (value == Math.round(value)) { + this.view.setInt8(this.position, Tags.INT32) + this.view.setInt32(this.position + 1, value, true) + this.position += 5 + return + } + this.view.setInt8(this.position, Tags.FLOAT32) + this.view.setFloat32(this.position + 1, value, true) + this.position += 5 + } + writeInt8(value: int32) { + this.checkCapacity(1) + this.view.setInt8(this.position, value) + this.position += 1 + } + writeInt32(value: int32) { + this.checkCapacity(4) + this.view.setInt32(this.position, value, true) + this.position += 4 + } + writeInt64(value: int64) { + this.checkCapacity(8) + this.view.setBigInt64(this.position, BigInt(value), true) + this.position += 8 + } + writePointer(value: pointer) { + this.checkCapacity(8) + this.view.setBigInt64(this.position, BigInt(value ?? 0), true) + this.position += 8 + } + writeFloat32(value: float32) { + this.checkCapacity(4) + this.view.setFloat32(this.position, value, true) + this.position += 4 + } + writeFloat64(value: float64) { + this.checkCapacity(8) + this.view.setFloat64(this.position, value, true) + this.position += 8 + } + writeBoolean(value: boolean|undefined) { + this.checkCapacity(1) + this.view.setInt8(this.position, value == undefined ? RuntimeType.UNDEFINED : +value) + this.position++ + } + writeFunction(value: object | undefined) { + this.writeInt32(registerCallback(value)) + } + writeString(value: string) { + this.checkCapacity(4 + value.length * 4) // length, data + let encodedLength = + InteropNativeModule._ManagedStringWrite(value, new Uint8Array(this.view.buffer, 0), this.view.buffer.byteLength, this.position + 4) + this.view.setInt32(this.position, encodedLength, true) + this.position += encodedLength + 4 + } + writeBuffer(buffer: ArrayBuffer) { + this.holdAndWriteObject(buffer) + const ptr = InteropNativeModule._GetNativeBufferPointer(buffer) + this.writePointer(ptr) + this.writeInt64(buffer.byteLength) + } +} + +class DateSerializer extends CustomSerializer { + constructor() { + super(["Date"]) + } + + serialize(serializer: SerializerBase, value: object, kind: string): void { + serializer.writeString((value as Date).toISOString()) + } +} +SerializerBase.registerCustomSerializer(new DateSerializer()) + +export function unsafeCast(value: unknown) { + return value as unknown as T +} diff --git a/ets1.2/interop/src/interop/Wrapper.ts b/ets1.2/interop/src/interop/Wrapper.ts new file mode 100644 index 0000000000000000000000000000000000000000..47da5d393a829537ec07e306933c50da80008800 --- /dev/null +++ b/ets1.2/interop/src/interop/Wrapper.ts @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { ptrToString, nullptr, isSamePtr } from "#common/wrappers/Wrapper" +import { className } from "@koalaui/common" +import { KPointer } from "./InteropTypes" + +export { isNullPtr, nullptr, ptrToBits, bitsToPtr, isSamePtr, ptrToString } from "#common/wrappers/Wrapper" + +/** + * An object holding reference to the native pointer. + */ +export class Wrapper { + ptr: KPointer + constructor(ptr: KPointer) { + if (ptr == null) + throw new Error(`Init <${className(this)}> with null native peer`) + this.ptr = ptr + } + toString(): string { + return `[native object <${className(this)}> at ${ptrToString(this.ptr)}]` + } +} + +export function getPtr(value: Wrapper|undefined): KPointer { + return value?.ptr ?? nullptr +} + +export function ptrEqual(a: Wrapper|undefined, b: Wrapper|undefined): boolean { + if (a === b) return true + if (a == undefined || b == undefined) return false + return isSamePtr(a.ptr, b.ptr) +} diff --git a/ets1.2/interop/src/interop/arrays.ts b/ets1.2/interop/src/interop/arrays.ts new file mode 100644 index 0000000000000000000000000000000000000000..f85319a27d772160266c7f42790a6a3e5d2ee4c3 --- /dev/null +++ b/ets1.2/interop/src/interop/arrays.ts @@ -0,0 +1,43 @@ +/* + * 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 { int32 } from "@koalaui/common" + +export enum Access { + READ = 1, // 1 << 0, + WRITE = 2, // 1 << 1, + READWRITE = 3, // READ | WRITE +} +export function isRead(access: Access) { + return access & Access.READ +} +export function isWrite(access: Access) { + return access & Access.WRITE +} + +export type Exec = (pointer: P) => R +export type ExecWithLength = (pointer: P, length: int32) => R + +export type TypedArray = + Uint8Array + | Int8Array + | Uint16Array + | Int16Array + | Uint32Array + | Int32Array + | Float32Array + | Float64Array + +export type PtrArray = Uint32Array | BigUint64Array \ No newline at end of file diff --git a/ets1.2/interop/src/interop/buffer.ts b/ets1.2/interop/src/interop/buffer.ts new file mode 100644 index 0000000000000000000000000000000000000000..9163a99669b6935bf36ba4e3c424437d181776eb --- /dev/null +++ b/ets1.2/interop/src/interop/buffer.ts @@ -0,0 +1,39 @@ +/* + * Copyright (c) 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 { int32 } from "@koalaui/common" + +// Improve: can be removed if passing ArrayBuffer type through interop is possible +export class KBuffer { + private readonly _buffer: Uint8Array + public get buffer(): ArrayBuffer { + return this._buffer + } + public get length(): int32 { + return this._buffer.length + } + + constructor(length: int32) { + this._buffer = new Uint8Array(length) + } + + set(index: int32, value: int32): void { + this._buffer[index] = value + } + + get(index: int32): int32 { + return this._buffer[index] + } +} \ No newline at end of file diff --git a/ets1.2/interop/src/interop/events.ts b/ets1.2/interop/src/interop/events.ts new file mode 100644 index 0000000000000000000000000000000000000000..7fb4ce1aec8b7282d70b031857d3ca9453694eba --- /dev/null +++ b/ets1.2/interop/src/interop/events.ts @@ -0,0 +1,78 @@ +import { int32 } from "@koalaui/common" +import { DeserializerBase } from "./DeserializerBase" +import { InteropNativeModule } from "./InteropNativeModule" +import { ResourceHolder } from "../arkts/ResourceManager" +import { wrapSystemCallback } from "./InteropOps" +import { KSerializerBuffer } from "./InteropTypes" + +const API_KIND_MAX = 100 +const apiEventHandlers: (EventHandler | undefined)[] = new Array(API_KIND_MAX).fill(undefined) +export type EventHandler = (deserializer: DeserializerBase) => void +export function registerApiEventHandler(apiKind: int32, handler: EventHandler) { + if (apiKind < 0 || apiKind > API_KIND_MAX) { + throw new Error(`Maximum api kind is ${API_KIND_MAX}, received ${apiKind}`) + } + if (apiEventHandlers[apiKind] !== undefined) { + throw new Error(`Callback caller for api kind ${apiKind} already was set`) + } + apiEventHandlers[apiKind] = handler +} +export function handleApiEvent(apiKind: int32, deserializer: DeserializerBase) { + if (apiKind < 0 || apiKind > API_KIND_MAX) { + throw new Error(`Maximum api kind is ${API_KIND_MAX}, received ${apiKind}`) + } + if (apiEventHandlers[apiKind] === undefined) { + throw new Error(`Callback caller for api kind ${apiKind} was not set`) + } + apiEventHandlers[apiKind]!(deserializer) +} +export function wrapSystemApiHandlerCallback() { + wrapSystemCallback(1, (buffer: KSerializerBuffer, len:int32) => { + const deserializer = new DeserializerBase(buffer, len) + const apiKind = deserializer.readInt32() + handleApiEvent(apiKind, deserializer) + return 0 + }) +} +export function checkEvents(): void { + while (checkSingleEvent()) {} +} + + +enum CallbackEventKind { + Event_CallCallback = 0, + Event_HoldManagedResource = 1, + Event_ReleaseManagedResource = 2, +} + +const bufferSize = 8 * 1024 +const buffer = new Uint8Array(bufferSize) +const deserializer = new DeserializerBase(buffer.buffer, bufferSize) +function checkSingleEvent(): boolean { + deserializer.resetCurrentPosition() + let result = InteropNativeModule._CheckCallbackEvent(buffer, bufferSize) + if (result == 0) + return false + + const eventKind = deserializer.readInt32() as CallbackEventKind + switch (eventKind) { + case CallbackEventKind.Event_CallCallback: { + const apiKind = deserializer.readInt32() + handleApiEvent(apiKind, deserializer) + return true; + } + case CallbackEventKind.Event_HoldManagedResource: { + const resourceId = deserializer.readInt32() + ResourceHolder.instance().hold(resourceId) + return true; + } + case CallbackEventKind.Event_ReleaseManagedResource: { + const resourceId = deserializer.readInt32() + ResourceHolder.instance().release(resourceId) + return true; + } + default: { + throw new Error(`Unknown callback event kind ${eventKind}`) + } + } +} \ No newline at end of file diff --git a/ets1.2/interop/src/interop/index.ts b/ets1.2/interop/src/interop/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..a59725dd9004ec3aca233c9b2ba788fa24dad25e --- /dev/null +++ b/ets1.2/interop/src/interop/index.ts @@ -0,0 +1,75 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { + withFloat32Array, + withFloat64Array, + withInt16Array, + withInt32Array, + withInt8Array, + withUint16Array, + withUint32Array, + withUint8Array, + wasmHeap as wasmHeapArrayBuffer +} from "#common/wrappers/arrays" + +export { registerCallback, setCallbackRegistry } from "#common/wrappers/Callback" + +export { Access, Exec } from "./arrays" +export { Finalizable, NativeThunk } from "./Finalizable" +export { nullable } from "./nullable" +export { getPtr, isNullPtr, nullptr, ptrEqual, Wrapper, ptrToBits, bitsToPtr } from "./Wrapper" + +export { + decodeToString, + encodeToData, + withString, + withStringArray, + withPtrArray, + fromPtrArray, + toPtrArray +} from "#common/wrappers/arrays" + +export const withFloatArray = withFloat32Array +export const withByteArray = withUint8Array +export const withIntArray = withInt32Array + +export const wasmHeap = wasmHeapArrayBuffer + +export { + withFloat32Array, + withFloat64Array, + withInt8Array, + withInt16Array, + withInt32Array, + withUint8Array, + withUint16Array, + withUint32Array, +} + +export * from "./Platform" +export * from "./InteropTypes" + +export * from "./InteropOps" +export * from "./NativeString" +export * from "./buffer" +export * from "../arkts/ResourceManager" +export * from "./NativeBuffer" +export { InteropNativeModule, loadInteropNativeModule } from "./InteropNativeModule" +export { SerializerBase, RuntimeType, Tags, runtimeType, CallbackResource, unsafeCast, isInstanceOf, toPeerPtr } from "./SerializerBase" +export { DeserializerBase } from "./DeserializerBase" +export * from "./events" +export { loadNativeModuleLibrary, loadNativeLibrary, registerNativeModuleLibraryName } from "./loadLibraries" +export * from "./MaterializedBase" diff --git a/ets1.2/interop/src/interop/java/CallbackRecord.java b/ets1.2/interop/src/interop/java/CallbackRecord.java new file mode 100644 index 0000000000000000000000000000000000000000..2292705a6c5707f76e068a8e26481f12eef2fb1d --- /dev/null +++ b/ets1.2/interop/src/interop/java/CallbackRecord.java @@ -0,0 +1,25 @@ +/* + * Copyright (c) 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. + */ +package org.koalaui.interop; + +class CallbackRecord { + public CallbackType callback; + public boolean autoDisposable; + + public CallbackRecord(CallbackType callback, boolean autoDisposable) { + this.callback = callback; + this.autoDisposable = autoDisposable; + } +} diff --git a/ets1.2/interop/src/interop/java/CallbackRegistry.java b/ets1.2/interop/src/interop/java/CallbackRegistry.java new file mode 100644 index 0000000000000000000000000000000000000000..2fb731539602a5fc07d25a2eaa72c73154e45fef --- /dev/null +++ b/ets1.2/interop/src/interop/java/CallbackRegistry.java @@ -0,0 +1,69 @@ +/* + * Copyright (c) 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. + */ +package org.koalaui.interop; + +import java.util.Arrays; +import java.util.HashMap; + +class CallbackRegistry { + + private static HashMap callbacks = new HashMap(); + private static Integer id = 0; + + static { + CallbackRegistry.callbacks.put(id, new CallbackRecord( + new CallbackType() { + @Override + public int apply(byte[] args, int length) { + System.out.printf("Callback 0 called with args = %s and length = %d\n", Arrays.toString(args), length); + throw new Error("Null callback called"); + } + }, false) + ); + CallbackRegistry.id++; + } + + private CallbackRegistry() { + + } + + public static Integer wrap(CallbackType callback) { + Integer callbackId = CallbackRegistry.id++; + CallbackRegistry.callbacks.put(callbackId, new CallbackRecord(callback, true)); + return callbackId; + } + + public static Integer wrap(CallbackType callback, boolean autoDisposable) { + Integer callbackId = CallbackRegistry.id++; + CallbackRegistry.callbacks.put(callbackId, new CallbackRecord(callback, autoDisposable)); + return callbackId; + } + + public static int call(Integer id, byte[] args, int length) { + if (!CallbackRegistry.callbacks.containsKey(id)) { + System.out.printf("Callback %d is not known\n", id); + throw new Error(String.format("Disposed or unwrapped callback called (id = %d)", id)); + } + CallbackRecord record = CallbackRegistry.callbacks.get(id); + if (record.autoDisposable) { + CallbackRegistry.dispose(id); + } + return record.callback.apply(args, length); + } + + public static void dispose(Integer id) { + CallbackRegistry.callbacks.remove(id); + } +} diff --git a/ets1.2/interop/src/interop/java/CallbackTests.java b/ets1.2/interop/src/interop/java/CallbackTests.java new file mode 100644 index 0000000000000000000000000000000000000000..22cf1fbe6c0fdae09969c9d3c315ed590bcbafe4 --- /dev/null +++ b/ets1.2/interop/src/interop/java/CallbackTests.java @@ -0,0 +1,181 @@ +/* + * Copyright (c) 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. + */ +package org.koalaui.interop; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.nio.IntBuffer; +import java.util.function.Function; + +import org.koalaui.arkoala.NativeModule; + +public class CallbackTests { + // Improve: where tests will be located? + + public class TestUtils { + // Improve: where test utils will be located? + public static void assertEquals(String name, T expected, T actual) { + if (!expected.equals(actual)) { + System.out.printf("TEST %s FAIL:\n EXPECTED \"%s\"\n ACTUAL \"%s\"\n", name, expected.toString(), actual.toString()); + } else { + System.out.printf("TEST %s PASS\n", name); + } + } + + public static void assertThrows(String name, Function fn) { + boolean caught = false; + try { + fn.apply(null); + } catch (Throwable e) { + caught = true; + } + if (!caught) { + System.out.printf("TEST %s FAIL:\n No exception thrown\n", name); + } else { + System.out.printf("TEST %s PASS\n", name); + } + } + } + + public static void checkCallback() { + Integer id1 = CallbackRegistry.wrap(new CallbackType() { + @Override + public int apply(byte[] args, int length) { + return 2024; + } + }); + Integer id2 = CallbackRegistry.wrap(new CallbackType() { + @Override + public int apply(byte[] args, int length) { + return 2025; + } + }); + + TestUtils.assertEquals("Call callback 1", 2024, CallbackRegistry.call(id1, new byte[] {}, 0)); + TestUtils.assertEquals("Call callback 2", 2025, CallbackRegistry.call(id2, new byte[] {}, 0)); + TestUtils.assertThrows("Call disposed callback 1", new Function() { + @Override + public Integer apply(Void v) { + return CallbackRegistry.call(id1, new byte[] { }, 0); + } + }); + TestUtils.assertThrows("Call callback 0", new Function() { + @Override + public Integer apply(Void v) { + return CallbackRegistry.call(0, new byte[] { 2, 4, 6, 8 }, 4); + } + }); + } + + public static void checkNativeCallback() { + Integer id1 = CallbackRegistry.wrap(new CallbackType() { + @Override + public int apply(byte[] args, int length) { + return 123456; + } + }); + TestUtils.assertEquals("NativeCallback without args", 123456, NativeModule._TestCallIntNoArgs(id1)); + TestUtils.assertThrows("NativeCallback without args called again", new Function() { + @Override + public Integer apply(Void v) { + return CallbackRegistry.call(id1, new byte[] { }, 0); + } + }); + TestUtils.assertThrows("NativeCallback without args called again from native", new Function() { + @Override + public Integer apply(Void v) { + return NativeModule._TestCallIntNoArgs(id1); + } + }); + + Integer id2 = CallbackRegistry.wrap(new CallbackType() { + @Override + public int apply(byte[] args, int length) { + ByteBuffer buffer = ByteBuffer.wrap(args); + buffer.order(ByteOrder.LITTLE_ENDIAN); + IntBuffer intBuffer = buffer.asIntBuffer(); + int sum = 0; + for (int i = 0; i < length / 4; i++) { + sum += intBuffer.get(i); + } + return sum; + } + }); + int[] arr2 = new int[] { 100, 200, 300, -1000 }; + TestUtils.assertEquals("NativeCallback Int32Array sum", -400, NativeModule._TestCallIntIntArraySum(id2, arr2, arr2.length)); + + Integer id3 = CallbackRegistry.wrap(new CallbackType() { + @Override + public int apply(byte[] args, int length) { + ByteBuffer buffer = ByteBuffer.wrap(args); + buffer.order(ByteOrder.LITTLE_ENDIAN); + IntBuffer intBuffer = buffer.asIntBuffer(); + for (int i = 1; i < length / 4; i++) { + intBuffer.put(i, intBuffer.get(i) + intBuffer.get(i - 1)); + } + return 0; + } + }); + int[] arr3 = new int[] { 100, 200, 300, -1000 }; + NativeModule._TestCallVoidIntArrayPrefixSum(id3, arr3, arr3.length); + TestUtils.assertEquals("NativeCallback Int32Array PrefixSum [0]", 100, arr3[0]); + TestUtils.assertEquals("NativeCallback Int32Array PrefixSum [1]", 300, arr3[1]); + TestUtils.assertEquals("NativeCallback Int32Array PrefixSum [2]", 600, arr3[2]); + TestUtils.assertEquals("NativeCallback Int32Array PrefixSum [3]", -400, arr3[3]); + + long start = System.currentTimeMillis(); + Integer id4 = CallbackRegistry.wrap(new CallbackType() { + @Override + public int apply(byte[] args, int length) { + ByteBuffer buffer = ByteBuffer.wrap(args); + buffer.order(ByteOrder.LITTLE_ENDIAN); + IntBuffer intBuffer = buffer.asIntBuffer(); + intBuffer.put(1, intBuffer.get(1) + 1); + if (intBuffer.get(0) + intBuffer.get(1) < intBuffer.get(2)) { + return NativeModule._TestCallIntRecursiveCallback(id3 + 1, args, args.length); + } + return 1; + } + }, false); + TestUtils.assertEquals("NativeCallback prepare recursive callback test", id4, id3 + 1); + int depth = 500; + int count = 100; + for (int i = 0; i < count; i++) { + int length = 12; + byte[] args = new byte[length]; + IntBuffer args32 = ByteBuffer.wrap(args).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer(); + args32.put(2, depth); + NativeModule._TestCallIntRecursiveCallback(id4, args, args.length); + if (i == 0) { + TestUtils.assertEquals("NativeCallback Recursive [0]", (depth + 1) / 2, args32.get(0)); + TestUtils.assertEquals("NativeCallback Recursive [1]", depth / 2, args32.get(1)); + } + } + long passed = System.currentTimeMillis() - start; + System.out.println("recursive native callback: " + String.valueOf(passed) + "ms for " + depth * count + " callbacks, " + Math.round((double)passed / (depth * count) * 1000000) + "ms per 1M callbacks"); + + Integer id5 = CallbackRegistry.wrap(new CallbackType() { + @Override + public int apply(byte[] args, int length) { + int sum = 0; + for (int i = 0; i < length; i++) { + sum += args[i]; + } + return sum; + } + }, false); + NativeModule._TestCallIntMemory(id5, 1000); + } +} diff --git a/ets1.2/interop/src/interop/java/CallbackType.java b/ets1.2/interop/src/interop/java/CallbackType.java new file mode 100644 index 0000000000000000000000000000000000000000..952cd3d399a7fddc441ca5bef9d755ee3231a24b --- /dev/null +++ b/ets1.2/interop/src/interop/java/CallbackType.java @@ -0,0 +1,19 @@ +/* + * Copyright (c) 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. + */ +package org.koalaui.interop; + +public interface CallbackType { + public int apply(byte[] args, int length); +} diff --git a/ets1.2/interop/src/interop/loadLibraries.ts b/ets1.2/interop/src/interop/loadLibraries.ts new file mode 100644 index 0000000000000000000000000000000000000000..a91b88cd34b5407c91d5370108e14a03de790cc6 --- /dev/null +++ b/ets1.2/interop/src/interop/loadLibraries.ts @@ -0,0 +1,65 @@ +/* + * Copyright (c) 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 os from "os" + +const nativeModuleLibraries: Map = new Map() + +export function loadNativeLibrary(name: string): Record { + const isHZVM = !!(globalThis as any).requireNapi + let nameWithoutSuffix = name.endsWith(".node") ? name.slice(0, name.length - 5) : name + let candidates: string[] = [ + name, + `${nameWithoutSuffix}.node`, + `${nameWithoutSuffix}_${os.arch()}.node`, + `${nameWithoutSuffix}_${os.platform()}_${os.arch()}.node`, + ] + const errors: { candidate: string, command: string, error: any }[] = [] + if (!isHZVM) + try { + candidates.push(eval(`require.resolve(${JSON.stringify((nameWithoutSuffix + ".node"))})`)) + } catch (e) { + errors.push({ candidate: `${nameWithoutSuffix}.node`, command: `resolve(...)`, error: e }) + } + + for (const candidate of candidates) { + try { + if (isHZVM) + return (globalThis as any).requireNapi(candidate, true) + else + return eval(`let exports = {}; process.dlopen({ exports }, ${JSON.stringify(candidate)}, 2); exports`) + } catch (e) { + errors.push({ candidate: candidate, command: `dlopen`, error: e }) + } + } + errors.forEach((e, i) => { + console.error(`Error ${i} of ${errors.length} command: ${e.command}, candidate: ${e.candidate}, message: ${e.error}`) + }) + throw new Error(`Failed to load native library ${name}. dlopen candidates: ${candidates.join(":")}`) +} + +export function registerNativeModuleLibraryName(nativeModule: string, libraryName: string) { + nativeModuleLibraries.set(nativeModule, libraryName) +} + +export function loadNativeModuleLibrary(moduleName: string, module?: object) { + if (!module) + throw new Error(" argument is required and optional only for compatibility with ArkTS") + const library = loadNativeLibrary(nativeModuleLibraries.get(moduleName) ?? moduleName) + if (!library || !library[moduleName]) { + console.error(`Failed to load library for module ${moduleName}`) + return + } + Object.assign(module, library[moduleName]) +} diff --git a/ets1.2/interop/src/interop/nullable.ts b/ets1.2/interop/src/interop/nullable.ts new file mode 100644 index 0000000000000000000000000000000000000000..1a1875e25662eecfade68bb221dccad907d45e36 --- /dev/null +++ b/ets1.2/interop/src/interop/nullable.ts @@ -0,0 +1,25 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { isNullPtr } from "./Wrapper" +import { KPointer } from "./InteropTypes" + +export function nullable(value: KPointer, body: (arg: KPointer) => T | undefined): T | undefined { + if (isNullPtr(value)) { + return undefined + } else { + return body(value) + } +} diff --git a/ets1.2/interop/src/napi/wrappers/Callback.ts b/ets1.2/interop/src/napi/wrappers/Callback.ts new file mode 100644 index 0000000000000000000000000000000000000000..5af4ae26bf1ad7d2f0e3d71003d08e9aac3a5077 --- /dev/null +++ b/ets1.2/interop/src/napi/wrappers/Callback.ts @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { KPointer } from "../../interop/InteropTypes" +import { CallbackRegistry } from "../../interop/Platform" + +export function registerCallback(callback: any, obj: any = null): KPointer { + return theRegistry!.registerCallback(callback, obj) +} + +let theRegistry: CallbackRegistry|undefined = undefined + +export function setCallbackRegistry(registry: CallbackRegistry) { + theRegistry = registry +} diff --git a/ets1.2/interop/src/napi/wrappers/Wrapper.ts b/ets1.2/interop/src/napi/wrappers/Wrapper.ts new file mode 100644 index 0000000000000000000000000000000000000000..b1e4383f43089fb2232e8a9bcf967d115b7c5513 --- /dev/null +++ b/ets1.2/interop/src/napi/wrappers/Wrapper.ts @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { int32 } from "@koalaui/common" +import { KPointer } from "../../interop/InteropTypes" + +export const nullptr = BigInt(0) + +export function isNullPtr(value: KPointer): boolean { + return value === nullptr +} + +export function ptrToString(ptr: KPointer) { + return `0x${ptr!.toString(16).padStart(8, "0")}` +} + +export function isSamePtr(a: KPointer, b: KPointer) { + return (a === b) +} + +// Improve: rethink me +export function ptrToBits(ptr: KPointer): Uint32Array | null { + let result = new Uint32Array(2) + let ptrBigInt = ptr as bigint + result[0] = Number(ptrBigInt & BigInt(0xFFFFFFFF)) + result[1] = Number((ptrBigInt >> BigInt(32)) & BigInt(0xFFFFFFFF)) + return result +} + +export function bitsToPtr(array: Int32Array, offset: int32): KPointer { + let ptrBigInt: bigint = BigInt(array[offset + 1]) & BigInt(0xFFFFFFFF) + ptrBigInt = (ptrBigInt << BigInt(32)) | (BigInt(array[offset]) & BigInt(0xFFFFFFFF)) + return ptrBigInt +} diff --git a/ets1.2/interop/src/napi/wrappers/arrays.ts b/ets1.2/interop/src/napi/wrappers/arrays.ts new file mode 100644 index 0000000000000000000000000000000000000000..25f8c560407486e475515baeb4936296d52a2182 --- /dev/null +++ b/ets1.2/interop/src/napi/wrappers/arrays.ts @@ -0,0 +1,111 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { CustomTextDecoder, CustomTextEncoder } from "@koalaui/common" +import { Access, Exec, ExecWithLength, PtrArray, TypedArray } from "../../interop/arrays" +import { nullptr } from "./Wrapper" +import { Wrapper } from "../../interop/Wrapper" +import { KPointer, KStringArrayPtr } from "../../interop" + +const encoder = new CustomTextEncoder() +const decoder = new CustomTextDecoder() + +export function decodeToString(array: Uint8Array): string { + return decoder.decode(array) +} + +export function encodeToData(string: string): Uint8Array { + return encoder.encode(string, false) +} + +export function withString(data: string | undefined, exec: Exec): R { + return exec(data === undefined ? null : data) +} + +export function withStringArray(strings: Array | undefined, exec: Exec): R { + if (strings === undefined || strings.length === 0) { + return exec(null) + } + + let array = encoder.encodeArray(strings) + return exec(array) +} + +function withArray( + data: C | undefined, + exec: ExecWithLength +): R { + return exec(data ?? null, data?.length ?? 0) +} + +export function withPtrArray(data: BigUint64Array, access: Access, exec: ExecWithLength) { + return exec(data ?? null, data?.length ?? 0) // Improve: rethink +} + +export function toPtrArray(data: Array | undefined): BigUint64Array { + if (data == undefined || data.length === 0) { + return new BigUint64Array(0) + } + const array = new BigUint64Array(data.length) + for (let i = 0; i < data.length; i++) { + let item = data[i] + array[i] = item != undefined ? item.ptr as bigint : nullptr + } + return array +} + +export function fromPtrArray(array: PtrArray, factory: (ptr: KPointer) => T) : Array { + if (array.length === 0) { + return new Array(0) + } + const result = new Array(array.length) + for (let i = 0; i < array.length; i++) { + let ptr = array[i] + if (ptr == nullptr) { + result[i] = undefined + } else { + result[i] = factory(ptr) + } + } + return result +} + +export function withUint8Array(data: Uint8Array | undefined, access: Access, exec: ExecWithLength) { + return withArray(data, exec) +} +export function withInt8Array(data: Int8Array | undefined, access: Access, exec: ExecWithLength) { + return withArray(data, exec) +} +export function withUint16Array(data: Uint16Array | undefined, access: Access, exec: ExecWithLength) { + return withArray(data, exec) +} +export function withInt16Array(data: Int16Array | undefined, access: Access, exec: ExecWithLength) { + return withArray(data, exec) +} +export function withUint32Array(data: Uint32Array | undefined, access: Access, exec: ExecWithLength) { + return withArray(data, exec) +} +export function withInt32Array(data: Int32Array | undefined, access: Access, exec: ExecWithLength) { + return withArray(data, exec) +} +export function withFloat32Array(data: Float32Array | undefined, access: Access, exec: ExecWithLength) { + return withArray(data, exec) +} +export function withFloat64Array(data: Float64Array | undefined, access: Access, exec: ExecWithLength) { + return withArray(data, exec) +} +export function wasmHeap(): ArrayBuffer { + throw new Error("Unused") +} \ No newline at end of file diff --git a/ets1.2/interop/src/wasm/wrappers/Callback.ts b/ets1.2/interop/src/wasm/wrappers/Callback.ts new file mode 100644 index 0000000000000000000000000000000000000000..abc939bcaf4f8548a8eca0ee7e35fd7389a203a0 --- /dev/null +++ b/ets1.2/interop/src/wasm/wrappers/Callback.ts @@ -0,0 +1,99 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { KPointer } from "../../interop/InteropTypes" +import { CallbackRegistry } from "../../interop/Platform" + +class CallbackInfo { + cb: any + recv: any + constructor(callback: any, obj: any = null) { + this.cb = callback + this.recv = obj + } +} + +const GLOBAL_SCOPE = new class CallbackScope { + static readonly CB_NULL = new CallbackInfo( + () => { throw new Error("attempted to call a callback at NULL") }, + null + ) + static readonly CB_UNDEFINED = new CallbackInfo( + () => { throw new Error("attempted to call an uninitialized callback") }, + null + ) + static readonly CB_NULL_ID = 0 + nextId: number + callbackMap: Map | null + + constructor() { + this.nextId = 1 + this.callbackMap = new Map() + this.callbackMap.set(CallbackScope.CB_NULL_ID, CallbackScope.CB_NULL) + } + + addCallback(cb: any, obj: any): number { + let id = this.nextId++ + this.callbackMap?.set(id, new CallbackInfo(cb, obj)) + return id + } + + getCallback(id: number): CallbackInfo { + return this.callbackMap?.get(id) || CallbackScope.CB_UNDEFINED + } + + deleteCallback(id: number): void { + if (id > CallbackScope.CB_NULL_ID) { + this.callbackMap?.delete(id) + } + } + + release(): void { + this.callbackMap = null + } +} + +function callCallback(callbackId: number): any { + let CallbackInfo = GLOBAL_SCOPE.getCallback(callbackId) + try { + let cb = CallbackInfo.cb + if (CallbackInfo.recv !== null) { + cb = cb.bind(CallbackInfo.recv) + } + return cb() + } catch (e) { + console.error(e) + } +} + +export function registerCallback(callback: any, obj: any = null): KPointer { + return GLOBAL_SCOPE.addCallback(callback, obj) +} + +function releaseCallback(callbackId: number): void { + return GLOBAL_SCOPE.deleteCallback(callbackId) +} + +declare namespace globalThis { + function callCallback(callbackId: number): any + function releaseCallback(callbackId: number): any +} + +globalThis.callCallback = callCallback +globalThis.releaseCallback = releaseCallback + +export function setCallbackRegistry(_ignoredRegistry: CallbackRegistry) { + // On WASM we don't need registry in current implementation. +} diff --git a/ets1.2/interop/src/wasm/wrappers/Wrapper.ts b/ets1.2/interop/src/wasm/wrappers/Wrapper.ts new file mode 100644 index 0000000000000000000000000000000000000000..8c0dc94f636766eeaad9573cfc07308e230ebd05 --- /dev/null +++ b/ets1.2/interop/src/wasm/wrappers/Wrapper.ts @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { int32 } from "@koalaui/common" +import { KPointer } from "../../interop/InteropTypes" + +export const nullptr: number = 0 + +export function isNullPtr(value: KPointer): boolean { + return (value == nullptr) +} + +export function ptrToString(ptr: KPointer) { + if (ptr === 0) return "0x0" + + const hex = (ptr as number).toString(16).padStart(8, "0") + return `0x${hex}` +} + +export function isSamePtr(a: KPointer, b: KPointer) { + return a === b +} + +export function ptrToBits(ptr: KPointer): Uint32Array { + let result = new Uint32Array(2) + result[0] = ptr as int32 + return result +} + +export function bitsToPtr(array: Int32Array, offset: int32): KPointer { + return array[offset] +} diff --git a/ets1.2/interop/src/wasm/wrappers/arrays.ts b/ets1.2/interop/src/wasm/wrappers/arrays.ts new file mode 100644 index 0000000000000000000000000000000000000000..7da912e7eaf30cad4bb84a8a52afa92bf6662303 --- /dev/null +++ b/ets1.2/interop/src/wasm/wrappers/arrays.ts @@ -0,0 +1,171 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { CustomTextEncoder, CustomTextDecoder, int32 } from "@koalaui/common" + +import { KPointer } from "../../interop/InteropTypes" +import { Wrapper } from "../../interop/Wrapper" +import { Access, isRead, isWrite, Exec, TypedArray, ExecWithLength } from "../../interop/arrays" + +const encoder = new CustomTextEncoder() +const decoder = new CustomTextDecoder() + +export function decodeToString(array: Uint8Array): string { + return decoder.decode(array) +} + +export function encodeToData(string: string): Uint8Array { + return encoder.encode(string, false) +} + +type Heap = { readonly buffer: ArrayBuffer } + +// Improve: actually memory allocation primitives are defined for a specific intance instance, +// refactor me +declare const _heaps: { + HEAP8(): Heap; + HEAP16(): Heap; + HEAP32(): Heap; + HEAPU8(): Heap; + HEAPU16(): Heap; + HEAPU32(): Heap; + HEAPF32(): Heap; + HEAPF64(): Heap; +} +declare function _malloc(size: number): number; +declare function _free(ptr: number): void; + +const nullptr: number = 0 + +// with string as array of utf8 data headed by length +export function withString(data: string | undefined, exec: Exec): R { + if (data === undefined) return exec(nullptr) + + let array = encoder.encode(data, true) + return withUint8Array(array, Access.READ, exec) +} + +export function withStringArray(strings: Array | undefined, exec: Exec): R { + if (strings === undefined || strings.length === 0) { + return exec(nullptr) + } + + let array = encoder.encodeArray(strings) + return withUint8Array(array, Access.READ, exec) +} + +function withArray( + data: C | undefined, + access: Access, + exec: ExecWithLength, + bytesPerElement: int32, + ctor: (ptr: number, length: number) => C +): R { + if (data === undefined || data.length === 0) { + return exec(nullptr, 0) + } + + let ptr = _malloc(data.length * bytesPerElement) + let wasmArray = ctor(ptr, data.length) + + if (isRead(access)) { + wasmArray.set(data) + } + + let result = exec(ptr, data.length) + + if (isWrite(access)) { + data.set(wasmArray) + } + + _free(ptr) + + return result +} + +export function withPtrArray(data: Uint32Array, access: Access, exec: ExecWithLength) { + return withArray(data as Uint32Array, access, exec, Uint32Array.BYTES_PER_ELEMENT, (ptr: number, length: number) => { + return new Uint32Array(_heaps.HEAPU8().buffer, ptr, length) + }) +} + +export function toPtrArray(data: Array | undefined): Uint32Array { + if (data === undefined || data.length === 0) { + return new Uint32Array(0) + } + const array = new Uint32Array(data.length) + for (let i = 0; i < data.length; i++) { + array[i] = data[i]?.ptr as number + } + return array +} + +export function fromPtrArray(array: Uint32Array, factory: (ptr: KPointer) => T) : Array { + const result = new Array(array.length) + for (let i = 0; i < array.length; i++) { + let v = array[i] + if (v == 0) { + result[i] = undefined + } else { + result[i] = factory(v) + } + } + return result +} + +export function withUint8Array(data: Uint8Array | undefined, access: Access, exec: ExecWithLength) { + return withArray(data, access, exec, Uint8Array.BYTES_PER_ELEMENT, (ptr: number, length: number) => { + return new Uint8Array(_heaps.HEAPU8().buffer, ptr, length) + }) +} +export function withInt8Array(data: Int8Array | undefined, access: Access, exec: ExecWithLength) { + return withArray(data, access, exec, Int8Array.BYTES_PER_ELEMENT, (ptr: number, length: number) => { + return new Int8Array(_heaps.HEAPU8().buffer, ptr, length) + }) +} +export function withUint16Array(data: Uint16Array | undefined, access: Access, exec: ExecWithLength) { + return withArray(data, access, exec, Uint16Array.BYTES_PER_ELEMENT, (ptr: number, length: number) => { + return new Uint16Array(_heaps.HEAPU8().buffer, ptr, length) + }) +} +export function withInt16Array(data: Int16Array | undefined, access: Access, exec: ExecWithLength) { + return withArray(data, access, exec, Int16Array.BYTES_PER_ELEMENT, (ptr: number, length: number) => { + return new Int16Array(_heaps.HEAPU8().buffer, ptr, length) + }) +} +export function withUint32Array(data: Uint32Array | undefined, access: Access, exec: ExecWithLength) { + return withArray(data, access, exec, Uint32Array.BYTES_PER_ELEMENT, (ptr: number, length: number) => { + return new Uint32Array(_heaps.HEAPU8().buffer, ptr, length) + }) +} +export function withInt32Array(data: Int32Array | undefined, access: Access, exec: ExecWithLength) { + return withArray(data, access, exec, Int32Array.BYTES_PER_ELEMENT, (ptr: number, length: number) => { + return new Int32Array(_heaps.HEAPU8().buffer, ptr, length) + }) +} +export function withFloat32Array(data: Float32Array | undefined, access: Access, exec: ExecWithLength) { + return withArray(data, access, exec, Float32Array.BYTES_PER_ELEMENT, (ptr: number, length: number) => { + return new Float32Array(_heaps.HEAPU8().buffer, ptr, length) + }) +} +export function withFloat64Array(data: Float64Array | undefined, access: Access, exec: ExecWithLength) { + return withArray(data, access, exec, Float64Array.BYTES_PER_ELEMENT, (ptr: number, length: number) => { + return new Float64Array(_heaps.HEAPU8().buffer, ptr, length) + }) +} + +export function wasmHeap(): ArrayBuffer { + return _heaps.HEAP32().buffer +} diff --git a/ets1.2/interop/tsconfig.json b/ets1.2/interop/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..afe382db7f7d696313ad5fe54bbff58bc7f6f71a --- /dev/null +++ b/ets1.2/interop/tsconfig.json @@ -0,0 +1,30 @@ +{ + "compilerOptions": { + "target": "es2017", + "lib": ["ESNext", "ESNext.WeakRef"], + "moduleResolution": "node", + "composite": true, + "incremental": true, + "declarationMap": true, + "sourceMap": true, + "declaration": true, + "noEmitOnError": true, + "strict": true, + "skipLibCheck": true, + "removeComments": false, + "outDir": "build/lib", + "module": "CommonJS", // Improve: maybe migrate to ESM? + "rootDirs": ["src"], + "baseUrl": ".", + "types": ["node"], + "paths": { + "@koalaui/common": ["../incremental/common/src"], + "#common/wrappers/*": ["./src/napi/wrappers/*", "./src/wasm/wrappers/*"] + } + }, + "include": ["src/interop/**/*", "src/napi/**/*", "src/wasm/**/*", "src/arkts/ResourceManager.ts"], + "references": [ + { "path": "../incremental/compat" }, + { "path": "../incremental/common" } + ] +} diff --git a/ets1.2/interop/ui2abcconfig.json b/ets1.2/interop/ui2abcconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..68085b0e5019f82fd95f7aebd18de264fbbebb45 --- /dev/null +++ b/ets1.2/interop/ui2abcconfig.json @@ -0,0 +1,12 @@ +{ + "compilerOptions": { + "package": "@koalaui/interop", + "outDir": "./build/abc", + "baseUrl": "./src/arkts", + "paths": { + "@koalaui/compat": ["../../../incremental/compat/src/arkts"], + "@koalaui/common": ["../../../incremental/common/src"] + } + }, + "include": ["./src/arkts/*.ts"] +} diff --git a/ets1.2/libarkts/.mocharc.json b/ets1.2/libarkts/.mocharc.json new file mode 100644 index 0000000000000000000000000000000000000000..35222a70dbc455d94ac0d57251be08cf39638af2 --- /dev/null +++ b/ets1.2/libarkts/.mocharc.json @@ -0,0 +1,11 @@ +{ + "ui": "tdd", + "spec": "./test/arkts-api/**/*.test.ts", + "extension": [ + "ts" + ], + "require": [ + "../../incremental/test-utils/scripts/register" + ], + "timeout": 20000 +} diff --git a/ets1.2/libarkts/BUILD.gn b/ets1.2/libarkts/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..8caa9faf9332b50c8d4b9cf5f626f545df77a6f0 --- /dev/null +++ b/ets1.2/libarkts/BUILD.gn @@ -0,0 +1,279 @@ +# 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("//build/ohos.gni") +import("//foundation/arkui/ace_engine/frameworks/bridge/arkts_frontend/koala_mirror/gn/npm_util.gni") + +koala_root = "../.." +libarkts_root = "." +ui2abc_root = ".." +interop_root = "$koala_root/interop" + +node_modules_dir = "../node_modules" + +node_version = "v16.20.2" +host_arch = "${host_os}-${host_cpu}" + +shared_library("es2panda_lib") { + external_deps = [ "ets_frontend:ets2panda" ] + + sources = [ + "$libarkts_root/native/src/common.cc", + "$libarkts_root/native/src/bridges.cc", + "$libarkts_root/native/src/generated/bridges.cc", + + "$interop_root/src/cpp/napi/convertors-napi.cc", + "$interop_root/src/cpp/callback-resource.cc", + "$interop_root/src/cpp/interop-logging.cc", + "$interop_root/src/cpp/common-interop.cc" + ] + + include_dirs = [ + "$ui2abc_root/build/sdk/linux_host_tools/include/tools/es2panda/public", + "$ui2abc_root/build/sdk/linux_host_tools/include/tools/es2panda", + + "$libarkts_root/native/src", + + "$koala_root/interop/src/cpp", + "$koala_root/interop/src/cpp/napi", + "$koala_root/interop/src/cpp/types", + + "$node_modules_dir/node-api-headers/include", + "$node_modules_dir/node-addon-api", + + # "//arkcompiler/ets_frontend/ets2panda/public/", + # rebase_path("$root_gen_dir/arkcompiler/ets_frontend/ets2panda/"), + ] + + defines = [ + "KOALA_INTEROP_MODULE=NativeModule", + "INTEROP_LIBRARY_NAME=es2panda", + "KOALA_USE_NODE_VM", + "KOALA_NAPI" + ] + + deps = [ + "$ui2abc_root:ui2abc_install(${host_toolchain})", + ":regenerate(${host_toolchain})" + ] + + configs -= [ "//build/config/compiler:compiler" ] + + if (is_mac) { + cflags_cc = [ + "-std=c++17", + "-Wall", + "-Werror", + "-Wno-unused-variable", + "-fPIC", + ] + + ldflags = [ + "-fPIC", + "-Wl,-undefined,dynamic_lookup", + "-fuse-ld=lld", + "-Wl,--icf=all", + "-Wl,--color-diagnostics", + "-m64" + ] + defines += [ "KOALA_MACOS" ] + output_extension = "node" + } + + if (is_linux) { + cflags_cc = [ + "-std=c++17", + "-Wall", + "-Werror", + "-Wno-unused-command-line-argument", + "-Wno-unused-variable", + "-fPIC", + ] + + ldflags = [ + "-Wl,--allow-shlib-undefined", + "-Wl,--fatal-warnings", + "-Wl,--build-id=md5", + "-fPIC", + "-Wl,-z,noexecstack", + "-Wl,-z,now", + "-Wl,-z,relro", + + # "-Wl,-z,defs", # must no use this option + "-Wl,--as-needed", + "-fuse-ld=lld", + "-Wl,--icf=all", + "-Wl,--color-diagnostics", + "-m64", + ] + defines += [ "KOALA_LINUX" ] + output_extension = "node" + } else if (current_os == "mingw") { + cflags_cc = [ + "-std=c++17", + "-Wall", + "-Werror", + "-Wno-unused-variable", + "-Wno-unused-command-line-argument", + "-fPIC", + "-Wno-error=deprecated-copy", + "-enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang", + "-ftrivial-auto-var-init=zero", + "-fcolor-diagnostics", + "-fmerge-all-constants", + "-Xclang", + "-mllvm", + "-Xclang", + "-instcombine-lower-dbg-declare=0", + "-no-canonical-prefixes", + "-fuse-ld=lld", + "-fno-stack-protector", + "-fno-strict-aliasing", + "-Wno-builtin-macro-redefined", + "-fms-extensions", + "-static", + "-rtlib=compiler-rt", + "-stdlib=libc++", + "-lunwind", + "-lpthread", + "-Qunused-arguments", + "-target", + "x86_64-pc-windows-gnu", + "-D__CUSTOM_SECURITY_LIBRARY", + ] + + ldflags = [ + "-Wl,--fatal-warnings", + "-fPIC", + "-Wl,--as-needed", + "-fuse-ld=lld", + "-Wl,--icf=all", + "-m64", + "-static", + "-rtlib=compiler-rt", + "-stdlib=libc++", + "-std=c++17", + "-lunwind", + "-lpthread", + "-Qunused-arguments", + "-target", + "x86_64-pc-windows-gnu", + ] + output_extension = "dll" + defines += [ "KOALA_WINDOWS" ] + sources += [ "../../interop/src/cpp/napi/win-dynamic-node.cc" ] + } +} + +action("es2panda_lib_copy") { + script = "gn/command/copy.py" + outputs = [ + "$target_out_dir/es2panda.node" + ] + if (build_ohos_sdk) { + deps = [ + ":es2panda_lib" + ] + } else { + deps = [ + ":es2panda_lib(${host_toolchain})" + ] + } + args = [ + "--from-path", rebase_path(root_out_dir), + "--to-path", rebase_path("."), + "--current-os", current_os, + "--current-cpu", current_cpu + ] +} + +if (current_toolchain == host_toolchain) { + npm_cmd("regenerate") { + assert(current_toolchain == host_toolchain, "must be executed with host_toolchain") + outputs = [ + "$target_out_dir/regenerate" + ] + deps = [ + "$ui2abc_root:ui2abc_install_all(${host_toolchain})", + "$ui2abc_root:ui2abc_panda_sdk" + ] + project_path = rebase_path(".") + run_tasks = [ "regenerate" ] + } +} + +if (current_toolchain == host_toolchain) { + npm_install("libarkts_install") { + outputs = [ + "$target_out_dir/libarkts_install" + ] + deps = [ + "$ui2abc_root:ui2abc_install(${host_toolchain})" + ] + project_path = rebase_path(".") + } +} + +action("libarkts_sdk_copy") { + script = "../gn/command/copy_libs.py" + args = [ + "--source_path", rebase_path(get_path_info(".", "abspath")), + "--output_path", rebase_path("$target_gen_dir"), + "--root_out_dir", rebase_path(root_out_dir), + ] + outputs = [ "$target_gen_dir" ] + deps = [ + "$ui2abc_root:ui2abc" + ] +} + +# Use from OHOS-SDK build (//build/ohos/sdk/ohos_sdk_description_std.json) + +ohos_copy("libarkts-sdk") { + deps = [ + ":libarkts_sdk_copy" + ] + sources = [ rebase_path("$target_gen_dir") ] + outputs = [ target_out_dir + "/$target_name" ] + module_source_dir = target_out_dir + "/$target_name" + module_install_name = "" + subsystem_name = "arkui" + part_name = "ace_engine" +} + +# for //developtools/ace_ets2bundle + +npm_cmd("libarkts_compile") { + deps = [ + ":regenerate(${host_toolchain})" + ] + outputs = [ + "$target_out_dir/libarkts.js" + ] + project_path = rebase_path(".") + run_tasks = [ "compile:koala:interop", "compile:js" ] +} + +group("es2panda") { + deps = [ + ":es2panda_lib_copy", + ":libarkts_compile(${host_toolchain})" + ] +} + +group("libarkts") { + deps = [ + ":es2panda_lib", + ":libarkts_compile(${host_toolchain})" + ] +} \ No newline at end of file diff --git a/ets1.2/libarkts/arktsconfig-direct.json b/ets1.2/libarkts/arktsconfig-direct.json new file mode 100644 index 0000000000000000000000000000000000000000..c97e444a7ff927fceeb4e4ac31a05a0cd4cfe973 --- /dev/null +++ b/ets1.2/libarkts/arktsconfig-direct.json @@ -0,0 +1,20 @@ +{ + "compilerOptions": { + "outDir": "./build/abc", + "baseUrl": ".", + "paths": { + "@koalaui/compat": [ "../../incremental/compat/src/arkts" ], + "#platform": [ "../../incremental/compat/src/arkts" ], + "@koalaui/common": [ "../../incremental/common/src" ], + "@koalaui/runtime": [ "../../incremental/runtime/ets" ], + "@koalaui/runtime/annotations": [ "../../incremental/runtime/annotations" ] + }, + "plugins": [ + { + "transform": "../memo-plugin", + "state": "checked", + "name": "memo" + } + ] + } +} diff --git a/ets1.2/libarkts/arktsconfig.json b/ets1.2/libarkts/arktsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..3ece19cfd09431daf8d0f38608dd54b419b04b58 --- /dev/null +++ b/ets1.2/libarkts/arktsconfig.json @@ -0,0 +1,25 @@ +{ + "compilerOptions": { + "package": "test", + "outDir": "./build/abc", + "baseUrl": ".", + "plugins": [ + { + "transform": "./lib/plugins/printer-plugin.js", + "state": "parsed", + "name": "printer" + }, + { + "transform": "./lib/plugins/printer-plugin.js", + "state": "checked", + "name": "printer" + }, + { + "transform": "./lib/plugins/printer-plugin.js", + "state": "checked", + "name": "printer2" + } + ] + }, + "include": ["./plugins/input/main.ets", "./plugins/input/library.ets"] +} diff --git a/ets1.2/libarkts/generator/options.json5 b/ets1.2/libarkts/generator/options.json5 new file mode 100644 index 0000000000000000000000000000000000000000..e8c2170976343b7789979863180ff8df8da1a5a0 --- /dev/null +++ b/ets1.2/libarkts/generator/options.json5 @@ -0,0 +1,543 @@ +/* + * 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. + */ + +{ + "irHack": [ + "AnnotationUsage", + "ETSFunctionType", + "ETSUnionType", + "ETSNullType", + "ETSUndefinedType", + ], + "ignore": { + "full": [ + "es2panda_Config", + "es2panda_ExternalSource", + "es2panda_OverloadInfo", + "es2panda_GlobalContext", + + // Duplicates of types in ir namespace + // They will be removed in the fututre. + 'es2panda_Signature', + 'es2panda_CheckerContext', + 'es2panda_Type', + 'es2panda_TypeRelation', + 'es2panda_GlobalTypesHolder', + 'es2panda_Variable', + 'es2panda_Scope', + 'es2panda_Path', + 'es2panda_ResolveResult', + 'es2panda_RecordTable', + 'es2panda_BoundContext', + 'es2panda_ImportPathManager', + 'es2panda_Options', + 'es2panda_AstNode', + 'es2panda_Program', + 'es2panda_ArkTsConfig', + 'es2panda_FunctionSignature', + + 'NodeTransformer', + 'NodeTraverser', + 'AstNodeForEachFunction', + 'ClassBuilder', + 'ClassInitializerBuilder', + 'MethodBuilder', + 'NodePredicate', + 'PropertyProcessor', + 'PropertyTraverser', + + 'checker.*', + 'varbinder.*', + 'parser.*', + 'util.*', + 'gen.*', + 'es2panda.*', + 'ast_verifier.*', + + 'parser.Program!', + 'es2panda.ArkTsConfig!', + // Do not support node type + //'varbinder.FunctionDecl!', + //'varbinder.InterfaceDecl!', + // MemberExpression has checker.ETSFunctionType ExtensionAccessorTypeConst(es2panda_Context context); + //'checker.ETSFunctionType!', + //'ir.ETSFunctionType', + + 'ir.Annotated', + 'ir.AnnotationAllowed', + 'ir.Typed', + 'ir.VectorIterationGuard', + + 'VoidPtr', + ], + "partial": [ + { + interface: "es2panda_Impl", + methods: [ + "LogSyntaxError", "LogWarning", "LogTypeError", // wrong idl + "DestroyContext", // cleanup arena (Improve: move this cleanup to another method) + ], + }, + { + interface: "MethodDefinition", + methods: [ + "GetOverloadInfo", // return type is wrong + ] + }, + { + interface: "AnnotationDeclaration", + methods: [ + "PropertiesPtrConst" // interfaces create-to-param matching + ] + }, + { + interface: "NumberLiteral", + methods: [ + "SetInt", + "SetLong", + "SetDouble", + "SetFloat" + ] + }, + { + interface: "AnnotationUsage", + methods: [ + "PropertiesPtrConst" // interfaces create-to-param matching + ] + }, + { + interface: "TSInterfaceBody", + methods: [ + "BodyPtr" // interfaces create-to-param matching + ] + }, + { + interface: "Signature", + methods: [ + "ProtectionFlagConst" // u8 + ] + }, + { + interface: "ETSReExportDeclaration", + methods: [ + "Create", // sequence + "Update", // sequence + "GetUserPathsConst" // sequence + ] + }, + { + interface: "CharLiteral", + methods: [ + "Create1", // KShort, + "Update1", // KShort + "CharConst", // KShort + ] + }, + { + interface: "ForUpdateStatement", + methods: [ + "Update" // forbidden naming + ] + }, + { + interface: "CallExpression", + methods: [ + "Update" // differs from handwritten + ] + }, + { + interface: "TryStatement", + methods: [ + "AddFinalizerInsertion" // idl missing const + ] + }, + { + interface: "MemberExpression", + methods: [ + "SetExtensionAccessorType" // ETSFunction type ambiguity + ] + }, + { + interface: "ArkTsConfig", + methods: [ + "EntriesConst", + "FilesConst", + "Parse", + ] + }, + ] + }, + nonNullable: [ + { + name: "ScriptFunction", + methods: [ + { + name: "SetIdent", + types: ["id"] + } + ] + }, + { + name: "ArrowFunctionExpression", + methods: [ + { + name: "FunctionConst", + types: ["returnType"] + } + ] + }, + { + name : "FunctionDeclaration", + methods: [ + { + name: "FunctionConst", + types: ["returnType"] + } + ] + }, + { + name: "CallExpression", + methods: [ + { + name: "CalleeConst", + types: ["returnType"] + } + ] + }, + { + name : "ExpressionStatement", + methods: [ + { + name: "GetExpressionConst", + types: ["returnType"] + } + ] + }, + { + name: "IfStatement", + methods: [ + { + name: "TestConst", + types: ["returnType"] + }, + { + name: "ConsequentConst", + types: ["returnType"] + } + ] + }, + { + name: "MemberExpression", + methods: [ + { + name: "ObjectConst", + types: ["returnType"] + }, + { + name: "PropertyConst", + types: ["returnType"] + } + ] + }, + { + name: "ETSParameterExpression", + methods: [ + { + name: "IdentConst", + types: ["returnType"] + } + ] + }, + { + name: "VariableDeclarator", + methods: [ + { + name: "IdConst", + types: ["returnType"] + } + ] + }, + { + name: "ClassElement", + methods: [ + { + name: "IdConst", + types: ["returnType"] + } + ] + }, + { + name: "MethodDefinition", + methods: [ + { + name: "FunctionConst", + types: ["returnType"] + }, + ] + }, + { + name: "ETSFunctionType", + methods: [ + { + name: "ReturnTypeConst", + types: ["returnType"] + } + ] + }, + { + name: "TSTypeAliasDeclaration", + methods: [ + { + name: "TypeAnnotationConst", + types: ["returnType"] + } + ] + }, + { + name: "Program", + methods: [ + { + name: "Ast", + types: ["returnType"] + } + ] + }, + { + name: "ClassDeclaration", + methods: [ + { + name: "Definition", + types: ["returnType"] + } + ] + }, + ], + fragments: [ + { + interface: "MethodDefinition", + methods: [ + { + name: "setChildrenParentPtr", + definition: "extension_MethodDefinitionSetChildrenParentPtr", + }, + { + name: "onUpdate", + definition: "extension_MethodDefinitionOnUpdate", + }, + ] + }, + { + interface: "ETSModule", + methods: [ + { + name: "getNamespaceFlag", + definition: "extension_ETSModuleGetNamespaceFlag", + } + ] + }, + { + interface: "ScriptFunction", + methods: [ + { + name: "getSignaturePointer", + definition: "extension_ScriptFunctionGetSignaturePointer", + }, + { + name: "setSignaturePointer", + definition: "extension_ScriptFunctionSetSignaturePointer", + }, + { + name: "getPreferredReturnTypePointer", + definition: "extension_ScriptFunctionGetPreferredReturnTypePointer", + }, + { + name: "setPreferredReturnTypePointer", + definition: "extension_ScriptFunctionSetPreferredReturnTypePointer", + }, + ] + }, + { + interface: "ClassDefinition", + methods: [ + { + name: "setBody", + definition: "extension_ClassDefinitionSetBody", + }, + ] + }, + { + interface: "Expression", + methods: [ + { + name: "getPreferredTypePointer", + definition: "extension_ExpressionGetPreferredTypePointer", + }, + { + name: "setPreferredTypePointer", + definition: "extension_ExpressionSetPreferredTypePointer", + }, + ] + }, + { + interface: "Program", + methods: [ + { + name: "getExternalSources", + definition: "extension_ProgramGetExternalSources", + }, + ], + }, + { + interface: "es2panda_SourcePosition", + methods: [ + { + name: "getLine", + definition: "extension_SourcePositionGetLine", + }, + { + name: "getCol", + definition: "extension_SourcePositionGetCol", + }, + { + name: "toString", + definition: "extension_SourcePositionToString", + }, + ], + }, + { + interface: "NumberLiteral", + methods: [ + { + name: "value", + definition: "extension_NumberLiteralValue", + }, + ], + }, + ], + parameters: [ + { + interface: "ArrowFunctionExpression", + parameters: [ + { + name: "annotations", + }, + ], + }, + { + interface: "CallExpression", + parameters: [ + { + name: "trailingBlock", + }, + ], + }, + { + interface: "ClassDeclaration", + parameters: [ + { + name: "modifierFlags", + }, + ], + }, + { + interface: "ClassDefinition", + parameters: [ + { + name: "annotations", + }, + ], + }, + { + interface: "ClassProperty", + parameters: [ + { + name: "annotations", + }, + ], + }, + { + interface: "ETSFunctionType", + parameters: [ + { + name: "annotations", + }, + ], + }, + { + interface: "ETSParameterExpression", + parameters: [ + { + name: "annotations", + }, + ], + }, + { + interface: "ETSUnionType", + parameters: [ + { + name: "annotations", + }, + ], + }, + { + interface: "MethodDefinition", + parameters: [ + { + name: "overloads", + }, + ], + }, + { + interface: "ScriptFunction", + parameters: [ + { + name: "ident", + setter: "setIdent", + getter: "id", + }, + { + name: "annotations", + }, + ], + }, + { + interface: "TSInterfaceDeclaration", + parameters: [ + { + name: "modifierFlags", + }, + ], + }, + { + interface: "TSTypeAliasDeclaration", + parameters: [ + { + name: "annotations", + }, + { + name: "modifierFlags", + }, + ], + }, + { + interface: "VariableDeclaration", + parameters: [ + { + name: "annotations", + }, + ], + }, + ], +} diff --git a/ets1.2/libarkts/gn/command/copy.py b/ets1.2/libarkts/gn/command/copy.py new file mode 100755 index 0000000000000000000000000000000000000000..9b360ab835b81842b52348aa4dc8c50a15f29d14 --- /dev/null +++ b/ets1.2/libarkts/gn/command/copy.py @@ -0,0 +1,89 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# 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 argparse +import os +import shutil +import subprocess +import sys + +def get_compiler_name(os, cpu): + if (os == 'mingw' and cpu == 'x86_64'): + return 'mingw_x86_64' + return 'clang_x64' + +def library_ext(os, cpu): + if (os == 'mingw' and cpu == 'x86_64'): + return 'dll' + return 'node' + +def copy_files(source_path, dest_path, is_file=False): + try: + if is_file: + os.makedirs(os.path.dirname(dest_path), exist_ok=True) + shutil.copy(source_path, dest_path) + else: + shutil.copytree(source_path, dest_path, dirs_exist_ok=True, + symlinks=True) + except Exception as err: + raise Exception("Copy files failed. Error: " + str(err)) from err + + +def run_cmd(cmd, execution_path=None): + proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, + stdin=subprocess.PIPE, + stderr=subprocess.PIPE, + cwd=execution_path) + stdout, stderr = proc.communicate(timeout=1000) + if proc.returncode != 0: + raise Exception(stdout.decode() + stderr.decode()) + + + +def copy_output(options): + + compiler = get_compiler_name(options.current_os, options.current_cpu) + library_extention = library_ext(options.current_os, options.current_cpu) + + from_path = options.from_path + to_path = options.to_path + + head_dir, tail_dir = os.path.split(from_path) + if (tail_dir == compiler): + from_path = head_dir + + + copy_files(os.path.join(from_path, f'{compiler}/libes2panda_lib.{library_extention}'), + os.path.join(to_path, 'build/native/build/es2panda.node'), True) + + +def parse_args(): + parser = argparse.ArgumentParser() + parser.add_argument('--from-path', help='path to output') + parser.add_argument('--to-path', help='path to root out') + parser.add_argument('--current-os', help='current OS') + parser.add_argument('--current-cpu', help='current CPU') + + options = parser.parse_args() + return options + + +def main(): + options = parse_args() + copy_output(options) + + +if __name__ == '__main__': + sys.exit(main()) \ No newline at end of file diff --git a/ets1.2/libarkts/native/meson.build b/ets1.2/libarkts/native/meson.build new file mode 100644 index 0000000000000000000000000000000000000000..f71b55ef82d59c8cfef448984472b4434fe35550 --- /dev/null +++ b/ets1.2/libarkts/native/meson.build @@ -0,0 +1,127 @@ +# 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. + +project( + 'es2panda_interop', + 'cpp', + version: '1.0', + default_options: [ + 'cpp_std=c++17', + 'buildtype=release', + ], +) +is_cross = get_option('cross_compile') + +sources = [ + './src/common.cc', + './src/bridges.cc', + './src/generated/bridges.cc', + get_option('interop_src_dir') / 'common-interop.cc', + get_option('interop_src_dir') / 'callback-resource.cc', + get_option('interop_src_dir') / 'interop-logging.cc', + get_option('interop_src_dir') / 'napi' / 'convertors-napi.cc', +] + +cflags = [ + '-DKOALA_INTEROP_MODULE=NativeModule', + '-DINTEROP_LIBRARY_NAME=' + get_option('lib_name'), + '-DKOALA_USE_NODE_VM', + '-DKOALA_NAPI', +] + +if (host_machine.system() == 'windows') + cflags += ['-DKOALA_WINDOWS'] + # apply node.exe symbol loading hook + sources += [ + get_option('interop_src_dir') / 'napi/win-dynamic-node.cc' + ] +else + cflags += ['-DKOALA_LINUX'] +endif + +arch = target_machine.cpu() + +oses = { 'darwin': 'macos' } # rename meson default names to convenient ones +archs = { 'x86_64': 'x64', 'aarch64': 'arm64', 'armv7-a': 'arm32', 'wasm32': 'wasm' } + +os = target_machine.system() +os = oses.get(os, os) +arch = target_machine.cpu() +arch = archs.get(arch, arch) + +cflags_cross = [] +cflags_host = [] +suffix_host = '_' + os + '_' + arch +suffix_cross = '' + +if get_option('cross_compile') +if arch == 'arm64' +cflags_cross = ['--target=x86_64-linux-gnu'] +suffix_cross = '_' + os + '_x64' +endif +if arch == 'x64' +cflags_cross = ['--target=aarch64-linux-gnu'] +suffix_cross = '_' + os + '_arm64' +endif +endif + +shared_library( + get_option('lib_name') + suffix_host, + sources, + override_options: [ + 'b_lundef=false', + ], + install: true, + name_prefix: '', + name_suffix: 'node', + include_directories: [ + './src/', + get_option('panda_sdk_dir') / 'ohos_arm64/include/tools/es2panda/public', + get_option('panda_sdk_dir') / 'ohos_arm64/include/tools/es2panda', + get_option('interop_src_dir'), + get_option('interop_src_dir') / 'types', + get_option('interop_src_dir') / 'napi', + get_option('node_modules_dir') / 'node-api-headers/include', + get_option('node_modules_dir') / 'node-addon-api', + ], + cpp_args: cflags + cflags_host, + link_args: [cflags_host], + dependencies: [] +) + +if is_cross + # sudo apt install g++-aarch64-linux-gnu binutils-aarch64-linux-gnu + shared_library( + get_option('lib_name') + suffix_cross, + sources, + override_options: [ + 'b_lundef=false', + ], + install: true, + name_prefix: '', + name_suffix: 'node', + include_directories: [ + './src/', + get_option('panda_sdk_dir') / 'ohos_arm64/include/tools/es2panda/public', + get_option('panda_sdk_dir') / 'ohos_arm64/include/tools/es2panda', + get_option('interop_src_dir'), + get_option('interop_src_dir') / 'types', + get_option('interop_src_dir') / 'napi', + get_option('node_modules_dir') / 'node-api-headers/include', + get_option('node_modules_dir') / 'node-addon-api', + ], + cpp_args: cflags + cflags_cross, + link_args: [cflags_cross], + dependencies: [] + ) +endif \ No newline at end of file diff --git a/ets1.2/libarkts/native/meson_options.txt b/ets1.2/libarkts/native/meson_options.txt new file mode 100644 index 0000000000000000000000000000000000000000..a59bde5ec5ec79c49d5033c733eb3cf5acbd70e1 --- /dev/null +++ b/ets1.2/libarkts/native/meson_options.txt @@ -0,0 +1,43 @@ +# 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. + +option( + 'node_modules_dir', + type : 'string', + value : '../../node_modules/', + description : 'path to node_modules' +) +option( + 'interop_src_dir', + type : 'string', + value : '../../../interop/src/cpp/', + description : 'path to koala interop cpp files' +) +option( + 'panda_sdk_dir', + type : 'string', + value : '../../../incremental/tools/panda/node_modules/@panda/sdk/', + description : 'path to panda sdk' +) +option( + 'lib_name', + type : 'string', + value : 'es2panda', + description : 'name of shared library' +) +option( + 'cross_compile', + type : 'boolean', + value : false, + description : 'whether to build binaries for all architectures or just for current' +) \ No newline at end of file diff --git a/ets1.2/libarkts/native/mingw.cross b/ets1.2/libarkts/native/mingw.cross new file mode 100644 index 0000000000000000000000000000000000000000..61007dbc506ba1fdfdd2805b666f92c2fed071f4 --- /dev/null +++ b/ets1.2/libarkts/native/mingw.cross @@ -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. + +[binaries] +c = 'x86_64-w64-mingw32-gcc' +cpp = 'x86_64-w64-mingw32-g++' +ar = 'x86_64-w64-mingw32-ar' +windres = 'x86_64-w64-mingw32-windres' +strip = 'x86_64-w64-mingw32-strip' +exe_wrapper = 'wine64' + +[host_machine] +system = 'windows' +cpu_family = 'x86_64' +cpu = 'x86_64' +endian = 'little' + diff --git a/ets1.2/libarkts/native/src/bridges.cc b/ets1.2/libarkts/native/src/bridges.cc new file mode 100644 index 0000000000000000000000000000000000000000..e3b1d2f91c33dc8511ff29511c41f5fb4f2c0b6a --- /dev/null +++ b/ets1.2/libarkts/native/src/bridges.cc @@ -0,0 +1,543 @@ +/* + * 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 "common.h" + +#include +#include +#include + +KNativePointer impl_AstNodeRebind(KNativePointer contextPtr, KNativePointer nodePtr) +{ + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + GetImpl()->AstNodeRebind(context, node); + return nullptr; +} +KOALA_INTEROP_2(AstNodeRebind, KNativePointer, KNativePointer, KNativePointer) + +KNativePointer impl_AnnotationAllowedAnnotations(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer returnLen) +{ + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + std::size_t params_len = 0; + auto annotations = GetImpl()->AnnotationAllowedAnnotations(context, node, ¶ms_len); + return StageArena::cloneVector(annotations, params_len); +} +KOALA_INTEROP_3(AnnotationAllowedAnnotations, KNativePointer, KNativePointer, KNativePointer, KNativePointer) + +KNativePointer impl_AnnotationAllowedAnnotationsConst(KNativePointer contextPtr, KNativePointer nodePtr, KNativePointer returnLen) +{ + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + std::size_t params_len = 0; + auto annotations = GetImpl()->AnnotationAllowedAnnotationsConst(context, node, ¶ms_len); + return StageArena::cloneVector(annotations, params_len); +} +KOALA_INTEROP_3(AnnotationAllowedAnnotationsConst, KNativePointer, KNativePointer, 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_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_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) + +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_SignatureFunction(KNativePointer context, KNativePointer classInstance) +{ + const auto _context = reinterpret_cast(context); + const auto _classInstance = reinterpret_cast(classInstance); + const auto result = GetImpl()->SignatureFunction(_context, _classInstance); + return result; +} +KOALA_INTEROP_2(SignatureFunction, KNativePointer, KNativePointer, KNativePointer) + +static KNativePointer impl_ProgramExternalSources(KNativePointer contextPtr, KNativePointer instancePtr) +{ + auto context = reinterpret_cast(contextPtr); + auto&& instance = reinterpret_cast(instancePtr); + std::size_t source_len = 0; + auto external_sources = GetImpl()->ProgramExternalSources(context, instance, &source_len); + return StageArena::cloneVector(external_sources, source_len); +} +KOALA_INTEROP_2(ProgramExternalSources, KNativePointer, KNativePointer, KNativePointer); + +static KNativePointer impl_ProgramDirectExternalSources(KNativePointer contextPtr, KNativePointer instancePtr) +{ + auto context = reinterpret_cast(contextPtr); + auto&& instance = reinterpret_cast(instancePtr); + std::size_t sourceLen = 0; + auto externalSources = GetImpl()->ProgramDirectExternalSources(context, instance, &sourceLen); + return new std::vector(externalSources, externalSources + sourceLen); +} +KOALA_INTEROP_2(ProgramDirectExternalSources, KNativePointer, KNativePointer, KNativePointer); + +static KNativePointer impl_ProgramSourceFilePath(KNativePointer contextPtr, KNativePointer instancePtr) +{ + auto context = reinterpret_cast(contextPtr); + auto&& instance = reinterpret_cast(instancePtr); + auto&& result = GetImpl()->ProgramSourceFilePathConst(context, instance); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ProgramSourceFilePath, KNativePointer, KNativePointer, KNativePointer); + +static KNativePointer impl_ExternalSourceName(KNativePointer instance) +{ + auto&& _instance_ = reinterpret_cast(instance); + auto&& result = GetImpl()->ExternalSourceName(_instance_); + return StageArena::strdup(result); +} +KOALA_INTEROP_1(ExternalSourceName, KNativePointer, KNativePointer); + +static KNativePointer impl_ExternalSourcePrograms(KNativePointer instance) +{ + auto&& _instance_ = reinterpret_cast(instance); + std::size_t program_len = 0; + auto programs = GetImpl()->ExternalSourcePrograms(_instance_, &program_len); + return StageArena::cloneVector(programs, program_len); +} +KOALA_INTEROP_1(ExternalSourcePrograms, KNativePointer, KNativePointer); + +KNativePointer impl_ETSParserBuildImportDeclaration(KNativePointer context, KInt importKinds, KNativePointerArray specifiers, KUInt specifiersSequenceLength, KNativePointer source, KNativePointer program, KInt importFlag) +{ + 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); + + return GetImpl()->ETSParserBuildImportDeclaration(_context, _kinds, _specifiers, _specifiersSequenceLength, _source, _program, _importFlag); +} +KOALA_INTEROP_7(ETSParserBuildImportDeclaration, KNativePointer, KNativePointer, KInt, KNativePointerArray, KUInt, KNativePointer, KNativePointer, KInt) + +KNativePointer impl_ETSParserGetImportPathManager(KNativePointer contextPtr) +{ + auto context = reinterpret_cast(contextPtr); + return GetImpl()->ETSParserGetImportPathManager(context); +} +KOALA_INTEROP_1(ETSParserGetImportPathManager, KNativePointer, KNativePointer); + +KInt impl_SourcePositionCol(KNativePointer context, KNativePointer instance) +{ + auto&& _context_ = reinterpret_cast(context); + auto&& _instance_ = reinterpret_cast(instance); + return GetImpl()->SourcePositionCol(_context_, _instance_); +} +KOALA_INTEROP_2(SourcePositionCol, KInt, KNativePointer, KNativePointer); + +KNativePointer impl_ConfigGetOptions(KNativePointer config) +{ + const auto _config = reinterpret_cast(config); + auto result = GetImpl()->ConfigGetOptions(_config); + return (void*)result; +} +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) + +KNativePointer impl_CreateCacheContextFromFile(KNativePointer configPtr, KStringPtr& source_file_namePtr, KNativePointer globalContextPtr, KBoolean isExternal) { + auto config = reinterpret_cast(configPtr); + auto globalContext = reinterpret_cast(globalContextPtr); + return GetImpl()->CreateCacheContextFromFile(config, getStringCopy(source_file_namePtr), globalContext, isExternal); +} +KOALA_INTEROP_4(CreateCacheContextFromFile, KNativePointer, KNativePointer, KStringPtr, KNativePointer, KBoolean) + +KNativePointer impl_CreateGlobalContext(KNativePointer configPtr, KStringArray externalFileListPtr, KUInt fileNum, KBoolean LspUsage) { + auto config = reinterpret_cast(configPtr); + const int headerLen = 4; + const char** files = StageArena::allocArray(fileNum); + uint8_t* filesPtr = (uint8_t*)externalFileListPtr; + std::size_t position = headerLen; + std::size_t strLen; + for (std::size_t i = 0; i < static_cast(fileNum); ++i) { + strLen = unpackUInt(filesPtr + position); + position += headerLen; + files[i] = StageArena::strdup(std::string(reinterpret_cast(filesPtr + position), strLen).c_str()); + position += strLen; + } + return GetImpl()->CreateGlobalContext(config, files, fileNum, LspUsage); +} +KOALA_INTEROP_4(CreateGlobalContext, KNativePointer, KNativePointer, KStringArray, KUInt, KBoolean) + +void impl_DestroyGlobalContext(KNativePointer globalContextPtr) { + auto globalContext = reinterpret_cast(globalContextPtr); + GetImpl()->DestroyGlobalContext(globalContext); +} +KOALA_INTEROP_V1(DestroyGlobalContext, KNativePointer) + +// All these "Checker_" bridges are related to checker namespace in es2panda, so work with them carefully +// Checker.Type does reset on recheck, so modifying them makes no sence +// It seems that compiler does not provide API to convert Checker.Type to ir.Type +KNativePointer impl_Checker_CreateOpaqueTypeNode(KNativePointer context, KNativePointer type) +{ + auto _context = reinterpret_cast(context); + auto _type = reinterpret_cast(type); + return GetImpl()->CreateOpaqueTypeNode(_context, _type); +} +KOALA_INTEROP_2(Checker_CreateOpaqueTypeNode, KNativePointer, KNativePointer, KNativePointer) + +KNativePointer impl_Checker_ScriptFunctionSignature(KNativePointer context, KNativePointer node) +{ + auto _context = reinterpret_cast(context); + auto _node = reinterpret_cast(node); + return GetImpl()->ScriptFunctionSignature(_context, _node); +} +KOALA_INTEROP_2(Checker_ScriptFunctionSignature, KNativePointer, KNativePointer, KNativePointer) + +void impl_Checker_ScriptFunctionSetSignature(KNativePointer context, KNativePointer node, KNativePointer signature) +{ + auto _context = reinterpret_cast(context); + auto _node = reinterpret_cast(node); + auto _signature = reinterpret_cast(signature); + GetImpl()->ScriptFunctionSetSignature(_context, _node, _signature); + return; +} +KOALA_INTEROP_V3(Checker_ScriptFunctionSetSignature, KNativePointer, KNativePointer, KNativePointer) + +KNativePointer impl_Checker_SignatureReturnType(KNativePointer context, KNativePointer signature) +{ + auto _context = reinterpret_cast(context); + auto _signature = reinterpret_cast(signature); + return GetImpl()->SignatureReturnType(_context, _signature); +} +KOALA_INTEROP_2(Checker_SignatureReturnType, KNativePointer, KNativePointer, KNativePointer) + +KNativePointer impl_Checker_ScriptFunctionGetPreferredReturnType(KNativePointer context, KNativePointer node) +{ + auto _context = reinterpret_cast(context); + auto _node = reinterpret_cast(node); + return GetImpl()->ScriptFunctionGetPreferredReturnType(_context, _node); +} +KOALA_INTEROP_2(Checker_ScriptFunctionGetPreferredReturnType, KNativePointer, KNativePointer, KNativePointer) + +void impl_Checker_ScriptFunctionSetPreferredReturnType(KNativePointer context, KNativePointer node, KNativePointer type) +{ + auto _context = reinterpret_cast(context); + auto _node = reinterpret_cast(node); + auto _type = reinterpret_cast(type); + GetImpl()->ScriptFunctionSetPreferredReturnType(_context, _node, _type); + return; +} +KOALA_INTEROP_V3(Checker_ScriptFunctionSetPreferredReturnType, KNativePointer, KNativePointer, KNativePointer) + +KNativePointer impl_Checker_ExpressionGetPreferredType(KNativePointer context, KNativePointer node) +{ + auto _context = reinterpret_cast(context); + auto _node = reinterpret_cast(node); + return GetImpl()->ExpressionPreferredTypeConst(_context, _node); +} +KOALA_INTEROP_2(Checker_ExpressionGetPreferredType, KNativePointer, KNativePointer, KNativePointer) + +void impl_Checker_ExpressionSetPreferredType(KNativePointer context, KNativePointer node, KNativePointer type) +{ + auto _context = reinterpret_cast(context); + auto _node = reinterpret_cast(node); + auto _type = reinterpret_cast(type); + GetImpl()->ExpressionSetPreferredType(_context, _node, _type); + return; +} +KOALA_INTEROP_V3(Checker_ExpressionSetPreferredType, KNativePointer, KNativePointer, KNativePointer) + +KNativePointer impl_Checker_TypeToString(KNativePointer context, KNativePointer type) +{ + auto _context = reinterpret_cast(context); + auto _type = reinterpret_cast(type); + auto result = GetImpl()->TypeToStringConst(_context, _type); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(Checker_TypeToString, KNativePointer, KNativePointer, KNativePointer) + +KNativePointer impl_Checker_TypeClone(KNativePointer context, KNativePointer type) +{ + auto _context = reinterpret_cast(context); + auto _type = reinterpret_cast(type); + return GetImpl()->TypeClone(_context, _type); +} +KOALA_INTEROP_2(Checker_TypeClone, KNativePointer, KNativePointer, KNativePointer) + +KNativePointer impl_Checker_TypeNodeGetType(KNativePointer context, KNativePointer astNode) +{ + auto _context = reinterpret_cast(context); + auto _astNode = reinterpret_cast(astNode); + return GetImpl()->TypeNodeGetType(_context, _astNode); +} +KOALA_INTEROP_2(Checker_TypeNodeGetType, KNativePointer, KNativePointer, KNativePointer) + +// From koala-wrapper +// Improve: check if some code should be generated + +std::set globalStructInfo; +#ifdef _GLIBCXX_HAS_GTHREADS +std::mutex g_structMutex; +#endif + +void impl_InsertGlobalStructInfo(KNativePointer contextPtr, KStringPtr& instancePtr) +{ +#ifdef _GLIBCXX_HAS_GTHREADS + std::lock_guard lock(g_structMutex); +#endif + globalStructInfo.insert(getStringCopy(instancePtr)); + return; +} +KOALA_INTEROP_V2(InsertGlobalStructInfo, KNativePointer, KStringPtr); + +KBoolean impl_HasGlobalStructInfo(KNativePointer contextPtr, KStringPtr& instancePtr) +{ +#ifdef _GLIBCXX_HAS_GTHREADS + std::lock_guard lock(g_structMutex); +#endif + return globalStructInfo.count(getStringCopy(instancePtr)); +} +KOALA_INTEROP_2(HasGlobalStructInfo, KBoolean, KNativePointer, KStringPtr); + +KNativePointer impl_ClassVariableDeclaration(KNativePointer context, KNativePointer classInstance) +{ + const auto _context = reinterpret_cast(context); + const auto _classInstance = reinterpret_cast(classInstance); + auto _typedTsType = GetImpl()->TypedTsType(_context, _classInstance); + if (_typedTsType == nullptr) { + return nullptr; + } + const auto _instanceType = reinterpret_cast(_typedTsType); + auto _typeVar = GetImpl()->TypeVariable(_context, _instanceType); + if (_typeVar == nullptr) { + return nullptr; + } + const auto result = reinterpret_cast(GetImpl()->VariableDeclaration(_context, _typeVar)); + const auto declNode = GetImpl()->DeclNode(_context, result); + return declNode; +} +KOALA_INTEROP_2(ClassVariableDeclaration, KNativePointer, KNativePointer, 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 StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSInterfaceBodyBodyPtr, KNativePointer, KNativePointer, KNativePointer); + +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 StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(AnnotationDeclarationPropertiesPtrConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSParserGetGlobalProgramAbsName(KNativePointer contextPtr) +{ + auto context = reinterpret_cast(contextPtr); + auto result = GetImpl()->ETSParserGetGlobalProgramAbsName(context); + return new std::string(result); +} +KOALA_INTEROP_1(ETSParserGetGlobalProgramAbsName, KNativePointer, KNativePointer) + +KNativePointer impl_CreateDiagnosticKind(KNativePointer context, KStringPtr& message, KInt type) +{ + const auto _context = reinterpret_cast(context); + const auto _message = getStringCopy(message); + const auto _type = static_cast(type); + return const_cast(GetImpl()->CreateDiagnosticKind(_context, _message, _type)); +} +KOALA_INTEROP_3(CreateDiagnosticKind, KNativePointer, KNativePointer, KStringPtr, KInt) + +KNativePointer impl_CreateDiagnosticInfo(KNativePointer context, KNativePointer kind, KStringArray argsPtr, + KInt argc, KNativePointer pos) +{ + const auto _context = reinterpret_cast(context); + const auto _kind = reinterpret_cast(kind); + const auto _pos = reinterpret_cast(pos); + const std::size_t headerLen = 4; + const char** _args = new const char*[argc]; + std::size_t position = headerLen; + std::size_t strLen; + for (std::size_t i = 0; i < static_cast(argc); ++i) { + strLen = unpackUInt(argsPtr + position); + position += headerLen; + _args[i] = strdup(std::string(reinterpret_cast(argsPtr + position), strLen).c_str()); + position += strLen; + } + return GetImpl()->CreateDiagnosticInfo(_context, _kind, _args, argc, _pos); +} +KOALA_INTEROP_5(CreateDiagnosticInfo, KNativePointer, KNativePointer, KNativePointer, + KStringArray, KInt, KNativePointer) + +KNativePointer impl_CreateSuggestionInfo(KNativePointer context, KNativePointer kind, KStringArray argsPtr, + KInt argc, KStringPtr& substitutionCode, KStringPtr& title, KNativePointer range) +{ + const auto _context = reinterpret_cast(context); + const auto _kind = reinterpret_cast(kind); + const auto _title = getStringCopy(title); + const auto _range = reinterpret_cast(range); + const std::size_t headerLen = 4; + const char** _args = new const char*[argc]; + std::size_t position = headerLen; + std::size_t strLen; + for (std::size_t i = 0; i < static_cast(argc); ++i) { + strLen = unpackUInt(argsPtr + position); + position += headerLen; + _args[i] = strdup(std::string(reinterpret_cast(argsPtr + position), strLen).c_str()); + position += strLen; + } + const auto _substitutionCode = getStringCopy(substitutionCode); + return GetImpl()->CreateSuggestionInfo(_context, _kind, _args, argc, _substitutionCode, _title, _range); +} +KOALA_INTEROP_7(CreateSuggestionInfo, KNativePointer, KNativePointer, KNativePointer, KStringArray, KInt, + KStringPtr, KStringPtr, KNativePointer) + +void impl_LogDiagnostic(KNativePointer context, KNativePointer kind, KStringArray argvPtr, + KInt argc, KNativePointer pos) +{ + auto&& _context_ = reinterpret_cast(context); + auto&& _kind_ = reinterpret_cast(kind); + auto&& _pos_ = reinterpret_cast(pos); + const std::size_t headerLen = 4; + const char** argv = new const char*[argc]; + std::size_t position = headerLen; + std::size_t strLen; + for (std::size_t i = 0; i < static_cast(argc); ++i) { + strLen = unpackUInt(argvPtr + position); + position += headerLen; + argv[i] = strdup(std::string(reinterpret_cast(argvPtr + position), strLen).c_str()); + position += strLen; + } + GetImpl()->LogDiagnostic(_context_, _kind_, argv, argc, _pos_); +} +KOALA_INTEROP_V5(LogDiagnostic, KNativePointer, KNativePointer, KStringArray, KInt, KNativePointer) + +KNativePointer impl_AnnotationUsageIrPropertiesPtrConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->AnnotationUsageIrPropertiesPtrConst(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(AnnotationUsageIrPropertiesPtrConst, KNativePointer, KNativePointer, KNativePointer); + +KInt impl_GenerateTsDeclarationsFromContext(KNativePointer contextPtr, KStringPtr &outputDeclEts, KStringPtr &outputEts, + KBoolean exportAll, KBoolean isolated, KStringPtr &recordFile) +{ + auto context = reinterpret_cast(contextPtr); + return GetImpl()->GenerateTsDeclarationsFromContext(context, outputDeclEts.data(), outputEts.data(), exportAll, isolated, recordFile.data() ); +} +KOALA_INTEROP_6(GenerateTsDeclarationsFromContext, KInt, KNativePointer, KStringPtr, KStringPtr, KBoolean, KBoolean, KStringPtr) + +// Improve: simplify +KNativePointer impl_CreateContextGenerateAbcForExternalSourceFiles( + KNativePointer configPtr, KInt fileNamesCount, KStringArray fileNames) +{ + auto config = reinterpret_cast(configPtr); + const std::size_t headerLen = 4; + const char **argv = + new const char *[static_cast(fileNamesCount)]; + std::size_t position = headerLen; + std::size_t strLen; + for (std::size_t i = 0; i < static_cast(fileNamesCount); ++i) { + strLen = unpackUInt(fileNames + position); + position += headerLen; + argv[i] = strdup( + std::string(reinterpret_cast(fileNames + position), + strLen) + .c_str()); + position += strLen; + } + return GetImpl()->CreateContextGenerateAbcForExternalSourceFiles( + config, fileNamesCount, argv); +} +KOALA_INTEROP_3(CreateContextGenerateAbcForExternalSourceFiles, KNativePointer, KNativePointer, KInt, KStringArray) + +KInt impl_GetCompilationMode(KNativePointer configPtr) +{ + auto _config = reinterpret_cast(configPtr); + auto _options = const_cast(GetImpl()->ConfigGetOptions(_config)); + return GetImpl()->OptionsUtilGetCompilationModeConst(nullptr, _options); +} +KOALA_INTEROP_1(GetCompilationMode, KInt, KNativePointer); + +KNativePointer impl_CreateTypeNodeFromTsType(KNativePointer context, KNativePointer nodePtr) +{ + const auto _context = reinterpret_cast(context); + const auto _nodePtr = reinterpret_cast(nodePtr); + auto _tsType = GetImpl()->TypedTsType(_context, _nodePtr); + if (_tsType == nullptr) { + _tsType = GetImpl()->ExpressionTsType(_context, _nodePtr); + } + if (_tsType == nullptr) { + return nullptr; + } + const auto _nodeTsType = reinterpret_cast(_tsType); + auto _typeAnnotation = GetImpl()->CreateOpaqueTypeNode(_context, _nodeTsType); + return _typeAnnotation; +} +KOALA_INTEROP_2(CreateTypeNodeFromTsType, KNativePointer, KNativePointer, KNativePointer); \ No newline at end of file diff --git a/ets1.2/libarkts/native/src/common.cc b/ets1.2/libarkts/native/src/common.cc new file mode 100644 index 0000000000000000000000000000000000000000..6fea396a6952a7ea16624af4dde451f438b2b94b --- /dev/null +++ b/ets1.2/libarkts/native/src/common.cc @@ -0,0 +1,433 @@ +/* + * 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 "interop-types.h" + +using std::string, std::cout, std::endl, std::vector; + +es2panda_Impl *es2pandaImplementation = nullptr; +static thread_local StageArena currentArena; + +StageArena* StageArena::instance() +{ + return ¤tArena; +} + +void StageArena::add(void* pointer) +{ + if (pointer) + allocated.push_back(pointer); +} + +void StageArena::cleanup() +{ + if (totalSize > 0 && false) + printf("cleanup %d objects %d bytes\n", (int)allocated.size(), (int)totalSize); + for (auto it : allocated) { + free(it); + } + totalSize = 0; + allocated.clear(); +} + +StageArena::StageArena() +{ + totalSize = 0; +} + +StageArena::~StageArena() +{ + cleanup(); +} + +char* StageArena::strdup(const char* string) +{ + auto* arena = StageArena::instance(); + auto size = strlen(string) + 1; + char* memory = (char*)arena->alloc(size); + interop_memcpy(memory, size, string, size); + return memory; +} + +void* StageArena::alloc(size_t size) +{ + void* result = malloc(size); + if (!result) { + INTEROP_FATAL("Cannot allocate memory"); + } + totalSize += size; + add(result); + return result; +} + +#ifdef KOALA_WINDOWS + #include + #define PLUGIN_DIR "windows_host_tools" + #define LIB_PREFIX "lib" + #define LIB_SUFFIX ".dll" +#endif + +#if defined(KOALA_LINUX) || defined(KOALA_MACOS) + #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* DEFAULT_SDK_PATH = "../../../incremental/tools/panda/node_modules/@panda/sdk" ; +const char* NAME = LIB_PREFIX "es2panda-public" LIB_SUFFIX; + +const char* LIB_ES2PANDA_PUBLIC = LIB_PREFIX "es2panda_public" LIB_SUFFIX; +const char* IS_UI_FLAG = "IS_UI_FLAG"; +const char* NOT_UI_FLAG = "NOT_UI_FLAG"; +const string MODULE_SUFFIX = ".d.ets"; +const string ARKUI = "arkui"; + +#ifdef KOALA_WINDOWS + const char *SEPARATOR = "\\"; +#else + const char *SEPARATOR = "/"; +#endif +const char *LIB_DIR = "lib"; + +static std::string ES2PANDA_LIB_PATH = ""; + +std::string joinPath(vector &paths) +{ + std::string res; + for (std::size_t 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()); +} +KOALA_INTEROP_V1(SetUpSoPath, KStringPtr); + +// Improve: simplify this +void* FindLibrary() { + void *res = nullptr; + std::vector pathArray; + + // find by SetUpSoPath + if (!ES2PANDA_LIB_PATH.empty()) { + pathArray = {ES2PANDA_LIB_PATH, LIB_DIR, LIB_ES2PANDA_PUBLIC}; + res = loadLibrary(joinPath(pathArray)); + if (res) { + return res; + } + } + + // find by set PANDA_SDK_PATH + char* envValue = getenv("PANDA_SDK_PATH"); + if (envValue) { + pathArray = {envValue, PLUGIN_DIR, LIB_DIR, NAME}; + res = loadLibrary(joinPath(pathArray)); + if (res) { + return res; + } + } + + // find by set LD_LIBRARY_PATH + pathArray = {LIB_ES2PANDA_PUBLIC}; + res = loadLibrary(joinPath(pathArray)); + if (res) { + return res; + } + + // find by DEFAULT_SDK_PATH + pathArray = {DEFAULT_SDK_PATH, PLUGIN_DIR, LIB_DIR, NAME}; + res = loadLibrary(joinPath(pathArray)); + if (res) { + return res; + } + + return nullptr; +} + +es2panda_Impl *GetImplSlow() +{ + if (es2pandaImplementation) { + return es2pandaImplementation; + } + auto library = FindLibrary(); + if (!library) { + printf("No library (es2panda_lib.cc)"); + abort(); + } + auto symbol = findSymbol(library, "es2panda_GetImpl"); + if (!symbol) { + printf("no entry point"); + abort(); + } + es2pandaImplementation = reinterpret_cast(symbol)(ES2PANDA_LIB_VERSION); + return es2pandaImplementation; +} + +string getString(KStringPtr ptr) +{ + return ptr.data(); +} + +char* getStringCopy(KStringPtr& ptr) +{ + return StageArena::strdup(ptr.c_str() ? ptr.c_str() : ""); +} + +KNativePointer impl_CreateConfig(KInt argc, KStringArray argvPtr) { + const std::size_t headerLen = 4; + + const char** argv = StageArena::allocArray(argc); + std::size_t position = headerLen; + std::size_t strLen; + for (std::size_t i = 0; i < static_cast(argc); ++i) { + strLen = unpackUInt(argvPtr + position); + position += headerLen; + argv[i] = StageArena::strdup(std::string(reinterpret_cast(argvPtr + position), strLen).c_str()); + position += strLen; + } + 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) + +void impl_DestroyContext(KNativePointer contextPtr) { + auto context = reinterpret_cast(contextPtr); + GetImpl()->DestroyContext(context); + StageArena::instance()->cleanup(); +} +KOALA_INTEROP_V1(DestroyContext, KNativePointer) + +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()->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) + +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) ? (1 << 1) : 0) | + (GetImpl()->IdentifierIsTdzConst(context, node) ? (1 << 2) : 0); +} +KOALA_INTEROP_2(IdentifierIdentifierFlags, KInt, KNativePointer, KNativePointer) + +void impl_ClassDefinitionSetBody(KNativePointer context, KNativePointer receiver, KNativePointerArray body, KUInt bodyLength) { + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _body = reinterpret_cast(body); + const auto _bodyLength = static_cast(bodyLength); + GetImpl()->ClassDefinitionClearBody(_context, _receiver); + for (size_t i = 0; i < _bodyLength; i++) { + GetImpl()->ClassDefinitionEmplaceBody(_context, _receiver, _body[i]); + } +} +KOALA_INTEROP_V4(ClassDefinitionSetBody, KNativePointer, KNativePointer, KNativePointerArray, KUInt) + +/* +Improve: NOT FROM API (shouldn't be there) +----------------------------------------------------------------------------------------------------------------------------- +*/ + +es2panda_AstNode * cachedParentNode; +es2panda_Context * cachedContext; + +static void changeParent(es2panda_AstNode *child) +{ + GetImpl()->AstNodeSetParent(cachedContext, child, cachedParentNode); +} + +static void SetRightParent(es2panda_AstNode *node, void *arg) +{ + es2panda_Context *ctx = static_cast(arg); + cachedContext = ctx; + cachedParentNode = 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) + +void impl_AstNodeSetChildrenParentPtr(KNativePointer contextPtr, KNativePointer nodePtr) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + cachedParentNode = node; + + GetImpl()->AstNodeIterateConst(context, node, changeParent); +} +KOALA_INTEROP_V2(AstNodeSetChildrenParentPtr, KNativePointer, KNativePointer) + +void impl_AstNodeOnUpdate(KNativePointer context, KNativePointer newNode, KNativePointer replacedNode) { + auto _context = reinterpret_cast(context); + auto _newNode = reinterpret_cast(newNode); + auto _replacedNode = reinterpret_cast(replacedNode); + + // Assign original + auto _original = GetImpl()->AstNodeOriginalNodeConst(_context, _replacedNode); + if (!_original) { + _original = _replacedNode; + } + GetImpl()->AstNodeSetOriginalNode(_context, _newNode, _original); + + // Assign new node parent + auto _parent = GetImpl()->AstNodeParent(_context, _replacedNode); + if (_parent) { + GetImpl()->AstNodeSetParent(_context, _newNode, _parent); + } + + // Redirect children parent pointer to this node + impl_AstNodeSetChildrenParentPtr(context, newNode); +} +KOALA_INTEROP_V3(AstNodeOnUpdate, KNativePointer, KNativePointer, KNativePointer) + +std::vector cachedChildren; + +static void visitChild(es2panda_AstNode *node) +{ + cachedChildren.emplace_back(node); +} + +KNativePointer impl_AstNodeChildren( + KNativePointer contextPtr, + KNativePointer nodePtr +) { + auto context = reinterpret_cast(contextPtr); + auto node = reinterpret_cast(nodePtr); + cachedContext = context; + cachedChildren.clear(); + + GetImpl()->AstNodeIterateConst(context, node, visitChild); + return StageArena::clone(cachedChildren); +} +KOALA_INTEROP_2(AstNodeChildren, KNativePointer, KNativePointer, KNativePointer) + +/* +----------------------------------------------------------------------------------------------------------------------------- +*/ + +// From koala-wrapper +// Improve: check if some code should be generated + +void impl_MemInitialize() +{ + GetImpl()->MemInitialize(); +} +KOALA_INTEROP_V0(MemInitialize) + +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) + +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) diff --git a/ets1.2/libarkts/native/src/common.h b/ets1.2/libarkts/native/src/common.h new file mode 100644 index 0000000000000000000000000000000000000000..0ee7cd1d7646c9b8d7f30dd3f69d1c9f0899a951 --- /dev/null +++ b/ets1.2/libarkts/native/src/common.h @@ -0,0 +1,133 @@ +/* + * 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. + */ + +#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" +#include "stdexcept" +#include "interop-utils.h" +#include +#include +#include + +using std::string, std::cout, std::endl, std::vector; + +extern es2panda_Impl *es2pandaImplementation; + +es2panda_Impl *GetImplSlow(); +inline es2panda_Impl *GetImpl() { + if (es2pandaImplementation) { + return es2pandaImplementation; + } + return GetImplSlow(); +} + +string getString(KStringPtr ptr); + +char* getStringCopy(KStringPtr& ptr); + +inline KUInt unpackUInt(const KByte* bytes) +{ + const KUInt BYTE_0 = 0; + const KUInt BYTE_1 = 1; + const KUInt BYTE_2 = 2; + const KUInt BYTE_3 = 3; + + const KUInt BYTE_1_SHIFT = 8; + const KUInt BYTE_2_SHIFT = 16; + const KUInt BYTE_3_SHIFT = 24; + return ( + bytes[BYTE_0] + | (bytes[BYTE_1] << BYTE_1_SHIFT) + | (bytes[BYTE_2] << BYTE_2_SHIFT) + | (bytes[BYTE_3] << BYTE_3_SHIFT) + ); +} + +es2panda_ContextState intToState(KInt state); + +class StageArena { + std::vector allocated; + size_t totalSize; + public: + StageArena(); + ~StageArena(); + static StageArena* instance(); + template + static T* alloc() + { + auto* arena = StageArena::instance(); + void* memory = arena->alloc(sizeof(T)); + return new (memory) T(); + } + template + static T* alloc(T1 arg1) + { + auto* arena = StageArena::instance(); + void* memory = arena->alloc(sizeof(T)); + return new (memory) T(std::forward(arg1)); + } + template + static T* alloc(T1 arg1, T2 arg2) + { + auto* arena = StageArena::instance(); + void* memory = arena->alloc(sizeof(T)); + return new (memory) T(arg1, arg2); + } + template + static T* allocArray(size_t count) + { + auto* arena = StageArena::instance(); + // align? + void* memory = arena->alloc(sizeof(T) * count); + return new (memory) T(); + } + template + static T* clone(const T& arg) + { + auto* arena = StageArena::instance(); + void* memory = arena->alloc(sizeof(T)); + return new (memory) T(arg); + } + template + static std::vector* cloneVector(const T* arg, size_t count) + { + return alloc, const T*, const T*>(arg, arg + count); + } + void* alloc(size_t size); + static char* strdup(const char* original); + void add(void* pointer); + void cleanup(); +}; + +#endif // COMMON_H \ No newline at end of file diff --git a/ets1.2/libarkts/native/src/generated/bridges.cc b/ets1.2/libarkts/native/src/generated/bridges.cc new file mode 100644 index 0000000000000000000000000000000000000000..b2e702b1ee6960a9c4d32848b01380f45eb84368 --- /dev/null +++ b/ets1.2/libarkts/native/src/generated/bridges.cc @@ -0,0 +1,16373 @@ +/* + * 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 + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen v2.1.10-arktscgen-2. DO NOT EDIT MANUALLY! + * es2panda ffeffdaea78faa7141933ce1df0d0f279ddfe5a3(2025-08-21) sdk v1.5.0-dev.42554 + */ + +KNativePointer impl_GetAllErrorMessages(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->GetAllErrorMessages(_context); + return StageArena::strdup(result); +} +KOALA_INTEROP_1(GetAllErrorMessages, KNativePointer, KNativePointer); + +KNativePointer impl_ProceedToState(KNativePointer context, KInt state) +{ + const auto _context = reinterpret_cast(context); + const auto _state = static_cast(state); + auto result = GetImpl()->ProceedToState(_context, _state); + return result; +} +KOALA_INTEROP_2(ProceedToState, KNativePointer, KNativePointer, KInt); + +KInt impl_ContextState(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->ContextState(_context); + return result; +} +KOALA_INTEROP_1(ContextState, KInt, KNativePointer); + +KNativePointer impl_ContextErrorMessage(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->ContextErrorMessage(_context); + return StageArena::strdup(result); +} +KOALA_INTEROP_1(ContextErrorMessage, KNativePointer, KNativePointer); + +KNativePointer impl_ContextProgram(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->ContextProgram(_context); + return result; +} +KOALA_INTEROP_1(ContextProgram, KNativePointer, KNativePointer); + +KNativePointer impl_CreateSourcePosition(KNativePointer context, KUInt index, KUInt line) +{ + const auto _context = reinterpret_cast(context); + const auto _index = static_cast(index); + const auto _line = static_cast(line); + auto result = GetImpl()->CreateSourcePosition(_context, _index, _line); + return result; +} +KOALA_INTEROP_3(CreateSourcePosition, KNativePointer, KNativePointer, KUInt, KUInt); + +KNativePointer impl_CreateSourceRange(KNativePointer context, KNativePointer start, KNativePointer end) +{ + const auto _context = reinterpret_cast(context); + const auto _start = reinterpret_cast(start); + const auto _end = reinterpret_cast(end); + auto result = GetImpl()->CreateSourceRange(_context, _start, _end); + return result; +} +KOALA_INTEROP_3(CreateSourceRange, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KUInt impl_SourcePositionIndex(KNativePointer context, KNativePointer position) +{ + const auto _context = reinterpret_cast(context); + const auto _position = reinterpret_cast(position); + auto result = GetImpl()->SourcePositionIndex(_context, _position); + return result; +} +KOALA_INTEROP_2(SourcePositionIndex, KUInt, KNativePointer, KNativePointer); + +KUInt impl_SourcePositionLine(KNativePointer context, KNativePointer position) +{ + const auto _context = reinterpret_cast(context); + const auto _position = reinterpret_cast(position); + auto result = GetImpl()->SourcePositionLine(_context, _position); + return result; +} +KOALA_INTEROP_2(SourcePositionLine, KUInt, 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); + return result; +} +KOALA_INTEROP_2(SourceRangeStart, KNativePointer, KNativePointer, KNativePointer); + +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); + return result; +} +KOALA_INTEROP_2(SourceRangeEnd, KNativePointer, KNativePointer, KNativePointer); + +void impl_LogDiagnosticWithSuggestion(KNativePointer context, KNativePointer diagnosticInfo, KNativePointer suggestionInfo) +{ + const auto _context = reinterpret_cast(context); + const auto _diagnosticInfo = reinterpret_cast(diagnosticInfo); + const auto _suggestionInfo = reinterpret_cast(suggestionInfo); + GetImpl()->LogDiagnosticWithSuggestion(_context, _diagnosticInfo, _suggestionInfo); + return ; +} +KOALA_INTEROP_V3(LogDiagnosticWithSuggestion, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_IsAnyError(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->IsAnyError(_context); + return result; +} +KOALA_INTEROP_1(IsAnyError, KBoolean, KNativePointer); + +void impl_AstNodeRecheck(KNativePointer context, KNativePointer node) +{ + const auto _context = reinterpret_cast(context); + const auto _node = reinterpret_cast(node); + GetImpl()->AstNodeRecheck(_context, _node); + return ; +} +KOALA_INTEROP_V2(AstNodeRecheck, KNativePointer, KNativePointer); + +KInt impl_Es2pandaEnumFromString(KNativePointer context, KStringPtr& str) +{ + const auto _context = reinterpret_cast(context); + const auto _str = getStringCopy(str); + auto result = GetImpl()->Es2pandaEnumFromString(_context, _str); + return result; +} +KOALA_INTEROP_2(Es2pandaEnumFromString, KInt, KNativePointer, KStringPtr); + +KNativePointer impl_Es2pandaEnumToString(KNativePointer context, KInt id) +{ + const auto _context = reinterpret_cast(context); + const auto _id = static_cast(id); + auto result = GetImpl()->Es2pandaEnumToString(_context, _id); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(Es2pandaEnumToString, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_DeclarationFromIdentifier(KNativePointer context, KNativePointer node) +{ + const auto _context = reinterpret_cast(context); + const auto _node = reinterpret_cast(node); + auto result = GetImpl()->DeclarationFromIdentifier(_context, _node); + return result; +} +KOALA_INTEROP_2(DeclarationFromIdentifier, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_IsImportTypeKind(KNativePointer context, KNativePointer node) +{ + const auto _context = reinterpret_cast(context); + const auto _node = reinterpret_cast(node); + auto result = GetImpl()->IsImportTypeKind(_context, _node); + return result; +} +KOALA_INTEROP_2(IsImportTypeKind, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_JsdocStringFromDeclaration(KNativePointer context, KNativePointer node) +{ + const auto _context = reinterpret_cast(context); + const auto _node = reinterpret_cast(node); + auto result = GetImpl()->JsdocStringFromDeclaration(_context, _node); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(JsdocStringFromDeclaration, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_GetLicenseFromRootNode(KNativePointer context, KNativePointer node) +{ + const auto _context = reinterpret_cast(context); + const auto _node = reinterpret_cast(node); + auto result = GetImpl()->GetLicenseFromRootNode(_context, _node); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(GetLicenseFromRootNode, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_FirstDeclarationByNameFromNode(KNativePointer context, KNativePointer node, KStringPtr& name) +{ + const auto _context = reinterpret_cast(context); + const auto _node = reinterpret_cast(node); + const auto _name = getStringCopy(name); + auto result = GetImpl()->FirstDeclarationByNameFromNode(_context, _node, _name); + return result; +} +KOALA_INTEROP_3(FirstDeclarationByNameFromNode, KNativePointer, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_FirstDeclarationByNameFromProgram(KNativePointer context, KNativePointer program, KStringPtr& name) +{ + const auto _context = reinterpret_cast(context); + const auto _program = reinterpret_cast(program); + const auto _name = getStringCopy(name); + auto result = GetImpl()->FirstDeclarationByNameFromProgram(_context, _program, _name); + return result; +} +KOALA_INTEROP_3(FirstDeclarationByNameFromProgram, KNativePointer, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_AllDeclarationsByNameFromNode(KNativePointer context, KNativePointer node, KStringPtr& name) +{ + const auto _context = reinterpret_cast(context); + const auto _node = reinterpret_cast(node); + const auto _name = getStringCopy(name); + std::size_t length; + auto result = GetImpl()->AllDeclarationsByNameFromNode(_context, _node, _name, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_3(AllDeclarationsByNameFromNode, KNativePointer, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_AllDeclarationsByNameFromProgram(KNativePointer context, KNativePointer program, KStringPtr& name) +{ + const auto _context = reinterpret_cast(context); + const auto _program = reinterpret_cast(program); + const auto _name = getStringCopy(name); + std::size_t length; + auto result = GetImpl()->AllDeclarationsByNameFromProgram(_context, _program, _name, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_3(AllDeclarationsByNameFromProgram, KNativePointer, KNativePointer, KNativePointer, KStringPtr); + +void impl_InsertETSImportDeclarationAndParse(KNativePointer context, KNativePointer program, KNativePointer node) +{ + const auto _context = reinterpret_cast(context); + const auto _program = reinterpret_cast(program); + const auto _node = reinterpret_cast(node); + GetImpl()->InsertETSImportDeclarationAndParse(_context, _program, _node); + return ; +} +KOALA_INTEROP_V3(InsertETSImportDeclarationAndParse, KNativePointer, KNativePointer, KNativePointer); + +KInt impl_GenerateStaticDeclarationsFromContext(KNativePointer context, KStringPtr& outputPath) +{ + const auto _context = reinterpret_cast(context); + const auto _outputPath = getStringCopy(outputPath); + auto result = GetImpl()->GenerateStaticDeclarationsFromContext(_context, _outputPath); + return result; +} +KOALA_INTEROP_2(GenerateStaticDeclarationsFromContext, KInt, KNativePointer, KStringPtr); + +KBoolean impl_IsExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsExpression, KBoolean, KNativePointer); + +KBoolean impl_IsStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsStatement, KBoolean, KNativePointer); + +KBoolean impl_IsArrowFunctionExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsArrowFunctionExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsArrowFunctionExpression, KBoolean, KNativePointer); + +KBoolean impl_IsAnnotationDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsAnnotationDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsAnnotationDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsAnnotationUsage(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsAnnotationUsage(_ast); + return result; +} +KOALA_INTEROP_1(IsAnnotationUsage, KBoolean, KNativePointer); + +KBoolean impl_IsAssertStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsAssertStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsAssertStatement, KBoolean, KNativePointer); + +KBoolean impl_IsAwaitExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsAwaitExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsAwaitExpression, KBoolean, KNativePointer); + +KBoolean impl_IsBigIntLiteral(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsBigIntLiteral(_ast); + return result; +} +KOALA_INTEROP_1(IsBigIntLiteral, KBoolean, KNativePointer); + +KBoolean impl_IsBinaryExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsBinaryExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsBinaryExpression, KBoolean, KNativePointer); + +KBoolean impl_IsBlockStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsBlockStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsBlockStatement, KBoolean, KNativePointer); + +KBoolean impl_IsBooleanLiteral(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsBooleanLiteral(_ast); + return result; +} +KOALA_INTEROP_1(IsBooleanLiteral, KBoolean, KNativePointer); + +KBoolean impl_IsBreakStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsBreakStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsBreakStatement, KBoolean, KNativePointer); + +KBoolean impl_IsCallExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsCallExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsCallExpression, KBoolean, KNativePointer); + +KBoolean impl_IsCatchClause(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsCatchClause(_ast); + return result; +} +KOALA_INTEROP_1(IsCatchClause, KBoolean, KNativePointer); + +KBoolean impl_IsChainExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsChainExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsChainExpression, KBoolean, KNativePointer); + +KBoolean impl_IsCharLiteral(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsCharLiteral(_ast); + return result; +} +KOALA_INTEROP_1(IsCharLiteral, KBoolean, KNativePointer); + +KBoolean impl_IsClassDefinition(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsClassDefinition(_ast); + return result; +} +KOALA_INTEROP_1(IsClassDefinition, KBoolean, KNativePointer); + +KBoolean impl_IsClassDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsClassDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsClassDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsClassExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsClassExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsClassExpression, KBoolean, KNativePointer); + +KBoolean impl_IsClassProperty(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsClassProperty(_ast); + return result; +} +KOALA_INTEROP_1(IsClassProperty, KBoolean, KNativePointer); + +KBoolean impl_IsClassStaticBlock(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsClassStaticBlock(_ast); + return result; +} +KOALA_INTEROP_1(IsClassStaticBlock, KBoolean, KNativePointer); + +KBoolean impl_IsConditionalExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsConditionalExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsConditionalExpression, KBoolean, KNativePointer); + +KBoolean impl_IsContinueStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsContinueStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsContinueStatement, KBoolean, KNativePointer); + +KBoolean impl_IsDebuggerStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsDebuggerStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsDebuggerStatement, KBoolean, KNativePointer); + +KBoolean impl_IsDecorator(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsDecorator(_ast); + return result; +} +KOALA_INTEROP_1(IsDecorator, KBoolean, KNativePointer); + +KBoolean impl_IsDirectEvalExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsDirectEvalExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsDirectEvalExpression, KBoolean, KNativePointer); + +KBoolean impl_IsDoWhileStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsDoWhileStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsDoWhileStatement, KBoolean, KNativePointer); + +KBoolean impl_IsEmptyStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsEmptyStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsEmptyStatement, KBoolean, KNativePointer); + +KBoolean impl_IsExportAllDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsExportAllDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsExportAllDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsExportDefaultDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsExportDefaultDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsExportDefaultDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsExportNamedDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsExportNamedDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsExportNamedDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsExportSpecifier(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsExportSpecifier(_ast); + return result; +} +KOALA_INTEROP_1(IsExportSpecifier, KBoolean, KNativePointer); + +KBoolean impl_IsExpressionStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsExpressionStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsExpressionStatement, KBoolean, KNativePointer); + +KBoolean impl_IsForInStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsForInStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsForInStatement, KBoolean, KNativePointer); + +KBoolean impl_IsForOfStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsForOfStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsForOfStatement, KBoolean, KNativePointer); + +KBoolean impl_IsForUpdateStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsForUpdateStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsForUpdateStatement, KBoolean, KNativePointer); + +KBoolean impl_IsFunctionDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsFunctionDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsFunctionDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsFunctionExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsFunctionExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsFunctionExpression, KBoolean, KNativePointer); + +KBoolean impl_IsIdentifier(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsIdentifier(_ast); + return result; +} +KOALA_INTEROP_1(IsIdentifier, KBoolean, KNativePointer); + +KBoolean impl_IsDummyNode(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsDummyNode(_ast); + return result; +} +KOALA_INTEROP_1(IsDummyNode, KBoolean, KNativePointer); + +KBoolean impl_IsIfStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsIfStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsIfStatement, KBoolean, KNativePointer); + +KBoolean impl_IsImportDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsImportDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsImportDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsImportExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsImportExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsImportExpression, KBoolean, KNativePointer); + +KBoolean impl_IsImportDefaultSpecifier(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsImportDefaultSpecifier(_ast); + return result; +} +KOALA_INTEROP_1(IsImportDefaultSpecifier, KBoolean, KNativePointer); + +KBoolean impl_IsImportNamespaceSpecifier(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsImportNamespaceSpecifier(_ast); + return result; +} +KOALA_INTEROP_1(IsImportNamespaceSpecifier, KBoolean, KNativePointer); + +KBoolean impl_IsImportSpecifier(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsImportSpecifier(_ast); + return result; +} +KOALA_INTEROP_1(IsImportSpecifier, KBoolean, KNativePointer); + +KBoolean impl_IsLabelledStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsLabelledStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsLabelledStatement, KBoolean, KNativePointer); + +KBoolean impl_IsMemberExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsMemberExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsMemberExpression, KBoolean, KNativePointer); + +KBoolean impl_IsMetaProperty(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsMetaProperty(_ast); + return result; +} +KOALA_INTEROP_1(IsMetaProperty, KBoolean, KNativePointer); + +KBoolean impl_IsMethodDefinition(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsMethodDefinition(_ast); + return result; +} +KOALA_INTEROP_1(IsMethodDefinition, KBoolean, KNativePointer); + +KBoolean impl_IsNamedType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsNamedType(_ast); + return result; +} +KOALA_INTEROP_1(IsNamedType, KBoolean, KNativePointer); + +KBoolean impl_IsNewExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsNewExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsNewExpression, KBoolean, KNativePointer); + +KBoolean impl_IsNullLiteral(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsNullLiteral(_ast); + return result; +} +KOALA_INTEROP_1(IsNullLiteral, KBoolean, KNativePointer); + +KBoolean impl_IsUndefinedLiteral(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsUndefinedLiteral(_ast); + return result; +} +KOALA_INTEROP_1(IsUndefinedLiteral, KBoolean, KNativePointer); + +KBoolean impl_IsNumberLiteral(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsNumberLiteral(_ast); + return result; +} +KOALA_INTEROP_1(IsNumberLiteral, KBoolean, KNativePointer); + +KBoolean impl_IsOmittedExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsOmittedExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsOmittedExpression, KBoolean, KNativePointer); + +KBoolean impl_IsOverloadDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsOverloadDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsOverloadDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsPrefixAssertionExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsPrefixAssertionExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsPrefixAssertionExpression, KBoolean, KNativePointer); + +KBoolean impl_IsProperty(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsProperty(_ast); + return result; +} +KOALA_INTEROP_1(IsProperty, KBoolean, KNativePointer); + +KBoolean impl_IsRegExpLiteral(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsRegExpLiteral(_ast); + return result; +} +KOALA_INTEROP_1(IsRegExpLiteral, KBoolean, KNativePointer); + +KBoolean impl_IsETSReExportDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSReExportDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsETSReExportDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsReturnStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsReturnStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsReturnStatement, KBoolean, KNativePointer); + +KBoolean impl_IsScriptFunction(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsScriptFunction(_ast); + return result; +} +KOALA_INTEROP_1(IsScriptFunction, KBoolean, KNativePointer); + +KBoolean impl_IsSequenceExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsSequenceExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsSequenceExpression, KBoolean, KNativePointer); + +KBoolean impl_IsStringLiteral(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsStringLiteral(_ast); + return result; +} +KOALA_INTEROP_1(IsStringLiteral, KBoolean, KNativePointer); + +KBoolean impl_IsETSNonNullishTypeNode(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSNonNullishTypeNode(_ast); + return result; +} +KOALA_INTEROP_1(IsETSNonNullishTypeNode, KBoolean, KNativePointer); + +KBoolean impl_IsETSNullType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSNullType(_ast); + return result; +} +KOALA_INTEROP_1(IsETSNullType, KBoolean, KNativePointer); + +KBoolean impl_IsETSUndefinedType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSUndefinedType(_ast); + return result; +} +KOALA_INTEROP_1(IsETSUndefinedType, KBoolean, KNativePointer); + +KBoolean impl_IsETSNeverType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSNeverType(_ast); + return result; +} +KOALA_INTEROP_1(IsETSNeverType, KBoolean, KNativePointer); + +KBoolean impl_IsETSStringLiteralType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSStringLiteralType(_ast); + return result; +} +KOALA_INTEROP_1(IsETSStringLiteralType, KBoolean, KNativePointer); + +KBoolean impl_IsETSIntrinsicNode(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSIntrinsicNode(_ast); + return result; +} +KOALA_INTEROP_1(IsETSIntrinsicNode, KBoolean, KNativePointer); + +KBoolean impl_IsETSFunctionType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSFunctionType(_ast); + return result; +} +KOALA_INTEROP_1(IsETSFunctionType, KBoolean, KNativePointer); + +KBoolean impl_IsETSWildcardType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSWildcardType(_ast); + return result; +} +KOALA_INTEROP_1(IsETSWildcardType, KBoolean, KNativePointer); + +KBoolean impl_IsETSPrimitiveType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSPrimitiveType(_ast); + return result; +} +KOALA_INTEROP_1(IsETSPrimitiveType, KBoolean, KNativePointer); + +KBoolean impl_IsETSPackageDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSPackageDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsETSPackageDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsETSClassLiteral(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSClassLiteral(_ast); + return result; +} +KOALA_INTEROP_1(IsETSClassLiteral, KBoolean, KNativePointer); + +KBoolean impl_IsETSTypeReference(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSTypeReference(_ast); + return result; +} +KOALA_INTEROP_1(IsETSTypeReference, KBoolean, KNativePointer); + +KBoolean impl_IsETSTypeReferencePart(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSTypeReferencePart(_ast); + return result; +} +KOALA_INTEROP_1(IsETSTypeReferencePart, KBoolean, KNativePointer); + +KBoolean impl_IsETSUnionType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSUnionType(_ast); + return result; +} +KOALA_INTEROP_1(IsETSUnionType, KBoolean, KNativePointer); + +KBoolean impl_IsETSKeyofType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSKeyofType(_ast); + return result; +} +KOALA_INTEROP_1(IsETSKeyofType, KBoolean, KNativePointer); + +KBoolean impl_IsETSNewArrayInstanceExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSNewArrayInstanceExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsETSNewArrayInstanceExpression, KBoolean, KNativePointer); + +KBoolean impl_IsETSNewMultiDimArrayInstanceExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSNewMultiDimArrayInstanceExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsETSNewMultiDimArrayInstanceExpression, KBoolean, KNativePointer); + +KBoolean impl_IsETSNewClassInstanceExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSNewClassInstanceExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsETSNewClassInstanceExpression, KBoolean, KNativePointer); + +KBoolean impl_IsETSImportDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSImportDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsETSImportDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsETSParameterExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSParameterExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsETSParameterExpression, KBoolean, KNativePointer); + +KBoolean impl_IsETSTuple(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSTuple(_ast); + return result; +} +KOALA_INTEROP_1(IsETSTuple, KBoolean, KNativePointer); + +KBoolean impl_IsETSModule(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSModule(_ast); + return result; +} +KOALA_INTEROP_1(IsETSModule, KBoolean, KNativePointer); + +KBoolean impl_IsSuperExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsSuperExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsSuperExpression, KBoolean, KNativePointer); + +KBoolean impl_IsETSStructDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsETSStructDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsETSStructDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsSwitchCaseStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsSwitchCaseStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsSwitchCaseStatement, KBoolean, KNativePointer); + +KBoolean impl_IsSwitchStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsSwitchStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsSwitchStatement, KBoolean, KNativePointer); + +KBoolean impl_IsTSEnumDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSEnumDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsTSEnumDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsTSEnumMember(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSEnumMember(_ast); + return result; +} +KOALA_INTEROP_1(IsTSEnumMember, KBoolean, KNativePointer); + +KBoolean impl_IsTSExternalModuleReference(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSExternalModuleReference(_ast); + return result; +} +KOALA_INTEROP_1(IsTSExternalModuleReference, KBoolean, KNativePointer); + +KBoolean impl_IsTSNumberKeyword(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSNumberKeyword(_ast); + return result; +} +KOALA_INTEROP_1(IsTSNumberKeyword, KBoolean, KNativePointer); + +KBoolean impl_IsTSAnyKeyword(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSAnyKeyword(_ast); + return result; +} +KOALA_INTEROP_1(IsTSAnyKeyword, KBoolean, KNativePointer); + +KBoolean impl_IsTSStringKeyword(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSStringKeyword(_ast); + return result; +} +KOALA_INTEROP_1(IsTSStringKeyword, KBoolean, KNativePointer); + +KBoolean impl_IsTSBooleanKeyword(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSBooleanKeyword(_ast); + return result; +} +KOALA_INTEROP_1(IsTSBooleanKeyword, KBoolean, KNativePointer); + +KBoolean impl_IsTSVoidKeyword(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSVoidKeyword(_ast); + return result; +} +KOALA_INTEROP_1(IsTSVoidKeyword, KBoolean, KNativePointer); + +KBoolean impl_IsTSUndefinedKeyword(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSUndefinedKeyword(_ast); + return result; +} +KOALA_INTEROP_1(IsTSUndefinedKeyword, KBoolean, KNativePointer); + +KBoolean impl_IsTSUnknownKeyword(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSUnknownKeyword(_ast); + return result; +} +KOALA_INTEROP_1(IsTSUnknownKeyword, KBoolean, KNativePointer); + +KBoolean impl_IsTSObjectKeyword(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSObjectKeyword(_ast); + return result; +} +KOALA_INTEROP_1(IsTSObjectKeyword, KBoolean, KNativePointer); + +KBoolean impl_IsTSBigintKeyword(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSBigintKeyword(_ast); + return result; +} +KOALA_INTEROP_1(IsTSBigintKeyword, KBoolean, KNativePointer); + +KBoolean impl_IsTSNeverKeyword(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSNeverKeyword(_ast); + return result; +} +KOALA_INTEROP_1(IsTSNeverKeyword, KBoolean, KNativePointer); + +KBoolean impl_IsTSNonNullExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSNonNullExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsTSNonNullExpression, KBoolean, KNativePointer); + +KBoolean impl_IsTSNullKeyword(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSNullKeyword(_ast); + return result; +} +KOALA_INTEROP_1(IsTSNullKeyword, KBoolean, KNativePointer); + +KBoolean impl_IsTSArrayType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSArrayType(_ast); + return result; +} +KOALA_INTEROP_1(IsTSArrayType, KBoolean, KNativePointer); + +KBoolean impl_IsTSUnionType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSUnionType(_ast); + return result; +} +KOALA_INTEROP_1(IsTSUnionType, KBoolean, KNativePointer); + +KBoolean impl_IsTSTypeLiteral(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSTypeLiteral(_ast); + return result; +} +KOALA_INTEROP_1(IsTSTypeLiteral, KBoolean, KNativePointer); + +KBoolean impl_IsTSPropertySignature(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSPropertySignature(_ast); + return result; +} +KOALA_INTEROP_1(IsTSPropertySignature, KBoolean, KNativePointer); + +KBoolean impl_IsTSMethodSignature(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSMethodSignature(_ast); + return result; +} +KOALA_INTEROP_1(IsTSMethodSignature, KBoolean, KNativePointer); + +KBoolean impl_IsTSSignatureDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSSignatureDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsTSSignatureDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsTSParenthesizedType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSParenthesizedType(_ast); + return result; +} +KOALA_INTEROP_1(IsTSParenthesizedType, KBoolean, KNativePointer); + +KBoolean impl_IsTSLiteralType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSLiteralType(_ast); + return result; +} +KOALA_INTEROP_1(IsTSLiteralType, KBoolean, KNativePointer); + +KBoolean impl_IsTSInferType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSInferType(_ast); + return result; +} +KOALA_INTEROP_1(IsTSInferType, KBoolean, KNativePointer); + +KBoolean impl_IsTSConditionalType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSConditionalType(_ast); + return result; +} +KOALA_INTEROP_1(IsTSConditionalType, KBoolean, KNativePointer); + +KBoolean impl_IsTSImportType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSImportType(_ast); + return result; +} +KOALA_INTEROP_1(IsTSImportType, KBoolean, KNativePointer); + +KBoolean impl_IsTSIntersectionType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSIntersectionType(_ast); + return result; +} +KOALA_INTEROP_1(IsTSIntersectionType, KBoolean, KNativePointer); + +KBoolean impl_IsTSMappedType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSMappedType(_ast); + return result; +} +KOALA_INTEROP_1(IsTSMappedType, KBoolean, KNativePointer); + +KBoolean impl_IsTSModuleBlock(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSModuleBlock(_ast); + return result; +} +KOALA_INTEROP_1(IsTSModuleBlock, KBoolean, KNativePointer); + +KBoolean impl_IsTSThisType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSThisType(_ast); + return result; +} +KOALA_INTEROP_1(IsTSThisType, KBoolean, KNativePointer); + +KBoolean impl_IsTSTypeOperator(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSTypeOperator(_ast); + return result; +} +KOALA_INTEROP_1(IsTSTypeOperator, KBoolean, KNativePointer); + +KBoolean impl_IsTSTypeParameter(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSTypeParameter(_ast); + return result; +} +KOALA_INTEROP_1(IsTSTypeParameter, KBoolean, KNativePointer); + +KBoolean impl_IsTSTypeParameterDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSTypeParameterDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsTSTypeParameterDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsTSTypeParameterInstantiation(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSTypeParameterInstantiation(_ast); + return result; +} +KOALA_INTEROP_1(IsTSTypeParameterInstantiation, KBoolean, KNativePointer); + +KBoolean impl_IsTSTypePredicate(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSTypePredicate(_ast); + return result; +} +KOALA_INTEROP_1(IsTSTypePredicate, KBoolean, KNativePointer); + +KBoolean impl_IsTSParameterProperty(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSParameterProperty(_ast); + return result; +} +KOALA_INTEROP_1(IsTSParameterProperty, KBoolean, KNativePointer); + +KBoolean impl_IsTSModuleDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSModuleDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsTSModuleDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsTSImportEqualsDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSImportEqualsDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsTSImportEqualsDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsTSFunctionType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSFunctionType(_ast); + return result; +} +KOALA_INTEROP_1(IsTSFunctionType, KBoolean, KNativePointer); + +KBoolean impl_IsTSConstructorType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSConstructorType(_ast); + return result; +} +KOALA_INTEROP_1(IsTSConstructorType, KBoolean, KNativePointer); + +KBoolean impl_IsTSTypeAliasDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSTypeAliasDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsTSTypeAliasDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsTSTypeReference(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSTypeReference(_ast); + return result; +} +KOALA_INTEROP_1(IsTSTypeReference, KBoolean, KNativePointer); + +KBoolean impl_IsTSQualifiedName(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSQualifiedName(_ast); + return result; +} +KOALA_INTEROP_1(IsTSQualifiedName, KBoolean, KNativePointer); + +KBoolean impl_IsTSIndexedAccessType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSIndexedAccessType(_ast); + return result; +} +KOALA_INTEROP_1(IsTSIndexedAccessType, KBoolean, KNativePointer); + +KBoolean impl_IsTSInterfaceDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSInterfaceDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsTSInterfaceDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsTSInterfaceBody(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSInterfaceBody(_ast); + return result; +} +KOALA_INTEROP_1(IsTSInterfaceBody, KBoolean, KNativePointer); + +KBoolean impl_IsTSInterfaceHeritage(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSInterfaceHeritage(_ast); + return result; +} +KOALA_INTEROP_1(IsTSInterfaceHeritage, KBoolean, KNativePointer); + +KBoolean impl_IsTSTupleType(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSTupleType(_ast); + return result; +} +KOALA_INTEROP_1(IsTSTupleType, KBoolean, KNativePointer); + +KBoolean impl_IsTSNamedTupleMember(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSNamedTupleMember(_ast); + return result; +} +KOALA_INTEROP_1(IsTSNamedTupleMember, KBoolean, KNativePointer); + +KBoolean impl_IsTSIndexSignature(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSIndexSignature(_ast); + return result; +} +KOALA_INTEROP_1(IsTSIndexSignature, KBoolean, KNativePointer); + +KBoolean impl_IsTSTypeQuery(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSTypeQuery(_ast); + return result; +} +KOALA_INTEROP_1(IsTSTypeQuery, KBoolean, KNativePointer); + +KBoolean impl_IsTSAsExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSAsExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsTSAsExpression, KBoolean, KNativePointer); + +KBoolean impl_IsTSClassImplements(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSClassImplements(_ast); + return result; +} +KOALA_INTEROP_1(IsTSClassImplements, KBoolean, KNativePointer); + +KBoolean impl_IsTSTypeAssertion(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTSTypeAssertion(_ast); + return result; +} +KOALA_INTEROP_1(IsTSTypeAssertion, KBoolean, KNativePointer); + +KBoolean impl_IsTaggedTemplateExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTaggedTemplateExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsTaggedTemplateExpression, KBoolean, KNativePointer); + +KBoolean impl_IsTemplateElement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTemplateElement(_ast); + return result; +} +KOALA_INTEROP_1(IsTemplateElement, KBoolean, KNativePointer); + +KBoolean impl_IsTemplateLiteral(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTemplateLiteral(_ast); + return result; +} +KOALA_INTEROP_1(IsTemplateLiteral, KBoolean, KNativePointer); + +KBoolean impl_IsThisExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsThisExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsThisExpression, KBoolean, KNativePointer); + +KBoolean impl_IsTypeofExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTypeofExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsTypeofExpression, KBoolean, KNativePointer); + +KBoolean impl_IsThrowStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsThrowStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsThrowStatement, KBoolean, KNativePointer); + +KBoolean impl_IsTryStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsTryStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsTryStatement, KBoolean, KNativePointer); + +KBoolean impl_IsUnaryExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsUnaryExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsUnaryExpression, KBoolean, KNativePointer); + +KBoolean impl_IsUpdateExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsUpdateExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsUpdateExpression, KBoolean, KNativePointer); + +KBoolean impl_IsVariableDeclaration(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsVariableDeclaration(_ast); + return result; +} +KOALA_INTEROP_1(IsVariableDeclaration, KBoolean, KNativePointer); + +KBoolean impl_IsVariableDeclarator(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsVariableDeclarator(_ast); + return result; +} +KOALA_INTEROP_1(IsVariableDeclarator, KBoolean, KNativePointer); + +KBoolean impl_IsWhileStatement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsWhileStatement(_ast); + return result; +} +KOALA_INTEROP_1(IsWhileStatement, KBoolean, KNativePointer); + +KBoolean impl_IsYieldExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsYieldExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsYieldExpression, KBoolean, KNativePointer); + +KBoolean impl_IsOpaqueTypeNode(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsOpaqueTypeNode(_ast); + return result; +} +KOALA_INTEROP_1(IsOpaqueTypeNode, KBoolean, KNativePointer); + +KBoolean impl_IsBlockExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsBlockExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsBlockExpression, KBoolean, KNativePointer); + +KBoolean impl_IsBrokenTypeNode(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsBrokenTypeNode(_ast); + return result; +} +KOALA_INTEROP_1(IsBrokenTypeNode, KBoolean, KNativePointer); + +KBoolean impl_IsArrayExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsArrayExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsArrayExpression, KBoolean, KNativePointer); + +KBoolean impl_IsArrayPattern(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsArrayPattern(_ast); + return result; +} +KOALA_INTEROP_1(IsArrayPattern, KBoolean, KNativePointer); + +KBoolean impl_IsAssignmentExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsAssignmentExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsAssignmentExpression, KBoolean, KNativePointer); + +KBoolean impl_IsAssignmentPattern(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsAssignmentPattern(_ast); + return result; +} +KOALA_INTEROP_1(IsAssignmentPattern, KBoolean, KNativePointer); + +KBoolean impl_IsObjectExpression(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsObjectExpression(_ast); + return result; +} +KOALA_INTEROP_1(IsObjectExpression, KBoolean, KNativePointer); + +KBoolean impl_IsObjectPattern(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsObjectPattern(_ast); + return result; +} +KOALA_INTEROP_1(IsObjectPattern, KBoolean, KNativePointer); + +KBoolean impl_IsSpreadElement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsSpreadElement(_ast); + return result; +} +KOALA_INTEROP_1(IsSpreadElement, KBoolean, KNativePointer); + +KBoolean impl_IsRestElement(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->IsRestElement(_ast); + return result; +} +KOALA_INTEROP_1(IsRestElement, KBoolean, KNativePointer); + +KNativePointer impl_AstNodeName(KNativePointer ast) +{ + const auto _ast = reinterpret_cast(ast); + auto result = GetImpl()->AstNodeName(_ast); + return StageArena::strdup(result); +} +KOALA_INTEROP_1(AstNodeName, KNativePointer, KNativePointer); + +KNativePointer impl_CreateNumberLiteral(KNativePointer context, KInt value) +{ + const auto _context = reinterpret_cast(context); + const auto _value = static_cast(value); + auto result = GetImpl()->CreateNumberLiteral(_context, _value); + return result; +} +KOALA_INTEROP_2(CreateNumberLiteral, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_CreateNumberLiteral1(KNativePointer context, KLong value) +{ + const auto _context = reinterpret_cast(context); + const auto _value = static_cast(value); + auto result = GetImpl()->CreateNumberLiteral1(_context, _value); + return result; +} +KOALA_INTEROP_2(CreateNumberLiteral1, KNativePointer, KNativePointer, KLong); + +KNativePointer impl_CreateNumberLiteral2(KNativePointer context, KDouble value) +{ + const auto _context = reinterpret_cast(context); + const auto _value = static_cast(value); + auto result = GetImpl()->CreateNumberLiteral2(_context, _value); + return result; +} +KOALA_INTEROP_2(CreateNumberLiteral2, KNativePointer, KNativePointer, KDouble); + +KNativePointer impl_CreateNumberLiteral3(KNativePointer context, KFloat value) +{ + const auto _context = reinterpret_cast(context); + const auto _value = static_cast(value); + auto result = GetImpl()->CreateNumberLiteral3(_context, _value); + return result; +} +KOALA_INTEROP_2(CreateNumberLiteral3, KNativePointer, KNativePointer, KFloat); + +KNativePointer impl_UpdateNumberLiteral(KNativePointer context, KNativePointer original, KInt value) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _value = static_cast(value); + auto result = GetImpl()->UpdateNumberLiteral(_context, _original, _value); + return result; +} +KOALA_INTEROP_3(UpdateNumberLiteral, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_UpdateNumberLiteral1(KNativePointer context, KNativePointer original, KLong value) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _value = static_cast(value); + auto result = GetImpl()->UpdateNumberLiteral1(_context, _original, _value); + return result; +} +KOALA_INTEROP_3(UpdateNumberLiteral1, KNativePointer, KNativePointer, KNativePointer, KLong); + +KNativePointer impl_UpdateNumberLiteral2(KNativePointer context, KNativePointer original, KDouble value) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _value = static_cast(value); + auto result = GetImpl()->UpdateNumberLiteral2(_context, _original, _value); + return result; +} +KOALA_INTEROP_3(UpdateNumberLiteral2, KNativePointer, KNativePointer, KNativePointer, KDouble); + +KNativePointer impl_UpdateNumberLiteral3(KNativePointer context, KNativePointer original, KFloat value) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _value = static_cast(value); + auto result = GetImpl()->UpdateNumberLiteral3(_context, _original, _value); + return result; +} +KOALA_INTEROP_3(UpdateNumberLiteral3, KNativePointer, KNativePointer, KNativePointer, KFloat); + +KNativePointer impl_NumberLiteralStrConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->NumberLiteralStrConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(NumberLiteralStrConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateLabelledStatement(KNativePointer context, KNativePointer ident, KNativePointer body) +{ + const auto _context = reinterpret_cast(context); + const auto _ident = reinterpret_cast(ident); + const auto _body = reinterpret_cast(body); + auto result = GetImpl()->CreateLabelledStatement(_context, _ident, _body); + return result; +} +KOALA_INTEROP_3(CreateLabelledStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateLabelledStatement(KNativePointer context, KNativePointer original, KNativePointer ident, KNativePointer body) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _ident = reinterpret_cast(ident); + const auto _body = reinterpret_cast(body); + auto result = GetImpl()->UpdateLabelledStatement(_context, _original, _ident, _body); + return result; +} +KOALA_INTEROP_4(UpdateLabelledStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_LabelledStatementBody(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->LabelledStatementBody(_context, _receiver); + return result; +} +KOALA_INTEROP_2(LabelledStatementBody, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_LabelledStatementBodyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->LabelledStatementBodyConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(LabelledStatementBodyConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_LabelledStatementIdentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->LabelledStatementIdentConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(LabelledStatementIdentConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_LabelledStatementIdent(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->LabelledStatementIdent(_context, _receiver); + return result; +} +KOALA_INTEROP_2(LabelledStatementIdent, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_LabelledStatementGetReferencedStatementConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->LabelledStatementGetReferencedStatementConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(LabelledStatementGetReferencedStatementConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateThrowStatement(KNativePointer context, KNativePointer argument) +{ + const auto _context = reinterpret_cast(context); + const auto _argument = reinterpret_cast(argument); + auto result = GetImpl()->CreateThrowStatement(_context, _argument); + return result; +} +KOALA_INTEROP_2(CreateThrowStatement, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateThrowStatement(KNativePointer context, KNativePointer original, KNativePointer argument) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _argument = reinterpret_cast(argument); + auto result = GetImpl()->UpdateThrowStatement(_context, _original, _argument); + return result; +} +KOALA_INTEROP_3(UpdateThrowStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ThrowStatementArgumentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ThrowStatementArgumentConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ThrowStatementArgumentConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateClassProperty(KNativePointer context, KNativePointer key, KNativePointer value, KNativePointer typeAnnotation, KInt modifiers, KBoolean isComputed) +{ + const auto _context = reinterpret_cast(context); + const auto _key = reinterpret_cast(key); + const auto _value = reinterpret_cast(value); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + const auto _modifiers = static_cast(modifiers); + const auto _isComputed = static_cast(isComputed); + auto result = GetImpl()->CreateClassProperty(_context, _key, _value, _typeAnnotation, _modifiers, _isComputed); + return result; +} +KOALA_INTEROP_6(CreateClassProperty, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KBoolean); + +KNativePointer impl_UpdateClassProperty(KNativePointer context, KNativePointer original, KNativePointer key, KNativePointer value, KNativePointer typeAnnotation, KInt modifiers, KBoolean isComputed) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _key = reinterpret_cast(key); + const auto _value = reinterpret_cast(value); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + const auto _modifiers = static_cast(modifiers); + const auto _isComputed = static_cast(isComputed); + auto result = GetImpl()->UpdateClassProperty(_context, _original, _key, _value, _typeAnnotation, _modifiers, _isComputed); + return result; +} +KOALA_INTEROP_7(UpdateClassProperty, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KBoolean); + +KBoolean impl_ClassPropertyIsDefaultAccessModifierConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassPropertyIsDefaultAccessModifierConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassPropertyIsDefaultAccessModifierConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ClassPropertySetDefaultAccessModifier(KNativePointer context, KNativePointer receiver, KBoolean isDefault) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _isDefault = static_cast(isDefault); + GetImpl()->ClassPropertySetDefaultAccessModifier(_context, _receiver, _isDefault); + return ; +} +KOALA_INTEROP_V3(ClassPropertySetDefaultAccessModifier, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_ClassPropertyTypeAnnotationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassPropertyTypeAnnotationConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ClassPropertyTypeAnnotationConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassPropertySetTypeAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer typeAnnotation) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + GetImpl()->ClassPropertySetTypeAnnotation(_context, _receiver, _typeAnnotation); + return ; +} +KOALA_INTEROP_V3(ClassPropertySetTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ClassPropertyNeedInitInStaticBlockConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassPropertyNeedInitInStaticBlockConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassPropertyNeedInitInStaticBlockConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ClassPropertySetNeedInitInStaticBlock(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ClassPropertySetNeedInitInStaticBlock(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ClassPropertySetNeedInitInStaticBlock, KNativePointer, KNativePointer); + +KBoolean impl_ClassPropertyIsImmediateInitConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassPropertyIsImmediateInitConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassPropertyIsImmediateInitConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ClassPropertySetIsImmediateInit(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ClassPropertySetIsImmediateInit(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ClassPropertySetIsImmediateInit, KNativePointer, KNativePointer); + +KBoolean impl_ClassPropertyHasAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassPropertyHasAnnotationsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassPropertyHasAnnotationsConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ClassPropertyEmplaceAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer source) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + GetImpl()->ClassPropertyEmplaceAnnotation(_context, _receiver, _source); + return ; +} +KOALA_INTEROP_V3(ClassPropertyEmplaceAnnotation, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassPropertyClearAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ClassPropertyClearAnnotations(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ClassPropertyClearAnnotations, KNativePointer, KNativePointer); + +void impl_ClassPropertyDumpAnnotationsConst(KNativePointer context, KNativePointer receiver, KNativePointer dumper) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _dumper = reinterpret_cast(dumper); + GetImpl()->ClassPropertyDumpAnnotationsConst(_context, _receiver, _dumper); + return ; +} +KOALA_INTEROP_V3(ClassPropertyDumpAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassPropertyAnnotationsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ClassPropertyAnnotationsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ClassPropertyAnnotationsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassPropertyAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ClassPropertyAnnotations(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ClassPropertyAnnotations, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassPropertyAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ClassPropertyAnnotationsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ClassPropertyAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassPropertySetAnnotations(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->ClassPropertySetAnnotations(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(ClassPropertySetAnnotations, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_ClassPropertySetAnnotations1(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->ClassPropertySetAnnotations1(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(ClassPropertySetAnnotations1, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateTSVoidKeyword(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateTSVoidKeyword(_context); + return result; +} +KOALA_INTEROP_1(CreateTSVoidKeyword, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSVoidKeyword(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateTSVoidKeyword(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateTSVoidKeyword, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSFunctionType(KNativePointer context, KNativePointer signature, KInt funcFlags) +{ + const auto _context = reinterpret_cast(context); + const auto _signature = reinterpret_cast(signature); + const auto _funcFlags = static_cast(funcFlags); + auto result = GetImpl()->CreateETSFunctionTypeIr(_context, _signature, _funcFlags); + return result; +} +KOALA_INTEROP_3(CreateETSFunctionType, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_UpdateETSFunctionType(KNativePointer context, KNativePointer original, KNativePointer signature, KInt funcFlags) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _signature = reinterpret_cast(signature); + const auto _funcFlags = static_cast(funcFlags); + auto result = GetImpl()->UpdateETSFunctionTypeIr(_context, _original, _signature, _funcFlags); + return result; +} +KOALA_INTEROP_4(UpdateETSFunctionType, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_ETSFunctionTypeTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSFunctionTypeIrTypeParamsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSFunctionTypeTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSFunctionTypeTypeParams(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSFunctionTypeIrTypeParams(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSFunctionTypeTypeParams, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSFunctionTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ETSFunctionTypeIrParamsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ETSFunctionTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ETSFunctionTypeSetParams(KNativePointer context, KNativePointer receiver, KNativePointerArray paramsList, KUInt paramsListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _paramsList = reinterpret_cast(paramsList); + const auto _paramsListSequenceLength = static_cast(paramsListSequenceLength); + GetImpl()->ETSFunctionTypeIrSetParams(_context, _receiver, _paramsList, _paramsListSequenceLength); + return ; +} +KOALA_INTEROP_V4(ETSFunctionTypeSetParams, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_ETSFunctionTypeReturnTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSFunctionTypeIrReturnTypeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSFunctionTypeReturnTypeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSFunctionTypeReturnType(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSFunctionTypeIrReturnType(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSFunctionTypeReturnType, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSFunctionTypeFunctionalInterface(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSFunctionTypeIrFunctionalInterface(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSFunctionTypeFunctionalInterface, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSFunctionTypeFunctionalInterfaceConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSFunctionTypeIrFunctionalInterfaceConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSFunctionTypeFunctionalInterfaceConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ETSFunctionTypeSetFunctionalInterface(KNativePointer context, KNativePointer receiver, KNativePointer functionalInterface) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _functionalInterface = reinterpret_cast(functionalInterface); + GetImpl()->ETSFunctionTypeIrSetFunctionalInterface(_context, _receiver, _functionalInterface); + return ; +} +KOALA_INTEROP_V3(ETSFunctionTypeSetFunctionalInterface, KNativePointer, KNativePointer, KNativePointer); + +KInt impl_ETSFunctionTypeFlags(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSFunctionTypeIrFlags(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSFunctionTypeFlags, KInt, KNativePointer, KNativePointer); + +KInt impl_ETSFunctionTypeFlagsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSFunctionTypeIrFlagsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSFunctionTypeFlagsConst, KInt, KNativePointer, KNativePointer); + +KBoolean impl_ETSFunctionTypeIsExtensionFunctionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSFunctionTypeIrIsExtensionFunctionConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSFunctionTypeIsExtensionFunctionConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSTypeOperator(KNativePointer context, KNativePointer type, KInt operatorType) +{ + const auto _context = reinterpret_cast(context); + const auto _type = reinterpret_cast(type); + const auto _operatorType = static_cast(operatorType); + auto result = GetImpl()->CreateTSTypeOperator(_context, _type, _operatorType); + return result; +} +KOALA_INTEROP_3(CreateTSTypeOperator, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_UpdateTSTypeOperator(KNativePointer context, KNativePointer original, KNativePointer type, KInt operatorType) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _type = reinterpret_cast(type); + const auto _operatorType = static_cast(operatorType); + auto result = GetImpl()->UpdateTSTypeOperator(_context, _original, _type, _operatorType); + return result; +} +KOALA_INTEROP_4(UpdateTSTypeOperator, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_TSTypeOperatorTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeOperatorTypeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSTypeOperatorTypeConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_TSTypeOperatorIsReadonlyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeOperatorIsReadonlyConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSTypeOperatorIsReadonlyConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_TSTypeOperatorIsKeyofConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeOperatorIsKeyofConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSTypeOperatorIsKeyofConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_TSTypeOperatorIsUniqueConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeOperatorIsUniqueConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSTypeOperatorIsUniqueConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateIfStatement(KNativePointer context, KNativePointer test, KNativePointer consequent, KNativePointer alternate) +{ + const auto _context = reinterpret_cast(context); + const auto _test = reinterpret_cast(test); + const auto _consequent = reinterpret_cast(consequent); + const auto _alternate = reinterpret_cast(alternate); + auto result = GetImpl()->CreateIfStatement(_context, _test, _consequent, _alternate); + return result; +} +KOALA_INTEROP_4(CreateIfStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateIfStatement(KNativePointer context, KNativePointer original, KNativePointer test, KNativePointer consequent, KNativePointer alternate) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _test = reinterpret_cast(test); + const auto _consequent = reinterpret_cast(consequent); + const auto _alternate = reinterpret_cast(alternate); + auto result = GetImpl()->UpdateIfStatement(_context, _original, _test, _consequent, _alternate); + return result; +} +KOALA_INTEROP_5(UpdateIfStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_IfStatementTestConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IfStatementTestConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(IfStatementTestConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_IfStatementTest(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IfStatementTest(_context, _receiver); + return result; +} +KOALA_INTEROP_2(IfStatementTest, KNativePointer, KNativePointer, KNativePointer); + +void impl_IfStatementSetTest(KNativePointer context, KNativePointer receiver, KNativePointer test) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _test = reinterpret_cast(test); + GetImpl()->IfStatementSetTest(_context, _receiver, _test); + return ; +} +KOALA_INTEROP_V3(IfStatementSetTest, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_IfStatementConsequentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IfStatementConsequentConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(IfStatementConsequentConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_IfStatementConsequent(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IfStatementConsequent(_context, _receiver); + return result; +} +KOALA_INTEROP_2(IfStatementConsequent, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_IfStatementAlternate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IfStatementAlternate(_context, _receiver); + return result; +} +KOALA_INTEROP_2(IfStatementAlternate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_IfStatementAlternateConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IfStatementAlternateConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(IfStatementAlternateConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_IfStatementSetAlternate(KNativePointer context, KNativePointer receiver, KNativePointer alternate) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _alternate = reinterpret_cast(alternate); + GetImpl()->IfStatementSetAlternate(_context, _receiver, _alternate); + return ; +} +KOALA_INTEROP_V3(IfStatementSetAlternate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSConstructorType(KNativePointer context, KNativePointer signature, KBoolean abstract) +{ + const auto _context = reinterpret_cast(context); + const auto _signature = reinterpret_cast(signature); + const auto _abstract = static_cast(abstract); + auto result = GetImpl()->CreateTSConstructorType(_context, _signature, _abstract); + return result; +} +KOALA_INTEROP_3(CreateTSConstructorType, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_UpdateTSConstructorType(KNativePointer context, KNativePointer original, KNativePointer signature, KBoolean abstract) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _signature = reinterpret_cast(signature); + const auto _abstract = static_cast(abstract); + auto result = GetImpl()->UpdateTSConstructorType(_context, _original, _signature, _abstract); + return result; +} +KOALA_INTEROP_4(UpdateTSConstructorType, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_TSConstructorTypeTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSConstructorTypeTypeParamsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSConstructorTypeTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSConstructorTypeTypeParams(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSConstructorTypeTypeParams(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSConstructorTypeTypeParams, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSConstructorTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSConstructorTypeParamsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSConstructorTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSConstructorTypeReturnTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSConstructorTypeReturnTypeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSConstructorTypeReturnTypeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSConstructorTypeReturnType(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSConstructorTypeReturnType(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSConstructorTypeReturnType, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_TSConstructorTypeAbstractConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSConstructorTypeAbstractConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSConstructorTypeAbstractConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateDecorator(KNativePointer context, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->CreateDecorator(_context, _expr); + return result; +} +KOALA_INTEROP_2(CreateDecorator, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateDecorator(KNativePointer context, KNativePointer original, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->UpdateDecorator(_context, _original, _expr); + return result; +} +KOALA_INTEROP_3(UpdateDecorator, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_DecoratorExprConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->DecoratorExprConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(DecoratorExprConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSEnumDeclaration(KNativePointer context, KNativePointer key, KNativePointerArray members, KUInt membersSequenceLength, KBoolean isConst, KBoolean isStatic, KBoolean isDeclare) +{ + const auto _context = reinterpret_cast(context); + const auto _key = reinterpret_cast(key); + const auto _members = reinterpret_cast(members); + const auto _membersSequenceLength = static_cast(membersSequenceLength); + const auto _isConst = static_cast(isConst); + const auto _isStatic = static_cast(isStatic); + const auto _isDeclare = static_cast(isDeclare); + auto result = GetImpl()->CreateTSEnumDeclaration(_context, _key, _members, _membersSequenceLength, _isConst, _isStatic, _isDeclare); + return result; +} +KOALA_INTEROP_7(CreateTSEnumDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KBoolean, KBoolean, KBoolean); + +KNativePointer impl_UpdateTSEnumDeclaration(KNativePointer context, KNativePointer original, KNativePointer key, KNativePointerArray members, KUInt membersSequenceLength, KBoolean isConst, KBoolean isStatic, KBoolean isDeclare) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _key = reinterpret_cast(key); + const auto _members = reinterpret_cast(members); + const auto _membersSequenceLength = static_cast(membersSequenceLength); + const auto _isConst = static_cast(isConst); + const auto _isStatic = static_cast(isStatic); + const auto _isDeclare = static_cast(isDeclare); + auto result = GetImpl()->UpdateTSEnumDeclaration(_context, _original, _key, _members, _membersSequenceLength, _isConst, _isStatic, _isDeclare); + return result; +} +KOALA_INTEROP_8(UpdateTSEnumDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KBoolean, KBoolean, KBoolean); + +KNativePointer impl_CreateTSEnumDeclaration1(KNativePointer context, KNativePointer key, KNativePointerArray members, KUInt membersSequenceLength, KBoolean isConst, KBoolean isStatic, KBoolean isDeclare, KNativePointer typeNode) +{ + const auto _context = reinterpret_cast(context); + const auto _key = reinterpret_cast(key); + const auto _members = reinterpret_cast(members); + const auto _membersSequenceLength = static_cast(membersSequenceLength); + const auto _isConst = static_cast(isConst); + const auto _isStatic = static_cast(isStatic); + const auto _isDeclare = static_cast(isDeclare); + const auto _typeNode = reinterpret_cast(typeNode); + auto result = GetImpl()->CreateTSEnumDeclaration1(_context, _key, _members, _membersSequenceLength, _isConst, _isStatic, _isDeclare, _typeNode); + return result; +} +KOALA_INTEROP_8(CreateTSEnumDeclaration1, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KBoolean, KBoolean, KBoolean, KNativePointer); + +KNativePointer impl_UpdateTSEnumDeclaration1(KNativePointer context, KNativePointer original, KNativePointer key, KNativePointerArray members, KUInt membersSequenceLength, KBoolean isConst, KBoolean isStatic, KBoolean isDeclare, KNativePointer typeNode) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _key = reinterpret_cast(key); + const auto _members = reinterpret_cast(members); + const auto _membersSequenceLength = static_cast(membersSequenceLength); + const auto _isConst = static_cast(isConst); + const auto _isStatic = static_cast(isStatic); + const auto _isDeclare = static_cast(isDeclare); + const auto _typeNode = reinterpret_cast(typeNode); + auto result = GetImpl()->UpdateTSEnumDeclaration1(_context, _original, _key, _members, _membersSequenceLength, _isConst, _isStatic, _isDeclare, _typeNode); + return result; +} +KOALA_INTEROP_9(UpdateTSEnumDeclaration1, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KBoolean, KBoolean, KBoolean, KNativePointer); + +KNativePointer impl_TSEnumDeclarationKeyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSEnumDeclarationKeyConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSEnumDeclarationKeyConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSEnumDeclarationTypeNodes(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSEnumDeclarationTypeNodes(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSEnumDeclarationTypeNodes, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSEnumDeclarationKey(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSEnumDeclarationKey(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSEnumDeclarationKey, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSEnumDeclarationMembersConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSEnumDeclarationMembersConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSEnumDeclarationMembersConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSEnumDeclarationInternalNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSEnumDeclarationInternalNameConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(TSEnumDeclarationInternalNameConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSEnumDeclarationSetInternalName(KNativePointer context, KNativePointer receiver, KStringPtr& internalName) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _internalName = getStringCopy(internalName); + GetImpl()->TSEnumDeclarationSetInternalName(_context, _receiver, _internalName); + return ; +} +KOALA_INTEROP_V3(TSEnumDeclarationSetInternalName, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_TSEnumDeclarationBoxedClassConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSEnumDeclarationBoxedClassConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSEnumDeclarationBoxedClassConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSEnumDeclarationSetBoxedClass(KNativePointer context, KNativePointer receiver, KNativePointer boxedClass) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _boxedClass = reinterpret_cast(boxedClass); + GetImpl()->TSEnumDeclarationSetBoxedClass(_context, _receiver, _boxedClass); + return ; +} +KOALA_INTEROP_V3(TSEnumDeclarationSetBoxedClass, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_TSEnumDeclarationIsConstConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSEnumDeclarationIsConstConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSEnumDeclarationIsConstConst, KBoolean, KNativePointer, KNativePointer); + +void impl_TSEnumDeclarationEmplaceMembers(KNativePointer context, KNativePointer receiver, KNativePointer source) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + GetImpl()->TSEnumDeclarationEmplaceMembers(_context, _receiver, _source); + return ; +} +KOALA_INTEROP_V3(TSEnumDeclarationEmplaceMembers, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSEnumDeclarationClearMembers(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->TSEnumDeclarationClearMembers(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(TSEnumDeclarationClearMembers, KNativePointer, KNativePointer); + +void impl_TSEnumDeclarationSetValueMembers(KNativePointer context, KNativePointer receiver, KNativePointer source, KUInt index) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + const auto _index = static_cast(index); + GetImpl()->TSEnumDeclarationSetValueMembers(_context, _receiver, _source, _index); + return ; +} +KOALA_INTEROP_V4(TSEnumDeclarationSetValueMembers, KNativePointer, KNativePointer, KNativePointer, KUInt); + +KNativePointer impl_TSEnumDeclarationMembersForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSEnumDeclarationMembersForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSEnumDeclarationMembersForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSNeverKeyword(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateTSNeverKeyword(_context); + return result; +} +KOALA_INTEROP_1(CreateTSNeverKeyword, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSNeverKeyword(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateTSNeverKeyword(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateTSNeverKeyword, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateImportDefaultSpecifier(KNativePointer context, KNativePointer local) +{ + const auto _context = reinterpret_cast(context); + const auto _local = reinterpret_cast(local); + auto result = GetImpl()->CreateImportDefaultSpecifier(_context, _local); + return result; +} +KOALA_INTEROP_2(CreateImportDefaultSpecifier, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateImportDefaultSpecifier(KNativePointer context, KNativePointer original, KNativePointer local) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _local = reinterpret_cast(local); + auto result = GetImpl()->UpdateImportDefaultSpecifier(_context, _original, _local); + return result; +} +KOALA_INTEROP_3(UpdateImportDefaultSpecifier, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ImportDefaultSpecifierLocalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ImportDefaultSpecifierLocalConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ImportDefaultSpecifierLocalConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ImportDefaultSpecifierLocal(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ImportDefaultSpecifierLocal(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ImportDefaultSpecifierLocal, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateObjectExpression(KNativePointer context, KInt nodeType, KNativePointerArray properties, KUInt propertiesSequenceLength, KBoolean trailingComma) +{ + const auto _context = reinterpret_cast(context); + const auto _nodeType = static_cast(nodeType); + const auto _properties = reinterpret_cast(properties); + const auto _propertiesSequenceLength = static_cast(propertiesSequenceLength); + const auto _trailingComma = static_cast(trailingComma); + auto result = GetImpl()->CreateObjectExpression(_context, _nodeType, _properties, _propertiesSequenceLength, _trailingComma); + return result; +} +KOALA_INTEROP_5(CreateObjectExpression, KNativePointer, KNativePointer, KInt, KNativePointerArray, KUInt, KBoolean); + +KNativePointer impl_UpdateObjectExpression(KNativePointer context, KNativePointer original, KInt nodeType, KNativePointerArray properties, KUInt propertiesSequenceLength, KBoolean trailingComma) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _nodeType = static_cast(nodeType); + const auto _properties = reinterpret_cast(properties); + const auto _propertiesSequenceLength = static_cast(propertiesSequenceLength); + const auto _trailingComma = static_cast(trailingComma); + auto result = GetImpl()->UpdateObjectExpression(_context, _original, _nodeType, _properties, _propertiesSequenceLength, _trailingComma); + return result; +} +KOALA_INTEROP_6(UpdateObjectExpression, KNativePointer, KNativePointer, KNativePointer, KInt, KNativePointerArray, KUInt, KBoolean); + +KNativePointer impl_ObjectExpressionPropertiesConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ObjectExpressionPropertiesConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ObjectExpressionPropertiesConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ObjectExpressionIsDeclarationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ObjectExpressionIsDeclarationConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ObjectExpressionIsDeclarationConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ObjectExpressionIsOptionalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ObjectExpressionIsOptionalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ObjectExpressionIsOptionalConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_ObjectExpressionValidateExpression(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ObjectExpressionValidateExpression(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ObjectExpressionValidateExpression, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ObjectExpressionConvertibleToObjectPattern(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ObjectExpressionConvertibleToObjectPattern(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ObjectExpressionConvertibleToObjectPattern, KBoolean, KNativePointer, KNativePointer); + +void impl_ObjectExpressionSetDeclaration(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ObjectExpressionSetDeclaration(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ObjectExpressionSetDeclaration, KNativePointer, KNativePointer); + +void impl_ObjectExpressionSetOptional(KNativePointer context, KNativePointer receiver, KBoolean optional_arg) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _optional_arg = static_cast(optional_arg); + GetImpl()->ObjectExpressionSetOptional(_context, _receiver, _optional_arg); + return ; +} +KOALA_INTEROP_V3(ObjectExpressionSetOptional, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_ObjectExpressionTypeAnnotationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ObjectExpressionTypeAnnotationConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ObjectExpressionTypeAnnotationConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ObjectExpressionSetTsTypeAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer typeAnnotation) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + GetImpl()->ObjectExpressionSetTsTypeAnnotation(_context, _receiver, _typeAnnotation); + return ; +} +KOALA_INTEROP_V3(ObjectExpressionSetTsTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateImportSpecifier(KNativePointer context, KNativePointer imported, KNativePointer local) +{ + const auto _context = reinterpret_cast(context); + const auto _imported = reinterpret_cast(imported); + const auto _local = reinterpret_cast(local); + auto result = GetImpl()->CreateImportSpecifier(_context, _imported, _local); + return result; +} +KOALA_INTEROP_3(CreateImportSpecifier, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateImportSpecifier(KNativePointer context, KNativePointer original, KNativePointer imported, KNativePointer local) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _imported = reinterpret_cast(imported); + const auto _local = reinterpret_cast(local); + auto result = GetImpl()->UpdateImportSpecifier(_context, _original, _imported, _local); + return result; +} +KOALA_INTEROP_4(UpdateImportSpecifier, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ImportSpecifierImported(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ImportSpecifierImported(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ImportSpecifierImported, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ImportSpecifierImportedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ImportSpecifierImportedConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ImportSpecifierImportedConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ImportSpecifierLocal(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ImportSpecifierLocal(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ImportSpecifierLocal, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ImportSpecifierLocalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ImportSpecifierLocalConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ImportSpecifierLocalConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ImportSpecifierIsRemovableConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ImportSpecifierIsRemovableConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ImportSpecifierIsRemovableConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ImportSpecifierSetRemovable(KNativePointer context, KNativePointer receiver, KBoolean isRemovable) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _isRemovable = static_cast(isRemovable); + GetImpl()->ImportSpecifierSetRemovable(_context, _receiver, _isRemovable); + return ; +} +KOALA_INTEROP_V3(ImportSpecifierSetRemovable, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_CreateConditionalExpression(KNativePointer context, KNativePointer test, KNativePointer consequent, KNativePointer alternate) +{ + const auto _context = reinterpret_cast(context); + const auto _test = reinterpret_cast(test); + const auto _consequent = reinterpret_cast(consequent); + const auto _alternate = reinterpret_cast(alternate); + auto result = GetImpl()->CreateConditionalExpression(_context, _test, _consequent, _alternate); + return result; +} +KOALA_INTEROP_4(CreateConditionalExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateConditionalExpression(KNativePointer context, KNativePointer original, KNativePointer test, KNativePointer consequent, KNativePointer alternate) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _test = reinterpret_cast(test); + const auto _consequent = reinterpret_cast(consequent); + const auto _alternate = reinterpret_cast(alternate); + auto result = GetImpl()->UpdateConditionalExpression(_context, _original, _test, _consequent, _alternate); + return result; +} +KOALA_INTEROP_5(UpdateConditionalExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ConditionalExpressionTestConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ConditionalExpressionTestConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ConditionalExpressionTestConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ConditionalExpressionTest(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ConditionalExpressionTest(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ConditionalExpressionTest, KNativePointer, KNativePointer, KNativePointer); + +void impl_ConditionalExpressionSetTest(KNativePointer context, KNativePointer receiver, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _expr = reinterpret_cast(expr); + GetImpl()->ConditionalExpressionSetTest(_context, _receiver, _expr); + return ; +} +KOALA_INTEROP_V3(ConditionalExpressionSetTest, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ConditionalExpressionConsequentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ConditionalExpressionConsequentConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ConditionalExpressionConsequentConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ConditionalExpressionConsequent(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ConditionalExpressionConsequent(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ConditionalExpressionConsequent, KNativePointer, KNativePointer, KNativePointer); + +void impl_ConditionalExpressionSetConsequent(KNativePointer context, KNativePointer receiver, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _expr = reinterpret_cast(expr); + GetImpl()->ConditionalExpressionSetConsequent(_context, _receiver, _expr); + return ; +} +KOALA_INTEROP_V3(ConditionalExpressionSetConsequent, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ConditionalExpressionAlternateConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ConditionalExpressionAlternateConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ConditionalExpressionAlternateConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ConditionalExpressionAlternate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ConditionalExpressionAlternate(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ConditionalExpressionAlternate, KNativePointer, KNativePointer, KNativePointer); + +void impl_ConditionalExpressionSetAlternate(KNativePointer context, KNativePointer receiver, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _expr = reinterpret_cast(expr); + GetImpl()->ConditionalExpressionSetAlternate(_context, _receiver, _expr); + return ; +} +KOALA_INTEROP_V3(ConditionalExpressionSetAlternate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateCallExpression(KNativePointer context, KNativePointer callee, KNativePointerArray _arguments, KUInt _argumentsSequenceLength, KNativePointer typeParams, KBoolean optional_arg, KBoolean trailingComma) +{ + const auto _context = reinterpret_cast(context); + const auto _callee = reinterpret_cast(callee); + const auto __arguments = reinterpret_cast(_arguments); + const auto __argumentsSequenceLength = static_cast(_argumentsSequenceLength); + const auto _typeParams = reinterpret_cast(typeParams); + const auto _optional_arg = static_cast(optional_arg); + const auto _trailingComma = static_cast(trailingComma); + auto result = GetImpl()->CreateCallExpression(_context, _callee, __arguments, __argumentsSequenceLength, _typeParams, _optional_arg, _trailingComma); + return result; +} +KOALA_INTEROP_7(CreateCallExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KNativePointer, KBoolean, KBoolean); + +KNativePointer impl_CreateCallExpression1(KNativePointer context, KNativePointer other) +{ + const auto _context = reinterpret_cast(context); + const auto _other = reinterpret_cast(other); + auto result = GetImpl()->CreateCallExpression1(_context, _other); + return result; +} +KOALA_INTEROP_2(CreateCallExpression1, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateCallExpression1(KNativePointer context, KNativePointer original, KNativePointer other) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _other = reinterpret_cast(other); + auto result = GetImpl()->UpdateCallExpression1(_context, _original, _other); + return result; +} +KOALA_INTEROP_3(UpdateCallExpression1, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CallExpressionCalleeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->CallExpressionCalleeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(CallExpressionCalleeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CallExpressionCallee(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->CallExpressionCallee(_context, _receiver); + return result; +} +KOALA_INTEROP_2(CallExpressionCallee, KNativePointer, KNativePointer, KNativePointer); + +void impl_CallExpressionSetCallee(KNativePointer context, KNativePointer receiver, KNativePointer callee) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _callee = reinterpret_cast(callee); + GetImpl()->CallExpressionSetCallee(_context, _receiver, _callee); + return ; +} +KOALA_INTEROP_V3(CallExpressionSetCallee, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CallExpressionTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->CallExpressionTypeParamsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(CallExpressionTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CallExpressionTypeParams(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->CallExpressionTypeParams(_context, _receiver); + return result; +} +KOALA_INTEROP_2(CallExpressionTypeParams, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CallExpressionArgumentsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->CallExpressionArgumentsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(CallExpressionArgumentsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CallExpressionArguments(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->CallExpressionArguments(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(CallExpressionArguments, KNativePointer, KNativePointer, KNativePointer); + +void impl_CallExpressionSetArguments(KNativePointer context, KNativePointer receiver, KNativePointerArray argumentsList, KUInt argumentsListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _argumentsList = reinterpret_cast(argumentsList); + const auto _argumentsListSequenceLength = static_cast(argumentsListSequenceLength); + GetImpl()->CallExpressionSetArguments(_context, _receiver, _argumentsList, _argumentsListSequenceLength); + return ; +} +KOALA_INTEROP_V4(CallExpressionSetArguments, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KBoolean impl_CallExpressionHasTrailingCommaConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->CallExpressionHasTrailingCommaConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(CallExpressionHasTrailingCommaConst, KBoolean, KNativePointer, KNativePointer); + +void impl_CallExpressionSetTypeParams(KNativePointer context, KNativePointer receiver, KNativePointer typeParams) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _typeParams = reinterpret_cast(typeParams); + GetImpl()->CallExpressionSetTypeParams(_context, _receiver, _typeParams); + return ; +} +KOALA_INTEROP_V3(CallExpressionSetTypeParams, KNativePointer, KNativePointer, KNativePointer); + +void impl_CallExpressionSetTrailingBlock(KNativePointer context, KNativePointer receiver, KNativePointer block) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _block = reinterpret_cast(block); + GetImpl()->CallExpressionSetTrailingBlock(_context, _receiver, _block); + return ; +} +KOALA_INTEROP_V3(CallExpressionSetTrailingBlock, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_CallExpressionIsExtensionAccessorCall(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->CallExpressionIsExtensionAccessorCall(_context, _receiver); + return result; +} +KOALA_INTEROP_2(CallExpressionIsExtensionAccessorCall, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CallExpressionTrailingBlockConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->CallExpressionTrailingBlockConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(CallExpressionTrailingBlockConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_CallExpressionSetIsTrailingBlockInNewLine(KNativePointer context, KNativePointer receiver, KBoolean isNewLine) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _isNewLine = static_cast(isNewLine); + GetImpl()->CallExpressionSetIsTrailingBlockInNewLine(_context, _receiver, _isNewLine); + return ; +} +KOALA_INTEROP_V3(CallExpressionSetIsTrailingBlockInNewLine, KNativePointer, KNativePointer, KBoolean); + +KBoolean impl_CallExpressionIsTrailingBlockInNewLineConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->CallExpressionIsTrailingBlockInNewLineConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(CallExpressionIsTrailingBlockInNewLineConst, KBoolean, KNativePointer, KNativePointer); + +void impl_CallExpressionSetIsTrailingCall(KNativePointer context, KNativePointer receiver, KBoolean isTrailingCall) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _isTrailingCall = static_cast(isTrailingCall); + GetImpl()->CallExpressionSetIsTrailingCall(_context, _receiver, _isTrailingCall); + return ; +} +KOALA_INTEROP_V3(CallExpressionSetIsTrailingCall, KNativePointer, KNativePointer, KBoolean); + +KBoolean impl_CallExpressionIsTrailingCallConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->CallExpressionIsTrailingCallConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(CallExpressionIsTrailingCallConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_CallExpressionIsETSConstructorCallConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->CallExpressionIsETSConstructorCallConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(CallExpressionIsETSConstructorCallConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_CallExpressionIsDynamicCallConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->CallExpressionIsDynamicCallConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(CallExpressionIsDynamicCallConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateBigIntLiteral(KNativePointer context, KStringPtr& src) +{ + const auto _context = reinterpret_cast(context); + const auto _src = getStringCopy(src); + auto result = GetImpl()->CreateBigIntLiteral(_context, _src); + return result; +} +KOALA_INTEROP_2(CreateBigIntLiteral, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_UpdateBigIntLiteral(KNativePointer context, KNativePointer original, KStringPtr& src) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _src = getStringCopy(src); + auto result = GetImpl()->UpdateBigIntLiteral(_context, _original, _src); + return result; +} +KOALA_INTEROP_3(UpdateBigIntLiteral, KNativePointer, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_BigIntLiteralStrConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BigIntLiteralStrConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(BigIntLiteralStrConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassElementId(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassElementId(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassElementId, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassElementIdConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassElementIdConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ClassElementIdConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassElementKey(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassElementKey(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassElementKey, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassElementKeyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassElementKeyConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ClassElementKeyConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassElementValue(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassElementValue(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassElementValue, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassElementSetValue(KNativePointer context, KNativePointer receiver, KNativePointer value) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _value = reinterpret_cast(value); + GetImpl()->ClassElementSetValue(_context, _receiver, _value); + return ; +} +KOALA_INTEROP_V3(ClassElementSetValue, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassElementValueConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassElementValueConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ClassElementValueConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassElementOriginEnumMemberConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassElementOriginEnumMemberConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ClassElementOriginEnumMemberConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassElementSetOrigEnumMember(KNativePointer context, KNativePointer receiver, KNativePointer enumMember) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _enumMember = reinterpret_cast(enumMember); + GetImpl()->ClassElementSetOrigEnumMember(_context, _receiver, _enumMember); + return ; +} +KOALA_INTEROP_V3(ClassElementSetOrigEnumMember, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ClassElementIsPrivateElementConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassElementIsPrivateElementConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassElementIsPrivateElementConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassElementIsComputedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassElementIsComputedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassElementIsComputedConst, KBoolean, KNativePointer, KNativePointer); + +KInt impl_ClassElementToPrivateFieldKindConst(KNativePointer context, KNativePointer receiver, KBoolean isStatic) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _isStatic = static_cast(isStatic); + auto result = GetImpl()->ClassElementToPrivateFieldKindConst(_context, _receiver, _isStatic); + return result; +} +KOALA_INTEROP_3(ClassElementToPrivateFieldKindConst, KInt, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_CreateTSImportType(KNativePointer context, KNativePointer param, KNativePointer typeParams, KNativePointer qualifier, KBoolean isTypeof) +{ + const auto _context = reinterpret_cast(context); + const auto _param = reinterpret_cast(param); + const auto _typeParams = reinterpret_cast(typeParams); + const auto _qualifier = reinterpret_cast(qualifier); + const auto _isTypeof = static_cast(isTypeof); + auto result = GetImpl()->CreateTSImportType(_context, _param, _typeParams, _qualifier, _isTypeof); + return result; +} +KOALA_INTEROP_5(CreateTSImportType, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_UpdateTSImportType(KNativePointer context, KNativePointer original, KNativePointer param, KNativePointer typeParams, KNativePointer qualifier, KBoolean isTypeof) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _param = reinterpret_cast(param); + const auto _typeParams = reinterpret_cast(typeParams); + const auto _qualifier = reinterpret_cast(qualifier); + const auto _isTypeof = static_cast(isTypeof); + auto result = GetImpl()->UpdateTSImportType(_context, _original, _param, _typeParams, _qualifier, _isTypeof); + return result; +} +KOALA_INTEROP_6(UpdateTSImportType, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_TSImportTypeParamConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSImportTypeParamConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSImportTypeParamConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSImportTypeTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSImportTypeTypeParamsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSImportTypeTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSImportTypeQualifierConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSImportTypeQualifierConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSImportTypeQualifierConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_TSImportTypeIsTypeofConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSImportTypeIsTypeofConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSImportTypeIsTypeofConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTaggedTemplateExpression(KNativePointer context, KNativePointer tag, KNativePointer quasi, KNativePointer typeParams) +{ + const auto _context = reinterpret_cast(context); + const auto _tag = reinterpret_cast(tag); + const auto _quasi = reinterpret_cast(quasi); + const auto _typeParams = reinterpret_cast(typeParams); + auto result = GetImpl()->CreateTaggedTemplateExpression(_context, _tag, _quasi, _typeParams); + return result; +} +KOALA_INTEROP_4(CreateTaggedTemplateExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTaggedTemplateExpression(KNativePointer context, KNativePointer original, KNativePointer tag, KNativePointer quasi, KNativePointer typeParams) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _tag = reinterpret_cast(tag); + const auto _quasi = reinterpret_cast(quasi); + const auto _typeParams = reinterpret_cast(typeParams); + auto result = GetImpl()->UpdateTaggedTemplateExpression(_context, _original, _tag, _quasi, _typeParams); + return result; +} +KOALA_INTEROP_5(UpdateTaggedTemplateExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TaggedTemplateExpressionTagConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TaggedTemplateExpressionTagConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TaggedTemplateExpressionTagConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TaggedTemplateExpressionQuasiConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TaggedTemplateExpressionQuasiConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TaggedTemplateExpressionQuasiConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TaggedTemplateExpressionTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TaggedTemplateExpressionTypeParamsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TaggedTemplateExpressionTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateFunctionDeclaration(KNativePointer context, KNativePointer func, KNativePointerArray annotations, KUInt annotationsSequenceLength, KBoolean isAnonymous) +{ + const auto _context = reinterpret_cast(context); + const auto _func = reinterpret_cast(func); + const auto _annotations = reinterpret_cast(annotations); + const auto _annotationsSequenceLength = static_cast(annotationsSequenceLength); + const auto _isAnonymous = static_cast(isAnonymous); + auto result = GetImpl()->CreateFunctionDeclaration(_context, _func, _annotations, _annotationsSequenceLength, _isAnonymous); + return result; +} +KOALA_INTEROP_5(CreateFunctionDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KBoolean); + +KNativePointer impl_UpdateFunctionDeclaration(KNativePointer context, KNativePointer original, KNativePointer func, KNativePointerArray annotations, KUInt annotationsSequenceLength, KBoolean isAnonymous) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _func = reinterpret_cast(func); + const auto _annotations = reinterpret_cast(annotations); + const auto _annotationsSequenceLength = static_cast(annotationsSequenceLength); + const auto _isAnonymous = static_cast(isAnonymous); + auto result = GetImpl()->UpdateFunctionDeclaration(_context, _original, _func, _annotations, _annotationsSequenceLength, _isAnonymous); + return result; +} +KOALA_INTEROP_6(UpdateFunctionDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KBoolean); + +KNativePointer impl_CreateFunctionDeclaration1(KNativePointer context, KNativePointer func, KBoolean isAnonymous) +{ + const auto _context = reinterpret_cast(context); + const auto _func = reinterpret_cast(func); + const auto _isAnonymous = static_cast(isAnonymous); + auto result = GetImpl()->CreateFunctionDeclaration1(_context, _func, _isAnonymous); + return result; +} +KOALA_INTEROP_3(CreateFunctionDeclaration1, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_UpdateFunctionDeclaration1(KNativePointer context, KNativePointer original, KNativePointer func, KBoolean isAnonymous) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _func = reinterpret_cast(func); + const auto _isAnonymous = static_cast(isAnonymous); + auto result = GetImpl()->UpdateFunctionDeclaration1(_context, _original, _func, _isAnonymous); + return result; +} +KOALA_INTEROP_4(UpdateFunctionDeclaration1, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_FunctionDeclarationFunction(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->FunctionDeclarationFunction(_context, _receiver); + return result; +} +KOALA_INTEROP_2(FunctionDeclarationFunction, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_FunctionDeclarationIsAnonymousConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->FunctionDeclarationIsAnonymousConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(FunctionDeclarationIsAnonymousConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_FunctionDeclarationFunctionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->FunctionDeclarationFunctionConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(FunctionDeclarationFunctionConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_FunctionDeclarationHasAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->FunctionDeclarationHasAnnotationsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(FunctionDeclarationHasAnnotationsConst, KBoolean, KNativePointer, KNativePointer); + +void impl_FunctionDeclarationEmplaceAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer source) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + GetImpl()->FunctionDeclarationEmplaceAnnotation(_context, _receiver, _source); + return ; +} +KOALA_INTEROP_V3(FunctionDeclarationEmplaceAnnotation, KNativePointer, KNativePointer, KNativePointer); + +void impl_FunctionDeclarationClearAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->FunctionDeclarationClearAnnotations(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(FunctionDeclarationClearAnnotations, KNativePointer, KNativePointer); + +void impl_FunctionDeclarationDumpAnnotationsConst(KNativePointer context, KNativePointer receiver, KNativePointer dumper) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _dumper = reinterpret_cast(dumper); + GetImpl()->FunctionDeclarationDumpAnnotationsConst(_context, _receiver, _dumper); + return ; +} +KOALA_INTEROP_V3(FunctionDeclarationDumpAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_FunctionDeclarationAnnotationsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->FunctionDeclarationAnnotationsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(FunctionDeclarationAnnotationsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_FunctionDeclarationAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->FunctionDeclarationAnnotations(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(FunctionDeclarationAnnotations, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_FunctionDeclarationAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->FunctionDeclarationAnnotationsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(FunctionDeclarationAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_FunctionDeclarationSetAnnotations(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->FunctionDeclarationSetAnnotations(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(FunctionDeclarationSetAnnotations, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_FunctionDeclarationSetAnnotations1(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->FunctionDeclarationSetAnnotations1(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(FunctionDeclarationSetAnnotations1, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateETSTypeReference(KNativePointer context, KNativePointer part) +{ + const auto _context = reinterpret_cast(context); + const auto _part = reinterpret_cast(part); + auto result = GetImpl()->CreateETSTypeReference(_context, _part); + return result; +} +KOALA_INTEROP_2(CreateETSTypeReference, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSTypeReference(KNativePointer context, KNativePointer original, KNativePointer part) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _part = reinterpret_cast(part); + auto result = GetImpl()->UpdateETSTypeReference(_context, _original, _part); + return result; +} +KOALA_INTEROP_3(UpdateETSTypeReference, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSTypeReferencePart(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSTypeReferencePart(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSTypeReferencePart, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSTypeReferencePartConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSTypeReferencePartConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSTypeReferencePartConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSTypeReferenceBaseNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSTypeReferenceBaseNameConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSTypeReferenceBaseNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSTypeReference(KNativePointer context, KNativePointer typeName, KNativePointer typeParams) +{ + const auto _context = reinterpret_cast(context); + const auto _typeName = reinterpret_cast(typeName); + const auto _typeParams = reinterpret_cast(typeParams); + auto result = GetImpl()->CreateTSTypeReference(_context, _typeName, _typeParams); + return result; +} +KOALA_INTEROP_3(CreateTSTypeReference, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSTypeReference(KNativePointer context, KNativePointer original, KNativePointer typeName, KNativePointer typeParams) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _typeName = reinterpret_cast(typeName); + const auto _typeParams = reinterpret_cast(typeParams); + auto result = GetImpl()->UpdateTSTypeReference(_context, _original, _typeName, _typeParams); + return result; +} +KOALA_INTEROP_4(UpdateTSTypeReference, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeReferenceTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeReferenceTypeParamsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSTypeReferenceTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeReferenceTypeNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeReferenceTypeNameConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSTypeReferenceTypeNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeReferenceBaseNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeReferenceBaseNameConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSTypeReferenceBaseNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateNamedType(KNativePointer context, KNativePointer name) +{ + const auto _context = reinterpret_cast(context); + const auto _name = reinterpret_cast(name); + auto result = GetImpl()->CreateNamedType(_context, _name); + return result; +} +KOALA_INTEROP_2(CreateNamedType, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateNamedType(KNativePointer context, KNativePointer original, KNativePointer name) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _name = reinterpret_cast(name); + auto result = GetImpl()->UpdateNamedType(_context, _original, _name); + return result; +} +KOALA_INTEROP_3(UpdateNamedType, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_NamedTypeNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->NamedTypeNameConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(NamedTypeNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_NamedTypeTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->NamedTypeTypeParamsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(NamedTypeTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_NamedTypeIsNullableConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->NamedTypeIsNullableConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(NamedTypeIsNullableConst, KBoolean, KNativePointer, KNativePointer); + +void impl_NamedTypeSetNullable(KNativePointer context, KNativePointer receiver, KBoolean nullable) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _nullable = static_cast(nullable); + GetImpl()->NamedTypeSetNullable(_context, _receiver, _nullable); + return ; +} +KOALA_INTEROP_V3(NamedTypeSetNullable, KNativePointer, KNativePointer, KBoolean); + +void impl_NamedTypeSetNext(KNativePointer context, KNativePointer receiver, KNativePointer next) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _next = reinterpret_cast(next); + GetImpl()->NamedTypeSetNext(_context, _receiver, _next); + return ; +} +KOALA_INTEROP_V3(NamedTypeSetNext, KNativePointer, KNativePointer, KNativePointer); + +void impl_NamedTypeSetTypeParams(KNativePointer context, KNativePointer receiver, KNativePointer typeParams) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _typeParams = reinterpret_cast(typeParams); + GetImpl()->NamedTypeSetTypeParams(_context, _receiver, _typeParams); + return ; +} +KOALA_INTEROP_V3(NamedTypeSetTypeParams, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSFunctionType(KNativePointer context, KNativePointer signature) +{ + const auto _context = reinterpret_cast(context); + const auto _signature = reinterpret_cast(signature); + auto result = GetImpl()->CreateTSFunctionType(_context, _signature); + return result; +} +KOALA_INTEROP_2(CreateTSFunctionType, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSFunctionType(KNativePointer context, KNativePointer original, KNativePointer signature) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _signature = reinterpret_cast(signature); + auto result = GetImpl()->UpdateTSFunctionType(_context, _original, _signature); + return result; +} +KOALA_INTEROP_3(UpdateTSFunctionType, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSFunctionTypeTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSFunctionTypeTypeParamsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSFunctionTypeTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSFunctionTypeTypeParams(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSFunctionTypeTypeParams(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSFunctionTypeTypeParams, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSFunctionTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSFunctionTypeParamsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSFunctionTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSFunctionTypeReturnTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSFunctionTypeReturnTypeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSFunctionTypeReturnTypeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSFunctionTypeReturnType(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSFunctionTypeReturnType(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSFunctionTypeReturnType, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSFunctionTypeSetNullable(KNativePointer context, KNativePointer receiver, KBoolean nullable) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _nullable = static_cast(nullable); + GetImpl()->TSFunctionTypeSetNullable(_context, _receiver, _nullable); + return ; +} +KOALA_INTEROP_V3(TSFunctionTypeSetNullable, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_CreateTemplateElement(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateTemplateElement(_context); + return result; +} +KOALA_INTEROP_1(CreateTemplateElement, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTemplateElement(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateTemplateElement(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateTemplateElement, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTemplateElement1(KNativePointer context, KStringPtr& raw, KStringPtr& cooked) +{ + const auto _context = reinterpret_cast(context); + const auto _raw = getStringCopy(raw); + const auto _cooked = getStringCopy(cooked); + auto result = GetImpl()->CreateTemplateElement1(_context, _raw, _cooked); + return result; +} +KOALA_INTEROP_3(CreateTemplateElement1, KNativePointer, KNativePointer, KStringPtr, KStringPtr); + +KNativePointer impl_UpdateTemplateElement1(KNativePointer context, KNativePointer original, KStringPtr& raw, KStringPtr& cooked) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _raw = getStringCopy(raw); + const auto _cooked = getStringCopy(cooked); + auto result = GetImpl()->UpdateTemplateElement1(_context, _original, _raw, _cooked); + return result; +} +KOALA_INTEROP_4(UpdateTemplateElement1, KNativePointer, KNativePointer, KNativePointer, KStringPtr, KStringPtr); + +KNativePointer impl_TemplateElementRawConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TemplateElementRawConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(TemplateElementRawConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TemplateElementCookedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TemplateElementCookedConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(TemplateElementCookedConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSInterfaceDeclaration(KNativePointer context, KNativePointerArray _extends, KUInt _extendsSequenceLength, KNativePointer id, KNativePointer typeParams, KNativePointer body, KBoolean isStatic, KBoolean isExternal) +{ + const auto _context = reinterpret_cast(context); + const auto __extends = reinterpret_cast(_extends); + const auto __extendsSequenceLength = static_cast(_extendsSequenceLength); + const auto _id = reinterpret_cast(id); + const auto _typeParams = reinterpret_cast(typeParams); + const auto _body = reinterpret_cast(body); + const auto _isStatic = static_cast(isStatic); + const auto _isExternal = static_cast(isExternal); + auto result = GetImpl()->CreateTSInterfaceDeclaration(_context, __extends, __extendsSequenceLength, _id, _typeParams, _body, _isStatic, _isExternal); + return result; +} +KOALA_INTEROP_8(CreateTSInterfaceDeclaration, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KNativePointer, KNativePointer, KNativePointer, KBoolean, KBoolean); + +KNativePointer impl_UpdateTSInterfaceDeclaration(KNativePointer context, KNativePointer original, KNativePointerArray _extends, KUInt _extendsSequenceLength, KNativePointer id, KNativePointer typeParams, KNativePointer body, KBoolean isStatic, KBoolean isExternal) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto __extends = reinterpret_cast(_extends); + const auto __extendsSequenceLength = static_cast(_extendsSequenceLength); + const auto _id = reinterpret_cast(id); + const auto _typeParams = reinterpret_cast(typeParams); + const auto _body = reinterpret_cast(body); + const auto _isStatic = static_cast(isStatic); + const auto _isExternal = static_cast(isExternal); + auto result = GetImpl()->UpdateTSInterfaceDeclaration(_context, _original, __extends, __extendsSequenceLength, _id, _typeParams, _body, _isStatic, _isExternal); + return result; +} +KOALA_INTEROP_9(UpdateTSInterfaceDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KNativePointer, KNativePointer, KNativePointer, KBoolean, KBoolean); + +KNativePointer impl_TSInterfaceDeclarationBody(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSInterfaceDeclarationBody(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSInterfaceDeclarationBody, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSInterfaceDeclarationBodyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSInterfaceDeclarationBodyConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSInterfaceDeclarationBodyConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSInterfaceDeclarationId(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSInterfaceDeclarationId(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSInterfaceDeclarationId, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSInterfaceDeclarationIdConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSInterfaceDeclarationIdConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSInterfaceDeclarationIdConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSInterfaceDeclarationInternalNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSInterfaceDeclarationInternalNameConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(TSInterfaceDeclarationInternalNameConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSInterfaceDeclarationSetInternalName(KNativePointer context, KNativePointer receiver, KStringPtr& internalName) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _internalName = getStringCopy(internalName); + GetImpl()->TSInterfaceDeclarationSetInternalName(_context, _receiver, _internalName); + return ; +} +KOALA_INTEROP_V3(TSInterfaceDeclarationSetInternalName, KNativePointer, KNativePointer, KStringPtr); + +KBoolean impl_TSInterfaceDeclarationIsStaticConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSInterfaceDeclarationIsStaticConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSInterfaceDeclarationIsStaticConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_TSInterfaceDeclarationIsFromExternalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSInterfaceDeclarationIsFromExternalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSInterfaceDeclarationIsFromExternalConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_TSInterfaceDeclarationTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSInterfaceDeclarationTypeParamsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSInterfaceDeclarationTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSInterfaceDeclarationTypeParams(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSInterfaceDeclarationTypeParams(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSInterfaceDeclarationTypeParams, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSInterfaceDeclarationExtends(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSInterfaceDeclarationExtends(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSInterfaceDeclarationExtends, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSInterfaceDeclarationExtendsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSInterfaceDeclarationExtendsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSInterfaceDeclarationExtendsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSInterfaceDeclarationExtendsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSInterfaceDeclarationExtendsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSInterfaceDeclarationExtendsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSInterfaceDeclarationGetAnonClass(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSInterfaceDeclarationGetAnonClass(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSInterfaceDeclarationGetAnonClass, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSInterfaceDeclarationGetAnonClassConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSInterfaceDeclarationGetAnonClassConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSInterfaceDeclarationGetAnonClassConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSInterfaceDeclarationSetAnonClass(KNativePointer context, KNativePointer receiver, KNativePointer anonClass) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _anonClass = reinterpret_cast(anonClass); + GetImpl()->TSInterfaceDeclarationSetAnonClass(_context, _receiver, _anonClass); + return ; +} +KOALA_INTEROP_V3(TSInterfaceDeclarationSetAnonClass, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSInterfaceDeclarationEmplaceExtends(KNativePointer context, KNativePointer receiver, KNativePointer _extends) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto __extends = reinterpret_cast(_extends); + GetImpl()->TSInterfaceDeclarationEmplaceExtends(_context, _receiver, __extends); + return ; +} +KOALA_INTEROP_V3(TSInterfaceDeclarationEmplaceExtends, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSInterfaceDeclarationClearExtends(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->TSInterfaceDeclarationClearExtends(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(TSInterfaceDeclarationClearExtends, KNativePointer, KNativePointer); + +void impl_TSInterfaceDeclarationSetValueExtends(KNativePointer context, KNativePointer receiver, KNativePointer _extends, KUInt index) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto __extends = reinterpret_cast(_extends); + const auto _index = static_cast(index); + GetImpl()->TSInterfaceDeclarationSetValueExtends(_context, _receiver, __extends, _index); + return ; +} +KOALA_INTEROP_V4(TSInterfaceDeclarationSetValueExtends, KNativePointer, KNativePointer, KNativePointer, KUInt); + +KBoolean impl_TSInterfaceDeclarationHasAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSInterfaceDeclarationHasAnnotationsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSInterfaceDeclarationHasAnnotationsConst, KBoolean, KNativePointer, KNativePointer); + +void impl_TSInterfaceDeclarationEmplaceAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer source) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + GetImpl()->TSInterfaceDeclarationEmplaceAnnotation(_context, _receiver, _source); + return ; +} +KOALA_INTEROP_V3(TSInterfaceDeclarationEmplaceAnnotation, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSInterfaceDeclarationClearAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->TSInterfaceDeclarationClearAnnotations(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(TSInterfaceDeclarationClearAnnotations, KNativePointer, KNativePointer); + +void impl_TSInterfaceDeclarationDumpAnnotationsConst(KNativePointer context, KNativePointer receiver, KNativePointer dumper) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _dumper = reinterpret_cast(dumper); + GetImpl()->TSInterfaceDeclarationDumpAnnotationsConst(_context, _receiver, _dumper); + return ; +} +KOALA_INTEROP_V3(TSInterfaceDeclarationDumpAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSInterfaceDeclarationAnnotationsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSInterfaceDeclarationAnnotationsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSInterfaceDeclarationAnnotationsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSInterfaceDeclarationAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSInterfaceDeclarationAnnotations(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSInterfaceDeclarationAnnotations, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSInterfaceDeclarationAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSInterfaceDeclarationAnnotationsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSInterfaceDeclarationAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSInterfaceDeclarationSetAnnotations(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->TSInterfaceDeclarationSetAnnotations(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(TSInterfaceDeclarationSetAnnotations, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_TSInterfaceDeclarationSetAnnotations1(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->TSInterfaceDeclarationSetAnnotations1(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(TSInterfaceDeclarationSetAnnotations1, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateVariableDeclaration(KNativePointer context, KInt kind, KNativePointerArray declarators, KUInt declaratorsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _kind = static_cast(kind); + const auto _declarators = reinterpret_cast(declarators); + const auto _declaratorsSequenceLength = static_cast(declaratorsSequenceLength); + auto result = GetImpl()->CreateVariableDeclaration(_context, _kind, _declarators, _declaratorsSequenceLength); + return result; +} +KOALA_INTEROP_4(CreateVariableDeclaration, KNativePointer, KNativePointer, KInt, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateVariableDeclaration(KNativePointer context, KNativePointer original, KInt kind, KNativePointerArray declarators, KUInt declaratorsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _kind = static_cast(kind); + const auto _declarators = reinterpret_cast(declarators); + const auto _declaratorsSequenceLength = static_cast(declaratorsSequenceLength); + auto result = GetImpl()->UpdateVariableDeclaration(_context, _original, _kind, _declarators, _declaratorsSequenceLength); + return result; +} +KOALA_INTEROP_5(UpdateVariableDeclaration, KNativePointer, KNativePointer, KNativePointer, KInt, KNativePointerArray, KUInt); + +KNativePointer impl_VariableDeclarationDeclaratorsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->VariableDeclarationDeclaratorsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(VariableDeclarationDeclaratorsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_VariableDeclarationDeclarators(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->VariableDeclarationDeclarators(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(VariableDeclarationDeclarators, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_VariableDeclarationDeclaratorsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->VariableDeclarationDeclaratorsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(VariableDeclarationDeclaratorsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KInt impl_VariableDeclarationKindConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->VariableDeclarationKindConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(VariableDeclarationKindConst, KInt, KNativePointer, KNativePointer); + +KNativePointer impl_VariableDeclarationGetDeclaratorByNameConst(KNativePointer context, KNativePointer receiver, KStringPtr& name) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _name = getStringCopy(name); + auto result = GetImpl()->VariableDeclarationGetDeclaratorByNameConst(_context, _receiver, _name); + return (void*)result; +} +KOALA_INTEROP_3(VariableDeclarationGetDeclaratorByNameConst, KNativePointer, KNativePointer, KNativePointer, KStringPtr); + +KBoolean impl_VariableDeclarationHasAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->VariableDeclarationHasAnnotationsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(VariableDeclarationHasAnnotationsConst, KBoolean, KNativePointer, KNativePointer); + +void impl_VariableDeclarationEmplaceAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer source) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + GetImpl()->VariableDeclarationEmplaceAnnotation(_context, _receiver, _source); + return ; +} +KOALA_INTEROP_V3(VariableDeclarationEmplaceAnnotation, KNativePointer, KNativePointer, KNativePointer); + +void impl_VariableDeclarationClearAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->VariableDeclarationClearAnnotations(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(VariableDeclarationClearAnnotations, KNativePointer, KNativePointer); + +void impl_VariableDeclarationDumpAnnotationsConst(KNativePointer context, KNativePointer receiver, KNativePointer dumper) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _dumper = reinterpret_cast(dumper); + GetImpl()->VariableDeclarationDumpAnnotationsConst(_context, _receiver, _dumper); + return ; +} +KOALA_INTEROP_V3(VariableDeclarationDumpAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_VariableDeclarationAnnotationsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->VariableDeclarationAnnotationsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(VariableDeclarationAnnotationsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_VariableDeclarationAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->VariableDeclarationAnnotations(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(VariableDeclarationAnnotations, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_VariableDeclarationAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->VariableDeclarationAnnotationsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(VariableDeclarationAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_VariableDeclarationSetAnnotations(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->VariableDeclarationSetAnnotations(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(VariableDeclarationSetAnnotations, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_VariableDeclarationSetAnnotations1(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->VariableDeclarationSetAnnotations1(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(VariableDeclarationSetAnnotations1, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateUndefinedLiteral(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateUndefinedLiteral(_context); + return result; +} +KOALA_INTEROP_1(CreateUndefinedLiteral, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateUndefinedLiteral(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateUndefinedLiteral(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateUndefinedLiteral, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateMemberExpression(KNativePointer context, KNativePointer object_arg, KNativePointer property, KInt kind, KBoolean computed, KBoolean optional_arg) +{ + const auto _context = reinterpret_cast(context); + const auto _object_arg = reinterpret_cast(object_arg); + const auto _property = reinterpret_cast(property); + const auto _kind = static_cast(kind); + const auto _computed = static_cast(computed); + const auto _optional_arg = static_cast(optional_arg); + auto result = GetImpl()->CreateMemberExpression(_context, _object_arg, _property, _kind, _computed, _optional_arg); + return result; +} +KOALA_INTEROP_6(CreateMemberExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KBoolean, KBoolean); + +KNativePointer impl_UpdateMemberExpression(KNativePointer context, KNativePointer original, KNativePointer object_arg, KNativePointer property, KInt kind, KBoolean computed, KBoolean optional_arg) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _object_arg = reinterpret_cast(object_arg); + const auto _property = reinterpret_cast(property); + const auto _kind = static_cast(kind); + const auto _computed = static_cast(computed); + const auto _optional_arg = static_cast(optional_arg); + auto result = GetImpl()->UpdateMemberExpression(_context, _original, _object_arg, _property, _kind, _computed, _optional_arg); + return result; +} +KOALA_INTEROP_7(UpdateMemberExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KBoolean, KBoolean); + +KNativePointer impl_MemberExpressionObject(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MemberExpressionObject(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MemberExpressionObject, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_MemberExpressionObjectConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MemberExpressionObjectConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(MemberExpressionObjectConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_MemberExpressionSetObject(KNativePointer context, KNativePointer receiver, KNativePointer object_arg) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _object_arg = reinterpret_cast(object_arg); + GetImpl()->MemberExpressionSetObject(_context, _receiver, _object_arg); + return ; +} +KOALA_INTEROP_V3(MemberExpressionSetObject, KNativePointer, KNativePointer, KNativePointer); + +void impl_MemberExpressionSetProperty(KNativePointer context, KNativePointer receiver, KNativePointer prop) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _prop = reinterpret_cast(prop); + GetImpl()->MemberExpressionSetProperty(_context, _receiver, _prop); + return ; +} +KOALA_INTEROP_V3(MemberExpressionSetProperty, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_MemberExpressionProperty(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MemberExpressionProperty(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MemberExpressionProperty, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_MemberExpressionPropertyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MemberExpressionPropertyConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(MemberExpressionPropertyConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_MemberExpressionIsComputedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MemberExpressionIsComputedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MemberExpressionIsComputedConst, KBoolean, KNativePointer, KNativePointer); + +KInt impl_MemberExpressionKindConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MemberExpressionKindConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MemberExpressionKindConst, KInt, KNativePointer, KNativePointer); + +void impl_MemberExpressionAddMemberKind(KNativePointer context, KNativePointer receiver, KInt kind) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _kind = static_cast(kind); + GetImpl()->MemberExpressionAddMemberKind(_context, _receiver, _kind); + return ; +} +KOALA_INTEROP_V3(MemberExpressionAddMemberKind, KNativePointer, KNativePointer, KInt); + +KBoolean impl_MemberExpressionHasMemberKindConst(KNativePointer context, KNativePointer receiver, KInt kind) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _kind = static_cast(kind); + auto result = GetImpl()->MemberExpressionHasMemberKindConst(_context, _receiver, _kind); + return result; +} +KOALA_INTEROP_3(MemberExpressionHasMemberKindConst, KBoolean, KNativePointer, KNativePointer, KInt); + +void impl_MemberExpressionRemoveMemberKind(KNativePointer context, KNativePointer receiver, KInt kind) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _kind = static_cast(kind); + GetImpl()->MemberExpressionRemoveMemberKind(_context, _receiver, _kind); + return ; +} +KOALA_INTEROP_V3(MemberExpressionRemoveMemberKind, KNativePointer, KNativePointer, KInt); + +KBoolean impl_MemberExpressionIsIgnoreBoxConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MemberExpressionIsIgnoreBoxConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MemberExpressionIsIgnoreBoxConst, KBoolean, KNativePointer, KNativePointer); + +void impl_MemberExpressionSetIgnoreBox(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->MemberExpressionSetIgnoreBox(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(MemberExpressionSetIgnoreBox, KNativePointer, KNativePointer); + +KBoolean impl_MemberExpressionIsPrivateReferenceConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MemberExpressionIsPrivateReferenceConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MemberExpressionIsPrivateReferenceConst, KBoolean, KNativePointer, KNativePointer); + +void impl_MemberExpressionCompileToRegConst(KNativePointer context, KNativePointer receiver, KNativePointer pg, KNativePointer objReg) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _pg = reinterpret_cast(pg); + const auto _objReg = reinterpret_cast(objReg); + GetImpl()->MemberExpressionCompileToRegConst(_context, _receiver, _pg, _objReg); + return ; +} +KOALA_INTEROP_V4(MemberExpressionCompileToRegConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +void impl_MemberExpressionCompileToRegsConst(KNativePointer context, KNativePointer receiver, KNativePointer pg, KNativePointer object_arg, KNativePointer property) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _pg = reinterpret_cast(pg); + const auto _object_arg = reinterpret_cast(object_arg); + const auto _property = reinterpret_cast(property); + GetImpl()->MemberExpressionCompileToRegsConst(_context, _receiver, _pg, _object_arg, _property); + return ; +} +KOALA_INTEROP_V5(MemberExpressionCompileToRegsConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSClassImplements(KNativePointer context, KNativePointer expression, KNativePointer typeParameters) +{ + const auto _context = reinterpret_cast(context); + const auto _expression = reinterpret_cast(expression); + const auto _typeParameters = reinterpret_cast(typeParameters); + auto result = GetImpl()->CreateTSClassImplements(_context, _expression, _typeParameters); + return result; +} +KOALA_INTEROP_3(CreateTSClassImplements, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSClassImplements(KNativePointer context, KNativePointer original, KNativePointer expression, KNativePointer typeParameters) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _expression = reinterpret_cast(expression); + const auto _typeParameters = reinterpret_cast(typeParameters); + auto result = GetImpl()->UpdateTSClassImplements(_context, _original, _expression, _typeParameters); + return result; +} +KOALA_INTEROP_4(UpdateTSClassImplements, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSClassImplements1(KNativePointer context, KNativePointer expression) +{ + const auto _context = reinterpret_cast(context); + const auto _expression = reinterpret_cast(expression); + auto result = GetImpl()->CreateTSClassImplements1(_context, _expression); + return result; +} +KOALA_INTEROP_2(CreateTSClassImplements1, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSClassImplements1(KNativePointer context, KNativePointer original, KNativePointer expression) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _expression = reinterpret_cast(expression); + auto result = GetImpl()->UpdateTSClassImplements1(_context, _original, _expression); + return result; +} +KOALA_INTEROP_3(UpdateTSClassImplements1, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSClassImplementsExpr(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSClassImplementsExpr(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSClassImplementsExpr, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSClassImplementsExprConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSClassImplementsExprConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSClassImplementsExprConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSClassImplementsTypeParametersConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSClassImplementsTypeParametersConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSClassImplementsTypeParametersConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSObjectKeyword(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateTSObjectKeyword(_context); + return result; +} +KOALA_INTEROP_1(CreateTSObjectKeyword, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSObjectKeyword(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateTSObjectKeyword(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateTSObjectKeyword, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSUnionType(KNativePointer context, KNativePointerArray types, KUInt typesSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _types = reinterpret_cast(types); + const auto _typesSequenceLength = static_cast(typesSequenceLength); + auto result = GetImpl()->CreateETSUnionTypeIr(_context, _types, _typesSequenceLength); + return result; +} +KOALA_INTEROP_3(CreateETSUnionType, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateETSUnionType(KNativePointer context, KNativePointer original, KNativePointerArray types, KUInt typesSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _types = reinterpret_cast(types); + const auto _typesSequenceLength = static_cast(typesSequenceLength); + auto result = GetImpl()->UpdateETSUnionTypeIr(_context, _original, _types, _typesSequenceLength); + return result; +} +KOALA_INTEROP_4(UpdateETSUnionType, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_ETSUnionTypeTypesConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ETSUnionTypeIrTypesConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ETSUnionTypeTypesConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ETSUnionTypeSetValueTypesConst(KNativePointer context, KNativePointer receiver, KNativePointer type, KUInt index) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _type = reinterpret_cast(type); + const auto _index = static_cast(index); + GetImpl()->ETSUnionTypeIrSetValueTypesConst(_context, _receiver, _type, _index); + return ; +} +KOALA_INTEROP_V4(ETSUnionTypeSetValueTypesConst, KNativePointer, KNativePointer, KNativePointer, KUInt); + +KNativePointer impl_CreateETSKeyofType(KNativePointer context, KNativePointer type) +{ + const auto _context = reinterpret_cast(context); + const auto _type = reinterpret_cast(type); + auto result = GetImpl()->CreateETSKeyofType(_context, _type); + return result; +} +KOALA_INTEROP_2(CreateETSKeyofType, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSKeyofType(KNativePointer context, KNativePointer original, KNativePointer type) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _type = reinterpret_cast(type); + auto result = GetImpl()->UpdateETSKeyofType(_context, _original, _type); + return result; +} +KOALA_INTEROP_3(UpdateETSKeyofType, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSKeyofTypeGetTypeRefConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSKeyofTypeGetTypeRefConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSKeyofTypeGetTypeRefConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSPropertySignature(KNativePointer context, KNativePointer key, KNativePointer typeAnnotation, KBoolean computed, KBoolean optional_arg, KBoolean readonly_arg) +{ + const auto _context = reinterpret_cast(context); + const auto _key = reinterpret_cast(key); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + const auto _computed = static_cast(computed); + const auto _optional_arg = static_cast(optional_arg); + const auto _readonly_arg = static_cast(readonly_arg); + auto result = GetImpl()->CreateTSPropertySignature(_context, _key, _typeAnnotation, _computed, _optional_arg, _readonly_arg); + return result; +} +KOALA_INTEROP_6(CreateTSPropertySignature, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean, KBoolean, KBoolean); + +KNativePointer impl_UpdateTSPropertySignature(KNativePointer context, KNativePointer original, KNativePointer key, KNativePointer typeAnnotation, KBoolean computed, KBoolean optional_arg, KBoolean readonly_arg) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _key = reinterpret_cast(key); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + const auto _computed = static_cast(computed); + const auto _optional_arg = static_cast(optional_arg); + const auto _readonly_arg = static_cast(readonly_arg); + auto result = GetImpl()->UpdateTSPropertySignature(_context, _original, _key, _typeAnnotation, _computed, _optional_arg, _readonly_arg); + return result; +} +KOALA_INTEROP_7(UpdateTSPropertySignature, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean, KBoolean, KBoolean); + +KNativePointer impl_TSPropertySignatureKeyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSPropertySignatureKeyConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSPropertySignatureKeyConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSPropertySignatureKey(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSPropertySignatureKey(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSPropertySignatureKey, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_TSPropertySignatureComputedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSPropertySignatureComputedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSPropertySignatureComputedConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_TSPropertySignatureOptionalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSPropertySignatureOptionalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSPropertySignatureOptionalConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_TSPropertySignatureReadonlyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSPropertySignatureReadonlyConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSPropertySignatureReadonlyConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_TSPropertySignatureTypeAnnotationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSPropertySignatureTypeAnnotationConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSPropertySignatureTypeAnnotationConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSPropertySignatureSetTsTypeAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer typeAnnotation) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + GetImpl()->TSPropertySignatureSetTsTypeAnnotation(_context, _receiver, _typeAnnotation); + return ; +} +KOALA_INTEROP_V3(TSPropertySignatureSetTsTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSConditionalType(KNativePointer context, KNativePointer checkType, KNativePointer extendsType, KNativePointer trueType, KNativePointer falseType) +{ + const auto _context = reinterpret_cast(context); + const auto _checkType = reinterpret_cast(checkType); + const auto _extendsType = reinterpret_cast(extendsType); + const auto _trueType = reinterpret_cast(trueType); + const auto _falseType = reinterpret_cast(falseType); + auto result = GetImpl()->CreateTSConditionalType(_context, _checkType, _extendsType, _trueType, _falseType); + return result; +} +KOALA_INTEROP_5(CreateTSConditionalType, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSConditionalType(KNativePointer context, KNativePointer original, KNativePointer checkType, KNativePointer extendsType, KNativePointer trueType, KNativePointer falseType) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _checkType = reinterpret_cast(checkType); + const auto _extendsType = reinterpret_cast(extendsType); + const auto _trueType = reinterpret_cast(trueType); + const auto _falseType = reinterpret_cast(falseType); + auto result = GetImpl()->UpdateTSConditionalType(_context, _original, _checkType, _extendsType, _trueType, _falseType); + return result; +} +KOALA_INTEROP_6(UpdateTSConditionalType, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSConditionalTypeCheckTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSConditionalTypeCheckTypeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSConditionalTypeCheckTypeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSConditionalTypeExtendsTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSConditionalTypeExtendsTypeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSConditionalTypeExtendsTypeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSConditionalTypeTrueTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSConditionalTypeTrueTypeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSConditionalTypeTrueTypeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSConditionalTypeFalseTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSConditionalTypeFalseTypeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSConditionalTypeFalseTypeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSLiteralType(KNativePointer context, KNativePointer literal) +{ + const auto _context = reinterpret_cast(context); + const auto _literal = reinterpret_cast(literal); + auto result = GetImpl()->CreateTSLiteralType(_context, _literal); + return result; +} +KOALA_INTEROP_2(CreateTSLiteralType, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSLiteralType(KNativePointer context, KNativePointer original, KNativePointer literal) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _literal = reinterpret_cast(literal); + auto result = GetImpl()->UpdateTSLiteralType(_context, _original, _literal); + return result; +} +KOALA_INTEROP_3(UpdateTSLiteralType, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSLiteralTypeLiteralConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSLiteralTypeLiteralConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSLiteralTypeLiteralConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSTypeAliasDeclaration(KNativePointer context, KNativePointer id, KNativePointer typeParams, KNativePointer typeAnnotation) +{ + const auto _context = reinterpret_cast(context); + const auto _id = reinterpret_cast(id); + const auto _typeParams = reinterpret_cast(typeParams); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + auto result = GetImpl()->CreateTSTypeAliasDeclaration(_context, _id, _typeParams, _typeAnnotation); + return result; +} +KOALA_INTEROP_4(CreateTSTypeAliasDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSTypeAliasDeclaration(KNativePointer context, KNativePointer original, KNativePointer id, KNativePointer typeParams, KNativePointer typeAnnotation) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _id = reinterpret_cast(id); + const auto _typeParams = reinterpret_cast(typeParams); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + auto result = GetImpl()->UpdateTSTypeAliasDeclaration(_context, _original, _id, _typeParams, _typeAnnotation); + return result; +} +KOALA_INTEROP_5(UpdateTSTypeAliasDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSTypeAliasDeclaration1(KNativePointer context, KNativePointer id) +{ + const auto _context = reinterpret_cast(context); + const auto _id = reinterpret_cast(id); + auto result = GetImpl()->CreateTSTypeAliasDeclaration1(_context, _id); + return result; +} +KOALA_INTEROP_2(CreateTSTypeAliasDeclaration1, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSTypeAliasDeclaration1(KNativePointer context, KNativePointer original, KNativePointer id) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _id = reinterpret_cast(id); + auto result = GetImpl()->UpdateTSTypeAliasDeclaration1(_context, _original, _id); + return result; +} +KOALA_INTEROP_3(UpdateTSTypeAliasDeclaration1, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeAliasDeclarationId(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeAliasDeclarationId(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSTypeAliasDeclarationId, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeAliasDeclarationIdConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeAliasDeclarationIdConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSTypeAliasDeclarationIdConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeAliasDeclarationTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeAliasDeclarationTypeParamsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSTypeAliasDeclarationTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSTypeAliasDeclarationSetTypeParameters(KNativePointer context, KNativePointer receiver, KNativePointer typeParams) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _typeParams = reinterpret_cast(typeParams); + GetImpl()->TSTypeAliasDeclarationSetTypeParameters(_context, _receiver, _typeParams); + return ; +} +KOALA_INTEROP_V3(TSTypeAliasDeclarationSetTypeParameters, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSTypeAliasDeclarationClearTypeParamterTypes(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->TSTypeAliasDeclarationClearTypeParamterTypes(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(TSTypeAliasDeclarationClearTypeParamterTypes, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeAliasDeclarationTypeAnnotationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeAliasDeclarationTypeAnnotationConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSTypeAliasDeclarationTypeAnnotationConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSTypeAliasDeclarationSetTsTypeAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer typeAnnotation) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + GetImpl()->TSTypeAliasDeclarationSetTsTypeAnnotation(_context, _receiver, _typeAnnotation); + return ; +} +KOALA_INTEROP_V3(TSTypeAliasDeclarationSetTsTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_TSTypeAliasDeclarationHasAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeAliasDeclarationHasAnnotationsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSTypeAliasDeclarationHasAnnotationsConst, KBoolean, KNativePointer, KNativePointer); + +void impl_TSTypeAliasDeclarationEmplaceAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer source) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + GetImpl()->TSTypeAliasDeclarationEmplaceAnnotation(_context, _receiver, _source); + return ; +} +KOALA_INTEROP_V3(TSTypeAliasDeclarationEmplaceAnnotation, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSTypeAliasDeclarationClearAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->TSTypeAliasDeclarationClearAnnotations(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(TSTypeAliasDeclarationClearAnnotations, KNativePointer, KNativePointer); + +void impl_TSTypeAliasDeclarationDumpAnnotationsConst(KNativePointer context, KNativePointer receiver, KNativePointer dumper) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _dumper = reinterpret_cast(dumper); + GetImpl()->TSTypeAliasDeclarationDumpAnnotationsConst(_context, _receiver, _dumper); + return ; +} +KOALA_INTEROP_V3(TSTypeAliasDeclarationDumpAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeAliasDeclarationAnnotationsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSTypeAliasDeclarationAnnotationsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSTypeAliasDeclarationAnnotationsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeAliasDeclarationAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSTypeAliasDeclarationAnnotations(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSTypeAliasDeclarationAnnotations, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeAliasDeclarationAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSTypeAliasDeclarationAnnotationsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSTypeAliasDeclarationAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSTypeAliasDeclarationSetAnnotations(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->TSTypeAliasDeclarationSetAnnotations(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(TSTypeAliasDeclarationSetAnnotations, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_TSTypeAliasDeclarationSetAnnotations1(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->TSTypeAliasDeclarationSetAnnotations1(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(TSTypeAliasDeclarationSetAnnotations1, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateDebuggerStatement(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateDebuggerStatement(_context); + return result; +} +KOALA_INTEROP_1(CreateDebuggerStatement, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateDebuggerStatement(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateDebuggerStatement(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateDebuggerStatement, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateReturnStatement(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateReturnStatement(_context); + return result; +} +KOALA_INTEROP_1(CreateReturnStatement, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateReturnStatement(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateReturnStatement(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateReturnStatement, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateReturnStatement1(KNativePointer context, KNativePointer argument) +{ + const auto _context = reinterpret_cast(context); + const auto _argument = reinterpret_cast(argument); + auto result = GetImpl()->CreateReturnStatement1(_context, _argument); + return result; +} +KOALA_INTEROP_2(CreateReturnStatement1, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateReturnStatement1(KNativePointer context, KNativePointer original, KNativePointer argument) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _argument = reinterpret_cast(argument); + auto result = GetImpl()->UpdateReturnStatement1(_context, _original, _argument); + return result; +} +KOALA_INTEROP_3(UpdateReturnStatement1, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ReturnStatementArgument(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ReturnStatementArgument(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ReturnStatementArgument, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ReturnStatementArgumentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ReturnStatementArgumentConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ReturnStatementArgumentConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ReturnStatementSetArgument(KNativePointer context, KNativePointer receiver, KNativePointer arg) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _arg = reinterpret_cast(arg); + GetImpl()->ReturnStatementSetArgument(_context, _receiver, _arg); + return ; +} +KOALA_INTEROP_V3(ReturnStatementSetArgument, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ReturnStatementIsAsyncImplReturnConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ReturnStatementIsAsyncImplReturnConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ReturnStatementIsAsyncImplReturnConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateExportDefaultDeclaration(KNativePointer context, KNativePointer decl, KBoolean exportEquals) +{ + const auto _context = reinterpret_cast(context); + const auto _decl = reinterpret_cast(decl); + const auto _exportEquals = static_cast(exportEquals); + auto result = GetImpl()->CreateExportDefaultDeclaration(_context, _decl, _exportEquals); + return result; +} +KOALA_INTEROP_3(CreateExportDefaultDeclaration, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_UpdateExportDefaultDeclaration(KNativePointer context, KNativePointer original, KNativePointer decl, KBoolean exportEquals) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _decl = reinterpret_cast(decl); + const auto _exportEquals = static_cast(exportEquals); + auto result = GetImpl()->UpdateExportDefaultDeclaration(_context, _original, _decl, _exportEquals); + return result; +} +KOALA_INTEROP_4(UpdateExportDefaultDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_ExportDefaultDeclarationDecl(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExportDefaultDeclarationDecl(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ExportDefaultDeclarationDecl, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ExportDefaultDeclarationDeclConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExportDefaultDeclarationDeclConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ExportDefaultDeclarationDeclConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ExportDefaultDeclarationIsExportEqualsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExportDefaultDeclarationIsExportEqualsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ExportDefaultDeclarationIsExportEqualsConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateScriptFunction(KNativePointer context, KNativePointer databody, KNativePointer datasignature, KInt datafuncFlags, KInt dataflags) +{ + const auto _context = reinterpret_cast(context); + const auto _databody = reinterpret_cast(databody); + const auto _datasignature = reinterpret_cast(datasignature); + const auto _datafuncFlags = static_cast(datafuncFlags); + const auto _dataflags = static_cast(dataflags); + auto result = GetImpl()->CreateScriptFunction(_context, _databody, _datasignature, _datafuncFlags, _dataflags); + return result; +} +KOALA_INTEROP_5(CreateScriptFunction, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KInt); + +KNativePointer impl_UpdateScriptFunction(KNativePointer context, KNativePointer original, KNativePointer databody, KNativePointer datasignature, KInt datafuncFlags, KInt dataflags) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _databody = reinterpret_cast(databody); + const auto _datasignature = reinterpret_cast(datasignature); + const auto _datafuncFlags = static_cast(datafuncFlags); + const auto _dataflags = static_cast(dataflags); + auto result = GetImpl()->UpdateScriptFunction(_context, _original, _databody, _datasignature, _datafuncFlags, _dataflags); + return result; +} +KOALA_INTEROP_6(UpdateScriptFunction, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KInt); + +KNativePointer impl_ScriptFunctionIdConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIdConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ScriptFunctionIdConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ScriptFunctionId(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionId(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionId, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ScriptFunctionParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ScriptFunctionParamsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ScriptFunctionParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ScriptFunctionParams(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ScriptFunctionParams(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ScriptFunctionParams, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ScriptFunctionReturnStatementsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ScriptFunctionReturnStatementsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ScriptFunctionReturnStatementsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ScriptFunctionReturnStatements(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ScriptFunctionReturnStatements(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ScriptFunctionReturnStatements, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ScriptFunctionReturnStatementsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ScriptFunctionReturnStatementsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ScriptFunctionReturnStatementsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ScriptFunctionTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionTypeParamsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ScriptFunctionTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ScriptFunctionTypeParams(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionTypeParams(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionTypeParams, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ScriptFunctionBodyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionBodyConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ScriptFunctionBodyConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ScriptFunctionBody(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionBody(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionBody, KNativePointer, KNativePointer, KNativePointer); + +void impl_ScriptFunctionAddReturnStatement(KNativePointer context, KNativePointer receiver, KNativePointer returnStatement) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _returnStatement = reinterpret_cast(returnStatement); + GetImpl()->ScriptFunctionAddReturnStatement(_context, _receiver, _returnStatement); + return ; +} +KOALA_INTEROP_V3(ScriptFunctionAddReturnStatement, KNativePointer, KNativePointer, KNativePointer); + +void impl_ScriptFunctionSetBody(KNativePointer context, KNativePointer receiver, KNativePointer body) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _body = reinterpret_cast(body); + GetImpl()->ScriptFunctionSetBody(_context, _receiver, _body); + return ; +} +KOALA_INTEROP_V3(ScriptFunctionSetBody, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ScriptFunctionReturnTypeAnnotationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionReturnTypeAnnotationConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ScriptFunctionReturnTypeAnnotationConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ScriptFunctionReturnTypeAnnotation(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionReturnTypeAnnotation(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionReturnTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +void impl_ScriptFunctionSetReturnTypeAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer node) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _node = reinterpret_cast(node); + GetImpl()->ScriptFunctionSetReturnTypeAnnotation(_context, _receiver, _node); + return ; +} +KOALA_INTEROP_V3(ScriptFunctionSetReturnTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsEntryPointConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsEntryPointConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsEntryPointConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsGeneratorConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsGeneratorConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsGeneratorConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsAsyncFuncConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsAsyncFuncConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsAsyncFuncConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsAsyncImplFuncConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsAsyncImplFuncConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsAsyncImplFuncConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsArrowConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsArrowConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsArrowConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsOverloadConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsOverloadConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsOverloadConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsExternalOverloadConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsExternalOverloadConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsExternalOverloadConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsConstructorConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsConstructorConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsConstructorConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsGetterConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsGetterConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsGetterConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsSetterConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsSetterConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsSetterConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsExtensionAccessorConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsExtensionAccessorConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsExtensionAccessorConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsMethodConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsMethodConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsMethodConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsProxyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsProxyConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsProxyConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsStaticBlockConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsStaticBlockConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsStaticBlockConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsEnumConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsEnumConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsEnumConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsHiddenConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsHiddenConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsHiddenConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsExternalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsExternalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsExternalConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsImplicitSuperCallNeededConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsImplicitSuperCallNeededConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsImplicitSuperCallNeededConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionHasBodyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionHasBodyConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionHasBodyConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionHasRestParameterConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionHasRestParameterConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionHasRestParameterConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionHasReturnStatementConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionHasReturnStatementConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionHasReturnStatementConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionHasThrowStatementConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionHasThrowStatementConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionHasThrowStatementConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsTrailingLambdaConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsTrailingLambdaConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsTrailingLambdaConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsSyntheticConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsSyntheticConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsSyntheticConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsDynamicConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsDynamicConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsDynamicConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionIsExtensionMethodConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionIsExtensionMethodConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionIsExtensionMethodConst, KBoolean, KNativePointer, KNativePointer); + +KInt impl_ScriptFunctionFlagsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionFlagsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionFlagsConst, KInt, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionHasReceiverConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionHasReceiverConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionHasReceiverConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ScriptFunctionSetIdent(KNativePointer context, KNativePointer receiver, KNativePointer id) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _id = reinterpret_cast(id); + GetImpl()->ScriptFunctionSetIdent(_context, _receiver, _id); + return ; +} +KOALA_INTEROP_V3(ScriptFunctionSetIdent, KNativePointer, KNativePointer, KNativePointer); + +void impl_ScriptFunctionAddFlag(KNativePointer context, KNativePointer receiver, KInt flags) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _flags = static_cast(flags); + GetImpl()->ScriptFunctionAddFlag(_context, _receiver, _flags); + return ; +} +KOALA_INTEROP_V3(ScriptFunctionAddFlag, KNativePointer, KNativePointer, KInt); + +void impl_ScriptFunctionClearFlag(KNativePointer context, KNativePointer receiver, KInt flags) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _flags = static_cast(flags); + GetImpl()->ScriptFunctionClearFlag(_context, _receiver, _flags); + return ; +} +KOALA_INTEROP_V3(ScriptFunctionClearFlag, KNativePointer, KNativePointer, KInt); + +KUInt impl_ScriptFunctionFormalParamsLengthConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionFormalParamsLengthConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionFormalParamsLengthConst, KUInt, KNativePointer, KNativePointer); + +void impl_ScriptFunctionSetAsyncPairMethod(KNativePointer context, KNativePointer receiver, KNativePointer asyncPairFunction) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _asyncPairFunction = reinterpret_cast(asyncPairFunction); + GetImpl()->ScriptFunctionSetAsyncPairMethod(_context, _receiver, _asyncPairFunction); + return ; +} +KOALA_INTEROP_V3(ScriptFunctionSetAsyncPairMethod, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ScriptFunctionAsyncPairMethodConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionAsyncPairMethodConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ScriptFunctionAsyncPairMethodConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ScriptFunctionAsyncPairMethod(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionAsyncPairMethod(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionAsyncPairMethod, KNativePointer, KNativePointer, KNativePointer); + +void impl_ScriptFunctionEmplaceReturnStatements(KNativePointer context, KNativePointer receiver, KNativePointer returnStatements) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _returnStatements = reinterpret_cast(returnStatements); + GetImpl()->ScriptFunctionEmplaceReturnStatements(_context, _receiver, _returnStatements); + return ; +} +KOALA_INTEROP_V3(ScriptFunctionEmplaceReturnStatements, KNativePointer, KNativePointer, KNativePointer); + +void impl_ScriptFunctionClearReturnStatements(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ScriptFunctionClearReturnStatements(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ScriptFunctionClearReturnStatements, KNativePointer, KNativePointer); + +void impl_ScriptFunctionSetValueReturnStatements(KNativePointer context, KNativePointer receiver, KNativePointer returnStatements, KUInt index) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _returnStatements = reinterpret_cast(returnStatements); + const auto _index = static_cast(index); + GetImpl()->ScriptFunctionSetValueReturnStatements(_context, _receiver, _returnStatements, _index); + return ; +} +KOALA_INTEROP_V4(ScriptFunctionSetValueReturnStatements, KNativePointer, KNativePointer, KNativePointer, KUInt); + +void impl_ScriptFunctionEmplaceParams(KNativePointer context, KNativePointer receiver, KNativePointer params) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _params = reinterpret_cast(params); + GetImpl()->ScriptFunctionEmplaceParams(_context, _receiver, _params); + return ; +} +KOALA_INTEROP_V3(ScriptFunctionEmplaceParams, KNativePointer, KNativePointer, KNativePointer); + +void impl_ScriptFunctionSetParams(KNativePointer context, KNativePointer receiver, KNativePointerArray paramsList, KUInt paramsListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _paramsList = reinterpret_cast(paramsList); + const auto _paramsListSequenceLength = static_cast(paramsListSequenceLength); + GetImpl()->ScriptFunctionSetParams(_context, _receiver, _paramsList, _paramsListSequenceLength); + return ; +} +KOALA_INTEROP_V4(ScriptFunctionSetParams, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_ScriptFunctionClearParams(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ScriptFunctionClearParams(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ScriptFunctionClearParams, KNativePointer, KNativePointer); + +void impl_ScriptFunctionSetValueParams(KNativePointer context, KNativePointer receiver, KNativePointer params, KUInt index) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _params = reinterpret_cast(params); + const auto _index = static_cast(index); + GetImpl()->ScriptFunctionSetValueParams(_context, _receiver, _params, _index); + return ; +} +KOALA_INTEROP_V4(ScriptFunctionSetValueParams, KNativePointer, KNativePointer, KNativePointer, KUInt); + +KNativePointer impl_ScriptFunctionParamsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ScriptFunctionParamsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ScriptFunctionParamsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ScriptFunctionHasAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ScriptFunctionHasAnnotationsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ScriptFunctionHasAnnotationsConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ScriptFunctionEmplaceAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer source) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + GetImpl()->ScriptFunctionEmplaceAnnotation(_context, _receiver, _source); + return ; +} +KOALA_INTEROP_V3(ScriptFunctionEmplaceAnnotation, KNativePointer, KNativePointer, KNativePointer); + +void impl_ScriptFunctionClearAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ScriptFunctionClearAnnotations(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ScriptFunctionClearAnnotations, KNativePointer, KNativePointer); + +void impl_ScriptFunctionDumpAnnotationsConst(KNativePointer context, KNativePointer receiver, KNativePointer dumper) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _dumper = reinterpret_cast(dumper); + GetImpl()->ScriptFunctionDumpAnnotationsConst(_context, _receiver, _dumper); + return ; +} +KOALA_INTEROP_V3(ScriptFunctionDumpAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ScriptFunctionAnnotationsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ScriptFunctionAnnotationsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ScriptFunctionAnnotationsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ScriptFunctionAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ScriptFunctionAnnotations(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ScriptFunctionAnnotations, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ScriptFunctionAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ScriptFunctionAnnotationsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ScriptFunctionAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ScriptFunctionSetAnnotations(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->ScriptFunctionSetAnnotations(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(ScriptFunctionSetAnnotations, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_ScriptFunctionSetAnnotations1(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->ScriptFunctionSetAnnotations1(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(ScriptFunctionSetAnnotations1, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateClassDefinition(KNativePointer context, KNativePointer ident, KNativePointer typeParams, KNativePointer superTypeParams, KNativePointerArray _implements, KUInt _implementsSequenceLength, KNativePointer ctor, KNativePointer superClass, KNativePointerArray body, KUInt bodySequenceLength, KInt modifiers, KInt flags) +{ + const auto _context = reinterpret_cast(context); + const auto _ident = reinterpret_cast(ident); + const auto _typeParams = reinterpret_cast(typeParams); + const auto _superTypeParams = reinterpret_cast(superTypeParams); + const auto __implements = reinterpret_cast(_implements); + const auto __implementsSequenceLength = static_cast(_implementsSequenceLength); + const auto _ctor = reinterpret_cast(ctor); + const auto _superClass = reinterpret_cast(superClass); + const auto _body = reinterpret_cast(body); + const auto _bodySequenceLength = static_cast(bodySequenceLength); + const auto _modifiers = static_cast(modifiers); + const auto _flags = static_cast(flags); + auto result = GetImpl()->CreateClassDefinition(_context, _ident, _typeParams, _superTypeParams, __implements, __implementsSequenceLength, _ctor, _superClass, _body, _bodySequenceLength, _modifiers, _flags); + return result; +} +KOALA_INTEROP_12(CreateClassDefinition, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KInt, KInt); + +KNativePointer impl_UpdateClassDefinition(KNativePointer context, KNativePointer original, KNativePointer ident, KNativePointer typeParams, KNativePointer superTypeParams, KNativePointerArray _implements, KUInt _implementsSequenceLength, KNativePointer ctor, KNativePointer superClass, KNativePointerArray body, KUInt bodySequenceLength, KInt modifiers, KInt flags) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _ident = reinterpret_cast(ident); + const auto _typeParams = reinterpret_cast(typeParams); + const auto _superTypeParams = reinterpret_cast(superTypeParams); + const auto __implements = reinterpret_cast(_implements); + const auto __implementsSequenceLength = static_cast(_implementsSequenceLength); + const auto _ctor = reinterpret_cast(ctor); + const auto _superClass = reinterpret_cast(superClass); + const auto _body = reinterpret_cast(body); + const auto _bodySequenceLength = static_cast(bodySequenceLength); + const auto _modifiers = static_cast(modifiers); + const auto _flags = static_cast(flags); + auto result = GetImpl()->UpdateClassDefinition(_context, _original, _ident, _typeParams, _superTypeParams, __implements, __implementsSequenceLength, _ctor, _superClass, _body, _bodySequenceLength, _modifiers, _flags); + return result; +} +KOALA_INTEROP_13(UpdateClassDefinition, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KInt, KInt); + +KNativePointer impl_CreateClassDefinition1(KNativePointer context, KNativePointer ident, KNativePointerArray body, KUInt bodySequenceLength, KInt modifiers, KInt flags) +{ + const auto _context = reinterpret_cast(context); + const auto _ident = reinterpret_cast(ident); + const auto _body = reinterpret_cast(body); + const auto _bodySequenceLength = static_cast(bodySequenceLength); + const auto _modifiers = static_cast(modifiers); + const auto _flags = static_cast(flags); + auto result = GetImpl()->CreateClassDefinition1(_context, _ident, _body, _bodySequenceLength, _modifiers, _flags); + return result; +} +KOALA_INTEROP_6(CreateClassDefinition1, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KInt, KInt); + +KNativePointer impl_UpdateClassDefinition1(KNativePointer context, KNativePointer original, KNativePointer ident, KNativePointerArray body, KUInt bodySequenceLength, KInt modifiers, KInt flags) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _ident = reinterpret_cast(ident); + const auto _body = reinterpret_cast(body); + const auto _bodySequenceLength = static_cast(bodySequenceLength); + const auto _modifiers = static_cast(modifiers); + const auto _flags = static_cast(flags); + auto result = GetImpl()->UpdateClassDefinition1(_context, _original, _ident, _body, _bodySequenceLength, _modifiers, _flags); + return result; +} +KOALA_INTEROP_7(UpdateClassDefinition1, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KInt, KInt); + +KNativePointer impl_CreateClassDefinition2(KNativePointer context, KNativePointer ident, KInt modifiers, KInt flags) +{ + const auto _context = reinterpret_cast(context); + const auto _ident = reinterpret_cast(ident); + const auto _modifiers = static_cast(modifiers); + const auto _flags = static_cast(flags); + auto result = GetImpl()->CreateClassDefinition2(_context, _ident, _modifiers, _flags); + return result; +} +KOALA_INTEROP_4(CreateClassDefinition2, KNativePointer, KNativePointer, KNativePointer, KInt, KInt); + +KNativePointer impl_UpdateClassDefinition2(KNativePointer context, KNativePointer original, KNativePointer ident, KInt modifiers, KInt flags) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _ident = reinterpret_cast(ident); + const auto _modifiers = static_cast(modifiers); + const auto _flags = static_cast(flags); + auto result = GetImpl()->UpdateClassDefinition2(_context, _original, _ident, _modifiers, _flags); + return result; +} +KOALA_INTEROP_5(UpdateClassDefinition2, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KInt); + +KNativePointer impl_ClassDefinitionIdentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIdentConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ClassDefinitionIdentConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionIdent(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIdent(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionIdent, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetIdent(KNativePointer context, KNativePointer receiver, KNativePointer ident) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _ident = reinterpret_cast(ident); + GetImpl()->ClassDefinitionSetIdent(_context, _receiver, _ident); + return ; +} +KOALA_INTEROP_V3(ClassDefinitionSetIdent, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionInternalNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionInternalNameConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ClassDefinitionInternalNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionSuper(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionSuper(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionSuper, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionSuperConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionSuperConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ClassDefinitionSuperConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetSuper(KNativePointer context, KNativePointer receiver, KNativePointer superClass) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _superClass = reinterpret_cast(superClass); + GetImpl()->ClassDefinitionSetSuper(_context, _receiver, _superClass); + return ; +} +KOALA_INTEROP_V3(ClassDefinitionSetSuper, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionIsGlobalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIsGlobalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionIsGlobalConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionIsLocalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIsLocalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionIsLocalConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionIsExternConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIsExternConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionIsExternConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionIsFromExternalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIsFromExternalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionIsFromExternalConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionIsInnerConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIsInnerConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionIsInnerConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionIsGlobalInitializedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIsGlobalInitializedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionIsGlobalInitializedConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionIsClassDefinitionCheckedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIsClassDefinitionCheckedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionIsClassDefinitionCheckedConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionIsAnonymousConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIsAnonymousConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionIsAnonymousConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionIsIntEnumTransformedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIsIntEnumTransformedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionIsIntEnumTransformedConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionIsStringEnumTransformedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIsStringEnumTransformedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionIsStringEnumTransformedConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionIsEnumTransformedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIsEnumTransformedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionIsEnumTransformedConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionIsNamespaceTransformedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIsNamespaceTransformedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionIsNamespaceTransformedConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionIsLazyImportObjectClassConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIsLazyImportObjectClassConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionIsLazyImportObjectClassConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionIsFromStructConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIsFromStructConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionIsFromStructConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionIsInitInCctorConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIsInitInCctorConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionIsInitInCctorConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionIsModuleConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionIsModuleConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionIsModuleConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetGlobalInitialized(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ClassDefinitionSetGlobalInitialized(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ClassDefinitionSetGlobalInitialized, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetInnerModifier(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ClassDefinitionSetInnerModifier(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ClassDefinitionSetInnerModifier, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetClassDefinitionChecked(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ClassDefinitionSetClassDefinitionChecked(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ClassDefinitionSetClassDefinitionChecked, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetAnonymousModifier(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ClassDefinitionSetAnonymousModifier(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ClassDefinitionSetAnonymousModifier, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetNamespaceTransformed(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ClassDefinitionSetNamespaceTransformed(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ClassDefinitionSetNamespaceTransformed, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetLazyImportObjectClass(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ClassDefinitionSetLazyImportObjectClass(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ClassDefinitionSetLazyImportObjectClass, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetFromStructModifier(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ClassDefinitionSetFromStructModifier(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ClassDefinitionSetFromStructModifier, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetInitInCctor(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ClassDefinitionSetInitInCctor(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ClassDefinitionSetInitInCctor, KNativePointer, KNativePointer); + +KInt impl_ClassDefinitionModifiersConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionModifiersConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionModifiersConst, KInt, KNativePointer, KNativePointer); + +void impl_ClassDefinitionAddProperties(KNativePointer context, KNativePointer receiver, KNativePointerArray body, KUInt bodySequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _body = reinterpret_cast(body); + const auto _bodySequenceLength = static_cast(bodySequenceLength); + GetImpl()->ClassDefinitionAddProperties(_context, _receiver, _body, _bodySequenceLength); + return ; +} +KOALA_INTEROP_V4(ClassDefinitionAddProperties, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_ClassDefinitionBodyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ClassDefinitionBodyConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ClassDefinitionBodyConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionCtor(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionCtor(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionCtor, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionImplementsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ClassDefinitionImplementsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ClassDefinitionImplementsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionTypeParamsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ClassDefinitionTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionTypeParams(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionTypeParams(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionTypeParams, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionSuperTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionSuperTypeParamsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ClassDefinitionSuperTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionSuperTypeParams(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionSuperTypeParams(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionSuperTypeParams, KNativePointer, KNativePointer, KNativePointer); + +KInt impl_ClassDefinitionLocalTypeCounter(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionLocalTypeCounter(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionLocalTypeCounter, KInt, KNativePointer, KNativePointer); + +KInt impl_ClassDefinitionLocalIndexConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionLocalIndexConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionLocalIndexConst, KInt, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionFunctionalReferenceReferencedMethodConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionFunctionalReferenceReferencedMethodConst(_context, _receiver); + return (void*)result; +} +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); + +KNativePointer impl_ClassDefinitionLocalPrefixConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionLocalPrefixConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ClassDefinitionLocalPrefixConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionOrigEnumDeclConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionOrigEnumDeclConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ClassDefinitionOrigEnumDeclConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionGetAnonClass(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionGetAnonClass(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionGetAnonClass, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionCtorConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionCtorConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ClassDefinitionCtorConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionHasPrivateMethodConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionHasPrivateMethodConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionHasPrivateMethodConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionHasNativeMethodConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionHasNativeMethodConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionHasNativeMethodConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionHasComputedInstanceFieldConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionHasComputedInstanceFieldConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionHasComputedInstanceFieldConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ClassDefinitionHasMatchingPrivateKeyConst(KNativePointer context, KNativePointer receiver, KStringPtr& name) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _name = getStringCopy(name); + auto result = GetImpl()->ClassDefinitionHasMatchingPrivateKeyConst(_context, _receiver, _name); + return result; +} +KOALA_INTEROP_3(ClassDefinitionHasMatchingPrivateKeyConst, KBoolean, KNativePointer, KNativePointer, KStringPtr); + +void impl_ClassDefinitionAddToExportedClasses(KNativePointer context, KNativePointer receiver, KNativePointer cls) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _cls = reinterpret_cast(cls); + GetImpl()->ClassDefinitionAddToExportedClasses(_context, _receiver, _cls); + return ; +} +KOALA_INTEROP_V3(ClassDefinitionAddToExportedClasses, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetModifiers(KNativePointer context, KNativePointer receiver, KInt modifiers) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _modifiers = static_cast(modifiers); + GetImpl()->ClassDefinitionSetModifiers(_context, _receiver, _modifiers); + return ; +} +KOALA_INTEROP_V3(ClassDefinitionSetModifiers, KNativePointer, KNativePointer, KInt); + +void impl_ClassDefinitionEmplaceBody(KNativePointer context, KNativePointer receiver, KNativePointer body) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _body = reinterpret_cast(body); + GetImpl()->ClassDefinitionEmplaceBody(_context, _receiver, _body); + return ; +} +KOALA_INTEROP_V3(ClassDefinitionEmplaceBody, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassDefinitionClearBody(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ClassDefinitionClearBody(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ClassDefinitionClearBody, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetValueBody(KNativePointer context, KNativePointer receiver, KNativePointer body, KUInt index) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _body = reinterpret_cast(body); + const auto _index = static_cast(index); + GetImpl()->ClassDefinitionSetValueBody(_context, _receiver, _body, _index); + return ; +} +KOALA_INTEROP_V4(ClassDefinitionSetValueBody, KNativePointer, KNativePointer, KNativePointer, KUInt); + +KNativePointer impl_ClassDefinitionBody(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ClassDefinitionBody(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ClassDefinitionBody, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionBodyForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ClassDefinitionBodyForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ClassDefinitionBodyForUpdate, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassDefinitionEmplaceImplements(KNativePointer context, KNativePointer receiver, KNativePointer _implements) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto __implements = reinterpret_cast(_implements); + GetImpl()->ClassDefinitionEmplaceImplements(_context, _receiver, __implements); + return ; +} +KOALA_INTEROP_V3(ClassDefinitionEmplaceImplements, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassDefinitionClearImplements(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ClassDefinitionClearImplements(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ClassDefinitionClearImplements, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetValueImplements(KNativePointer context, KNativePointer receiver, KNativePointer _implements, KUInt index) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto __implements = reinterpret_cast(_implements); + const auto _index = static_cast(index); + GetImpl()->ClassDefinitionSetValueImplements(_context, _receiver, __implements, _index); + return ; +} +KOALA_INTEROP_V4(ClassDefinitionSetValueImplements, KNativePointer, KNativePointer, KNativePointer, KUInt); + +KNativePointer impl_ClassDefinitionImplements(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ClassDefinitionImplements(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ClassDefinitionImplements, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionImplementsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ClassDefinitionImplementsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ClassDefinitionImplementsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetCtor(KNativePointer context, KNativePointer receiver, KNativePointer ctor) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _ctor = reinterpret_cast(ctor); + GetImpl()->ClassDefinitionSetCtor(_context, _receiver, _ctor); + return ; +} +KOALA_INTEROP_V3(ClassDefinitionSetCtor, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetTypeParams(KNativePointer context, KNativePointer receiver, KNativePointer typeParams) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _typeParams = reinterpret_cast(typeParams); + GetImpl()->ClassDefinitionSetTypeParams(_context, _receiver, _typeParams); + return ; +} +KOALA_INTEROP_V3(ClassDefinitionSetTypeParams, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetOrigEnumDecl(KNativePointer context, KNativePointer receiver, KNativePointer origEnumDecl) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _origEnumDecl = reinterpret_cast(origEnumDecl); + GetImpl()->ClassDefinitionSetOrigEnumDecl(_context, _receiver, _origEnumDecl); + return ; +} +KOALA_INTEROP_V3(ClassDefinitionSetOrigEnumDecl, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetAnonClass(KNativePointer context, KNativePointer receiver, KNativePointer anonClass) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _anonClass = reinterpret_cast(anonClass); + GetImpl()->ClassDefinitionSetAnonClass(_context, _receiver, _anonClass); + return ; +} +KOALA_INTEROP_V3(ClassDefinitionSetAnonClass, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetInternalName(KNativePointer context, KNativePointer receiver, KStringPtr& internalName) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _internalName = getStringCopy(internalName); + GetImpl()->ClassDefinitionSetInternalName(_context, _receiver, _internalName); + return ; +} +KOALA_INTEROP_V3(ClassDefinitionSetInternalName, KNativePointer, KNativePointer, KStringPtr); + +KBoolean impl_ClassDefinitionHasAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDefinitionHasAnnotationsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDefinitionHasAnnotationsConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ClassDefinitionEmplaceAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer source) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + GetImpl()->ClassDefinitionEmplaceAnnotation(_context, _receiver, _source); + return ; +} +KOALA_INTEROP_V3(ClassDefinitionEmplaceAnnotation, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassDefinitionClearAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ClassDefinitionClearAnnotations(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ClassDefinitionClearAnnotations, KNativePointer, KNativePointer); + +void impl_ClassDefinitionDumpAnnotationsConst(KNativePointer context, KNativePointer receiver, KNativePointer dumper) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _dumper = reinterpret_cast(dumper); + GetImpl()->ClassDefinitionDumpAnnotationsConst(_context, _receiver, _dumper); + return ; +} +KOALA_INTEROP_V3(ClassDefinitionDumpAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionAnnotationsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ClassDefinitionAnnotationsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ClassDefinitionAnnotationsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ClassDefinitionAnnotations(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ClassDefinitionAnnotations, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDefinitionAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ClassDefinitionAnnotationsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ClassDefinitionAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassDefinitionSetAnnotations(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->ClassDefinitionSetAnnotations(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(ClassDefinitionSetAnnotations, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_ClassDefinitionSetAnnotations1(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->ClassDefinitionSetAnnotations1(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(ClassDefinitionSetAnnotations1, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateArrayExpression(KNativePointer context, KNativePointerArray elements, KUInt elementsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _elements = reinterpret_cast(elements); + const auto _elementsSequenceLength = static_cast(elementsSequenceLength); + auto result = GetImpl()->CreateArrayExpression(_context, _elements, _elementsSequenceLength); + return result; +} +KOALA_INTEROP_3(CreateArrayExpression, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateArrayExpression(KNativePointer context, KNativePointer original, KNativePointerArray elements, KUInt elementsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _elements = reinterpret_cast(elements); + const auto _elementsSequenceLength = static_cast(elementsSequenceLength); + auto result = GetImpl()->UpdateArrayExpression(_context, _original, _elements, _elementsSequenceLength); + return result; +} +KOALA_INTEROP_4(UpdateArrayExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateArrayExpression1(KNativePointer context, KInt nodeType, KNativePointerArray elements, KUInt elementsSequenceLength, KBoolean trailingComma) +{ + const auto _context = reinterpret_cast(context); + const auto _nodeType = static_cast(nodeType); + const auto _elements = reinterpret_cast(elements); + const auto _elementsSequenceLength = static_cast(elementsSequenceLength); + const auto _trailingComma = static_cast(trailingComma); + auto result = GetImpl()->CreateArrayExpression1(_context, _nodeType, _elements, _elementsSequenceLength, _trailingComma); + return result; +} +KOALA_INTEROP_5(CreateArrayExpression1, KNativePointer, KNativePointer, KInt, KNativePointerArray, KUInt, KBoolean); + +KNativePointer impl_UpdateArrayExpression1(KNativePointer context, KNativePointer original, KInt nodeType, KNativePointerArray elements, KUInt elementsSequenceLength, KBoolean trailingComma) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _nodeType = static_cast(nodeType); + const auto _elements = reinterpret_cast(elements); + const auto _elementsSequenceLength = static_cast(elementsSequenceLength); + const auto _trailingComma = static_cast(trailingComma); + auto result = GetImpl()->UpdateArrayExpression1(_context, _original, _nodeType, _elements, _elementsSequenceLength, _trailingComma); + return result; +} +KOALA_INTEROP_6(UpdateArrayExpression1, KNativePointer, KNativePointer, KNativePointer, KInt, KNativePointerArray, KUInt, KBoolean); + +KNativePointer impl_ArrayExpressionGetElementNodeAtIdxConst(KNativePointer context, KNativePointer receiver, KUInt idx) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _idx = static_cast(idx); + auto result = GetImpl()->ArrayExpressionGetElementNodeAtIdxConst(_context, _receiver, _idx); + return (void*)result; +} +KOALA_INTEROP_3(ArrayExpressionGetElementNodeAtIdxConst, KNativePointer, KNativePointer, KNativePointer, KUInt); + +KNativePointer impl_ArrayExpressionElementsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ArrayExpressionElementsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ArrayExpressionElementsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ArrayExpressionElements(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ArrayExpressionElements(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ArrayExpressionElements, KNativePointer, KNativePointer, KNativePointer); + +void impl_ArrayExpressionSetElements(KNativePointer context, KNativePointer receiver, KNativePointerArray elements, KUInt elementsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _elements = reinterpret_cast(elements); + const auto _elementsSequenceLength = static_cast(elementsSequenceLength); + GetImpl()->ArrayExpressionSetElements(_context, _receiver, _elements, _elementsSequenceLength); + return ; +} +KOALA_INTEROP_V4(ArrayExpressionSetElements, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KBoolean impl_ArrayExpressionIsDeclarationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ArrayExpressionIsDeclarationConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ArrayExpressionIsDeclarationConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ArrayExpressionIsOptionalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ArrayExpressionIsOptionalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ArrayExpressionIsOptionalConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ArrayExpressionSetDeclaration(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ArrayExpressionSetDeclaration(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ArrayExpressionSetDeclaration, KNativePointer, KNativePointer); + +void impl_ArrayExpressionSetOptional(KNativePointer context, KNativePointer receiver, KBoolean optional_arg) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _optional_arg = static_cast(optional_arg); + GetImpl()->ArrayExpressionSetOptional(_context, _receiver, _optional_arg); + return ; +} +KOALA_INTEROP_V3(ArrayExpressionSetOptional, KNativePointer, KNativePointer, KBoolean); + +void impl_ArrayExpressionClearPreferredType(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ArrayExpressionClearPreferredType(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ArrayExpressionClearPreferredType, KNativePointer, KNativePointer); + +KBoolean impl_ArrayExpressionConvertibleToArrayPattern(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ArrayExpressionConvertibleToArrayPattern(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ArrayExpressionConvertibleToArrayPattern, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_ArrayExpressionValidateExpression(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ArrayExpressionValidateExpression(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ArrayExpressionValidateExpression, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ArrayExpressionTrySetPreferredTypeForNestedArrayExprConst(KNativePointer context, KNativePointer receiver, KNativePointer nestedArrayExpr, KUInt idx) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _nestedArrayExpr = reinterpret_cast(nestedArrayExpr); + const auto _idx = static_cast(idx); + auto result = GetImpl()->ArrayExpressionTrySetPreferredTypeForNestedArrayExprConst(_context, _receiver, _nestedArrayExpr, _idx); + return result; +} +KOALA_INTEROP_4(ArrayExpressionTrySetPreferredTypeForNestedArrayExprConst, KBoolean, KNativePointer, KNativePointer, KNativePointer, KUInt); + +KNativePointer impl_ArrayExpressionTypeAnnotationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ArrayExpressionTypeAnnotationConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ArrayExpressionTypeAnnotationConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ArrayExpressionSetTsTypeAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer typeAnnotation) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + GetImpl()->ArrayExpressionSetTsTypeAnnotation(_context, _receiver, _typeAnnotation); + return ; +} +KOALA_INTEROP_V3(ArrayExpressionSetTsTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSInterfaceBody(KNativePointer context, KNativePointerArray body, KUInt bodySequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _body = reinterpret_cast(body); + const auto _bodySequenceLength = static_cast(bodySequenceLength); + auto result = GetImpl()->CreateTSInterfaceBody(_context, _body, _bodySequenceLength); + return result; +} +KOALA_INTEROP_3(CreateTSInterfaceBody, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateTSInterfaceBody(KNativePointer context, KNativePointer original, KNativePointerArray body, KUInt bodySequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _body = reinterpret_cast(body); + const auto _bodySequenceLength = static_cast(bodySequenceLength); + auto result = GetImpl()->UpdateTSInterfaceBody(_context, _original, _body, _bodySequenceLength); + return result; +} +KOALA_INTEROP_4(UpdateTSInterfaceBody, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_TSInterfaceBodyBody(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSInterfaceBodyBody(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSInterfaceBodyBody, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSInterfaceBodyBodyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSInterfaceBodyBodyConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSInterfaceBodyBodyConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSTypeQuery(KNativePointer context, KNativePointer exprName) +{ + const auto _context = reinterpret_cast(context); + const auto _exprName = reinterpret_cast(exprName); + auto result = GetImpl()->CreateTSTypeQuery(_context, _exprName); + return result; +} +KOALA_INTEROP_2(CreateTSTypeQuery, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSTypeQuery(KNativePointer context, KNativePointer original, KNativePointer exprName) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _exprName = reinterpret_cast(exprName); + auto result = GetImpl()->UpdateTSTypeQuery(_context, _original, _exprName); + return result; +} +KOALA_INTEROP_3(UpdateTSTypeQuery, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeQueryExprNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeQueryExprNameConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSTypeQueryExprNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSBigintKeyword(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateTSBigintKeyword(_context); + return result; +} +KOALA_INTEROP_1(CreateTSBigintKeyword, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSBigintKeyword(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateTSBigintKeyword(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateTSBigintKeyword, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateProperty(KNativePointer context, KNativePointer key, KNativePointer value) +{ + const auto _context = reinterpret_cast(context); + const auto _key = reinterpret_cast(key); + const auto _value = reinterpret_cast(value); + auto result = GetImpl()->CreateProperty(_context, _key, _value); + return result; +} +KOALA_INTEROP_3(CreateProperty, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateProperty(KNativePointer context, KNativePointer original, KNativePointer key, KNativePointer value) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _key = reinterpret_cast(key); + const auto _value = reinterpret_cast(value); + auto result = GetImpl()->UpdateProperty(_context, _original, _key, _value); + return result; +} +KOALA_INTEROP_4(UpdateProperty, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateProperty1(KNativePointer context, KInt kind, KNativePointer key, KNativePointer value, KBoolean isMethod, KBoolean isComputed) +{ + const auto _context = reinterpret_cast(context); + const auto _kind = static_cast(kind); + const auto _key = reinterpret_cast(key); + const auto _value = reinterpret_cast(value); + const auto _isMethod = static_cast(isMethod); + const auto _isComputed = static_cast(isComputed); + auto result = GetImpl()->CreateProperty1(_context, _kind, _key, _value, _isMethod, _isComputed); + return result; +} +KOALA_INTEROP_6(CreateProperty1, KNativePointer, KNativePointer, KInt, KNativePointer, KNativePointer, KBoolean, KBoolean); + +KNativePointer impl_UpdateProperty1(KNativePointer context, KNativePointer original, KInt kind, KNativePointer key, KNativePointer value, KBoolean isMethod, KBoolean isComputed) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _kind = static_cast(kind); + const auto _key = reinterpret_cast(key); + const auto _value = reinterpret_cast(value); + const auto _isMethod = static_cast(isMethod); + const auto _isComputed = static_cast(isComputed); + auto result = GetImpl()->UpdateProperty1(_context, _original, _kind, _key, _value, _isMethod, _isComputed); + return result; +} +KOALA_INTEROP_7(UpdateProperty1, KNativePointer, KNativePointer, KNativePointer, KInt, KNativePointer, KNativePointer, KBoolean, KBoolean); + +KNativePointer impl_PropertyKey(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->PropertyKey(_context, _receiver); + return result; +} +KOALA_INTEROP_2(PropertyKey, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_PropertyKeyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->PropertyKeyConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(PropertyKeyConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_PropertyValueConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->PropertyValueConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(PropertyValueConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_PropertyValue(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->PropertyValue(_context, _receiver); + return result; +} +KOALA_INTEROP_2(PropertyValue, KNativePointer, KNativePointer, KNativePointer); + +KInt impl_PropertyKindConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->PropertyKindConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(PropertyKindConst, KInt, KNativePointer, KNativePointer); + +KBoolean impl_PropertyIsMethodConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->PropertyIsMethodConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(PropertyIsMethodConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_PropertyIsShorthandConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->PropertyIsShorthandConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(PropertyIsShorthandConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_PropertyIsComputedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->PropertyIsComputedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(PropertyIsComputedConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_PropertyIsAccessorConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->PropertyIsAccessorConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(PropertyIsAccessorConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_PropertyIsAccessorKind(KNativePointer context, KNativePointer receiver, KInt kind) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _kind = static_cast(kind); + auto result = GetImpl()->PropertyIsAccessorKind(_context, _receiver, _kind); + return result; +} +KOALA_INTEROP_3(PropertyIsAccessorKind, KBoolean, KNativePointer, KNativePointer, KInt); + +KBoolean impl_PropertyConvertibleToPatternProperty(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->PropertyConvertibleToPatternProperty(_context, _receiver); + return result; +} +KOALA_INTEROP_2(PropertyConvertibleToPatternProperty, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_PropertyValidateExpression(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->PropertyValidateExpression(_context, _receiver); + return result; +} +KOALA_INTEROP_2(PropertyValidateExpression, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateVariableDeclarator(KNativePointer context, KInt flag, KNativePointer ident) +{ + const auto _context = reinterpret_cast(context); + const auto _flag = static_cast(flag); + const auto _ident = reinterpret_cast(ident); + auto result = GetImpl()->CreateVariableDeclarator(_context, _flag, _ident); + return result; +} +KOALA_INTEROP_3(CreateVariableDeclarator, KNativePointer, KNativePointer, KInt, KNativePointer); + +KNativePointer impl_UpdateVariableDeclarator(KNativePointer context, KNativePointer original, KInt flag, KNativePointer ident) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _flag = static_cast(flag); + const auto _ident = reinterpret_cast(ident); + auto result = GetImpl()->UpdateVariableDeclarator(_context, _original, _flag, _ident); + return result; +} +KOALA_INTEROP_4(UpdateVariableDeclarator, KNativePointer, KNativePointer, KNativePointer, KInt, KNativePointer); + +KNativePointer impl_CreateVariableDeclarator1(KNativePointer context, KInt flag, KNativePointer ident, KNativePointer init) +{ + const auto _context = reinterpret_cast(context); + const auto _flag = static_cast(flag); + const auto _ident = reinterpret_cast(ident); + const auto _init = reinterpret_cast(init); + auto result = GetImpl()->CreateVariableDeclarator1(_context, _flag, _ident, _init); + return result; +} +KOALA_INTEROP_4(CreateVariableDeclarator1, KNativePointer, KNativePointer, KInt, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateVariableDeclarator1(KNativePointer context, KNativePointer original, KInt flag, KNativePointer ident, KNativePointer init) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _flag = static_cast(flag); + const auto _ident = reinterpret_cast(ident); + const auto _init = reinterpret_cast(init); + auto result = GetImpl()->UpdateVariableDeclarator1(_context, _original, _flag, _ident, _init); + return result; +} +KOALA_INTEROP_5(UpdateVariableDeclarator1, KNativePointer, KNativePointer, KNativePointer, KInt, KNativePointer, KNativePointer); + +KNativePointer impl_VariableDeclaratorInit(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->VariableDeclaratorInit(_context, _receiver); + return result; +} +KOALA_INTEROP_2(VariableDeclaratorInit, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_VariableDeclaratorInitConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->VariableDeclaratorInitConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(VariableDeclaratorInitConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_VariableDeclaratorSetInit(KNativePointer context, KNativePointer receiver, KNativePointer init) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _init = reinterpret_cast(init); + GetImpl()->VariableDeclaratorSetInit(_context, _receiver, _init); + return ; +} +KOALA_INTEROP_V3(VariableDeclaratorSetInit, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_VariableDeclaratorId(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->VariableDeclaratorId(_context, _receiver); + return result; +} +KOALA_INTEROP_2(VariableDeclaratorId, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_VariableDeclaratorIdConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->VariableDeclaratorIdConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(VariableDeclaratorIdConst, KNativePointer, KNativePointer, KNativePointer); + +KInt impl_VariableDeclaratorFlag(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->VariableDeclaratorFlag(_context, _receiver); + return result; +} +KOALA_INTEROP_2(VariableDeclaratorFlag, KInt, KNativePointer, KNativePointer); + +KNativePointer impl_CreateStringLiteral(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateStringLiteral(_context); + return result; +} +KOALA_INTEROP_1(CreateStringLiteral, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateStringLiteral(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateStringLiteral(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateStringLiteral, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateStringLiteral1(KNativePointer context, KStringPtr& str) +{ + const auto _context = reinterpret_cast(context); + const auto _str = getStringCopy(str); + auto result = GetImpl()->CreateStringLiteral1(_context, _str); + return result; +} +KOALA_INTEROP_2(CreateStringLiteral1, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_UpdateStringLiteral1(KNativePointer context, KNativePointer original, KStringPtr& str) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _str = getStringCopy(str); + auto result = GetImpl()->UpdateStringLiteral1(_context, _original, _str); + return result; +} +KOALA_INTEROP_3(UpdateStringLiteral1, KNativePointer, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_StringLiteralStrConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->StringLiteralStrConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(StringLiteralStrConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSTypeAssertion(KNativePointer context, KNativePointer typeAnnotation, KNativePointer expression) +{ + const auto _context = reinterpret_cast(context); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + const auto _expression = reinterpret_cast(expression); + auto result = GetImpl()->CreateTSTypeAssertion(_context, _typeAnnotation, _expression); + return result; +} +KOALA_INTEROP_3(CreateTSTypeAssertion, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSTypeAssertion(KNativePointer context, KNativePointer original, KNativePointer typeAnnotation, KNativePointer expression) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + const auto _expression = reinterpret_cast(expression); + auto result = GetImpl()->UpdateTSTypeAssertion(_context, _original, _typeAnnotation, _expression); + return result; +} +KOALA_INTEROP_4(UpdateTSTypeAssertion, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeAssertionGetExpressionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeAssertionGetExpressionConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSTypeAssertionGetExpressionConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeAssertionTypeAnnotationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeAssertionTypeAnnotationConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSTypeAssertionTypeAnnotationConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSTypeAssertionSetTsTypeAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer typeAnnotation) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + GetImpl()->TSTypeAssertionSetTsTypeAnnotation(_context, _receiver, _typeAnnotation); + return ; +} +KOALA_INTEROP_V3(TSTypeAssertionSetTsTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSExternalModuleReference(KNativePointer context, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->CreateTSExternalModuleReference(_context, _expr); + return result; +} +KOALA_INTEROP_2(CreateTSExternalModuleReference, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSExternalModuleReference(KNativePointer context, KNativePointer original, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->UpdateTSExternalModuleReference(_context, _original, _expr); + return result; +} +KOALA_INTEROP_3(UpdateTSExternalModuleReference, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSExternalModuleReferenceExprConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSExternalModuleReferenceExprConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSExternalModuleReferenceExprConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSUndefinedKeyword(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateTSUndefinedKeyword(_context); + return result; +} +KOALA_INTEROP_1(CreateTSUndefinedKeyword, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSUndefinedKeyword(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateTSUndefinedKeyword(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateTSUndefinedKeyword, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSTuple(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateETSTuple(_context); + return result; +} +KOALA_INTEROP_1(CreateETSTuple, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSTuple(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateETSTuple(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateETSTuple, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSTuple1(KNativePointer context, KUInt size) +{ + const auto _context = reinterpret_cast(context); + const auto _size = static_cast(size); + auto result = GetImpl()->CreateETSTuple1(_context, _size); + return result; +} +KOALA_INTEROP_2(CreateETSTuple1, KNativePointer, KNativePointer, KUInt); + +KNativePointer impl_UpdateETSTuple1(KNativePointer context, KNativePointer original, KUInt size) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _size = static_cast(size); + auto result = GetImpl()->UpdateETSTuple1(_context, _original, _size); + return result; +} +KOALA_INTEROP_3(UpdateETSTuple1, KNativePointer, KNativePointer, KNativePointer, KUInt); + +KNativePointer impl_CreateETSTuple2(KNativePointer context, KNativePointerArray typeList, KUInt typeListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _typeList = reinterpret_cast(typeList); + const auto _typeListSequenceLength = static_cast(typeListSequenceLength); + auto result = GetImpl()->CreateETSTuple2(_context, _typeList, _typeListSequenceLength); + return result; +} +KOALA_INTEROP_3(CreateETSTuple2, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateETSTuple2(KNativePointer context, KNativePointer original, KNativePointerArray typeList, KUInt typeListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _typeList = reinterpret_cast(typeList); + const auto _typeListSequenceLength = static_cast(typeListSequenceLength); + auto result = GetImpl()->UpdateETSTuple2(_context, _original, _typeList, _typeListSequenceLength); + return result; +} +KOALA_INTEROP_4(UpdateETSTuple2, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KUInt impl_ETSTupleGetTupleSizeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSTupleGetTupleSizeConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSTupleGetTupleSizeConst, KUInt, KNativePointer, KNativePointer); + +KNativePointer impl_ETSTupleGetTupleTypeAnnotationsList(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ETSTupleGetTupleTypeAnnotationsList(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ETSTupleGetTupleTypeAnnotationsList, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSTupleGetTupleTypeAnnotationsListConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ETSTupleGetTupleTypeAnnotationsListConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ETSTupleGetTupleTypeAnnotationsListConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ETSTupleSetTypeAnnotationsList(KNativePointer context, KNativePointer receiver, KNativePointerArray typeNodeList, KUInt typeNodeListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _typeNodeList = reinterpret_cast(typeNodeList); + const auto _typeNodeListSequenceLength = static_cast(typeNodeListSequenceLength); + GetImpl()->ETSTupleSetTypeAnnotationsList(_context, _receiver, _typeNodeList, _typeNodeListSequenceLength); + return ; +} +KOALA_INTEROP_V4(ETSTupleSetTypeAnnotationsList, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateETSStringLiteralType(KNativePointer context, KStringPtr& value) +{ + const auto _context = reinterpret_cast(context); + const auto _value = getStringCopy(value); + auto result = GetImpl()->CreateETSStringLiteralType(_context, _value); + return result; +} +KOALA_INTEROP_2(CreateETSStringLiteralType, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_UpdateETSStringLiteralType(KNativePointer context, KNativePointer original, KStringPtr& value) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _value = getStringCopy(value); + auto result = GetImpl()->UpdateETSStringLiteralType(_context, _original, _value); + return result; +} +KOALA_INTEROP_3(UpdateETSStringLiteralType, KNativePointer, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_CreateTryStatement(KNativePointer context, KNativePointer block, KNativePointerArray catchClauses, KUInt catchClausesSequenceLength, KNativePointer finalizer, KNativePointerArray finalizerInsertionsLabelPair, KUInt finalizerInsertionsLabelPairSequenceLength, KNativePointerArray finalizerInsertionsStatement, KUInt finalizerInsertionsStatementSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _block = reinterpret_cast(block); + const auto _catchClauses = reinterpret_cast(catchClauses); + const auto _catchClausesSequenceLength = static_cast(catchClausesSequenceLength); + const auto _finalizer = reinterpret_cast(finalizer); + const auto _finalizerInsertionsLabelPair = reinterpret_cast(finalizerInsertionsLabelPair); + const auto _finalizerInsertionsLabelPairSequenceLength = static_cast(finalizerInsertionsLabelPairSequenceLength); + const auto _finalizerInsertionsStatement = reinterpret_cast(finalizerInsertionsStatement); + const auto _finalizerInsertionsStatementSequenceLength = static_cast(finalizerInsertionsStatementSequenceLength); + auto result = GetImpl()->CreateTryStatement(_context, _block, _catchClauses, _catchClausesSequenceLength, _finalizer, _finalizerInsertionsLabelPair, _finalizerInsertionsLabelPairSequenceLength, _finalizerInsertionsStatement, _finalizerInsertionsStatementSequenceLength); + return result; +} +KOALA_INTEROP_9(CreateTryStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KNativePointer, KNativePointerArray, KUInt, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateTryStatement(KNativePointer context, KNativePointer original, KNativePointer block, KNativePointerArray catchClauses, KUInt catchClausesSequenceLength, KNativePointer finalizer, KNativePointerArray finalizerInsertionsLabelPair, KUInt finalizerInsertionsLabelPairSequenceLength, KNativePointerArray finalizerInsertionsStatement, KUInt finalizerInsertionsStatementSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _block = reinterpret_cast(block); + const auto _catchClauses = reinterpret_cast(catchClauses); + const auto _catchClausesSequenceLength = static_cast(catchClausesSequenceLength); + const auto _finalizer = reinterpret_cast(finalizer); + const auto _finalizerInsertionsLabelPair = reinterpret_cast(finalizerInsertionsLabelPair); + const auto _finalizerInsertionsLabelPairSequenceLength = static_cast(finalizerInsertionsLabelPairSequenceLength); + const auto _finalizerInsertionsStatement = reinterpret_cast(finalizerInsertionsStatement); + const auto _finalizerInsertionsStatementSequenceLength = static_cast(finalizerInsertionsStatementSequenceLength); + auto result = GetImpl()->UpdateTryStatement(_context, _original, _block, _catchClauses, _catchClausesSequenceLength, _finalizer, _finalizerInsertionsLabelPair, _finalizerInsertionsLabelPairSequenceLength, _finalizerInsertionsStatement, _finalizerInsertionsStatementSequenceLength); + return result; +} +KOALA_INTEROP_10(UpdateTryStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KNativePointer, KNativePointerArray, KUInt, KNativePointerArray, KUInt); + +KNativePointer impl_CreateTryStatement1(KNativePointer context, KNativePointer other) +{ + const auto _context = reinterpret_cast(context); + const auto _other = reinterpret_cast(other); + auto result = GetImpl()->CreateTryStatement1(_context, _other); + return result; +} +KOALA_INTEROP_2(CreateTryStatement1, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTryStatement1(KNativePointer context, KNativePointer original, KNativePointer other) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _other = reinterpret_cast(other); + auto result = GetImpl()->UpdateTryStatement1(_context, _original, _other); + return result; +} +KOALA_INTEROP_3(UpdateTryStatement1, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TryStatementFinallyBlockConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TryStatementFinallyBlockConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TryStatementFinallyBlockConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TryStatementBlockConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TryStatementBlockConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TryStatementBlockConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_TryStatementHasFinalizerConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TryStatementHasFinalizerConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TryStatementHasFinalizerConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_TryStatementHasDefaultCatchClauseConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TryStatementHasDefaultCatchClauseConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TryStatementHasDefaultCatchClauseConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_TryStatementCatchClausesConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TryStatementCatchClausesConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TryStatementCatchClausesConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_TryStatementFinallyCanCompleteNormallyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TryStatementFinallyCanCompleteNormallyConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TryStatementFinallyCanCompleteNormallyConst, KBoolean, KNativePointer, KNativePointer); + +void impl_TryStatementSetFinallyCanCompleteNormally(KNativePointer context, KNativePointer receiver, KBoolean finallyCanCompleteNormally) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _finallyCanCompleteNormally = static_cast(finallyCanCompleteNormally); + GetImpl()->TryStatementSetFinallyCanCompleteNormally(_context, _receiver, _finallyCanCompleteNormally); + return ; +} +KOALA_INTEROP_V3(TryStatementSetFinallyCanCompleteNormally, KNativePointer, KNativePointer, KBoolean); + +KBoolean impl_AstNodeIsProgramConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsProgramConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsProgramConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsStatementConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsStatementConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsStatementConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsExpressionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsExpressionConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsExpressionConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsTypedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsTypedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsTypedConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeAsTyped(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeAsTyped(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeAsTyped, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeAsTypedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeAsTypedConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AstNodeAsTypedConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsBrokenStatementConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsBrokenStatementConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsBrokenStatementConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeAsExpression(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeAsExpression(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeAsExpression, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeAsExpressionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeAsExpressionConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AstNodeAsExpressionConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeAsStatement(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeAsStatement(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeAsStatement, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeAsStatementConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeAsStatementConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AstNodeAsStatementConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_AstNodeSetRange(KNativePointer context, KNativePointer receiver, KNativePointer loc) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _loc = reinterpret_cast(loc); + GetImpl()->AstNodeSetRange(_context, _receiver, _loc); + return ; +} +KOALA_INTEROP_V3(AstNodeSetRange, KNativePointer, KNativePointer, KNativePointer); + +void impl_AstNodeSetProgram(KNativePointer context, KNativePointer receiver, KNativePointer program) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _program = reinterpret_cast(program); + GetImpl()->AstNodeSetProgram(_context, _receiver, _program); + return ; +} +KOALA_INTEROP_V3(AstNodeSetProgram, KNativePointer, KNativePointer, KNativePointer); + +void impl_AstNodeSetStart(KNativePointer context, KNativePointer receiver, KNativePointer start) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _start = reinterpret_cast(start); + GetImpl()->AstNodeSetStart(_context, _receiver, _start); + return ; +} +KOALA_INTEROP_V3(AstNodeSetStart, KNativePointer, KNativePointer, KNativePointer); + +void impl_AstNodeSetEnd(KNativePointer context, KNativePointer receiver, KNativePointer end) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _end = reinterpret_cast(end); + GetImpl()->AstNodeSetEnd(_context, _receiver, _end); + return ; +} +KOALA_INTEROP_V3(AstNodeSetEnd, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeProgramConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeProgramConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AstNodeProgramConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeStartConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeStartConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AstNodeStartConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeEndConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeEndConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AstNodeEndConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeRangeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeRangeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AstNodeRangeConst, KNativePointer, KNativePointer, KNativePointer); + +KInt impl_AstNodeTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeTypeConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeTypeConst, KInt, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeParent(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeParent(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeParent, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeParentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeParentConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AstNodeParentConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_AstNodeSetParent(KNativePointer context, KNativePointer receiver, KNativePointer parent) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _parent = reinterpret_cast(parent); + GetImpl()->AstNodeSetParent(_context, _receiver, _parent); + return ; +} +KOALA_INTEROP_V3(AstNodeSetParent, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeDecoratorsPtrConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->AstNodeDecoratorsPtrConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(AstNodeDecoratorsPtrConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_AstNodeAddDecorators(KNativePointer context, KNativePointer receiver, KNativePointerArray decorators, KUInt decoratorsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _decorators = reinterpret_cast(decorators); + const auto _decoratorsSequenceLength = static_cast(decoratorsSequenceLength); + GetImpl()->AstNodeAddDecorators(_context, _receiver, _decorators, _decoratorsSequenceLength); + return ; +} +KOALA_INTEROP_V4(AstNodeAddDecorators, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KBoolean impl_AstNodeCanHaveDecoratorConst(KNativePointer context, KNativePointer receiver, KBoolean inTs) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _inTs = static_cast(inTs); + auto result = GetImpl()->AstNodeCanHaveDecoratorConst(_context, _receiver, _inTs); + return result; +} +KOALA_INTEROP_3(AstNodeCanHaveDecoratorConst, KBoolean, KNativePointer, KNativePointer, KBoolean); + +KBoolean impl_AstNodeIsReadonlyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsReadonlyConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsReadonlyConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsReadonlyTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsReadonlyTypeConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsReadonlyTypeConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsOptionalDeclarationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsOptionalDeclarationConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsOptionalDeclarationConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsDefiniteConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsDefiniteConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsDefiniteConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsConstructorConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsConstructorConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsConstructorConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsOverrideConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsOverrideConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsOverrideConst, KBoolean, KNativePointer, KNativePointer); + +void impl_AstNodeSetOverride(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->AstNodeSetOverride(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(AstNodeSetOverride, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsAsyncConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsAsyncConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsAsyncConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsSynchronizedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsSynchronizedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsSynchronizedConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsNativeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsNativeConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsNativeConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsConstConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsConstConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsConstConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsStaticConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsStaticConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsStaticConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsFinalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsFinalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsFinalConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsAbstractConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsAbstractConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsAbstractConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsPublicConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsPublicConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsPublicConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsProtectedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsProtectedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsProtectedConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsPrivateConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsPrivateConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsPrivateConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsInternalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsInternalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsInternalConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsExportedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsExportedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsExportedConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsDefaultExportedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsDefaultExportedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsDefaultExportedConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsExportedTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsExportedTypeConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsExportedTypeConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsDeclareConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsDeclareConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsDeclareConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsInConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsInConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsInConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsOutConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsOutConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsOutConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsSetterConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsSetterConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsSetterConst, KBoolean, KNativePointer, KNativePointer); + +void impl_AstNodeAddModifier(KNativePointer context, KNativePointer receiver, KInt flags) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _flags = static_cast(flags); + GetImpl()->AstNodeAddModifier(_context, _receiver, _flags); + return ; +} +KOALA_INTEROP_V3(AstNodeAddModifier, KNativePointer, KNativePointer, KInt); + +void impl_AstNodeClearModifier(KNativePointer context, KNativePointer receiver, KInt flags) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _flags = static_cast(flags); + GetImpl()->AstNodeClearModifier(_context, _receiver, _flags); + return ; +} +KOALA_INTEROP_V3(AstNodeClearModifier, KNativePointer, KNativePointer, KInt); + +KInt impl_AstNodeModifiers(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeModifiers(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeModifiers, KInt, KNativePointer, KNativePointer); + +KInt impl_AstNodeModifiersConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeModifiersConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeModifiersConst, KInt, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeHasExportAliasConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeHasExportAliasConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeHasExportAliasConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeAsClassElement(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeAsClassElement(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeAsClassElement, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeAsClassElementConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeAsClassElementConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AstNodeAsClassElementConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsScopeBearerConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsScopeBearerConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsScopeBearerConst, KBoolean, KNativePointer, KNativePointer); + +void impl_AstNodeClearScope(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->AstNodeClearScope(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(AstNodeClearScope, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeGetTopStatement(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeGetTopStatement(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeGetTopStatement, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeGetTopStatementConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeGetTopStatementConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AstNodeGetTopStatementConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeClone(KNativePointer context, KNativePointer receiver, KNativePointer parent) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _parent = reinterpret_cast(parent); + auto result = GetImpl()->AstNodeClone(_context, _receiver, _parent); + return result; +} +KOALA_INTEROP_3(AstNodeClone, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeDumpJSONConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeDumpJSONConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(AstNodeDumpJSONConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeDumpEtsSrcConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeDumpEtsSrcConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(AstNodeDumpEtsSrcConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeDumpDeclConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeDumpDeclConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(AstNodeDumpDeclConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_AstNodeDumpConst(KNativePointer context, KNativePointer receiver, KNativePointer dumper) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _dumper = reinterpret_cast(dumper); + GetImpl()->AstNodeDumpConst(_context, _receiver, _dumper); + return ; +} +KOALA_INTEROP_V3(AstNodeDumpConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_AstNodeDumpConst1(KNativePointer context, KNativePointer receiver, KNativePointer dumper) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _dumper = reinterpret_cast(dumper); + GetImpl()->AstNodeDumpConst1(_context, _receiver, _dumper); + return ; +} +KOALA_INTEROP_V3(AstNodeDumpConst1, KNativePointer, KNativePointer, KNativePointer); + +void impl_AstNodeCompileConst(KNativePointer context, KNativePointer receiver, KNativePointer pg) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _pg = reinterpret_cast(pg); + GetImpl()->AstNodeCompileConst(_context, _receiver, _pg); + return ; +} +KOALA_INTEROP_V3(AstNodeCompileConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_AstNodeCompileConst1(KNativePointer context, KNativePointer receiver, KNativePointer etsg) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _etsg = reinterpret_cast(etsg); + GetImpl()->AstNodeCompileConst1(_context, _receiver, _etsg); + return ; +} +KOALA_INTEROP_V3(AstNodeCompileConst1, KNativePointer, KNativePointer, KNativePointer); + +void impl_AstNodeSetTransformedNode(KNativePointer context, KNativePointer receiver, KStringPtr& transformationName, KNativePointer transformedNode) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _transformationName = getStringCopy(transformationName); + const auto _transformedNode = reinterpret_cast(transformedNode); + GetImpl()->AstNodeSetTransformedNode(_context, _receiver, _transformationName, _transformedNode); + return ; +} +KOALA_INTEROP_V4(AstNodeSetTransformedNode, KNativePointer, KNativePointer, KStringPtr, KNativePointer); + +void impl_AstNodeAccept(KNativePointer context, KNativePointer receiver, KNativePointer v) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _v = reinterpret_cast(v); + GetImpl()->AstNodeAccept(_context, _receiver, _v); + return ; +} +KOALA_INTEROP_V3(AstNodeAccept, KNativePointer, KNativePointer, KNativePointer); + +void impl_AstNodeSetOriginalNode(KNativePointer context, KNativePointer receiver, KNativePointer originalNode) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _originalNode = reinterpret_cast(originalNode); + GetImpl()->AstNodeSetOriginalNode(_context, _receiver, _originalNode); + return ; +} +KOALA_INTEROP_V3(AstNodeSetOriginalNode, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeOriginalNodeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeOriginalNodeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AstNodeOriginalNodeConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_AstNodeCleanUp(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->AstNodeCleanUp(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(AstNodeCleanUp, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeShallowClone(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeShallowClone(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeShallowClone, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_AstNodeIsValidInCurrentPhaseConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeIsValidInCurrentPhaseConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AstNodeIsValidInCurrentPhaseConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeGetHistoryNodeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeGetHistoryNodeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AstNodeGetHistoryNodeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AstNodeGetOrCreateHistoryNodeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstNodeGetOrCreateHistoryNodeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AstNodeGetOrCreateHistoryNodeConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_AstNodeCleanCheckInformation(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->AstNodeCleanCheckInformation(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(AstNodeCleanCheckInformation, KNativePointer, KNativePointer); + +KNativePointer impl_CreateUnaryExpression(KNativePointer context, KNativePointer argument, KInt unaryOperator) +{ + const auto _context = reinterpret_cast(context); + const auto _argument = reinterpret_cast(argument); + const auto _unaryOperator = static_cast(unaryOperator); + auto result = GetImpl()->CreateUnaryExpression(_context, _argument, _unaryOperator); + return result; +} +KOALA_INTEROP_3(CreateUnaryExpression, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_UpdateUnaryExpression(KNativePointer context, KNativePointer original, KNativePointer argument, KInt unaryOperator) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _argument = reinterpret_cast(argument); + const auto _unaryOperator = static_cast(unaryOperator); + auto result = GetImpl()->UpdateUnaryExpression(_context, _original, _argument, _unaryOperator); + return result; +} +KOALA_INTEROP_4(UpdateUnaryExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt); + +KInt impl_UnaryExpressionOperatorTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->UnaryExpressionOperatorTypeConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(UnaryExpressionOperatorTypeConst, KInt, KNativePointer, KNativePointer); + +KNativePointer impl_UnaryExpressionArgument(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->UnaryExpressionArgument(_context, _receiver); + return result; +} +KOALA_INTEROP_2(UnaryExpressionArgument, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UnaryExpressionArgumentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->UnaryExpressionArgumentConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(UnaryExpressionArgumentConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_UnaryExpressionSetArgument(KNativePointer context, KNativePointer receiver, KNativePointer arg) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _arg = reinterpret_cast(arg); + GetImpl()->UnaryExpressionSetArgument(_context, _receiver, _arg); + return ; +} +KOALA_INTEROP_V3(UnaryExpressionSetArgument, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateForInStatement(KNativePointer context, KNativePointer left, KNativePointer right, KNativePointer body) +{ + const auto _context = reinterpret_cast(context); + const auto _left = reinterpret_cast(left); + const auto _right = reinterpret_cast(right); + const auto _body = reinterpret_cast(body); + auto result = GetImpl()->CreateForInStatement(_context, _left, _right, _body); + return result; +} +KOALA_INTEROP_4(CreateForInStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateForInStatement(KNativePointer context, KNativePointer original, KNativePointer left, KNativePointer right, KNativePointer body) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _left = reinterpret_cast(left); + const auto _right = reinterpret_cast(right); + const auto _body = reinterpret_cast(body); + auto result = GetImpl()->UpdateForInStatement(_context, _original, _left, _right, _body); + return result; +} +KOALA_INTEROP_5(UpdateForInStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForInStatementLeft(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForInStatementLeft(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ForInStatementLeft, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForInStatementLeftConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForInStatementLeftConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ForInStatementLeftConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForInStatementRight(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForInStatementRight(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ForInStatementRight, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForInStatementRightConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForInStatementRightConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ForInStatementRightConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForInStatementBody(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForInStatementBody(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ForInStatementBody, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForInStatementBodyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForInStatementBodyConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ForInStatementBodyConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateThisExpression(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateThisExpression(_context); + return result; +} +KOALA_INTEROP_1(CreateThisExpression, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateThisExpression(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateThisExpression(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateThisExpression, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSMethodSignature(KNativePointer context, KNativePointer key, KNativePointer signature, KBoolean computed, KBoolean optional_arg) +{ + const auto _context = reinterpret_cast(context); + const auto _key = reinterpret_cast(key); + const auto _signature = reinterpret_cast(signature); + const auto _computed = static_cast(computed); + const auto _optional_arg = static_cast(optional_arg); + auto result = GetImpl()->CreateTSMethodSignature(_context, _key, _signature, _computed, _optional_arg); + return result; +} +KOALA_INTEROP_5(CreateTSMethodSignature, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean, KBoolean); + +KNativePointer impl_UpdateTSMethodSignature(KNativePointer context, KNativePointer original, KNativePointer key, KNativePointer signature, KBoolean computed, KBoolean optional_arg) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _key = reinterpret_cast(key); + const auto _signature = reinterpret_cast(signature); + const auto _computed = static_cast(computed); + const auto _optional_arg = static_cast(optional_arg); + auto result = GetImpl()->UpdateTSMethodSignature(_context, _original, _key, _signature, _computed, _optional_arg); + return result; +} +KOALA_INTEROP_6(UpdateTSMethodSignature, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean, KBoolean); + +KNativePointer impl_TSMethodSignatureKeyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSMethodSignatureKeyConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSMethodSignatureKeyConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSMethodSignatureKey(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSMethodSignatureKey(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSMethodSignatureKey, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSMethodSignatureTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSMethodSignatureTypeParamsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSMethodSignatureTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSMethodSignatureTypeParams(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSMethodSignatureTypeParams(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSMethodSignatureTypeParams, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSMethodSignatureParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSMethodSignatureParamsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSMethodSignatureParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSMethodSignatureReturnTypeAnnotationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSMethodSignatureReturnTypeAnnotationConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSMethodSignatureReturnTypeAnnotationConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSMethodSignatureReturnTypeAnnotation(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSMethodSignatureReturnTypeAnnotation(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSMethodSignatureReturnTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_TSMethodSignatureComputedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSMethodSignatureComputedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSMethodSignatureComputedConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_TSMethodSignatureOptionalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSMethodSignatureOptionalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSMethodSignatureOptionalConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateBinaryExpression(KNativePointer context, KNativePointer left, KNativePointer right, KInt operatorType) +{ + const auto _context = reinterpret_cast(context); + const auto _left = reinterpret_cast(left); + const auto _right = reinterpret_cast(right); + const auto _operatorType = static_cast(operatorType); + auto result = GetImpl()->CreateBinaryExpression(_context, _left, _right, _operatorType); + return result; +} +KOALA_INTEROP_4(CreateBinaryExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_UpdateBinaryExpression(KNativePointer context, KNativePointer original, KNativePointer left, KNativePointer right, KInt operatorType) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _left = reinterpret_cast(left); + const auto _right = reinterpret_cast(right); + const auto _operatorType = static_cast(operatorType); + auto result = GetImpl()->UpdateBinaryExpression(_context, _original, _left, _right, _operatorType); + return result; +} +KOALA_INTEROP_5(UpdateBinaryExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_BinaryExpressionLeftConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BinaryExpressionLeftConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(BinaryExpressionLeftConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_BinaryExpressionLeft(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BinaryExpressionLeft(_context, _receiver); + return result; +} +KOALA_INTEROP_2(BinaryExpressionLeft, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_BinaryExpressionRightConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BinaryExpressionRightConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(BinaryExpressionRightConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_BinaryExpressionRight(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BinaryExpressionRight(_context, _receiver); + return result; +} +KOALA_INTEROP_2(BinaryExpressionRight, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_BinaryExpressionResultConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BinaryExpressionResultConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(BinaryExpressionResultConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_BinaryExpressionResult(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BinaryExpressionResult(_context, _receiver); + return result; +} +KOALA_INTEROP_2(BinaryExpressionResult, KNativePointer, KNativePointer, KNativePointer); + +KInt impl_BinaryExpressionOperatorTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BinaryExpressionOperatorTypeConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(BinaryExpressionOperatorTypeConst, KInt, KNativePointer, KNativePointer); + +KBoolean impl_BinaryExpressionIsLogicalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BinaryExpressionIsLogicalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(BinaryExpressionIsLogicalConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_BinaryExpressionIsLogicalExtendedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BinaryExpressionIsLogicalExtendedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(BinaryExpressionIsLogicalExtendedConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_BinaryExpressionIsBitwiseConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BinaryExpressionIsBitwiseConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(BinaryExpressionIsBitwiseConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_BinaryExpressionIsArithmeticConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BinaryExpressionIsArithmeticConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(BinaryExpressionIsArithmeticConst, KBoolean, KNativePointer, KNativePointer); + +void impl_BinaryExpressionSetLeft(KNativePointer context, KNativePointer receiver, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _expr = reinterpret_cast(expr); + GetImpl()->BinaryExpressionSetLeft(_context, _receiver, _expr); + return ; +} +KOALA_INTEROP_V3(BinaryExpressionSetLeft, KNativePointer, KNativePointer, KNativePointer); + +void impl_BinaryExpressionSetRight(KNativePointer context, KNativePointer receiver, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _expr = reinterpret_cast(expr); + GetImpl()->BinaryExpressionSetRight(_context, _receiver, _expr); + return ; +} +KOALA_INTEROP_V3(BinaryExpressionSetRight, KNativePointer, KNativePointer, KNativePointer); + +void impl_BinaryExpressionSetResult(KNativePointer context, KNativePointer receiver, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _expr = reinterpret_cast(expr); + GetImpl()->BinaryExpressionSetResult(_context, _receiver, _expr); + return ; +} +KOALA_INTEROP_V3(BinaryExpressionSetResult, KNativePointer, KNativePointer, KNativePointer); + +void impl_BinaryExpressionSetOperator(KNativePointer context, KNativePointer receiver, KInt operatorType) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _operatorType = static_cast(operatorType); + GetImpl()->BinaryExpressionSetOperator(_context, _receiver, _operatorType); + return ; +} +KOALA_INTEROP_V3(BinaryExpressionSetOperator, KNativePointer, KNativePointer, KInt); + +void impl_BinaryExpressionCompileOperandsConst(KNativePointer context, KNativePointer receiver, KNativePointer etsg, KNativePointer lhs) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _etsg = reinterpret_cast(etsg); + const auto _lhs = reinterpret_cast(lhs); + GetImpl()->BinaryExpressionCompileOperandsConst(_context, _receiver, _etsg, _lhs); + return ; +} +KOALA_INTEROP_V4(BinaryExpressionCompileOperandsConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateSuperExpression(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateSuperExpression(_context); + return result; +} +KOALA_INTEROP_1(CreateSuperExpression, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateSuperExpression(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateSuperExpression(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateSuperExpression, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateAssertStatement(KNativePointer context, KNativePointer test, KNativePointer second) +{ + const auto _context = reinterpret_cast(context); + const auto _test = reinterpret_cast(test); + const auto _second = reinterpret_cast(second); + auto result = GetImpl()->CreateAssertStatement(_context, _test, _second); + return result; +} +KOALA_INTEROP_3(CreateAssertStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateAssertStatement(KNativePointer context, KNativePointer original, KNativePointer test, KNativePointer second) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _test = reinterpret_cast(test); + const auto _second = reinterpret_cast(second); + auto result = GetImpl()->UpdateAssertStatement(_context, _original, _test, _second); + return result; +} +KOALA_INTEROP_4(UpdateAssertStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AssertStatementTestConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AssertStatementTestConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AssertStatementTestConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AssertStatementTest(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AssertStatementTest(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AssertStatementTest, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AssertStatementSecondConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AssertStatementSecondConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AssertStatementSecondConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSStringKeyword(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateTSStringKeyword(_context); + return result; +} +KOALA_INTEROP_1(CreateTSStringKeyword, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSStringKeyword(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateTSStringKeyword(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateTSStringKeyword, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateAssignmentExpression(KNativePointer context, KNativePointer left, KNativePointer right, KInt assignmentOperator) +{ + const auto _context = reinterpret_cast(context); + const auto _left = reinterpret_cast(left); + const auto _right = reinterpret_cast(right); + const auto _assignmentOperator = static_cast(assignmentOperator); + auto result = GetImpl()->CreateAssignmentExpression(_context, _left, _right, _assignmentOperator); + return result; +} +KOALA_INTEROP_4(CreateAssignmentExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_UpdateAssignmentExpression(KNativePointer context, KNativePointer original, KNativePointer left, KNativePointer right, KInt assignmentOperator) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _left = reinterpret_cast(left); + const auto _right = reinterpret_cast(right); + const auto _assignmentOperator = static_cast(assignmentOperator); + auto result = GetImpl()->UpdateAssignmentExpression(_context, _original, _left, _right, _assignmentOperator); + return result; +} +KOALA_INTEROP_5(UpdateAssignmentExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_CreateAssignmentExpression1(KNativePointer context, KInt type, KNativePointer left, KNativePointer right, KInt assignmentOperator) +{ + const auto _context = reinterpret_cast(context); + const auto _type = static_cast(type); + const auto _left = reinterpret_cast(left); + const auto _right = reinterpret_cast(right); + const auto _assignmentOperator = static_cast(assignmentOperator); + auto result = GetImpl()->CreateAssignmentExpression1(_context, _type, _left, _right, _assignmentOperator); + return result; +} +KOALA_INTEROP_5(CreateAssignmentExpression1, KNativePointer, KNativePointer, KInt, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_UpdateAssignmentExpression1(KNativePointer context, KNativePointer original, KInt type, KNativePointer left, KNativePointer right, KInt assignmentOperator) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _type = static_cast(type); + const auto _left = reinterpret_cast(left); + const auto _right = reinterpret_cast(right); + const auto _assignmentOperator = static_cast(assignmentOperator); + auto result = GetImpl()->UpdateAssignmentExpression1(_context, _original, _type, _left, _right, _assignmentOperator); + return result; +} +KOALA_INTEROP_6(UpdateAssignmentExpression1, KNativePointer, KNativePointer, KNativePointer, KInt, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_AssignmentExpressionLeftConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AssignmentExpressionLeftConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AssignmentExpressionLeftConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AssignmentExpressionLeft(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AssignmentExpressionLeft(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AssignmentExpressionLeft, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AssignmentExpressionRight(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AssignmentExpressionRight(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AssignmentExpressionRight, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AssignmentExpressionRightConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AssignmentExpressionRightConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AssignmentExpressionRightConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_AssignmentExpressionSetRight(KNativePointer context, KNativePointer receiver, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _expr = reinterpret_cast(expr); + GetImpl()->AssignmentExpressionSetRight(_context, _receiver, _expr); + return ; +} +KOALA_INTEROP_V3(AssignmentExpressionSetRight, KNativePointer, KNativePointer, KNativePointer); + +void impl_AssignmentExpressionSetLeft(KNativePointer context, KNativePointer receiver, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _expr = reinterpret_cast(expr); + GetImpl()->AssignmentExpressionSetLeft(_context, _receiver, _expr); + return ; +} +KOALA_INTEROP_V3(AssignmentExpressionSetLeft, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AssignmentExpressionResultConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AssignmentExpressionResultConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AssignmentExpressionResultConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AssignmentExpressionResult(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AssignmentExpressionResult(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AssignmentExpressionResult, KNativePointer, KNativePointer, KNativePointer); + +KInt impl_AssignmentExpressionOperatorTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AssignmentExpressionOperatorTypeConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AssignmentExpressionOperatorTypeConst, KInt, KNativePointer, KNativePointer); + +KInt impl_AssignmentExpressionSetOperatorType(KNativePointer context, KNativePointer receiver, KInt tokenType) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _tokenType = static_cast(tokenType); + auto result = GetImpl()->AssignmentExpressionSetOperatorType(_context, _receiver, _tokenType); + return result; +} +KOALA_INTEROP_3(AssignmentExpressionSetOperatorType, KInt, KNativePointer, KNativePointer, KInt); + +void impl_AssignmentExpressionSetResult(KNativePointer context, KNativePointer receiver, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _expr = reinterpret_cast(expr); + GetImpl()->AssignmentExpressionSetResult(_context, _receiver, _expr); + return ; +} +KOALA_INTEROP_V3(AssignmentExpressionSetResult, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_AssignmentExpressionIsLogicalExtendedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AssignmentExpressionIsLogicalExtendedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AssignmentExpressionIsLogicalExtendedConst, KBoolean, KNativePointer, KNativePointer); + +void impl_AssignmentExpressionSetIgnoreConstAssign(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->AssignmentExpressionSetIgnoreConstAssign(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(AssignmentExpressionSetIgnoreConstAssign, KNativePointer, KNativePointer); + +KBoolean impl_AssignmentExpressionIsIgnoreConstAssignConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AssignmentExpressionIsIgnoreConstAssignConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AssignmentExpressionIsIgnoreConstAssignConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AssignmentExpressionConvertibleToAssignmentPatternLeft(KNativePointer context, KNativePointer receiver, KBoolean mustBePattern) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _mustBePattern = static_cast(mustBePattern); + auto result = GetImpl()->AssignmentExpressionConvertibleToAssignmentPatternLeft(_context, _receiver, _mustBePattern); + return result; +} +KOALA_INTEROP_3(AssignmentExpressionConvertibleToAssignmentPatternLeft, KBoolean, KNativePointer, KNativePointer, KBoolean); + +KBoolean impl_AssignmentExpressionConvertibleToAssignmentPatternRight(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AssignmentExpressionConvertibleToAssignmentPatternRight(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AssignmentExpressionConvertibleToAssignmentPatternRight, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AssignmentExpressionConvertibleToAssignmentPattern(KNativePointer context, KNativePointer receiver, KBoolean mustBePattern) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _mustBePattern = static_cast(mustBePattern); + auto result = GetImpl()->AssignmentExpressionConvertibleToAssignmentPattern(_context, _receiver, _mustBePattern); + return result; +} +KOALA_INTEROP_3(AssignmentExpressionConvertibleToAssignmentPattern, KBoolean, KNativePointer, KNativePointer, KBoolean); + +void impl_AssignmentExpressionCompilePatternConst(KNativePointer context, KNativePointer receiver, KNativePointer pg) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _pg = reinterpret_cast(pg); + GetImpl()->AssignmentExpressionCompilePatternConst(_context, _receiver, _pg); + return ; +} +KOALA_INTEROP_V3(AssignmentExpressionCompilePatternConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateExpressionStatement(KNativePointer context, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->CreateExpressionStatement(_context, _expr); + return result; +} +KOALA_INTEROP_2(CreateExpressionStatement, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateExpressionStatement(KNativePointer context, KNativePointer original, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->UpdateExpressionStatement(_context, _original, _expr); + return result; +} +KOALA_INTEROP_3(UpdateExpressionStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ExpressionStatementGetExpressionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExpressionStatementGetExpressionConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ExpressionStatementGetExpressionConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ExpressionStatementGetExpression(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExpressionStatementGetExpression(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ExpressionStatementGetExpression, KNativePointer, KNativePointer, KNativePointer); + +void impl_ExpressionStatementSetExpression(KNativePointer context, KNativePointer receiver, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _expr = reinterpret_cast(expr); + GetImpl()->ExpressionStatementSetExpression(_context, _receiver, _expr); + return ; +} +KOALA_INTEROP_V3(ExpressionStatementSetExpression, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSModule(KNativePointer context, KNativePointerArray statementList, KUInt statementListSequenceLength, KNativePointer ident, KInt flag, KNativePointer program) +{ + const auto _context = reinterpret_cast(context); + const auto _statementList = reinterpret_cast(statementList); + const auto _statementListSequenceLength = static_cast(statementListSequenceLength); + const auto _ident = reinterpret_cast(ident); + const auto _flag = static_cast(flag); + const auto _program = reinterpret_cast(program); + auto result = GetImpl()->CreateETSModule(_context, _statementList, _statementListSequenceLength, _ident, _flag, _program); + return result; +} +KOALA_INTEROP_6(CreateETSModule, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KNativePointer, KInt, KNativePointer); + +KNativePointer impl_UpdateETSModule(KNativePointer context, KNativePointer original, KNativePointerArray statementList, KUInt statementListSequenceLength, KNativePointer ident, KInt flag, KNativePointer program) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _statementList = reinterpret_cast(statementList); + const auto _statementListSequenceLength = static_cast(statementListSequenceLength); + const auto _ident = reinterpret_cast(ident); + const auto _flag = static_cast(flag); + const auto _program = reinterpret_cast(program); + auto result = GetImpl()->UpdateETSModule(_context, _original, _statementList, _statementListSequenceLength, _ident, _flag, _program); + return result; +} +KOALA_INTEROP_7(UpdateETSModule, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KNativePointer, KInt, KNativePointer); + +KNativePointer impl_ETSModuleIdent(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSModuleIdent(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSModuleIdent, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSModuleIdentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSModuleIdentConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSModuleIdentConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSModuleProgram(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSModuleProgram(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSModuleProgram, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSModuleGlobalClassConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSModuleGlobalClassConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSModuleGlobalClassConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSModuleGlobalClass(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSModuleGlobalClass(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSModuleGlobalClass, KNativePointer, KNativePointer, KNativePointer); + +void impl_ETSModuleSetGlobalClass(KNativePointer context, KNativePointer receiver, KNativePointer globalClass) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _globalClass = reinterpret_cast(globalClass); + GetImpl()->ETSModuleSetGlobalClass(_context, _receiver, _globalClass); + return ; +} +KOALA_INTEROP_V3(ETSModuleSetGlobalClass, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ETSModuleIsETSScriptConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSModuleIsETSScriptConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSModuleIsETSScriptConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ETSModuleIsNamespaceConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSModuleIsNamespaceConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSModuleIsNamespaceConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ETSModuleIsNamespaceChainLastNodeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSModuleIsNamespaceChainLastNodeConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSModuleIsNamespaceChainLastNodeConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ETSModuleSetNamespaceChainLastNode(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ETSModuleSetNamespaceChainLastNode(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ETSModuleSetNamespaceChainLastNode, KNativePointer, KNativePointer); + +KNativePointer impl_ETSModuleProgramConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSModuleProgramConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSModuleProgramConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ETSModuleHasAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSModuleHasAnnotationsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSModuleHasAnnotationsConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ETSModuleEmplaceAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer source) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + GetImpl()->ETSModuleEmplaceAnnotation(_context, _receiver, _source); + return ; +} +KOALA_INTEROP_V3(ETSModuleEmplaceAnnotation, KNativePointer, KNativePointer, KNativePointer); + +void impl_ETSModuleClearAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ETSModuleClearAnnotations(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ETSModuleClearAnnotations, KNativePointer, KNativePointer); + +void impl_ETSModuleDumpAnnotationsConst(KNativePointer context, KNativePointer receiver, KNativePointer dumper) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _dumper = reinterpret_cast(dumper); + GetImpl()->ETSModuleDumpAnnotationsConst(_context, _receiver, _dumper); + return ; +} +KOALA_INTEROP_V3(ETSModuleDumpAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSModuleAnnotationsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ETSModuleAnnotationsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ETSModuleAnnotationsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSModuleAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ETSModuleAnnotations(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ETSModuleAnnotations, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSModuleAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ETSModuleAnnotationsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ETSModuleAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ETSModuleSetAnnotations(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->ETSModuleSetAnnotations(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(ETSModuleSetAnnotations, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_ETSModuleSetAnnotations1(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->ETSModuleSetAnnotations1(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(ETSModuleSetAnnotations1, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateMetaProperty(KNativePointer context, KInt kind) +{ + const auto _context = reinterpret_cast(context); + const auto _kind = static_cast(kind); + auto result = GetImpl()->CreateMetaProperty(_context, _kind); + return result; +} +KOALA_INTEROP_2(CreateMetaProperty, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_UpdateMetaProperty(KNativePointer context, KNativePointer original, KInt kind) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _kind = static_cast(kind); + auto result = GetImpl()->UpdateMetaProperty(_context, _original, _kind); + return result; +} +KOALA_INTEROP_3(UpdateMetaProperty, KNativePointer, KNativePointer, KNativePointer, KInt); + +KInt impl_MetaPropertyKindConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MetaPropertyKindConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MetaPropertyKindConst, KInt, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSArrayType(KNativePointer context, KNativePointer elementType) +{ + const auto _context = reinterpret_cast(context); + const auto _elementType = reinterpret_cast(elementType); + auto result = GetImpl()->CreateTSArrayType(_context, _elementType); + return result; +} +KOALA_INTEROP_2(CreateTSArrayType, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSArrayType(KNativePointer context, KNativePointer original, KNativePointer elementType) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _elementType = reinterpret_cast(elementType); + auto result = GetImpl()->UpdateTSArrayType(_context, _original, _elementType); + return result; +} +KOALA_INTEROP_3(UpdateTSArrayType, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSArrayTypeElementTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSArrayTypeElementTypeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSArrayTypeElementTypeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSSignatureDeclaration(KNativePointer context, KInt kind, KNativePointer signature) +{ + const auto _context = reinterpret_cast(context); + const auto _kind = static_cast(kind); + const auto _signature = reinterpret_cast(signature); + auto result = GetImpl()->CreateTSSignatureDeclaration(_context, _kind, _signature); + return result; +} +KOALA_INTEROP_3(CreateTSSignatureDeclaration, KNativePointer, KNativePointer, KInt, KNativePointer); + +KNativePointer impl_UpdateTSSignatureDeclaration(KNativePointer context, KNativePointer original, KInt kind, KNativePointer signature) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _kind = static_cast(kind); + const auto _signature = reinterpret_cast(signature); + auto result = GetImpl()->UpdateTSSignatureDeclaration(_context, _original, _kind, _signature); + return result; +} +KOALA_INTEROP_4(UpdateTSSignatureDeclaration, KNativePointer, KNativePointer, KNativePointer, KInt, KNativePointer); + +KNativePointer impl_TSSignatureDeclarationTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSSignatureDeclarationTypeParamsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSSignatureDeclarationTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSSignatureDeclarationTypeParams(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSSignatureDeclarationTypeParams(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSSignatureDeclarationTypeParams, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSSignatureDeclarationParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSSignatureDeclarationParamsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSSignatureDeclarationParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSSignatureDeclarationReturnTypeAnnotationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSSignatureDeclarationReturnTypeAnnotationConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSSignatureDeclarationReturnTypeAnnotationConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSSignatureDeclarationReturnTypeAnnotation(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSSignatureDeclarationReturnTypeAnnotation(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSSignatureDeclarationReturnTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +KInt impl_TSSignatureDeclarationKindConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSSignatureDeclarationKindConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSSignatureDeclarationKindConst, KInt, KNativePointer, KNativePointer); + +KNativePointer impl_CreateExportAllDeclaration(KNativePointer context, KNativePointer source, KNativePointer exported) +{ + const auto _context = reinterpret_cast(context); + const auto _source = reinterpret_cast(source); + const auto _exported = reinterpret_cast(exported); + auto result = GetImpl()->CreateExportAllDeclaration(_context, _source, _exported); + return result; +} +KOALA_INTEROP_3(CreateExportAllDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateExportAllDeclaration(KNativePointer context, KNativePointer original, KNativePointer source, KNativePointer exported) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _source = reinterpret_cast(source); + const auto _exported = reinterpret_cast(exported); + auto result = GetImpl()->UpdateExportAllDeclaration(_context, _original, _source, _exported); + return result; +} +KOALA_INTEROP_4(UpdateExportAllDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ExportAllDeclarationSourceConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExportAllDeclarationSourceConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ExportAllDeclarationSourceConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ExportAllDeclarationExportedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExportAllDeclarationExportedConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ExportAllDeclarationExportedConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateExportSpecifier(KNativePointer context, KNativePointer local, KNativePointer exported) +{ + const auto _context = reinterpret_cast(context); + const auto _local = reinterpret_cast(local); + const auto _exported = reinterpret_cast(exported); + auto result = GetImpl()->CreateExportSpecifier(_context, _local, _exported); + return result; +} +KOALA_INTEROP_3(CreateExportSpecifier, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateExportSpecifier(KNativePointer context, KNativePointer original, KNativePointer local, KNativePointer exported) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _local = reinterpret_cast(local); + const auto _exported = reinterpret_cast(exported); + auto result = GetImpl()->UpdateExportSpecifier(_context, _original, _local, _exported); + return result; +} +KOALA_INTEROP_4(UpdateExportSpecifier, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ExportSpecifierLocalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExportSpecifierLocalConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ExportSpecifierLocalConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ExportSpecifierExportedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExportSpecifierExportedConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ExportSpecifierExportedConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ExportSpecifierSetDefault(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ExportSpecifierSetDefault(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ExportSpecifierSetDefault, KNativePointer, KNativePointer); + +KBoolean impl_ExportSpecifierIsDefaultConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExportSpecifierIsDefaultConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ExportSpecifierIsDefaultConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ExportSpecifierSetConstantExpression(KNativePointer context, KNativePointer receiver, KNativePointer constantExpression) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _constantExpression = reinterpret_cast(constantExpression); + GetImpl()->ExportSpecifierSetConstantExpression(_context, _receiver, _constantExpression); + return ; +} +KOALA_INTEROP_V3(ExportSpecifierSetConstantExpression, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ExportSpecifierGetConstantExpressionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExportSpecifierGetConstantExpressionConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ExportSpecifierGetConstantExpressionConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSTupleType(KNativePointer context, KNativePointerArray elementTypes, KUInt elementTypesSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _elementTypes = reinterpret_cast(elementTypes); + const auto _elementTypesSequenceLength = static_cast(elementTypesSequenceLength); + auto result = GetImpl()->CreateTSTupleType(_context, _elementTypes, _elementTypesSequenceLength); + return result; +} +KOALA_INTEROP_3(CreateTSTupleType, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateTSTupleType(KNativePointer context, KNativePointer original, KNativePointerArray elementTypes, KUInt elementTypesSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _elementTypes = reinterpret_cast(elementTypes); + const auto _elementTypesSequenceLength = static_cast(elementTypesSequenceLength); + auto result = GetImpl()->UpdateTSTupleType(_context, _original, _elementTypes, _elementTypesSequenceLength); + return result; +} +KOALA_INTEROP_4(UpdateTSTupleType, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_TSTupleTypeElementTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSTupleTypeElementTypeConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSTupleTypeElementTypeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateFunctionExpression(KNativePointer context, KNativePointer func) +{ + const auto _context = reinterpret_cast(context); + const auto _func = reinterpret_cast(func); + auto result = GetImpl()->CreateFunctionExpression(_context, _func); + return result; +} +KOALA_INTEROP_2(CreateFunctionExpression, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateFunctionExpression(KNativePointer context, KNativePointer original, KNativePointer func) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _func = reinterpret_cast(func); + auto result = GetImpl()->UpdateFunctionExpression(_context, _original, _func); + return result; +} +KOALA_INTEROP_3(UpdateFunctionExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateFunctionExpression1(KNativePointer context, KNativePointer namedExpr, KNativePointer func) +{ + const auto _context = reinterpret_cast(context); + const auto _namedExpr = reinterpret_cast(namedExpr); + const auto _func = reinterpret_cast(func); + auto result = GetImpl()->CreateFunctionExpression1(_context, _namedExpr, _func); + return result; +} +KOALA_INTEROP_3(CreateFunctionExpression1, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateFunctionExpression1(KNativePointer context, KNativePointer original, KNativePointer namedExpr, KNativePointer func) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _namedExpr = reinterpret_cast(namedExpr); + const auto _func = reinterpret_cast(func); + auto result = GetImpl()->UpdateFunctionExpression1(_context, _original, _namedExpr, _func); + return result; +} +KOALA_INTEROP_4(UpdateFunctionExpression1, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_FunctionExpressionFunctionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->FunctionExpressionFunctionConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(FunctionExpressionFunctionConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_FunctionExpressionFunction(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->FunctionExpressionFunction(_context, _receiver); + return result; +} +KOALA_INTEROP_2(FunctionExpressionFunction, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_FunctionExpressionIsAnonymousConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->FunctionExpressionIsAnonymousConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(FunctionExpressionIsAnonymousConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_FunctionExpressionId(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->FunctionExpressionId(_context, _receiver); + return result; +} +KOALA_INTEROP_2(FunctionExpressionId, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSIndexSignature(KNativePointer context, KNativePointer param, KNativePointer typeAnnotation, KBoolean readonly_arg) +{ + const auto _context = reinterpret_cast(context); + const auto _param = reinterpret_cast(param); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + const auto _readonly_arg = static_cast(readonly_arg); + auto result = GetImpl()->CreateTSIndexSignature(_context, _param, _typeAnnotation, _readonly_arg); + return result; +} +KOALA_INTEROP_4(CreateTSIndexSignature, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_UpdateTSIndexSignature(KNativePointer context, KNativePointer original, KNativePointer param, KNativePointer typeAnnotation, KBoolean readonly_arg) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _param = reinterpret_cast(param); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + const auto _readonly_arg = static_cast(readonly_arg); + auto result = GetImpl()->UpdateTSIndexSignature(_context, _original, _param, _typeAnnotation, _readonly_arg); + return result; +} +KOALA_INTEROP_5(UpdateTSIndexSignature, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_TSIndexSignatureParamConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSIndexSignatureParamConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSIndexSignatureParamConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSIndexSignatureTypeAnnotationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSIndexSignatureTypeAnnotationConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSIndexSignatureTypeAnnotationConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_TSIndexSignatureReadonlyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSIndexSignatureReadonlyConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSIndexSignatureReadonlyConst, KBoolean, KNativePointer, KNativePointer); + +KInt impl_TSIndexSignatureKindConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSIndexSignatureKindConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSIndexSignatureKindConst, KInt, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSModuleDeclaration(KNativePointer context, KNativePointer name, KNativePointer body, KBoolean declare, KBoolean _global) +{ + const auto _context = reinterpret_cast(context); + const auto _name = reinterpret_cast(name); + const auto _body = reinterpret_cast(body); + const auto _declare = static_cast(declare); + const auto __global = static_cast(_global); + auto result = GetImpl()->CreateTSModuleDeclaration(_context, _name, _body, _declare, __global); + return result; +} +KOALA_INTEROP_5(CreateTSModuleDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean, KBoolean); + +KNativePointer impl_UpdateTSModuleDeclaration(KNativePointer context, KNativePointer original, KNativePointer name, KNativePointer body, KBoolean declare, KBoolean _global) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _name = reinterpret_cast(name); + const auto _body = reinterpret_cast(body); + const auto _declare = static_cast(declare); + const auto __global = static_cast(_global); + auto result = GetImpl()->UpdateTSModuleDeclaration(_context, _original, _name, _body, _declare, __global); + return result; +} +KOALA_INTEROP_6(UpdateTSModuleDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean, KBoolean); + +KNativePointer impl_TSModuleDeclarationNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSModuleDeclarationNameConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSModuleDeclarationNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSModuleDeclarationBodyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSModuleDeclarationBodyConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSModuleDeclarationBodyConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_TSModuleDeclarationGlobalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSModuleDeclarationGlobalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSModuleDeclarationGlobalConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_TSModuleDeclarationIsExternalOrAmbientConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSModuleDeclarationIsExternalOrAmbientConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSModuleDeclarationIsExternalOrAmbientConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateImportDeclaration(KNativePointer context, KNativePointer source, KNativePointerArray specifiers, KUInt specifiersSequenceLength, KInt importKinds) +{ + const auto _context = reinterpret_cast(context); + const auto _source = reinterpret_cast(source); + const auto _specifiers = reinterpret_cast(specifiers); + const auto _specifiersSequenceLength = static_cast(specifiersSequenceLength); + const auto _importKinds = static_cast(importKinds); + auto result = GetImpl()->CreateImportDeclaration(_context, _source, _specifiers, _specifiersSequenceLength, _importKinds); + return result; +} +KOALA_INTEROP_5(CreateImportDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KInt); + +KNativePointer impl_UpdateImportDeclaration(KNativePointer context, KNativePointer original, KNativePointer source, KNativePointerArray specifiers, KUInt specifiersSequenceLength, KInt importKinds) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _source = reinterpret_cast(source); + const auto _specifiers = reinterpret_cast(specifiers); + const auto _specifiersSequenceLength = static_cast(specifiersSequenceLength); + const auto _importKinds = static_cast(importKinds); + auto result = GetImpl()->UpdateImportDeclaration(_context, _original, _source, _specifiers, _specifiersSequenceLength, _importKinds); + return result; +} +KOALA_INTEROP_6(UpdateImportDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KInt); + +void impl_ImportDeclarationEmplaceSpecifiers(KNativePointer context, KNativePointer receiver, KNativePointer source) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + GetImpl()->ImportDeclarationEmplaceSpecifiers(_context, _receiver, _source); + return ; +} +KOALA_INTEROP_V3(ImportDeclarationEmplaceSpecifiers, KNativePointer, KNativePointer, KNativePointer); + +void impl_ImportDeclarationClearSpecifiers(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ImportDeclarationClearSpecifiers(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ImportDeclarationClearSpecifiers, KNativePointer, KNativePointer); + +void impl_ImportDeclarationSetValueSpecifiers(KNativePointer context, KNativePointer receiver, KNativePointer source, KUInt index) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + const auto _index = static_cast(index); + GetImpl()->ImportDeclarationSetValueSpecifiers(_context, _receiver, _source, _index); + return ; +} +KOALA_INTEROP_V4(ImportDeclarationSetValueSpecifiers, KNativePointer, KNativePointer, KNativePointer, KUInt); + +KNativePointer impl_ImportDeclarationSpecifiersForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ImportDeclarationSpecifiersForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ImportDeclarationSpecifiersForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ImportDeclarationSourceConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ImportDeclarationSourceConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ImportDeclarationSourceConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ImportDeclarationSource(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ImportDeclarationSource(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ImportDeclarationSource, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ImportDeclarationSpecifiersConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ImportDeclarationSpecifiersConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ImportDeclarationSpecifiersConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ImportDeclarationIsTypeKindConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ImportDeclarationIsTypeKindConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ImportDeclarationIsTypeKindConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSParenthesizedType(KNativePointer context, KNativePointer type) +{ + const auto _context = reinterpret_cast(context); + const auto _type = reinterpret_cast(type); + auto result = GetImpl()->CreateTSParenthesizedType(_context, _type); + return result; +} +KOALA_INTEROP_2(CreateTSParenthesizedType, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSParenthesizedType(KNativePointer context, KNativePointer original, KNativePointer type) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _type = reinterpret_cast(type); + auto result = GetImpl()->UpdateTSParenthesizedType(_context, _original, _type); + return result; +} +KOALA_INTEROP_3(UpdateTSParenthesizedType, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSParenthesizedTypeTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSParenthesizedTypeTypeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSParenthesizedTypeTypeConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_LiteralIsFoldedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->LiteralIsFoldedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(LiteralIsFoldedConst, KBoolean, KNativePointer, KNativePointer); + +void impl_LiteralSetFolded(KNativePointer context, KNativePointer receiver, KBoolean folded) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _folded = static_cast(folded); + GetImpl()->LiteralSetFolded(_context, _receiver, _folded); + return ; +} +KOALA_INTEROP_V3(LiteralSetFolded, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_CreateCharLiteral(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateCharLiteral(_context); + return result; +} +KOALA_INTEROP_1(CreateCharLiteral, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateCharLiteral(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateCharLiteral(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateCharLiteral, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSIntrinsicNode(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateETSIntrinsicNode(_context); + return result; +} +KOALA_INTEROP_1(CreateETSIntrinsicNode, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSIntrinsicNode(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateETSIntrinsicNode(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateETSIntrinsicNode, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSIntrinsicNode1(KNativePointer context, KNativePointer other) +{ + const auto _context = reinterpret_cast(context); + const auto _other = reinterpret_cast(other); + auto result = GetImpl()->CreateETSIntrinsicNode1(_context, _other); + return result; +} +KOALA_INTEROP_2(CreateETSIntrinsicNode1, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSIntrinsicNode1(KNativePointer context, KNativePointer original, KNativePointer other) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _other = reinterpret_cast(other); + auto result = GetImpl()->UpdateETSIntrinsicNode1(_context, _original, _other); + return result; +} +KOALA_INTEROP_3(UpdateETSIntrinsicNode1, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSIntrinsicNode2(KNativePointer context, KInt type, KNativePointerArray _arguments, KUInt _argumentsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _type = static_cast(type); + const auto __arguments = reinterpret_cast(_arguments); + const auto __argumentsSequenceLength = static_cast(_argumentsSequenceLength); + auto result = GetImpl()->CreateETSIntrinsicNode2(_context, _type, __arguments, __argumentsSequenceLength); + return result; +} +KOALA_INTEROP_4(CreateETSIntrinsicNode2, KNativePointer, KNativePointer, KInt, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateETSIntrinsicNode2(KNativePointer context, KNativePointer original, KInt type, KNativePointerArray _arguments, KUInt _argumentsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _type = static_cast(type); + const auto __arguments = reinterpret_cast(_arguments); + const auto __argumentsSequenceLength = static_cast(_argumentsSequenceLength); + auto result = GetImpl()->UpdateETSIntrinsicNode2(_context, _original, _type, __arguments, __argumentsSequenceLength); + return result; +} +KOALA_INTEROP_5(UpdateETSIntrinsicNode2, KNativePointer, KNativePointer, KNativePointer, KInt, KNativePointerArray, KUInt); + +KInt impl_ETSIntrinsicNodeTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSIntrinsicNodeTypeConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSIntrinsicNodeTypeConst, KInt, KNativePointer, KNativePointer); + +KNativePointer impl_ETSIntrinsicNodeArgumentsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ETSIntrinsicNodeArgumentsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ETSIntrinsicNodeArgumentsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSPackageDeclaration(KNativePointer context, KNativePointer name) +{ + const auto _context = reinterpret_cast(context); + const auto _name = reinterpret_cast(name); + auto result = GetImpl()->CreateETSPackageDeclaration(_context, _name); + return result; +} +KOALA_INTEROP_2(CreateETSPackageDeclaration, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSPackageDeclaration(KNativePointer context, KNativePointer original, KNativePointer name) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _name = reinterpret_cast(name); + auto result = GetImpl()->UpdateETSPackageDeclaration(_context, _original, _name); + return result; +} +KOALA_INTEROP_3(UpdateETSPackageDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSImportDeclaration(KNativePointer context, KNativePointer importPath, KNativePointerArray specifiers, KUInt specifiersSequenceLength, KInt importKinds) +{ + const auto _context = reinterpret_cast(context); + const auto _importPath = reinterpret_cast(importPath); + const auto _specifiers = reinterpret_cast(specifiers); + const auto _specifiersSequenceLength = static_cast(specifiersSequenceLength); + const auto _importKinds = static_cast(importKinds); + auto result = GetImpl()->CreateETSImportDeclaration(_context, _importPath, _specifiers, _specifiersSequenceLength, _importKinds); + return result; +} +KOALA_INTEROP_5(CreateETSImportDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KInt); + +KNativePointer impl_UpdateETSImportDeclaration(KNativePointer context, KNativePointer original, KNativePointer importPath, KNativePointerArray specifiers, KUInt specifiersSequenceLength, KInt importKinds) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _importPath = reinterpret_cast(importPath); + const auto _specifiers = reinterpret_cast(specifiers); + const auto _specifiersSequenceLength = static_cast(specifiersSequenceLength); + const auto _importKinds = static_cast(importKinds); + auto result = GetImpl()->UpdateETSImportDeclaration(_context, _original, _importPath, _specifiers, _specifiersSequenceLength, _importKinds); + return result; +} +KOALA_INTEROP_6(UpdateETSImportDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KInt); + +void impl_ETSImportDeclarationSetImportMetadata(KNativePointer context, KNativePointer receiver, KInt importFlags, KInt lang, KStringPtr& resolvedSource, KStringPtr& declPath, KStringPtr& ohmUrl) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _importFlags = static_cast(importFlags); + const auto _lang = static_cast(lang); + const auto _resolvedSource = getStringCopy(resolvedSource); + const auto _declPath = getStringCopy(declPath); + const auto _ohmUrl = getStringCopy(ohmUrl); + GetImpl()->ETSImportDeclarationSetImportMetadata(_context, _receiver, _importFlags, _lang, _resolvedSource, _declPath, _ohmUrl); + return ; +} +KOALA_INTEROP_V7(ETSImportDeclarationSetImportMetadata, KNativePointer, KNativePointer, KInt, KInt, KStringPtr, KStringPtr, KStringPtr); + +KNativePointer impl_ETSImportDeclarationDeclPathConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSImportDeclarationDeclPathConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ETSImportDeclarationDeclPathConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSImportDeclarationOhmUrlConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSImportDeclarationOhmUrlConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ETSImportDeclarationOhmUrlConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ETSImportDeclarationIsValidConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSImportDeclarationIsValidConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSImportDeclarationIsValidConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ETSImportDeclarationIsPureDynamicConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSImportDeclarationIsPureDynamicConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSImportDeclarationIsPureDynamicConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ETSImportDeclarationSetAssemblerName(KNativePointer context, KNativePointer receiver, KStringPtr& assemblerName) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _assemblerName = getStringCopy(assemblerName); + GetImpl()->ETSImportDeclarationSetAssemblerName(_context, _receiver, _assemblerName); + return ; +} +KOALA_INTEROP_V3(ETSImportDeclarationSetAssemblerName, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_ETSImportDeclarationAssemblerNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSImportDeclarationAssemblerNameConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ETSImportDeclarationAssemblerNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSImportDeclarationResolvedSourceConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSImportDeclarationResolvedSourceConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ETSImportDeclarationResolvedSourceConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSStructDeclaration(KNativePointer context, KNativePointer def) +{ + const auto _context = reinterpret_cast(context); + const auto _def = reinterpret_cast(def); + auto result = GetImpl()->CreateETSStructDeclaration(_context, _def); + return result; +} +KOALA_INTEROP_2(CreateETSStructDeclaration, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSStructDeclaration(KNativePointer context, KNativePointer original, KNativePointer def) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _def = reinterpret_cast(def); + auto result = GetImpl()->UpdateETSStructDeclaration(_context, _original, _def); + return result; +} +KOALA_INTEROP_3(UpdateETSStructDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSModuleBlock(KNativePointer context, KNativePointerArray statements, KUInt statementsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _statements = reinterpret_cast(statements); + const auto _statementsSequenceLength = static_cast(statementsSequenceLength); + auto result = GetImpl()->CreateTSModuleBlock(_context, _statements, _statementsSequenceLength); + return result; +} +KOALA_INTEROP_3(CreateTSModuleBlock, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateTSModuleBlock(KNativePointer context, KNativePointer original, KNativePointerArray statements, KUInt statementsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _statements = reinterpret_cast(statements); + const auto _statementsSequenceLength = static_cast(statementsSequenceLength); + auto result = GetImpl()->UpdateTSModuleBlock(_context, _original, _statements, _statementsSequenceLength); + return result; +} +KOALA_INTEROP_4(UpdateTSModuleBlock, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_TSModuleBlockStatementsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSModuleBlockStatementsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSModuleBlockStatementsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSNewArrayInstanceExpression(KNativePointer context, KNativePointer typeReference, KNativePointer dimension) +{ + const auto _context = reinterpret_cast(context); + const auto _typeReference = reinterpret_cast(typeReference); + const auto _dimension = reinterpret_cast(dimension); + auto result = GetImpl()->CreateETSNewArrayInstanceExpression(_context, _typeReference, _dimension); + return result; +} +KOALA_INTEROP_3(CreateETSNewArrayInstanceExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSNewArrayInstanceExpression(KNativePointer context, KNativePointer original, KNativePointer typeReference, KNativePointer dimension) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _typeReference = reinterpret_cast(typeReference); + const auto _dimension = reinterpret_cast(dimension); + auto result = GetImpl()->UpdateETSNewArrayInstanceExpression(_context, _original, _typeReference, _dimension); + return result; +} +KOALA_INTEROP_4(UpdateETSNewArrayInstanceExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSNewArrayInstanceExpressionTypeReference(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSNewArrayInstanceExpressionTypeReference(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSNewArrayInstanceExpressionTypeReference, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSNewArrayInstanceExpressionTypeReferenceConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSNewArrayInstanceExpressionTypeReferenceConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSNewArrayInstanceExpressionTypeReferenceConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSNewArrayInstanceExpressionDimension(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSNewArrayInstanceExpressionDimension(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSNewArrayInstanceExpressionDimension, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSNewArrayInstanceExpressionDimensionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSNewArrayInstanceExpressionDimensionConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSNewArrayInstanceExpressionDimensionConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ETSNewArrayInstanceExpressionSetDimension(KNativePointer context, KNativePointer receiver, KNativePointer dimension) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _dimension = reinterpret_cast(dimension); + GetImpl()->ETSNewArrayInstanceExpressionSetDimension(_context, _receiver, _dimension); + return ; +} +KOALA_INTEROP_V3(ETSNewArrayInstanceExpressionSetDimension, KNativePointer, KNativePointer, KNativePointer); + +void impl_ETSNewArrayInstanceExpressionClearPreferredType(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ETSNewArrayInstanceExpressionClearPreferredType(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ETSNewArrayInstanceExpressionClearPreferredType, KNativePointer, KNativePointer); + +KNativePointer impl_CreateAnnotationDeclaration(KNativePointer context, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->CreateAnnotationDeclaration(_context, _expr); + return result; +} +KOALA_INTEROP_2(CreateAnnotationDeclaration, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateAnnotationDeclaration(KNativePointer context, KNativePointer original, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->UpdateAnnotationDeclaration(_context, _original, _expr); + return result; +} +KOALA_INTEROP_3(UpdateAnnotationDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateAnnotationDeclaration1(KNativePointer context, KNativePointer expr, KNativePointerArray properties, KUInt propertiesSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _expr = reinterpret_cast(expr); + const auto _properties = reinterpret_cast(properties); + const auto _propertiesSequenceLength = static_cast(propertiesSequenceLength); + auto result = GetImpl()->CreateAnnotationDeclaration1(_context, _expr, _properties, _propertiesSequenceLength); + return result; +} +KOALA_INTEROP_4(CreateAnnotationDeclaration1, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateAnnotationDeclaration1(KNativePointer context, KNativePointer original, KNativePointer expr, KNativePointerArray properties, KUInt propertiesSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _expr = reinterpret_cast(expr); + const auto _properties = reinterpret_cast(properties); + const auto _propertiesSequenceLength = static_cast(propertiesSequenceLength); + auto result = GetImpl()->UpdateAnnotationDeclaration1(_context, _original, _expr, _properties, _propertiesSequenceLength); + return result; +} +KOALA_INTEROP_5(UpdateAnnotationDeclaration1, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_AnnotationDeclarationInternalNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AnnotationDeclarationInternalNameConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(AnnotationDeclarationInternalNameConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_AnnotationDeclarationSetInternalName(KNativePointer context, KNativePointer receiver, KStringPtr& internalName) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _internalName = getStringCopy(internalName); + GetImpl()->AnnotationDeclarationSetInternalName(_context, _receiver, _internalName); + return ; +} +KOALA_INTEROP_V3(AnnotationDeclarationSetInternalName, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_AnnotationDeclarationExprConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AnnotationDeclarationExprConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AnnotationDeclarationExprConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AnnotationDeclarationExpr(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AnnotationDeclarationExpr(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AnnotationDeclarationExpr, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AnnotationDeclarationProperties(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->AnnotationDeclarationProperties(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(AnnotationDeclarationProperties, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AnnotationDeclarationPropertiesForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->AnnotationDeclarationPropertiesForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(AnnotationDeclarationPropertiesForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AnnotationDeclarationPropertiesConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->AnnotationDeclarationPropertiesConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(AnnotationDeclarationPropertiesConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_AnnotationDeclarationAddProperties(KNativePointer context, KNativePointer receiver, KNativePointerArray properties, KUInt propertiesSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _properties = reinterpret_cast(properties); + const auto _propertiesSequenceLength = static_cast(propertiesSequenceLength); + GetImpl()->AnnotationDeclarationAddProperties(_context, _receiver, _properties, _propertiesSequenceLength); + return ; +} +KOALA_INTEROP_V4(AnnotationDeclarationAddProperties, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KBoolean impl_AnnotationDeclarationIsSourceRetentionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AnnotationDeclarationIsSourceRetentionConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AnnotationDeclarationIsSourceRetentionConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AnnotationDeclarationIsBytecodeRetentionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AnnotationDeclarationIsBytecodeRetentionConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AnnotationDeclarationIsBytecodeRetentionConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_AnnotationDeclarationIsRuntimeRetentionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AnnotationDeclarationIsRuntimeRetentionConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AnnotationDeclarationIsRuntimeRetentionConst, KBoolean, KNativePointer, KNativePointer); + +void impl_AnnotationDeclarationSetSourceRetention(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->AnnotationDeclarationSetSourceRetention(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(AnnotationDeclarationSetSourceRetention, KNativePointer, KNativePointer); + +void impl_AnnotationDeclarationSetBytecodeRetention(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->AnnotationDeclarationSetBytecodeRetention(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(AnnotationDeclarationSetBytecodeRetention, KNativePointer, KNativePointer); + +void impl_AnnotationDeclarationSetRuntimeRetention(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->AnnotationDeclarationSetRuntimeRetention(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(AnnotationDeclarationSetRuntimeRetention, KNativePointer, KNativePointer); + +KNativePointer impl_AnnotationDeclarationGetBaseNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AnnotationDeclarationGetBaseNameConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AnnotationDeclarationGetBaseNameConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_AnnotationDeclarationEmplaceProperties(KNativePointer context, KNativePointer receiver, KNativePointer properties) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _properties = reinterpret_cast(properties); + GetImpl()->AnnotationDeclarationEmplaceProperties(_context, _receiver, _properties); + return ; +} +KOALA_INTEROP_V3(AnnotationDeclarationEmplaceProperties, KNativePointer, KNativePointer, KNativePointer); + +void impl_AnnotationDeclarationClearProperties(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->AnnotationDeclarationClearProperties(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(AnnotationDeclarationClearProperties, KNativePointer, KNativePointer); + +void impl_AnnotationDeclarationSetValueProperties(KNativePointer context, KNativePointer receiver, KNativePointer properties, KUInt index) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _properties = reinterpret_cast(properties); + const auto _index = static_cast(index); + GetImpl()->AnnotationDeclarationSetValueProperties(_context, _receiver, _properties, _index); + return ; +} +KOALA_INTEROP_V4(AnnotationDeclarationSetValueProperties, KNativePointer, KNativePointer, KNativePointer, KUInt); + +KBoolean impl_AnnotationDeclarationHasAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AnnotationDeclarationHasAnnotationsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AnnotationDeclarationHasAnnotationsConst, KBoolean, KNativePointer, KNativePointer); + +void impl_AnnotationDeclarationEmplaceAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer source) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + GetImpl()->AnnotationDeclarationEmplaceAnnotation(_context, _receiver, _source); + return ; +} +KOALA_INTEROP_V3(AnnotationDeclarationEmplaceAnnotation, KNativePointer, KNativePointer, KNativePointer); + +void impl_AnnotationDeclarationClearAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->AnnotationDeclarationClearAnnotations(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(AnnotationDeclarationClearAnnotations, KNativePointer, KNativePointer); + +void impl_AnnotationDeclarationDumpAnnotationsConst(KNativePointer context, KNativePointer receiver, KNativePointer dumper) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _dumper = reinterpret_cast(dumper); + GetImpl()->AnnotationDeclarationDumpAnnotationsConst(_context, _receiver, _dumper); + return ; +} +KOALA_INTEROP_V3(AnnotationDeclarationDumpAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AnnotationDeclarationAnnotationsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->AnnotationDeclarationAnnotationsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(AnnotationDeclarationAnnotationsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AnnotationDeclarationAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->AnnotationDeclarationAnnotations(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(AnnotationDeclarationAnnotations, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AnnotationDeclarationAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->AnnotationDeclarationAnnotationsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(AnnotationDeclarationAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_AnnotationDeclarationSetAnnotations(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->AnnotationDeclarationSetAnnotations(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(AnnotationDeclarationSetAnnotations, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_AnnotationDeclarationSetAnnotations1(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->AnnotationDeclarationSetAnnotations1(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(AnnotationDeclarationSetAnnotations1, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateAnnotationUsage(KNativePointer context, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->CreateAnnotationUsageIr(_context, _expr); + return result; +} +KOALA_INTEROP_2(CreateAnnotationUsage, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateAnnotationUsage(KNativePointer context, KNativePointer original, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->UpdateAnnotationUsageIr(_context, _original, _expr); + return result; +} +KOALA_INTEROP_3(UpdateAnnotationUsage, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateAnnotationUsage1(KNativePointer context, KNativePointer expr, KNativePointerArray properties, KUInt propertiesSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _expr = reinterpret_cast(expr); + const auto _properties = reinterpret_cast(properties); + const auto _propertiesSequenceLength = static_cast(propertiesSequenceLength); + auto result = GetImpl()->CreateAnnotationUsageIr1(_context, _expr, _properties, _propertiesSequenceLength); + return result; +} +KOALA_INTEROP_4(CreateAnnotationUsage1, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateAnnotationUsage1(KNativePointer context, KNativePointer original, KNativePointer expr, KNativePointerArray properties, KUInt propertiesSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _expr = reinterpret_cast(expr); + const auto _properties = reinterpret_cast(properties); + const auto _propertiesSequenceLength = static_cast(propertiesSequenceLength); + auto result = GetImpl()->UpdateAnnotationUsageIr1(_context, _original, _expr, _properties, _propertiesSequenceLength); + return result; +} +KOALA_INTEROP_5(UpdateAnnotationUsage1, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_AnnotationUsageExpr(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AnnotationUsageIrExpr(_context, _receiver); + return result; +} +KOALA_INTEROP_2(AnnotationUsageExpr, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AnnotationUsageProperties(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->AnnotationUsageIrProperties(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(AnnotationUsageProperties, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AnnotationUsagePropertiesConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->AnnotationUsageIrPropertiesConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(AnnotationUsagePropertiesConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_AnnotationUsageAddProperty(KNativePointer context, KNativePointer receiver, KNativePointer property) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _property = reinterpret_cast(property); + GetImpl()->AnnotationUsageIrAddProperty(_context, _receiver, _property); + return ; +} +KOALA_INTEROP_V3(AnnotationUsageAddProperty, KNativePointer, KNativePointer, KNativePointer); + +void impl_AnnotationUsageSetProperties(KNativePointer context, KNativePointer receiver, KNativePointerArray properties, KUInt propertiesSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _properties = reinterpret_cast(properties); + const auto _propertiesSequenceLength = static_cast(propertiesSequenceLength); + GetImpl()->AnnotationUsageIrSetProperties(_context, _receiver, _properties, _propertiesSequenceLength); + return ; +} +KOALA_INTEROP_V4(AnnotationUsageSetProperties, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_AnnotationUsageGetBaseNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AnnotationUsageIrGetBaseNameConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AnnotationUsageGetBaseNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateEmptyStatement(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateEmptyStatement(_context); + return result; +} +KOALA_INTEROP_1(CreateEmptyStatement, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateEmptyStatement(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateEmptyStatement(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateEmptyStatement, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateEmptyStatement1(KNativePointer context, KBoolean isBrokenStatement) +{ + const auto _context = reinterpret_cast(context); + const auto _isBrokenStatement = static_cast(isBrokenStatement); + auto result = GetImpl()->CreateEmptyStatement1(_context, _isBrokenStatement); + return result; +} +KOALA_INTEROP_2(CreateEmptyStatement1, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_UpdateEmptyStatement1(KNativePointer context, KNativePointer original, KBoolean isBrokenStatement) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _isBrokenStatement = static_cast(isBrokenStatement); + auto result = GetImpl()->UpdateEmptyStatement1(_context, _original, _isBrokenStatement); + return result; +} +KOALA_INTEROP_3(UpdateEmptyStatement1, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KBoolean impl_EmptyStatementIsBrokenStatement(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->EmptyStatementIsBrokenStatement(_context, _receiver); + return result; +} +KOALA_INTEROP_2(EmptyStatementIsBrokenStatement, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateWhileStatement(KNativePointer context, KNativePointer test, KNativePointer body) +{ + const auto _context = reinterpret_cast(context); + const auto _test = reinterpret_cast(test); + const auto _body = reinterpret_cast(body); + auto result = GetImpl()->CreateWhileStatement(_context, _test, _body); + return result; +} +KOALA_INTEROP_3(CreateWhileStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateWhileStatement(KNativePointer context, KNativePointer original, KNativePointer test, KNativePointer body) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _test = reinterpret_cast(test); + const auto _body = reinterpret_cast(body); + auto result = GetImpl()->UpdateWhileStatement(_context, _original, _test, _body); + return result; +} +KOALA_INTEROP_4(UpdateWhileStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_WhileStatementTestConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->WhileStatementTestConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(WhileStatementTestConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_WhileStatementTest(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->WhileStatementTest(_context, _receiver); + return result; +} +KOALA_INTEROP_2(WhileStatementTest, KNativePointer, KNativePointer, KNativePointer); + +void impl_WhileStatementSetTest(KNativePointer context, KNativePointer receiver, KNativePointer test) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _test = reinterpret_cast(test); + GetImpl()->WhileStatementSetTest(_context, _receiver, _test); + return ; +} +KOALA_INTEROP_V3(WhileStatementSetTest, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_WhileStatementBodyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->WhileStatementBodyConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(WhileStatementBodyConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_WhileStatementBody(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->WhileStatementBody(_context, _receiver); + return result; +} +KOALA_INTEROP_2(WhileStatementBody, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateFunctionSignature(KNativePointer context, KNativePointer typeParams, KNativePointerArray params, KUInt paramsSequenceLength, KNativePointer returnTypeAnnotation, KBoolean hasReceiver) +{ + const auto _context = reinterpret_cast(context); + const auto _typeParams = reinterpret_cast(typeParams); + const auto _params = reinterpret_cast(params); + const auto _paramsSequenceLength = static_cast(paramsSequenceLength); + const auto _returnTypeAnnotation = reinterpret_cast(returnTypeAnnotation); + const auto _hasReceiver = static_cast(hasReceiver); + auto result = GetImpl()->CreateFunctionSignature(_context, _typeParams, _params, _paramsSequenceLength, _returnTypeAnnotation, _hasReceiver); + return result; +} +KOALA_INTEROP_6(CreateFunctionSignature, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KNativePointer, KBoolean); + +KNativePointer impl_FunctionSignatureParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->FunctionSignatureParamsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(FunctionSignatureParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_FunctionSignatureParams(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->FunctionSignatureParams(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(FunctionSignatureParams, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_FunctionSignatureTypeParams(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->FunctionSignatureTypeParams(_context, _receiver); + return result; +} +KOALA_INTEROP_2(FunctionSignatureTypeParams, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_FunctionSignatureTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->FunctionSignatureTypeParamsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(FunctionSignatureTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_FunctionSignatureReturnType(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->FunctionSignatureReturnType(_context, _receiver); + return result; +} +KOALA_INTEROP_2(FunctionSignatureReturnType, KNativePointer, KNativePointer, KNativePointer); + +void impl_FunctionSignatureSetReturnType(KNativePointer context, KNativePointer receiver, KNativePointer type) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _type = reinterpret_cast(type); + GetImpl()->FunctionSignatureSetReturnType(_context, _receiver, _type); + return ; +} +KOALA_INTEROP_V3(FunctionSignatureSetReturnType, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_FunctionSignatureReturnTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->FunctionSignatureReturnTypeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(FunctionSignatureReturnTypeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_FunctionSignatureClone(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->FunctionSignatureClone(_context, _receiver); + return result; +} +KOALA_INTEROP_2(FunctionSignatureClone, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_FunctionSignatureHasReceiverConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->FunctionSignatureHasReceiverConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(FunctionSignatureHasReceiverConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateChainExpression(KNativePointer context, KNativePointer expression) +{ + const auto _context = reinterpret_cast(context); + const auto _expression = reinterpret_cast(expression); + auto result = GetImpl()->CreateChainExpression(_context, _expression); + return result; +} +KOALA_INTEROP_2(CreateChainExpression, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateChainExpression(KNativePointer context, KNativePointer original, KNativePointer expression) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _expression = reinterpret_cast(expression); + auto result = GetImpl()->UpdateChainExpression(_context, _original, _expression); + return result; +} +KOALA_INTEROP_3(UpdateChainExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ChainExpressionGetExpressionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ChainExpressionGetExpressionConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ChainExpressionGetExpressionConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ChainExpressionGetExpression(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ChainExpressionGetExpression(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ChainExpressionGetExpression, KNativePointer, KNativePointer, KNativePointer); + +void impl_ChainExpressionCompileToRegConst(KNativePointer context, KNativePointer receiver, KNativePointer pg, KNativePointer objReg) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _pg = reinterpret_cast(pg); + const auto _objReg = reinterpret_cast(objReg); + GetImpl()->ChainExpressionCompileToRegConst(_context, _receiver, _pg, _objReg); + return ; +} +KOALA_INTEROP_V4(ChainExpressionCompileToRegConst, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSIntersectionType(KNativePointer context, KNativePointerArray types, KUInt typesSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _types = reinterpret_cast(types); + const auto _typesSequenceLength = static_cast(typesSequenceLength); + auto result = GetImpl()->CreateTSIntersectionType(_context, _types, _typesSequenceLength); + return result; +} +KOALA_INTEROP_3(CreateTSIntersectionType, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateTSIntersectionType(KNativePointer context, KNativePointer original, KNativePointerArray types, KUInt typesSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _types = reinterpret_cast(types); + const auto _typesSequenceLength = static_cast(typesSequenceLength); + auto result = GetImpl()->UpdateTSIntersectionType(_context, _original, _types, _typesSequenceLength); + return result; +} +KOALA_INTEROP_4(UpdateTSIntersectionType, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_TSIntersectionTypeTypesConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSIntersectionTypeTypesConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSIntersectionTypeTypesConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateUpdateExpression(KNativePointer context, KNativePointer argument, KInt updateOperator, KBoolean isPrefix) +{ + const auto _context = reinterpret_cast(context); + const auto _argument = reinterpret_cast(argument); + const auto _updateOperator = static_cast(updateOperator); + const auto _isPrefix = static_cast(isPrefix); + auto result = GetImpl()->CreateUpdateExpression(_context, _argument, _updateOperator, _isPrefix); + return result; +} +KOALA_INTEROP_4(CreateUpdateExpression, KNativePointer, KNativePointer, KNativePointer, KInt, KBoolean); + +KNativePointer impl_UpdateUpdateExpression(KNativePointer context, KNativePointer original, KNativePointer argument, KInt updateOperator, KBoolean isPrefix) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _argument = reinterpret_cast(argument); + const auto _updateOperator = static_cast(updateOperator); + const auto _isPrefix = static_cast(isPrefix); + auto result = GetImpl()->UpdateUpdateExpression(_context, _original, _argument, _updateOperator, _isPrefix); + return result; +} +KOALA_INTEROP_5(UpdateUpdateExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KBoolean); + +KInt impl_UpdateExpressionOperatorTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->UpdateExpressionOperatorTypeConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(UpdateExpressionOperatorTypeConst, KInt, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateExpressionArgument(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->UpdateExpressionArgument(_context, _receiver); + return result; +} +KOALA_INTEROP_2(UpdateExpressionArgument, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateExpressionArgumentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->UpdateExpressionArgumentConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(UpdateExpressionArgumentConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_UpdateExpressionIsPrefixConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->UpdateExpressionIsPrefixConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(UpdateExpressionIsPrefixConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateBlockExpression(KNativePointer context, KNativePointerArray statements, KUInt statementsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _statements = reinterpret_cast(statements); + const auto _statementsSequenceLength = static_cast(statementsSequenceLength); + auto result = GetImpl()->CreateBlockExpression(_context, _statements, _statementsSequenceLength); + return result; +} +KOALA_INTEROP_3(CreateBlockExpression, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateBlockExpression(KNativePointer context, KNativePointer original, KNativePointerArray statements, KUInt statementsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _statements = reinterpret_cast(statements); + const auto _statementsSequenceLength = static_cast(statementsSequenceLength); + auto result = GetImpl()->UpdateBlockExpression(_context, _original, _statements, _statementsSequenceLength); + return result; +} +KOALA_INTEROP_4(UpdateBlockExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_BlockExpressionStatementsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->BlockExpressionStatementsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(BlockExpressionStatementsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_BlockExpressionStatements(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->BlockExpressionStatements(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(BlockExpressionStatements, KNativePointer, KNativePointer, KNativePointer); + +void impl_BlockExpressionAddStatements(KNativePointer context, KNativePointer receiver, KNativePointerArray statements, KUInt statementsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _statements = reinterpret_cast(statements); + const auto _statementsSequenceLength = static_cast(statementsSequenceLength); + GetImpl()->BlockExpressionAddStatements(_context, _receiver, _statements, _statementsSequenceLength); + return ; +} +KOALA_INTEROP_V4(BlockExpressionAddStatements, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_BlockExpressionAddStatement(KNativePointer context, KNativePointer receiver, KNativePointer statement) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _statement = reinterpret_cast(statement); + GetImpl()->BlockExpressionAddStatement(_context, _receiver, _statement); + return ; +} +KOALA_INTEROP_V3(BlockExpressionAddStatement, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSTypeLiteral(KNativePointer context, KNativePointerArray members, KUInt membersSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _members = reinterpret_cast(members); + const auto _membersSequenceLength = static_cast(membersSequenceLength); + auto result = GetImpl()->CreateTSTypeLiteral(_context, _members, _membersSequenceLength); + return result; +} +KOALA_INTEROP_3(CreateTSTypeLiteral, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateTSTypeLiteral(KNativePointer context, KNativePointer original, KNativePointerArray members, KUInt membersSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _members = reinterpret_cast(members); + const auto _membersSequenceLength = static_cast(membersSequenceLength); + auto result = GetImpl()->UpdateTSTypeLiteral(_context, _original, _members, _membersSequenceLength); + return result; +} +KOALA_INTEROP_4(UpdateTSTypeLiteral, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_TSTypeLiteralMembersConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSTypeLiteralMembersConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSTypeLiteralMembersConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSTypeParameter(KNativePointer context, KNativePointer name, KNativePointer constraint, KNativePointer defaultType) +{ + const auto _context = reinterpret_cast(context); + const auto _name = reinterpret_cast(name); + const auto _constraint = reinterpret_cast(constraint); + const auto _defaultType = reinterpret_cast(defaultType); + auto result = GetImpl()->CreateTSTypeParameter(_context, _name, _constraint, _defaultType); + return result; +} +KOALA_INTEROP_4(CreateTSTypeParameter, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSTypeParameter(KNativePointer context, KNativePointer original, KNativePointer name, KNativePointer constraint, KNativePointer defaultType) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _name = reinterpret_cast(name); + const auto _constraint = reinterpret_cast(constraint); + const auto _defaultType = reinterpret_cast(defaultType); + auto result = GetImpl()->UpdateTSTypeParameter(_context, _original, _name, _constraint, _defaultType); + return result; +} +KOALA_INTEROP_5(UpdateTSTypeParameter, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSTypeParameter1(KNativePointer context, KNativePointer name, KNativePointer constraint, KNativePointer defaultType, KInt flags) +{ + const auto _context = reinterpret_cast(context); + const auto _name = reinterpret_cast(name); + const auto _constraint = reinterpret_cast(constraint); + const auto _defaultType = reinterpret_cast(defaultType); + const auto _flags = static_cast(flags); + auto result = GetImpl()->CreateTSTypeParameter1(_context, _name, _constraint, _defaultType, _flags); + return result; +} +KOALA_INTEROP_5(CreateTSTypeParameter1, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_UpdateTSTypeParameter1(KNativePointer context, KNativePointer original, KNativePointer name, KNativePointer constraint, KNativePointer defaultType, KInt flags) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _name = reinterpret_cast(name); + const auto _constraint = reinterpret_cast(constraint); + const auto _defaultType = reinterpret_cast(defaultType); + const auto _flags = static_cast(flags); + auto result = GetImpl()->UpdateTSTypeParameter1(_context, _original, _name, _constraint, _defaultType, _flags); + return result; +} +KOALA_INTEROP_6(UpdateTSTypeParameter1, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_TSTypeParameterNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeParameterNameConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSTypeParameterNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeParameterName(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeParameterName(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSTypeParameterName, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeParameterConstraint(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeParameterConstraint(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSTypeParameterConstraint, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeParameterConstraintConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeParameterConstraintConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSTypeParameterConstraintConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSTypeParameterSetConstraint(KNativePointer context, KNativePointer receiver, KNativePointer constraint) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _constraint = reinterpret_cast(constraint); + GetImpl()->TSTypeParameterSetConstraint(_context, _receiver, _constraint); + return ; +} +KOALA_INTEROP_V3(TSTypeParameterSetConstraint, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeParameterDefaultTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeParameterDefaultTypeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSTypeParameterDefaultTypeConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSTypeParameterSetDefaultType(KNativePointer context, KNativePointer receiver, KNativePointer defaultType) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _defaultType = reinterpret_cast(defaultType); + GetImpl()->TSTypeParameterSetDefaultType(_context, _receiver, _defaultType); + return ; +} +KOALA_INTEROP_V3(TSTypeParameterSetDefaultType, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_TSTypeParameterHasAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeParameterHasAnnotationsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSTypeParameterHasAnnotationsConst, KBoolean, KNativePointer, KNativePointer); + +void impl_TSTypeParameterEmplaceAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer source) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + GetImpl()->TSTypeParameterEmplaceAnnotation(_context, _receiver, _source); + return ; +} +KOALA_INTEROP_V3(TSTypeParameterEmplaceAnnotation, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSTypeParameterClearAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->TSTypeParameterClearAnnotations(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(TSTypeParameterClearAnnotations, KNativePointer, KNativePointer); + +void impl_TSTypeParameterDumpAnnotationsConst(KNativePointer context, KNativePointer receiver, KNativePointer dumper) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _dumper = reinterpret_cast(dumper); + GetImpl()->TSTypeParameterDumpAnnotationsConst(_context, _receiver, _dumper); + return ; +} +KOALA_INTEROP_V3(TSTypeParameterDumpAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeParameterAnnotationsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSTypeParameterAnnotationsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSTypeParameterAnnotationsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeParameterAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSTypeParameterAnnotations(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSTypeParameterAnnotations, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypeParameterAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSTypeParameterAnnotationsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSTypeParameterAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSTypeParameterSetAnnotations(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->TSTypeParameterSetAnnotations(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(TSTypeParameterSetAnnotations, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_TSTypeParameterSetAnnotations1(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->TSTypeParameterSetAnnotations1(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(TSTypeParameterSetAnnotations1, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateTSBooleanKeyword(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateTSBooleanKeyword(_context); + return result; +} +KOALA_INTEROP_1(CreateTSBooleanKeyword, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSBooleanKeyword(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateTSBooleanKeyword(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateTSBooleanKeyword, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateSpreadElement(KNativePointer context, KInt nodeType, KNativePointer argument) +{ + const auto _context = reinterpret_cast(context); + const auto _nodeType = static_cast(nodeType); + const auto _argument = reinterpret_cast(argument); + auto result = GetImpl()->CreateSpreadElement(_context, _nodeType, _argument); + return result; +} +KOALA_INTEROP_3(CreateSpreadElement, KNativePointer, KNativePointer, KInt, KNativePointer); + +KNativePointer impl_UpdateSpreadElement(KNativePointer context, KNativePointer original, KInt nodeType, KNativePointer argument) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _nodeType = static_cast(nodeType); + const auto _argument = reinterpret_cast(argument); + auto result = GetImpl()->UpdateSpreadElement(_context, _original, _nodeType, _argument); + return result; +} +KOALA_INTEROP_4(UpdateSpreadElement, KNativePointer, KNativePointer, KNativePointer, KInt, KNativePointer); + +KNativePointer impl_SpreadElementArgumentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->SpreadElementArgumentConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(SpreadElementArgumentConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_SpreadElementArgument(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->SpreadElementArgument(_context, _receiver); + return result; +} +KOALA_INTEROP_2(SpreadElementArgument, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_SpreadElementIsOptionalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->SpreadElementIsOptionalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(SpreadElementIsOptionalConst, KBoolean, KNativePointer, KNativePointer); + +void impl_SpreadElementSetOptional(KNativePointer context, KNativePointer receiver, KBoolean optional_arg) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _optional_arg = static_cast(optional_arg); + GetImpl()->SpreadElementSetOptional(_context, _receiver, _optional_arg); + return ; +} +KOALA_INTEROP_V3(SpreadElementSetOptional, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_SpreadElementValidateExpression(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->SpreadElementValidateExpression(_context, _receiver); + return result; +} +KOALA_INTEROP_2(SpreadElementValidateExpression, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_SpreadElementConvertibleToRest(KNativePointer context, KNativePointer receiver, KBoolean isDeclaration, KBoolean allowPattern) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _isDeclaration = static_cast(isDeclaration); + const auto _allowPattern = static_cast(allowPattern); + auto result = GetImpl()->SpreadElementConvertibleToRest(_context, _receiver, _isDeclaration, _allowPattern); + return result; +} +KOALA_INTEROP_4(SpreadElementConvertibleToRest, KBoolean, KNativePointer, KNativePointer, KBoolean, KBoolean); + +KNativePointer impl_SpreadElementTypeAnnotationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->SpreadElementTypeAnnotationConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(SpreadElementTypeAnnotationConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_SpreadElementSetTsTypeAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer typeAnnotation) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + GetImpl()->SpreadElementSetTsTypeAnnotation(_context, _receiver, _typeAnnotation); + return ; +} +KOALA_INTEROP_V3(SpreadElementSetTsTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSTypePredicate(KNativePointer context, KNativePointer parameterName, KNativePointer typeAnnotation, KBoolean asserts) +{ + const auto _context = reinterpret_cast(context); + const auto _parameterName = reinterpret_cast(parameterName); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + const auto _asserts = static_cast(asserts); + auto result = GetImpl()->CreateTSTypePredicate(_context, _parameterName, _typeAnnotation, _asserts); + return result; +} +KOALA_INTEROP_4(CreateTSTypePredicate, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_UpdateTSTypePredicate(KNativePointer context, KNativePointer original, KNativePointer parameterName, KNativePointer typeAnnotation, KBoolean asserts) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _parameterName = reinterpret_cast(parameterName); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + const auto _asserts = static_cast(asserts); + auto result = GetImpl()->UpdateTSTypePredicate(_context, _original, _parameterName, _typeAnnotation, _asserts); + return result; +} +KOALA_INTEROP_5(UpdateTSTypePredicate, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_TSTypePredicateParameterNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypePredicateParameterNameConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSTypePredicateParameterNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSTypePredicateTypeAnnotationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypePredicateTypeAnnotationConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSTypePredicateTypeAnnotationConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_TSTypePredicateAssertsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypePredicateAssertsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSTypePredicateAssertsConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateImportNamespaceSpecifier(KNativePointer context, KNativePointer local) +{ + const auto _context = reinterpret_cast(context); + const auto _local = reinterpret_cast(local); + auto result = GetImpl()->CreateImportNamespaceSpecifier(_context, _local); + return result; +} +KOALA_INTEROP_2(CreateImportNamespaceSpecifier, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateImportNamespaceSpecifier(KNativePointer context, KNativePointer original, KNativePointer local) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _local = reinterpret_cast(local); + auto result = GetImpl()->UpdateImportNamespaceSpecifier(_context, _original, _local); + return result; +} +KOALA_INTEROP_3(UpdateImportNamespaceSpecifier, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ImportNamespaceSpecifierLocal(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ImportNamespaceSpecifierLocal(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ImportNamespaceSpecifierLocal, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ImportNamespaceSpecifierLocalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ImportNamespaceSpecifierLocalConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ImportNamespaceSpecifierLocalConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateExportNamedDeclaration(KNativePointer context, KNativePointer source, KNativePointerArray specifiers, KUInt specifiersSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _source = reinterpret_cast(source); + const auto _specifiers = reinterpret_cast(specifiers); + const auto _specifiersSequenceLength = static_cast(specifiersSequenceLength); + auto result = GetImpl()->CreateExportNamedDeclaration(_context, _source, _specifiers, _specifiersSequenceLength); + return result; +} +KOALA_INTEROP_4(CreateExportNamedDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateExportNamedDeclaration(KNativePointer context, KNativePointer original, KNativePointer source, KNativePointerArray specifiers, KUInt specifiersSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _source = reinterpret_cast(source); + const auto _specifiers = reinterpret_cast(specifiers); + const auto _specifiersSequenceLength = static_cast(specifiersSequenceLength); + auto result = GetImpl()->UpdateExportNamedDeclaration(_context, _original, _source, _specifiers, _specifiersSequenceLength); + return result; +} +KOALA_INTEROP_5(UpdateExportNamedDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateExportNamedDeclaration1(KNativePointer context, KNativePointer decl, KNativePointerArray specifiers, KUInt specifiersSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _decl = reinterpret_cast(decl); + const auto _specifiers = reinterpret_cast(specifiers); + const auto _specifiersSequenceLength = static_cast(specifiersSequenceLength); + auto result = GetImpl()->CreateExportNamedDeclaration1(_context, _decl, _specifiers, _specifiersSequenceLength); + return result; +} +KOALA_INTEROP_4(CreateExportNamedDeclaration1, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateExportNamedDeclaration1(KNativePointer context, KNativePointer original, KNativePointer decl, KNativePointerArray specifiers, KUInt specifiersSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _decl = reinterpret_cast(decl); + const auto _specifiers = reinterpret_cast(specifiers); + const auto _specifiersSequenceLength = static_cast(specifiersSequenceLength); + auto result = GetImpl()->UpdateExportNamedDeclaration1(_context, _original, _decl, _specifiers, _specifiersSequenceLength); + return result; +} +KOALA_INTEROP_5(UpdateExportNamedDeclaration1, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateExportNamedDeclaration2(KNativePointer context, KNativePointer decl) +{ + const auto _context = reinterpret_cast(context); + const auto _decl = reinterpret_cast(decl); + auto result = GetImpl()->CreateExportNamedDeclaration2(_context, _decl); + return result; +} +KOALA_INTEROP_2(CreateExportNamedDeclaration2, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateExportNamedDeclaration2(KNativePointer context, KNativePointer original, KNativePointer decl) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _decl = reinterpret_cast(decl); + auto result = GetImpl()->UpdateExportNamedDeclaration2(_context, _original, _decl); + return result; +} +KOALA_INTEROP_3(UpdateExportNamedDeclaration2, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ExportNamedDeclarationDeclConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExportNamedDeclarationDeclConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ExportNamedDeclarationDeclConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ExportNamedDeclarationSourceConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExportNamedDeclarationSourceConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ExportNamedDeclarationSourceConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ExportNamedDeclarationSpecifiersConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ExportNamedDeclarationSpecifiersConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ExportNamedDeclarationSpecifiersConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ExportNamedDeclarationReplaceSpecifiers(KNativePointer context, KNativePointer receiver, KNativePointerArray specifiers, KUInt specifiersSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _specifiers = reinterpret_cast(specifiers); + const auto _specifiersSequenceLength = static_cast(specifiersSequenceLength); + GetImpl()->ExportNamedDeclarationReplaceSpecifiers(_context, _receiver, _specifiers, _specifiersSequenceLength); + return ; +} +KOALA_INTEROP_V4(ExportNamedDeclarationReplaceSpecifiers, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateETSParameterExpression(KNativePointer context, KNativePointer identOrSpread, KBoolean isOptional) +{ + const auto _context = reinterpret_cast(context); + const auto _identOrSpread = reinterpret_cast(identOrSpread); + const auto _isOptional = static_cast(isOptional); + auto result = GetImpl()->CreateETSParameterExpression(_context, _identOrSpread, _isOptional); + return result; +} +KOALA_INTEROP_3(CreateETSParameterExpression, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_UpdateETSParameterExpression(KNativePointer context, KNativePointer original, KNativePointer identOrSpread, KBoolean isOptional) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _identOrSpread = reinterpret_cast(identOrSpread); + const auto _isOptional = static_cast(isOptional); + auto result = GetImpl()->UpdateETSParameterExpression(_context, _original, _identOrSpread, _isOptional); + return result; +} +KOALA_INTEROP_4(UpdateETSParameterExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_CreateETSParameterExpression1(KNativePointer context, KNativePointer identOrSpread, KNativePointer initializer) +{ + const auto _context = reinterpret_cast(context); + const auto _identOrSpread = reinterpret_cast(identOrSpread); + const auto _initializer = reinterpret_cast(initializer); + auto result = GetImpl()->CreateETSParameterExpression1(_context, _identOrSpread, _initializer); + return result; +} +KOALA_INTEROP_3(CreateETSParameterExpression1, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSParameterExpression1(KNativePointer context, KNativePointer original, KNativePointer identOrSpread, KNativePointer initializer) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _identOrSpread = reinterpret_cast(identOrSpread); + const auto _initializer = reinterpret_cast(initializer); + auto result = GetImpl()->UpdateETSParameterExpression1(_context, _original, _identOrSpread, _initializer); + return result; +} +KOALA_INTEROP_4(UpdateETSParameterExpression1, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSParameterExpressionNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSParameterExpressionNameConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ETSParameterExpressionNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSParameterExpressionIdentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSParameterExpressionIdentConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSParameterExpressionIdentConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSParameterExpressionIdent(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSParameterExpressionIdent(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSParameterExpressionIdent, KNativePointer, KNativePointer, KNativePointer); + +void impl_ETSParameterExpressionSetIdent(KNativePointer context, KNativePointer receiver, KNativePointer ident) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _ident = reinterpret_cast(ident); + GetImpl()->ETSParameterExpressionSetIdent(_context, _receiver, _ident); + return ; +} +KOALA_INTEROP_V3(ETSParameterExpressionSetIdent, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSParameterExpressionSpread(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSParameterExpressionSpread(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSParameterExpressionSpread, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSParameterExpressionSpreadConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSParameterExpressionSpreadConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSParameterExpressionSpreadConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ETSParameterExpressionSetSpread(KNativePointer context, KNativePointer receiver, KNativePointer spread) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _spread = reinterpret_cast(spread); + GetImpl()->ETSParameterExpressionSetSpread(_context, _receiver, _spread); + return ; +} +KOALA_INTEROP_V3(ETSParameterExpressionSetSpread, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSParameterExpressionRestParameterConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSParameterExpressionRestParameterConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSParameterExpressionRestParameterConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSParameterExpressionRestParameter(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSParameterExpressionRestParameter(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSParameterExpressionRestParameter, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSParameterExpressionInitializerConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSParameterExpressionInitializerConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSParameterExpressionInitializerConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSParameterExpressionInitializer(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSParameterExpressionInitializer(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSParameterExpressionInitializer, KNativePointer, KNativePointer, KNativePointer); + +void impl_ETSParameterExpressionSetLexerSaved(KNativePointer context, KNativePointer receiver, KStringPtr& savedLexer) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _savedLexer = getStringCopy(savedLexer); + GetImpl()->ETSParameterExpressionSetLexerSaved(_context, _receiver, _savedLexer); + return ; +} +KOALA_INTEROP_V3(ETSParameterExpressionSetLexerSaved, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_ETSParameterExpressionLexerSavedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSParameterExpressionLexerSavedConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ETSParameterExpressionLexerSavedConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSParameterExpressionTypeAnnotationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSParameterExpressionTypeAnnotationConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSParameterExpressionTypeAnnotationConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSParameterExpressionTypeAnnotation(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSParameterExpressionTypeAnnotation(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSParameterExpressionTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +void impl_ETSParameterExpressionSetTypeAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer typeNode) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _typeNode = reinterpret_cast(typeNode); + GetImpl()->ETSParameterExpressionSetTypeAnnotation(_context, _receiver, _typeNode); + return ; +} +KOALA_INTEROP_V3(ETSParameterExpressionSetTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ETSParameterExpressionIsOptionalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSParameterExpressionIsOptionalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSParameterExpressionIsOptionalConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ETSParameterExpressionSetOptional(KNativePointer context, KNativePointer receiver, KBoolean value) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _value = static_cast(value); + GetImpl()->ETSParameterExpressionSetOptional(_context, _receiver, _value); + return ; +} +KOALA_INTEROP_V3(ETSParameterExpressionSetOptional, KNativePointer, KNativePointer, KBoolean); + +void impl_ETSParameterExpressionSetInitializer(KNativePointer context, KNativePointer receiver, KNativePointer initExpr) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _initExpr = reinterpret_cast(initExpr); + GetImpl()->ETSParameterExpressionSetInitializer(_context, _receiver, _initExpr); + return ; +} +KOALA_INTEROP_V3(ETSParameterExpressionSetInitializer, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ETSParameterExpressionIsRestParameterConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSParameterExpressionIsRestParameterConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSParameterExpressionIsRestParameterConst, KBoolean, KNativePointer, KNativePointer); + +KUInt impl_ETSParameterExpressionGetRequiredParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSParameterExpressionGetRequiredParamsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSParameterExpressionGetRequiredParamsConst, KUInt, KNativePointer, KNativePointer); + +void impl_ETSParameterExpressionSetRequiredParams(KNativePointer context, KNativePointer receiver, KUInt extraValue) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _extraValue = static_cast(extraValue); + GetImpl()->ETSParameterExpressionSetRequiredParams(_context, _receiver, _extraValue); + return ; +} +KOALA_INTEROP_V3(ETSParameterExpressionSetRequiredParams, KNativePointer, KNativePointer, KUInt); + +KBoolean impl_ETSParameterExpressionHasAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSParameterExpressionHasAnnotationsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSParameterExpressionHasAnnotationsConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ETSParameterExpressionEmplaceAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer source) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + GetImpl()->ETSParameterExpressionEmplaceAnnotation(_context, _receiver, _source); + return ; +} +KOALA_INTEROP_V3(ETSParameterExpressionEmplaceAnnotation, KNativePointer, KNativePointer, KNativePointer); + +void impl_ETSParameterExpressionClearAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ETSParameterExpressionClearAnnotations(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ETSParameterExpressionClearAnnotations, KNativePointer, KNativePointer); + +void impl_ETSParameterExpressionDumpAnnotationsConst(KNativePointer context, KNativePointer receiver, KNativePointer dumper) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _dumper = reinterpret_cast(dumper); + GetImpl()->ETSParameterExpressionDumpAnnotationsConst(_context, _receiver, _dumper); + return ; +} +KOALA_INTEROP_V3(ETSParameterExpressionDumpAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSParameterExpressionAnnotationsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ETSParameterExpressionAnnotationsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ETSParameterExpressionAnnotationsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSParameterExpressionAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ETSParameterExpressionAnnotations(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ETSParameterExpressionAnnotations, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSParameterExpressionAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ETSParameterExpressionAnnotationsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ETSParameterExpressionAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ETSParameterExpressionSetAnnotations(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->ETSParameterExpressionSetAnnotations(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(ETSParameterExpressionSetAnnotations, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_ETSParameterExpressionSetAnnotations1(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->ETSParameterExpressionSetAnnotations1(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(ETSParameterExpressionSetAnnotations1, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateTSTypeParameterInstantiation(KNativePointer context, KNativePointerArray params, KUInt paramsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _params = reinterpret_cast(params); + const auto _paramsSequenceLength = static_cast(paramsSequenceLength); + auto result = GetImpl()->CreateTSTypeParameterInstantiation(_context, _params, _paramsSequenceLength); + return result; +} +KOALA_INTEROP_3(CreateTSTypeParameterInstantiation, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateTSTypeParameterInstantiation(KNativePointer context, KNativePointer original, KNativePointerArray params, KUInt paramsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _params = reinterpret_cast(params); + const auto _paramsSequenceLength = static_cast(paramsSequenceLength); + auto result = GetImpl()->UpdateTSTypeParameterInstantiation(_context, _original, _params, _paramsSequenceLength); + return result; +} +KOALA_INTEROP_4(UpdateTSTypeParameterInstantiation, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_TSTypeParameterInstantiationParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSTypeParameterInstantiationParamsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSTypeParameterInstantiationParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateNullLiteral(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateNullLiteral(_context); + return result; +} +KOALA_INTEROP_1(CreateNullLiteral, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateNullLiteral(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateNullLiteral(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateNullLiteral, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSInferType(KNativePointer context, KNativePointer typeParam) +{ + const auto _context = reinterpret_cast(context); + const auto _typeParam = reinterpret_cast(typeParam); + auto result = GetImpl()->CreateTSInferType(_context, _typeParam); + return result; +} +KOALA_INTEROP_2(CreateTSInferType, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSInferType(KNativePointer context, KNativePointer original, KNativePointer typeParam) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _typeParam = reinterpret_cast(typeParam); + auto result = GetImpl()->UpdateTSInferType(_context, _original, _typeParam); + return result; +} +KOALA_INTEROP_3(UpdateTSInferType, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSInferTypeTypeParamConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSInferTypeTypeParamConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSInferTypeTypeParamConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateSwitchCaseStatement(KNativePointer context, KNativePointer test, KNativePointerArray consequent, KUInt consequentSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _test = reinterpret_cast(test); + const auto _consequent = reinterpret_cast(consequent); + const auto _consequentSequenceLength = static_cast(consequentSequenceLength); + auto result = GetImpl()->CreateSwitchCaseStatement(_context, _test, _consequent, _consequentSequenceLength); + return result; +} +KOALA_INTEROP_4(CreateSwitchCaseStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateSwitchCaseStatement(KNativePointer context, KNativePointer original, KNativePointer test, KNativePointerArray consequent, KUInt consequentSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _test = reinterpret_cast(test); + const auto _consequent = reinterpret_cast(consequent); + const auto _consequentSequenceLength = static_cast(consequentSequenceLength); + auto result = GetImpl()->UpdateSwitchCaseStatement(_context, _original, _test, _consequent, _consequentSequenceLength); + return result; +} +KOALA_INTEROP_5(UpdateSwitchCaseStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_SwitchCaseStatementTest(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->SwitchCaseStatementTest(_context, _receiver); + return result; +} +KOALA_INTEROP_2(SwitchCaseStatementTest, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_SwitchCaseStatementTestConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->SwitchCaseStatementTestConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(SwitchCaseStatementTestConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_SwitchCaseStatementSetTest(KNativePointer context, KNativePointer receiver, KNativePointer test) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _test = reinterpret_cast(test); + GetImpl()->SwitchCaseStatementSetTest(_context, _receiver, _test); + return ; +} +KOALA_INTEROP_V3(SwitchCaseStatementSetTest, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_SwitchCaseStatementConsequentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->SwitchCaseStatementConsequentConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(SwitchCaseStatementConsequentConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateYieldExpression(KNativePointer context, KNativePointer argument, KBoolean isDelegate) +{ + const auto _context = reinterpret_cast(context); + const auto _argument = reinterpret_cast(argument); + const auto _isDelegate = static_cast(isDelegate); + auto result = GetImpl()->CreateYieldExpression(_context, _argument, _isDelegate); + return result; +} +KOALA_INTEROP_3(CreateYieldExpression, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_UpdateYieldExpression(KNativePointer context, KNativePointer original, KNativePointer argument, KBoolean isDelegate) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _argument = reinterpret_cast(argument); + const auto _isDelegate = static_cast(isDelegate); + auto result = GetImpl()->UpdateYieldExpression(_context, _original, _argument, _isDelegate); + return result; +} +KOALA_INTEROP_4(UpdateYieldExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KBoolean impl_YieldExpressionHasDelegateConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->YieldExpressionHasDelegateConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(YieldExpressionHasDelegateConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_YieldExpressionArgumentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->YieldExpressionArgumentConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(YieldExpressionArgumentConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSImportEqualsDeclaration(KNativePointer context, KNativePointer id, KNativePointer moduleReference, KBoolean isExport) +{ + const auto _context = reinterpret_cast(context); + const auto _id = reinterpret_cast(id); + const auto _moduleReference = reinterpret_cast(moduleReference); + const auto _isExport = static_cast(isExport); + auto result = GetImpl()->CreateTSImportEqualsDeclaration(_context, _id, _moduleReference, _isExport); + return result; +} +KOALA_INTEROP_4(CreateTSImportEqualsDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_UpdateTSImportEqualsDeclaration(KNativePointer context, KNativePointer original, KNativePointer id, KNativePointer moduleReference, KBoolean isExport) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _id = reinterpret_cast(id); + const auto _moduleReference = reinterpret_cast(moduleReference); + const auto _isExport = static_cast(isExport); + auto result = GetImpl()->UpdateTSImportEqualsDeclaration(_context, _original, _id, _moduleReference, _isExport); + return result; +} +KOALA_INTEROP_5(UpdateTSImportEqualsDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_TSImportEqualsDeclarationIdConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSImportEqualsDeclarationIdConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSImportEqualsDeclarationIdConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSImportEqualsDeclarationModuleReferenceConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSImportEqualsDeclarationModuleReferenceConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSImportEqualsDeclarationModuleReferenceConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_TSImportEqualsDeclarationIsExportConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSImportEqualsDeclarationIsExportConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSImportEqualsDeclarationIsExportConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateBooleanLiteral(KNativePointer context, KBoolean value) +{ + const auto _context = reinterpret_cast(context); + const auto _value = static_cast(value); + auto result = GetImpl()->CreateBooleanLiteral(_context, _value); + return result; +} +KOALA_INTEROP_2(CreateBooleanLiteral, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_UpdateBooleanLiteral(KNativePointer context, KNativePointer original, KBoolean value) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _value = static_cast(value); + auto result = GetImpl()->UpdateBooleanLiteral(_context, _original, _value); + return result; +} +KOALA_INTEROP_3(UpdateBooleanLiteral, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KBoolean impl_BooleanLiteralValueConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BooleanLiteralValueConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(BooleanLiteralValueConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSNumberKeyword(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateTSNumberKeyword(_context); + return result; +} +KOALA_INTEROP_1(CreateTSNumberKeyword, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSNumberKeyword(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateTSNumberKeyword(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateTSNumberKeyword, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateClassStaticBlock(KNativePointer context, KNativePointer value) +{ + const auto _context = reinterpret_cast(context); + const auto _value = reinterpret_cast(value); + auto result = GetImpl()->CreateClassStaticBlock(_context, _value); + return result; +} +KOALA_INTEROP_2(CreateClassStaticBlock, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateClassStaticBlock(KNativePointer context, KNativePointer original, KNativePointer value) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _value = reinterpret_cast(value); + auto result = GetImpl()->UpdateClassStaticBlock(_context, _original, _value); + return result; +} +KOALA_INTEROP_3(UpdateClassStaticBlock, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassStaticBlockFunction(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassStaticBlockFunction(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassStaticBlockFunction, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassStaticBlockFunctionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassStaticBlockFunctionConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ClassStaticBlockFunctionConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassStaticBlockNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassStaticBlockNameConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ClassStaticBlockNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSNonNullExpression(KNativePointer context, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->CreateTSNonNullExpression(_context, _expr); + return result; +} +KOALA_INTEROP_2(CreateTSNonNullExpression, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSNonNullExpression(KNativePointer context, KNativePointer original, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->UpdateTSNonNullExpression(_context, _original, _expr); + return result; +} +KOALA_INTEROP_3(UpdateTSNonNullExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSNonNullExpressionExprConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSNonNullExpressionExprConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSNonNullExpressionExprConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSNonNullExpressionExpr(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSNonNullExpressionExpr(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSNonNullExpressionExpr, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSNonNullExpressionSetExpr(KNativePointer context, KNativePointer receiver, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _expr = reinterpret_cast(expr); + GetImpl()->TSNonNullExpressionSetExpr(_context, _receiver, _expr); + return ; +} +KOALA_INTEROP_V3(TSNonNullExpressionSetExpr, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreatePrefixAssertionExpression(KNativePointer context, KNativePointer expr, KNativePointer type) +{ + const auto _context = reinterpret_cast(context); + const auto _expr = reinterpret_cast(expr); + const auto _type = reinterpret_cast(type); + auto result = GetImpl()->CreatePrefixAssertionExpression(_context, _expr, _type); + return result; +} +KOALA_INTEROP_3(CreatePrefixAssertionExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdatePrefixAssertionExpression(KNativePointer context, KNativePointer original, KNativePointer expr, KNativePointer type) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _expr = reinterpret_cast(expr); + const auto _type = reinterpret_cast(type); + auto result = GetImpl()->UpdatePrefixAssertionExpression(_context, _original, _expr, _type); + return result; +} +KOALA_INTEROP_4(UpdatePrefixAssertionExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_PrefixAssertionExpressionExprConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->PrefixAssertionExpressionExprConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(PrefixAssertionExpressionExprConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_PrefixAssertionExpressionTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->PrefixAssertionExpressionTypeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(PrefixAssertionExpressionTypeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateClassExpression(KNativePointer context, KNativePointer def) +{ + const auto _context = reinterpret_cast(context); + const auto _def = reinterpret_cast(def); + auto result = GetImpl()->CreateClassExpression(_context, _def); + return result; +} +KOALA_INTEROP_2(CreateClassExpression, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateClassExpression(KNativePointer context, KNativePointer original, KNativePointer def) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _def = reinterpret_cast(def); + auto result = GetImpl()->UpdateClassExpression(_context, _original, _def); + return result; +} +KOALA_INTEROP_3(UpdateClassExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassExpressionDefinitionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassExpressionDefinitionConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ClassExpressionDefinitionConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateForOfStatement(KNativePointer context, KNativePointer left, KNativePointer right, KNativePointer body, KBoolean isAwait) +{ + const auto _context = reinterpret_cast(context); + const auto _left = reinterpret_cast(left); + const auto _right = reinterpret_cast(right); + const auto _body = reinterpret_cast(body); + const auto _isAwait = static_cast(isAwait); + auto result = GetImpl()->CreateForOfStatement(_context, _left, _right, _body, _isAwait); + return result; +} +KOALA_INTEROP_5(CreateForOfStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_UpdateForOfStatement(KNativePointer context, KNativePointer original, KNativePointer left, KNativePointer right, KNativePointer body, KBoolean isAwait) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _left = reinterpret_cast(left); + const auto _right = reinterpret_cast(right); + const auto _body = reinterpret_cast(body); + const auto _isAwait = static_cast(isAwait); + auto result = GetImpl()->UpdateForOfStatement(_context, _original, _left, _right, _body, _isAwait); + return result; +} +KOALA_INTEROP_6(UpdateForOfStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_ForOfStatementLeft(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForOfStatementLeft(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ForOfStatementLeft, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForOfStatementLeftConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForOfStatementLeftConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ForOfStatementLeftConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForOfStatementRight(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForOfStatementRight(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ForOfStatementRight, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForOfStatementRightConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForOfStatementRightConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ForOfStatementRightConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForOfStatementBody(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForOfStatementBody(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ForOfStatementBody, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForOfStatementBodyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForOfStatementBodyConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ForOfStatementBodyConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ForOfStatementIsAwaitConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForOfStatementIsAwaitConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ForOfStatementIsAwaitConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTemplateLiteral(KNativePointer context, KNativePointerArray quasis, KUInt quasisSequenceLength, KNativePointerArray expressions, KUInt expressionsSequenceLength, KStringPtr& multilineString) +{ + const auto _context = reinterpret_cast(context); + const auto _quasis = reinterpret_cast(quasis); + const auto _quasisSequenceLength = static_cast(quasisSequenceLength); + const auto _expressions = reinterpret_cast(expressions); + const auto _expressionsSequenceLength = static_cast(expressionsSequenceLength); + const auto _multilineString = getStringCopy(multilineString); + auto result = GetImpl()->CreateTemplateLiteral(_context, _quasis, _quasisSequenceLength, _expressions, _expressionsSequenceLength, _multilineString); + return result; +} +KOALA_INTEROP_6(CreateTemplateLiteral, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KNativePointerArray, KUInt, KStringPtr); + +KNativePointer impl_UpdateTemplateLiteral(KNativePointer context, KNativePointer original, KNativePointerArray quasis, KUInt quasisSequenceLength, KNativePointerArray expressions, KUInt expressionsSequenceLength, KStringPtr& multilineString) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _quasis = reinterpret_cast(quasis); + const auto _quasisSequenceLength = static_cast(quasisSequenceLength); + const auto _expressions = reinterpret_cast(expressions); + const auto _expressionsSequenceLength = static_cast(expressionsSequenceLength); + const auto _multilineString = getStringCopy(multilineString); + auto result = GetImpl()->UpdateTemplateLiteral(_context, _original, _quasis, _quasisSequenceLength, _expressions, _expressionsSequenceLength, _multilineString); + return result; +} +KOALA_INTEROP_7(UpdateTemplateLiteral, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KNativePointerArray, KUInt, KStringPtr); + +KNativePointer impl_TemplateLiteralQuasisConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TemplateLiteralQuasisConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TemplateLiteralQuasisConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TemplateLiteralExpressionsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TemplateLiteralExpressionsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TemplateLiteralExpressionsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TemplateLiteralGetMultilineStringConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TemplateLiteralGetMultilineStringConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(TemplateLiteralGetMultilineStringConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSUnionType(KNativePointer context, KNativePointerArray types, KUInt typesSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _types = reinterpret_cast(types); + const auto _typesSequenceLength = static_cast(typesSequenceLength); + auto result = GetImpl()->CreateTSUnionType(_context, _types, _typesSequenceLength); + return result; +} +KOALA_INTEROP_3(CreateTSUnionType, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateTSUnionType(KNativePointer context, KNativePointer original, KNativePointerArray types, KUInt typesSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _types = reinterpret_cast(types); + const auto _typesSequenceLength = static_cast(typesSequenceLength); + auto result = GetImpl()->UpdateTSUnionType(_context, _original, _types, _typesSequenceLength); + return result; +} +KOALA_INTEROP_4(UpdateTSUnionType, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_TSUnionTypeTypesConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSUnionTypeTypesConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSUnionTypeTypesConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSUnknownKeyword(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateTSUnknownKeyword(_context); + return result; +} +KOALA_INTEROP_1(CreateTSUnknownKeyword, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSUnknownKeyword(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateTSUnknownKeyword(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateTSUnknownKeyword, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateIdentifier(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateIdentifier(_context); + return result; +} +KOALA_INTEROP_1(CreateIdentifier, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateIdentifier(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateIdentifier(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateIdentifier, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateIdentifier1(KNativePointer context, KStringPtr& name) +{ + const auto _context = reinterpret_cast(context); + const auto _name = getStringCopy(name); + auto result = GetImpl()->CreateIdentifier1(_context, _name); + return result; +} +KOALA_INTEROP_2(CreateIdentifier1, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_UpdateIdentifier1(KNativePointer context, KNativePointer original, KStringPtr& name) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _name = getStringCopy(name); + auto result = GetImpl()->UpdateIdentifier1(_context, _original, _name); + return result; +} +KOALA_INTEROP_3(UpdateIdentifier1, KNativePointer, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_CreateIdentifier2(KNativePointer context, KStringPtr& name, KNativePointer typeAnnotation) +{ + const auto _context = reinterpret_cast(context); + const auto _name = getStringCopy(name); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + auto result = GetImpl()->CreateIdentifier2(_context, _name, _typeAnnotation); + return result; +} +KOALA_INTEROP_3(CreateIdentifier2, KNativePointer, KNativePointer, KStringPtr, KNativePointer); + +KNativePointer impl_UpdateIdentifier2(KNativePointer context, KNativePointer original, KStringPtr& name, KNativePointer typeAnnotation) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _name = getStringCopy(name); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + auto result = GetImpl()->UpdateIdentifier2(_context, _original, _name, _typeAnnotation); + return result; +} +KOALA_INTEROP_4(UpdateIdentifier2, KNativePointer, KNativePointer, KNativePointer, KStringPtr, KNativePointer); + +KNativePointer impl_IdentifierNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IdentifierNameConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(IdentifierNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_IdentifierName(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IdentifierName(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(IdentifierName, KNativePointer, KNativePointer, KNativePointer); + +void impl_IdentifierSetName(KNativePointer context, KNativePointer receiver, KStringPtr& newName) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _newName = getStringCopy(newName); + GetImpl()->IdentifierSetName(_context, _receiver, _newName); + return ; +} +KOALA_INTEROP_V3(IdentifierSetName, KNativePointer, KNativePointer, KStringPtr); + +KBoolean impl_IdentifierIsErrorPlaceHolderConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IdentifierIsErrorPlaceHolderConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(IdentifierIsErrorPlaceHolderConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_IdentifierIsOptionalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IdentifierIsOptionalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(IdentifierIsOptionalConst, KBoolean, KNativePointer, KNativePointer); + +void impl_IdentifierSetOptional(KNativePointer context, KNativePointer receiver, KBoolean optional_arg) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _optional_arg = static_cast(optional_arg); + GetImpl()->IdentifierSetOptional(_context, _receiver, _optional_arg); + return ; +} +KOALA_INTEROP_V3(IdentifierSetOptional, KNativePointer, KNativePointer, KBoolean); + +KBoolean impl_IdentifierIsReferenceConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IdentifierIsReferenceConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(IdentifierIsReferenceConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_IdentifierIsTdzConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IdentifierIsTdzConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(IdentifierIsTdzConst, KBoolean, KNativePointer, KNativePointer); + +void impl_IdentifierSetTdz(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->IdentifierSetTdz(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(IdentifierSetTdz, KNativePointer, KNativePointer); + +void impl_IdentifierSetAccessor(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->IdentifierSetAccessor(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(IdentifierSetAccessor, KNativePointer, KNativePointer); + +KBoolean impl_IdentifierIsAccessorConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IdentifierIsAccessorConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(IdentifierIsAccessorConst, KBoolean, KNativePointer, KNativePointer); + +void impl_IdentifierSetMutator(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->IdentifierSetMutator(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(IdentifierSetMutator, KNativePointer, KNativePointer); + +KBoolean impl_IdentifierIsMutatorConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IdentifierIsMutatorConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(IdentifierIsMutatorConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_IdentifierIsReceiverConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IdentifierIsReceiverConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(IdentifierIsReceiverConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_IdentifierIsPrivateIdentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IdentifierIsPrivateIdentConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(IdentifierIsPrivateIdentConst, KBoolean, KNativePointer, KNativePointer); + +void impl_IdentifierSetPrivate(KNativePointer context, KNativePointer receiver, KBoolean isPrivate) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _isPrivate = static_cast(isPrivate); + GetImpl()->IdentifierSetPrivate(_context, _receiver, _isPrivate); + return ; +} +KOALA_INTEROP_V3(IdentifierSetPrivate, KNativePointer, KNativePointer, KBoolean); + +KBoolean impl_IdentifierIsIgnoreBoxConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IdentifierIsIgnoreBoxConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(IdentifierIsIgnoreBoxConst, KBoolean, KNativePointer, KNativePointer); + +void impl_IdentifierSetIgnoreBox(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->IdentifierSetIgnoreBox(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(IdentifierSetIgnoreBox, KNativePointer, KNativePointer); + +KBoolean impl_IdentifierIsAnnotationDeclConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IdentifierIsAnnotationDeclConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(IdentifierIsAnnotationDeclConst, KBoolean, KNativePointer, KNativePointer); + +void impl_IdentifierSetAnnotationDecl(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->IdentifierSetAnnotationDecl(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(IdentifierSetAnnotationDecl, KNativePointer, KNativePointer); + +KBoolean impl_IdentifierIsAnnotationUsageConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IdentifierIsAnnotationUsageConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(IdentifierIsAnnotationUsageConst, KBoolean, KNativePointer, KNativePointer); + +void impl_IdentifierSetAnnotationUsage(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->IdentifierSetAnnotationUsage(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(IdentifierSetAnnotationUsage, KNativePointer, KNativePointer); + +KNativePointer impl_IdentifierCloneReference(KNativePointer context, KNativePointer receiver, KNativePointer parent) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _parent = reinterpret_cast(parent); + auto result = GetImpl()->IdentifierCloneReference(_context, _receiver, _parent); + return result; +} +KOALA_INTEROP_3(IdentifierCloneReference, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_IdentifierValidateExpression(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IdentifierValidateExpression(_context, _receiver); + return result; +} +KOALA_INTEROP_2(IdentifierValidateExpression, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_IdentifierTypeAnnotationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->IdentifierTypeAnnotationConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(IdentifierTypeAnnotationConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_IdentifierSetTsTypeAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer typeAnnotation) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + GetImpl()->IdentifierSetTsTypeAnnotation(_context, _receiver, _typeAnnotation); + return ; +} +KOALA_INTEROP_V3(IdentifierSetTsTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateOpaqueTypeNode1(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateOpaqueTypeNode1(_context); + return result; +} +KOALA_INTEROP_1(CreateOpaqueTypeNode1, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateOpaqueTypeNode1(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateOpaqueTypeNode1(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateOpaqueTypeNode1, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateBlockStatement(KNativePointer context, KNativePointerArray statementList, KUInt statementListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _statementList = reinterpret_cast(statementList); + const auto _statementListSequenceLength = static_cast(statementListSequenceLength); + auto result = GetImpl()->CreateBlockStatement(_context, _statementList, _statementListSequenceLength); + return result; +} +KOALA_INTEROP_3(CreateBlockStatement, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateBlockStatement(KNativePointer context, KNativePointer original, KNativePointerArray statementList, KUInt statementListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _statementList = reinterpret_cast(statementList); + const auto _statementListSequenceLength = static_cast(statementListSequenceLength); + auto result = GetImpl()->UpdateBlockStatement(_context, _original, _statementList, _statementListSequenceLength); + return result; +} +KOALA_INTEROP_4(UpdateBlockStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_BlockStatementStatementsForUpdates(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->BlockStatementStatementsForUpdates(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(BlockStatementStatementsForUpdates, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_BlockStatementStatements(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->BlockStatementStatements(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(BlockStatementStatements, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_BlockStatementStatementsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->BlockStatementStatementsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(BlockStatementStatementsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_BlockStatementSetStatements(KNativePointer context, KNativePointer receiver, KNativePointerArray statementList, KUInt statementListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _statementList = reinterpret_cast(statementList); + const auto _statementListSequenceLength = static_cast(statementListSequenceLength); + GetImpl()->BlockStatementSetStatements(_context, _receiver, _statementList, _statementListSequenceLength); + return ; +} +KOALA_INTEROP_V4(BlockStatementSetStatements, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_BlockStatementAddStatements(KNativePointer context, KNativePointer receiver, KNativePointerArray statementList, KUInt statementListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _statementList = reinterpret_cast(statementList); + const auto _statementListSequenceLength = static_cast(statementListSequenceLength); + GetImpl()->BlockStatementAddStatements(_context, _receiver, _statementList, _statementListSequenceLength); + return ; +} +KOALA_INTEROP_V4(BlockStatementAddStatements, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_BlockStatementClearStatements(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->BlockStatementClearStatements(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(BlockStatementClearStatements, KNativePointer, KNativePointer); + +void impl_BlockStatementAddStatement(KNativePointer context, KNativePointer receiver, KNativePointer statement) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _statement = reinterpret_cast(statement); + GetImpl()->BlockStatementAddStatement(_context, _receiver, _statement); + return ; +} +KOALA_INTEROP_V3(BlockStatementAddStatement, KNativePointer, KNativePointer, KNativePointer); + +void impl_BlockStatementAddStatement1(KNativePointer context, KNativePointer receiver, KUInt idx, KNativePointer statement) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _idx = static_cast(idx); + const auto _statement = reinterpret_cast(statement); + GetImpl()->BlockStatementAddStatement1(_context, _receiver, _idx, _statement); + return ; +} +KOALA_INTEROP_V4(BlockStatementAddStatement1, KNativePointer, KNativePointer, KUInt, KNativePointer); + +void impl_BlockStatementAddTrailingBlock(KNativePointer context, KNativePointer receiver, KNativePointer stmt, KNativePointer trailingBlock) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _stmt = reinterpret_cast(stmt); + const auto _trailingBlock = reinterpret_cast(trailingBlock); + GetImpl()->BlockStatementAddTrailingBlock(_context, _receiver, _stmt, _trailingBlock); + return ; +} +KOALA_INTEROP_V4(BlockStatementAddTrailingBlock, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_BlockStatementSearchStatementInTrailingBlock(KNativePointer context, KNativePointer receiver, KNativePointer item) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _item = reinterpret_cast(item); + auto result = GetImpl()->BlockStatementSearchStatementInTrailingBlock(_context, _receiver, _item); + return result; +} +KOALA_INTEROP_3(BlockStatementSearchStatementInTrailingBlock, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateDirectEvalExpression(KNativePointer context, KNativePointer callee, KNativePointerArray _arguments, KUInt _argumentsSequenceLength, KNativePointer typeParams, KBoolean optional_arg, KUInt parserStatus) +{ + const auto _context = reinterpret_cast(context); + const auto _callee = reinterpret_cast(callee); + const auto __arguments = reinterpret_cast(_arguments); + const auto __argumentsSequenceLength = static_cast(_argumentsSequenceLength); + const auto _typeParams = reinterpret_cast(typeParams); + const auto _optional_arg = static_cast(optional_arg); + const auto _parserStatus = static_cast(parserStatus); + auto result = GetImpl()->CreateDirectEvalExpression(_context, _callee, __arguments, __argumentsSequenceLength, _typeParams, _optional_arg, _parserStatus); + return result; +} +KOALA_INTEROP_7(CreateDirectEvalExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KNativePointer, KBoolean, KUInt); + +KNativePointer impl_UpdateDirectEvalExpression(KNativePointer context, KNativePointer original, KNativePointer callee, KNativePointerArray _arguments, KUInt _argumentsSequenceLength, KNativePointer typeParams, KBoolean optional_arg, KUInt parserStatus) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _callee = reinterpret_cast(callee); + const auto __arguments = reinterpret_cast(_arguments); + const auto __argumentsSequenceLength = static_cast(_argumentsSequenceLength); + const auto _typeParams = reinterpret_cast(typeParams); + const auto _optional_arg = static_cast(optional_arg); + const auto _parserStatus = static_cast(parserStatus); + auto result = GetImpl()->UpdateDirectEvalExpression(_context, _original, _callee, __arguments, __argumentsSequenceLength, _typeParams, _optional_arg, _parserStatus); + return result; +} +KOALA_INTEROP_8(UpdateDirectEvalExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KNativePointer, KBoolean, KUInt); + +KNativePointer impl_CreateTSTypeParameterDeclaration(KNativePointer context, KNativePointerArray params, KUInt paramsSequenceLength, KUInt requiredParams) +{ + const auto _context = reinterpret_cast(context); + const auto _params = reinterpret_cast(params); + const auto _paramsSequenceLength = static_cast(paramsSequenceLength); + const auto _requiredParams = static_cast(requiredParams); + auto result = GetImpl()->CreateTSTypeParameterDeclaration(_context, _params, _paramsSequenceLength, _requiredParams); + return result; +} +KOALA_INTEROP_4(CreateTSTypeParameterDeclaration, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KUInt); + +KNativePointer impl_UpdateTSTypeParameterDeclaration(KNativePointer context, KNativePointer original, KNativePointerArray params, KUInt paramsSequenceLength, KUInt requiredParams) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _params = reinterpret_cast(params); + const auto _paramsSequenceLength = static_cast(paramsSequenceLength); + const auto _requiredParams = static_cast(requiredParams); + auto result = GetImpl()->UpdateTSTypeParameterDeclaration(_context, _original, _params, _paramsSequenceLength, _requiredParams); + return result; +} +KOALA_INTEROP_5(UpdateTSTypeParameterDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt, KUInt); + +KNativePointer impl_TSTypeParameterDeclarationParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TSTypeParameterDeclarationParamsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TSTypeParameterDeclarationParamsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSTypeParameterDeclarationAddParam(KNativePointer context, KNativePointer receiver, KNativePointer param) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _param = reinterpret_cast(param); + GetImpl()->TSTypeParameterDeclarationAddParam(_context, _receiver, _param); + return ; +} +KOALA_INTEROP_V3(TSTypeParameterDeclarationAddParam, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSTypeParameterDeclarationSetValueParams(KNativePointer context, KNativePointer receiver, KNativePointer source, KUInt index) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + const auto _index = static_cast(index); + GetImpl()->TSTypeParameterDeclarationSetValueParams(_context, _receiver, _source, _index); + return ; +} +KOALA_INTEROP_V4(TSTypeParameterDeclarationSetValueParams, KNativePointer, KNativePointer, KNativePointer, KUInt); + +KUInt impl_TSTypeParameterDeclarationRequiredParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSTypeParameterDeclarationRequiredParamsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSTypeParameterDeclarationRequiredParamsConst, KUInt, KNativePointer, KNativePointer); + +KNativePointer impl_CreateMethodDefinition(KNativePointer context, KInt kind, KNativePointer key, KNativePointer value, KInt modifiers, KBoolean isComputed) +{ + const auto _context = reinterpret_cast(context); + const auto _kind = static_cast(kind); + const auto _key = reinterpret_cast(key); + const auto _value = reinterpret_cast(value); + const auto _modifiers = static_cast(modifiers); + const auto _isComputed = static_cast(isComputed); + auto result = GetImpl()->CreateMethodDefinition(_context, _kind, _key, _value, _modifiers, _isComputed); + return result; +} +KOALA_INTEROP_6(CreateMethodDefinition, KNativePointer, KNativePointer, KInt, KNativePointer, KNativePointer, KInt, KBoolean); + +KNativePointer impl_UpdateMethodDefinition(KNativePointer context, KNativePointer original, KInt kind, KNativePointer key, KNativePointer value, KInt modifiers, KBoolean isComputed) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _kind = static_cast(kind); + const auto _key = reinterpret_cast(key); + const auto _value = reinterpret_cast(value); + const auto _modifiers = static_cast(modifiers); + const auto _isComputed = static_cast(isComputed); + auto result = GetImpl()->UpdateMethodDefinition(_context, _original, _kind, _key, _value, _modifiers, _isComputed); + return result; +} +KOALA_INTEROP_7(UpdateMethodDefinition, KNativePointer, KNativePointer, KNativePointer, KInt, KNativePointer, KNativePointer, KInt, KBoolean); + +KInt impl_MethodDefinitionKindConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MethodDefinitionKindConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MethodDefinitionKindConst, KInt, KNativePointer, KNativePointer); + +KBoolean impl_MethodDefinitionIsConstructorConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MethodDefinitionIsConstructorConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MethodDefinitionIsConstructorConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_MethodDefinitionIsMethodConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MethodDefinitionIsMethodConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MethodDefinitionIsMethodConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_MethodDefinitionIsExtensionMethodConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MethodDefinitionIsExtensionMethodConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MethodDefinitionIsExtensionMethodConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_MethodDefinitionIsGetterConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MethodDefinitionIsGetterConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MethodDefinitionIsGetterConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_MethodDefinitionIsSetterConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MethodDefinitionIsSetterConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MethodDefinitionIsSetterConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_MethodDefinitionIsDefaultAccessModifierConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MethodDefinitionIsDefaultAccessModifierConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MethodDefinitionIsDefaultAccessModifierConst, KBoolean, KNativePointer, KNativePointer); + +void impl_MethodDefinitionSetDefaultAccessModifier(KNativePointer context, KNativePointer receiver, KBoolean isDefault) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _isDefault = static_cast(isDefault); + GetImpl()->MethodDefinitionSetDefaultAccessModifier(_context, _receiver, _isDefault); + return ; +} +KOALA_INTEROP_V3(MethodDefinitionSetDefaultAccessModifier, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_MethodDefinitionOverloadsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->MethodDefinitionOverloadsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(MethodDefinitionOverloadsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_MethodDefinitionBaseOverloadMethodConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MethodDefinitionBaseOverloadMethodConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(MethodDefinitionBaseOverloadMethodConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_MethodDefinitionBaseOverloadMethod(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MethodDefinitionBaseOverloadMethod(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MethodDefinitionBaseOverloadMethod, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_MethodDefinitionAsyncPairMethodConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MethodDefinitionAsyncPairMethodConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(MethodDefinitionAsyncPairMethodConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_MethodDefinitionAsyncPairMethod(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MethodDefinitionAsyncPairMethod(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MethodDefinitionAsyncPairMethod, KNativePointer, KNativePointer, KNativePointer); + +void impl_MethodDefinitionSetOverloads(KNativePointer context, KNativePointer receiver, KNativePointerArray overloads, KUInt overloadsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _overloads = reinterpret_cast(overloads); + const auto _overloadsSequenceLength = static_cast(overloadsSequenceLength); + GetImpl()->MethodDefinitionSetOverloads(_context, _receiver, _overloads, _overloadsSequenceLength); + return ; +} +KOALA_INTEROP_V4(MethodDefinitionSetOverloads, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_MethodDefinitionAddOverload(KNativePointer context, KNativePointer receiver, KNativePointer overload) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _overload = reinterpret_cast(overload); + GetImpl()->MethodDefinitionAddOverload(_context, _receiver, _overload); + return ; +} +KOALA_INTEROP_V3(MethodDefinitionAddOverload, KNativePointer, KNativePointer, KNativePointer); + +void impl_MethodDefinitionSetBaseOverloadMethod(KNativePointer context, KNativePointer receiver, KNativePointer baseOverloadMethod) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _baseOverloadMethod = reinterpret_cast(baseOverloadMethod); + GetImpl()->MethodDefinitionSetBaseOverloadMethod(_context, _receiver, _baseOverloadMethod); + return ; +} +KOALA_INTEROP_V3(MethodDefinitionSetBaseOverloadMethod, KNativePointer, KNativePointer, KNativePointer); + +void impl_MethodDefinitionSetAsyncPairMethod(KNativePointer context, KNativePointer receiver, KNativePointer asyncPairMethod) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _asyncPairMethod = reinterpret_cast(asyncPairMethod); + GetImpl()->MethodDefinitionSetAsyncPairMethod(_context, _receiver, _asyncPairMethod); + return ; +} +KOALA_INTEROP_V3(MethodDefinitionSetAsyncPairMethod, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_MethodDefinitionHasOverload(KNativePointer context, KNativePointer receiver, KNativePointer overload) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _overload = reinterpret_cast(overload); + auto result = GetImpl()->MethodDefinitionHasOverload(_context, _receiver, _overload); + return result; +} +KOALA_INTEROP_3(MethodDefinitionHasOverload, KBoolean, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_MethodDefinitionFunction(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MethodDefinitionFunction(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MethodDefinitionFunction, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_MethodDefinitionFunctionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MethodDefinitionFunctionConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(MethodDefinitionFunctionConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_MethodDefinitionInitializeOverloadInfo(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->MethodDefinitionInitializeOverloadInfo(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(MethodDefinitionInitializeOverloadInfo, KNativePointer, KNativePointer); + +void impl_MethodDefinitionEmplaceOverloads(KNativePointer context, KNativePointer receiver, KNativePointer overloads) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _overloads = reinterpret_cast(overloads); + GetImpl()->MethodDefinitionEmplaceOverloads(_context, _receiver, _overloads); + return ; +} +KOALA_INTEROP_V3(MethodDefinitionEmplaceOverloads, KNativePointer, KNativePointer, KNativePointer); + +void impl_MethodDefinitionClearOverloads(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->MethodDefinitionClearOverloads(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(MethodDefinitionClearOverloads, KNativePointer, KNativePointer); + +void impl_MethodDefinitionSetValueOverloads(KNativePointer context, KNativePointer receiver, KNativePointer overloads, KUInt index) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _overloads = reinterpret_cast(overloads); + const auto _index = static_cast(index); + GetImpl()->MethodDefinitionSetValueOverloads(_context, _receiver, _overloads, _index); + return ; +} +KOALA_INTEROP_V4(MethodDefinitionSetValueOverloads, KNativePointer, KNativePointer, KNativePointer, KUInt); + +KNativePointer impl_CreateOverloadDeclaration(KNativePointer context, KNativePointer key, KInt modifiers) +{ + const auto _context = reinterpret_cast(context); + const auto _key = reinterpret_cast(key); + const auto _modifiers = static_cast(modifiers); + auto result = GetImpl()->CreateOverloadDeclaration(_context, _key, _modifiers); + return result; +} +KOALA_INTEROP_3(CreateOverloadDeclaration, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_UpdateOverloadDeclaration(KNativePointer context, KNativePointer original, KNativePointer key, KInt modifiers) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _key = reinterpret_cast(key); + const auto _modifiers = static_cast(modifiers); + auto result = GetImpl()->UpdateOverloadDeclaration(_context, _original, _key, _modifiers); + return result; +} +KOALA_INTEROP_4(UpdateOverloadDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt); + +KInt impl_OverloadDeclarationFlagConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->OverloadDeclarationFlagConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(OverloadDeclarationFlagConst, KInt, KNativePointer, KNativePointer); + +KNativePointer impl_OverloadDeclarationOverloadedList(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->OverloadDeclarationOverloadedList(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(OverloadDeclarationOverloadedList, KNativePointer, KNativePointer, KNativePointer); + +void impl_OverloadDeclarationSetOverloadedList(KNativePointer context, KNativePointer receiver, KNativePointerArray overloadedList, KUInt overloadedListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _overloadedList = reinterpret_cast(overloadedList); + const auto _overloadedListSequenceLength = static_cast(overloadedListSequenceLength); + GetImpl()->OverloadDeclarationSetOverloadedList(_context, _receiver, _overloadedList, _overloadedListSequenceLength); + return ; +} +KOALA_INTEROP_V4(OverloadDeclarationSetOverloadedList, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_OverloadDeclarationPushFront(KNativePointer context, KNativePointer receiver, KNativePointer overloadedExpression) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _overloadedExpression = reinterpret_cast(overloadedExpression); + GetImpl()->OverloadDeclarationPushFront(_context, _receiver, _overloadedExpression); + return ; +} +KOALA_INTEROP_V3(OverloadDeclarationPushFront, KNativePointer, KNativePointer, KNativePointer); + +void impl_OverloadDeclarationAddOverloadDeclFlag(KNativePointer context, KNativePointer receiver, KInt overloadFlag) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _overloadFlag = static_cast(overloadFlag); + GetImpl()->OverloadDeclarationAddOverloadDeclFlag(_context, _receiver, _overloadFlag); + return ; +} +KOALA_INTEROP_V3(OverloadDeclarationAddOverloadDeclFlag, KNativePointer, KNativePointer, KInt); + +KBoolean impl_OverloadDeclarationHasOverloadDeclFlagConst(KNativePointer context, KNativePointer receiver, KInt overloadFlag) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _overloadFlag = static_cast(overloadFlag); + auto result = GetImpl()->OverloadDeclarationHasOverloadDeclFlagConst(_context, _receiver, _overloadFlag); + return result; +} +KOALA_INTEROP_3(OverloadDeclarationHasOverloadDeclFlagConst, KBoolean, KNativePointer, KNativePointer, KInt); + +KBoolean impl_OverloadDeclarationIsConstructorOverloadDeclaration(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->OverloadDeclarationIsConstructorOverloadDeclaration(_context, _receiver); + return result; +} +KOALA_INTEROP_2(OverloadDeclarationIsConstructorOverloadDeclaration, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_OverloadDeclarationIsFunctionOverloadDeclaration(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->OverloadDeclarationIsFunctionOverloadDeclaration(_context, _receiver); + return result; +} +KOALA_INTEROP_2(OverloadDeclarationIsFunctionOverloadDeclaration, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_OverloadDeclarationIsClassMethodOverloadDeclaration(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->OverloadDeclarationIsClassMethodOverloadDeclaration(_context, _receiver); + return result; +} +KOALA_INTEROP_2(OverloadDeclarationIsClassMethodOverloadDeclaration, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_OverloadDeclarationIsInterfaceMethodOverloadDeclaration(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->OverloadDeclarationIsInterfaceMethodOverloadDeclaration(_context, _receiver); + return result; +} +KOALA_INTEROP_2(OverloadDeclarationIsInterfaceMethodOverloadDeclaration, KBoolean, KNativePointer, KNativePointer); + +void impl_OverloadDeclarationDumpModifierConst(KNativePointer context, KNativePointer receiver, KNativePointer dumper) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _dumper = reinterpret_cast(dumper); + GetImpl()->OverloadDeclarationDumpModifierConst(_context, _receiver, _dumper); + return ; +} +KOALA_INTEROP_V3(OverloadDeclarationDumpModifierConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSNullKeyword(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateTSNullKeyword(_context); + return result; +} +KOALA_INTEROP_1(CreateTSNullKeyword, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSNullKeyword(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateTSNullKeyword(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateTSNullKeyword, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSInterfaceHeritage(KNativePointer context, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->CreateTSInterfaceHeritage(_context, _expr); + return result; +} +KOALA_INTEROP_2(CreateTSInterfaceHeritage, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSInterfaceHeritage(KNativePointer context, KNativePointer original, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->UpdateTSInterfaceHeritage(_context, _original, _expr); + return result; +} +KOALA_INTEROP_3(UpdateTSInterfaceHeritage, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSInterfaceHeritageExpr(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSInterfaceHeritageExpr(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSInterfaceHeritageExpr, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSInterfaceHeritageExprConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSInterfaceHeritageExprConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSInterfaceHeritageExprConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ExpressionIsGroupedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExpressionIsGroupedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ExpressionIsGroupedConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ExpressionSetGrouped(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ExpressionSetGrouped(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ExpressionSetGrouped, KNativePointer, KNativePointer); + +KNativePointer impl_ExpressionAsLiteralConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExpressionAsLiteralConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ExpressionAsLiteralConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ExpressionAsLiteral(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExpressionAsLiteral(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ExpressionAsLiteral, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ExpressionIsLiteralConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExpressionIsLiteralConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ExpressionIsLiteralConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ExpressionIsTypeNodeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExpressionIsTypeNodeConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ExpressionIsTypeNodeConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ExpressionIsAnnotatedExpressionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExpressionIsAnnotatedExpressionConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ExpressionIsAnnotatedExpressionConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_ExpressionAsTypeNode(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExpressionAsTypeNode(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ExpressionAsTypeNode, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ExpressionAsTypeNodeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExpressionAsTypeNodeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ExpressionAsTypeNodeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ExpressionAsAnnotatedExpression(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExpressionAsAnnotatedExpression(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ExpressionAsAnnotatedExpression, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ExpressionAsAnnotatedExpressionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExpressionAsAnnotatedExpressionConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ExpressionAsAnnotatedExpressionConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ExpressionIsBrokenExpressionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExpressionIsBrokenExpressionConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ExpressionIsBrokenExpressionConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_ExpressionToStringConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ExpressionToStringConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ExpressionToStringConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AnnotatedExpressionTypeAnnotationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AnnotatedExpressionTypeAnnotationConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AnnotatedExpressionTypeAnnotationConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_AnnotatedExpressionSetTsTypeAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer typeAnnotation) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + GetImpl()->AnnotatedExpressionSetTsTypeAnnotation(_context, _receiver, _typeAnnotation); + return ; +} +KOALA_INTEROP_V3(AnnotatedExpressionSetTsTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_MaybeOptionalExpressionIsOptionalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->MaybeOptionalExpressionIsOptionalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(MaybeOptionalExpressionIsOptionalConst, KBoolean, KNativePointer, KNativePointer); + +void impl_MaybeOptionalExpressionClearOptional(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->MaybeOptionalExpressionClearOptional(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(MaybeOptionalExpressionClearOptional, KNativePointer, KNativePointer); + +KNativePointer impl_CreateSrcDumper(KNativePointer context, KNativePointer node) +{ + const auto _context = reinterpret_cast(context); + const auto _node = reinterpret_cast(node); + auto result = GetImpl()->CreateSrcDumper(_context, _node); + return result; +} +KOALA_INTEROP_2(CreateSrcDumper, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateSrcDumper1(KNativePointer context, KNativePointer node, KBoolean isDeclgen) +{ + const auto _context = reinterpret_cast(context); + const auto _node = reinterpret_cast(node); + const auto _isDeclgen = static_cast(isDeclgen); + auto result = GetImpl()->CreateSrcDumper1(_context, _node, _isDeclgen); + return result; +} +KOALA_INTEROP_3(CreateSrcDumper1, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +void impl_SrcDumperAdd(KNativePointer context, KNativePointer receiver, KStringPtr& str) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _str = getStringCopy(str); + GetImpl()->SrcDumperAdd(_context, _receiver, _str); + return ; +} +KOALA_INTEROP_V3(SrcDumperAdd, KNativePointer, KNativePointer, KStringPtr); + +void impl_SrcDumperAdd1(KNativePointer context, KNativePointer receiver, KBoolean i) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _i = static_cast(i); + GetImpl()->SrcDumperAdd1(_context, _receiver, _i); + return ; +} +KOALA_INTEROP_V3(SrcDumperAdd1, KNativePointer, KNativePointer, KBoolean); + +void impl_SrcDumperAdd2(KNativePointer context, KNativePointer receiver, KInt i) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _i = static_cast(i); + GetImpl()->SrcDumperAdd2(_context, _receiver, _i); + return ; +} +KOALA_INTEROP_V3(SrcDumperAdd2, KNativePointer, KNativePointer, KInt); + +void impl_SrcDumperAdd3(KNativePointer context, KNativePointer receiver, KInt i) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _i = static_cast(i); + GetImpl()->SrcDumperAdd3(_context, _receiver, _i); + return ; +} +KOALA_INTEROP_V3(SrcDumperAdd3, KNativePointer, KNativePointer, KInt); + +void impl_SrcDumperAdd4(KNativePointer context, KNativePointer receiver, KLong l) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _l = static_cast(l); + GetImpl()->SrcDumperAdd4(_context, _receiver, _l); + return ; +} +KOALA_INTEROP_V3(SrcDumperAdd4, KNativePointer, KNativePointer, KLong); + +void impl_SrcDumperAdd5(KNativePointer context, KNativePointer receiver, KFloat f) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _f = static_cast(f); + GetImpl()->SrcDumperAdd5(_context, _receiver, _f); + return ; +} +KOALA_INTEROP_V3(SrcDumperAdd5, KNativePointer, KNativePointer, KFloat); + +void impl_SrcDumperAdd6(KNativePointer context, KNativePointer receiver, KDouble d) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _d = static_cast(d); + GetImpl()->SrcDumperAdd6(_context, _receiver, _d); + return ; +} +KOALA_INTEROP_V3(SrcDumperAdd6, KNativePointer, KNativePointer, KDouble); + +KNativePointer impl_SrcDumperStrConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->SrcDumperStrConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(SrcDumperStrConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_SrcDumperIncrIndent(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->SrcDumperIncrIndent(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(SrcDumperIncrIndent, KNativePointer, KNativePointer); + +void impl_SrcDumperDecrIndent(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->SrcDumperDecrIndent(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(SrcDumperDecrIndent, KNativePointer, KNativePointer); + +void impl_SrcDumperEndl(KNativePointer context, KNativePointer receiver, KUInt num) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _num = static_cast(num); + GetImpl()->SrcDumperEndl(_context, _receiver, _num); + return ; +} +KOALA_INTEROP_V3(SrcDumperEndl, KNativePointer, KNativePointer, KUInt); + +KBoolean impl_SrcDumperIsDeclgenConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->SrcDumperIsDeclgenConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(SrcDumperIsDeclgenConst, KBoolean, KNativePointer, KNativePointer); + +void impl_SrcDumperDumpNode(KNativePointer context, KNativePointer receiver, KStringPtr& key) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _key = getStringCopy(key); + GetImpl()->SrcDumperDumpNode(_context, _receiver, _key); + return ; +} +KOALA_INTEROP_V3(SrcDumperDumpNode, KNativePointer, KNativePointer, KStringPtr); + +void impl_SrcDumperRemoveNode(KNativePointer context, KNativePointer receiver, KStringPtr& key) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _key = getStringCopy(key); + GetImpl()->SrcDumperRemoveNode(_context, _receiver, _key); + return ; +} +KOALA_INTEROP_V3(SrcDumperRemoveNode, KNativePointer, KNativePointer, KStringPtr); + +KBoolean impl_SrcDumperIsIndirectDepPhaseConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->SrcDumperIsIndirectDepPhaseConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(SrcDumperIsIndirectDepPhaseConst, KBoolean, KNativePointer, KNativePointer); + +void impl_SrcDumperRun(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->SrcDumperRun(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(SrcDumperRun, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSClassLiteral(KNativePointer context, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->CreateETSClassLiteral(_context, _expr); + return result; +} +KOALA_INTEROP_2(CreateETSClassLiteral, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSClassLiteral(KNativePointer context, KNativePointer original, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _expr = reinterpret_cast(expr); + auto result = GetImpl()->UpdateETSClassLiteral(_context, _original, _expr); + return result; +} +KOALA_INTEROP_3(UpdateETSClassLiteral, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSClassLiteralExprConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSClassLiteralExprConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSClassLiteralExprConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateBreakStatement(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateBreakStatement(_context); + return result; +} +KOALA_INTEROP_1(CreateBreakStatement, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateBreakStatement(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateBreakStatement(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateBreakStatement, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateBreakStatement1(KNativePointer context, KNativePointer ident) +{ + const auto _context = reinterpret_cast(context); + const auto _ident = reinterpret_cast(ident); + auto result = GetImpl()->CreateBreakStatement1(_context, _ident); + return result; +} +KOALA_INTEROP_2(CreateBreakStatement1, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateBreakStatement1(KNativePointer context, KNativePointer original, KNativePointer ident) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _ident = reinterpret_cast(ident); + auto result = GetImpl()->UpdateBreakStatement1(_context, _original, _ident); + return result; +} +KOALA_INTEROP_3(UpdateBreakStatement1, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_BreakStatementIdentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BreakStatementIdentConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(BreakStatementIdentConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_BreakStatementIdent(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BreakStatementIdent(_context, _receiver); + return result; +} +KOALA_INTEROP_2(BreakStatementIdent, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_BreakStatementTargetConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BreakStatementTargetConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(BreakStatementTargetConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_BreakStatementHasTargetConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->BreakStatementHasTargetConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(BreakStatementHasTargetConst, KBoolean, KNativePointer, KNativePointer); + +void impl_BreakStatementSetTarget(KNativePointer context, KNativePointer receiver, KNativePointer target) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _target = reinterpret_cast(target); + GetImpl()->BreakStatementSetTarget(_context, _receiver, _target); + return ; +} +KOALA_INTEROP_V3(BreakStatementSetTarget, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateRegExpLiteral(KNativePointer context, KStringPtr& pattern, KInt flags, KStringPtr& flagsStr) +{ + const auto _context = reinterpret_cast(context); + const auto _pattern = getStringCopy(pattern); + const auto _flags = static_cast(flags); + const auto _flagsStr = getStringCopy(flagsStr); + auto result = GetImpl()->CreateRegExpLiteral(_context, _pattern, _flags, _flagsStr); + return result; +} +KOALA_INTEROP_4(CreateRegExpLiteral, KNativePointer, KNativePointer, KStringPtr, KInt, KStringPtr); + +KNativePointer impl_UpdateRegExpLiteral(KNativePointer context, KNativePointer original, KStringPtr& pattern, KInt flags, KStringPtr& flagsStr) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _pattern = getStringCopy(pattern); + const auto _flags = static_cast(flags); + const auto _flagsStr = getStringCopy(flagsStr); + auto result = GetImpl()->UpdateRegExpLiteral(_context, _original, _pattern, _flags, _flagsStr); + return result; +} +KOALA_INTEROP_5(UpdateRegExpLiteral, KNativePointer, KNativePointer, KNativePointer, KStringPtr, KInt, KStringPtr); + +KNativePointer impl_RegExpLiteralPatternConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->RegExpLiteralPatternConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(RegExpLiteralPatternConst, KNativePointer, KNativePointer, KNativePointer); + +KInt impl_RegExpLiteralFlagsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->RegExpLiteralFlagsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(RegExpLiteralFlagsConst, KInt, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSMappedType(KNativePointer context, KNativePointer typeParameter, KNativePointer typeAnnotation, KInt readonly_arg, KInt optional_arg) +{ + const auto _context = reinterpret_cast(context); + const auto _typeParameter = reinterpret_cast(typeParameter); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + const auto _readonly_arg = static_cast(readonly_arg); + const auto _optional_arg = static_cast(optional_arg); + auto result = GetImpl()->CreateTSMappedType(_context, _typeParameter, _typeAnnotation, _readonly_arg, _optional_arg); + return result; +} +KOALA_INTEROP_5(CreateTSMappedType, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KInt); + +KNativePointer impl_UpdateTSMappedType(KNativePointer context, KNativePointer original, KNativePointer typeParameter, KNativePointer typeAnnotation, KInt readonly_arg, KInt optional_arg) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _typeParameter = reinterpret_cast(typeParameter); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + const auto _readonly_arg = static_cast(readonly_arg); + const auto _optional_arg = static_cast(optional_arg); + auto result = GetImpl()->UpdateTSMappedType(_context, _original, _typeParameter, _typeAnnotation, _readonly_arg, _optional_arg); + return result; +} +KOALA_INTEROP_6(UpdateTSMappedType, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt, KInt); + +KNativePointer impl_TSMappedTypeTypeParameter(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSMappedTypeTypeParameter(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSMappedTypeTypeParameter, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSMappedTypeTypeAnnotation(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSMappedTypeTypeAnnotation(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSMappedTypeTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +KInt impl_TSMappedTypeReadonly(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSMappedTypeReadonly(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSMappedTypeReadonly, KInt, KNativePointer, KNativePointer); + +KInt impl_TSMappedTypeOptional(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSMappedTypeOptional(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSMappedTypeOptional, KInt, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSAnyKeyword(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateTSAnyKeyword(_context); + return result; +} +KOALA_INTEROP_1(CreateTSAnyKeyword, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSAnyKeyword(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateTSAnyKeyword(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateTSAnyKeyword, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateClassDeclaration(KNativePointer context, KNativePointer def) +{ + const auto _context = reinterpret_cast(context); + const auto _def = reinterpret_cast(def); + auto result = GetImpl()->CreateClassDeclaration(_context, _def); + return result; +} +KOALA_INTEROP_2(CreateClassDeclaration, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateClassDeclaration(KNativePointer context, KNativePointer original, KNativePointer def) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _def = reinterpret_cast(def); + auto result = GetImpl()->UpdateClassDeclaration(_context, _original, _def); + return result; +} +KOALA_INTEROP_3(UpdateClassDeclaration, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDeclarationDefinition(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDeclarationDefinition(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ClassDeclarationDefinition, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ClassDeclarationDefinitionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ClassDeclarationDefinitionConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ClassDeclarationDefinitionConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ClassDeclarationSetDefinition(KNativePointer context, KNativePointer receiver, KNativePointer def) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _def = reinterpret_cast(def); + GetImpl()->ClassDeclarationSetDefinition(_context, _receiver, _def); + return ; +} +KOALA_INTEROP_V3(ClassDeclarationSetDefinition, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSIndexedAccessType(KNativePointer context, KNativePointer objectType, KNativePointer indexType) +{ + const auto _context = reinterpret_cast(context); + const auto _objectType = reinterpret_cast(objectType); + const auto _indexType = reinterpret_cast(indexType); + auto result = GetImpl()->CreateTSIndexedAccessType(_context, _objectType, _indexType); + return result; +} +KOALA_INTEROP_3(CreateTSIndexedAccessType, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSIndexedAccessType(KNativePointer context, KNativePointer original, KNativePointer objectType, KNativePointer indexType) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _objectType = reinterpret_cast(objectType); + const auto _indexType = reinterpret_cast(indexType); + auto result = GetImpl()->UpdateTSIndexedAccessType(_context, _original, _objectType, _indexType); + return result; +} +KOALA_INTEROP_4(UpdateTSIndexedAccessType, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSIndexedAccessTypeObjectTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSIndexedAccessTypeObjectTypeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSIndexedAccessTypeObjectTypeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSIndexedAccessTypeIndexTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSIndexedAccessTypeIndexTypeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSIndexedAccessTypeIndexTypeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSQualifiedName(KNativePointer context, KNativePointer left, KNativePointer right) +{ + const auto _context = reinterpret_cast(context); + const auto _left = reinterpret_cast(left); + const auto _right = reinterpret_cast(right); + auto result = GetImpl()->CreateTSQualifiedName(_context, _left, _right); + return result; +} +KOALA_INTEROP_3(CreateTSQualifiedName, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSQualifiedName(KNativePointer context, KNativePointer original, KNativePointer left, KNativePointer right) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _left = reinterpret_cast(left); + const auto _right = reinterpret_cast(right); + auto result = GetImpl()->UpdateTSQualifiedName(_context, _original, _left, _right); + return result; +} +KOALA_INTEROP_4(UpdateTSQualifiedName, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSQualifiedNameLeftConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSQualifiedNameLeftConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSQualifiedNameLeftConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSQualifiedNameLeft(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSQualifiedNameLeft(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSQualifiedNameLeft, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSQualifiedNameRightConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSQualifiedNameRightConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSQualifiedNameRightConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSQualifiedNameRight(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSQualifiedNameRight(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSQualifiedNameRight, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSQualifiedNameNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSQualifiedNameNameConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(TSQualifiedNameNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSQualifiedNameResolveLeftMostQualifiedName(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSQualifiedNameResolveLeftMostQualifiedName(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSQualifiedNameResolveLeftMostQualifiedName, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSQualifiedNameResolveLeftMostQualifiedNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSQualifiedNameResolveLeftMostQualifiedNameConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSQualifiedNameResolveLeftMostQualifiedNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateAwaitExpression(KNativePointer context, KNativePointer argument) +{ + const auto _context = reinterpret_cast(context); + const auto _argument = reinterpret_cast(argument); + auto result = GetImpl()->CreateAwaitExpression(_context, _argument); + return result; +} +KOALA_INTEROP_2(CreateAwaitExpression, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateAwaitExpression(KNativePointer context, KNativePointer original, KNativePointer argument) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _argument = reinterpret_cast(argument); + auto result = GetImpl()->UpdateAwaitExpression(_context, _original, _argument); + return result; +} +KOALA_INTEROP_3(UpdateAwaitExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_AwaitExpressionArgumentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AwaitExpressionArgumentConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(AwaitExpressionArgumentConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateValidationInfo(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateValidationInfo(_context); + return result; +} +KOALA_INTEROP_1(CreateValidationInfo, KNativePointer, KNativePointer); + +KNativePointer impl_CreateValidationInfo1(KNativePointer context, KStringPtr& m, KNativePointer p) +{ + const auto _context = reinterpret_cast(context); + const auto _m = getStringCopy(m); + const auto _p = reinterpret_cast(p); + auto result = GetImpl()->CreateValidationInfo1(_context, _m, _p); + return result; +} +KOALA_INTEROP_3(CreateValidationInfo1, KNativePointer, KNativePointer, KStringPtr, KNativePointer); + +KBoolean impl_ValidationInfoFailConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ValidationInfoFailConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ValidationInfoFailConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateContinueStatement(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateContinueStatement(_context); + return result; +} +KOALA_INTEROP_1(CreateContinueStatement, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateContinueStatement(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateContinueStatement(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateContinueStatement, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateContinueStatement1(KNativePointer context, KNativePointer ident) +{ + const auto _context = reinterpret_cast(context); + const auto _ident = reinterpret_cast(ident); + auto result = GetImpl()->CreateContinueStatement1(_context, _ident); + return result; +} +KOALA_INTEROP_2(CreateContinueStatement1, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateContinueStatement1(KNativePointer context, KNativePointer original, KNativePointer ident) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _ident = reinterpret_cast(ident); + auto result = GetImpl()->UpdateContinueStatement1(_context, _original, _ident); + return result; +} +KOALA_INTEROP_3(UpdateContinueStatement1, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ContinueStatementIdentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ContinueStatementIdentConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ContinueStatementIdentConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ContinueStatementIdent(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ContinueStatementIdent(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ContinueStatementIdent, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ContinueStatementTargetConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ContinueStatementTargetConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ContinueStatementTargetConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ContinueStatementHasTargetConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ContinueStatementHasTargetConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ContinueStatementHasTargetConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ContinueStatementSetTarget(KNativePointer context, KNativePointer receiver, KNativePointer target) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _target = reinterpret_cast(target); + GetImpl()->ContinueStatementSetTarget(_context, _receiver, _target); + return ; +} +KOALA_INTEROP_V3(ContinueStatementSetTarget, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSNewMultiDimArrayInstanceExpression(KNativePointer context, KNativePointer typeReference, KNativePointerArray dimensions, KUInt dimensionsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _typeReference = reinterpret_cast(typeReference); + const auto _dimensions = reinterpret_cast(dimensions); + const auto _dimensionsSequenceLength = static_cast(dimensionsSequenceLength); + auto result = GetImpl()->CreateETSNewMultiDimArrayInstanceExpression(_context, _typeReference, _dimensions, _dimensionsSequenceLength); + return result; +} +KOALA_INTEROP_4(CreateETSNewMultiDimArrayInstanceExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateETSNewMultiDimArrayInstanceExpression(KNativePointer context, KNativePointer original, KNativePointer typeReference, KNativePointerArray dimensions, KUInt dimensionsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _typeReference = reinterpret_cast(typeReference); + const auto _dimensions = reinterpret_cast(dimensions); + const auto _dimensionsSequenceLength = static_cast(dimensionsSequenceLength); + auto result = GetImpl()->UpdateETSNewMultiDimArrayInstanceExpression(_context, _original, _typeReference, _dimensions, _dimensionsSequenceLength); + return result; +} +KOALA_INTEROP_5(UpdateETSNewMultiDimArrayInstanceExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateETSNewMultiDimArrayInstanceExpression1(KNativePointer context, KNativePointer other) +{ + const auto _context = reinterpret_cast(context); + const auto _other = reinterpret_cast(other); + auto result = GetImpl()->CreateETSNewMultiDimArrayInstanceExpression1(_context, _other); + return result; +} +KOALA_INTEROP_2(CreateETSNewMultiDimArrayInstanceExpression1, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSNewMultiDimArrayInstanceExpression1(KNativePointer context, KNativePointer original, KNativePointer other) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _other = reinterpret_cast(other); + auto result = GetImpl()->UpdateETSNewMultiDimArrayInstanceExpression1(_context, _original, _other); + return result; +} +KOALA_INTEROP_3(UpdateETSNewMultiDimArrayInstanceExpression1, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSNewMultiDimArrayInstanceExpressionTypeReference(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSNewMultiDimArrayInstanceExpressionTypeReference(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSNewMultiDimArrayInstanceExpressionTypeReference, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSNewMultiDimArrayInstanceExpressionTypeReferenceConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSNewMultiDimArrayInstanceExpressionTypeReferenceConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSNewMultiDimArrayInstanceExpressionTypeReferenceConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSNewMultiDimArrayInstanceExpressionDimensions(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ETSNewMultiDimArrayInstanceExpressionDimensions(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ETSNewMultiDimArrayInstanceExpressionDimensions, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSNewMultiDimArrayInstanceExpressionDimensionsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ETSNewMultiDimArrayInstanceExpressionDimensionsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ETSNewMultiDimArrayInstanceExpressionDimensionsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ETSNewMultiDimArrayInstanceExpressionClearPreferredType(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ETSNewMultiDimArrayInstanceExpressionClearPreferredType(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ETSNewMultiDimArrayInstanceExpressionClearPreferredType, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSNamedTupleMember(KNativePointer context, KNativePointer label, KNativePointer elementType, KBoolean optional_arg) +{ + const auto _context = reinterpret_cast(context); + const auto _label = reinterpret_cast(label); + const auto _elementType = reinterpret_cast(elementType); + const auto _optional_arg = static_cast(optional_arg); + auto result = GetImpl()->CreateTSNamedTupleMember(_context, _label, _elementType, _optional_arg); + return result; +} +KOALA_INTEROP_4(CreateTSNamedTupleMember, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_UpdateTSNamedTupleMember(KNativePointer context, KNativePointer original, KNativePointer label, KNativePointer elementType, KBoolean optional_arg) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _label = reinterpret_cast(label); + const auto _elementType = reinterpret_cast(elementType); + const auto _optional_arg = static_cast(optional_arg); + auto result = GetImpl()->UpdateTSNamedTupleMember(_context, _original, _label, _elementType, _optional_arg); + return result; +} +KOALA_INTEROP_5(UpdateTSNamedTupleMember, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_TSNamedTupleMemberLabelConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSNamedTupleMemberLabelConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSNamedTupleMemberLabelConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSNamedTupleMemberElementType(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSNamedTupleMemberElementType(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSNamedTupleMemberElementType, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSNamedTupleMemberElementTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSNamedTupleMemberElementTypeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSNamedTupleMemberElementTypeConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_TSNamedTupleMemberIsOptionalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSNamedTupleMemberIsOptionalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSNamedTupleMemberIsOptionalConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateImportExpression(KNativePointer context, KNativePointer source) +{ + const auto _context = reinterpret_cast(context); + const auto _source = reinterpret_cast(source); + auto result = GetImpl()->CreateImportExpression(_context, _source); + return result; +} +KOALA_INTEROP_2(CreateImportExpression, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateImportExpression(KNativePointer context, KNativePointer original, KNativePointer source) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _source = reinterpret_cast(source); + auto result = GetImpl()->UpdateImportExpression(_context, _original, _source); + return result; +} +KOALA_INTEROP_3(UpdateImportExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ImportExpressionSource(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ImportExpressionSource(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ImportExpressionSource, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ImportExpressionSourceConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ImportExpressionSourceConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ImportExpressionSourceConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateAstDumper(KNativePointer context, KNativePointer node, KStringPtr& sourceCode) +{ + const auto _context = reinterpret_cast(context); + const auto _node = reinterpret_cast(node); + const auto _sourceCode = getStringCopy(sourceCode); + auto result = GetImpl()->CreateAstDumper(_context, _node, _sourceCode); + return result; +} +KOALA_INTEROP_3(CreateAstDumper, KNativePointer, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_AstDumperModifierToString(KNativePointer context, KNativePointer receiver, KInt flags) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _flags = static_cast(flags); + auto result = GetImpl()->AstDumperModifierToString(_context, _receiver, _flags); + return StageArena::strdup(result); +} +KOALA_INTEROP_3(AstDumperModifierToString, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_AstDumperTypeOperatorToString(KNativePointer context, KNativePointer receiver, KInt operatorType) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _operatorType = static_cast(operatorType); + auto result = GetImpl()->AstDumperTypeOperatorToString(_context, _receiver, _operatorType); + return StageArena::strdup(result); +} +KOALA_INTEROP_3(AstDumperTypeOperatorToString, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_AstDumperStrConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->AstDumperStrConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(AstDumperStrConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSNullType(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateETSNullTypeIr(_context); + return result; +} +KOALA_INTEROP_1(CreateETSNullType, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSNullType(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateETSNullTypeIr(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateETSNullType, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSUndefinedType(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateETSUndefinedTypeIr(_context); + return result; +} +KOALA_INTEROP_1(CreateETSUndefinedType, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSUndefinedType(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateETSUndefinedTypeIr(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateETSUndefinedType, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTypeofExpression(KNativePointer context, KNativePointer argument) +{ + const auto _context = reinterpret_cast(context); + const auto _argument = reinterpret_cast(argument); + auto result = GetImpl()->CreateTypeofExpression(_context, _argument); + return result; +} +KOALA_INTEROP_2(CreateTypeofExpression, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTypeofExpression(KNativePointer context, KNativePointer original, KNativePointer argument) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _argument = reinterpret_cast(argument); + auto result = GetImpl()->UpdateTypeofExpression(_context, _original, _argument); + return result; +} +KOALA_INTEROP_3(UpdateTypeofExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TypeofExpressionArgumentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TypeofExpressionArgumentConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TypeofExpressionArgumentConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSEnumMember(KNativePointer context, KNativePointer key, KNativePointer init) +{ + const auto _context = reinterpret_cast(context); + const auto _key = reinterpret_cast(key); + const auto _init = reinterpret_cast(init); + auto result = GetImpl()->CreateTSEnumMember(_context, _key, _init); + return result; +} +KOALA_INTEROP_3(CreateTSEnumMember, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSEnumMember(KNativePointer context, KNativePointer original, KNativePointer key, KNativePointer init) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _key = reinterpret_cast(key); + const auto _init = reinterpret_cast(init); + auto result = GetImpl()->UpdateTSEnumMember(_context, _original, _key, _init); + return result; +} +KOALA_INTEROP_4(UpdateTSEnumMember, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSEnumMember1(KNativePointer context, KNativePointer key, KNativePointer init, KBoolean isGenerated) +{ + const auto _context = reinterpret_cast(context); + const auto _key = reinterpret_cast(key); + const auto _init = reinterpret_cast(init); + const auto _isGenerated = static_cast(isGenerated); + auto result = GetImpl()->CreateTSEnumMember1(_context, _key, _init, _isGenerated); + return result; +} +KOALA_INTEROP_4(CreateTSEnumMember1, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_UpdateTSEnumMember1(KNativePointer context, KNativePointer original, KNativePointer key, KNativePointer init, KBoolean isGenerated) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _key = reinterpret_cast(key); + const auto _init = reinterpret_cast(init); + const auto _isGenerated = static_cast(isGenerated); + auto result = GetImpl()->UpdateTSEnumMember1(_context, _original, _key, _init, _isGenerated); + return result; +} +KOALA_INTEROP_5(UpdateTSEnumMember1, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_TSEnumMemberKeyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSEnumMemberKeyConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSEnumMemberKeyConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSEnumMemberKey(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSEnumMemberKey(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSEnumMemberKey, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSEnumMemberInitConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSEnumMemberInitConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSEnumMemberInitConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSEnumMemberInit(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSEnumMemberInit(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSEnumMemberInit, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_TSEnumMemberIsGeneratedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSEnumMemberIsGeneratedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSEnumMemberIsGeneratedConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_TSEnumMemberNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSEnumMemberNameConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(TSEnumMemberNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateSwitchStatement(KNativePointer context, KNativePointer discriminant, KNativePointerArray cases, KUInt casesSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _discriminant = reinterpret_cast(discriminant); + const auto _cases = reinterpret_cast(cases); + const auto _casesSequenceLength = static_cast(casesSequenceLength); + auto result = GetImpl()->CreateSwitchStatement(_context, _discriminant, _cases, _casesSequenceLength); + return result; +} +KOALA_INTEROP_4(CreateSwitchStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateSwitchStatement(KNativePointer context, KNativePointer original, KNativePointer discriminant, KNativePointerArray cases, KUInt casesSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _discriminant = reinterpret_cast(discriminant); + const auto _cases = reinterpret_cast(cases); + const auto _casesSequenceLength = static_cast(casesSequenceLength); + auto result = GetImpl()->UpdateSwitchStatement(_context, _original, _discriminant, _cases, _casesSequenceLength); + return result; +} +KOALA_INTEROP_5(UpdateSwitchStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_SwitchStatementDiscriminantConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->SwitchStatementDiscriminantConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(SwitchStatementDiscriminantConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_SwitchStatementDiscriminant(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->SwitchStatementDiscriminant(_context, _receiver); + return result; +} +KOALA_INTEROP_2(SwitchStatementDiscriminant, KNativePointer, KNativePointer, KNativePointer); + +void impl_SwitchStatementSetDiscriminant(KNativePointer context, KNativePointer receiver, KNativePointer discriminant) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _discriminant = reinterpret_cast(discriminant); + GetImpl()->SwitchStatementSetDiscriminant(_context, _receiver, _discriminant); + return ; +} +KOALA_INTEROP_V3(SwitchStatementSetDiscriminant, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_SwitchStatementCasesConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->SwitchStatementCasesConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(SwitchStatementCasesConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_SwitchStatementCases(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->SwitchStatementCases(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(SwitchStatementCases, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateDoWhileStatement(KNativePointer context, KNativePointer body, KNativePointer test) +{ + const auto _context = reinterpret_cast(context); + const auto _body = reinterpret_cast(body); + const auto _test = reinterpret_cast(test); + auto result = GetImpl()->CreateDoWhileStatement(_context, _body, _test); + return result; +} +KOALA_INTEROP_3(CreateDoWhileStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateDoWhileStatement(KNativePointer context, KNativePointer original, KNativePointer body, KNativePointer test) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _body = reinterpret_cast(body); + const auto _test = reinterpret_cast(test); + auto result = GetImpl()->UpdateDoWhileStatement(_context, _original, _body, _test); + return result; +} +KOALA_INTEROP_4(UpdateDoWhileStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_DoWhileStatementBodyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->DoWhileStatementBodyConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(DoWhileStatementBodyConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_DoWhileStatementBody(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->DoWhileStatementBody(_context, _receiver); + return result; +} +KOALA_INTEROP_2(DoWhileStatementBody, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_DoWhileStatementTestConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->DoWhileStatementTestConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(DoWhileStatementTestConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_DoWhileStatementTest(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->DoWhileStatementTest(_context, _receiver); + return result; +} +KOALA_INTEROP_2(DoWhileStatementTest, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateCatchClause(KNativePointer context, KNativePointer param, KNativePointer body) +{ + const auto _context = reinterpret_cast(context); + const auto _param = reinterpret_cast(param); + const auto _body = reinterpret_cast(body); + auto result = GetImpl()->CreateCatchClause(_context, _param, _body); + return result; +} +KOALA_INTEROP_3(CreateCatchClause, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateCatchClause(KNativePointer context, KNativePointer original, KNativePointer param, KNativePointer body) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _param = reinterpret_cast(param); + const auto _body = reinterpret_cast(body); + auto result = GetImpl()->UpdateCatchClause(_context, _original, _param, _body); + return result; +} +KOALA_INTEROP_4(UpdateCatchClause, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateCatchClause1(KNativePointer context, KNativePointer other) +{ + const auto _context = reinterpret_cast(context); + const auto _other = reinterpret_cast(other); + auto result = GetImpl()->CreateCatchClause1(_context, _other); + return result; +} +KOALA_INTEROP_2(CreateCatchClause1, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateCatchClause1(KNativePointer context, KNativePointer original, KNativePointer other) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _other = reinterpret_cast(other); + auto result = GetImpl()->UpdateCatchClause1(_context, _original, _other); + return result; +} +KOALA_INTEROP_3(UpdateCatchClause1, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CatchClauseParam(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->CatchClauseParam(_context, _receiver); + return result; +} +KOALA_INTEROP_2(CatchClauseParam, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CatchClauseParamConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->CatchClauseParamConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(CatchClauseParamConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CatchClauseBody(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->CatchClauseBody(_context, _receiver); + return result; +} +KOALA_INTEROP_2(CatchClauseBody, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CatchClauseBodyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->CatchClauseBodyConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(CatchClauseBodyConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_CatchClauseIsDefaultCatchClauseConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->CatchClauseIsDefaultCatchClauseConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(CatchClauseIsDefaultCatchClauseConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_CreateSequenceExpression(KNativePointer context, KNativePointerArray sequence_arg, KUInt sequence_argSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _sequence_arg = reinterpret_cast(sequence_arg); + const auto _sequence_argSequenceLength = static_cast(sequence_argSequenceLength); + auto result = GetImpl()->CreateSequenceExpression(_context, _sequence_arg, _sequence_argSequenceLength); + return result; +} +KOALA_INTEROP_3(CreateSequenceExpression, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateSequenceExpression(KNativePointer context, KNativePointer original, KNativePointerArray sequence_arg, KUInt sequence_argSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _sequence_arg = reinterpret_cast(sequence_arg); + const auto _sequence_argSequenceLength = static_cast(sequence_argSequenceLength); + auto result = GetImpl()->UpdateSequenceExpression(_context, _original, _sequence_arg, _sequence_argSequenceLength); + return result; +} +KOALA_INTEROP_4(UpdateSequenceExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_SequenceExpressionSequenceConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->SequenceExpressionSequenceConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(SequenceExpressionSequenceConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_SequenceExpressionSequence(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->SequenceExpressionSequence(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(SequenceExpressionSequence, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateArrowFunctionExpression(KNativePointer context, KNativePointer func) +{ + const auto _context = reinterpret_cast(context); + const auto _func = reinterpret_cast(func); + auto result = GetImpl()->CreateArrowFunctionExpression(_context, _func); + return result; +} +KOALA_INTEROP_2(CreateArrowFunctionExpression, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateArrowFunctionExpression(KNativePointer context, KNativePointer original, KNativePointer func) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _func = reinterpret_cast(func); + auto result = GetImpl()->UpdateArrowFunctionExpression(_context, _original, _func); + return result; +} +KOALA_INTEROP_3(UpdateArrowFunctionExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateArrowFunctionExpression1(KNativePointer context, KNativePointer other) +{ + const auto _context = reinterpret_cast(context); + const auto _other = reinterpret_cast(other); + auto result = GetImpl()->CreateArrowFunctionExpression1(_context, _other); + return result; +} +KOALA_INTEROP_2(CreateArrowFunctionExpression1, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateArrowFunctionExpression1(KNativePointer context, KNativePointer original, KNativePointer other) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _other = reinterpret_cast(other); + auto result = GetImpl()->UpdateArrowFunctionExpression1(_context, _original, _other); + return result; +} +KOALA_INTEROP_3(UpdateArrowFunctionExpression1, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ArrowFunctionExpressionFunctionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ArrowFunctionExpressionFunctionConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ArrowFunctionExpressionFunctionConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ArrowFunctionExpressionFunction(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ArrowFunctionExpressionFunction(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ArrowFunctionExpressionFunction, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ArrowFunctionExpressionCreateTypeAnnotation(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ArrowFunctionExpressionCreateTypeAnnotation(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ArrowFunctionExpressionCreateTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ArrowFunctionExpressionHasAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ArrowFunctionExpressionHasAnnotationsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ArrowFunctionExpressionHasAnnotationsConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ArrowFunctionExpressionEmplaceAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer source) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + GetImpl()->ArrowFunctionExpressionEmplaceAnnotation(_context, _receiver, _source); + return ; +} +KOALA_INTEROP_V3(ArrowFunctionExpressionEmplaceAnnotation, KNativePointer, KNativePointer, KNativePointer); + +void impl_ArrowFunctionExpressionClearAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ArrowFunctionExpressionClearAnnotations(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ArrowFunctionExpressionClearAnnotations, KNativePointer, KNativePointer); + +void impl_ArrowFunctionExpressionDumpAnnotationsConst(KNativePointer context, KNativePointer receiver, KNativePointer dumper) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _dumper = reinterpret_cast(dumper); + GetImpl()->ArrowFunctionExpressionDumpAnnotationsConst(_context, _receiver, _dumper); + return ; +} +KOALA_INTEROP_V3(ArrowFunctionExpressionDumpAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ArrowFunctionExpressionAnnotationsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ArrowFunctionExpressionAnnotationsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ArrowFunctionExpressionAnnotationsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ArrowFunctionExpressionAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ArrowFunctionExpressionAnnotations(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ArrowFunctionExpressionAnnotations, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ArrowFunctionExpressionAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ArrowFunctionExpressionAnnotationsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ArrowFunctionExpressionAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ArrowFunctionExpressionSetAnnotations(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->ArrowFunctionExpressionSetAnnotations(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(ArrowFunctionExpressionSetAnnotations, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_ArrowFunctionExpressionSetAnnotations1(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->ArrowFunctionExpressionSetAnnotations1(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(ArrowFunctionExpressionSetAnnotations1, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateOmittedExpression(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateOmittedExpression(_context); + return result; +} +KOALA_INTEROP_1(CreateOmittedExpression, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateOmittedExpression(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateOmittedExpression(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateOmittedExpression, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSNewClassInstanceExpression(KNativePointer context, KNativePointer typeReference, KNativePointerArray _arguments, KUInt _argumentsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _typeReference = reinterpret_cast(typeReference); + const auto __arguments = reinterpret_cast(_arguments); + const auto __argumentsSequenceLength = static_cast(_argumentsSequenceLength); + auto result = GetImpl()->CreateETSNewClassInstanceExpression(_context, _typeReference, __arguments, __argumentsSequenceLength); + return result; +} +KOALA_INTEROP_4(CreateETSNewClassInstanceExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateETSNewClassInstanceExpression(KNativePointer context, KNativePointer original, KNativePointer typeReference, KNativePointerArray _arguments, KUInt _argumentsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _typeReference = reinterpret_cast(typeReference); + const auto __arguments = reinterpret_cast(_arguments); + const auto __argumentsSequenceLength = static_cast(_argumentsSequenceLength); + auto result = GetImpl()->UpdateETSNewClassInstanceExpression(_context, _original, _typeReference, __arguments, __argumentsSequenceLength); + return result; +} +KOALA_INTEROP_5(UpdateETSNewClassInstanceExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateETSNewClassInstanceExpression1(KNativePointer context, KNativePointer other) +{ + const auto _context = reinterpret_cast(context); + const auto _other = reinterpret_cast(other); + auto result = GetImpl()->CreateETSNewClassInstanceExpression1(_context, _other); + return result; +} +KOALA_INTEROP_2(CreateETSNewClassInstanceExpression1, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSNewClassInstanceExpression1(KNativePointer context, KNativePointer original, KNativePointer other) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _other = reinterpret_cast(other); + auto result = GetImpl()->UpdateETSNewClassInstanceExpression1(_context, _original, _other); + return result; +} +KOALA_INTEROP_3(UpdateETSNewClassInstanceExpression1, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSNewClassInstanceExpressionGetTypeRefConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSNewClassInstanceExpressionGetTypeRefConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSNewClassInstanceExpressionGetTypeRefConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSNewClassInstanceExpressionGetArguments(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ETSNewClassInstanceExpressionGetArguments(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ETSNewClassInstanceExpressionGetArguments, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSNewClassInstanceExpressionGetArgumentsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->ETSNewClassInstanceExpressionGetArgumentsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(ETSNewClassInstanceExpressionGetArgumentsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ETSNewClassInstanceExpressionSetArguments(KNativePointer context, KNativePointer receiver, KNativePointerArray _arguments, KUInt _argumentsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto __arguments = reinterpret_cast(_arguments); + const auto __argumentsSequenceLength = static_cast(_argumentsSequenceLength); + GetImpl()->ETSNewClassInstanceExpressionSetArguments(_context, _receiver, __arguments, __argumentsSequenceLength); + return ; +} +KOALA_INTEROP_V4(ETSNewClassInstanceExpressionSetArguments, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_ETSNewClassInstanceExpressionAddToArgumentsFront(KNativePointer context, KNativePointer receiver, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _expr = reinterpret_cast(expr); + GetImpl()->ETSNewClassInstanceExpressionAddToArgumentsFront(_context, _receiver, _expr); + return ; +} +KOALA_INTEROP_V3(ETSNewClassInstanceExpressionAddToArgumentsFront, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSAsExpression(KNativePointer context, KNativePointer expression, KNativePointer typeAnnotation, KBoolean isConst) +{ + const auto _context = reinterpret_cast(context); + const auto _expression = reinterpret_cast(expression); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + const auto _isConst = static_cast(isConst); + auto result = GetImpl()->CreateTSAsExpression(_context, _expression, _typeAnnotation, _isConst); + return result; +} +KOALA_INTEROP_4(CreateTSAsExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_UpdateTSAsExpression(KNativePointer context, KNativePointer original, KNativePointer expression, KNativePointer typeAnnotation, KBoolean isConst) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _expression = reinterpret_cast(expression); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + const auto _isConst = static_cast(isConst); + auto result = GetImpl()->UpdateTSAsExpression(_context, _original, _expression, _typeAnnotation, _isConst); + return result; +} +KOALA_INTEROP_5(UpdateTSAsExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_TSAsExpressionExprConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSAsExpressionExprConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSAsExpressionExprConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TSAsExpressionExpr(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSAsExpressionExpr(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSAsExpressionExpr, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSAsExpressionSetExpr(KNativePointer context, KNativePointer receiver, KNativePointer expr) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _expr = reinterpret_cast(expr); + GetImpl()->TSAsExpressionSetExpr(_context, _receiver, _expr); + return ; +} +KOALA_INTEROP_V3(TSAsExpressionSetExpr, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_TSAsExpressionIsConstConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSAsExpressionIsConstConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSAsExpressionIsConstConst, KBoolean, KNativePointer, KNativePointer); + +void impl_TSAsExpressionSetUncheckedCast(KNativePointer context, KNativePointer receiver, KBoolean isUncheckedCast) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _isUncheckedCast = static_cast(isUncheckedCast); + GetImpl()->TSAsExpressionSetUncheckedCast(_context, _receiver, _isUncheckedCast); + return ; +} +KOALA_INTEROP_V3(TSAsExpressionSetUncheckedCast, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_TSAsExpressionTypeAnnotationConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSAsExpressionTypeAnnotationConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSAsExpressionTypeAnnotationConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_TSAsExpressionSetTsTypeAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer typeAnnotation) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _typeAnnotation = reinterpret_cast(typeAnnotation); + GetImpl()->TSAsExpressionSetTsTypeAnnotation(_context, _receiver, _typeAnnotation); + return ; +} +KOALA_INTEROP_V3(TSAsExpressionSetTsTypeAnnotation, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateForUpdateStatement(KNativePointer context, KNativePointer init, KNativePointer test, KNativePointer update, KNativePointer body) +{ + const auto _context = reinterpret_cast(context); + const auto _init = reinterpret_cast(init); + const auto _test = reinterpret_cast(test); + const auto _update = reinterpret_cast(update); + const auto _body = reinterpret_cast(body); + auto result = GetImpl()->CreateForUpdateStatement(_context, _init, _test, _update, _body); + return result; +} +KOALA_INTEROP_5(CreateForUpdateStatement, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForUpdateStatementInit(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForUpdateStatementInit(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ForUpdateStatementInit, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForUpdateStatementInitConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForUpdateStatementInitConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ForUpdateStatementInitConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForUpdateStatementTest(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForUpdateStatementTest(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ForUpdateStatementTest, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForUpdateStatementTestConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForUpdateStatementTestConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ForUpdateStatementTestConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForUpdateStatementUpdateConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForUpdateStatementUpdateConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ForUpdateStatementUpdateConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForUpdateStatementBody(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForUpdateStatementBody(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ForUpdateStatementBody, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ForUpdateStatementBodyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ForUpdateStatementBodyConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ForUpdateStatementBodyConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSTypeReferencePart(KNativePointer context, KNativePointer name, KNativePointer typeParams, KNativePointer prev) +{ + const auto _context = reinterpret_cast(context); + const auto _name = reinterpret_cast(name); + const auto _typeParams = reinterpret_cast(typeParams); + const auto _prev = reinterpret_cast(prev); + auto result = GetImpl()->CreateETSTypeReferencePart(_context, _name, _typeParams, _prev); + return result; +} +KOALA_INTEROP_4(CreateETSTypeReferencePart, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSTypeReferencePart(KNativePointer context, KNativePointer original, KNativePointer name, KNativePointer typeParams, KNativePointer prev) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _name = reinterpret_cast(name); + const auto _typeParams = reinterpret_cast(typeParams); + const auto _prev = reinterpret_cast(prev); + auto result = GetImpl()->UpdateETSTypeReferencePart(_context, _original, _name, _typeParams, _prev); + return result; +} +KOALA_INTEROP_5(UpdateETSTypeReferencePart, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSTypeReferencePart1(KNativePointer context, KNativePointer name) +{ + const auto _context = reinterpret_cast(context); + const auto _name = reinterpret_cast(name); + auto result = GetImpl()->CreateETSTypeReferencePart1(_context, _name); + return result; +} +KOALA_INTEROP_2(CreateETSTypeReferencePart1, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateETSTypeReferencePart1(KNativePointer context, KNativePointer original, KNativePointer name) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _name = reinterpret_cast(name); + auto result = GetImpl()->UpdateETSTypeReferencePart1(_context, _original, _name); + return result; +} +KOALA_INTEROP_3(UpdateETSTypeReferencePart1, KNativePointer, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSTypeReferencePartPrevious(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSTypeReferencePartPrevious(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSTypeReferencePartPrevious, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSTypeReferencePartPreviousConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSTypeReferencePartPreviousConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSTypeReferencePartPreviousConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSTypeReferencePartName(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSTypeReferencePartName(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSTypeReferencePartName, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSTypeReferencePartTypeParams(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSTypeReferencePartTypeParams(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSTypeReferencePartTypeParams, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSTypeReferencePartTypeParamsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSTypeReferencePartTypeParamsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSTypeReferencePartTypeParamsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSTypeReferencePartNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSTypeReferencePartNameConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSTypeReferencePartNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSTypeReferencePartGetIdent(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSTypeReferencePartGetIdent(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSTypeReferencePartGetIdent, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSReExportDeclarationGetETSImportDeclarationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSReExportDeclarationGetETSImportDeclarationsConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSReExportDeclarationGetETSImportDeclarationsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSReExportDeclarationGetETSImportDeclarations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSReExportDeclarationGetETSImportDeclarations(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSReExportDeclarationGetETSImportDeclarations, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSReExportDeclarationGetProgramPathConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSReExportDeclarationGetProgramPathConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ETSReExportDeclarationGetProgramPathConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSPrimitiveType(KNativePointer context, KInt type) +{ + const auto _context = reinterpret_cast(context); + const auto _type = static_cast(type); + auto result = GetImpl()->CreateETSPrimitiveType(_context, _type); + return result; +} +KOALA_INTEROP_2(CreateETSPrimitiveType, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_UpdateETSPrimitiveType(KNativePointer context, KNativePointer original, KInt type) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _type = static_cast(type); + auto result = GetImpl()->UpdateETSPrimitiveType(_context, _original, _type); + return result; +} +KOALA_INTEROP_3(UpdateETSPrimitiveType, KNativePointer, KNativePointer, KNativePointer, KInt); + +KInt impl_ETSPrimitiveTypeGetPrimitiveTypeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSPrimitiveTypeGetPrimitiveTypeConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSPrimitiveTypeGetPrimitiveTypeConst, KInt, KNativePointer, KNativePointer); + +KBoolean impl_TypeNodeHasAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TypeNodeHasAnnotationsConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TypeNodeHasAnnotationsConst, KBoolean, KNativePointer, KNativePointer); + +void impl_TypeNodeEmplaceAnnotation(KNativePointer context, KNativePointer receiver, KNativePointer source) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _source = reinterpret_cast(source); + GetImpl()->TypeNodeEmplaceAnnotation(_context, _receiver, _source); + return ; +} +KOALA_INTEROP_V3(TypeNodeEmplaceAnnotation, KNativePointer, KNativePointer, KNativePointer); + +void impl_TypeNodeClearAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->TypeNodeClearAnnotations(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(TypeNodeClearAnnotations, KNativePointer, KNativePointer); + +void impl_TypeNodeDumpAnnotationsConst(KNativePointer context, KNativePointer receiver, KNativePointer dumper) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _dumper = reinterpret_cast(dumper); + GetImpl()->TypeNodeDumpAnnotationsConst(_context, _receiver, _dumper); + return ; +} +KOALA_INTEROP_V3(TypeNodeDumpAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TypeNodeAnnotationsForUpdate(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TypeNodeAnnotationsForUpdate(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TypeNodeAnnotationsForUpdate, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TypeNodeAnnotations(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TypeNodeAnnotations(_context, _receiver, &length); + return StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TypeNodeAnnotations, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_TypeNodeAnnotationsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->TypeNodeAnnotationsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(TypeNodeAnnotationsConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_TypeNodeSetAnnotations(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->TypeNodeSetAnnotations(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(TypeNodeSetAnnotations, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +void impl_TypeNodeSetAnnotations1(KNativePointer context, KNativePointer receiver, KNativePointerArray annotationList, KUInt annotationListSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _annotationList = reinterpret_cast(annotationList); + const auto _annotationListSequenceLength = static_cast(annotationListSequenceLength); + GetImpl()->TypeNodeSetAnnotations1(_context, _receiver, _annotationList, _annotationListSequenceLength); + return ; +} +KOALA_INTEROP_V4(TypeNodeSetAnnotations1, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_CreateNewExpression(KNativePointer context, KNativePointer callee, KNativePointerArray _arguments, KUInt _argumentsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _callee = reinterpret_cast(callee); + const auto __arguments = reinterpret_cast(_arguments); + const auto __argumentsSequenceLength = static_cast(_argumentsSequenceLength); + auto result = GetImpl()->CreateNewExpression(_context, _callee, __arguments, __argumentsSequenceLength); + return result; +} +KOALA_INTEROP_4(CreateNewExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_UpdateNewExpression(KNativePointer context, KNativePointer original, KNativePointer callee, KNativePointerArray _arguments, KUInt _argumentsSequenceLength) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _callee = reinterpret_cast(callee); + const auto __arguments = reinterpret_cast(_arguments); + const auto __argumentsSequenceLength = static_cast(_argumentsSequenceLength); + auto result = GetImpl()->UpdateNewExpression(_context, _original, _callee, __arguments, __argumentsSequenceLength); + return result; +} +KOALA_INTEROP_5(UpdateNewExpression, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KNativePointerArray, KUInt); + +KNativePointer impl_NewExpressionCalleeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->NewExpressionCalleeConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(NewExpressionCalleeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_NewExpressionArgumentsConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + std::size_t length; + auto result = GetImpl()->NewExpressionArgumentsConst(_context, _receiver, &length); + return (void*)StageArena::cloneVector(result, length); +} +KOALA_INTEROP_2(NewExpressionArgumentsConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSParameterProperty(KNativePointer context, KInt accessibility, KNativePointer parameter, KBoolean readonly_arg, KBoolean isStatic, KBoolean isExport) +{ + const auto _context = reinterpret_cast(context); + const auto _accessibility = static_cast(accessibility); + const auto _parameter = reinterpret_cast(parameter); + const auto _readonly_arg = static_cast(readonly_arg); + const auto _isStatic = static_cast(isStatic); + const auto _isExport = static_cast(isExport); + auto result = GetImpl()->CreateTSParameterProperty(_context, _accessibility, _parameter, _readonly_arg, _isStatic, _isExport); + return result; +} +KOALA_INTEROP_6(CreateTSParameterProperty, KNativePointer, KNativePointer, KInt, KNativePointer, KBoolean, KBoolean, KBoolean); + +KNativePointer impl_UpdateTSParameterProperty(KNativePointer context, KNativePointer original, KInt accessibility, KNativePointer parameter, KBoolean readonly_arg, KBoolean isStatic, KBoolean isExport) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _accessibility = static_cast(accessibility); + const auto _parameter = reinterpret_cast(parameter); + const auto _readonly_arg = static_cast(readonly_arg); + const auto _isStatic = static_cast(isStatic); + const auto _isExport = static_cast(isExport); + auto result = GetImpl()->UpdateTSParameterProperty(_context, _original, _accessibility, _parameter, _readonly_arg, _isStatic, _isExport); + return result; +} +KOALA_INTEROP_7(UpdateTSParameterProperty, KNativePointer, KNativePointer, KNativePointer, KInt, KNativePointer, KBoolean, KBoolean, KBoolean); + +KInt impl_TSParameterPropertyAccessibilityConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSParameterPropertyAccessibilityConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSParameterPropertyAccessibilityConst, KInt, KNativePointer, KNativePointer); + +KBoolean impl_TSParameterPropertyReadonlyConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSParameterPropertyReadonlyConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSParameterPropertyReadonlyConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_TSParameterPropertyIsStaticConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSParameterPropertyIsStaticConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSParameterPropertyIsStaticConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_TSParameterPropertyIsExportConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSParameterPropertyIsExportConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(TSParameterPropertyIsExportConst, KBoolean, KNativePointer, KNativePointer); + +KNativePointer impl_TSParameterPropertyParameterConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->TSParameterPropertyParameterConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(TSParameterPropertyParameterConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateETSWildcardType(KNativePointer context, KNativePointer typeReference, KInt flags) +{ + const auto _context = reinterpret_cast(context); + const auto _typeReference = reinterpret_cast(typeReference); + const auto _flags = static_cast(flags); + auto result = GetImpl()->CreateETSWildcardType(_context, _typeReference, _flags); + return result; +} +KOALA_INTEROP_3(CreateETSWildcardType, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_UpdateETSWildcardType(KNativePointer context, KNativePointer original, KNativePointer typeReference, KInt flags) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + const auto _typeReference = reinterpret_cast(typeReference); + const auto _flags = static_cast(flags); + auto result = GetImpl()->UpdateETSWildcardType(_context, _original, _typeReference, _flags); + return result; +} +KOALA_INTEROP_4(UpdateETSWildcardType, KNativePointer, KNativePointer, KNativePointer, KNativePointer, KInt); + +KNativePointer impl_ETSWildcardTypeTypeReference(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSWildcardTypeTypeReference(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ETSWildcardTypeTypeReference, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ETSWildcardTypeTypeReferenceConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ETSWildcardTypeTypeReferenceConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ETSWildcardTypeTypeReferenceConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_CreateTSThisType(KNativePointer context) +{ + const auto _context = reinterpret_cast(context); + auto result = GetImpl()->CreateTSThisType(_context); + return result; +} +KOALA_INTEROP_1(CreateTSThisType, KNativePointer, KNativePointer); + +KNativePointer impl_UpdateTSThisType(KNativePointer context, KNativePointer original) +{ + const auto _context = reinterpret_cast(context); + const auto _original = reinterpret_cast(original); + auto result = GetImpl()->UpdateTSThisType(_context, _original); + return result; +} +KOALA_INTEROP_2(UpdateTSThisType, KNativePointer, KNativePointer, KNativePointer); + +void impl_ProgramSetKind(KNativePointer context, KNativePointer receiver, KInt kind) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _kind = static_cast(kind); + GetImpl()->ProgramSetKind(_context, _receiver, _kind); + return ; +} +KOALA_INTEROP_V3(ProgramSetKind, KNativePointer, KNativePointer, KInt); + +void impl_ProgramPushVarBinder(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ProgramPushVarBinder(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ProgramPushVarBinder, KNativePointer, KNativePointer); + +void impl_ProgramPushChecker(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ProgramPushChecker(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ProgramPushChecker, KNativePointer, KNativePointer); + +KInt impl_ProgramKindConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramKindConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ProgramKindConst, KInt, KNativePointer, KNativePointer); + +KNativePointer impl_ProgramSourceCodeConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramSourceCodeConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ProgramSourceCodeConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ProgramSourceFilePathConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramSourceFilePathConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ProgramSourceFilePathConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ProgramSourceFileFolderConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramSourceFileFolderConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ProgramSourceFileFolderConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ProgramFileNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramFileNameConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ProgramFileNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ProgramFileNameWithExtensionConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramFileNameWithExtensionConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ProgramFileNameWithExtensionConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ProgramAbsoluteNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramAbsoluteNameConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ProgramAbsoluteNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ProgramResolvedFilePathConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramResolvedFilePathConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ProgramResolvedFilePathConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ProgramRelativeFilePathConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramRelativeFilePathConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ProgramRelativeFilePathConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ProgramSetRelativeFilePath(KNativePointer context, KNativePointer receiver, KStringPtr& relPath) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _relPath = getStringCopy(relPath); + GetImpl()->ProgramSetRelativeFilePath(_context, _receiver, _relPath); + return ; +} +KOALA_INTEROP_V3(ProgramSetRelativeFilePath, KNativePointer, KNativePointer, KStringPtr); + +KNativePointer impl_ProgramAst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramAst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ProgramAst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ProgramAstConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramAstConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ProgramAstConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ProgramSetAst(KNativePointer context, KNativePointer receiver, KNativePointer ast) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _ast = reinterpret_cast(ast); + GetImpl()->ProgramSetAst(_context, _receiver, _ast); + return ; +} +KOALA_INTEROP_V3(ProgramSetAst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ProgramGlobalClass(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramGlobalClass(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ProgramGlobalClass, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ProgramGlobalClassConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramGlobalClassConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ProgramGlobalClassConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ProgramSetGlobalClass(KNativePointer context, KNativePointer receiver, KNativePointer globalClass) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _globalClass = reinterpret_cast(globalClass); + GetImpl()->ProgramSetGlobalClass(_context, _receiver, _globalClass); + return ; +} +KOALA_INTEROP_V3(ProgramSetGlobalClass, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ProgramPackageStartConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramPackageStartConst(_context, _receiver); + return (void*)result; +} +KOALA_INTEROP_2(ProgramPackageStartConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ProgramSetPackageStart(KNativePointer context, KNativePointer receiver, KNativePointer start) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _start = reinterpret_cast(start); + GetImpl()->ProgramSetPackageStart(_context, _receiver, _start); + return ; +} +KOALA_INTEROP_V3(ProgramSetPackageStart, KNativePointer, KNativePointer, KNativePointer); + +void impl_ProgramSetSource(KNativePointer context, KNativePointer receiver, KStringPtr& sourceCode, KStringPtr& sourceFilePath, KStringPtr& sourceFileFolder) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _sourceCode = getStringCopy(sourceCode); + const auto _sourceFilePath = getStringCopy(sourceFilePath); + const auto _sourceFileFolder = getStringCopy(sourceFileFolder); + GetImpl()->ProgramSetSource(_context, _receiver, _sourceCode, _sourceFilePath, _sourceFileFolder); + return ; +} +KOALA_INTEROP_V5(ProgramSetSource, KNativePointer, KNativePointer, KStringPtr, KStringPtr, KStringPtr); + +void impl_ProgramSetPackageInfo(KNativePointer context, KNativePointer receiver, KStringPtr& name, KInt kind) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _name = getStringCopy(name); + const auto _kind = static_cast(kind); + GetImpl()->ProgramSetPackageInfo(_context, _receiver, _name, _kind); + return ; +} +KOALA_INTEROP_V4(ProgramSetPackageInfo, KNativePointer, KNativePointer, KStringPtr, KInt); + +KNativePointer impl_ProgramModuleNameConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramModuleNameConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ProgramModuleNameConst, KNativePointer, KNativePointer, KNativePointer); + +KNativePointer impl_ProgramModulePrefixConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramModulePrefixConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ProgramModulePrefixConst, KNativePointer, KNativePointer, KNativePointer); + +KBoolean impl_ProgramIsSeparateModuleConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramIsSeparateModuleConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ProgramIsSeparateModuleConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ProgramIsDeclarationModuleConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramIsDeclarationModuleConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ProgramIsDeclarationModuleConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ProgramIsPackageConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramIsPackageConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ProgramIsPackageConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ProgramIsDeclForDynamicStaticInteropConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramIsDeclForDynamicStaticInteropConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ProgramIsDeclForDynamicStaticInteropConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ProgramSetFlag(KNativePointer context, KNativePointer receiver, KInt flag) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _flag = static_cast(flag); + GetImpl()->ProgramSetFlag(_context, _receiver, _flag); + return ; +} +KOALA_INTEROP_V3(ProgramSetFlag, KNativePointer, KNativePointer, KInt); + +KBoolean impl_ProgramGetFlagConst(KNativePointer context, KNativePointer receiver, KInt flag) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _flag = static_cast(flag); + auto result = GetImpl()->ProgramGetFlagConst(_context, _receiver, _flag); + return result; +} +KOALA_INTEROP_3(ProgramGetFlagConst, KBoolean, KNativePointer, KNativePointer, KInt); + +void impl_ProgramSetASTChecked(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ProgramSetASTChecked(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ProgramSetASTChecked, KNativePointer, KNativePointer); + +void impl_ProgramRemoveAstChecked(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ProgramRemoveAstChecked(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ProgramRemoveAstChecked, KNativePointer, KNativePointer); + +KBoolean impl_ProgramIsASTChecked(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramIsASTChecked(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ProgramIsASTChecked, KBoolean, KNativePointer, KNativePointer); + +void impl_ProgramMarkASTAsLowered(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ProgramMarkASTAsLowered(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ProgramMarkASTAsLowered, KNativePointer, KNativePointer); + +KBoolean impl_ProgramIsASTLoweredConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramIsASTLoweredConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ProgramIsASTLoweredConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ProgramIsStdLibConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramIsStdLibConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ProgramIsStdLibConst, KBoolean, KNativePointer, KNativePointer); + +KBoolean impl_ProgramIsGenAbcForExternalConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramIsGenAbcForExternalConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ProgramIsGenAbcForExternalConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ProgramSetGenAbcForExternalSources(KNativePointer context, KNativePointer receiver, KBoolean genAbc) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _genAbc = static_cast(genAbc); + GetImpl()->ProgramSetGenAbcForExternalSources(_context, _receiver, _genAbc); + return ; +} +KOALA_INTEROP_V3(ProgramSetGenAbcForExternalSources, KNativePointer, KNativePointer, KBoolean); + +KNativePointer impl_ProgramDumpConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramDumpConst(_context, _receiver); + return StageArena::strdup(result); +} +KOALA_INTEROP_2(ProgramDumpConst, KNativePointer, KNativePointer, KNativePointer); + +void impl_ProgramDumpSilentConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + GetImpl()->ProgramDumpSilentConst(_context, _receiver); + return ; +} +KOALA_INTEROP_V2(ProgramDumpSilentConst, KNativePointer, KNativePointer); + +KBoolean impl_ProgramIsDiedConst(KNativePointer context, KNativePointer receiver) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + auto result = GetImpl()->ProgramIsDiedConst(_context, _receiver); + return result; +} +KOALA_INTEROP_2(ProgramIsDiedConst, KBoolean, KNativePointer, KNativePointer); + +void impl_ProgramAddFileDependencies(KNativePointer context, KNativePointer receiver, KStringPtr& file, KStringPtr& depFile) +{ + const auto _context = reinterpret_cast(context); + const auto _receiver = reinterpret_cast(receiver); + const auto _file = getStringCopy(file); + const auto _depFile = getStringCopy(depFile); + GetImpl()->ProgramAddFileDependencies(_context, _receiver, _file, _depFile); + return ; +} +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); + +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/ets1.2/libarkts/package.json b/ets1.2/libarkts/package.json new file mode 100644 index 0000000000000000000000000000000000000000..8c07d9d7a5e38ca948b3d67e3b99a13a94393952 --- /dev/null +++ b/ets1.2/libarkts/package.json @@ -0,0 +1,84 @@ +{ + "name": "@koalaui/libarkts", + "version": "1.7.9+devel", + "bin": "./lib/es2panda", + "typesVersions": { + "*": { + "./compat/*": [ + "./lib/types/wrapper-compat/index.d.ts" + ], + "*": [ + "./lib/types/index.d.ts" + ] + } + }, + "exports": { + ".": "./lib/libarkts.js", + "./compat": "./lib/libarkts-compat.js", + "./plugins/*": "./lib/plugins/*.js" + }, + "files": [ + "./lib/**/*", + "./build/**/*", + "./plugins/build/src/**/*" + ], + "config": { + "panda_sdk_path": "../../incremental/tools/panda/node_modules/@panda/sdk", + "panda_sdk_version": "next" + }, + "dependencies": { + "@koalaui/ets-tsc": "4.9.5-r6", + "@koalaui/build-common": "1.7.9+devel", + "@koalaui/compat": "1.7.9+devel", + "@koalaui/common": "1.7.9+devel", + "@koalaui/harness": "1.7.9+devel", + "@koalaui/interop": "1.7.9+devel", + "@koalaui/fast-arktsc": "1.7.9+devel", + "@idlizer/arktscgen": "2.1.10-arktscgen-2", + "@types/mocha": "^9.1.0", + "mocha": "^9.2.2", + "node-addon-api": "8.0.0", + "node-api-headers": "0.0.5", + "commander": "10.0.1" + }, + "devDependencies": { + "rollup": "^4.13.0", + "@rollup/plugin-commonjs": "^26.0.1", + "@rollup/plugin-node-resolve": "^15.3.0", + "@rollup/plugin-terser": "^0.4.4", + "@rollup/plugin-typescript": "^11.1.6", + "rimraf": "^6.0.1" + }, + "scripts": { + "clean": "rimraf build native/build* ./.rollup.cache tsconfig.tsbuildinfo lib", + "clean:plugins": "rimraf plugins/build", + "compile:koala:interop": "npm run --prefix ../../interop compile", + "compile:meson": "cd native && meson setup build && meson compile -C build", + "compile:meson:mingw": "cd native && meson setup --cross-file ./mingw.cross mingw_build && meson compile -C mingw_build", + "crosscompile:meson": "cd native && CXX=clang++ meson setup -D cross_compile=true build && CXX=clang++ meson compile -C build", + "copy:.node": "mkdir -p ./build/native/build && cp ./native/build/es2panda_*.node ./build/native/build", + "compile:native": "npm run compile:koala:interop && npm run compile:meson && npm run copy:.node", + "crosscompile:native": "npm run compile:koala:interop && npm run crosscompile:meson && npm run copy:.node", + "compile": "npm run compile:native && npm run compile:js", + "compile:release": "npm run crosscompile:native && npm run compile:js", + "compile:js": "rm -rf lib/ && rollup -c rollup.lib.mjs && rollup -c rollup.es2panda.mjs", + "compile:plugins": "rollup -c ./rollup.printer-plugin.mjs", + "direct": "fast-arktsc --config arktsconfig.json --compiler ../../incremental/tools/panda/arkts/ui2abc --link-name ./build/abc/main.abc && ninja -f build/abc/build.ninja", + "simultaneous": "mkdir -p build/abc && bash ../../incremental/tools/panda/arkts/ui2abc --simultaneous --arktsconfig arktsconfig.json --output ./build/abc/main.abc:./build/abc/library.abc plugins/input/main.ets:plugins/input/library.ets", + "run": "npm run compile && npm run compile:plugins && npm run simultaneous", + "run:memo": "npm run compile && npm run compile:plugins && npm run compile --prefix ../memo-plugin && npm run memo", + "run:abc": "$npm_package_config_panda_sdk_path/linux_host_tools/bin/ark --load-runtimes=ets --boot-panda-files=$npm_package_config_panda_sdk_path/ets/etsstdlib.abc ./main.abc main.ETSGLOBAL::main", + "mocha": "PANDA_SDK_PATH=${PANDA_SDK_PATH:=$npm_package_config_panda_sdk_path} TS_NODE_PROJECT=./test/tsconfig.json mocha -r tsconfig-paths/register --reporter-option maxDiffSize=0", + "test:light": "npm run mocha", + "test": "npm run compile:native && npm run test:light", + "test:golden": "npm run compile:native && TEST_GOLDEN=1 npm run test:light", + "compile:playground": "cd playground && meson setup build && meson compile -C build", + "run:playground": "npm run compile:playground && mkdir -p build && ./playground/build/playground _ --extension ets --stdlib ../../incremental/tools/panda/node_modules/@panda/sdk/ets/stdlib --output build/playground.abc ./playground/src/main.ets", + "panda:sdk:clean": "cd ../../incremental/tools/panda && rimraf node_modules", + "panda:sdk:install": "cd ../../incremental/tools/panda && echo \"Installing panda sdk $npm_package_config_panda_sdk_version\" && PANDA_SDK_VERSION=$npm_package_config_panda_sdk_version npm run panda:sdk:install", + "panda:sdk:reinstall": "npm run panda:sdk:clean && npm run panda:sdk:install", + "regenerate:current": "rimraf -rf src/generated && npm run compile -C ../../../arktscgen && node ../../../arktscgen --panda-sdk-path $npm_package_config_panda_sdk_path --output-dir ../ --options-file ./generator/options.json5 --no-initialize --debug", + "regenerate": "rimraf -rf src/generated && arktscgen --panda-sdk-path ${PANDA_SDK_PATH:=$npm_package_config_panda_sdk_path} --output-dir ../ --options-file ./generator/options.json5 --no-initialize", + "reinstall:regenerate": "npm run panda:sdk:reinstall && npm run regenerate && git diff --shortstat" + } +} \ No newline at end of file diff --git a/ets1.2/libarkts/plugins/input/direct.ets b/ets1.2/libarkts/plugins/input/direct.ets new file mode 100644 index 0000000000000000000000000000000000000000..b51286dbbd777886f910d1274831c1f0aba8774d --- /dev/null +++ b/ets1.2/libarkts/plugins/input/direct.ets @@ -0,0 +1,36 @@ +/* + * 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 { __memo_context_type, __memo_id_type } from "@koalaui/runtime" + +@Retention({policy: "SOURCE"}) +@interface memo { } + +class A { + +} + +class Memo { + @memo static memo_method(): int { + return 1 + } + + @memo static memo_call(): int { + @memo const f = (): int => { + return 2 + } + return f() + } +} diff --git a/ets1.2/libarkts/plugins/input/export.ets b/ets1.2/libarkts/plugins/input/export.ets new file mode 100644 index 0000000000000000000000000000000000000000..77e954c91731fbabddeac5c3c122e9799c8752ef --- /dev/null +++ b/ets1.2/libarkts/plugins/input/export.ets @@ -0,0 +1,20 @@ +/* + * 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. + */ + +export function foo() { + console.log("Hello, world!") +} + +export const TEST: double = 2.718281828459045; diff --git a/ets1.2/libarkts/plugins/input/f.ets b/ets1.2/libarkts/plugins/input/f.ets new file mode 100644 index 0000000000000000000000000000000000000000..6904403bc5aa43fb340076f9de3c18d885ec081b --- /dev/null +++ b/ets1.2/libarkts/plugins/input/f.ets @@ -0,0 +1,18 @@ +/* + * 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. + */ + +export function f() { + console.log("Hello, world!") +} diff --git a/ets1.2/libarkts/plugins/input/library.ets b/ets1.2/libarkts/plugins/input/library.ets new file mode 100644 index 0000000000000000000000000000000000000000..6a90478cce3064de4ad1521dde0bedfeb7da1083 --- /dev/null +++ b/ets1.2/libarkts/plugins/input/library.ets @@ -0,0 +1,22 @@ +/* + * 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. + */ + +export function testFunction(): string { + return "yes" +} +export function anotherFunction(): string { + return "no" +} + diff --git a/ets1.2/libarkts/plugins/input/main.ets b/ets1.2/libarkts/plugins/input/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..4846a65a957ef52a657ca7c743d4b86341481788 --- /dev/null +++ b/ets1.2/libarkts/plugins/input/main.ets @@ -0,0 +1,35 @@ +/* + * 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. + */ + +enum X { + A = 17 +} + +namespace Y { + function foo() { + } +} + +function foo(value: int): void { + switch (X.fromValue(value)) { + case X.A: + console.log("A") + break + default: + console.log("default") + + } +} + diff --git a/ets1.2/libarkts/plugins/input/no-import-no-struct.ets b/ets1.2/libarkts/plugins/input/no-import-no-struct.ets new file mode 100644 index 0000000000000000000000000000000000000000..c1e39867ade1d3df4af5aada138eef6acb3d317c --- /dev/null +++ b/ets1.2/libarkts/plugins/input/no-import-no-struct.ets @@ -0,0 +1,47 @@ +/* + * 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. + */ + +@interface Component{} + +@interface BuilderLambda { + value: string +} + +@Component +class MyComponent { + @BuilderLambda("instantiateImpl") + static $_instantiate(factory: () => MyComponent): MyComponent { + const instance = factory() + return instance + } + + static instantiateImpl(builder: (instance: MyComponent)=>void, factory: () => MyComponent): void { + const instance = factory() + builder(instance) + } + + width(value: number): MyComponent { return this } + build() {} +} + + +@Component +class AnotherComponent { + + build() { + MyComponent() + .width(17.0) + } +} diff --git a/ets1.2/libarkts/plugins/input/one_recursive.ts b/ets1.2/libarkts/plugins/input/one_recursive.ts new file mode 100644 index 0000000000000000000000000000000000000000..baf5bae595d84d887b36395aa290c248b6b56f12 --- /dev/null +++ b/ets1.2/libarkts/plugins/input/one_recursive.ts @@ -0,0 +1,23 @@ +/* + * 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 { Two } from "./two_recursive" + +export interface One { + two(): Two { + throw new Error("") + } +} + diff --git a/ets1.2/libarkts/plugins/input/two_recursive.ts b/ets1.2/libarkts/plugins/input/two_recursive.ts new file mode 100644 index 0000000000000000000000000000000000000000..e3e6de586b443924412f819e9b630276dfd3fbb5 --- /dev/null +++ b/ets1.2/libarkts/plugins/input/two_recursive.ts @@ -0,0 +1,23 @@ +/* + * 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 { One } from "./one_recursive" + +export interface Two { + one(): One { + throw new Error("") + } +} + diff --git a/ets1.2/libarkts/plugins/input/variable.ets b/ets1.2/libarkts/plugins/input/variable.ets new file mode 100644 index 0000000000000000000000000000000000000000..289ef6ec995e13b4fa383a9634cf896b2529ce58 --- /dev/null +++ b/ets1.2/libarkts/plugins/input/variable.ets @@ -0,0 +1,16 @@ +/* + * 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. + */ + +export const X: number = 1.2345; diff --git a/ets1.2/libarkts/plugins/src/print-visitor.ts b/ets1.2/libarkts/plugins/src/print-visitor.ts new file mode 100644 index 0000000000000000000000000000000000000000..c2c30cbf5bd1a6c002ff3e3a458698ea47a01e0d --- /dev/null +++ b/ets1.2/libarkts/plugins/src/print-visitor.ts @@ -0,0 +1,30 @@ +/* + * 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 * as arkts from "@koalaui/libarkts" + + +export class PrintVisitor extends arkts.AbstractVisitor { + private result = "" + + private printNode(node: arkts.AstNode) { + return `${" ".repeat(4 * this.indentation)}${arkts.asString(node)}` + } + + visitor(node: arkts.AstNode): arkts.AstNode { + console.log(this.printNode(node)) + return this.visitEachChild(node) + } +} diff --git a/ets1.2/libarkts/plugins/src/printer-plugin.ts b/ets1.2/libarkts/plugins/src/printer-plugin.ts new file mode 100644 index 0000000000000000000000000000000000000000..0d87341193ab16bd2f7778db6c74b00898c1b9d1 --- /dev/null +++ b/ets1.2/libarkts/plugins/src/printer-plugin.ts @@ -0,0 +1,64 @@ +/* + * 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 { PrintVisitor } from './print-visitor' + +export interface TransformerOptions { + trace?: boolean, +} + +export function printerTransformer( + userPluginOptions?: TransformerOptions +) { + return (program: arkts.Program) => { + return new PrintVisitor().visitor(program.ast) + } +} + +export function init(parsedJson?: Object, checkedJson?: Object) { + let pluginContext = new arkts.PluginContextImpl() + const parsedHooks = new arkts.DumpingHooks(arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED, "printer") + const checkedHooks = new arkts.DumpingHooks(arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED, "printer") + return { + name: "printer", + parsed(hooks: arkts.RunTransformerHooks = parsedHooks) { + console.log("[printer-plugin] Run parsed state plugin") + const transform = printerTransformer(parsedJson) + const prog = arkts.arktsGlobal.compilerContext!.program + const state = arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED + try { + arkts.runTransformer(prog, state, transform, pluginContext, hooks) + } catch(e) { + console.trace(e) + throw e + } + }, + checked(hooks: arkts.RunTransformerHooks = checkedHooks) { + console.log("[printer-plugin] Run checked state plugin") + const transform = printerTransformer(checkedJson) + const prog = arkts.arktsGlobal.compilerContext!.program + const state = arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED + try { + arkts.runTransformer(prog, state, transform, pluginContext, hooks) + arkts.recheckSubtree(prog.ast) + } catch(e) { + console.trace(e) + throw e + } + }, + } +} diff --git a/ets1.2/libarkts/plugins/tsconfig.json b/ets1.2/libarkts/plugins/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..2336e67754f08e5aa65c9f893a4737409b71c1dd --- /dev/null +++ b/ets1.2/libarkts/plugins/tsconfig.json @@ -0,0 +1,13 @@ +{ + "extends": "@koalaui/build-common/tsconfig.json", + "compilerOptions": { + "rootDir": ".", + "baseUrl": ".", + "outDir": "./build", + "module": "CommonJS" + }, + "include": [ + "./src/printer-plugin.ts", + "./src/print-visitor.ts", + ] +} diff --git a/ets1.2/libarkts/rollup.es2panda.mjs b/ets1.2/libarkts/rollup.es2panda.mjs new file mode 100644 index 0000000000000000000000000000000000000000..bbcc959915ea0bd0ebfae4ff34d21dad0b249c26 --- /dev/null +++ b/ets1.2/libarkts/rollup.es2panda.mjs @@ -0,0 +1,68 @@ +/* + * Copyright (c) 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 nodeResolve from "@rollup/plugin-node-resolve"; +import typescript from "@rollup/plugin-typescript"; +import commonjs from '@rollup/plugin-commonjs' + +/** @type {import("rollup").RollupOptions} */ +export default { + input: "./src-host/es2panda.ts", + output: { + file: "./lib/es2panda.js", + format: "commonjs", + banner: [ + "#!/usr/bin/env node", + APACHE_LICENSE_HEADER() + ].join("\n"), + }, + external: ["@koalaui/libarkts"], + plugins: [ + commonjs(), + typescript({ + outputToFilesystem: false, + module: "esnext", + sourceMap: false, + declarationMap: false, + declaration: false, + composite: false, + tsconfig: "./tsconfig.host.json" + }), + nodeResolve({ + extensions: [".js", ".mjs", ".cjs", ".ts", ".cts", ".mts"], + preferBuiltins: true, + }) + ], +} + +function APACHE_LICENSE_HEADER() { + return ` +/** +* @license +* Copyright (c) ${new Date().getUTCFullYear()} 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. +*/ + +` +} diff --git a/ets1.2/libarkts/rollup.lib.mjs b/ets1.2/libarkts/rollup.lib.mjs new file mode 100644 index 0000000000000000000000000000000000000000..6a17260d346d00d94e9d81e459a73524bf199738 --- /dev/null +++ b/ets1.2/libarkts/rollup.lib.mjs @@ -0,0 +1,82 @@ +/* + * Copyright (c) 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 nodeResolve from "@rollup/plugin-node-resolve"; +import typescript from "@rollup/plugin-typescript"; +import commonjs from '@rollup/plugin-commonjs' + +const ENABLE_SOURCE_MAPS = false // Enable for debugging + +/** @type {import("rollup").RollupOptions} */ +export default makeConfig() + +function makeConfig(input, output) { + return { + input: { + 'libarkts': "./src/index.ts" + }, + output: { + dir: "lib", + format: "commonjs", + plugins: [ + // terser() + ], + manualChunks: { + 'libarkts-common': ["./src/index.ts"], + // Improve: maybe split scripts into smaller chunks + // 'libarkts-api': ["./src/arkts-api/index.ts"], + // 'libarkts-generated': ["./src/generated/index.ts"], + }, + banner: APACHE_LICENSE_HEADER(), + sourcemap: ENABLE_SOURCE_MAPS + }, + plugins: [ + commonjs(), + typescript({ + outputToFilesystem: false, + outDir: "lib", + module: "esnext", + sourceMap: ENABLE_SOURCE_MAPS, + declaration: true, + declarationMap: false, + declarationDir: "lib/types", + composite: false, + }), + nodeResolve({ + extensions: [".js", ".mjs", ".cjs", ".ts", ".cts", ".mts"] + }) + ], + } +} + +function APACHE_LICENSE_HEADER() { + return ` +/** +* @license +* Copyright (c) ${new Date().getUTCFullYear()} 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. +*/ + +` +} diff --git a/ets1.2/libarkts/rollup.printer-plugin.mjs b/ets1.2/libarkts/rollup.printer-plugin.mjs new file mode 100644 index 0000000000000000000000000000000000000000..fc5779c87606020bf8ff7a4abd50a404393881d7 --- /dev/null +++ b/ets1.2/libarkts/rollup.printer-plugin.mjs @@ -0,0 +1,67 @@ +/* + * Copyright (c) 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 nodeResolve from "@rollup/plugin-node-resolve"; +import typescript from "@rollup/plugin-typescript"; +import commonjs from '@rollup/plugin-commonjs' + +/** @type {import("rollup").RollupOptions} */ +export default { + input: "./plugins/src/printer-plugin.ts", + output: { + file: "./lib/plugins/printer-plugin.js", + format: "commonjs", + banner: [ + "#!/usr/bin/env node", + APACHE_LICENSE_HEADER() + ].join("\n"), + }, + external: ["@koalaui/libarkts"], + plugins: [ + commonjs(), + typescript({ + outputToFilesystem: false, + module: "esnext", + sourceMap: false, + declarationMap: false, + declaration: false, + composite: false, + tsconfig: "./tsconfig.plugin.json" + }), + nodeResolve({ + extensions: [".js", ".mjs", ".cjs", ".ts", ".cts", ".mts"] + }) + ], +} + +function APACHE_LICENSE_HEADER() { + return ` +/** +* @license +* Copyright (c) ${new Date().getUTCFullYear()} 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. +*/ + +` +} diff --git a/ets1.2/libarkts/src-host/es2panda.ts b/ets1.2/libarkts/src-host/es2panda.ts new file mode 100644 index 0000000000000000000000000000000000000000..632ae8f796f561c147c800ba8722e51812cbe438 --- /dev/null +++ b/ets1.2/libarkts/src-host/es2panda.ts @@ -0,0 +1,302 @@ +/* + * 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 fs from "node:fs" +import * as path from "node:path" +import { checkSDK, arktsGlobal as global, findStdlib, DumpingHooks, listPrograms, initVisitsTable } from "@koalaui/libarkts" +import { PluginEntry, PluginInitializer, CompilationOptions, Program } from "@koalaui/libarkts" +import { Command } from "commander" +import { throwError } from "@koalaui/libarkts" +import { Es2pandaContextState } from "@koalaui/libarkts" +import { Tracer, traceGlobal, Options, Config, Context, proceedToState, dumpProgramInfo, dumpArkTsConfigInfo } from "@koalaui/libarkts" + +interface CommandLineOptions { + files: string[] + configPath: string + outputs: string[] + dumpAst: boolean + simultaneous: boolean + profileMemory: boolean + trace: boolean +} + +function readResponseFile(arg: string | undefined): string | undefined { + if (!arg) { + return undefined + } + if (!arg.startsWith('@')) { + return arg + } + return fs.readFileSync(arg.slice(1), 'utf-8') +} + +function parseCommandLineArgs(): CommandLineOptions { + const commander = new Command() + .argument('[file]', 'Path to files to be compiled') + .option('--file, ', 'Path to file to be compiled (deprecated)') + .option('--arktsconfig, ', 'Path to arkts configuration file') + .option('--ets-module', 'Do nothing, legacy compatibility') + .option('--output, ', 'The name of result file') + .option('--dump-plugin-ast', 'Dump ast before and after each plugin') + .option('--simultaneous', 'Use "simultaneous" mode of compilation') + .option('--profile-memory', 'Profile memory usage') + .option('--trace', 'Trace plugin compilation') + .parse(process.argv) + + const cliOptions = commander.opts() + const cliArgs = commander.args + const fileArg = readResponseFile(cliOptions.file ?? cliArgs[0]) + if (!fileArg) { + reportErrorAndExit(`Either --file option or file argument is required`) + } + const files = fileArg.split(/[ :]/g).map((it: string) => path.resolve(it)) + const configPath = path.resolve(cliOptions.arktsconfig) + const outputArg = cliOptions.output + const outputs = outputArg.split(':').map((it: string) => path.resolve(it)) + files.forEach((it: string) => { + if (!fs.existsSync(it)) { + reportErrorAndExit(`File path doesn't exist: ${it}`) + } + }) + if (!fs.existsSync(configPath)) { + reportErrorAndExit(`Arktsconfig path doesn't exist: ${configPath}`) + } + + const dumpAst = cliOptions.dumpPluginAst ?? false + const simultaneous = cliOptions.simultaneous ?? false + const profileMemory = cliOptions.profileMemory ?? false + const trace = cliOptions.trace ?? false + + return { files, configPath, outputs, dumpAst, simultaneous, profileMemory, trace } +} + +function insertPlugin( + pluginEntry: PluginEntry, + state: Es2pandaContextState, + dumpAst: boolean, +) { + const pluginName = `${pluginEntry.name}-${Es2pandaContextState[state].substring(`ES2PANDA_STATE_`.length).toLowerCase()}` + global.profiler.curPlugin = pluginName + global.profiler.transformStarted() + + const hooks = new DumpingHooks(state, pluginName, dumpAst) + + if (state == Es2pandaContextState.ES2PANDA_STATE_PARSED) { + pluginEntry.parsed?.(hooks) + } + + if (state == Es2pandaContextState.ES2PANDA_STATE_CHECKED) { + pluginEntry.checked?.(hooks) + } + + global.profiler.transformEnded(state, pluginName) + global.profiler.curPlugin = "" +} + +// Improve: move to profiler +function dumpMemoryProfilerInfo(str: string) { + console.log(str, process.memoryUsage().rss) +} + +function dumpCompilationInfo(simultaneous: boolean) { + traceGlobal(() => { + const programs = listPrograms(global.compilerContext!.program) + if (simultaneous) { + const programsForCodegeneration = programs.filter(it => it.isGenAbcForExternal) + traceGlobal(() => `Programs for codegeneration : ${programsForCodegeneration.length}`) + traceGlobal(() => `External programs passed to plugins: ${programs.length - programsForCodegeneration.length - 1}`) + } else { + traceGlobal(() => `Programs for codegeneration : 1`) + traceGlobal(() => `External programs passed to plugins: ${programs.length - 1}`) + } + }) +} + +function createContextAdapter(filePaths: string[]): Context { + return Context.createFromFile(filePaths[0]) +} + +function invoke( + configPath: string, + filePaths: string[], + outputPath: string, + pluginsByState: Map, + dumpAst: boolean, + profileMemory: boolean, + trace: boolean, + simultaneous: boolean, + createContext: (fileNames: string[]) => Context, +): void { + const stdlib = findStdlib() + const cmd = ['--arktsconfig', configPath, '--extension', 'ets', '--stdlib', stdlib, '--output', outputPath] + if (simultaneous) { + cmd.push('--simultaneous') + } + cmd.push(filePaths[0]) + + fs.mkdirSync(path.dirname(outputPath), { recursive: true }) + if (trace) { + Tracer.startGlobalTracing(path.dirname(outputPath)) + } + Tracer.pushContext('es2panda') + + initVisitsTable() + + const compilerConfig = Config.create(['_', ...cmd]) + global.config = compilerConfig.peer + if (!global.configIsInitialized()) + throw new Error(`Wrong config: path=${configPath}`) + + const compilerContext = createContext(filePaths) + global.compilerContext = compilerContext + global.isContextGenerateAbcForExternalSourceFiles = simultaneous + + const options = Options.createOptions(new Config(global.config)) + global.arktsconfig = options.getArkTsConfig() + dumpArkTsConfigInfo(global.arktsconfig) + + if (profileMemory) dumpMemoryProfilerInfo('Memory usage before proceed to parsed:') + proceedToState(Es2pandaContextState.ES2PANDA_STATE_PARSED) + if (profileMemory) dumpMemoryProfilerInfo('Memory usage after proceed to parsed:') + + pluginsByState.get(Es2pandaContextState.ES2PANDA_STATE_PARSED)?.forEach(plugin => { + if (profileMemory) dumpMemoryProfilerInfo(`Memory usage before ${plugin.name}-parsed:`) + insertPlugin(plugin, Es2pandaContextState.ES2PANDA_STATE_PARSED, dumpAst) + if (profileMemory) dumpMemoryProfilerInfo(`Memory usage after ${plugin.name}-parsed:`) + }) + + dumpCompilationInfo(simultaneous) + + if (profileMemory) dumpMemoryProfilerInfo('Memory usage before proceed to checked:') + proceedToState(Es2pandaContextState.ES2PANDA_STATE_CHECKED) + if (profileMemory) dumpMemoryProfilerInfo('Memory usage after proceed to checked:') + + pluginsByState.get(Es2pandaContextState.ES2PANDA_STATE_CHECKED)?.forEach(plugin => { + if (profileMemory) dumpMemoryProfilerInfo(`Memory usage before ${plugin.name}-checked:`) + insertPlugin(plugin, Es2pandaContextState.ES2PANDA_STATE_CHECKED, dumpAst) + if (profileMemory) dumpMemoryProfilerInfo(`Memory usage after ${plugin.name}-checked:`) + }) + + if (profileMemory) dumpMemoryProfilerInfo('Memory usage before proceed to asm:') + proceedToState(Es2pandaContextState.ES2PANDA_STATE_ASM_GENERATED) + if (profileMemory) dumpMemoryProfilerInfo('Memory usage after proceed to asm:') + + if (profileMemory) dumpMemoryProfilerInfo('Memory usage before proceed to bin:') + proceedToState(Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED) + if (profileMemory) dumpMemoryProfilerInfo('Memory usage after proceed to bin:') + + global.profiler.compilationEnded() + global.profiler.report() + global.profiler.reportToFile(true) + + compilerContext.destroy() + compilerConfig.destroy() + + Tracer.popContext() + if (trace) { + Tracer.stopGlobalTracing() + } +} + +function loadPlugin(configDir: string, transform: string) { + /** Improve: read and pass plugin options */ + const plugin = (transform.startsWith(".") || transform.startsWith("/")) ? + path.resolve(configDir, transform) : transform + const pluginEntry = require(plugin) + if (!pluginEntry.init) { + throw new Error(`init is not specified in plugin ${transform}`) + } + if (typeof (pluginEntry.init) !== 'function') { + throw new Error(`init is not a function in plugin ${transform}`) + } + return pluginEntry.init +} + +function stateFromString(stateName: string): Es2pandaContextState { + switch (stateName) { + case "parsed": return Es2pandaContextState.ES2PANDA_STATE_PARSED + case "checked": return Es2pandaContextState.ES2PANDA_STATE_CHECKED + default: throw new Error(`Invalid state name: ${stateName}`) + } +} + +function readAndSortPlugins(configDir: string, plugins: any[]) { + const pluginsByState = new Map() + const pluginInitializers = new Map() + const pluginParsedStageOptions = new Map() + const pluginCheckedStageOptions = new Map() + + plugins.forEach(it => { + const transform = it.transform + if (!transform) { + throwError(`arktsconfig plugins objects should specify transform`) + } + const state = stateFromString(it.state) + if (!pluginInitializers.has(it.transform)) { + pluginInitializers.set(it.transform, loadPlugin(configDir, it.transform)) + } + if (!pluginsByState.has(state)) { + pluginsByState.set(state, []) + } + if (state == Es2pandaContextState.ES2PANDA_STATE_PARSED) { + pluginParsedStageOptions.set(it.transform, it) + } + if (state == Es2pandaContextState.ES2PANDA_STATE_CHECKED) { + pluginCheckedStageOptions.set(it.transform, it) + } + }) + + pluginInitializers.forEach((pluginInit, pluginTransform) => { + const parsedJson = pluginParsedStageOptions.get(pluginTransform) + const checkedJson = pluginCheckedStageOptions.get(pluginTransform) + const plugin = pluginInit(parsedJson, checkedJson) + if (parsedJson && plugin.parsed) { + pluginsByState.get(Es2pandaContextState.ES2PANDA_STATE_PARSED)?.push(plugin) + } + if (checkedJson && plugin.checked) { + pluginsByState.get(Es2pandaContextState.ES2PANDA_STATE_CHECKED)?.push(plugin) + } + }) + + return pluginsByState +} + +export function main() { + checkSDK() + const { files, configPath, outputs, dumpAst, simultaneous, profileMemory, trace } = parseCommandLineArgs() + if (!simultaneous && files.length != outputs.length) { + reportErrorAndExit("Different length of inputs and outputs") + } + const arktsconfig = JSON.parse(fs.readFileSync(configPath).toString()) + const configDir = path.dirname(configPath) + const compilerOptions = arktsconfig.compilerOptions ?? throwError(`arktsconfig should specify compilerOptions`) + const plugins = compilerOptions.plugins ?? [] + const pluginsByState = readAndSortPlugins(configDir, plugins) + + if (simultaneous) { + invoke(configPath, files, outputs[0], pluginsByState, dumpAst, profileMemory, trace, simultaneous, Context.createContextGenerateAbcForExternalSourceFiles) + } else { + for (var i = 0; i < files.length; i++) { + invoke(configPath, [files[i]], outputs[i], pluginsByState, dumpAst, profileMemory, trace, simultaneous, createContextAdapter) + } + } +} + +function reportErrorAndExit(message: string): never { + console.error(message) + process.exit(1) +} + +main() diff --git a/ets1.2/libarkts/src/Es2pandaNativeModule.ts b/ets1.2/libarkts/src/Es2pandaNativeModule.ts new file mode 100644 index 0000000000000000000000000000000000000000..e107d7eda9cd1b77f585cf4dcdddbe6e34d3f64d --- /dev/null +++ b/ets1.2/libarkts/src/Es2pandaNativeModule.ts @@ -0,0 +1,262 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { + KNativePointer as KPtr, + KInt, + KBoolean, + KNativePointer, + registerNativeModuleLibraryName, + loadNativeModuleLibrary, + KDouble, + KUInt, + KStringArrayPtr, +} from "@koalaui/interop" +import { Es2pandaNativeModule as GeneratedEs2pandaNativeModule, KNativePointerArray } from "./generated/Es2pandaNativeModule" +import * as path from "path" +import * as fs from "fs" +import { Es2pandaPluginDiagnosticType } from "./generated/Es2pandaEnums" + +// Improve: this type should be in interop +export type KPtrArray = BigUint64Array + +export class Es2pandaNativeModule { + _AnnotationAllowedAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr { + throw new Error("Not implemented") + } + _AstNodeRebind(context: KPtr, node: KPtr): void { + throw new Error("Not implemented") + } + _ContextState(context: KPtr): KInt { + throw new Error("Not implemented") + } + _AstNodeChildren(context: KPtr, node: KPtr): KPtr { + throw new Error("Not implemented") + } + _AstNodeDumpModifiers(context: KPtr, node: KPtr): KPtr { + throw new Error("Not implemented") + } + _CreateConfig(argc: number, argv: string[]): KPtr { + throw new Error("Not implemented") + } + _DestroyConfig(peer: KNativePointer): void { + throw new Error("Not implemented") + } + _CreateContextFromString(config: KPtr, source: String, filename: String): KPtr { + throw new Error("Not implemented") + } + _CreateContextFromFile(config: KPtr, filename: String): KPtr { + throw new Error("Not implemented") + } + _CreateCacheContextFromFile(config: KNativePointer, sourceFileName: String, globalContext: KNativePointer, isExternal: KBoolean): KNativePointer { + throw new Error("Not implemented"); + } + _InsertGlobalStructInfo(context: KNativePointer, str: String): void { + throw new Error("Not implemented"); + } + _HasGlobalStructInfo(context: KNativePointer, str: String): KBoolean { + throw new Error("Not implemented"); + } + _CreateGlobalContext(config: KNativePointer, externalFileList: KStringArrayPtr, fileNum: KUInt, lspUsage: KBoolean): KNativePointer { + throw new Error("Not implemented"); + } + _DestroyGlobalContext(context: KNativePointer): void { + throw new Error("Not implemented"); + } + _DestroyContext(context: KPtr): void { + throw new Error("Not implemented") + } + _ProceedToState(context: KPtr, state: number): void { + throw new Error("Not implemented") + } + _CheckerStartChecker(context: KPtr): KBoolean { + throw new Error("Not implemented") + } + _AstNodeVariableConst(context: KPtr, ast: KPtr): KPtr { + throw new Error("Not implemented") + } + _CreateNumberLiteral(context: KPtr, value: KDouble): KPtr { + throw new Error("Not implemented") + } + _AstNodeSetChildrenParentPtr(context: KPtr, node: KPtr): void { + throw new Error("Not implemented") + } + _AstNodeOnUpdate(context: KPtr, newNode: KPtr, replacedNode: KPtr): void { + throw new Error("Not implemented") + } + _AstNodeUpdateAll(context: KPtr, node: KPtr): void { + throw new Error("Not implemented") + } + _VariableDeclaration(context: KPtr, variable: KPtr): KPtr { + throw new Error("Not implemented") + } + _DeclNode(context: KPtr, decl: KPtr): KPtr { + throw new Error("Not implemented") + } + _ProgramSourceFilePath(context: KNativePointer, instance: KNativePointer): KNativePointer { + throw new Error("Not implemented"); + } + _ProgramExternalSources(context: KNativePointer, instance: KNativePointer): KNativePointer { + throw new Error("Not implemented"); + } + _ProgramDirectExternalSources(context: KNativePointer, instance: KNativePointer): KNativePointer { + throw new Error("Not implemented") + } + _ExternalSourceName(instance: KNativePointer): KNativePointer { + 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"); + } + _ImportPathManagerResolvePathConst(context: KNativePointer, importPathManager: KNativePointer, currentModulePath: String, importPath: String, sourcePosition: KNativePointer): KNativePointer { + throw new Error("Not implemented"); + } + _ETSParserGetImportPathManager(context: KNativePointer): KPtr { + throw new Error("Not implemented"); + } + _SourcePositionCol(context: KNativePointer, instance: KNativePointer): KInt { + 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"); + } + _Checker_CreateOpaqueTypeNode(context: KNativePointer, type: KNativePointer): KNativePointer { + throw new Error("Not implemented"); + } + _Checker_ScriptFunctionSignature(context: KNativePointer, node: KNativePointer): KNativePointer { + throw new Error("Not implemented"); + } + _Checker_ScriptFunctionSetSignature(context: KNativePointer, node: KNativePointer, signature: KNativePointer): void { + throw new Error("Not implemented"); + } + _Checker_SignatureReturnType(context: KNativePointer, signature: KNativePointer): KNativePointer { + throw new Error("Not implemented"); + } + _Checker_ScriptFunctionGetPreferredReturnType(context: KNativePointer, node: KNativePointer): KNativePointer { + throw new Error("Not implemented"); + } + _Checker_ScriptFunctionSetPreferredReturnType(context: KNativePointer, node: KNativePointer, type: KNativePointer): void { + throw new Error("Not implemented"); + } + _Checker_ExpressionGetPreferredType(context: KNativePointer, node: KNativePointer): KNativePointer { + throw new Error("Not implemented"); + } + _Checker_ExpressionSetPreferredType(context: KNativePointer, node: KNativePointer, type: KNativePointer): void { + throw new Error("Not implemented"); + } + _Checker_TypeToString(context: KNativePointer, type: KNativePointer): KNativePointer { + throw new Error("Not implemented"); + } + _Checker_TypeClone(context: KNativePointer, type: KNativePointer): KNativePointer { + throw new Error("Not implemented"); + } + _Checker_TypeNodeGetType(context: KNativePointer, node: KNativePointer): KNativePointer { + throw new Error("Not implemented"); + } + _ScriptFunctionSetParams(context: KNativePointer, receiver: KNativePointer, paramsList: BigUint64Array, paramsListLength: KUInt): void { + throw new Error("Not implemented") + } + _ClassDefinitionSetBody(context: KNativePointer, receiver: KNativePointer, body: BigUint64Array, bodyLength: KUInt): void { + throw new Error("Not implemented") + } + + // From koala-wrapper + _ClassVariableDeclaration(context: KNativePointer, classInstance: KNativePointer): KNativePointer { + throw new Error("Not implemented") + } + _ETSParserGetGlobalProgramAbsName(context: KNativePointer): KNativePointer { + throw new Error("Not implemented") + } + _CreateDiagnosticKind(context: KNativePointer, message: string, type: Es2pandaPluginDiagnosticType): KNativePointer { + throw new Error("Not implemented") + } + _CreateDiagnosticInfo(context: KNativePointer, kind: KNativePointer, args: string[], argc: number, pos: KNativePointer): KNativePointer { + throw new Error("Not implemented") + } + _CreateSuggestionInfo(context: KNativePointer, kind: KNativePointer, args: string[], + argc: number, substitutionCode: string, title: string, range: KNativePointer): KNativePointer { + throw new Error("Not implemented") + } + _LogDiagnostic(context: KNativePointer, kind: KNativePointer, argv: string[], argc: number, pos: KNativePointer): void { + throw new Error("Not implemented") + } + _SetUpSoPath(soPath: string): void { + throw new Error("Not implemented") + } + _MemInitialize(): void { + throw new Error("Not implemented") + } + _MemFinalize(): void { + 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, isolated: KBoolean, recordFile: String): KPtr { + throw new Error("Not implemented") + } + _AstNodeProgram(context: KNativePointer, instance: KNativePointer): KNativePointer { + throw new Error("Not implemented") + } + _CreateContextGenerateAbcForExternalSourceFiles(config: KPtr, fileCount: KInt, filenames: string[]): KPtr { + throw new Error('Not implemented'); + } + + _GetCompilationMode(config: KNativePointer): KInt { + throw new Error('Not implemented'); + } + + _CreateTypeNodeFromTsType(context: KNativePointer, classInstance: KNativePointer): KNativePointer { + throw new Error('Not implemented'); + } +} + +export function findNativeModule(): string { + const candidates = [ + path.resolve(__dirname, "../native/build"), + path.resolve(__dirname, "../build/native/build"), + ] + let result = undefined + candidates.forEach(path => { + if (fs.existsSync(path)) { + result = path + return + } + }) + if (result) + return path.join(result, "es2panda") + throw new Error("Cannot find native module") +} + +export function initEs2panda(): Es2pandaNativeModule { + registerNativeModuleLibraryName("NativeModule", findNativeModule()) + const instance = new Es2pandaNativeModule() + loadNativeModuleLibrary("NativeModule", instance) + return instance +} + +export function initGeneratedEs2panda(): GeneratedEs2pandaNativeModule { + registerNativeModuleLibraryName("NativeModule", findNativeModule()) + const instance = new GeneratedEs2pandaNativeModule() + // registerNativeModule("InteropNativeModule", NativeModule) + loadNativeModuleLibrary("NativeModule", instance) + return instance +} diff --git a/ets1.2/libarkts/src/InteropNativeModule.ts b/ets1.2/libarkts/src/InteropNativeModule.ts new file mode 100644 index 0000000000000000000000000000000000000000..5b4d48048462892295281961f399c13b807096b8 --- /dev/null +++ b/ets1.2/libarkts/src/InteropNativeModule.ts @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { + KNativePointer as KPtr, + KInt, + registerNativeModuleLibraryName, + loadNativeModuleLibrary +} from "@koalaui/interop" +import { findNativeModule } from "./Es2pandaNativeModule" + +export class InteropNativeModule { + _StringLength(ptr: KPtr): KInt { + throw new Error("Not implemented") + } + _StringData(ptr: KPtr, buffer: KPtr, length: KInt): void { + throw new Error("Not implemented") + } + _GetStringFinalizer(): KPtr { + throw new Error("Not implemented") + } + _RawUtf8ToString(ptr: KPtr): string { + throw new Error("Not implemented") + } + _InvokeFinalizer(ptr: KPtr, finalizer: KPtr): void { + throw new Error("Not implemented") + } + _GetPtrVectorSize(ptr: KPtr): KInt { + throw new Error("Not implemented") + } + _GetPtrVectorElement(ptr: KPtr, index: KInt): KPtr { + throw new Error("Not implemented") + } +} + +export function initInterop(): InteropNativeModule { + registerNativeModuleLibraryName("InteropNativeModule", findNativeModule()) + const instance = new InteropNativeModule() + loadNativeModuleLibrary("InteropNativeModule", instance) + return instance +} diff --git a/ets1.2/libarkts/src/arkts-api/AbstractVisitor.ts b/ets1.2/libarkts/src/arkts-api/AbstractVisitor.ts new file mode 100644 index 0000000000000000000000000000000000000000..eb21588719f92c9cfbf9d66d4b9725dfc1542722 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/AbstractVisitor.ts @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { AstNode } from "./peers/AstNode" +import { visitEachChild } from "./visitor" +import { Program } from "../generated" + +export interface VisitorOptions { + program?: Program +} + +export abstract class AbstractVisitor { + public program?: Program + + constructor(options?: VisitorOptions) { + this.program = options?.program; + } + + indentation = 0 + + withIndentation(exec: () => T) { + this.indentation++ + const result = exec() + this.indentation-- + return result + } + + abstract visitor(node: AstNode, options?: object): AstNode + + visitEachChild(node: AstNode, options?: object): AstNode { + return this.withIndentation(() => + visitEachChild( + node, + it => this.visitor(it, options) + ) + ) + } +} diff --git a/ets1.2/libarkts/src/arkts-api/ChainExpressionFilter.ts b/ets1.2/libarkts/src/arkts-api/ChainExpressionFilter.ts new file mode 100644 index 0000000000000000000000000000000000000000..3d22c7c46fd7d0c09de50fca8ad5409c5393e170 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/ChainExpressionFilter.ts @@ -0,0 +1,79 @@ +/* + * 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 { BlockStatement, ChainExpression, Expression, isChainExpression, isMemberExpression, MemberExpression } from "src/generated"; +import { AbstractVisitor } from "./AbstractVisitor"; +import { AstNode } from "./peers/AstNode" +import { factory } from "./factory/nodeFactory"; +import { Es2pandaTokenType, Es2pandaVariableDeclarationKind, Es2pandaVariableDeclaratorFlag } from "src/generated/Es2pandaEnums"; + + +export class ChainExpressionFilter extends AbstractVisitor { + static counter = 0 + transformChainExpression(node: ChainExpression): Expression { + const expression = node.expression + if (expression == undefined) return node + if (!isMemberExpression(expression)) return node + return this.transformMemberExpression(expression) + } + transformMemberExpression(expression: MemberExpression): Expression { + const temporaryVarName = `chaintmp%%_${ChainExpressionFilter.counter++}` + return factory.createBlockExpression( + [ + factory.createVariableDeclaration( + Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET, + [ + factory.createVariableDeclarator( + Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_LET, + factory.createIdentifier(temporaryVarName), + expression.object + ) + ], + undefined + ), + factory.createExpressionStatement( + factory.createConditionalExpression( + factory.createBinaryExpression( + factory.createIdentifier(temporaryVarName, undefined), + factory.createUndefinedLiteral(), + Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_STRICT_EQUAL + ), + factory.createUndefinedLiteral(), + factory.createMemberExpression( + factory.createIdentifier(temporaryVarName, undefined), + expression.property, + expression.kind, + expression.isComputed, + false + ) + ) + ) + ] + ) + } + + + visitor(beforeChildren: BlockStatement): BlockStatement + visitor(beforeChildren: AstNode): AstNode { + const node = this.visitEachChild(beforeChildren) + if (isChainExpression(node)) { + return this.transformChainExpression(node) + } + if (isMemberExpression(node) && node.isOptional) { + return this.transformMemberExpression(node) + } + return node + } +} \ No newline at end of file diff --git a/ets1.2/libarkts/src/arkts-api/ImportStorage.ts b/ets1.2/libarkts/src/arkts-api/ImportStorage.ts new file mode 100644 index 0000000000000000000000000000000000000000..24c3bbada48b7eb7e7ced8f17158bfd3c6363345 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/ImportStorage.ts @@ -0,0 +1,84 @@ +/* + * 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 { ETSModule, ImportDeclaration, isETSImportDeclaration, Program, Statement } from "../generated" +import { passNode, passNodeArray, unpackNonNullableNode } from "./utilities/private" +import { global } from "./static/global" +import { Es2pandaImportFlags, Es2pandaImportKinds } from "../generated/Es2pandaEnums" +import { factory } from "./factory/nodeFactory" + +export class ImportStorage { + // Improve: migrate to wrappers instead of pointers + private imports: Set = new Set() + private importSources: Set = new Set() + + constructor(private program: Program, private isParserState: boolean) { + for (const statement of program.ast.statements) { + if (isETSImportDeclaration(statement)) { + this.imports.add(statement.peer) + if (!isParserState) { + // Improve: is source non nullable? + this.importSources.add(statement.source?.str) + } + } + } + } + + update() { + // Save current statements + const statements = this.program.ast.statements + + // Update parser information + const newStatements: Statement[] = [] + for (const statement of statements) { + if (isETSImportDeclaration(statement) && !this.imports.has(statement.peer)) { + if (!this.isParserState && !this.importSources.has(statement.source?.str)) { + console.warn("Attempt to insert import from new source after parsed state:") + console.warn(statement.dumpSrc()) + } + + const importDeclaration = unpackNonNullableNode( + // Note: this call is important, we cannot just pass "statement" to "InsertETSImportDeclarationAndParse" + global.es2panda._ETSParserBuildImportDeclaration( + global.context, + Es2pandaImportKinds.IMPORT_KINDS_ALL, // Improve: do we use IMPORT_KINDS_TYPES? + passNodeArray(statement.specifiers), + statement.specifiers.length, + passNode(statement.source), + this.program.peer, + Es2pandaImportFlags.IMPORT_FLAGS_NONE, // Improve: where to get it? + ) + ) + global.generatedEs2panda._InsertETSImportDeclarationAndParse(global.context, this.program.peer, importDeclaration.peer) + newStatements.push(importDeclaration) + } else { + newStatements.push(statement) + } + } + + // Drop import statements generated by compiler in the beginning of the ETSModule + const module = this.program.ast as ETSModule + this.program.setAst( + factory.updateETSModule( + module, + newStatements, + module.ident, + module.getNamespaceFlag(), + module.program, + ) + ) + } +} diff --git a/ets1.2/libarkts/src/arkts-api/ProgramProvider.ts b/ets1.2/libarkts/src/arkts-api/ProgramProvider.ts new file mode 100644 index 0000000000000000000000000000000000000000..6831a29ed0a70eace6a05472438e9c1ffb146f56 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/ProgramProvider.ts @@ -0,0 +1,50 @@ +/* + * 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 { defaultFilter, listPrograms } from "./plugins" +import { Program } from "../generated" + +export class ProgramProvider { + // Improve: migrate to wrappers instead of pointers + seenPrograms: Set = new Set() + queue: Program[] = [] + + constructor(private mainProgram: Program, private readonly filter: (name: string) => boolean = defaultFilter) { + this.seenPrograms.add(mainProgram.peer) + this.queue = [mainProgram] + } + + updateQueue() { + const listed = listPrograms(this.mainProgram, this.filter) + for (const program of listed) { + if (!this.seenPrograms.has(program.peer)) { + this.seenPrograms.add(program.peer) + this.queue.push(program) + } + } + } + + next(): Program | undefined { + if (this.queue.length == 0) { + this.updateQueue() + if (this.queue.length == 0) { + // console.log("PROGRAMS:", this.seenPrograms.size) + return undefined + } + } + return this.queue.shift() + } +} diff --git a/ets1.2/libarkts/src/arkts-api/class-by-peer.ts b/ets1.2/libarkts/src/arkts-api/class-by-peer.ts new file mode 100644 index 0000000000000000000000000000000000000000..0c00f1dbe4d2a78ab8b92235bd6582c5b9ce100d --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/class-by-peer.ts @@ -0,0 +1,33 @@ +/* + * Copyright (c) 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 { Es2pandaAstNodeType } from "../generated/Es2pandaEnums" +import { throwError } from "../utils" +import { global } from "./static/global" +import { KNativePointer } from "@koalaui/interop" +import { AstNode } from "./peers/AstNode" +import { NodeCache } from "./node-cache" + +export const nodeByType = new Map AstNode>([]) + +export function nodeFrom(peer: KNativePointer): T { + const fromCache = NodeCache.get(peer) + if (fromCache) { + return fromCache + } + const type = global.generatedEs2panda._AstNodeTypeConst(global.context, peer) + const create = nodeByType.get(type) ?? throwError(`unknown node type: ${type}`) + return create(peer) as T +} diff --git a/ets1.2/libarkts/src/arkts-api/factory/nodeFactory.ts b/ets1.2/libarkts/src/arkts-api/factory/nodeFactory.ts new file mode 100644 index 0000000000000000000000000000000000000000..b94d05d0298747b05ad8961069c14549934965fd --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/factory/nodeFactory.ts @@ -0,0 +1,129 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { + BlockStatement, + CallExpression, + ClassDefinition, + ClassProperty, + ETSImportDeclaration, + ETSModule, + ETSStructDeclaration, + ETSTuple, + ETSTypeReferencePart, + MemberExpression, + ObjectExpression, + TryStatement, + TSTypeParameter, + VariableDeclarator, +} from "../../generated" +import { factory as generatedFactory } from "../../generated/factory" +import { createScriptFunction, updateScriptFunction } from "../node-utilities/ScriptFunction" +import { updateCallExpression } from "../node-utilities/CallExpression" +import { createNumberLiteral, updateNumberLiteral } from "../node-utilities/NumberLiteral" +import { updateMemberExpression } from "../node-utilities/MemberExpression" +import { createETSParameterExpression, updateETSParameterExpression } from "../node-utilities/ETSParameterExpression" +import { updateTSTypeParameter } from "../node-utilities/TSTypeParameter" +import { updateETSTypeReferencePart } from "../node-utilities/TSTypeReferencePart" +import { updateETSImportDeclaration } from "../node-utilities/ETSImportDeclaration" +import { updateVariableDeclarator } from "../node-utilities/VariableDeclarator" +import { updateClassDefinition } from "../node-utilities/ClassDefinition" +import { updateETSStructDeclaration } from "../node-utilities/ETSStructDeclaration" +import { updateClassProperty } from "../node-utilities/ClassProperty" +import { createETSFunctionType, updateETSFunctionType } from "../node-utilities/ETSFunctionType" +import { createMethodDefinition, updateMethodDefinition } from "../node-utilities/MethodDefinition" +import { createTSInterfaceDeclaration, updateTSInterfaceDeclaration } from "../node-utilities/TSInterfaceDeclaration" +import { updateTryStatement } from "../node-utilities/TryStatement" +import { createAssignmentExpression, updateAssignmentExpression } from "../node-utilities/AssignmentExpression" +import { createObjectExpression, updateObjectExpression } from "../node-utilities/ObjectExpression" +import { updateETSTuple } from "../node-utilities/ETSTuple" +import { createArrayExpression, updateArrayExpression } from "../node-utilities/ArrayExpression" +import { updateBlockStatement } from "../node-utilities/BlockStatement" +import { updateETSModule } from "../node-utilities/ETSModule" +import { createOpaqueTypeNode } from "../node-utilities/OpaqueTypeNode" + +export const factory = { + ...generatedFactory, + + createETSModule: ETSModule.createETSModule, + updateETSModule, + + createCallExpression: CallExpression.createCallExpression, + updateCallExpression, + + createMemberExpression: MemberExpression.createMemberExpression, + updateMemberExpression, + + createScriptFunction, + updateScriptFunction, + + createNumberLiteral, + updateNumberLiteral, + + createETSParameterExpression, + updateETSParameterExpression, + + createTypeParameter: TSTypeParameter.create1TSTypeParameter, + updateTypeParameter: updateTSTypeParameter, + + createETSTypeReferencePart: ETSTypeReferencePart.createETSTypeReferencePart, + updateETSTypeReferencePart, + + createETSImportDeclaration: ETSImportDeclaration.createETSImportDeclaration, + updateETSImportDeclaration, + + createVariableDeclarator: VariableDeclarator.create1VariableDeclarator, + updateVariableDeclarator, + + createETSStructDeclaration: ETSStructDeclaration.createETSStructDeclaration, + updateETSStructDeclaration, + + createClassDefinition: ClassDefinition.createClassDefinition, + updateClassDefinition, + + createClassProperty: ClassProperty.createClassProperty, + updateClassProperty, + + createETSFunctionType, + updateETSFunctionType, + + createMethodDefinition, + updateMethodDefinition, + + createInterfaceDeclaration: createTSInterfaceDeclaration, + updateInterfaceDeclaration: updateTSInterfaceDeclaration, + + createTryStatement: TryStatement.createTryStatement, + updateTryStatement, + + createAssignmentExpression, + updateAssignmentExpression, + + createObjectExpression, + updateObjectExpression, + + createETSTuple: ETSTuple.create2ETSTuple, + updateETSTuple, + + createArrayExpression, + updateArrayExpression, + + createBlockStatement: BlockStatement.createBlockStatement, + updateBlockStatement, + + updateInterfaceBody : generatedFactory.updateTSInterfaceBody, + + createOpaqueTypeNode, +} diff --git a/ets1.2/libarkts/src/arkts-api/index.ts b/ets1.2/libarkts/src/arkts-api/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..3d088c3480552327dd3e5a027c8ca70e0594e36b --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/index.ts @@ -0,0 +1,40 @@ +/* + * 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. + */ + +export * from "../generated/Es2pandaEnums" +export * from "../generated" + +export * from "./utilities/private" +export * from "./utilities/public" +export * from "./factory/nodeFactory" +export * from "./visitor" +export * from "./AbstractVisitor" +export * from "./ChainExpressionFilter" +export * from "./plugins" +export * from "./ImportStorage" +export * from "./ProgramProvider" + +export * from "./peers/AstNode" +export * from "./peers/Config" +export * from "./peers/Context" +export { GlobalContext } from "./peers/Context" +export * from "./peers/ExternalSource" +export * from "./peers/Options" +export * from "./node-utilities/ArkTsConfig" +export * from "./node-utilities/Program" +export * from "./peers/ImportPathManager" +export * from "./static/globalUtils" +export { global as arktsGlobal } from "./static/global" +export * from "./wrapper-compat" \ No newline at end of file diff --git a/ets1.2/libarkts/src/arkts-api/node-cache.ts b/ets1.2/libarkts/src/arkts-api/node-cache.ts new file mode 100644 index 0000000000000000000000000000000000000000..149831d3f167c284ac4ba5e6dbc49b8fe4f06446 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-cache.ts @@ -0,0 +1,43 @@ +/* + * 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 { AstNode } from "./peers/AstNode" + +export class NodeCache { + private static cache = new Map() + + static cached(pointer: KNativePointer, factory: (pointer: KNativePointer) => AstNode): T { + const cached = NodeCache.cache.get(pointer) + if (cached !== undefined) { + return cached as T + } + const node = factory(pointer) + NodeCache.addToCache(pointer, node) + return node as T + } + + static get(pointer: KNativePointer): T | undefined { + return NodeCache.cache.get(pointer) as T | undefined + } + + public static addToCache(pointer: KNativePointer, node: AstNode) { + NodeCache.cache.set(pointer, node) + } + + public static clear(): void { + NodeCache.cache.clear() + } +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/ArkTsConfig.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/ArkTsConfig.ts new file mode 100644 index 0000000000000000000000000000000000000000..7778a25d686b661443c6121b471101e1f05aed22 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/ArkTsConfig.ts @@ -0,0 +1,26 @@ +/* + * Copyright (c) 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 { ArkTsConfig } from "../../generated" +import { traceGlobal } from "../../tracer" + +export function dumpArkTsConfigInfo(arkTsConfig: ArkTsConfig) { + traceGlobal(() => `ArkTsConfig info:`) + traceGlobal(() => `\tBaseUrl: ${arkTsConfig.baseUrl}`) + traceGlobal(() => `\tConfigPath: ${arkTsConfig.configPath}`) + traceGlobal(() => `\tOutDir: ${arkTsConfig.outDir}`) + traceGlobal(() => `\tPackage: ${arkTsConfig.package}`) + traceGlobal(() => `\tRootDir: ${arkTsConfig.rootDir}`) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/ArrayExpression.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/ArrayExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..f4ce7df2a7756031f15e849693eed6acb31754e9 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/ArrayExpression.ts @@ -0,0 +1,42 @@ +/* + * Copyright (c) 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 { Es2pandaAstNodeType } from "../../generated/Es2pandaEnums" +import { ArrayExpression, Expression } from "../../generated" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" + +export function createArrayExpression( + elements: readonly Expression[] +): ArrayExpression { + return ArrayExpression.create1ArrayExpression( + Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION, + elements, + false + ) +} + +export function updateArrayExpression( + original: ArrayExpression, + elements: readonly Expression[] +): ArrayExpression { + if (isSameNativeObject(original.elements, elements)) { + return original + } + return updateNodeByNode( + createArrayExpression(elements), + original + ) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/AssignmentExpression.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/AssignmentExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..b5fa8024e53e4313536f4a373836a9911590dc47 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/AssignmentExpression.ts @@ -0,0 +1,50 @@ +/* + * Copyright (c) 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 { AssignmentExpression, Expression } from "../../generated" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" +import { Es2pandaAstNodeType, Es2pandaTokenType } from "../../generated/Es2pandaEnums" + +export function createAssignmentExpression( + left: Expression | undefined, + right: Expression | undefined, + assignmentOperator: Es2pandaTokenType +): AssignmentExpression { + return AssignmentExpression.create1AssignmentExpression( + Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION, + left, + right, + assignmentOperator, + ) +} + +export function updateAssignmentExpression( + original: AssignmentExpression, + left: Expression | undefined, + right: Expression | undefined, + assignmentOperator: Es2pandaTokenType +): AssignmentExpression { + if (isSameNativeObject(left, original.left) + && isSameNativeObject(right, original.right) + && isSameNativeObject(assignmentOperator, original.operatorType) + ) { + return original + } + return updateNodeByNode( + createAssignmentExpression(left, right, assignmentOperator), + original + ) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/BlockStatement.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/BlockStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..8da2777584465889f125e14beb343836fac7b45a --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/BlockStatement.ts @@ -0,0 +1,25 @@ +/* + * Copyright (c) 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 { BlockStatement, Statement } from "../../generated" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" + +export function updateBlockStatement(original: BlockStatement, statements: readonly Statement[]): BlockStatement { + if (isSameNativeObject(statements, original.statements)) { + return original + } + return updateNodeByNode(BlockStatement.createBlockStatement(statements), original) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/CallExpression.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/CallExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..3d58248927b703386db73466e3dea1e63ecb2670 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/CallExpression.ts @@ -0,0 +1,42 @@ +/* + * 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 { BlockStatement, CallExpression, Expression, TSTypeParameterInstantiation } from "../../generated" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" + +export function updateCallExpression( + original: CallExpression, + callee: Expression | undefined, + _arguments: readonly Expression[], + typeParams: TSTypeParameterInstantiation | undefined, + optional_arg: boolean = false, + trailingComma: boolean = false, + trailingBlock: BlockStatement | undefined = undefined, +): CallExpression { + if (isSameNativeObject(callee, original.callee) + && isSameNativeObject(_arguments, original.arguments) + && isSameNativeObject(typeParams, original.typeParams) + && isSameNativeObject(optional_arg, original.isOptional) + && isSameNativeObject(trailingComma, original.hasTrailingComma) + && isSameNativeObject(trailingBlock, original.trailingBlock) + ) { + return original + } + return updateNodeByNode( + CallExpression.createCallExpression(callee, _arguments, typeParams, optional_arg, trailingComma, trailingBlock), + original + ) +} \ No newline at end of file diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/ClassDefinition.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/ClassDefinition.ts new file mode 100644 index 0000000000000000000000000000000000000000..0e7a778282ac6cd9030bb0933135202220469dc9 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/ClassDefinition.ts @@ -0,0 +1,72 @@ +/* + * Copyright (c) 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 { + AnnotationUsage, + ClassDefinition, + Expression, + Identifier, + MethodDefinition, + TSClassImplements, + TSTypeParameterDeclaration, + TSTypeParameterInstantiation +} from "../../generated" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" +import { AstNode } from "../peers/AstNode" +import { Es2pandaClassDefinitionModifiers, Es2pandaModifierFlags } from "../../generated/Es2pandaEnums" + +export function updateClassDefinition( + original: ClassDefinition, + ident: Identifier | undefined, + typeParams: TSTypeParameterDeclaration | undefined, + superTypeParams: TSTypeParameterInstantiation | undefined, + _implements: readonly TSClassImplements[], + ctor: MethodDefinition | undefined, + superClass: Expression | undefined, + body: readonly AstNode[], + modifiers: Es2pandaClassDefinitionModifiers, + flags: Es2pandaModifierFlags, + annotations?: readonly AnnotationUsage[] +): ClassDefinition { + if (isSameNativeObject(ident, original.ident) + && (isSameNativeObject(typeParams, original.typeParams)) + && (isSameNativeObject(superTypeParams, original.superTypeParams)) + && (isSameNativeObject(_implements, original.implements)) + && (isSameNativeObject(ctor, original.ctor)) + && (isSameNativeObject(superClass, original.super)) + && (isSameNativeObject(body, original.body)) + && (isSameNativeObject(modifiers, original.modifiers)) + && (isSameNativeObject(flags, original.modifierFlags)) + && (isSameNativeObject(annotations, original.annotations)) + ) { + return original + } + return updateNodeByNode( + ClassDefinition.createClassDefinition( + ident, + typeParams, + superTypeParams, + _implements, + ctor, + superClass, + body, + modifiers, + flags, + annotations, + ), + original + ) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/ClassProperty.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/ClassProperty.ts new file mode 100644 index 0000000000000000000000000000000000000000..d22553dd8e6ae57927d55fca257ceff40830b0da --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/ClassProperty.ts @@ -0,0 +1,43 @@ +/* + * Copyright (c) 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 { AnnotationUsage, ClassProperty, Expression, TypeNode } from "../../generated" +import { Es2pandaModifierFlags } from "../../generated/Es2pandaEnums" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" + +export function updateClassProperty( + original: ClassProperty, + key: Expression | undefined, + value: Expression | undefined, + typeAnnotation: TypeNode | undefined, + modifiers: Es2pandaModifierFlags, + isComputed: boolean, + annotations?: readonly AnnotationUsage[], +): ClassProperty { + if (isSameNativeObject(key, original.key) + && isSameNativeObject(value, original.value) + && isSameNativeObject(typeAnnotation, original.typeAnnotation) + && isSameNativeObject(modifiers, original.modifierFlags) + && isSameNativeObject(isComputed, original.isComputed) + && isSameNativeObject(annotations, original.annotations) + ) { + return original + } + return updateNodeByNode( + ClassProperty.createClassProperty(key, value, typeAnnotation, modifiers, isComputed, annotations), + original + ) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/ETSFunctionType.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/ETSFunctionType.ts new file mode 100644 index 0000000000000000000000000000000000000000..a549a0d5388b2f3ec0b611f0391a16d83d4692e7 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/ETSFunctionType.ts @@ -0,0 +1,62 @@ +/* + * Copyright (c) 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 { AnnotationUsage, ETSFunctionType, Expression, FunctionSignature, TSTypeParameterDeclaration, TypeNode } from "../../generated" +import { Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" + +export function createETSFunctionType( + typeParams: TSTypeParameterDeclaration | undefined, + params: readonly Expression[], + returnTypeAnnotation: TypeNode | undefined, + hasReceiver: boolean, + funcFlags: Es2pandaScriptFunctionFlags, + annotations?: readonly AnnotationUsage[], +): ETSFunctionType { + return ETSFunctionType.createETSFunctionType( + FunctionSignature.createFunctionSignature( + typeParams, + params, + returnTypeAnnotation, + hasReceiver, + ), + funcFlags, + annotations, + ) +} + +export function updateETSFunctionType( + original: ETSFunctionType, + typeParams: TSTypeParameterDeclaration | undefined, + params: readonly Expression[], + returnTypeAnnotation: TypeNode | undefined, + hasReceiver: boolean, + funcFlags: Es2pandaScriptFunctionFlags, + annotations?: readonly AnnotationUsage[], +): ETSFunctionType { + if (isSameNativeObject(typeParams, original.typeParams) + && isSameNativeObject(params, original.params) + && isSameNativeObject(returnTypeAnnotation, original.returnType) + && isSameNativeObject(funcFlags, original.flags) + && isSameNativeObject(annotations, original.annotations) + ) { + return original + } + return updateNodeByNode( + createETSFunctionType(typeParams, params, returnTypeAnnotation, hasReceiver, funcFlags, annotations), + original + ) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/ETSImportDeclaration.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/ETSImportDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..34078a1084a487dad4ec83d17b5d47ca59453771 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/ETSImportDeclaration.ts @@ -0,0 +1,39 @@ +/* + * Copyright (c) 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 { ETSImportDeclaration, StringLiteral } from "../../generated" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" +import { AstNode } from "../peers/AstNode" +import { Es2pandaImportKinds } from "../../generated/Es2pandaEnums" + +export function updateETSImportDeclaration( + original: ETSImportDeclaration, + source: StringLiteral | undefined, + specifiers: readonly AstNode[], + importKind: Es2pandaImportKinds +): ETSImportDeclaration { + if (isSameNativeObject(source, original.source) + && isSameNativeObject(specifiers, original.specifiers) + /* no getter for importKind */ + ) { + /* Improve: probably should set importMetadata, but no getter provided yet */ + return original + } + return updateNodeByNode( + ETSImportDeclaration.createETSImportDeclaration(source, specifiers, importKind), + original + ) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/ETSModule.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/ETSModule.ts new file mode 100644 index 0000000000000000000000000000000000000000..c875efab0bfb15a8eb20042b31cf5321c0ea887f --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/ETSModule.ts @@ -0,0 +1,44 @@ +/* + * Copyright (c) 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 { ETSModule, Identifier, Program, Statement } from "../../generated" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" +import { Es2pandaModuleFlag } from "../../generated/Es2pandaEnums" + +export function updateETSModule( + original: ETSModule, + statementList: readonly Statement[], + ident: Identifier | undefined, + flag: Es2pandaModuleFlag, + program?: Program, +) { + if (isSameNativeObject(statementList, original.statements) + && isSameNativeObject(ident, original.ident) + && isSameNativeObject(flag, original.getNamespaceFlag()) + && isSameNativeObject(program, original.program) + ) { + return original + } + return updateNodeByNode( + ETSModule.createETSModule( + statementList, + ident, + flag, + program, + ), + original, + ) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/ETSParameterExpression.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/ETSParameterExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..f09511a5cfc01a29feb9ba83611ecde81341e8fe --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/ETSParameterExpression.ts @@ -0,0 +1,51 @@ +/* + * Copyright (c) 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 { AnnotatedExpression, AnnotationUsage, ETSParameterExpression, Expression, TypeNode } from "../../generated" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" + +export function createETSParameterExpression( + identOrSpread: AnnotatedExpression | undefined, + isOptional: boolean, + initExpr?: Expression, + annotations?: readonly AnnotationUsage[] +): ETSParameterExpression { + const res = ETSParameterExpression.createETSParameterExpression(identOrSpread, isOptional, annotations) + if (initExpr) { + res.setInitializer(initExpr) + } + return res +} + +export function updateETSParameterExpression( + original: ETSParameterExpression, + identOrSpread: AnnotatedExpression | undefined, + isOptional: boolean, + initExpr?: Expression, + annotations?: readonly AnnotationUsage[], +): ETSParameterExpression { + if ((isSameNativeObject(identOrSpread, original.ident) || isSameNativeObject(identOrSpread, original.restParameter)) + && isSameNativeObject(isOptional, original.isOptional) + && isSameNativeObject(initExpr, original.initializer) + && isSameNativeObject(annotations, original.annotations) + ) { + return original + } + return updateNodeByNode( + createETSParameterExpression(identOrSpread, isOptional, initExpr, annotations), + original + ) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/ETSStructDeclaration.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/ETSStructDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..f4fbd959604e907ee35efdd8fcbc16840899fd25 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/ETSStructDeclaration.ts @@ -0,0 +1,31 @@ +/* + * Copyright (c) 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 { ClassDefinition, ETSStructDeclaration } from "../../generated" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" + +export function updateETSStructDeclaration( + original: ETSStructDeclaration, + def?: ClassDefinition +): ETSStructDeclaration { + if (isSameNativeObject(def, original.definition)) { + return original + } + return updateNodeByNode( + ETSStructDeclaration.createETSStructDeclaration(def), + original + ) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/ETSTuple.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/ETSTuple.ts new file mode 100644 index 0000000000000000000000000000000000000000..65bc8633adfaef97ce99d7f154474618e1930737 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/ETSTuple.ts @@ -0,0 +1,31 @@ +/* + * Copyright (c) 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 { ETSTuple, TypeNode } from "../../generated" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" + +export function updateETSTuple( + original: ETSTuple, + typeList: readonly TypeNode[] +): ETSTuple { + if (isSameNativeObject(typeList, original.tupleTypeAnnotationsList)) { + return original + } + return updateNodeByNode( + ETSTuple.create2ETSTuple(typeList), + original + ) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/MemberExpression.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/MemberExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..fdaa969d9b616fec7e33820583768fc6e9d7b966 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/MemberExpression.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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 { Expression, MemberExpression } from "../../generated" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" +import { Es2pandaMemberExpressionKind } from "../../generated/Es2pandaEnums" + +export function updateMemberExpression( + original: MemberExpression, + object_arg: Expression | undefined, + property: Expression | undefined, + kind: Es2pandaMemberExpressionKind, + computed: boolean, + optional_arg: boolean +): MemberExpression { + if (isSameNativeObject(object_arg, original.object) + && isSameNativeObject(property, original.property) + && isSameNativeObject(kind, original.kind) + && isSameNativeObject(computed, original.isComputed) + && isSameNativeObject(optional_arg, original.isOptional) + ) { + return original + } + return updateNodeByNode( + MemberExpression.createMemberExpression(object_arg, property, kind, computed, optional_arg), + original + ) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/MethodDefinition.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/MethodDefinition.ts new file mode 100644 index 0000000000000000000000000000000000000000..4308241d295d5e66d148f08d0dd22d1920d9f276 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/MethodDefinition.ts @@ -0,0 +1,71 @@ +/* + * Copyright (c) 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 { Expression, MethodDefinition } from "../../generated" +import { + Es2pandaMethodDefinitionKind, + Es2pandaModifierFlags, +} from "../../generated/Es2pandaEnums" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" + +export function createMethodDefinition( + kind: Es2pandaMethodDefinitionKind, + key: Expression | undefined, + value: Expression | undefined, + modifiers: Es2pandaModifierFlags, + isComputed: boolean, + overloads?: readonly MethodDefinition[] +): MethodDefinition { + return MethodDefinition.createMethodDefinition( + kind, + key, + value, + modifiers, + isComputed, + overloads, + ) +} + +export function updateMethodDefinition( + original: MethodDefinition, + kind: Es2pandaMethodDefinitionKind, + key: Expression | undefined, + value: Expression | undefined, + modifiers: Es2pandaModifierFlags, + isComputed: boolean, + overloads?: readonly MethodDefinition[] +): MethodDefinition { + if (isSameNativeObject(kind, original.kind) + && isSameNativeObject(key, original.key) + && isSameNativeObject(value, original.value) + && isSameNativeObject(modifiers, original.modifierFlags) + && isSameNativeObject(isComputed, original.isComputed) + && isSameNativeObject(overloads, original.overloads) + ) { + return original + } + return updateNodeByNode( + createMethodDefinition( + kind, + key, + value, + modifiers, + isComputed, + overloads, + ), + original + ) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/NumberLiteral.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/NumberLiteral.ts new file mode 100644 index 0000000000000000000000000000000000000000..369587f7ba28dedf0dfbeba8aed789a2ba29874c --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/NumberLiteral.ts @@ -0,0 +1,45 @@ +/* + * 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 { global } from "../static/global" +import { NumberLiteral } from "../../generated" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" +import { Es2pandaAstNodeType } from "../../generated/Es2pandaEnums" + +export function createNumberLiteral( + value: number +): NumberLiteral { + return new NumberLiteral( + global.es2panda._CreateNumberLiteral( + global.context, + value + ), + Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, + ) +} + +export function updateNumberLiteral( + original: NumberLiteral, + value: number +): NumberLiteral { + if (isSameNativeObject(value.toString(), original.str)) { + return original + } + return updateNodeByNode( + createNumberLiteral(value), + original + ) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/ObjectExpression.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/ObjectExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..cb7ef117f6330d66d75bd6c0ecc376d708d59c3f --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/ObjectExpression.ts @@ -0,0 +1,53 @@ +/* + * Copyright (c) 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 { KNativePointer } from "@koalaui/interop" +import { ObjectExpression, Expression } from "../../generated" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" +import { Es2pandaAstNodeType } from "../../generated/Es2pandaEnums" + +export function createObjectExpression( + properties: readonly Expression[], + preferredReturnType?: KNativePointer, +): ObjectExpression { + const result = ObjectExpression.createObjectExpression( + Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION, + properties, + false, // Improve: provide trailingComma value from native module through ObjectExpression? + ) + if (preferredReturnType) { + result.setPreferredTypePointer(preferredReturnType) + } + return result +} + +export function updateObjectExpression( + original: ObjectExpression, + properties: readonly Expression[], + preferredReturnType?: KNativePointer, +): ObjectExpression { + if (isSameNativeObject(properties, original.properties) + && preferredReturnType == original.getPreferredTypePointer()) { + return original + } + return updateNodeByNode( + createObjectExpression( + properties, + preferredReturnType + ), + original + ) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/OpaqueTypeNode.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/OpaqueTypeNode.ts new file mode 100644 index 0000000000000000000000000000000000000000..aa4162e3136b47d2a858fe4da943fe31eb7ed3b1 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/OpaqueTypeNode.ts @@ -0,0 +1,25 @@ +/* + * 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 { global } from "../static/global" +import { OpaqueTypeNode } from "../../generated" +import { Es2pandaAstNodeType } from "../../generated/Es2pandaEnums" + +export function createOpaqueTypeNode( + typePointer: KNativePointer +): OpaqueTypeNode { + return new OpaqueTypeNode(global.es2panda._Checker_CreateOpaqueTypeNode(global.context, typePointer), Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/Program.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/Program.ts new file mode 100644 index 0000000000000000000000000000000000000000..ba5ac902257e49ba3a55b427954c6b27d7151a36 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/Program.ts @@ -0,0 +1,40 @@ +/* + * Copyright (c) 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 { Program } from "../../generated" +import { traceGlobal } from "../../tracer" + +export function dumpProgramInfo(program: Program) { + traceGlobal(() => `Program info:`) + traceGlobal(() => `\tAbsoluteName: ${program.absoluteName}`) + traceGlobal(() => `\tFileName: ${program.fileName}`) + traceGlobal(() => `\tFileNameWithExtension: ${program.fileNameWithExtension}`) + traceGlobal(() => `\tModuleName: ${program.moduleName}`) + traceGlobal(() => `\tModulePrefix: ${program.modulePrefix}`) + traceGlobal(() => `\tRelativeFilePath: ${program.relativeFilePath}`) + traceGlobal(() => `\tResolvedFilePath: ${program.resolvedFilePath}`) + traceGlobal(() => `\tSourceFileFolder: ${program.sourceFileFolder}`) + traceGlobal(() => `\tSourceFilePath: ${program.sourceFilePath}`) +} + +export function dumpProgramSrcFormatted(program: Program, recursive: boolean, withLines: boolean = true) { + const lines = program.ast.dumpSrc() + console.log(`// file: ${program.absoluteName}`) + if (withLines) { + console.log(lines.split('\n').map((it, index) => `${`${index + 1}`.padStart(4)} |${it}`).join('\n')) + } else { + console.log(lines) + } +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/ScriptFunction.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/ScriptFunction.ts new file mode 100644 index 0000000000000000000000000000000000000000..8b7a0f6cac9968eb962d2f7015cadcd193d0fb22 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/ScriptFunction.ts @@ -0,0 +1,110 @@ +/* + * 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 { + AnnotationUsage, + Expression, + FunctionSignature, + Identifier, + ScriptFunction, + TSTypeParameterDeclaration, + TypeNode +} from "../../generated" +import { AstNode } from "../peers/AstNode" +import { Es2pandaModifierFlags, Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" +import { KNativePointer } from "@koalaui/interop" + +export function createScriptFunction( + databody: AstNode | undefined, + typeParams: TSTypeParameterDeclaration | undefined, + params: readonly Expression[], + returnTypeAnnotation: TypeNode | undefined, + hasReceiver: boolean, + datafuncFlags: Es2pandaScriptFunctionFlags, + dataflags: Es2pandaModifierFlags, + ident: Identifier | undefined, + annotations: readonly AnnotationUsage[] | undefined, + signaturePointer?: KNativePointer, + preferredReturnTypePointer?: KNativePointer, +) { + const res = ScriptFunction.createScriptFunction( + databody, + FunctionSignature.createFunctionSignature( + typeParams, + params, + returnTypeAnnotation, + hasReceiver, + ), + datafuncFlags, + dataflags, + ident, + annotations, + ) + if (signaturePointer) { + res.setSignaturePointer(signaturePointer) + } + if (preferredReturnTypePointer) { + res.setPreferredReturnTypePointer(preferredReturnTypePointer) + } + return res +} + +export function updateScriptFunction( + original: ScriptFunction, + databody: AstNode | undefined, + typeParams: TSTypeParameterDeclaration | undefined, + params: readonly Expression[], + returnTypeAnnotation: TypeNode | undefined, + hasReceiver: boolean, + datafuncFlags: Es2pandaScriptFunctionFlags, + dataflags: Es2pandaModifierFlags, + ident: Identifier | undefined, + annotations: readonly AnnotationUsage[] | undefined, + signaturePointer?: KNativePointer, + preferredReturnTypePointer?: KNativePointer, +) { + if (isSameNativeObject(databody, original.body) + && isSameNativeObject(typeParams, original.typeParams) + && isSameNativeObject(params, original.params) + && isSameNativeObject(returnTypeAnnotation, original.returnTypeAnnotation) + && isSameNativeObject(hasReceiver, original.hasReceiver) + && isSameNativeObject(datafuncFlags, original.flags) + && isSameNativeObject(dataflags, original.modifierFlags) + && isSameNativeObject(ident, original.id) + && isSameNativeObject(annotations, original.annotations) + && signaturePointer == original.getSignaturePointer() + && preferredReturnTypePointer == original.getPreferredReturnTypePointer() + ) { + return original + } + return updateNodeByNode( + createScriptFunction( + databody, + typeParams, + params, + returnTypeAnnotation, + hasReceiver, + datafuncFlags, + dataflags, + ident, + annotations, + signaturePointer, + preferredReturnTypePointer, + ), + original + ) +} \ No newline at end of file diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/TSInterfaceDeclaration.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/TSInterfaceDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..dc7becd09c854123b3e8b58d038a6818d937f8aa --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/TSInterfaceDeclaration.ts @@ -0,0 +1,78 @@ +/* + * Copyright (c) 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 { + TSInterfaceDeclaration, TSInterfaceHeritage +} from "../../generated" +import { + Es2pandaModifierFlags, +} from "../../generated/Es2pandaEnums" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" +import { AstNode } from "../peers/AstNode" + +export function createTSInterfaceDeclaration( + _extends: readonly TSInterfaceHeritage[], + id: AstNode | undefined, + typeParams: AstNode | undefined, + body: AstNode | undefined, + isStatic: boolean, + isExternal: boolean, + modifierFlags?: Es2pandaModifierFlags, +): TSInterfaceDeclaration { + return TSInterfaceDeclaration.createTSInterfaceDeclaration( + _extends, + id, + typeParams, + body, + isStatic, + isExternal, + modifierFlags, + ) +} + +export function updateTSInterfaceDeclaration( + original: TSInterfaceDeclaration, + _extends: readonly TSInterfaceHeritage[], + id: AstNode | undefined, + typeParams: AstNode | undefined, + body: AstNode | undefined, + isStatic: boolean, + isExternal: boolean, + modifierFlags?: Es2pandaModifierFlags, +): TSInterfaceDeclaration { + if (isSameNativeObject(_extends, original.extends) + && isSameNativeObject(id, original.id) + && isSameNativeObject(typeParams, original.typeParams) + && isSameNativeObject(body, original.body) + && isSameNativeObject(isStatic, original.isStatic) + && isSameNativeObject(isExternal, original.isFromExternal) + && isSameNativeObject(modifierFlags, original.modifierFlags) + ) { + return original + } + return updateNodeByNode( + createTSInterfaceDeclaration( + _extends, + id, + typeParams, + body, + isStatic, + isExternal, + modifierFlags, + ), + original + ) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/TSTypeParameter.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/TSTypeParameter.ts new file mode 100644 index 0000000000000000000000000000000000000000..e60b4315346e1c842687f572391079a595a07f8c --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/TSTypeParameter.ts @@ -0,0 +1,39 @@ +/* + * Copyright (c) 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 { Identifier, TSTypeParameter, TypeNode } from "../../generated" +import { Es2pandaModifierFlags } from "../../generated/Es2pandaEnums" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" + +export function updateTSTypeParameter( + original: TSTypeParameter, + name: Identifier | undefined, + constraint: TypeNode | undefined, + defaultType: TypeNode | undefined, + flags: Es2pandaModifierFlags +): TSTypeParameter { + if (isSameNativeObject(name, original.name) + && isSameNativeObject(constraint, original.constraint) + && isSameNativeObject(defaultType, original.defaultType) + && isSameNativeObject(flags, original.modifierFlags) + ) { + return original + } + return updateNodeByNode( + TSTypeParameter.create1TSTypeParameter(name, constraint, defaultType, flags), + original + ) +} \ No newline at end of file diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/TSTypeReferencePart.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/TSTypeReferencePart.ts new file mode 100644 index 0000000000000000000000000000000000000000..b68d6ba3dc8d14cc2e02f05975c436c1b5accd00 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/TSTypeReferencePart.ts @@ -0,0 +1,36 @@ +/* + * Copyright (c) 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 { ETSTypeReferencePart, Expression, TSTypeParameterInstantiation } from "../../generated" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" + +export function updateETSTypeReferencePart( + original: ETSTypeReferencePart, + name?: Expression, + typeParams?: TSTypeParameterInstantiation, + prev?: ETSTypeReferencePart +): ETSTypeReferencePart { + if (isSameNativeObject(name, original.name) + && isSameNativeObject(typeParams, original.typeParams) + && isSameNativeObject(prev, original.previous) + ) { + return original + } + return updateNodeByNode( + ETSTypeReferencePart.createETSTypeReferencePart(name, typeParams, prev), + original + ) +} \ No newline at end of file diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/TryStatement.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/TryStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..0a36dd51a43bc058fcb5ecf2e8f3d436ff7be87b --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/TryStatement.ts @@ -0,0 +1,44 @@ +/* + * 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 { BlockStatement, CatchClause, LabelPair, Statement, TryStatement } from "../../generated" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" + +export function updateTryStatement( + original: TryStatement, + block: BlockStatement | undefined, + catchClauses: readonly CatchClause[], + finalizer: BlockStatement | undefined, + finalizerInsertionsLabelPair: readonly LabelPair[], + finalizerInsertionsStatement: readonly Statement[] +): TryStatement { + if (isSameNativeObject(block, original.block) + && isSameNativeObject(catchClauses, original.catchClauses) + && isSameNativeObject(finalizer, original.finallyBlock) + ) { + return original + } + return updateNodeByNode( + TryStatement.createTryStatement( + block, + catchClauses, + finalizer, + finalizerInsertionsLabelPair, + finalizerInsertionsStatement, + ), + original + ) +} diff --git a/ets1.2/libarkts/src/arkts-api/node-utilities/VariableDeclarator.ts b/ets1.2/libarkts/src/arkts-api/node-utilities/VariableDeclarator.ts new file mode 100644 index 0000000000000000000000000000000000000000..75c2ef64991a079be8d96c0ca690b73cff16c9f4 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/node-utilities/VariableDeclarator.ts @@ -0,0 +1,37 @@ +/* + * Copyright (c) 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 { Expression, VariableDeclarator } from "../../generated" +import { Es2pandaVariableDeclaratorFlag } from "../../generated/Es2pandaEnums" +import { isSameNativeObject } from "../peers/ArktsObject" +import { updateNodeByNode } from "../utilities/private" + +export function updateVariableDeclarator( + original: VariableDeclarator, + flag: Es2pandaVariableDeclaratorFlag, + ident?: Expression, + init?: Expression +): VariableDeclarator { + if (isSameNativeObject(flag, original.flag) + && isSameNativeObject(ident, original.id) + && isSameNativeObject(init, original.init) + ) { + return original + } + return updateNodeByNode( + VariableDeclarator.create1VariableDeclarator(flag, ident, init), + original + ) +} diff --git a/ets1.2/libarkts/src/arkts-api/peers/ArktsObject.ts b/ets1.2/libarkts/src/arkts-api/peers/ArktsObject.ts new file mode 100644 index 0000000000000000000000000000000000000000..c3906ac15248437657e2e4a829cc7e1768f402c5 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/peers/ArktsObject.ts @@ -0,0 +1,47 @@ +/* + * Copyright (c) 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 { KNativePointer } from "@koalaui/interop" + +export abstract class ArktsObject { + protected constructor(peer: KNativePointer) { + this.peer = peer + } + + peer: KNativePointer + + public onUpdate(node: ArktsObject) {} +} + +export function isSameNativeObject( + first: T | readonly T[], + second: T | readonly T[] +): boolean { + if (Array.isArray(first) && Array.isArray(second)) { + if (first.length !== second.length) { + return false + } + for (let i = 0; i < first.length; i++) { + if (!isSameNativeObject(first[i], second[i])) { + return false + } + } + return true + } + if (first instanceof ArktsObject && second instanceof ArktsObject) { + return first?.peer === second?.peer + } + return first === second +} diff --git a/ets1.2/libarkts/src/arkts-api/peers/AstNode.ts b/ets1.2/libarkts/src/arkts-api/peers/AstNode.ts new file mode 100644 index 0000000000000000000000000000000000000000..d8d398c24b4edb7ddb27731c24409624d95e821f --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/peers/AstNode.ts @@ -0,0 +1,190 @@ +/* + * Copyright (c) 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 { isNullPtr, KInt, KNativePointer, nullptr } from "@koalaui/interop" +import { global } from "../static/global" +import { allFlags, unpackNode, unpackNodeArray, unpackNonNullableNode, unpackString } from "../utilities/private" +import { throwError } from "../../utils" +import { Es2pandaAstNodeType, Es2pandaModifierFlags } from "../../generated/Es2pandaEnums" +import { ArktsObject } from "./ArktsObject" +import { SourcePosition } from "../../generated/peers/SourcePosition" +import { NodeCache } from "../node-cache" + +export abstract class AstNode extends ArktsObject { + public readonly astNodeType: Es2pandaAstNodeType + + protected constructor(peer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + global.profiler.nodeCreated() + if (isNullPtr(peer)) { + throwError(`attempted to create AstNode from nullptr`) + } + super(peer) + this.astNodeType = astNodeType + this.setChildrenParentPtr() + NodeCache.addToCache(peer, this) + } + + public get originalPeer(): KNativePointer { + const result = global.generatedEs2panda._AstNodeOriginalNodeConst(global.context, this.peer) + if (result === nullptr) { + this.originalPeer = this.peer + return this.peer + } + return result + } + + public set originalPeer(peer: KNativePointer) { + global.generatedEs2panda._AstNodeSetOriginalNode(global.context, this.peer, peer) + } + + public getChildren(): readonly AstNode[] { + return unpackNodeArray(global.es2panda._AstNodeChildren(global.context, this.peer)) + } + + public getSubtree(): readonly AstNode[] { + return this.getChildren().reduce( + (prev: readonly AstNode[], curr) => { + return prev.concat(curr.getSubtree()) + }, + [this] + ) + } + + public updateModifiers(modifierFlags: KInt | undefined): this { + global.generatedEs2panda._AstNodeClearModifier(global.context, this.peer, allFlags) + global.generatedEs2panda._AstNodeAddModifier(global.context, this.peer, modifierFlags ?? Es2pandaModifierFlags.MODIFIER_FLAGS_NONE) + return this + } + + public dump(indentation: number = 0): string { + const children = this.getChildren() + .map((it) => it.dump(indentation + 1)) + const msg = + `${indentation}_` + + ` ` + + this.dumpMessage() + return "> " + " ".repeat(4 * indentation) + msg + "\n" + children.join("") + } + + protected dumpMessage(): string { + return `` + } + + public dumpJson(): string { + return unpackString(global.generatedEs2panda._AstNodeDumpJSONConst(global.context, this.peer)) + } + + public dumpSrc(): string { + return unpackString(global.generatedEs2panda._AstNodeDumpEtsSrcConst(global.context, this.peer)) + } + + public dumpModifiers(): string { + return unpackString(global.es2panda._AstNodeDumpModifiers(global.context, this.peer)) + } + + // public clone(): this { + // return unpackNonNullableNode(global.generatedEs2panda._AstNodeClone(global.context, this.peer, this.parent.peer)); + // } + + // public get parent(): AstNode { + // const parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer) + // if (parent === nullptr) { + // throwError(`no parent`) + // } + // return unpackNonNullableNode(parent) + // } + + // public set parent(node: AstNode) { + // global.generatedEs2panda._AstNodeSetParent(global.context, this.peer, node.peer) + // } + + public clone(): this { + const clonedNode = unpackNonNullableNode( + global.generatedEs2panda._AstNodeClone(global.context, this.peer, this.parent?.peer ?? nullptr) + ); + clonedNode.parent = undefined; + return clonedNode as this; + } + + public get parent(): AstNode | undefined { + const parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer); + return unpackNode(parent); + } + + public set parent(node: AstNode | undefined) { + global.generatedEs2panda._AstNodeSetParent(global.context, this.peer, node?.peer ?? nullptr); + } + + public get modifierFlags(): Es2pandaModifierFlags { + return global.generatedEs2panda._AstNodeModifiers(global.context, this.peer) + } + + public set modifierFlags(flags: KInt | undefined) { + global.generatedEs2panda._AstNodeClearModifier(global.context, this.peer, allFlags) + global.generatedEs2panda._AstNodeAddModifier(global.context, this.peer, flags ?? Es2pandaModifierFlags.MODIFIER_FLAGS_NONE) + } + + /** @deprecated Use {@link modifierFlags} instead */ + public get modifiers(): KInt { + return this.modifierFlags + } + + /** @deprecated Use {@link modifierFlags} instead */ + public set modifiers(flags: KInt | undefined) { + this.modifierFlags = flags + } + + public setChildrenParentPtr(): void { + if (this.peer === nullptr) { + throwError('setChildrenParentPtr called on NULLPTR') + } + global.es2panda._AstNodeSetChildrenParentPtr(global.context, this.peer) + } + + public override onUpdate(original: AstNode): void { + // Improve: Update modifiers only for specific AST nodes in the generated factory code + this.modifierFlags = original.modifierFlags + + global.es2panda._AstNodeOnUpdate(global.context, this.peer, original.peer) + } + + public get isExport(): boolean { + return global.generatedEs2panda._AstNodeIsExportedConst(global.context, this.peer); + } + + public get isDefaultExport(): boolean { + return global.generatedEs2panda._AstNodeIsDefaultExportedConst(global.context, this.peer); + } + + public get isStatic(): boolean { + return global.generatedEs2panda._AstNodeIsStaticConst(global.context, this.peer); + } + + public get startPosition(): SourcePosition { + return new SourcePosition(global.generatedEs2panda._AstNodeStartConst(global.context, this.peer)); + } + + public set startPosition(start: SourcePosition) { + global.generatedEs2panda._AstNodeSetStart(global.context, this.peer, start.peer); + } + + public get endPosition(): SourcePosition { + return new SourcePosition(global.generatedEs2panda._AstNodeEndConst(global.context, this.peer)); + } + + public set endPosition(end: SourcePosition) { + global.generatedEs2panda._AstNodeSetEnd(global.context, this.peer, end.peer); + } +} diff --git a/ets1.2/libarkts/src/arkts-api/peers/Config.ts b/ets1.2/libarkts/src/arkts-api/peers/Config.ts new file mode 100644 index 0000000000000000000000000000000000000000..4e91cb987253230b6d65e2ede1ee582afd4aa0f5 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/peers/Config.ts @@ -0,0 +1,65 @@ +/* + * Copyright (c) 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 { ArktsObject } from "./ArktsObject" +import { global } from "../static/global" +import { passStringArray } from "../utilities/private" +import { KNativePointer, nullptr } from "@koalaui/interop" +import { Es2pandaCompilationMode } from "../../generated/Es2pandaEnums" + +export class Config extends ArktsObject { + constructor(peer: KNativePointer) { + super(peer) + // Improve: wait for getter from api + this.path = `` + } + + static create( + input: readonly string[] + ): Config { + return new Config( + global.es2panda._CreateConfig(input.length, passStringArray(input)) + ) + } + + static createDefault(): Config { + if (global.configIsInitialized()) { + console.warn(`Config already initialized`) + return new Config( + global.config + ) + } + return new Config( + global.es2panda._CreateConfig( + 4, + passStringArray(["", "--arktsconfig", "./arktsconfig.json", global.filePath]) + ) + ) + } + + destroy() { + if (this.peer != nullptr) { + global.es2panda._DestroyConfig(this.peer) + this.peer = nullptr + } + } + + get compilationMode(): Es2pandaCompilationMode { + return global.es2panda._GetCompilationMode(this.peer); + } + + + readonly path: string +} \ No newline at end of file diff --git a/ets1.2/libarkts/src/arkts-api/peers/Context.ts b/ets1.2/libarkts/src/arkts-api/peers/Context.ts new file mode 100644 index 0000000000000000000000000000000000000000..78eed92417ec479014d9989c2ca4f6d77726f879 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/peers/Context.ts @@ -0,0 +1,131 @@ +/* + * Copyright (c) 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 { ArktsObject } from "./ArktsObject" +import { Program } from "../../generated" +import { global } from "../static/global" +import { passString, passStringArray } from "../utilities/private" +import { KNativePointer, nullptr, KBoolean } from "@koalaui/interop" +import { Config } from "./Config" +import { filterSource, throwError } from "../../utils" +import { AstNode } from "./AstNode" + +export class Context extends ArktsObject { + constructor(peer: KNativePointer) { + super(peer) + } + + static createFromString(source: string): Context { + if (!global.configIsInitialized()) { + throw new Error(`Config not initialized`) + } + return new Context( + global.es2panda._CreateContextFromString( + global.config, + passString(source), + passString(global.filePath) + ) + ) + } + + /** @deprecated Use {@link createCacheFromFile} instead */ + static createCacheContextFromFile( + configPtr: KNativePointer, + fileName: string, + globalContextPtr: KNativePointer, + isExternal: KBoolean + ): Context { + return new Context( + global.es2panda._CreateCacheContextFromFile(configPtr, passString(fileName), globalContextPtr, isExternal) + ); + } + + static createFromFile(filePath: string): Context { + return new Context( + global.es2panda._CreateContextFromFile( + global.config, + passString(filePath) + ) + ) + } + + static createCacheFromFile(filePath: string, config: Config, globalContext: GlobalContext, isExternal: boolean) { + return new Context( + global.es2panda._CreateCacheContextFromFile( + config.peer, + passString(filePath), + globalContext.peer, + isExternal + ) + ) + } + + static createContextGenerateAbcForExternalSourceFiles( + filenames: string[]): Context { + if (!global.configIsInitialized()) { + throwError(`Config not initialized`); + } + return new Context( + global.es2panda._CreateContextGenerateAbcForExternalSourceFiles(global.config, filenames.length, passStringArray(filenames)) + ); + } + + destroy() { + if (this.peer != nullptr) { + global.es2panda._DestroyContext(this.peer) + this.peer = nullptr + } + } + + /** @deprecated */ + static destroyAndRecreate(ast: AstNode): Context { + console.log('[TS WRAPPER] DESTROY AND RECREATE'); + const source = filterSource(ast.dumpSrc()); + global.es2panda._DestroyContext(global.context); + global.compilerContext = Context.createFromString(source) as any; // Improve: commonize Context + + return new Context(global.context); + } + + get program(): Program { + return new Program(global.generatedEs2panda._ContextProgram(this.peer)); + } +} + +export class GlobalContext extends ArktsObject { + static create( + config: Config, externalFileList: string[] + ): GlobalContext { + return new GlobalContext( + global.es2panda._CreateGlobalContext( + config.peer, + passStringArray(externalFileList), + externalFileList.length, + false + ) + ) + } + + constructor(peer: KNativePointer) { + super(peer) + } + + destroy() { + if (this.peer != nullptr) { + global.es2panda._DestroyGlobalContext(this.peer) + this.peer = nullptr + } + } +} diff --git a/ets1.2/libarkts/src/arkts-api/peers/ExternalSource.ts b/ets1.2/libarkts/src/arkts-api/peers/ExternalSource.ts new file mode 100644 index 0000000000000000000000000000000000000000..ad8ddcacdd538e01edf58b9afbc2f60b3ae63eb4 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/peers/ExternalSource.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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 { global } from "../static/global" +import { acceptNativeObjectArrayResult, unpackString } from "../utilities/private" +import { KNativePointer, nullptr } from "@koalaui/interop" +import { Program } from "../../generated" +import { ArktsObject } from "./ArktsObject" + +export class ExternalSource extends ArktsObject { + constructor(peer: KNativePointer) { + super(peer) + } + + getName(): string { + return unpackString(global.es2panda._ExternalSourceName(this.peer)) + } + + get programs(): Program[] { + return acceptNativeObjectArrayResult( + global.es2panda._ExternalSourcePrograms(this.peer), + (instance: KNativePointer) => new Program(instance) + ) + } + + static instantiate(peer: KNativePointer) { + return new ExternalSource(peer) + } +} diff --git a/ets1.2/libarkts/src/arkts-api/peers/ImportPathManager.ts b/ets1.2/libarkts/src/arkts-api/peers/ImportPathManager.ts new file mode 100644 index 0000000000000000000000000000000000000000..020ac88c99073c0a9d08555db95afee8726e2cc6 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/peers/ImportPathManager.ts @@ -0,0 +1,30 @@ +/* + * 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 { ArktsObject } from "./ArktsObject" +import { global } from "../static/global" +import { KNativePointer } from "@koalaui/interop" + +export class ImportPathManager extends ArktsObject { + constructor(peer: KNativePointer) { + super(peer) + } + + static create(): ImportPathManager { + return new ImportPathManager( + global.es2panda._ETSParserGetImportPathManager(global.context) + ); + } +} \ No newline at end of file diff --git a/ets1.2/libarkts/src/arkts-api/peers/Options.ts b/ets1.2/libarkts/src/arkts-api/peers/Options.ts new file mode 100644 index 0000000000000000000000000000000000000000..cadb3e1e006a3d0ab835f9f220f2c4de67413a60 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/peers/Options.ts @@ -0,0 +1,34 @@ +/* + * 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 { ArktsObject } from "./ArktsObject" +import { global } from "../static/global" +import { Config } from "./Config" +import { ArkTsConfig } from "../../generated" + +export class Options extends ArktsObject { + constructor(peer: KNativePointer) { + super(peer) + } + + static createOptions(config: Config) { + return new Options(global.es2panda._ConfigGetOptions(config.peer)) + } + + getArkTsConfig(): ArkTsConfig { + return new ArkTsConfig(global.es2panda._OptionsArkTsConfig(global.context, this.peer)) + } +} diff --git a/ets1.2/libarkts/src/arkts-api/plugins.ts b/ets1.2/libarkts/src/arkts-api/plugins.ts new file mode 100644 index 0000000000000000000000000000000000000000..9e9b207ad31d6e26d7cd173923ceac24dd94e180 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/plugins.ts @@ -0,0 +1,70 @@ +/* + * 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 { Es2pandaContextState } from "../generated/Es2pandaEnums" +import { Program } from "../generated" +import { ExternalSource } from "./peers/ExternalSource" +import { KNativePointer } from "@koalaui/interop" +import { global } from "./static/global" +import { RunTransformerHooks } from "../plugin-utils" + +export interface CompilationOptions { + readonly isProgramForCodegeneration: boolean, + readonly state: Es2pandaContextState, +} + +export interface PluginContext { + setParameter(name: string, value: V): void + parameter(name: string) : V | undefined +} + +export class PluginContextImpl implements PluginContext { + map = new Map() + parameter(name: string): V|undefined { + return this.map.get(name) as (V|undefined) + } + setParameter(name: string, value: V) { + this.map.set(name, value as Object) + } +} + +export type ProgramTransformer = (program: Program, compilationOptions: CompilationOptions, context: PluginContext) => void + +export function defaultFilter(name: string) { + if (name.startsWith("std.")) return false + if (name.startsWith("escompat")) return false + return true +} + +export function listPrograms(program: Program, filter: (name: string) => boolean = defaultFilter): Program[] { + return [ + program, + ...program.getExternalSources().flatMap((it: ExternalSource) => { + if (filter(it.getName())) { + return it.programs + } + return [] + }) + ] +} + +export interface PluginEntry { + name?: string + parsed?: (hooks?: RunTransformerHooks) => void + checked?: (hooks?: RunTransformerHooks) => void + clean?: (hooks?: RunTransformerHooks) => void +} + +export type PluginInitializer = (parsedJson?: Object, checkedJson?: Object) => PluginEntry diff --git a/ets1.2/libarkts/src/arkts-api/static/global.ts b/ets1.2/libarkts/src/arkts-api/static/global.ts new file mode 100644 index 0000000000000000000000000000000000000000..282529aef69161a958b36be3e58b269793aed9d6 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/static/global.ts @@ -0,0 +1,107 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { throwError } from "../../utils" +import { KNativePointer, nullptr } from "@koalaui/interop" +import { initEs2panda, Es2pandaNativeModule, initGeneratedEs2panda } from "../../Es2pandaNativeModule" +import { Es2pandaNativeModule as GeneratedEs2pandaNativeModule } from "../../generated/Es2pandaNativeModule" +import { initInterop, InteropNativeModule } from "../../InteropNativeModule" +import { Context } from "../peers/Context" +import { Profiler } from "./profiler" +import { ArkTsConfig } from "../../generated" +import { Config } from '../peers/Config'; + +export class UpdateTracker { + stack: boolean[] = [] + + push() { + this.stack.push(false) + } + + update() { + this.stack[this.stack.length - 1] = true + } + + check() { + return this.stack.pop() + } +} + +export class global { + public static filePath: string = "./plugins/input/main.ets" + + public static arktsconfig?: ArkTsConfig + public static configObj?: Config; + + private static _config?: KNativePointer + public static set config(config: KNativePointer) { + global._config = config + global.configObj = new Config(global._config); + } + public static get config(): KNativePointer { + return global._config ?? throwError('Global.config not initialized') + } + public static configIsInitialized(): boolean { + return global._config !== undefined && global._config !== nullptr + } + public static resetConfig(): void { + global._config = undefined + global.configObj = undefined; + } + + // Improve: rename to contextPeer + public static get context(): KNativePointer { + return global.compilerContext?.peer ?? throwError('Global.context not initialized') + } + + // Improve: rename to context when the pointer valued one is eliminated + public static compilerContext: Context | undefined + public static isContextGenerateAbcForExternalSourceFiles: boolean = false + + private static _es2panda: Es2pandaNativeModule | undefined = undefined + public static get es2panda(): Es2pandaNativeModule { + if (this._es2panda === undefined) { + this._es2panda = initEs2panda() + } + return this._es2panda + } + + private static _generatedEs2panda: GeneratedEs2pandaNativeModule | undefined = undefined + public static get generatedEs2panda(): GeneratedEs2pandaNativeModule { + if (this._generatedEs2panda === undefined) { + this._generatedEs2panda = initGeneratedEs2panda() + } + return this._generatedEs2panda + } + + private static _interop: InteropNativeModule | undefined = undefined + public static get interop(): InteropNativeModule { + if (this._interop === undefined) this._interop = initInterop() + return this._interop + + } + + public static profiler = new Profiler() + + // Check node type values during node creation + public static validatePeerTypes = false + + public static clearContext(): void { + global.compilerContext = undefined + } + + // Keep track of update info to optimize performance + public static updateTracker: UpdateTracker = new UpdateTracker() +} diff --git a/ets1.2/libarkts/src/arkts-api/static/globalUtils.ts b/ets1.2/libarkts/src/arkts-api/static/globalUtils.ts new file mode 100644 index 0000000000000000000000000000000000000000..f23b1facfbbc5886cd744b894d781897614494fc --- /dev/null +++ b/ets1.2/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 { NodeCache } from "../node-cache" + +export function getOrUpdateGlobalContext(peer: KNativePointer): Context { + if (!global.compilerContext || global.context !== peer) { + NodeCache.clear(); + global.compilerContext = new Context(peer); + } + return global.compilerContext; +} \ No newline at end of file diff --git a/ets1.2/libarkts/src/arkts-api/static/profiler.ts b/ets1.2/libarkts/src/arkts-api/static/profiler.ts new file mode 100644 index 0000000000000000000000000000000000000000..5a1d2e15a458c5a0ff71dfbef369d787353a66d2 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/static/profiler.ts @@ -0,0 +1,189 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as fs from "fs" +import * as path from "path" +import { Es2pandaContextState } from "../../generated/Es2pandaEnums" +import { global } from "./global" + +const PERFORMANCE_DATA_DIR = "./performance-results/" + +interface PluginData { + transformTime: number + transformTimeDeps: number + visitedNodes: number + createdNodes: number + contextState?: Es2pandaContextState +} + +function emptyPluginData(contextState?: Es2pandaContextState): PluginData { + return { + transformTime: 0, + transformTimeDeps: 0, + visitedNodes: 0, + createdNodes: 0, + contextState: contextState + } +} + +interface PerformanceData { + filePath: string + + visitedNodes: number + createdNodes: number + proceedTime: number + totalTime: number + + pluginsByName: Record +} + +interface PerformanceDataFile { + data: PerformanceData[] + summary?: PerformanceData +} + +function parseFile(performanceFile: string): PerformanceDataFile | undefined { + if (!fs.existsSync(performanceFile)) return undefined + + const data = fs.readFileSync(path.resolve(performanceFile)).toString() + if (!data.length) return undefined + return JSON.parse(data) as PerformanceDataFile +} + +export class Profiler implements PerformanceData { + filePath: string = "" + visitedNodes: number = 0 + createdNodes: number = 0 + proceedTime: number = 0 + totalTime: number = 0 + pluginsByName: Record = {} + + curPlugin: string = "" + curContextState?: Es2pandaContextState + + private getPluginData(pluginName: string, contextState?: Es2pandaContextState): PluginData { + if (!(pluginName in this.pluginsByName)) { + this.pluginsByName[pluginName] = emptyPluginData(contextState) + } + return this.pluginsByName[pluginName] + } + + disableReport = false + + nodeCreated() { + this.createdNodes++ + if (this.curPlugin) this.getPluginData(this.curPlugin, this.curContextState).createdNodes++ + } + + nodeVisited() { + this.visitedNodes++ + if (this.curPlugin) this.getPluginData(this.curPlugin, this.curContextState).visitedNodes++ + } + + private transformStartTime = 0 + transformStarted() { + this.transformStartTime = Date.now() + } + private transformDepStartTime = 0 + transformDepStarted() { + this.transformDepStartTime = Date.now() + } + + transformEnded(state: Es2pandaContextState, pluginName: string) { + const transformEndTime = Date.now() + const consumedTime = transformEndTime - this.transformStartTime + this.getPluginData(pluginName, state).transformTime += consumedTime + } + + transformDepEnded(state: Es2pandaContextState, pluginName: string) { + const transformEndTime = Date.now() + const consumedTime = transformEndTime - this.transformDepStartTime + this.getPluginData(pluginName, state).transformTimeDeps += consumedTime + } + + proceededToState(consumedTime: number) { + this.proceedTime += consumedTime + } + + private compilationStartTime = 0 + compilationStarted(filePath: string) { + this.filePath = filePath + + this.visitedNodes = 0 + this.createdNodes = 0 + this.proceedTime = 0 + this.totalTime = 0 + this.pluginsByName = {} + + this.curPlugin = "" + this.compilationStartTime = Date.now() + } + + compilationEnded() { + const consumedTime: number = Date.now() - this.compilationStartTime + this.totalTime = consumedTime + } + + report() { + Object.entries(this.pluginsByName).forEach((data, key) => { + console.log(data[0], "totalTransformTime =", data[1].transformTime, "ms") + console.log(data[0], "totalDepsTransformTime =", data[1].transformTimeDeps, "ms") + }) + } + + reportToFile(withSummary: boolean = false) { + if (this.disableReport) return + const outDir = path.resolve(global.arktsconfig!.outDir, PERFORMANCE_DATA_DIR) + fs.mkdirSync(outDir, { recursive: true }) + const outFilePath = path.resolve(outDir, path.basename(this.filePath)) + ".json" + + const data: PerformanceDataFile = { data: [this as PerformanceData] } + if (!fs.existsSync(outFilePath)) { + fs.writeFileSync(outFilePath, JSON.stringify(data)) + } else { + const savedData: PerformanceDataFile | undefined = parseFile(outFilePath) ?? data + savedData.data.push(this as PerformanceData) + + if (withSummary) { + const summary: PerformanceData = { + filePath: this.filePath, + visitedNodes: savedData.data.map(it => it.visitedNodes).reduce((sum, it) => sum + it), + createdNodes: savedData.data.map(it => it.createdNodes).reduce((sum, it) => sum + it), + proceedTime: savedData.data.map(it => it.proceedTime).reduce((sum, it) => sum + it), + totalTime: savedData.data.map(it => it.totalTime).reduce((sum, it) => sum + it), + pluginsByName: {} + } + const pluginNames = new Set(savedData.data.flatMap(it => Object.keys(it.pluginsByName))) + for (const pluginName of pluginNames) { + const sumTransformTime = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].transformTime).reduce((sum, it) => sum+it) + const sumTransformTimeDeps = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].transformTimeDeps).reduce((sum, it) => sum+it) + const sumCreatedNodes = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].createdNodes).reduce((sum, it) => sum+it) + const sumVisitedNodes = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].visitedNodes).reduce((sum, it) => sum+it) + + summary.pluginsByName[pluginName] = { + transformTime: sumTransformTime, + transformTimeDeps: sumTransformTimeDeps, + createdNodes: sumCreatedNodes, + visitedNodes: sumVisitedNodes, + } + } + + savedData.summary = summary + } + + fs.writeFileSync(outFilePath, JSON.stringify(savedData)) + } + } +} diff --git a/ets1.2/libarkts/src/arkts-api/utilities/extensions.ts b/ets1.2/libarkts/src/arkts-api/utilities/extensions.ts new file mode 100644 index 0000000000000000000000000000000000000000..85e816557b737a1698570a5d4b4a4470635b2be8 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/utilities/extensions.ts @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { KInt, KNativePointer } from "@koalaui/interop" +import type { + ClassDefinition, + ETSModule, + Expression, + MethodDefinition, + NumberLiteral, + Program, + ScriptFunction, + SourcePosition, +} from "../../generated" +import { ExternalSource } from "../peers/ExternalSource" +import { Es2pandaModuleFlag } from "../../generated/Es2pandaEnums" +import { global } from "../static/global" +import { acceptNativeObjectArrayResult, passNodeArray } from "./private" +import type { AstNode } from "../peers/AstNode" + +export function extension_ETSModuleGetNamespaceFlag(this: ETSModule): Es2pandaModuleFlag { + return (this.isETSScript ? Es2pandaModuleFlag.MODULE_FLAG_ETSSCRIPT : 0) + + (this.isNamespace ? Es2pandaModuleFlag.MODULE_FLAG_NAMESPACE : 0) + + (this.isNamespaceChainLastNode ? Es2pandaModuleFlag.MODULE_FLAG_NAMESPACE_CHAIN_LAST_NODE : 0) +} + +// this is a workaround for overloads not included in children list +export function extension_MethodDefinitionSetChildrenParentPtr(this: MethodDefinition) { + global.es2panda._AstNodeSetChildrenParentPtr(global.context, this.peer) + const overloads = this.overloads + for (const overload of overloads) { + overload.setBaseOverloadMethod(this) + overload.parent = this // overloads are not listed as children in native + } +} + +export function extension_MethodDefinitionOnUpdate(this: MethodDefinition, original: MethodDefinition): void { + this.setChildrenParentPtr() + global.es2panda._AstNodeOnUpdate(global.context, this.peer, original.peer) + const originalBase = original.baseOverloadMethod + if (originalBase) { + this.setBaseOverloadMethod(originalBase) + } +} + +// Improve: generate checker related stuff +export function extension_ScriptFunctionGetSignaturePointer(this: ScriptFunction): KNativePointer { + return global.es2panda._Checker_ScriptFunctionSignature(global.context, this.peer) +} + +export function extension_ScriptFunctionSetSignaturePointer(this: ScriptFunction, signaturePointer: KNativePointer): void { + global.es2panda._Checker_ScriptFunctionSetSignature(global.context, this.peer, signaturePointer) +} + +// Improve: perhaps "preferredReturnType" stuff can be removed later if "signature" is always enough +export function extension_ScriptFunctionGetPreferredReturnTypePointer(this: ScriptFunction): KNativePointer { + return global.es2panda._Checker_ScriptFunctionGetPreferredReturnType(global.context, this.peer) +} + +export function extension_ScriptFunctionSetPreferredReturnTypePointer(this: ScriptFunction, typePointer: KNativePointer): void { + global.es2panda._Checker_ScriptFunctionSetPreferredReturnType(global.context, this.peer, typePointer) +} + +// Improve: generate checker related stuff +export function extension_ExpressionGetPreferredTypePointer(this: Expression): KNativePointer { + return global.es2panda._Checker_ExpressionGetPreferredType(global.context, this.peer) +} + +export function extension_ExpressionSetPreferredTypePointer(this: Expression, typePointer: KNativePointer): void { + global.es2panda._Checker_ExpressionSetPreferredType(global.context, this.peer, typePointer) +} + +// Improve: generate methods with string[] args or return type +export function extension_ProgramGetExternalSources(this: Program): ExternalSource[] { + return acceptNativeObjectArrayResult( + global.es2panda._ProgramExternalSources(global.context, this.peer), + ExternalSource.instantiate, + ) +} + +// Improve: SourcePositionLine is global in idl +export function extension_SourcePositionGetLine(this: SourcePosition): KInt { + return global.generatedEs2panda._SourcePositionLine(global.context, this.peer) +} + +// Improve: SourcePositionCol is not described in idl +export function extension_SourcePositionGetCol(this: SourcePosition): KInt { + return global.es2panda._SourcePositionCol(global.context, this.peer) +} + +export function extension_SourcePositionToString(this: SourcePosition): string { + return `:${this.getLine() + 1}:${this.getCol()}` +} + +// Improve: weird API +export function extension_NumberLiteralValue(this: NumberLiteral): number { + return +this.dumpSrc() +} + +// Improve: weird API +export function extension_ScriptFunctionSetParams(this: ScriptFunction, params: readonly Expression[]): void { + global.es2panda._ScriptFunctionSetParams(global.context, this.peer, passNodeArray(params), params.length) +} + +// Improve: weird API +export function extension_ClassDefinitionSetBody(this: ClassDefinition, body: readonly AstNode[]): void { + global.es2panda._ClassDefinitionSetBody(global.context, this.peer, passNodeArray(body), body.length) +} diff --git a/ets1.2/libarkts/src/arkts-api/utilities/nativePtrDecoder.ts b/ets1.2/libarkts/src/arkts-api/utilities/nativePtrDecoder.ts new file mode 100644 index 0000000000000000000000000000000000000000..08bf50a728f45098ea4441f06f85f83bd3de89a5 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/utilities/nativePtrDecoder.ts @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { int32 } from "@koalaui/common" +import { + Access, + ArrayDecoder, + CallbackRegistry, + NativeStringBase, + nullptr, + pointer, + providePlatformDefinedData, + withByteArray +} from "@koalaui/interop" +import { global } from "../static/global" + +class NativeString extends NativeStringBase { + constructor(ptr: pointer) { + super(ptr) + } + protected bytesLength(): int32 { + return global.interop._StringLength(this.ptr) + } + protected getData(data: Uint8Array): void { + withByteArray(data, Access.WRITE, (dataPtr: pointer) => { + global.interop._StringData(this.ptr, dataPtr, data.length) + }) + } + close(): void { + global.interop._InvokeFinalizer(this.ptr, global.interop._GetStringFinalizer()) + this.ptr = nullptr + } +} + +providePlatformDefinedData({ + nativeString(ptr: pointer): NativeStringBase { + return new NativeString(ptr) + }, + nativeStringArrayDecoder(): ArrayDecoder { + throw new Error("Not yet implemented") + }, + callbackRegistry(): CallbackRegistry | undefined { + return undefined + } +}) + +export class NativePtrDecoder extends ArrayDecoder { + getArraySize(blob: pointer) { + return global.interop._GetPtrVectorSize(blob) + } + disposeArray(blob: pointer): void { + // Improve: + } + getArrayElement(blob: pointer, index: int32): pointer { + return global.interop._GetPtrVectorElement(blob, index) + } +} \ No newline at end of file diff --git a/ets1.2/libarkts/src/arkts-api/utilities/private.ts b/ets1.2/libarkts/src/arkts-api/utilities/private.ts new file mode 100644 index 0000000000000000000000000000000000000000..24d909ff81baaaadd8750e82d811775169660014 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/utilities/private.ts @@ -0,0 +1,156 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { global } from "../static/global" +import { isNumber, throwError } from "../../utils" +import { + KInt, + KNativePointer as KPtr, + KNativePointer, + nullptr, + withString, + withStringArray +} from "@koalaui/interop" +import { NativePtrDecoder } from "./nativePtrDecoder" +import { Es2pandaAstNodeType, Es2pandaModifierFlags, Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums" +import { nodeFrom } from "../class-by-peer" +import { AstNode } from "../peers/AstNode" +import { ArktsObject } from "../peers/ArktsObject" + +export const arrayOfNullptr = new BigUint64Array([nullptr]) + +export const allFlags = + Object.values(Es2pandaModifierFlags) + .filter(isNumber) + .reduce( + (prev, next) => prev | next, + 0 + ) + +export function assertValidPeer(peer: KPtr, expectedKind: Es2pandaAstNodeType): void { + if (peer === nullptr) { + throwError(`invalid peer`) + } + + if (global.validatePeerTypes) { + const peerType = global.generatedEs2panda._AstNodeTypeConst(global.context, peer) + if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION) { + // Improve: Struct is a child class of Class + return + } + if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION) { + // Improve: ETSImportDeclaration is a child of a ImportDeclaration + return + } + if (peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE && expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT) { + // Improve: ETSModule is a child of a BlockStatement + return + } + if (peerType !== expectedKind) { + throwError(`expected: ${Es2pandaAstNodeType[expectedKind]}, got: ${Es2pandaAstNodeType[peerType]}`) + } + } +} + +export function acceptNativeObjectArrayResult(arrayObject: KNativePointer, factory: (instance: KNativePointer) => T): T[] { + return new NativePtrDecoder().decode(arrayObject).map(factory); +} + +export function unpackNonNullableNode(peer: KNativePointer): T { + if (peer === nullptr) { + throwError('peer is NULLPTR (maybe you should use unpackNode)') + } + return nodeFrom(peer) +} + +export function unpackNode(peer: KNativePointer): T | undefined { + if (peer === nullptr) { + return undefined + } + return nodeFrom(peer) +} + +export function passNode(node: ArktsObject | undefined): KNativePointer { + return node?.peer ?? nullptr +} + +export function unpackNodeArray(nodesPtr: KNativePointer): T[] { + if (nodesPtr === nullptr) { + throwError('nodesPtr is NULLPTR (maybe you should use unpackNodeArray)') + } + return new NativePtrDecoder() + .decode(nodesPtr) + .map((peer: KNativePointer) => unpackNonNullableNode(peer)) +} + +export function passNodeArray(nodes: readonly ArktsObject[] | undefined): BigUint64Array { + return new BigUint64Array( + nodes + ?.filter(it => it.peer != undefined) + ?.map(node => BigInt(node.peer)) + ?? [] + ) +} + +export function unpackNonNullableObject(type: { new (peer: KNativePointer): T }, peer: KNativePointer): T { + if (peer === nullptr) { + throwError('peer is NULLPTR (maybe you should use unpackObject)') + } + return new type(peer) +} + +export function unpackObject(type: { new (peer: KNativePointer): T }, peer: KNativePointer): T | undefined { + if (peer === nullptr) { + return undefined + } + return new type(peer) +} + +export function unpackString(peer: KNativePointer): string { + return global.interop._RawUtf8ToString(peer) +} + +// Improve: use direct string arguments instead. +export function passString(str: string | undefined): string { + return str ?? "" +} + +// Improve: use direct string arguments instead. +export function passStringArray(strings: readonly string[]): string[] { + return withStringArray(strings, (it: string[]) => it) +} + +export function passNodeWithNewModifiers(node: T, modifiers: KInt): T { + return unpackNonNullableNode(node.peer).updateModifiers(modifiers) +} + +export function scriptFunctionHasBody(peer: KNativePointer): boolean { + const flags = global.generatedEs2panda._ScriptFunctionFlagsConst(global.context, peer) + return (flags & Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_EXTERNAL) === 0 + && (flags & Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_EXTERNAL_OVERLOAD) === 0 +} + +export function updateNodeByNode(node: T, original: T): T { + if (original.peer === nullptr) { + throwError('update called on NULLPTR') + } + node.onUpdate(original) + return node +} + +export function nodeType(node: AstNode): Es2pandaAstNodeType { + return global.generatedEs2panda._AstNodeTypeConst(global.context, passNode(node)) +} + diff --git a/ets1.2/libarkts/src/arkts-api/utilities/public.ts b/ets1.2/libarkts/src/arkts-api/utilities/public.ts new file mode 100644 index 0000000000000000000000000000000000000000..3c025a409561ecfae736e251e272238bf3a91114 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/utilities/public.ts @@ -0,0 +1,397 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { global } from "../static/global" +import { isNumber, throwError, withWarning } from "../../utils" +import { KNativePointer, nullptr, KInt} from "@koalaui/interop" +import { passNode, passNodeArray, unpackNodeArray, unpackNonNullableNode, passString, unpackString, nodeType } from "./private" +import { Es2pandaContextState, Es2pandaModifierFlags, Es2pandaMethodDefinitionKind, Es2pandaPrimitiveType, Es2pandaScriptFunctionFlags, Es2pandaAstNodeType } from "../../generated/Es2pandaEnums" +import type { AstNode } from "../peers/AstNode" +import { SourcePosition } from "../../generated" +import { isSameNativeObject } from "../peers/ArktsObject" +import { + type AnnotationUsage, + ClassDefinition, + ClassProperty, + ETSModule, + isClassDefinition, + isFunctionDeclaration, + isMemberExpression, + isScriptFunction, + isIdentifier, + isETSModule, + ImportSpecifier, + Program, + isObjectExpression, + ETSImportDeclaration, + isProperty, + isTSInterfaceDeclaration, + isNumberLiteral, + Property, + MemberExpression, + isMethodDefinition, + TypeNode, +} from "../../generated" +import { Config } from "../peers/Config" +import { Context } from "../peers/Context" +import { NodeCache } from "../node-cache" +import { listPrograms } from "../plugins" +import { factory } from "../factory/nodeFactory" +import { traceGlobal } from "../../tracer" + +/** + * Improve: Replace or remove with better naming + * + * @deprecated + */ +export function createETSModuleFromContext(): ETSModule { + let program = global.generatedEs2panda._ContextProgram(global.context) + if (program == nullptr) { + throw new Error(`Program is null for context ${global.context.toString(16)}`) + } + const ast = global.generatedEs2panda._ProgramAst(global.context, program) + if (ast == nullptr) { + throw new Error(`AST is null for program ${program.toString(16)}`) + + } + return new ETSModule(ast, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) +} + +/** + * Now used only in tests + * Improve: Remove or replace with better method + * + * @deprecated + */ +export function createETSModuleFromSource( + source: string, + state: Es2pandaContextState = Es2pandaContextState.ES2PANDA_STATE_PARSED, +): ETSModule { + if (!global.configIsInitialized()) { + global.config = Config.createDefault().peer + } + global.compilerContext = Context.createFromString(source) + proceedToState(state) + let program = global.generatedEs2panda._ContextProgram(global.compilerContext.peer) + if (program == nullptr) + throw new Error(`Program is null for ${source} 0x${global.compilerContext.peer.toString(16)}`) + return new ETSModule(global.generatedEs2panda._ProgramAst(global.context, program), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) +} + +export function metaDatabase(fileName: string): string { + if (fileName.endsWith(".meta.json")) throw new Error(`Must pass source, not database: ${fileName}`) + return `${fileName}.meta.json` +} + +export function checkErrors() { + if (global.es2panda._ContextState(global.context) === Es2pandaContextState.ES2PANDA_STATE_ERROR) { + traceGlobal(() => `Terminated due to compilation errors occured`) + console.log(unpackString(global.generatedEs2panda._GetAllErrorMessages(global.context))) + // global.es2panda._DestroyConfig(global.config) + process.exit(1) + } +} + +export function proceedToState(state: Es2pandaContextState): void { + if (state <= global.es2panda._ContextState(global.context)) { + return + } + NodeCache.clear() + const before = Date.now() + traceGlobal(() => `Proceeding to state ${Es2pandaContextState[state]}: start`) + global.es2panda._ProceedToState(global.context, state) + traceGlobal(() => `Proceeding to state ${Es2pandaContextState[state]}: done`) + const after = Date.now() + global.profiler.proceededToState(after-before) + checkErrors() +} + +/** @deprecated Use {@link rebindContext} instead */ +export function rebindSubtree(node: AstNode): void { + NodeCache.clear() + traceGlobal(() => `Rebind: start`) + global.es2panda._AstNodeRebind(global.context, node.peer) + traceGlobal(() => `Rebind: done`) + checkErrors() +} + +/** @deprecated Use {@link recheckSubtree} instead */ +export function recheckSubtree(node: AstNode): void { + NodeCache.clear() + traceGlobal(() => `Recheck: start`) + global.generatedEs2panda._AstNodeRecheck(global.context, node.peer) + traceGlobal(() => `Recheck: done`) + checkErrors() +} + +export function rebindContext(context: KNativePointer = global.context): void { + NodeCache.clear() + traceGlobal(() => `Rebind: start`) + global.es2panda._AstNodeRebind( + context, + global.generatedEs2panda._ProgramAst( + context, + global.generatedEs2panda._ContextProgram( + context + ) + ) + ) + traceGlobal(() => `Rebind: done`) + checkErrors() +} + +export function recheckContext(context: KNativePointer = global.context): void { + NodeCache.clear() + traceGlobal(() => `Recheck: start`) + global.generatedEs2panda._AstNodeRecheck( + context, + global.generatedEs2panda._ProgramAst( + context, + global.generatedEs2panda._ContextProgram( + context, + ) + ) + ) + traceGlobal(() => `Recheck: done`) + checkErrors() +} + +export function getDecl(node: AstNode): AstNode | undefined { + if (isMemberExpression(node)) { + return getDeclFromArrayOrObjectMember(node) + } + if (isObjectExpression(node)) { + return getPeerObjectDecl(passNode(node)) + } + const decl = getPeerDecl(passNode(node)) + if (!!decl) { + return decl + } + if (!!node.parent && isProperty(node.parent)) { + return getDeclFromProperty(node.parent) + } + return undefined +} + +function getDeclFromProperty(node: Property): AstNode | undefined { + if (!node.key) { + return undefined + } + if (!!node.parent && !isObjectExpression(node.parent)) { + return getPeerDecl(passNode(node.key)) + } + return getDeclFromObjectExpressionProperty(node) +} + +function getDeclFromObjectExpressionProperty(node: Property): AstNode | undefined { + const declNode = getPeerObjectDecl(passNode(node.parent)) + if (!declNode || !node.key || !isIdentifier(node.key)) { + return undefined + } + let body: readonly AstNode[] = [] + if (isClassDefinition(declNode)) { + body = declNode.body + } else if (isTSInterfaceDeclaration(declNode)) { + body = declNode.body?.body ?? [] + } + return body.find( + (statement) => + isMethodDefinition(statement) && + statement.kind === Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_GET && + !!statement.id && + !!node.key && + isIdentifier(node.key) && + statement.id.name === node.key.name + ) +} + +function getDeclFromArrayOrObjectMember(node: MemberExpression): AstNode | undefined { + if (isNumberLiteral(node.property)) { + return node.object ? getDecl(node.object) : undefined + } + return node.property ? getDecl(node.property) : undefined +} + +export function getPeerDecl(peer: KNativePointer): AstNode | undefined { + const decl = global.generatedEs2panda._DeclarationFromIdentifier(global.context, peer) + if (decl === nullptr) { + return undefined + } + return unpackNonNullableNode(decl) +} + +export function getPeerObjectDecl(peer: KNativePointer): AstNode | undefined { + const decl = global.es2panda._ClassVariableDeclaration(global.context, peer); + if (decl === nullptr) { + return undefined; + } + return unpackNonNullableNode(decl) +} + +export function getAnnotations(node: AstNode): readonly AnnotationUsage[] { + if (!isFunctionDeclaration(node) && !isScriptFunction(node) && !isClassDefinition(node)) { + throwError('for now annotations allowed only for: functionDeclaration, scriptFunction, classDefinition') + } + return unpackNodeArray(global.es2panda._AnnotationAllowedAnnotations(global.context, node.peer, nullptr)) +} + +export function getOriginalNode(node: AstNode): AstNode { + if (node === undefined) { + // Improve: fix this + throwError('there is no arkts pair of ts node (unable to getOriginalNode)') + } + if (node.originalPeer === nullptr) { + return node + } + return unpackNonNullableNode(node.originalPeer) +} + +export function getFileName(): string { + return global.filePath +} + +export function getJsDoc(node: AstNode): string | undefined { + const result = unpackString(global.generatedEs2panda._JsdocStringFromDeclaration(global.context, node.peer)) + return result === 'Empty Jsdoc' ? undefined : result +} + + +// Improve: It seems like Definition overrides AstNode modifiers +// with it's own modifiers which is completely unrelated set of flags. +// Use this function if you need +// the language level modifiers: public, declare, export, etc. +export function classDefinitionFlags(node: ClassDefinition): Es2pandaModifierFlags { + return global.generatedEs2panda._AstNodeModifiers(global.context, node.peer) +} + +// Improve: ClassProperty's optional flag is set by AstNode's modifiers flags. +export function classPropertySetOptional(node: ClassProperty, value: boolean): ClassProperty { + if (value) { + node.modifierFlags |= Es2pandaModifierFlags.MODIFIER_FLAGS_OPTIONAL; + } else { + node.modifierFlags &= Es2pandaModifierFlags.MODIFIER_FLAGS_OPTIONAL; + } + return node; +} + +export function hasModifierFlag(node: AstNode, flag: Es2pandaModifierFlags): boolean { + if (!node) return false; + + let modifiers; + if (isClassDefinition(node)) { + modifiers = classDefinitionFlags(node); + } else { + modifiers = node.modifierFlags + } + return (modifiers & flag) === flag; +} + +export function modifiersToString(modifiers: Es2pandaModifierFlags): string { + return Object.values(Es2pandaModifierFlags) + .filter(isNumber) + .map(it => { + console.log(it.valueOf(), Es2pandaModifierFlags[it], modifiers.valueOf() & it) + return ((modifiers.valueOf() & it) === it) ? Es2pandaModifierFlags[it] : "" + }).join(" ") +} + +export function nameIfIdentifier(node: AstNode): string { + return isIdentifier(node) ? `'${node.name}'` : "" +} + +export function nameIfETSModule(node: AstNode): string { + return isETSModule(node) ? `'${node.ident?.name}'` : "" +} + +export function asString(node: AstNode|undefined): string { + return `${node?.constructor.name} ${node ? nameIfIdentifier(node) : undefined}` +} + +const defaultPandaSdk = "../../../incremental/tools/panda/node_modules/@panda/sdk" + + +export function findStdlib(): string { + const sdk = process.env.PANDA_SDK_PATH ?? withWarning( + defaultPandaSdk, + `PANDA_SDK_PATH not set, assuming ${defaultPandaSdk}` + ) + return `${sdk}/ets/stdlib` +} + +export function generateTsDeclarationsFromContext( + outputDeclEts: string, + outputEts: string, + exportAll: boolean, + isolated: boolean, + recordFile: string +): KInt { + return global.es2panda._GenerateTsDeclarationsFromContext( + global.context, + passString(outputDeclEts), + passString(outputEts), + exportAll, + isolated, + recordFile + ); +} + +export function setAllParents(ast: AstNode): void { + global.es2panda._AstNodeUpdateAll(global.context, ast.peer); +} + +export function getProgramFromAstNode(node: AstNode): Program { + return new Program(global.es2panda._AstNodeProgram(global.context, node.peer)) +} + +export function importDeclarationInsert(node: ETSImportDeclaration, program: Program): void { + global.generatedEs2panda._InsertETSImportDeclarationAndParse(global.context, program.peer, node.peer) +} + +export function signatureReturnType(signature: KNativePointer): KNativePointer { + if (!signature) { + return nullptr + } + return global.es2panda._Checker_SignatureReturnType(global.context, signature) +} + +export function convertCheckerTypeToTypeNode(typePeer: KNativePointer | undefined): TypeNode | undefined { + if (!typePeer) { + return undefined + } + return factory.createOpaqueTypeNode( + global.es2panda._Checker_TypeClone(global.context, typePeer) + ) +} + +export function originalSourcePositionString(node: AstNode | undefined) { + if (!node) { + return `[undefined]` + } + const originalPeer = node.originalPeer + const sourcePosition = new SourcePosition(global.generatedEs2panda._AstNodeStartConst(global.context, originalPeer)) + const program = new Program(global.es2panda._AstNodeProgram(global.context, originalPeer)) + if (!program.peer) { + // This can happen if we are calling this method on node that is in update now and parent chain does not lead to program + return `[${global.filePath}${sourcePosition.toString()}]` + } + return `[${program.absoluteName}${sourcePosition.toString()}]` +} + +export function generateStaticDeclarationsFromContext(outputPath: string): KInt { + return global.generatedEs2panda._GenerateStaticDeclarationsFromContext( + global.context, + passString(outputPath) + ); +} diff --git a/ets1.2/libarkts/src/arkts-api/visitor.ts b/ets1.2/libarkts/src/arkts-api/visitor.ts new file mode 100644 index 0000000000000000000000000000000000000000..761ac8d023d3cbdbfd4f1f6f3f0cda4e7e84d95a --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/visitor.ts @@ -0,0 +1,1200 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { isSameNativeObject } from "../arkts-api/peers/ArktsObject" +import { + AnnotationUsage, + ArrayExpression, + ArrowFunctionExpression, + AssignmentExpression, + BinaryExpression, + BlockExpression, + BlockStatement, + CallExpression, + CatchClause, + ChainExpression, + ClassDeclaration, + ClassDefinition, + ClassProperty, + ClassStaticBlock, + ConditionalExpression, + DoWhileStatement, + ETSFunctionType, + ETSImportDeclaration, + ETSModule, + ETSNewClassInstanceExpression, + ETSParameterExpression, + ETSStructDeclaration, + ETSTuple, + ETSTypeReference, + ETSTypeReferencePart, + ETSUnionType, + Expression, + ExpressionStatement, + ForInStatement, + ForOfStatement, + ForUpdateStatement, + FunctionDeclaration, + FunctionExpression, + Identifier, + IfStatement, + isArrayExpression, + isArrowFunctionExpression, + isAssignmentExpression, + isBinaryExpression, + isBlockExpression, + isBlockStatement, + isCallExpression, + isChainExpression, + isClassDeclaration, + isClassDefinition, + isClassProperty, + isConditionalExpression, + isDoWhileStatement, + isETSFunctionType, + isETSImportDeclaration, + isETSModule, + isETSNewClassInstanceExpression, + isETSParameterExpression, + isETSStructDeclaration, + isETSTuple, + isETSTypeReference, + isETSTypeReferencePart, + isETSUnionType, + isExpressionStatement, + isForInStatement, + isForOfStatement, + isForUpdateStatement, + isFunctionDeclaration, + isFunctionExpression, + isIdentifier, + isIfStatement, + isMemberExpression, + isMethodDefinition, + isObjectExpression, + isProperty, + isReturnStatement, + isScriptFunction, + isSwitchCaseStatement, + isSwitchStatement, + isTemplateLiteral, + isTryStatement, + isTSAsExpression, + isTSInterfaceBody, + isTSInterfaceDeclaration, + isTSNonNullExpression, + isTSTypeAliasDeclaration, + isTSTypeParameterDeclaration, + isTSTypeParameterInstantiation, + isUpdateExpression, + isVariableDeclaration, + isVariableDeclarator, + isWhileStatement, + MemberExpression, + MethodDefinition, + ObjectExpression, + Property, + ReturnStatement, + ScriptFunction, + Statement, + SwitchCaseStatement, + SwitchStatement, + TemplateElement, + TemplateLiteral, + TryStatement, + TSAsExpression, + TSClassImplements, + TSInterfaceBody, + TSInterfaceDeclaration, + TSInterfaceHeritage, + TSNonNullExpression, + TSTypeAliasDeclaration, + TSTypeParameter, + TSTypeParameterDeclaration, + TSTypeParameterInstantiation, + TypeNode, + UpdateExpression, + VariableDeclaration, + VariableDeclarator, + WhileStatement +} from "../generated" +import { Es2pandaAstNodeType, Es2pandaImportKinds } from "../generated/Es2pandaEnums" +import { factory } from "./factory/nodeFactory" +import { AstNode } from "./peers/AstNode" +import { global } from "./static/global" + +type Visitor = (node: AstNode, options?: object) => AstNode + +export interface DoubleNode { + originNode: AstNode; + translatedNode: AstNode; +} + +export class StructInfo { + stateVariables: Set = new Set(); + initializeBody: AstNode[] = []; + updateBody: AstNode[] = []; +} + +export class GlobalInfo { + private _structCollection: Set; + private static instance: GlobalInfo; + private _structMap: Map; + + private constructor() { + this._structCollection = new Set(); + this._structMap = new Map(); + } + + public static getInfoInstance(): GlobalInfo { + if (!this.instance) { + this.instance = new GlobalInfo(); + } + return this.instance; + } + + public add(str: string): void { + this._structCollection.add(str); + } + + public getStructCollection(): Set { + return this._structCollection; + } + + public getStructInfo(structName: string): StructInfo { + const structInfo = this._structMap.get(structName); + if (!structInfo) { + return new StructInfo(); + } + return structInfo; + } + + public setStructInfo(structName: string, info: StructInfo): void { + this._structMap.set(structName, info); + } +} + +// Improve: rethink (remove as) +function nodeVisitor(node: T, visitor: Visitor): T { + if (node === undefined) { + return node + } + const result = visitor(node) as T + if (node != result) { + global.updateTracker.update() + } + return result +} + +// Improve: rethink (remove as) +function nodesVisitor(nodes: TIn, visitor: Visitor): T[] | TIn { + if (nodes === undefined) { + return nodes + } + return nodes.map(node => { + const result = visitor(node) as T + if (node != result) { + global.updateTracker.update() + } + return result + }) +} + +function visitBlockStatement(node: BlockStatement, visitor: Visitor) { + global.updateTracker.push() + const newStatements: readonly Statement[] = nodesVisitor(node.statements, visitor) + if (global.updateTracker.check()) { + node.setStatements(newStatements) + } + return node +} + +function visitETSModule(node: ETSModule, visitor: Visitor) { + global.updateTracker.push() + const newStatements: readonly Statement[] = nodesVisitor(node.statements, visitor) + const oldIdent = node.ident + const newIdent = nodeVisitor(oldIdent, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newIdent, oldIdent)) { + const result = factory.createETSModule( + newStatements, + newIdent, + node.getNamespaceFlag(), + node.program, + ) + result.onUpdate(node) + return result + } + node.setStatements(newStatements) + } + return node +} + +function visitCallExpression(node: CallExpression, visitor: Visitor) { + global.updateTracker.push() + const newCallee = nodeVisitor(node.callee, visitor) + const oldArguments = node.arguments + const newArguments: readonly Expression[] = nodesVisitor(oldArguments, visitor) + const newTypeParams = nodeVisitor(node.typeParams, visitor) + const newTrailingBlock = nodeVisitor(node.trailingBlock, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newArguments, oldArguments)) { + const result = factory.createCallExpression( + newCallee, + newArguments, + newTypeParams, + node.isOptional, + node.hasTrailingComma, + newTrailingBlock, + ) + result.onUpdate(node) + return result + } + node.setCallee(newCallee) + node.setTypeParams(newTypeParams) + node.setTrailingBlock(newTrailingBlock) + } + return node +} + +function visitIdentifier(node: Identifier, visitor: Visitor) { + global.updateTracker.push() + const newTypeAnnotation = nodeVisitor(node.typeAnnotation, visitor) + if (global.updateTracker.check()) { + const result = factory.createIdentifier(node.name, newTypeAnnotation) + result.onUpdate(node) + return result + } + return node +} + +function visitMemberExpression(node: MemberExpression, visitor: Visitor) { + global.updateTracker.push() + const newObject = nodeVisitor(node.object, visitor) + const newProperty = nodeVisitor(node.property, visitor) + if (global.updateTracker.check()) { + node.setObject(newObject) + node.setProperty(newProperty) + } + return node +} + +function visitETSTypeReference(node: ETSTypeReference, visitor: Visitor) { + global.updateTracker.push() + const newPart = nodeVisitor(node.part, visitor) + if (global.updateTracker.check()) { + const result = factory.createETSTypeReference( + newPart, + ) + result.onUpdate(node) + return result + } + return node +} + +function visitETSTypeReferencePart(node: ETSTypeReferencePart, visitor: Visitor) { + global.updateTracker.push() + const newName = nodeVisitor(node.name, visitor) + const newTypeParams = nodeVisitor(node.typeParams, visitor) + const newPrev = nodeVisitor(node.previous, visitor) + if (global.updateTracker.check()) { + const result = factory.createETSTypeReferencePart( + newName, + newTypeParams, + newPrev, + ) + result.onUpdate(node) + return result + } + return node +} + +function visitScriptFunction(node: ScriptFunction, visitor: Visitor) { + global.updateTracker.push() + const newBody = nodeVisitor(node.body, visitor) + const oldTypeParams = node.typeParams + const newTypeParams = nodeVisitor(oldTypeParams, visitor) + const newParams: readonly Expression[] = nodesVisitor(node.params, visitor) + const newReturnTypeAnnotation = nodeVisitor(node.returnTypeAnnotation, visitor) + const newId = nodeVisitor(node.id, visitor) + const newAnnotations: readonly AnnotationUsage[] = nodesVisitor(node.annotations, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newTypeParams, oldTypeParams)) { + const result = factory.createScriptFunction( + newBody, + newTypeParams, + newParams, + newReturnTypeAnnotation, + node.hasReceiver, + node.flags, + node.modifierFlags, + newId, + newAnnotations, + node.getSignaturePointer(), + node.getPreferredReturnTypePointer(), + ) + result.onUpdate(node) + return result + } + node.setBody(newBody) + node.setParams(newParams) + node.setReturnTypeAnnotation(newReturnTypeAnnotation) + if (newId) node.setIdent(newId) + node.setAnnotations(newAnnotations) + } + return node +} + +function visitMethodDefinition(node: MethodDefinition, visitor: Visitor) { + global.updateTracker.push() + const oldId = node.id + const newId = nodeVisitor(oldId, visitor) + const oldValue = node.value + const newValue = nodeVisitor(oldValue, visitor) + const newOverloads: readonly MethodDefinition[] = nodesVisitor(node.overloads, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newValue, node.value) || !isSameNativeObject(newId, oldId)) { + const result = factory.createMethodDefinition( + node.kind, + newId, + newValue, + node.modifierFlags, + node.isComputed, + newOverloads, + ) + result.onUpdate(node) + return result + } + node.setOverloads(newOverloads) + newOverloads.forEach(it => { + it.setBaseOverloadMethod(node) + it.parent = node + }) + } + return node +} + +function visitArrowFunctionExpression(node: ArrowFunctionExpression, visitor: Visitor) { + global.updateTracker.push() + const oldFunction = node.function + const newFunction = nodeVisitor(oldFunction, visitor) + const newAnnotations: readonly AnnotationUsage[] = nodesVisitor(node.annotations, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newFunction, oldFunction)) { + const result = factory.createArrowFunctionExpression( + newFunction, + newAnnotations, + ) + result.onUpdate(node) + return result + } + node.setAnnotations(newAnnotations) + } + return node +} + +function visitFunctionDeclaration(node: FunctionDeclaration, visitor: Visitor) { + global.updateTracker.push() + const oldFunction = node.function + const newFunction = nodeVisitor(oldFunction, visitor) + const newAnnotations: readonly AnnotationUsage[] = nodesVisitor(node.annotations, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newFunction, oldFunction)) { + const result = factory.createFunctionDeclaration( + newFunction, + newAnnotations, + node.isAnonymous, + ) + result.onUpdate(node) + return result + } + node.setAnnotations(newAnnotations) + } + return node +} + +function visitBlockExpression(node: BlockExpression, visitor: Visitor) { + global.updateTracker.push() + const newStatements: readonly Statement[] = nodesVisitor(node.statements, visitor) + if (global.updateTracker.check()) { + const result = factory.createBlockExpression( + newStatements, + ) + result.onUpdate(node) + return result + } + return node +} + +function visitChainExpression(node: ChainExpression, visitor: Visitor) { + global.updateTracker.push() + const newExpression = nodeVisitor(node.expression, visitor) + if (global.updateTracker.check()) { + const result = factory.createChainExpression( + newExpression, + ) + result.onUpdate(node) + return result + } + return node +} + +function visitExpressionStatement(node: ExpressionStatement, visitor: Visitor) { + global.updateTracker.push() + const newExpression = nodeVisitor(node.expression, visitor) + if (global.updateTracker.check()) { + node.setExpression(newExpression) + } + return node +} + +function visitETSStructDeclaration(node: ETSStructDeclaration, visitor: Visitor) { + global.updateTracker.push() + const newDefinition = nodeVisitor(node.definition, visitor) + if (global.updateTracker.check()) { + node.setDefinition(newDefinition) + } + return node +} + +function visitClassDeclaration(node: ClassDeclaration, visitor: Visitor) { + global.updateTracker.push() + const newDefinition = nodeVisitor(node.definition, visitor) + if (global.updateTracker.check()) { + node.setDefinition(newDefinition) + } + return node +} + +function visitTSInterfaceBody(node: TSInterfaceBody, visitor: Visitor) { + global.updateTracker.push() + const newBody = nodesVisitor(node.body, visitor) + if (global.updateTracker.check()) { + const result = factory.createTSInterfaceBody( + newBody, + ) + result.onUpdate(node) + return result + } + return node +} + +function visitClassDefinition(node: ClassDefinition, visitor: Visitor) { + global.updateTracker.push() + const newIdent = nodeVisitor(node.ident, visitor) + const newTypeParams = nodeVisitor(node.typeParams, visitor) + const oldSuperTypeParams = node.superTypeParams + const newSuperTypeParams = nodeVisitor(oldSuperTypeParams, visitor) + const oldImplements = node.implements + const newImplements: readonly TSClassImplements[] = nodesVisitor(oldImplements, visitor) + const newSuper = nodeVisitor(node.super, visitor) + const newBody = nodesVisitor(node.body, visitor) + const newAnnotations: readonly AnnotationUsage[] = nodesVisitor(node.annotations, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(oldSuperTypeParams, newSuperTypeParams) || !isSameNativeObject(newImplements, oldImplements)) { + const result = factory.createClassDefinition( + newIdent, + newTypeParams, + newSuperTypeParams, + newImplements, + undefined, /* can not pass node.ctor here because of mismatching types */ + newSuper, + newBody, + node.modifiers, + node.modifierFlags, + newAnnotations, + ) + result.onUpdate(node) + return result + } + node.setIdent(newIdent) + node.setTypeParams(newTypeParams) + node.setSuper(newSuper) + node.setBody(newBody) + node.setAnnotations(newAnnotations) + } + return node +} + +function visitETSParameterExpression(node: ETSParameterExpression, visitor: Visitor) { + if (node.isRestParameter) { + /** there is no RestParameter node at .idl */ + return node + } + global.updateTracker.push() + const newIdent = nodeVisitor(node.ident, visitor) + const newInit = nodeVisitor(node.initializer, visitor) + const newAnnotations: readonly AnnotationUsage[] = nodesVisitor(node.annotations, visitor) + if (global.updateTracker.check()) { + node.setIdent(newIdent) + node.setInitializer(newInit) + node.setAnnotations(newAnnotations) + } + return node +} + +function visitSwitchStatement(node: SwitchStatement, visitor: Visitor) { + global.updateTracker.push() + const newDiscriminant = nodeVisitor(node.discriminant, visitor) + const oldCases = node.cases + const newCases: readonly SwitchCaseStatement[] = nodesVisitor(oldCases, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newCases, oldCases)) { + const result = factory.createSwitchStatement( + newDiscriminant, + newCases, + ) + result.onUpdate(node) + return result + } + node.setDiscriminant(newDiscriminant) + } + return node +} + +function visitSwitchCaseStatement(node: SwitchCaseStatement, visitor: Visitor) { + global.updateTracker.push() + const newTest = nodeVisitor(node.test, visitor) + const oldConsequent = node.consequent + const newConsequent: readonly Statement[] = nodesVisitor(oldConsequent, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newConsequent, oldConsequent)) { + const result = factory.createSwitchCaseStatement( + newTest, + newConsequent, + ) + result.onUpdate(node) + return result + } + node.setTest(newTest) + } + return node +} + +function visitTSInterfaceDeclaration(node: TSInterfaceDeclaration, visitor: Visitor) { + global.updateTracker.push() + const newExtends: readonly TSInterfaceHeritage[] = nodesVisitor(node.extends, visitor) + const newIdent = nodeVisitor(node.id, visitor) + const newTypeParams = nodeVisitor(node.typeParams, visitor) + const newBody = nodeVisitor(node.body, visitor) + if (global.updateTracker.check()) { + const result = factory.createInterfaceDeclaration( + newExtends, + newIdent, + newTypeParams, + newBody, + node.isStatic, + node.isFromExternal, + node.modifierFlags, + ) + result.onUpdate(node) + return result + } + return node +} + +function visitIfStatement(node: IfStatement, visitor: Visitor) { + global.updateTracker.push() + const newTest = nodeVisitor(node.test, visitor) + const oldConsequent = node.consequent + const newConsequent = nodeVisitor(oldConsequent, visitor) + const newAlternate = nodeVisitor(node.alternate, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newConsequent, oldConsequent)) { + const result = factory.createIfStatement( + newTest, + newConsequent, + newAlternate, + ) + result.onUpdate(node) + return result + } + node.setTest(newTest) + if (newTest) newTest.parent = node + node.setAlternate(newAlternate) + } + return node +} + +function visitConditionalExpression(node: ConditionalExpression, visitor: Visitor) { + global.updateTracker.push() + const newTest = nodeVisitor(node.test, visitor) + const newConsequent = nodeVisitor(node.consequent, visitor) + const newAlternate = nodeVisitor(node.alternate, visitor) + if (global.updateTracker.check()) { + node.setTest(newTest) + node.setConsequent(newConsequent) + node.setAlternate(newAlternate) + } + return node +} + +function visitVariableDeclararion(node: VariableDeclaration, visitor: Visitor) { + global.updateTracker.push() + const oldDeclarators = node.declarators + const newDeclarators: readonly VariableDeclarator[] = nodesVisitor(oldDeclarators, visitor) + const newAnnotations: readonly AnnotationUsage[] = nodesVisitor(node.annotations, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newDeclarators, oldDeclarators)) { + const result = factory.createVariableDeclaration( + node.kind, + newDeclarators, + newAnnotations, + ) + result.onUpdate(node) + return result + } + node.setAnnotations(newAnnotations) + } + return node +} + +function visitVariableDeclarator(node: VariableDeclarator, visitor: Visitor) { + global.updateTracker.push() + const oldId = node.id + const newId = nodeVisitor(oldId, visitor) + const newInit = nodeVisitor(node.init, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newId, oldId)) { + const result = factory.createVariableDeclarator( + node.flag, + newId, + newInit, + ) + result.onUpdate(node) + return result + } + node.setInit(newInit) + } + return node +} + +function visitReturnStatement(node: ReturnStatement, visitor: Visitor) { + global.updateTracker.push() + const newArgument = nodeVisitor(node.argument, visitor) + if (global.updateTracker.check()) { + node.setArgument(newArgument) + } + return node +} + +function visitTSAsExpression(node: TSAsExpression, visitor: Visitor) { + global.updateTracker.push() + const newExpr = nodeVisitor(node.expr, visitor) + const oldTypeAnnotation = node.typeAnnotation + const newTypeAnnotation = nodeVisitor(oldTypeAnnotation, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newTypeAnnotation, oldTypeAnnotation)) { + const result = factory.createTSAsExpression( + newExpr, + newTypeAnnotation, + node.isConst, + ) + result.onUpdate(node) + return result + } + node.setExpr(newExpr) + } + return node +} + +function visitTemplateLiteral(node: TemplateLiteral, visitor: Visitor) { + global.updateTracker.push() + const newQuasis: readonly TemplateElement[] = nodesVisitor(node.quasis, visitor) + const newExpression: readonly Expression[] = nodesVisitor(node.expressions, visitor) + if (global.updateTracker.check()) { + const result = factory.createTemplateLiteral( + newQuasis, + newExpression, + node.multilineString, + ) + result.onUpdate(node) + return result + } + return node +} + +function visitTSTypeAliasDeclaration(node: TSTypeAliasDeclaration, visitor: Visitor) { + global.updateTracker.push() + const oldId = node.id + const newId = nodeVisitor(oldId, visitor) + const newTypeParams = nodeVisitor(node.typeParams, visitor) + const oldTypeAnnotation = node.typeAnnotation + const newTypeAnnotation = nodeVisitor(oldTypeAnnotation, visitor) + const newAnnotations: readonly AnnotationUsage[] = nodesVisitor(node.annotations, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newId, oldId) || !isSameNativeObject(newTypeAnnotation, oldTypeAnnotation)) { + const result = factory.createTSTypeAliasDeclaration( + newId, + newTypeParams, + newTypeAnnotation, + newAnnotations, + ) + result.onUpdate(node) + return result + } + node.setAnnotations(newAnnotations) + node.setTypeParameters(newTypeParams) + } + return node +} + +function visitTryStatement(node: TryStatement, visitor: Visitor) { + global.updateTracker.push() + const newBlock = nodeVisitor(node.block, visitor) + const newCatchClauses: readonly CatchClause[] = nodesVisitor(node.catchClauses, visitor) + const newFinallyBlock = nodeVisitor(node.finallyBlock, visitor) + if (global.updateTracker.check()) { + const result = factory.createTryStatement( + newBlock, + newCatchClauses, + newFinallyBlock, + [], + [], + ) + result.onUpdate(node) + return result + } + return node +} + +function visitObjectExpression(node: ObjectExpression, visitor: Visitor) { + global.updateTracker.push() + const newProperties: readonly Expression[] = nodesVisitor(node.properties, visitor) + if (global.updateTracker.check()) { + const result = factory.createObjectExpression( + newProperties, + node.getPreferredTypePointer(), + ) + result.onUpdate(node) + return result + } + return node +} + +function visitFunctionExpression(node: FunctionExpression, visitor: Visitor) { + global.updateTracker.push() + const newId = nodeVisitor(node.id, visitor) + const newFunction = nodeVisitor(node.function, visitor) + if (global.updateTracker.check()) { + const result = factory.createFunctionExpression( + newId, + newFunction, + ) + result.onUpdate(node) + return result + } + return node +} + +function visitArrayExpression(node: ArrayExpression, visitor: Visitor) { + global.updateTracker.push() + const newElements: readonly Expression[] = nodesVisitor(node.elements, visitor) + if (global.updateTracker.check()) { + node.setElements(newElements) + } + return node +} + +function visitAssignmentExpression(node: AssignmentExpression, visitor: Visitor) { + global.updateTracker.push() + const newLeft = nodeVisitor(node.left, visitor) + const newRight = nodeVisitor(node.right, visitor) + if (global.updateTracker.check()) { + node.setLeft(newLeft) + node.setRight(newRight) + } + return node +} + +function visitETSTyple(node: ETSTuple, visitor: Visitor) { + global.updateTracker.push() + const newTypeAnnotationList: readonly TypeNode[] = nodesVisitor(node.tupleTypeAnnotationsList, visitor) + if (global.updateTracker.check()) { + node.setTypeAnnotationsList(newTypeAnnotationList) + } + return node +} + +function visitETSUnionType(node: ETSUnionType, visitor: Visitor) { + global.updateTracker.push() + const oldTypes = node.types + const newTypes: readonly TypeNode[] = nodesVisitor(oldTypes, visitor) + const newAnnotations: readonly AnnotationUsage[] = nodesVisitor(node.annotations, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newTypes, oldTypes)) { + const result = factory.createETSUnionType( + newTypes, + newAnnotations, + ) + result.onUpdate(node) + return result + } + node.setAnnotations(newAnnotations) + } + return node +} + +function visitETSFunctionType(node: ETSFunctionType, visitor: Visitor) { + global.updateTracker.push() + const oldTypeParams = node.typeParams + const newTypeParams = nodeVisitor(oldTypeParams, visitor) + const oldParams = node.params + const newParams: readonly Expression[] = nodesVisitor(oldParams, visitor) + const oldReturnTypeAnnotation = node.returnType + const newReturnTypeAnnotation = nodeVisitor(oldReturnTypeAnnotation, visitor) + const newAnnotations: readonly AnnotationUsage[] = nodesVisitor(node.annotations, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newTypeParams, oldTypeParams) + || !isSameNativeObject(newParams, oldParams) + || !isSameNativeObject(newReturnTypeAnnotation, oldReturnTypeAnnotation) + ) { + const result = factory.createETSFunctionType( + newTypeParams, + newParams, + newReturnTypeAnnotation, + node.isExtensionFunction, + node.flags, + newAnnotations, + ) + result.onUpdate(node) + return result + } + node.setAnnotations(newAnnotations) + } + return node +} + +function visitClassProperty(node: ClassProperty, visitor: Visitor) { + global.updateTracker.push() + const oldKey = node.key + const newKey = nodeVisitor(oldKey, visitor) + const newValue = nodeVisitor(node.value, visitor) + const newTypeAnnotation = nodeVisitor(node.typeAnnotation, visitor) + const newAnnotations: readonly AnnotationUsage[] = nodesVisitor(node.annotations, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newKey, oldKey)) { + const result = factory.createClassProperty( + newKey, + newValue, + newTypeAnnotation, + node.modifierFlags, + node.isComputed, + newAnnotations, + ) + result.onUpdate(node) + return result + } + node.setValue(newValue) + node.setTypeAnnotation(newTypeAnnotation) + node.setAnnotations(newAnnotations) + } + return node +} + +function visitProperty(node: Property, visitor: Visitor) { + global.updateTracker.push() + const newKey = nodeVisitor(node.key, visitor) + const newValue = nodeVisitor(node.value, visitor) + if (global.updateTracker.check()) { + const result = factory.createProperty( + node.kind, + newKey, + newValue, + node.isMethod, + node.isComputed, + ) + result.onUpdate(node) + return result + } + return node +} + +function visitBinaryExpression(node: BinaryExpression, visitor: Visitor) { + global.updateTracker.push() + const newLeft = nodeVisitor(node.left, visitor) + const newRight = nodeVisitor(node.right, visitor) + if (global.updateTracker.check()) { + node.setLeft(newLeft) + node.setRight(newRight) + } + return node +} + +function visitETSNewClassInstanceExpression(node: ETSNewClassInstanceExpression, visitor: Visitor) { + global.updateTracker.push() + const oldTypeRef = node.typeRef + const newTypeRef = nodeVisitor(oldTypeRef, visitor) + const newArguments: readonly Expression[] = nodesVisitor(node.arguments, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newTypeRef, oldTypeRef)) { + const result = factory.createETSNewClassInstanceExpression( + newTypeRef, + newArguments, + ) + result.onUpdate(node) + return result + } + node.setArguments(newArguments) + newArguments.forEach(it => it.parent = node) + } + return node +} + +function visitWhileStatement(node: WhileStatement, visitor: Visitor) { + global.updateTracker.push() + const newTest = nodeVisitor(node.test, visitor) + const oldBody = node.body + const newBody = nodeVisitor(node.body, visitor) + if (global.updateTracker.check()) { + if (!isSameNativeObject(newBody, oldBody)) { + const result = factory.createWhileStatement( + newTest, + newBody, + ) + result.onUpdate(node) + return result + } + node.setTest(newTest) + } + return node +} + +function visitDoWhileStatement(node: DoWhileStatement, visitor: Visitor) { + global.updateTracker.push() + const newBody = nodeVisitor(node.body, visitor) + const newTest = nodeVisitor(node.test, visitor) + if (global.updateTracker.check()) { + const result = factory.createDoWhileStatement( + newBody, + newTest, + ) + result.onUpdate(node) + return result + } + return node +} + +function visitForUpdateStatement(node: ForUpdateStatement, visitor: Visitor) { + global.updateTracker.push() + const newInit = nodeVisitor(node.init, visitor) + const newTest = nodeVisitor(node.test, visitor) + const newUpdate = nodeVisitor(node.update, visitor) + const newBody = nodeVisitor(node.body, visitor) + if (global.updateTracker.check()) { + const result = factory.createForUpdateStatement( + newInit, + newTest, + newUpdate, + newBody, + ) + result.onUpdate(node) + return result + } + return node +} + +function visitForInStatement(node: ForInStatement, visitor: Visitor) { + global.updateTracker.push() + const newLeft = nodeVisitor(node.left, visitor) + const newRight = nodeVisitor(node.right, visitor) + const newBody = nodeVisitor(node.body, visitor) + if (global.updateTracker.check()) { + const result = factory.createForInStatement( + newLeft, + newRight, + newBody, + ) + result.onUpdate(node) + return result + } + return node +} + +function visitForOfStatement(node: ForOfStatement, visitor: Visitor) { + global.updateTracker.push() + const newLeft = nodeVisitor(node.left, visitor) + const newRight = nodeVisitor(node.right, visitor) + const newBody = nodeVisitor(node.body, visitor) + if (global.updateTracker.check()) { + const result = factory.createForOfStatement( + newLeft, + newRight, + newBody, + node.isAwait, + ) + result.onUpdate(node) + return result + } + return node +} + +function visitETSImportDeclaration(node: ETSImportDeclaration, visitor: Visitor) { + global.updateTracker.push() + const newSource = nodeVisitor(node.source, visitor) + const newSpecifiers = nodesVisitor(node.specifiers, visitor) + if (global.updateTracker.check()) { + const result = factory.createETSImportDeclaration( + newSource, + newSpecifiers, + Es2pandaImportKinds.IMPORT_KINDS_ALL, + ) + result.onUpdate(node) + return result + } + return node +} + +function visitTSNonNullExpression(node: TSNonNullExpression, visitor: Visitor) { + global.updateTracker.push() + const newExpr = nodeVisitor(node.expr, visitor) + if (global.updateTracker.check()) { + node.setExpr(newExpr) + if (newExpr) newExpr.parent = node + } + return node +} + +function visitUpdateExpression(node: UpdateExpression, visitor: Visitor) { + global.updateTracker.push() + const newArgument = nodeVisitor(node.argument, visitor) + if (global.updateTracker.check()) { + const result = factory.createUpdateExpression( + newArgument, + node.operatorType, + node.isPrefix, + ) + result.onUpdate(node) + return result + } + return node +} + +function visitTSTypeParameterInstantiation(node: TSTypeParameterInstantiation, visitor: Visitor) { + global.updateTracker.push() + const newParams: readonly TypeNode[] = nodesVisitor(node.params, visitor) + if (global.updateTracker.check()) { + const result = factory.createTSTypeParameterInstantiation( + newParams, + ) + result.onUpdate(node) + return result + } + return node +} + +function visitTSTypeParameterDeclaration(node: TSTypeParameterDeclaration, visitor: Visitor) { + global.updateTracker.push() + const newParams: readonly TSTypeParameter[] = nodesVisitor(node.params, visitor) + if (global.updateTracker.check()) { + const result = factory.createTSTypeParameterDeclaration( + newParams, + node.requiredParams, + ) + result.onUpdate(node) + return result + } + return node +} + +function visitClassStaticBlock(node: ClassStaticBlock, visitor: Visitor) { + global.updateTracker.push() + const newId = nodeVisitor(node.id, visitor) + const newFunction = nodeVisitor(node.function, visitor) + if (global.updateTracker.check()) { + const result = ClassStaticBlock.createClassStaticBlock( + factory.createFunctionExpression( + newId, + newFunction, + ) + ) + result.onUpdate(node) + return result + } + return node +} + +const visitsTable: (((node: any, visitor: Visitor) => any) | undefined)[] = [] + +export function initVisitsTable() { + const length = Object.values(Es2pandaAstNodeType).length / 2 + visitsTable.push(...new Array(length)) + + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER] = visitIdentifier + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION] = visitMemberExpression + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE] = visitETSTypeReference + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART] = visitETSTypeReferencePart + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE] = visitETSModule + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION] = visitCallExpression + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION] = visitFunctionDeclaration + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT] = visitBlockStatement + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION] = visitBlockExpression + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION] = visitChainExpression + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT] = visitExpressionStatement + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION] = visitETSStructDeclaration + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION] = visitClassDeclaration + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION] = visitClassDefinition + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION] = visitMethodDefinition + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION] = visitScriptFunction + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION] = visitETSParameterExpression + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT] = visitSwitchStatement + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT] = visitSwitchCaseStatement + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION] = visitTSInterfaceDeclaration + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY] = visitTSInterfaceBody + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT] = visitIfStatement + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION] = visitConditionalExpression + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION] = visitVariableDeclararion + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR] = visitVariableDeclarator + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION] = visitArrowFunctionExpression + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT] = visitReturnStatement + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION] = visitTSAsExpression + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL] = visitTemplateLiteral + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION] = visitTSTypeAliasDeclaration + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT] = visitTryStatement + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION] = visitObjectExpression + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION] = visitFunctionExpression + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION] = visitArrayExpression + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION] = visitAssignmentExpression + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE] = visitETSTyple + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE] = visitETSUnionType + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE] = visitETSFunctionType + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY] = visitClassProperty + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY] = visitProperty + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION] = visitBinaryExpression + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION] = visitETSNewClassInstanceExpression + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_WHILE_STATEMENT] = visitWhileStatement + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT] = visitDoWhileStatement + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT] = visitForUpdateStatement + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT] = visitForInStatement + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT] = visitForOfStatement + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION] = visitETSImportDeclaration + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_TS_NON_NULL_EXPRESSION] = visitTSNonNullExpression + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_UPDATE_EXPRESSION] = visitUpdateExpression + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION] = visitTSTypeParameterDeclaration + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION] = visitTSTypeParameterInstantiation + visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK] = visitClassStaticBlock +} + +export function visitEachChild( + node: AstNode, + visitor: Visitor +): AstNode { + global.profiler.nodeVisited() + const visit = visitsTable[node.astNodeType] + if (visit) { + return visit(node, visitor) + } + return node +} diff --git a/ets1.2/libarkts/src/arkts-api/wrapper-compat.ts b/ets1.2/libarkts/src/arkts-api/wrapper-compat.ts new file mode 100644 index 0000000000000000000000000000000000000000..15226e716af76a79737df6a4111917edc972fe45 --- /dev/null +++ b/ets1.2/libarkts/src/arkts-api/wrapper-compat.ts @@ -0,0 +1,32 @@ +/* + * 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. + */ + +// koala-wrapper compatibility helpers + +import { KNativePointer } from "@koalaui/interop" +import { ETSModule } from "../generated" +import { createETSModuleFromContext } from "./utilities/public" +import { global } from "./static/global" + +export class EtsScript { + public static fromContext(): ETSModule { + return createETSModuleFromContext() + } +} + +export function destroyConfig(config: KNativePointer): void { + global.es2panda._DestroyConfig(config) + global.resetConfig() +} \ No newline at end of file diff --git a/ets1.2/libarkts/src/checkSdk.ts b/ets1.2/libarkts/src/checkSdk.ts new file mode 100644 index 0000000000000000000000000000000000000000..545398eb3b66ca4d4def1c4455c0d2c641e35d00 --- /dev/null +++ b/ets1.2/libarkts/src/checkSdk.ts @@ -0,0 +1,40 @@ +/* + * 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 fs from "fs" +import * as path from "path" + +function reportErrorAndExit(message: string): never { + console.error(message) + process.exit(1) +} + +export function checkSDK() { + const panda = process.env.PANDA_SDK_PATH + if (!panda) + reportErrorAndExit(`Variable PANDA_SDK_PATH is not set, please fix`) + if (!fs.existsSync(path.join(panda, 'package.json'))) + reportErrorAndExit(`Variable PANDA_SDK_PATH not points to SDK`) + const packageJson = JSON.parse(fs.readFileSync(path.join(panda, 'package.json')).toString()) + const version = packageJson.version as string + if (!version) + reportErrorAndExit(`version is unknown`) + const packageJsonOur = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json')).toString()) + const expectedVersion = packageJsonOur.config.panda_sdk_version + if (expectedVersion && expectedVersion != "next" && version != expectedVersion) + console.log(`WARNING: Panda SDK version "${version}" doesn't match expected "${expectedVersion}"`) + else + console.log(`Using Panda ${version}`) +} diff --git a/ets1.2/libarkts/src/generated/Es2pandaEnums.ts b/ets1.2/libarkts/src/generated/Es2pandaEnums.ts new file mode 100644 index 0000000000000000000000000000000000000000..421883a7e38b1ad846fac31e059b38755c0ccc84 --- /dev/null +++ b/ets1.2/libarkts/src/generated/Es2pandaEnums.ts @@ -0,0 +1,1350 @@ +/* + * 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + + +export enum Es2pandaContextState { + ES2PANDA_STATE_NEW = 0, + ES2PANDA_STATE_PARSED = 1, + ES2PANDA_STATE_BOUND = 2, + ES2PANDA_STATE_CHECKED = 3, + ES2PANDA_STATE_LOWERED = 4, + ES2PANDA_STATE_ASM_GENERATED = 5, + ES2PANDA_STATE_BIN_GENERATED = 6, + ES2PANDA_STATE_ERROR = 7 +} +export enum Es2pandaPluginDiagnosticType { + ES2PANDA_PLUGIN_WARNING = 0, + ES2PANDA_PLUGIN_ERROR = 1, + ES2PANDA_PLUGIN_SUGGESTION = 2 +} +export enum Es2pandaAstNodeType { + AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION = 0, + AST_NODE_TYPE_ANNOTATION_DECLARATION = 1, + AST_NODE_TYPE_ANNOTATION_USAGE = 2, + AST_NODE_TYPE_ASSERT_STATEMENT = 3, + AST_NODE_TYPE_AWAIT_EXPRESSION = 4, + AST_NODE_TYPE_BIGINT_LITERAL = 5, + AST_NODE_TYPE_BINARY_EXPRESSION = 6, + AST_NODE_TYPE_BLOCK_STATEMENT = 7, + AST_NODE_TYPE_BOOLEAN_LITERAL = 8, + AST_NODE_TYPE_BREAK_STATEMENT = 9, + AST_NODE_TYPE_CALL_EXPRESSION = 10, + AST_NODE_TYPE_CATCH_CLAUSE = 11, + AST_NODE_TYPE_CHAIN_EXPRESSION = 12, + AST_NODE_TYPE_CHAR_LITERAL = 13, + AST_NODE_TYPE_CLASS_DEFINITION = 14, + AST_NODE_TYPE_CLASS_DECLARATION = 15, + AST_NODE_TYPE_CLASS_EXPRESSION = 16, + AST_NODE_TYPE_CLASS_PROPERTY = 17, + AST_NODE_TYPE_CLASS_STATIC_BLOCK = 18, + AST_NODE_TYPE_CONDITIONAL_EXPRESSION = 19, + AST_NODE_TYPE_CONTINUE_STATEMENT = 20, + AST_NODE_TYPE_DEBUGGER_STATEMENT = 21, + AST_NODE_TYPE_DECORATOR = 22, + AST_NODE_TYPE_DIRECT_EVAL = 23, + AST_NODE_TYPE_DO_WHILE_STATEMENT = 24, + AST_NODE_TYPE_EMPTY_STATEMENT = 25, + AST_NODE_TYPE_EXPORT_ALL_DECLARATION = 26, + AST_NODE_TYPE_EXPORT_DEFAULT_DECLARATION = 27, + AST_NODE_TYPE_EXPORT_NAMED_DECLARATION = 28, + AST_NODE_TYPE_EXPORT_SPECIFIER = 29, + AST_NODE_TYPE_EXPRESSION_STATEMENT = 30, + AST_NODE_TYPE_FOR_IN_STATEMENT = 31, + AST_NODE_TYPE_FOR_OF_STATEMENT = 32, + AST_NODE_TYPE_FOR_UPDATE_STATEMENT = 33, + AST_NODE_TYPE_FUNCTION_DECLARATION = 34, + AST_NODE_TYPE_FUNCTION_EXPRESSION = 35, + AST_NODE_TYPE_IDENTIFIER = 36, + AST_NODE_TYPE_DUMMYNODE = 37, + AST_NODE_TYPE_IF_STATEMENT = 38, + AST_NODE_TYPE_IMPORT_DECLARATION = 39, + AST_NODE_TYPE_IMPORT_EXPRESSION = 40, + AST_NODE_TYPE_IMPORT_DEFAULT_SPECIFIER = 41, + AST_NODE_TYPE_IMPORT_NAMESPACE_SPECIFIER = 42, + AST_NODE_TYPE_IMPORT_SPECIFIER = 43, + AST_NODE_TYPE_LABELLED_STATEMENT = 44, + AST_NODE_TYPE_MEMBER_EXPRESSION = 45, + AST_NODE_TYPE_META_PROPERTY_EXPRESSION = 46, + AST_NODE_TYPE_METHOD_DEFINITION = 47, + AST_NODE_TYPE_NAMED_TYPE = 48, + AST_NODE_TYPE_NEW_EXPRESSION = 49, + AST_NODE_TYPE_NULL_LITERAL = 50, + AST_NODE_TYPE_UNDEFINED_LITERAL = 51, + AST_NODE_TYPE_NUMBER_LITERAL = 52, + AST_NODE_TYPE_OMITTED_EXPRESSION = 53, + AST_NODE_TYPE_OVERLOAD_DECLARATION = 54, + AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION = 55, + AST_NODE_TYPE_PROPERTY = 56, + AST_NODE_TYPE_REGEXP_LITERAL = 57, + AST_NODE_TYPE_REEXPORT_STATEMENT = 58, + AST_NODE_TYPE_RETURN_STATEMENT = 59, + AST_NODE_TYPE_SCRIPT_FUNCTION = 60, + AST_NODE_TYPE_SEQUENCE_EXPRESSION = 61, + AST_NODE_TYPE_STRING_LITERAL = 62, + AST_NODE_TYPE_ETS_NON_NULLISH_TYPE = 63, + AST_NODE_TYPE_ETS_NULL_TYPE = 64, + AST_NODE_TYPE_ETS_UNDEFINED_TYPE = 65, + AST_NODE_TYPE_ETS_NEVER_TYPE = 66, + AST_NODE_TYPE_ETS_STRING_LITERAL_TYPE = 67, + AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE = 68, + AST_NODE_TYPE_ETS_FUNCTION_TYPE = 69, + AST_NODE_TYPE_ETS_WILDCARD_TYPE = 70, + AST_NODE_TYPE_ETS_PRIMITIVE_TYPE = 71, + AST_NODE_TYPE_ETS_PACKAGE_DECLARATION = 72, + AST_NODE_TYPE_ETS_CLASS_LITERAL = 73, + AST_NODE_TYPE_ETS_TYPE_REFERENCE = 74, + AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART = 75, + AST_NODE_TYPE_ETS_UNION_TYPE = 76, + AST_NODE_TYPE_ETS_KEYOF_TYPE = 77, + AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION = 78, + AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION = 79, + AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION = 80, + AST_NODE_TYPE_ETS_IMPORT_DECLARATION = 81, + AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION = 82, + AST_NODE_TYPE_ETS_TUPLE = 83, + AST_NODE_TYPE_ETS_MODULE = 84, + AST_NODE_TYPE_SUPER_EXPRESSION = 85, + AST_NODE_TYPE_STRUCT_DECLARATION = 86, + AST_NODE_TYPE_SWITCH_CASE_STATEMENT = 87, + AST_NODE_TYPE_SWITCH_STATEMENT = 88, + AST_NODE_TYPE_TS_ENUM_DECLARATION = 89, + AST_NODE_TYPE_TS_ENUM_MEMBER = 90, + AST_NODE_TYPE_TS_EXTERNAL_MODULE_REFERENCE = 91, + AST_NODE_TYPE_TS_NUMBER_KEYWORD = 92, + AST_NODE_TYPE_TS_ANY_KEYWORD = 93, + AST_NODE_TYPE_TS_STRING_KEYWORD = 94, + AST_NODE_TYPE_TS_BOOLEAN_KEYWORD = 95, + AST_NODE_TYPE_TS_VOID_KEYWORD = 96, + AST_NODE_TYPE_TS_UNDEFINED_KEYWORD = 97, + AST_NODE_TYPE_TS_UNKNOWN_KEYWORD = 98, + AST_NODE_TYPE_TS_OBJECT_KEYWORD = 99, + AST_NODE_TYPE_TS_BIGINT_KEYWORD = 100, + AST_NODE_TYPE_TS_NEVER_KEYWORD = 101, + AST_NODE_TYPE_TS_NON_NULL_EXPRESSION = 102, + AST_NODE_TYPE_TS_NULL_KEYWORD = 103, + AST_NODE_TYPE_TS_ARRAY_TYPE = 104, + AST_NODE_TYPE_TS_UNION_TYPE = 105, + AST_NODE_TYPE_TS_TYPE_LITERAL = 106, + AST_NODE_TYPE_TS_PROPERTY_SIGNATURE = 107, + AST_NODE_TYPE_TS_METHOD_SIGNATURE = 108, + AST_NODE_TYPE_TS_SIGNATURE_DECLARATION = 109, + AST_NODE_TYPE_TS_PARENT_TYPE = 110, + AST_NODE_TYPE_TS_LITERAL_TYPE = 111, + AST_NODE_TYPE_TS_INFER_TYPE = 112, + AST_NODE_TYPE_TS_CONDITIONAL_TYPE = 113, + AST_NODE_TYPE_TS_IMPORT_TYPE = 114, + AST_NODE_TYPE_TS_INTERSECTION_TYPE = 115, + AST_NODE_TYPE_TS_MAPPED_TYPE = 116, + AST_NODE_TYPE_TS_MODULE_BLOCK = 117, + AST_NODE_TYPE_TS_THIS_TYPE = 118, + AST_NODE_TYPE_TS_TYPE_OPERATOR = 119, + AST_NODE_TYPE_TS_TYPE_PARAMETER = 120, + AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION = 121, + AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION = 122, + AST_NODE_TYPE_TS_TYPE_PREDICATE = 123, + AST_NODE_TYPE_TS_PARAMETER_PROPERTY = 124, + AST_NODE_TYPE_TS_MODULE_DECLARATION = 125, + AST_NODE_TYPE_TS_IMPORT_EQUALS_DECLARATION = 126, + AST_NODE_TYPE_TS_FUNCTION_TYPE = 127, + AST_NODE_TYPE_TS_CONSTRUCTOR_TYPE = 128, + AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION = 129, + AST_NODE_TYPE_TS_TYPE_REFERENCE = 130, + AST_NODE_TYPE_TS_QUALIFIED_NAME = 131, + AST_NODE_TYPE_TS_INDEXED_ACCESS_TYPE = 132, + AST_NODE_TYPE_TS_INTERFACE_DECLARATION = 133, + AST_NODE_TYPE_TS_INTERFACE_BODY = 134, + AST_NODE_TYPE_TS_INTERFACE_HERITAGE = 135, + AST_NODE_TYPE_TS_TUPLE_TYPE = 136, + AST_NODE_TYPE_TS_NAMED_TUPLE_MEMBER = 137, + AST_NODE_TYPE_TS_INDEX_SIGNATURE = 138, + AST_NODE_TYPE_TS_TYPE_QUERY = 139, + AST_NODE_TYPE_TS_AS_EXPRESSION = 140, + AST_NODE_TYPE_TS_CLASS_IMPLEMENTS = 141, + AST_NODE_TYPE_TS_TYPE_ASSERTION = 142, + AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION = 143, + AST_NODE_TYPE_TEMPLATE_ELEMENT = 144, + AST_NODE_TYPE_TEMPLATE_LITERAL = 145, + AST_NODE_TYPE_THIS_EXPRESSION = 146, + AST_NODE_TYPE_TYPEOF_EXPRESSION = 147, + AST_NODE_TYPE_THROW_STATEMENT = 148, + AST_NODE_TYPE_TRY_STATEMENT = 149, + AST_NODE_TYPE_UNARY_EXPRESSION = 150, + AST_NODE_TYPE_UPDATE_EXPRESSION = 151, + AST_NODE_TYPE_VARIABLE_DECLARATION = 152, + AST_NODE_TYPE_VARIABLE_DECLARATOR = 153, + AST_NODE_TYPE_WHILE_STATEMENT = 154, + AST_NODE_TYPE_YIELD_EXPRESSION = 155, + AST_NODE_TYPE_OPAQUE_TYPE_NODE = 156, + AST_NODE_TYPE_BLOCK_EXPRESSION = 157, + AST_NODE_TYPE_BROKEN_TYPE_NODE = 158, + AST_NODE_TYPE_ARRAY_EXPRESSION = 159, + AST_NODE_TYPE_ARRAY_PATTERN = 160, + AST_NODE_TYPE_ASSIGNMENT_EXPRESSION = 161, + AST_NODE_TYPE_ASSIGNMENT_PATTERN = 162, + AST_NODE_TYPE_OBJECT_EXPRESSION = 163, + AST_NODE_TYPE_OBJECT_PATTERN = 164, + AST_NODE_TYPE_SPREAD_ELEMENT = 165, + AST_NODE_TYPE_REST_ELEMENT = 166 +} +export enum Es2pandaScopeType { + SCOPE_TYPE_PARAM = 0, + SCOPE_TYPE_CATCH_PARAM = 1, + SCOPE_TYPE_FUNCTION_PARAM = 2, + SCOPE_TYPE_CATCH = 3, + SCOPE_TYPE_CLASS = 4, + SCOPE_TYPE_ANNOTATION = 5, + SCOPE_TYPE_ANNOTATIONPARAMSCOPE = 6, + SCOPE_TYPE_LOCAL = 7, + SCOPE_TYPE_LOOP = 8, + SCOPE_TYPE_LOOP_DECL = 9, + SCOPE_TYPE_FUNCTION = 10, + SCOPE_TYPE_GLOBAL = 11, + SCOPE_TYPE_MODULE = 12 +} +export enum Es2pandaDeclType { + DECL_TYPE_NONE = 0, + DECL_TYPE_VAR = 1, + DECL_TYPE_LET = 2, + DECL_TYPE_CONST = 3, + DECL_TYPE_LABEL = 4, + DECL_TYPE_READONLY = 5, + DECL_TYPE_FUNC = 6, + DECL_TYPE_PARAM = 7, + DECL_TYPE_IMPORT = 8, + DECL_TYPE_DYNAMIC_IMPORT = 9, + DECL_TYPE_EXPORT = 10, + DECL_TYPE_ANNOTATIONDECL = 11, + DECL_TYPE_ANNOTATIONUSAGE = 12, + DECL_TYPE_TYPE_ALIAS = 13, + DECL_TYPE_NAMESPACE = 14, + DECL_TYPE_INTERFACE = 15, + DECL_TYPE_ENUM_LITERAL = 16, + DECL_TYPE_TYPE_PARAMETER = 17, + DECL_TYPE_PROPERTY = 18, + DECL_TYPE_CLASS = 19, + DECL_TYPE_METHOD = 20, + DECL_TYPE_ENUM = 21 +} +export enum Es2pandaResolveBindingOptions { + RESOLVE_BINDING_OPTIONS_BINDINGS = 0, + RESOLVE_BINDING_OPTIONS_INTERFACES = 1, + RESOLVE_BINDING_OPTIONS_VARIABLES = 2, + RESOLVE_BINDING_OPTIONS_METHODS = 4, + RESOLVE_BINDING_OPTIONS_DECLARATION = 8, + RESOLVE_BINDING_OPTIONS_STATIC_VARIABLES = 16, + RESOLVE_BINDING_OPTIONS_STATIC_METHODS = 32, + RESOLVE_BINDING_OPTIONS_STATIC_DECLARATION = 64, + RESOLVE_BINDING_OPTIONS_TYPE_ALIASES = 128, + RESOLVE_BINDING_OPTIONS_ALL = 256, + RESOLVE_BINDING_OPTIONS_ALL_VARIABLES = 18, + RESOLVE_BINDING_OPTIONS_ALL_METHOD = 36, + RESOLVE_BINDING_OPTIONS_ALL_DECLARATION = 72, + RESOLVE_BINDING_OPTIONS_ALL_STATIC = 112, + RESOLVE_BINDING_OPTIONS_ALL_NON_STATIC = 14, + RESOLVE_BINDING_OPTIONS_LAST = 128 +} +export enum Es2pandaVariableKind { + VARIABLE_KIND_NONE = 0, + VARIABLE_KIND_VAR = 1, + VARIABLE_KIND_LEXICAL = 2, + VARIABLE_KIND_FUNCTION = 3, + VARIABLE_KIND_MODULE = 4 +} +export enum Es2pandaLetOrConstStatus { + LET_OR_CONST_STATUS_INITIALIZED = 0, + LET_OR_CONST_STATUS_UNINITIALIZED = 1 +} +export enum Es2pandaScopeFlags { + SCOPE_FLAGS_NONE = 0, + SCOPE_FLAGS_SET_LEXICAL_FUNCTION = 1, + SCOPE_FLAGS_USE_ARGS = 2, + SCOPE_FLAGS_USE_SUPER = 4, + SCOPE_FLAGS_INNER_ARROW = 8, + SCOPE_FLAGS_NO_REG_STORE = 16, + SCOPE_FLAGS_DECL_SCOPE = 32, + SCOPE_FLAGS_FIELD_SCOPE = 64, + SCOPE_FLAGS_METHOD_SCOPE = 128, + SCOPE_FLAGS_STATIC = 256, + SCOPE_FLAGS_TYPE_ALIAS = 512, + SCOPE_FLAGS_LOOP_SCOPE = 1024, + SCOPE_FLAGS_STATIC_DECL_SCOPE = 288, + SCOPE_FLAGS_STATIC_FIELD_SCOPE = 320, + SCOPE_FLAGS_STATIC_METHOD_SCOPE = 384 +} +export enum Es2pandaEnum { + ENUM_NODE_HAS_PARENT = 0, + ENUM_NODE_HAS_SOURCE_RANGE = 1, + ENUM_EVERY_CHILD_HAS_VALID_PARENT = 2, + ENUM_EVERY_CHILD_IN_PARENT_RANGE = 3, + ENUM_CHECK_STRUCT_DECLARATION = 4, + ENUM_VARIABLE_HAS_SCOPE = 5, + ENUM_NODE_HAS_TYPE = 6, + ENUM_NO_PRIMITIVE_TYPES = 7, + ENUM_IDENTIFIER_HAS_VARIABLE = 8, + ENUM_REFERENCE_TYPE_ANNOTATION_IS_NULL = 9, + ENUM_ARITHMETIC_OPERATION_VALID = 10, + ENUM_SEQUENCE_EXPRESSION_HAS_LAST_TYPE = 11, + ENUM_FOR_LOOP_CORRECTLY_INITIALIZED = 12, + ENUM_VARIABLE_HAS_ENCLOSING_SCOPE = 13, + ENUM_MODIFIER_ACCESS_VALID = 14, + ENUM_VARIABLE_NAME_IDENTIFIER_NAME_SAME = 15, + ENUM_CHECK_ABSTRACT_METHOD = 16, + ENUM_GETTER_SETTER_VALIDATION = 17, + ENUM_CHECK_SCOPE_DECLARATION = 18, + ENUM_CHECK_CONST_PROPERTIES = 19, + ENUM_COUNT = 20, + ENUM_BASE_FIRST = 0, + ENUM_BASE_LAST = 3, + ENUM_AFTER_PLUGINS_AFTER_PARSE_FIRST = 4, + ENUM_AFTER_PLUGINS_AFTER_PARSE_LAST = 4, + ENUM_AFTER_SCOPES_INIT_PHASE_FIRST = 5, + ENUM_AFTER_SCOPES_INIT_PHASE_LAST = 5, + ENUM_AFTER_CHECKER_PHASE_FIRST = 6, + ENUM_AFTER_CHECKER_PHASE_LAST = 19, + ENUM_FIRST = 0, + ENUM_LAST = 19, + ENUM_INVALID = 20 +} +export enum Es2pandaRegExpFlags { + REG_EXP_FLAGS_EMPTY = 0, + REG_EXP_FLAGS_GLOBAL = 1, + REG_EXP_FLAGS_IGNORE_CASE = 2, + REG_EXP_FLAGS_MULTILINE = 4, + REG_EXP_FLAGS_DOTALL = 8, + REG_EXP_FLAGS_UNICODE = 16, + REG_EXP_FLAGS_STICKY = 32 +} +export enum Es2pandaId { + ID_AS = 0, + ID_JS = 1, + ID_TS = 2, + ID_ETS = 3, + ID_COUNT = 4 +} +export enum Es2pandaTokenType { + TOKEN_TYPE_EOS = 0, + TOKEN_TYPE_LITERAL_IDENT = 1, + TOKEN_TYPE_LITERAL_STRING = 2, + TOKEN_TYPE_LITERAL_CHAR = 3, + TOKEN_TYPE_LITERAL_NUMBER = 4, + TOKEN_TYPE_LITERAL_REGEXP = 5, + TOKEN_TYPE_PUNCTUATOR_BITWISE_AND = 6, + TOKEN_TYPE_PUNCTUATOR_BITWISE_OR = 7, + TOKEN_TYPE_PUNCTUATOR_MULTIPLY = 8, + TOKEN_TYPE_PUNCTUATOR_DIVIDE = 9, + TOKEN_TYPE_PUNCTUATOR_MINUS = 10, + TOKEN_TYPE_PUNCTUATOR_EXCLAMATION_MARK = 11, + TOKEN_TYPE_PUNCTUATOR_TILDE = 12, + TOKEN_TYPE_PUNCTUATOR_MINUS_MINUS = 13, + TOKEN_TYPE_PUNCTUATOR_LEFT_SHIFT = 14, + TOKEN_TYPE_PUNCTUATOR_RIGHT_SHIFT = 15, + TOKEN_TYPE_PUNCTUATOR_LESS_THAN_EQUAL = 16, + TOKEN_TYPE_PUNCTUATOR_GREATER_THAN_EQUAL = 17, + TOKEN_TYPE_PUNCTUATOR_MOD = 18, + TOKEN_TYPE_PUNCTUATOR_BITWISE_XOR = 19, + TOKEN_TYPE_PUNCTUATOR_EXPONENTIATION = 20, + TOKEN_TYPE_PUNCTUATOR_MULTIPLY_EQUAL = 21, + TOKEN_TYPE_PUNCTUATOR_EXPONENTIATION_EQUAL = 22, + TOKEN_TYPE_PUNCTUATOR_ARROW = 23, + TOKEN_TYPE_PUNCTUATOR_BACK_TICK = 24, + TOKEN_TYPE_PUNCTUATOR_HASH_MARK = 25, + TOKEN_TYPE_PUNCTUATOR_DIVIDE_EQUAL = 26, + TOKEN_TYPE_PUNCTUATOR_MOD_EQUAL = 27, + TOKEN_TYPE_PUNCTUATOR_MINUS_EQUAL = 28, + TOKEN_TYPE_PUNCTUATOR_LEFT_SHIFT_EQUAL = 29, + TOKEN_TYPE_PUNCTUATOR_RIGHT_SHIFT_EQUAL = 30, + TOKEN_TYPE_PUNCTUATOR_UNSIGNED_RIGHT_SHIFT = 31, + TOKEN_TYPE_PUNCTUATOR_UNSIGNED_RIGHT_SHIFT_EQUAL = 32, + TOKEN_TYPE_PUNCTUATOR_BITWISE_AND_EQUAL = 33, + TOKEN_TYPE_PUNCTUATOR_BITWISE_OR_EQUAL = 34, + TOKEN_TYPE_PUNCTUATOR_LOGICAL_AND_EQUAL = 35, + TOKEN_TYPE_PUNCTUATOR_NULLISH_COALESCING = 36, + TOKEN_TYPE_PUNCTUATOR_LOGICAL_OR_EQUAL = 37, + TOKEN_TYPE_PUNCTUATOR_LOGICAL_NULLISH_EQUAL = 38, + TOKEN_TYPE_PUNCTUATOR_BITWISE_XOR_EQUAL = 39, + TOKEN_TYPE_PUNCTUATOR_PLUS = 40, + TOKEN_TYPE_PUNCTUATOR_PLUS_PLUS = 41, + TOKEN_TYPE_PUNCTUATOR_PLUS_EQUAL = 42, + TOKEN_TYPE_PUNCTUATOR_LESS_THAN = 43, + TOKEN_TYPE_PUNCTUATOR_GREATER_THAN = 44, + TOKEN_TYPE_PUNCTUATOR_EQUAL = 45, + TOKEN_TYPE_PUNCTUATOR_NOT_EQUAL = 46, + TOKEN_TYPE_PUNCTUATOR_STRICT_EQUAL = 47, + TOKEN_TYPE_PUNCTUATOR_NOT_STRICT_EQUAL = 48, + TOKEN_TYPE_PUNCTUATOR_LOGICAL_AND = 49, + TOKEN_TYPE_PUNCTUATOR_LOGICAL_OR = 50, + TOKEN_TYPE_PUNCTUATOR_SUBSTITUTION = 51, + TOKEN_TYPE_PUNCTUATOR_QUESTION_MARK = 52, + TOKEN_TYPE_PUNCTUATOR_QUESTION_DOT = 53, + TOKEN_TYPE_PUNCTUATOR_AT = 54, + TOKEN_TYPE_PUNCTUATOR_FORMAT = 55, + TOKEN_TYPE_PUNCTUATOR_RIGHT_PARENTHESIS = 56, + TOKEN_TYPE_PUNCTUATOR_LEFT_PARENTHESIS = 57, + TOKEN_TYPE_PUNCTUATOR_RIGHT_SQUARE_BRACKET = 58, + TOKEN_TYPE_PUNCTUATOR_LEFT_SQUARE_BRACKET = 59, + TOKEN_TYPE_PUNCTUATOR_RIGHT_BRACE = 60, + TOKEN_TYPE_PUNCTUATOR_PERIOD = 61, + TOKEN_TYPE_PUNCTUATOR_PERIOD_PERIOD_PERIOD = 62, + TOKEN_TYPE_PUNCTUATOR_PERIOD_QUESTION = 63, + TOKEN_TYPE_PUNCTUATOR_LEFT_BRACE = 64, + TOKEN_TYPE_PUNCTUATOR_SEMI_COLON = 65, + TOKEN_TYPE_PUNCTUATOR_COLON = 66, + TOKEN_TYPE_PUNCTUATOR_COMMA = 67, + TOKEN_TYPE_KEYW_ABSTRACT = 68, + TOKEN_TYPE_KEYW_ANY = 69, + TOKEN_TYPE_KEYW_BUILTIN_ANY = 70, + TOKEN_TYPE_KEYW_ANYREF = 71, + TOKEN_TYPE_KEYW_ARGUMENTS = 72, + TOKEN_TYPE_KEYW_AS = 73, + TOKEN_TYPE_KEYW_ASSERTS = 74, + TOKEN_TYPE_KEYW_ASYNC = 75, + TOKEN_TYPE_KEYW_AWAIT = 76, + TOKEN_TYPE_KEYW_BIGINT = 77, + TOKEN_TYPE_KEYW_BUILTIN_BIGINT = 78, + TOKEN_TYPE_KEYW_BOOLEAN = 79, + TOKEN_TYPE_KEYW_BUILTIN_BOOLEAN = 80, + TOKEN_TYPE_KEYW_BREAK = 81, + TOKEN_TYPE_KEYW_BYTE = 82, + TOKEN_TYPE_KEYW_BUILTIN_BYTE = 83, + TOKEN_TYPE_KEYW_CASE = 84, + TOKEN_TYPE_KEYW_CATCH = 85, + TOKEN_TYPE_KEYW_CHAR = 86, + TOKEN_TYPE_KEYW_BUILTIN_CHAR = 87, + TOKEN_TYPE_KEYW_CLASS = 88, + TOKEN_TYPE_KEYW_CONST = 89, + TOKEN_TYPE_KEYW_CONSTRUCTOR = 90, + TOKEN_TYPE_KEYW_CONTINUE = 91, + TOKEN_TYPE_KEYW_DATAREF = 92, + TOKEN_TYPE_KEYW_DEBUGGER = 93, + TOKEN_TYPE_KEYW_DECLARE = 94, + TOKEN_TYPE_KEYW_DEFAULT = 95, + TOKEN_TYPE_KEYW_DELETE = 96, + TOKEN_TYPE_KEYW_DO = 97, + TOKEN_TYPE_KEYW_DOUBLE = 98, + TOKEN_TYPE_KEYW_BUILTIN_DOUBLE = 99, + TOKEN_TYPE_KEYW_ELSE = 100, + TOKEN_TYPE_KEYW_ENUM = 101, + TOKEN_TYPE_KEYW_EQREF = 102, + TOKEN_TYPE_KEYW_EVAL = 103, + TOKEN_TYPE_KEYW_EXPORT = 104, + TOKEN_TYPE_KEYW_EXTENDS = 105, + TOKEN_TYPE_KEYW_EXTERNREF = 106, + TOKEN_TYPE_KEYW_F32 = 107, + TOKEN_TYPE_KEYW_F64 = 108, + TOKEN_TYPE_LITERAL_FALSE = 109, + TOKEN_TYPE_KEYW_FINALLY = 110, + TOKEN_TYPE_KEYW_FLOAT = 111, + TOKEN_TYPE_KEYW_BUILTIN_FLOAT = 112, + TOKEN_TYPE_KEYW_FOR = 113, + TOKEN_TYPE_KEYW_FROM = 114, + TOKEN_TYPE_KEYW_FUNCREF = 115, + TOKEN_TYPE_KEYW_FUNCTION = 116, + TOKEN_TYPE_KEYW_GET = 117, + TOKEN_TYPE_KEYW_GLOBAL = 118, + TOKEN_TYPE_KEYW_I8 = 119, + TOKEN_TYPE_KEYW_I16 = 120, + TOKEN_TYPE_KEYW_I31REF = 121, + TOKEN_TYPE_KEYW_I32 = 122, + TOKEN_TYPE_KEYW_I64 = 123, + TOKEN_TYPE_KEYW_IF = 124, + TOKEN_TYPE_KEYW_IMPLEMENTS = 125, + TOKEN_TYPE_KEYW_IMPORT = 126, + TOKEN_TYPE_KEYW_IN = 127, + TOKEN_TYPE_KEYW_INFER = 128, + TOKEN_TYPE_KEYW_INIT_MODULE = 129, + TOKEN_TYPE_KEYW_INSTANCEOF = 130, + TOKEN_TYPE_KEYW_INT = 131, + TOKEN_TYPE_KEYW_BUILTIN_INT = 132, + TOKEN_TYPE_KEYW_INTERFACE = 133, + TOKEN_TYPE_KEYW_IS = 134, + TOKEN_TYPE_KEYW_ISIZE = 135, + TOKEN_TYPE_KEYW_KEYOF = 136, + TOKEN_TYPE_KEYW_LET = 137, + TOKEN_TYPE_KEYW_LONG = 138, + TOKEN_TYPE_KEYW_BUILTIN_LONG = 139, + TOKEN_TYPE_KEYW_META = 140, + TOKEN_TYPE_KEYW_MODULE = 141, + TOKEN_TYPE_KEYW_NAMESPACE = 142, + TOKEN_TYPE_KEYW_NATIVE = 143, + TOKEN_TYPE_KEYW_NEVER = 144, + TOKEN_TYPE_KEYW_NEW = 145, + TOKEN_TYPE_KEYW_NON_NULLABLE = 146, + TOKEN_TYPE_LITERAL_NULL = 147, + TOKEN_TYPE_KEYW_NUMBER = 148, + TOKEN_TYPE_KEYW_OBJECT = 149, + TOKEN_TYPE_KEYW_BUILTIN_OBJECT = 150, + TOKEN_TYPE_KEYW_OF = 151, + TOKEN_TYPE_KEYW_FINAL = 152, + TOKEN_TYPE_KEYW_OUT = 153, + TOKEN_TYPE_KEYW_OVERLOAD = 154, + TOKEN_TYPE_KEYW_OVERRIDE = 155, + TOKEN_TYPE_KEYW_PACKAGE = 156, + TOKEN_TYPE_KEYW_INTERNAL = 157, + TOKEN_TYPE_KEYW_PRIVATE = 158, + TOKEN_TYPE_KEYW_PROTECTED = 159, + TOKEN_TYPE_KEYW_PUBLIC = 160, + TOKEN_TYPE_KEYW_READONLY = 161, + TOKEN_TYPE_KEYW_RETURN = 162, + TOKEN_TYPE_KEYW_REQUIRE = 163, + TOKEN_TYPE_KEYW_SET = 164, + TOKEN_TYPE_KEYW_SHORT = 165, + TOKEN_TYPE_KEYW_BUILTIN_SHORT = 166, + TOKEN_TYPE_KEYW_STATIC = 167, + TOKEN_TYPE_KEYW_STRING = 168, + TOKEN_TYPE_KEYW_BUILTIN_STRING = 169, + TOKEN_TYPE_KEYW_STRUCT = 170, + TOKEN_TYPE_KEYW_SUPER = 171, + TOKEN_TYPE_KEYW_SWITCH = 172, + TOKEN_TYPE_KEYW_TARGET = 173, + TOKEN_TYPE_KEYW_THIS = 174, + TOKEN_TYPE_KEYW_THROW = 175, + TOKEN_TYPE_LITERAL_TRUE = 176, + TOKEN_TYPE_KEYW_TRY = 177, + TOKEN_TYPE_KEYW_TYPE = 178, + TOKEN_TYPE_KEYW_TYPEOF = 179, + TOKEN_TYPE_KEYW_U8 = 180, + TOKEN_TYPE_KEYW_U16 = 181, + TOKEN_TYPE_KEYW_U32 = 182, + TOKEN_TYPE_KEYW_U64 = 183, + TOKEN_TYPE_KEYW_UNDEFINED = 184, + TOKEN_TYPE_KEYW_UNKNOWN = 185, + TOKEN_TYPE_KEYW_USIZE = 186, + TOKEN_TYPE_KEYW_V128 = 187, + TOKEN_TYPE_KEYW_VAR = 188, + TOKEN_TYPE_KEYW_VOID = 189, + TOKEN_TYPE_KEYW_WHILE = 190, + TOKEN_TYPE_KEYW_WITH = 191, + TOKEN_TYPE_KEYW_YIELD = 192, + TOKEN_TYPE_FIRST_PUNCTUATOR = 6, + TOKEN_TYPE_FIRST_KEYW = 68 +} +export enum Es2pandaAstNodeFlags { + AST_NODE_FLAGS_NO_OPTS = 0, + AST_NODE_FLAGS_CHECKCAST = 1, + AST_NODE_FLAGS_ALLOW_REQUIRED_INSTANTIATION = 2, + AST_NODE_FLAGS_HAS_EXPORT_ALIAS = 4, + AST_NODE_FLAGS_GENERATE_VALUE_OF = 8, + AST_NODE_FLAGS_RECHECK = 16, + AST_NODE_FLAGS_NOCLEANUP = 32, + AST_NODE_FLAGS_RESIZABLE_REST = 64, + AST_NODE_FLAGS_TMP_CONVERT_PRIMITIVE_CAST_METHOD_CALL = 128, + AST_NODE_FLAGS_IS_GROUPED = 256 +} +export enum Es2pandaModifierFlags { + MODIFIER_FLAGS_NONE = 0, + MODIFIER_FLAGS_STATIC = 1, + MODIFIER_FLAGS_ASYNC = 2, + MODIFIER_FLAGS_PUBLIC = 4, + MODIFIER_FLAGS_PROTECTED = 8, + MODIFIER_FLAGS_PRIVATE = 16, + MODIFIER_FLAGS_DECLARE = 32, + MODIFIER_FLAGS_READONLY = 64, + MODIFIER_FLAGS_OPTIONAL = 128, + MODIFIER_FLAGS_DEFINITE = 256, + MODIFIER_FLAGS_ABSTRACT = 512, + MODIFIER_FLAGS_CONST = 1024, + MODIFIER_FLAGS_FINAL = 2048, + MODIFIER_FLAGS_NATIVE = 4096, + MODIFIER_FLAGS_OVERRIDE = 8192, + MODIFIER_FLAGS_CONSTRUCTOR = 16384, + MODIFIER_FLAGS_SYNCHRONIZED = 32768, + MODIFIER_FLAGS_FUNCTIONAL = 65536, + MODIFIER_FLAGS_IN = 131072, + MODIFIER_FLAGS_OUT = 262144, + MODIFIER_FLAGS_INTERNAL = 524288, + MODIFIER_FLAGS_EXPORT = 1048576, + MODIFIER_FLAGS_GETTER = 2097152, + MODIFIER_FLAGS_SETTER = 4194304, + MODIFIER_FLAGS_DEFAULT_EXPORT = 8388608, + MODIFIER_FLAGS_EXPORT_TYPE = 16777216, + MODIFIER_FLAGS_SUPER_OWNER = 33554432, + MODIFIER_FLAGS_ANNOTATION_DECLARATION = 67108864, + MODIFIER_FLAGS_ANNOTATION_USAGE = 134217728, + MODIFIER_FLAGS_READONLY_PARAMETER = 268435456, + MODIFIER_FLAGS_ARRAY_SETTER = 536870912, + MODIFIER_FLAGS_DEFAULT = 1073741824, + MODIFIER_FLAGS_ACCESS = 524316, + MODIFIER_FLAGS_ALL = 524927, + MODIFIER_FLAGS_ALLOWED_IN_CTOR_PARAMETER = 524380, + MODIFIER_FLAGS_INTERNAL_PROTECTED = 524296, + MODIFIER_FLAGS_ACCESSOR_MODIFIERS = 2560, + MODIFIER_FLAGS_GETTER_SETTER = 6291456, + MODIFIER_FLAGS_EXPORTED = 26214400 +} +export enum Es2pandaPrivateFieldKind { + PRIVATE_FIELD_KIND_FIELD = 0, + PRIVATE_FIELD_KIND_METHOD = 1, + PRIVATE_FIELD_KIND_GET = 2, + PRIVATE_FIELD_KIND_SET = 3, + PRIVATE_FIELD_KIND_STATIC_FIELD = 4, + PRIVATE_FIELD_KIND_STATIC_METHOD = 5, + PRIVATE_FIELD_KIND_STATIC_GET = 6, + PRIVATE_FIELD_KIND_STATIC_SET = 7, + PRIVATE_FIELD_KIND_OVERLOAD = 8, + PRIVATE_FIELD_KIND_STATIC_OVERLOAD = 9 +} +export enum Es2pandaScriptFunctionFlags { + SCRIPT_FUNCTION_FLAGS_NONE = 0, + SCRIPT_FUNCTION_FLAGS_GENERATOR = 1, + SCRIPT_FUNCTION_FLAGS_ASYNC = 2, + SCRIPT_FUNCTION_FLAGS_ARROW = 4, + SCRIPT_FUNCTION_FLAGS_EXPRESSION = 8, + SCRIPT_FUNCTION_FLAGS_OVERLOAD = 16, + SCRIPT_FUNCTION_FLAGS_CONSTRUCTOR = 32, + SCRIPT_FUNCTION_FLAGS_METHOD = 64, + SCRIPT_FUNCTION_FLAGS_STATIC_BLOCK = 128, + SCRIPT_FUNCTION_FLAGS_HIDDEN = 256, + SCRIPT_FUNCTION_FLAGS_IMPLICIT_SUPER_CALL_NEEDED = 512, + SCRIPT_FUNCTION_FLAGS_ENUM = 1024, + SCRIPT_FUNCTION_FLAGS_EXTERNAL = 2048, + SCRIPT_FUNCTION_FLAGS_PROXY = 4096, + SCRIPT_FUNCTION_FLAGS_THROWS = 8192, + SCRIPT_FUNCTION_FLAGS_RETHROWS = 16384, + SCRIPT_FUNCTION_FLAGS_GETTER = 32768, + SCRIPT_FUNCTION_FLAGS_SETTER = 65536, + SCRIPT_FUNCTION_FLAGS_ENTRY_POINT = 131072, + SCRIPT_FUNCTION_FLAGS_HAS_RETURN = 262144, + SCRIPT_FUNCTION_FLAGS_ASYNC_IMPL = 524288, + SCRIPT_FUNCTION_FLAGS_EXTERNAL_OVERLOAD = 1048576, + SCRIPT_FUNCTION_FLAGS_HAS_THROW = 2097152, + SCRIPT_FUNCTION_FLAGS_IN_RECORD = 4194304, + SCRIPT_FUNCTION_FLAGS_TRAILING_LAMBDA = 8388608, + SCRIPT_FUNCTION_FLAGS_SYNTHETIC = 16777216 +} +export enum Es2pandaTSOperatorType { + TS_OPERATOR_TYPE_READONLY = 0, + TS_OPERATOR_TYPE_KEYOF = 1, + TS_OPERATOR_TYPE_UNIQUE = 2 +} +export enum Es2pandaMappedOption { + MAPPED_OPTION_NO_OPTS = 0, + MAPPED_OPTION_PLUS = 1, + MAPPED_OPTION_MINUS = 2 +} +export enum Es2pandaClassDefinitionModifiers { + CLASS_DEFINITION_MODIFIERS_NONE = 0, + CLASS_DEFINITION_MODIFIERS_DECLARATION = 1, + CLASS_DEFINITION_MODIFIERS_ID_REQUIRED = 2, + CLASS_DEFINITION_MODIFIERS_GLOBAL = 4, + CLASS_DEFINITION_MODIFIERS_HAS_SUPER = 8, + CLASS_DEFINITION_MODIFIERS_SET_CTOR_ID = 16, + CLASS_DEFINITION_MODIFIERS_EXTERN = 32, + CLASS_DEFINITION_MODIFIERS_ANONYMOUS = 64, + CLASS_DEFINITION_MODIFIERS_GLOBAL_INITIALIZED = 128, + CLASS_DEFINITION_MODIFIERS_CLASS_DECL = 256, + CLASS_DEFINITION_MODIFIERS_INNER = 512, + CLASS_DEFINITION_MODIFIERS_FROM_EXTERNAL = 1024, + CLASS_DEFINITION_MODIFIERS_LOCAL = 2048, + CLASS_DEFINITION_MODIFIERS_CLASSDEFINITION_CHECKED = 4096, + CLASS_DEFINITION_MODIFIERS_NAMESPACE_TRANSFORMED = 8192, + CLASS_DEFINITION_MODIFIERS_STRING_ENUM_TRANSFORMED = 16384, + CLASS_DEFINITION_MODIFIERS_INT_ENUM_TRANSFORMED = 32768, + CLASS_DEFINITION_MODIFIERS_FROM_STRUCT = 65536, + CLASS_DEFINITION_MODIFIERS_FUNCTIONAL_REFERENCE = 131072, + CLASS_DEFINITION_MODIFIERS_LAZY_IMPORT_OBJECT_CLASS = 262144, + CLASS_DEFINITION_MODIFIERS_INIT_IN_CCTOR = 524288, + CLASS_DEFINITION_MODIFIERS_DECLARATION_ID_REQUIRED = 3, + CLASS_DEFINITION_MODIFIERS_ETS_MODULE = 8196 +} +export enum Es2pandaOperandKind { + OPERAND_KIND_SRC_VREG = 0, + OPERAND_KIND_DST_VREG = 1, + OPERAND_KIND_SRC_DST_VREG = 2, + OPERAND_KIND_IMM = 3, + OPERAND_KIND_ID = 4, + OPERAND_KIND_STRING_ID = 5, + OPERAND_KIND_LABEL = 6 +} +export enum Es2pandaOperandType { + OPERAND_TYPE_REF = 0, + OPERAND_TYPE_B32 = 1, + OPERAND_TYPE_B64 = 2, + OPERAND_TYPE_ANY = 3, + OPERAND_TYPE_NONE = 4 +} +export enum Es2pandaTypeRelationFlag { + TYPE_RELATION_FLAG_NONE = 0, + TYPE_RELATION_FLAG_WIDENING = 1, + TYPE_RELATION_FLAG_BOXING = 2, + TYPE_RELATION_FLAG_UNBOXING = 4, + TYPE_RELATION_FLAG_CAPTURE = 8, + TYPE_RELATION_FLAG_STRING = 16, + TYPE_RELATION_FLAG_VALUE_SET = 32, + TYPE_RELATION_FLAG_UNCHECKED = 64, + TYPE_RELATION_FLAG_NO_THROW = 128, + TYPE_RELATION_FLAG_SELF_REFERENCE = 256, + TYPE_RELATION_FLAG_NO_RETURN_TYPE_CHECK = 512, + TYPE_RELATION_FLAG_DIRECT_RETURN = 1024, + TYPE_RELATION_FLAG_NO_WIDENING = 2048, + TYPE_RELATION_FLAG_NO_BOXING = 4096, + TYPE_RELATION_FLAG_NO_UNBOXING = 8192, + TYPE_RELATION_FLAG_ONLY_CHECK_WIDENING = 16384, + TYPE_RELATION_FLAG_ONLY_CHECK_BOXING_UNBOXING = 32768, + TYPE_RELATION_FLAG_IN_ASSIGNMENT_CONTEXT = 65536, + TYPE_RELATION_FLAG_IN_CASTING_CONTEXT = 131072, + TYPE_RELATION_FLAG_UNCHECKED_CAST = 262144, + TYPE_RELATION_FLAG_IGNORE_TYPE_PARAMETERS = 524288, + TYPE_RELATION_FLAG_CHECK_PROXY = 1048576, + TYPE_RELATION_FLAG_NO_CHECK_TRAILING_LAMBDA = 2097152, + TYPE_RELATION_FLAG_NO_THROW_GENERIC_TYPEALIAS = 4194304, + TYPE_RELATION_FLAG_OVERRIDING_CONTEXT = 8388608, + TYPE_RELATION_FLAG_IGNORE_REST_PARAM = 16777216, + TYPE_RELATION_FLAG_STRING_TO_CHAR = 33554432, + TYPE_RELATION_FLAG_OVERLOADING_CONTEXT = 67108864, + TYPE_RELATION_FLAG_NO_SUBSTITUTION_NEEDED = 134217728, + TYPE_RELATION_FLAG_ASSIGNMENT_CONTEXT = 7, + TYPE_RELATION_FLAG_BRIDGE_CHECK = 8912896, + TYPE_RELATION_FLAG_CASTING_CONTEXT = 262151 +} +export enum Es2pandaRelationResult { + RELATION_RESULT_TRUE = 0, + RELATION_RESULT_FALSE = 1, + RELATION_RESULT_UNKNOWN = 2, + RELATION_RESULT_MAYBE = 3, + RELATION_RESULT_CACHE_MISS = 4, + RELATION_RESULT_ERROR = 5 +} +export enum Es2pandaRelationType { + RELATION_TYPE_COMPARABLE = 0, + RELATION_TYPE_ASSIGNABLE = 1, + RELATION_TYPE_IDENTICAL = 2, + RELATION_TYPE_UNCHECKED_CASTABLE = 3, + RELATION_TYPE_SUPERTYPE = 4 +} +export enum Es2pandaVarianceFlag { + VARIANCE_FLAG_COVARIANT = 0, + VARIANCE_FLAG_CONTRAVARIANT = 1, + VARIANCE_FLAG_INVARIANT = 2 +} +export enum Es2pandaImportKinds { + IMPORT_KINDS_ALL = 0, + IMPORT_KINDS_TYPES = 1 +} +export enum Es2pandaPropertyKind { + PROPERTY_KIND_INIT = 0, + PROPERTY_KIND_GET = 1, + PROPERTY_KIND_SET = 2, + PROPERTY_KIND_PROTO = 3 +} +export enum Es2pandaConstant { + CONSTANT_PROP_NULL = 0, + CONSTANT_PROP_UNDEFINED = 1, + CONSTANT_EMPTY_ARRAY = 2 +} +export enum Es2pandaTSSignatureDeclarationKind { + TS_SIGNATURE_DECLARATION_KIND_CALL_SIGNATURE = 0, + TS_SIGNATURE_DECLARATION_KIND_CONSTRUCT_SIGNATURE = 1 +} +export enum Es2pandaInitMode { + INIT_MODE_NONE = 0, + INIT_MODE_IMMEDIATE_INIT = 1, + INIT_MODE_NEED_INIT_IN_STATIC_BLOCK = 2 +} +export enum Es2pandaTSIndexSignatureKind { + TS_INDEX_SIGNATURE_KIND_NUMBER = 0, + TS_INDEX_SIGNATURE_KIND_STRING = 1 +} +export enum Es2pandaEnumLiteralTypeKind { + ENUM_LITERAL_TYPE_KIND_NUMERIC = 0, + ENUM_LITERAL_TYPE_KIND_LITERAL = 1 +} +export enum Es2pandaIdentifierFlags { + IDENTIFIER_FLAGS_NONE = 0, + IDENTIFIER_FLAGS_OPTIONAL = 1, + IDENTIFIER_FLAGS_TDZ = 2, + IDENTIFIER_FLAGS_PRIVATE = 4, + IDENTIFIER_FLAGS_GET = 8, + IDENTIFIER_FLAGS_SET = 16, + IDENTIFIER_FLAGS_IGNORE_BOX = 32, + IDENTIFIER_FLAGS_ANNOTATIONDECL = 64, + IDENTIFIER_FLAGS_ANNOTATIONUSAGE = 128, + IDENTIFIER_FLAGS_ERROR_PLACEHOLDER = 256 +} +export enum Es2pandaMemberExpressionKind { + MEMBER_EXPRESSION_KIND_NONE = 0, + MEMBER_EXPRESSION_KIND_ELEMENT_ACCESS = 1, + MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS = 2, + MEMBER_EXPRESSION_KIND_GETTER = 4, + MEMBER_EXPRESSION_KIND_SETTER = 8, + MEMBER_EXPRESSION_KIND_EXTENSION_ACCESSOR = 16 +} +export enum Es2pandaTSTupleKind { + TS_TUPLE_KIND_NONE = 0, + TS_TUPLE_KIND_NAMED = 1, + TS_TUPLE_KIND_DEFAULT = 2 +} +export enum Es2pandaMetaPropertyKind { + META_PROPERTY_KIND_NEW_TARGET = 0, + META_PROPERTY_KIND_IMPORT_META = 1 +} +export enum Es2pandaModuleFlag { + MODULE_FLAG_NONE = 0, + MODULE_FLAG_ETSSCRIPT = 1, + MODULE_FLAG_NAMESPACE = 2, + MODULE_FLAG_NAMESPACE_CHAIN_LAST_NODE = 4 +} +export enum Es2pandaElementFlags { + ELEMENT_FLAGS_NO_OPTS = 0, + ELEMENT_FLAGS_REQUIRED = 1, + ELEMENT_FLAGS_OPTIONAL = 2, + ELEMENT_FLAGS_REST = 4, + ELEMENT_FLAGS_VARIADIC = 8, + ELEMENT_FLAGS_FIXED = 3, + ELEMENT_FLAGS_VARIABLE = 12, + ELEMENT_FLAGS_NON_REQUIRED = 14, + ELEMENT_FLAGS_NON_REST = 11 +} +export enum Es2pandaSignatureFlags { + SIGNATURE_FLAGS_NO_OPTS = 0, + SIGNATURE_FLAGS_ABSTRACT = 1, + SIGNATURE_FLAGS_CALL = 2, + SIGNATURE_FLAGS_CONSTRUCT = 4, + SIGNATURE_FLAGS_PUBLIC = 8, + SIGNATURE_FLAGS_PROTECTED = 16, + SIGNATURE_FLAGS_PRIVATE = 32, + SIGNATURE_FLAGS_STATIC = 64, + SIGNATURE_FLAGS_FINAL = 128, + SIGNATURE_FLAGS_CONSTRUCTOR = 256, + SIGNATURE_FLAGS_PROXY = 512, + SIGNATURE_FLAGS_INTERNAL = 1024, + SIGNATURE_FLAGS_NEED_RETURN_TYPE = 2048, + SIGNATURE_FLAGS_INFERRED_RETURN_TYPE = 4096, + SIGNATURE_FLAGS_THIS_RETURN_TYPE = 8192, + SIGNATURE_FLAGS_GETTER = 16384, + SIGNATURE_FLAGS_SETTER = 32768, + SIGNATURE_FLAGS_THROWS = 65536, + SIGNATURE_FLAGS_RETHROWS = 131072, + SIGNATURE_FLAGS_EXTENSION_FUNCTION = 262144, + SIGNATURE_FLAGS_DUPLICATE_ASM = 524288, + SIGNATURE_FLAGS_BRIDGE = 1048576, + SIGNATURE_FLAGS_DEFAULT = 2097152, + SIGNATURE_FLAGS_INTERNAL_PROTECTED = 1040, + SIGNATURE_FLAGS_GETTER_OR_SETTER = 49152, + SIGNATURE_FLAGS_THROWING = 196608 +} +export enum Es2pandaPrimitiveType { + PRIMITIVE_TYPE_BYTE = 0, + PRIMITIVE_TYPE_INT = 1, + PRIMITIVE_TYPE_LONG = 2, + PRIMITIVE_TYPE_SHORT = 3, + PRIMITIVE_TYPE_FLOAT = 4, + PRIMITIVE_TYPE_DOUBLE = 5, + PRIMITIVE_TYPE_BOOLEAN = 6, + PRIMITIVE_TYPE_CHAR = 7, + PRIMITIVE_TYPE_VOID = 8 +} +export enum Es2pandaIntrinsicNodeType { + INTRINSIC_NODE_TYPE_NONE = 0, + INTRINSIC_NODE_TYPE_TYPE_REFERENCE = 1 +} +export enum Es2pandaObjectFlags { + OBJECT_FLAGS_NO_OPTS = 0, + OBJECT_FLAGS_CHECK_EXCESS_PROPS = 1, + OBJECT_FLAGS_RESOLVED_MEMBERS = 2, + OBJECT_FLAGS_RESOLVED_BASE_TYPES = 4, + OBJECT_FLAGS_RESOLVED_DECLARED_MEMBERS = 8 +} +export enum Es2pandaObjectTypeKind { + OBJECT_TYPE_KIND_LITERAL = 0, + OBJECT_TYPE_KIND_CLASS = 1, + OBJECT_TYPE_KIND_INTERFACE = 2, + OBJECT_TYPE_KIND_TUPLE = 3, + OBJECT_TYPE_KIND_FUNCTION = 4 +} +export enum Es2pandaVariableDeclaratorFlag { + VARIABLE_DECLARATOR_FLAG_LET = 0, + VARIABLE_DECLARATOR_FLAG_CONST = 1, + VARIABLE_DECLARATOR_FLAG_VAR = 2, + VARIABLE_DECLARATOR_FLAG_UNKNOWN = 3 +} +export enum Es2pandaTypeFacts { + TYPE_FACTS_NONE = 0, + TYPE_FACTS_TYPEOF_EQ_STRING = 1, + TYPE_FACTS_TYPEOF_EQ_NUMBER = 2, + TYPE_FACTS_TYPEOF_EQ_BIGINT = 4, + TYPE_FACTS_TYPEOF_EQ_BOOLEAN = 8, + TYPE_FACTS_TYPEOF_EQ_SYMBOL = 16, + TYPE_FACTS_TYPEOF_EQ_OBJECT = 32, + TYPE_FACTS_TYPEOF_EQ_FUNCTION = 64, + TYPE_FACTS_TYPEOF_EQ_HOST_OBJECT = 128, + TYPE_FACTS_TYPEOF_NE_STRING = 256, + TYPE_FACTS_TYPEOF_NE_NUMBER = 512, + TYPE_FACTS_TYPEOF_NE_BIGINT = 1024, + TYPE_FACTS_TYPEOF_NE_BOOLEAN = 2048, + TYPE_FACTS_TYPEOF_NE_SYMBOL = 4096, + TYPE_FACTS_TYPEOF_NE_OBJECT = 8192, + TYPE_FACTS_TYPEOF_NE_FUNCTION = 16384, + TYPE_FACTS_TYPEOF_NE_HOST_OBJECT = 32768, + TYPE_FACTS_EQ_UNDEFINED = 65536, + TYPE_FACTS_EQ_NULL = 131072, + TYPE_FACTS_EQ_UNDEFINED_OR_NULL = 262144, + TYPE_FACTS_NE_UNDEFINED = 524288, + TYPE_FACTS_NE_NULL = 1048576, + TYPE_FACTS_NE_UNDEFINED_OR_NULL = 2097152, + TYPE_FACTS_TRUTHY = 4194304, + TYPE_FACTS_FALSY = 8388608, + TYPE_FACTS_ALL = 16777216, + TYPE_FACTS_LAST = 8388608, + TYPE_FACTS_BASE_NUMBER_STRICT_FACTS = 3734786, + TYPE_FACTS_BASE_NUMBER_FACTS = 12582146, + TYPE_FACTS_NUMBER_FACTS = 16776450, + TYPE_FACTS_ZERO_NUMBER_STRICT_FACTS = 12123394, + TYPE_FACTS_ZERO_NUMBER_FACTS = 12582146, + TYPE_FACTS_NON_ZERO_NUMBER_FACTS = 16776450, + TYPE_FACTS_BASE_STRING_STRICT_FACTS = 3735041, + TYPE_FACTS_BASE_STRING_FACTS = 12582401, + TYPE_FACTS_STRING_FACTS = 16776705, + TYPE_FACTS_EMPTY_STRING_STRICT_FACTS = 16317953, + TYPE_FACTS_EMPTY_STRING_FACTS = 12582401, + TYPE_FACTS_NON_EMPTY_STRING_FACTS = 16776705, + TYPE_FACTS_BASE_BIGINT_STRICT_FACTS = 3734276, + TYPE_FACTS_BASE_BIGINT_FACTS = 12581636, + TYPE_FACTS_BIGINT_FACTS = 16775940, + TYPE_FACTS_ZERO_BIGINT_STRICT_FACTS = 12122884, + TYPE_FACTS_ZERO_BIGINT_FACTS = 12581636, + TYPE_FACTS_NON_ZERO_BIGINT_FACTS = 16775940, + TYPE_FACTS_BASE_BOOLEAN_STRICT_FACTS = 3733256, + TYPE_FACTS_BASE_BOOLEAN_FACTS = 12580616, + TYPE_FACTS_BOOLEAN_FACTS = 16774920, + TYPE_FACTS_FALSE_STRICT_FACTS = 12121864, + TYPE_FACTS_FALSE_FACTS = 12580616, + TYPE_FACTS_TRUE_STRICT_FACTS = 7927560, + TYPE_FACTS_TRUE_FACTS = 16774920, + TYPE_FACTS_OBJECT_STRICT_FACTS = 7888800, + TYPE_FACTS_OBJECT_FACTS = 16736160, + TYPE_FACTS_EMPTY_OBJECT_FACTS = 16777216, + TYPE_FACTS_FUNCTION_STRICT_FACTS = 7880640, + TYPE_FACTS_FUNCTION_FACTS = 16728000, + TYPE_FACTS_UNDEFINED_FACTS = 9830144, + TYPE_FACTS_NULL_FACTS = 9363232 +} +export enum Es2pandaGlobalTypeId { + GLOBAL_TYPE_ID_NUMBER = 0, + GLOBAL_TYPE_ID_ANY = 1, + GLOBAL_TYPE_ID_STRING = 2, + GLOBAL_TYPE_ID_BOOLEAN = 3, + GLOBAL_TYPE_ID_VOID = 4, + GLOBAL_TYPE_ID_NULL_ID = 5, + GLOBAL_TYPE_ID_UNDEFINED = 6, + GLOBAL_TYPE_ID_UNKNOWN = 7, + GLOBAL_TYPE_ID_NEVER = 8, + GLOBAL_TYPE_ID_NON_PRIMITIVE = 9, + GLOBAL_TYPE_ID_BIGINT = 10, + GLOBAL_TYPE_ID_FALSE_ID = 11, + GLOBAL_TYPE_ID_TRUE_ID = 12, + GLOBAL_TYPE_ID_NUMBER_OR_BIGINT = 13, + GLOBAL_TYPE_ID_STRING_OR_NUMBER = 14, + GLOBAL_TYPE_ID_ZERO = 15, + GLOBAL_TYPE_ID_EMPTY_STRING = 16, + GLOBAL_TYPE_ID_ZERO_BIGINT = 17, + GLOBAL_TYPE_ID_PRIMITIVE = 18, + GLOBAL_TYPE_ID_EMPTY_TUPLE = 19, + GLOBAL_TYPE_ID_EMPTY_OBJECT = 20, + GLOBAL_TYPE_ID_RESOLVING_RETURN_TYPE = 21, + GLOBAL_TYPE_ID_ERROR_TYPE = 22, + GLOBAL_TYPE_ID_BYTE = 23, + GLOBAL_TYPE_ID_SHORT = 24, + GLOBAL_TYPE_ID_INT = 25, + GLOBAL_TYPE_ID_LONG = 26, + GLOBAL_TYPE_ID_FLOAT = 27, + GLOBAL_TYPE_ID_DOUBLE = 28, + GLOBAL_TYPE_ID_CHAR = 29, + GLOBAL_TYPE_ID_ETS_BOOLEAN = 30, + GLOBAL_TYPE_ID_ETS_STRING = 31, + GLOBAL_TYPE_ID_ETS_VOID = 32, + GLOBAL_TYPE_ID_ETS_OBJECT_BUILTIN = 33, + GLOBAL_TYPE_ID_ETS_NULL = 34, + GLOBAL_TYPE_ID_ETS_UNDEFINED = 35, + GLOBAL_TYPE_ID_ETS_UNION_UNDEFINED_NULL = 36, + GLOBAL_TYPE_ID_ETS_ANY = 37, + GLOBAL_TYPE_ID_ETS_RELAXED_ANY = 38, + GLOBAL_TYPE_ID_ETS_NEVER = 39, + GLOBAL_TYPE_ID_ETS_UNION_UNDEFINED_NULL_OBJECT = 40, + GLOBAL_TYPE_ID_ETS_WILDCARD = 41, + GLOBAL_TYPE_ID_ETS_BOOLEAN_BUILTIN = 42, + GLOBAL_TYPE_ID_ETS_BYTE_BUILTIN = 43, + GLOBAL_TYPE_ID_ETS_CLASS_BUILTIN = 44, + GLOBAL_TYPE_ID_ETS_CHAR_BUILTIN = 45, + GLOBAL_TYPE_ID_ETS_COMPARABLE_BUILTIN = 46, + GLOBAL_TYPE_ID_ETS_CONSOLE_BUILTIN = 47, + GLOBAL_TYPE_ID_ETS_DATE_BUILTIN = 48, + GLOBAL_TYPE_ID_ETS_DOUBLE_BUILTIN = 49, + GLOBAL_TYPE_ID_ETS_EXCEPTION_BUILTIN = 50, + GLOBAL_TYPE_ID_ETS_FLOAT_BUILTIN = 51, + GLOBAL_TYPE_ID_ETS_FLOATING_BUILTIN = 52, + GLOBAL_TYPE_ID_ETS_INT_BUILTIN = 53, + GLOBAL_TYPE_ID_ETS_INTEGRAL_BUILTIN = 54, + GLOBAL_TYPE_ID_ETS_LONG_BUILTIN = 55, + GLOBAL_TYPE_ID_ETS_NUMERIC_BUILTIN = 56, + GLOBAL_TYPE_ID_ETS_MAP_BUILTIN = 57, + GLOBAL_TYPE_ID_ETS_RECORD_BUILTIN = 58, + GLOBAL_TYPE_ID_ETS_ERROR_BUILTIN = 59, + GLOBAL_TYPE_ID_ETS_RUNTIME_BUILTIN = 60, + GLOBAL_TYPE_ID_ETS_RUNTIME_LINKER_BUILTIN = 61, + GLOBAL_TYPE_ID_ETS_SET_BUILTIN = 62, + GLOBAL_TYPE_ID_ETS_SHORT_BUILTIN = 63, + GLOBAL_TYPE_ID_ETS_STACK_TRACE_ELEMENT_BUILTIN = 64, + GLOBAL_TYPE_ID_ETS_STACK_TRACE_BUILTIN = 65, + GLOBAL_TYPE_ID_ETS_ARRAY_INDEX_OUT_OF_BOUNDS_ERROR_BUILTIN = 66, + GLOBAL_TYPE_ID_ETS_ARITHMETIC_ERROR_BUILTIN = 67, + GLOBAL_TYPE_ID_ETS_CLASS_CAST_ERROR_BUILTIN = 68, + GLOBAL_TYPE_ID_ETS_ASSERTION_ERROR_BUILTIN = 69, + GLOBAL_TYPE_ID_ETS_DIVIDE_BY_ZERO_ERROR_BUILTIN = 70, + GLOBAL_TYPE_ID_ETS_NULL_POINTER_ERROR_BUILTIN = 71, + GLOBAL_TYPE_ID_ETS_UNCAUGHT_EXCEPTION_ERROR_BUILTIN = 72, + GLOBAL_TYPE_ID_ETS_STRING_BUILTIN = 73, + GLOBAL_TYPE_ID_ETS_STRING_BUILDER_BUILTIN = 74, + GLOBAL_TYPE_ID_ETS_TYPE_BUILTIN = 75, + GLOBAL_TYPE_ID_ETS_TYPES_BUILTIN = 76, + GLOBAL_TYPE_ID_ETS_PROMISE_BUILTIN = 77, + GLOBAL_TYPE_ID_ETS_FUNCTION_BUILTIN = 78, + GLOBAL_TYPE_ID_ETS_REGEXP_BUILTIN = 79, + GLOBAL_TYPE_ID_ETS_ARRAY_BUILTIN = 80, + GLOBAL_TYPE_ID_ETS_INTEROP_JSRUNTIME_BUILTIN = 81, + GLOBAL_TYPE_ID_ETS_INTEROP_JSVALUE_BUILTIN = 82, + GLOBAL_TYPE_ID_ETS_BOX_BUILTIN = 83, + GLOBAL_TYPE_ID_ETS_BOOLEAN_BOX_BUILTIN = 84, + GLOBAL_TYPE_ID_ETS_BYTE_BOX_BUILTIN = 85, + GLOBAL_TYPE_ID_ETS_CHAR_BOX_BUILTIN = 86, + GLOBAL_TYPE_ID_ETS_SHORT_BOX_BUILTIN = 87, + GLOBAL_TYPE_ID_ETS_INT_BOX_BUILTIN = 88, + GLOBAL_TYPE_ID_ETS_LONG_BOX_BUILTIN = 89, + GLOBAL_TYPE_ID_ETS_FLOAT_BOX_BUILTIN = 90, + GLOBAL_TYPE_ID_ETS_DOUBLE_BOX_BUILTIN = 91, + GLOBAL_TYPE_ID_ETS_BIG_INT_BUILTIN = 92, + GLOBAL_TYPE_ID_ETS_BIG_INT = 93, + GLOBAL_TYPE_ID_ETS_ARRAY = 94, + GLOBAL_TYPE_ID_ETS_READONLY_ARRAY = 95, + GLOBAL_TYPE_ID_ETS_FUNCTION0_CLASS = 96, + GLOBAL_TYPE_ID_ETS_FUNCTION1_CLASS = 97, + GLOBAL_TYPE_ID_ETS_FUNCTION2_CLASS = 98, + GLOBAL_TYPE_ID_ETS_FUNCTION3_CLASS = 99, + GLOBAL_TYPE_ID_ETS_FUNCTION4_CLASS = 100, + GLOBAL_TYPE_ID_ETS_FUNCTION5_CLASS = 101, + GLOBAL_TYPE_ID_ETS_FUNCTION6_CLASS = 102, + GLOBAL_TYPE_ID_ETS_FUNCTION7_CLASS = 103, + GLOBAL_TYPE_ID_ETS_FUNCTION8_CLASS = 104, + GLOBAL_TYPE_ID_ETS_FUNCTION9_CLASS = 105, + GLOBAL_TYPE_ID_ETS_FUNCTION10_CLASS = 106, + GLOBAL_TYPE_ID_ETS_FUNCTION11_CLASS = 107, + GLOBAL_TYPE_ID_ETS_FUNCTION12_CLASS = 108, + GLOBAL_TYPE_ID_ETS_FUNCTION13_CLASS = 109, + GLOBAL_TYPE_ID_ETS_FUNCTION14_CLASS = 110, + GLOBAL_TYPE_ID_ETS_FUNCTION15_CLASS = 111, + GLOBAL_TYPE_ID_ETS_FUNCTION16_CLASS = 112, + GLOBAL_TYPE_ID_ETS_FUNCTIONN_CLASS = 113, + GLOBAL_TYPE_ID_ETS_LAMBDA0_CLASS = 114, + GLOBAL_TYPE_ID_ETS_LAMBDA1_CLASS = 115, + GLOBAL_TYPE_ID_ETS_LAMBDA2_CLASS = 116, + GLOBAL_TYPE_ID_ETS_LAMBDA3_CLASS = 117, + GLOBAL_TYPE_ID_ETS_LAMBDA4_CLASS = 118, + GLOBAL_TYPE_ID_ETS_LAMBDA5_CLASS = 119, + GLOBAL_TYPE_ID_ETS_LAMBDA6_CLASS = 120, + GLOBAL_TYPE_ID_ETS_LAMBDA7_CLASS = 121, + GLOBAL_TYPE_ID_ETS_LAMBDA8_CLASS = 122, + GLOBAL_TYPE_ID_ETS_LAMBDA9_CLASS = 123, + GLOBAL_TYPE_ID_ETS_LAMBDA10_CLASS = 124, + GLOBAL_TYPE_ID_ETS_LAMBDA11_CLASS = 125, + GLOBAL_TYPE_ID_ETS_LAMBDA12_CLASS = 126, + GLOBAL_TYPE_ID_ETS_LAMBDA13_CLASS = 127, + GLOBAL_TYPE_ID_ETS_LAMBDA14_CLASS = 128, + GLOBAL_TYPE_ID_ETS_LAMBDA15_CLASS = 129, + GLOBAL_TYPE_ID_ETS_LAMBDA16_CLASS = 130, + GLOBAL_TYPE_ID_ETS_LAMBDAN_CLASS = 131, + GLOBAL_TYPE_ID_ETS_FUNCTIONR0_CLASS = 132, + GLOBAL_TYPE_ID_ETS_FUNCTIONR1_CLASS = 133, + GLOBAL_TYPE_ID_ETS_FUNCTIONR2_CLASS = 134, + GLOBAL_TYPE_ID_ETS_FUNCTIONR3_CLASS = 135, + GLOBAL_TYPE_ID_ETS_FUNCTIONR4_CLASS = 136, + GLOBAL_TYPE_ID_ETS_FUNCTIONR5_CLASS = 137, + GLOBAL_TYPE_ID_ETS_FUNCTIONR6_CLASS = 138, + GLOBAL_TYPE_ID_ETS_FUNCTIONR7_CLASS = 139, + GLOBAL_TYPE_ID_ETS_FUNCTIONR8_CLASS = 140, + GLOBAL_TYPE_ID_ETS_FUNCTIONR9_CLASS = 141, + GLOBAL_TYPE_ID_ETS_FUNCTIONR10_CLASS = 142, + GLOBAL_TYPE_ID_ETS_FUNCTIONR11_CLASS = 143, + GLOBAL_TYPE_ID_ETS_FUNCTIONR12_CLASS = 144, + GLOBAL_TYPE_ID_ETS_FUNCTIONR13_CLASS = 145, + GLOBAL_TYPE_ID_ETS_FUNCTIONR14_CLASS = 146, + GLOBAL_TYPE_ID_ETS_FUNCTIONR15_CLASS = 147, + GLOBAL_TYPE_ID_ETS_FUNCTIONR16_CLASS = 148, + GLOBAL_TYPE_ID_ETS_LAMBDAR0_CLASS = 149, + GLOBAL_TYPE_ID_ETS_LAMBDAR1_CLASS = 150, + GLOBAL_TYPE_ID_ETS_LAMBDAR2_CLASS = 151, + GLOBAL_TYPE_ID_ETS_LAMBDAR3_CLASS = 152, + GLOBAL_TYPE_ID_ETS_LAMBDAR4_CLASS = 153, + GLOBAL_TYPE_ID_ETS_LAMBDAR5_CLASS = 154, + GLOBAL_TYPE_ID_ETS_LAMBDAR6_CLASS = 155, + GLOBAL_TYPE_ID_ETS_LAMBDAR7_CLASS = 156, + GLOBAL_TYPE_ID_ETS_LAMBDAR8_CLASS = 157, + GLOBAL_TYPE_ID_ETS_LAMBDAR9_CLASS = 158, + GLOBAL_TYPE_ID_ETS_LAMBDAR10_CLASS = 159, + GLOBAL_TYPE_ID_ETS_LAMBDAR11_CLASS = 160, + GLOBAL_TYPE_ID_ETS_LAMBDAR12_CLASS = 161, + GLOBAL_TYPE_ID_ETS_LAMBDAR13_CLASS = 162, + GLOBAL_TYPE_ID_ETS_LAMBDAR14_CLASS = 163, + GLOBAL_TYPE_ID_ETS_LAMBDAR15_CLASS = 164, + GLOBAL_TYPE_ID_ETS_LAMBDAR16_CLASS = 165, + GLOBAL_TYPE_ID_ETS_TUPLE0_CLASS = 166, + GLOBAL_TYPE_ID_ETS_TUPLE1_CLASS = 167, + GLOBAL_TYPE_ID_ETS_TUPLE2_CLASS = 168, + GLOBAL_TYPE_ID_ETS_TUPLE3_CLASS = 169, + GLOBAL_TYPE_ID_ETS_TUPLE4_CLASS = 170, + GLOBAL_TYPE_ID_ETS_TUPLE5_CLASS = 171, + GLOBAL_TYPE_ID_ETS_TUPLE6_CLASS = 172, + GLOBAL_TYPE_ID_ETS_TUPLE7_CLASS = 173, + GLOBAL_TYPE_ID_ETS_TUPLE8_CLASS = 174, + GLOBAL_TYPE_ID_ETS_TUPLE9_CLASS = 175, + GLOBAL_TYPE_ID_ETS_TUPLE10_CLASS = 176, + GLOBAL_TYPE_ID_ETS_TUPLE11_CLASS = 177, + GLOBAL_TYPE_ID_ETS_TUPLE12_CLASS = 178, + GLOBAL_TYPE_ID_ETS_TUPLE13_CLASS = 179, + GLOBAL_TYPE_ID_ETS_TUPLE14_CLASS = 180, + GLOBAL_TYPE_ID_ETS_TUPLE15_CLASS = 181, + GLOBAL_TYPE_ID_ETS_TUPLE16_CLASS = 182, + GLOBAL_TYPE_ID_ETS_TUPLEN_CLASS = 183, + GLOBAL_TYPE_ID_TYPE_ERROR = 184, + GLOBAL_TYPE_ID_COUNT = 185 +} +export enum Es2pandaMethodDefinitionKind { + METHOD_DEFINITION_KIND_NONE = 0, + METHOD_DEFINITION_KIND_CONSTRUCTOR = 1, + METHOD_DEFINITION_KIND_METHOD = 2, + METHOD_DEFINITION_KIND_EXTENSION_METHOD = 3, + METHOD_DEFINITION_KIND_GET = 4, + METHOD_DEFINITION_KIND_SET = 5, + METHOD_DEFINITION_KIND_EXTENSION_GET = 6, + METHOD_DEFINITION_KIND_EXTENSION_SET = 7 +} +export enum Es2pandaOverloadDeclFlags { + OVERLOAD_DECL_FLAGS_NONE = 0, + OVERLOAD_DECL_FLAGS_FUNCTION = 1, + OVERLOAD_DECL_FLAGS_CLASS_METHOD = 2, + OVERLOAD_DECL_FLAGS_INTERFACE_METHOD = 4 +} +export enum Es2pandaPropertySearchFlags { + PROPERTY_SEARCH_FLAGS_NO_OPTS = 0, + PROPERTY_SEARCH_FLAGS_SEARCH_INSTANCE_METHOD = 1, + PROPERTY_SEARCH_FLAGS_SEARCH_INSTANCE_FIELD = 2, + PROPERTY_SEARCH_FLAGS_SEARCH_INSTANCE_DECL = 4, + PROPERTY_SEARCH_FLAGS_SEARCH_STATIC_METHOD = 8, + PROPERTY_SEARCH_FLAGS_SEARCH_STATIC_FIELD = 16, + PROPERTY_SEARCH_FLAGS_SEARCH_STATIC_DECL = 32, + PROPERTY_SEARCH_FLAGS_SEARCH_IN_BASE = 64, + PROPERTY_SEARCH_FLAGS_SEARCH_IN_INTERFACES = 128, + PROPERTY_SEARCH_FLAGS_IGNORE_ABSTRACT = 256, + PROPERTY_SEARCH_FLAGS_ALLOW_FUNCTIONAL_INTERFACE = 512, + PROPERTY_SEARCH_FLAGS_DISALLOW_SYNTHETIC_METHOD_CREATION = 1024, + PROPERTY_SEARCH_FLAGS_IS_SETTER = 2048, + PROPERTY_SEARCH_FLAGS_IS_GETTER = 4096, + PROPERTY_SEARCH_FLAGS_IGNORE_OVERLOAD = 8192, + PROPERTY_SEARCH_FLAGS_SEARCH_INSTANCE = 7, + PROPERTY_SEARCH_FLAGS_SEARCH_STATIC = 56, + PROPERTY_SEARCH_FLAGS_SEARCH_METHOD = 9, + PROPERTY_SEARCH_FLAGS_SEARCH_FIELD = 18, + PROPERTY_SEARCH_FLAGS_SEARCH_DECL = 36, + PROPERTY_SEARCH_FLAGS_SEARCH_ALL = 63 +} +export enum Es2pandaPropertyType { + PROPERTY_TYPE_INSTANCE_METHOD = 0, + PROPERTY_TYPE_INSTANCE_FIELD = 1, + PROPERTY_TYPE_INSTANCE_DECL = 2, + PROPERTY_TYPE_STATIC_METHOD = 3, + PROPERTY_TYPE_STATIC_FIELD = 4, + PROPERTY_TYPE_STATIC_DECL = 5, + PROPERTY_TYPE_COUNT = 6 +} +export enum Es2pandaVariableDeclarationKind { + VARIABLE_DECLARATION_KIND_CONST = 0, + VARIABLE_DECLARATION_KIND_LET = 1, + VARIABLE_DECLARATION_KIND_VAR = 2 +} +export enum Es2pandaAccessibilityOption { + ACCESSIBILITY_OPTION_NO_OPTS = 0, + ACCESSIBILITY_OPTION_PUBLIC = 1, + ACCESSIBILITY_OPTION_PRIVATE = 2, + ACCESSIBILITY_OPTION_PROTECTED = 3 +} +export enum Es2pandaRetentionPolicy { + RETENTION_POLICY_SOURCE = 0, + RETENTION_POLICY_BYTECODE = 1, + RETENTION_POLICY_RUNTIME = 2 +} +export enum Es2pandaRecordTableFlags { + RECORD_TABLE_FLAGS_NONE = 0, + RECORD_TABLE_FLAGS_EXTERNAL = 1 +} +export enum Es2pandaCheckerStatus { + CHECKER_STATUS_NO_OPTS = 0, + CHECKER_STATUS_FORCE_TUPLE = 1, + CHECKER_STATUS_IN_CONST_CONTEXT = 2, + CHECKER_STATUS_KEEP_LITERAL_TYPE = 4, + CHECKER_STATUS_IN_PARAMETER = 8, + CHECKER_STATUS_IN_CLASS = 16, + CHECKER_STATUS_IN_INTERFACE = 32, + CHECKER_STATUS_IN_ABSTRACT = 64, + CHECKER_STATUS_IN_STATIC_CONTEXT = 128, + CHECKER_STATUS_IN_CONSTRUCTOR = 256, + CHECKER_STATUS_IN_STATIC_BLOCK = 512, + CHECKER_STATUS_INNER_CLASS = 1024, + CHECKER_STATUS_IN_ENUM = 2048, + CHECKER_STATUS_BUILTINS_INITIALIZED = 4096, + CHECKER_STATUS_IN_LAMBDA = 8192, + CHECKER_STATUS_IGNORE_VISIBILITY = 16384, + CHECKER_STATUS_IN_EXTENSION_METHOD = 32768, + CHECKER_STATUS_IN_LOCAL_CLASS = 65536, + CHECKER_STATUS_IN_INSTANCEOF_CONTEXT = 131072, + CHECKER_STATUS_IN_TEST_EXPRESSION = 262144, + CHECKER_STATUS_IN_LOOP = 524288, + CHECKER_STATUS_MEET_RETURN = 1048576, + CHECKER_STATUS_MEET_BREAK = 2097152, + CHECKER_STATUS_MEET_CONTINUE = 4194304, + CHECKER_STATUS_MEET_THROW = 8388608, + CHECKER_STATUS_IN_EXTERNAL = 16777216, + CHECKER_STATUS_IN_BRIDGE_TEST = 33554432, + CHECKER_STATUS_IN_GETTER = 67108864, + CHECKER_STATUS_IN_SETTER = 134217728, + CHECKER_STATUS_IN_EXTENSION_ACCESSOR_CHECK = 268435456, + CHECKER_STATUS_IN_TYPE_INFER = 536870912 +} +export enum Es2pandaOverrideErrorCode { + OVERRIDE_ERROR_CODE_NO_ERROR = 0, + OVERRIDE_ERROR_CODE_OVERRIDDEN_FINAL = 1, + OVERRIDE_ERROR_CODE_INCOMPATIBLE_RETURN = 2, + OVERRIDE_ERROR_CODE_INCOMPATIBLE_TYPEPARAM = 3, + OVERRIDE_ERROR_CODE_OVERRIDDEN_WEAKER = 4, + OVERRIDE_ERROR_CODE_OVERRIDDEN_INTERNAL = 5, + OVERRIDE_ERROR_CODE_ABSTRACT_OVERRIDES_CONCRETE = 6 +} +export enum Es2pandaResolvedKind { + RESOLVED_KIND_PROPERTY = 0, + RESOLVED_KIND_EXTENSION_FUNCTION = 1, + RESOLVED_KIND_EXTENSION_ACCESSOR = 2 +} +export enum Es2pandaLexicalScopeType { + LEXICAL_SCOPE_TYPE_BLOCK = 0, + LEXICAL_SCOPE_TYPE_STRICT_BLOCK = 1, + LEXICAL_SCOPE_TYPE_CATCH = 2, + LEXICAL_SCOPE_TYPE_FUNCTION_PARAM = 3, + LEXICAL_SCOPE_TYPE_TS_TYPE_LITERAL = 4 +} +export enum Es2pandaVariableParsingFlags { + VARIABLE_PARSING_FLAGS_NO_OPTS = 0, + VARIABLE_PARSING_FLAGS_NO_SKIP_VAR_KIND = 1, + VARIABLE_PARSING_FLAGS_ACCEPT_CONST_NO_INIT = 2, + VARIABLE_PARSING_FLAGS_DISALLOW_INIT = 4, + VARIABLE_PARSING_FLAGS_VAR = 8, + VARIABLE_PARSING_FLAGS_LET = 16, + VARIABLE_PARSING_FLAGS_CONST = 32, + VARIABLE_PARSING_FLAGS_STOP_AT_IN = 64, + VARIABLE_PARSING_FLAGS_IN_FOR = 128, + VARIABLE_PARSING_FLAGS_FOR_OF = 256 +} +export enum Es2pandaExpressionParseFlags { + EXPRESSION_PARSE_FLAGS_NO_OPTS = 0, + EXPRESSION_PARSE_FLAGS_ACCEPT_COMMA = 1, + EXPRESSION_PARSE_FLAGS_ACCEPT_REST = 2, + EXPRESSION_PARSE_FLAGS_EXP_DISALLOW_AS = 4, + EXPRESSION_PARSE_FLAGS_DISALLOW_ASSIGNMENT = 8, + EXPRESSION_PARSE_FLAGS_DISALLOW_YIELD = 16, + EXPRESSION_PARSE_FLAGS_STOP_AT_IN = 32, + EXPRESSION_PARSE_FLAGS_MUST_BE_PATTERN = 64, + EXPRESSION_PARSE_FLAGS_POTENTIALLY_IN_PATTERN = 128, + EXPRESSION_PARSE_FLAGS_OBJECT_PATTERN = 256, + EXPRESSION_PARSE_FLAGS_IN_REST = 512, + EXPRESSION_PARSE_FLAGS_IMPORT = 1024, + EXPRESSION_PARSE_FLAGS_POTENTIAL_CLASS_LITERAL = 2048, + EXPRESSION_PARSE_FLAGS_IN_FOR = 4096, + EXPRESSION_PARSE_FLAGS_INSTANCEOF = 8192, + EXPRESSION_PARSE_FLAGS_POTENTIAL_NEW_ARRAY = 16384 +} +export enum Es2pandaStatementParsingFlags { + STATEMENT_PARSING_FLAGS_NONE = 0, + STATEMENT_PARSING_FLAGS_ALLOW_LEXICAL = 1, + STATEMENT_PARSING_FLAGS_GLOBAL = 2, + STATEMENT_PARSING_FLAGS_IF_ELSE = 4, + STATEMENT_PARSING_FLAGS_LABELLED = 8, + STATEMENT_PARSING_FLAGS_INIT_MODULE = 16, + STATEMENT_PARSING_FLAGS_STMT_LEXICAL_SCOPE_NEEDED = 12, + STATEMENT_PARSING_FLAGS_STMT_GLOBAL_LEXICAL = 3 +} +export enum Es2pandaForStatementKind { + FOR_STATEMENT_KIND_UPDATE = 0, + FOR_STATEMENT_KIND_IN = 1, + FOR_STATEMENT_KIND_OF = 2 +} +export enum Es2pandaTypeAnnotationParsingOptions { + TYPE_ANNOTATION_PARSING_OPTIONS_NO_OPTS = 0, + TYPE_ANNOTATION_PARSING_OPTIONS_IN_UNION = 1, + TYPE_ANNOTATION_PARSING_OPTIONS_ALLOW_CONST = 2, + TYPE_ANNOTATION_PARSING_OPTIONS_IN_INTERSECTION = 4, + TYPE_ANNOTATION_PARSING_OPTIONS_RESTRICT_EXTENDS = 8, + TYPE_ANNOTATION_PARSING_OPTIONS_REPORT_ERROR = 16, + TYPE_ANNOTATION_PARSING_OPTIONS_CAN_BE_TS_TYPE_PREDICATE = 32, + TYPE_ANNOTATION_PARSING_OPTIONS_BREAK_AT_NEW_LINE = 64, + TYPE_ANNOTATION_PARSING_OPTIONS_RETURN_TYPE = 128, + TYPE_ANNOTATION_PARSING_OPTIONS_POTENTIAL_CLASS_LITERAL = 256, + TYPE_ANNOTATION_PARSING_OPTIONS_ALLOW_INTERSECTION = 512, + TYPE_ANNOTATION_PARSING_OPTIONS_ADD_TYPE_PARAMETER_BINDING = 1024, + TYPE_ANNOTATION_PARSING_OPTIONS_DISALLOW_PRIMARY_TYPE = 2048, + TYPE_ANNOTATION_PARSING_OPTIONS_ALLOW_WILDCARD = 4096, + TYPE_ANNOTATION_PARSING_OPTIONS_IGNORE_FUNCTION_TYPE = 8192, + TYPE_ANNOTATION_PARSING_OPTIONS_ALLOW_DECLARATION_SITE_VARIANCE = 16384, + TYPE_ANNOTATION_PARSING_OPTIONS_DISALLOW_UNION = 32768, + TYPE_ANNOTATION_PARSING_OPTIONS_POTENTIAL_NEW_ARRAY = 65536, + TYPE_ANNOTATION_PARSING_OPTIONS_ANNOTATION_NOT_ALLOW = 131072, + TYPE_ANNOTATION_PARSING_OPTIONS_INSTANCEOF = 262144, + TYPE_ANNOTATION_PARSING_OPTIONS_TYPE_ALIAS_CONTEXT = 524288 +} +export enum Es2pandaScriptKind { + SCRIPT_KIND_SCRIPT = 0, + SCRIPT_KIND_MODULE = 1, + SCRIPT_KIND_STDLIB = 2, + SCRIPT_KIND_GENEXTERNAL = 3 +} +export enum Es2pandaProgramFlags { + PROGRAM_FLAGS_NONE = 0, + PROGRAM_FLAGS_AST_CHECKED = 1, + PROGRAM_FLAGS_AST_CHECK_PROCESSED = 2, + PROGRAM_FLAGS_AST_ENUM_LOWERED = 4, + PROGRAM_FLAGS_AST_BOXED_TYPE_LOWERED = 8, + PROGRAM_FLAGS_AST_CONSTANT_EXPRESSION_LOWERED = 16, + PROGRAM_FLAGS_AST_STRING_CONSTANT_LOWERED = 32, + PROGRAM_FLAGS_AST_IDENTIFIER_ANALYZED = 64, + PROGRAM_FLAGS_AST_HAS_SCOPES_INITIALIZED = 128, + PROGRAM_FLAGS_AST_HAS_OPTIONAL_PARAMETER_ANNOTATION = 256 +} +export enum Es2pandaCompilationMode { + COMPILATION_MODE_GEN_STD_LIB = 0, + COMPILATION_MODE_PROJECT = 1, + COMPILATION_MODE_SINGLE_FILE = 2, + COMPILATION_MODE_GEN_ABC_FOR_EXTERNAL_SOURCE = 3 +} +export enum Es2pandaImportFlags { + IMPORT_FLAGS_NONE = 0, + IMPORT_FLAGS_DEFAULT_IMPORT = 1, + IMPORT_FLAGS_IMPLICIT_PACKAGE_IMPORT = 2, + IMPORT_FLAGS_EXTERNAL_BINARY_IMPORT = 4, + IMPORT_FLAGS_EXTERNAL_SOURCE_IMPORT = 8 +} +export enum Es2pandaModuleKind { + MODULE_KIND_MODULE = 0, + MODULE_KIND_DECLARATION = 1, + MODULE_KIND_PACKAGE = 2 +} diff --git a/ets1.2/libarkts/src/generated/Es2pandaNativeModule.ts b/ets1.2/libarkts/src/generated/Es2pandaNativeModule.ts new file mode 100644 index 0000000000000000000000000000000000000000..7edba643d667acac1b2db21b6ae18473bfee47fa --- /dev/null +++ b/ets1.2/libarkts/src/generated/Es2pandaNativeModule.ts @@ -0,0 +1,5192 @@ +/* + * 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + KNativePointer, + KStringPtr, + KUInt, + KInt, + KBoolean, + KDouble, + KFloat, + KLong +} from "@koalaui/interop" + +// Improve: this type should be in interop +export type KNativePointerArray = BigUint64Array + +export class Es2pandaNativeModule { + _GetAllErrorMessages(context: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProceedToState(context: KNativePointer, state: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ContextState(context: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _ContextErrorMessage(context: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ContextProgram(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateSourcePosition(context: KNativePointer, index: KUInt, line: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateSourceRange(context: KNativePointer, start: KNativePointer, end: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _SourcePositionIndex(context: KNativePointer, position: KNativePointer): KUInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _SourcePositionLine(context: KNativePointer, position: KNativePointer): KUInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _SourceRangeStart(context: KNativePointer, range: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _SourceRangeEnd(context: KNativePointer, range: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _LogDiagnosticWithSuggestion(context: KNativePointer, diagnosticInfo: KNativePointer, suggestionInfo: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsAnyError(context: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeRecheck(context: KNativePointer, node: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _Es2pandaEnumFromString(context: KNativePointer, str: KStringPtr): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _Es2pandaEnumToString(context: KNativePointer, id: KInt): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _DeclarationFromIdentifier(context: KNativePointer, node: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsImportTypeKind(context: KNativePointer, node: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _JsdocStringFromDeclaration(context: KNativePointer, node: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _GetLicenseFromRootNode(context: KNativePointer, node: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _FirstDeclarationByNameFromNode(context: KNativePointer, node: KNativePointer, name: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FirstDeclarationByNameFromProgram(context: KNativePointer, program: KNativePointer, name: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AllDeclarationsByNameFromNode(context: KNativePointer, node: KNativePointer, name: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AllDeclarationsByNameFromProgram(context: KNativePointer, program: KNativePointer, name: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _InsertETSImportDeclarationAndParse(context: KNativePointer, program: KNativePointer, node: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _GenerateStaticDeclarationsFromContext(context: KNativePointer, outputPath: KStringPtr): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsArrowFunctionExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsAnnotationDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsAnnotationUsage(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsAssertStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsAwaitExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsBigIntLiteral(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsBinaryExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsBlockStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsBooleanLiteral(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsBreakStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsCallExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsCatchClause(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsChainExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsCharLiteral(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsClassDefinition(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsClassDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsClassExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsClassProperty(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsClassStaticBlock(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsConditionalExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsContinueStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsDebuggerStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsDecorator(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsDirectEvalExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsDoWhileStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsEmptyStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsExportAllDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsExportDefaultDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsExportNamedDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsExportSpecifier(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsExpressionStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsForInStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsForOfStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsForUpdateStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsFunctionDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsFunctionExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsIdentifier(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsDummyNode(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsIfStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsImportDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsImportExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsImportDefaultSpecifier(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsImportNamespaceSpecifier(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsImportSpecifier(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsLabelledStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsMemberExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsMetaProperty(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsMethodDefinition(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsNamedType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsNewExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsNullLiteral(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsUndefinedLiteral(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsNumberLiteral(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsOmittedExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsOverloadDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsPrefixAssertionExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsProperty(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsRegExpLiteral(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSReExportDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsReturnStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsScriptFunction(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsSequenceExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsStringLiteral(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSNonNullishTypeNode(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSNullType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSUndefinedType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSNeverType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSStringLiteralType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSIntrinsicNode(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSFunctionType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSWildcardType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSPrimitiveType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSPackageDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSClassLiteral(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSTypeReference(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSTypeReferencePart(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSUnionType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSKeyofType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSNewArrayInstanceExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSNewMultiDimArrayInstanceExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSNewClassInstanceExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSImportDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSParameterExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSTuple(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSModule(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsSuperExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsETSStructDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsSwitchCaseStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsSwitchStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSEnumDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSEnumMember(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSExternalModuleReference(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSNumberKeyword(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSAnyKeyword(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSStringKeyword(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSBooleanKeyword(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSVoidKeyword(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSUndefinedKeyword(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSUnknownKeyword(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSObjectKeyword(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSBigintKeyword(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSNeverKeyword(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSNonNullExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSNullKeyword(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSArrayType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSUnionType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSTypeLiteral(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSPropertySignature(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSMethodSignature(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSSignatureDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSParenthesizedType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSLiteralType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSInferType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSConditionalType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSImportType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSIntersectionType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSMappedType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSModuleBlock(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSThisType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSTypeOperator(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSTypeParameter(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSTypeParameterDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSTypeParameterInstantiation(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSTypePredicate(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSParameterProperty(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSModuleDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSImportEqualsDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSFunctionType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSConstructorType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSTypeAliasDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSTypeReference(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSQualifiedName(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSIndexedAccessType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSInterfaceDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSInterfaceBody(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSInterfaceHeritage(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSTupleType(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSNamedTupleMember(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSIndexSignature(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSTypeQuery(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSAsExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSClassImplements(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTSTypeAssertion(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTaggedTemplateExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTemplateElement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTemplateLiteral(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsThisExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTypeofExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsThrowStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsTryStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsUnaryExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsUpdateExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsVariableDeclaration(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsVariableDeclarator(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsWhileStatement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsYieldExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsOpaqueTypeNode(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsBlockExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsBrokenTypeNode(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsArrayExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsArrayPattern(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsAssignmentExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsAssignmentPattern(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsObjectExpression(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsObjectPattern(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsSpreadElement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IsRestElement(ast: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeName(ast: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateNumberLiteral(context: KNativePointer, value: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateNumberLiteral1(context: KNativePointer, value: KLong): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateNumberLiteral2(context: KNativePointer, value: KDouble): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateNumberLiteral3(context: KNativePointer, value: KFloat): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateNumberLiteral(context: KNativePointer, original: KNativePointer, value: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateNumberLiteral1(context: KNativePointer, original: KNativePointer, value: KLong): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateNumberLiteral2(context: KNativePointer, original: KNativePointer, value: KDouble): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateNumberLiteral3(context: KNativePointer, original: KNativePointer, value: KFloat): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _NumberLiteralStrConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateLabelledStatement(context: KNativePointer, ident: KNativePointer, body: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateLabelledStatement(context: KNativePointer, original: KNativePointer, ident: KNativePointer, body: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _LabelledStatementBody(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _LabelledStatementBodyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _LabelledStatementIdentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _LabelledStatementIdent(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _LabelledStatementGetReferencedStatementConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateThrowStatement(context: KNativePointer, argument: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateThrowStatement(context: KNativePointer, original: KNativePointer, argument: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ThrowStatementArgumentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateClassProperty(context: KNativePointer, key: KNativePointer, value: KNativePointer, typeAnnotation: KNativePointer, modifiers: KInt, isComputed: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateClassProperty(context: KNativePointer, original: KNativePointer, key: KNativePointer, value: KNativePointer, typeAnnotation: KNativePointer, modifiers: KInt, isComputed: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassPropertyIsDefaultAccessModifierConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassPropertySetDefaultAccessModifier(context: KNativePointer, receiver: KNativePointer, isDefault: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassPropertyTypeAnnotationConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassPropertySetTypeAnnotation(context: KNativePointer, receiver: KNativePointer, typeAnnotation: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassPropertyNeedInitInStaticBlockConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassPropertySetNeedInitInStaticBlock(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassPropertyIsImmediateInitConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassPropertySetIsImmediateInit(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassPropertyHasAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassPropertyEmplaceAnnotation(context: KNativePointer, receiver: KNativePointer, source: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassPropertyClearAnnotations(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassPropertyDumpAnnotationsConst(context: KNativePointer, receiver: KNativePointer, dumper: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassPropertyAnnotationsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassPropertyAnnotations(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassPropertyAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassPropertySetAnnotations(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassPropertySetAnnotations1(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSVoidKeyword(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSVoidKeyword(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSFunctionType(context: KNativePointer, signature: KNativePointer, funcFlags: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSFunctionType(context: KNativePointer, original: KNativePointer, signature: KNativePointer, funcFlags: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSFunctionTypeTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSFunctionTypeTypeParams(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSFunctionTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSFunctionTypeSetParams(context: KNativePointer, receiver: KNativePointer, paramsList: BigUint64Array, paramsListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSFunctionTypeReturnTypeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSFunctionTypeReturnType(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSFunctionTypeFunctionalInterface(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSFunctionTypeFunctionalInterfaceConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSFunctionTypeSetFunctionalInterface(context: KNativePointer, receiver: KNativePointer, functionalInterface: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSFunctionTypeFlags(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSFunctionTypeFlagsConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSFunctionTypeIsExtensionFunctionConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSTypeOperator(context: KNativePointer, type: KNativePointer, operatorType: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSTypeOperator(context: KNativePointer, original: KNativePointer, type: KNativePointer, operatorType: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeOperatorTypeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeOperatorIsReadonlyConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeOperatorIsKeyofConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeOperatorIsUniqueConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateIfStatement(context: KNativePointer, test: KNativePointer, consequent: KNativePointer, alternate: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateIfStatement(context: KNativePointer, original: KNativePointer, test: KNativePointer, consequent: KNativePointer, alternate: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _IfStatementTestConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _IfStatementTest(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _IfStatementSetTest(context: KNativePointer, receiver: KNativePointer, test: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _IfStatementConsequentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _IfStatementConsequent(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _IfStatementAlternate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _IfStatementAlternateConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _IfStatementSetAlternate(context: KNativePointer, receiver: KNativePointer, alternate: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSConstructorType(context: KNativePointer, signature: KNativePointer, abstract: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSConstructorType(context: KNativePointer, original: KNativePointer, signature: KNativePointer, abstract: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSConstructorTypeTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSConstructorTypeTypeParams(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSConstructorTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSConstructorTypeReturnTypeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSConstructorTypeReturnType(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSConstructorTypeAbstractConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateDecorator(context: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateDecorator(context: KNativePointer, original: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _DecoratorExprConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSEnumDeclaration(context: KNativePointer, key: KNativePointer, members: BigUint64Array, membersSequenceLength: KUInt, isConst: KBoolean, isStatic: KBoolean, isDeclare: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSEnumDeclaration(context: KNativePointer, original: KNativePointer, key: KNativePointer, members: BigUint64Array, membersSequenceLength: KUInt, isConst: KBoolean, isStatic: KBoolean, isDeclare: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSEnumDeclaration1(context: KNativePointer, key: KNativePointer, members: BigUint64Array, membersSequenceLength: KUInt, isConst: KBoolean, isStatic: KBoolean, isDeclare: KBoolean, typeNode: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSEnumDeclaration1(context: KNativePointer, original: KNativePointer, key: KNativePointer, members: BigUint64Array, membersSequenceLength: KUInt, isConst: KBoolean, isStatic: KBoolean, isDeclare: KBoolean, typeNode: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumDeclarationKeyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumDeclarationTypeNodes(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumDeclarationKey(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumDeclarationMembersConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumDeclarationInternalNameConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumDeclarationSetInternalName(context: KNativePointer, receiver: KNativePointer, internalName: KStringPtr): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumDeclarationBoxedClassConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumDeclarationSetBoxedClass(context: KNativePointer, receiver: KNativePointer, boxedClass: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumDeclarationIsConstConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumDeclarationEmplaceMembers(context: KNativePointer, receiver: KNativePointer, source: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumDeclarationClearMembers(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumDeclarationSetValueMembers(context: KNativePointer, receiver: KNativePointer, source: KNativePointer, index: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumDeclarationMembersForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSNeverKeyword(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSNeverKeyword(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateImportDefaultSpecifier(context: KNativePointer, local: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateImportDefaultSpecifier(context: KNativePointer, original: KNativePointer, local: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportDefaultSpecifierLocalConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportDefaultSpecifierLocal(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateObjectExpression(context: KNativePointer, nodeType: KInt, properties: BigUint64Array, propertiesSequenceLength: KUInt, trailingComma: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateObjectExpression(context: KNativePointer, original: KNativePointer, nodeType: KInt, properties: BigUint64Array, propertiesSequenceLength: KUInt, trailingComma: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ObjectExpressionPropertiesConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ObjectExpressionIsDeclarationConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ObjectExpressionIsOptionalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ObjectExpressionValidateExpression(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ObjectExpressionConvertibleToObjectPattern(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ObjectExpressionSetDeclaration(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ObjectExpressionSetOptional(context: KNativePointer, receiver: KNativePointer, optional_arg: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ObjectExpressionTypeAnnotationConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ObjectExpressionSetTsTypeAnnotation(context: KNativePointer, receiver: KNativePointer, typeAnnotation: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateImportSpecifier(context: KNativePointer, imported: KNativePointer, local: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateImportSpecifier(context: KNativePointer, original: KNativePointer, imported: KNativePointer, local: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportSpecifierImported(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportSpecifierImportedConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportSpecifierLocal(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportSpecifierLocalConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportSpecifierIsRemovableConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportSpecifierSetRemovable(context: KNativePointer, receiver: KNativePointer, isRemovable: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateConditionalExpression(context: KNativePointer, test: KNativePointer, consequent: KNativePointer, alternate: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateConditionalExpression(context: KNativePointer, original: KNativePointer, test: KNativePointer, consequent: KNativePointer, alternate: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ConditionalExpressionTestConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ConditionalExpressionTest(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ConditionalExpressionSetTest(context: KNativePointer, receiver: KNativePointer, expr: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ConditionalExpressionConsequentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ConditionalExpressionConsequent(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ConditionalExpressionSetConsequent(context: KNativePointer, receiver: KNativePointer, expr: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ConditionalExpressionAlternateConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ConditionalExpressionAlternate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ConditionalExpressionSetAlternate(context: KNativePointer, receiver: KNativePointer, expr: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateCallExpression(context: KNativePointer, callee: KNativePointer, _arguments: BigUint64Array, _argumentsSequenceLength: KUInt, typeParams: KNativePointer, optional_arg: KBoolean, trailingComma: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateCallExpression1(context: KNativePointer, other: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateCallExpression1(context: KNativePointer, original: KNativePointer, other: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionCalleeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionCallee(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionSetCallee(context: KNativePointer, receiver: KNativePointer, callee: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionTypeParams(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionArgumentsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionArguments(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionSetArguments(context: KNativePointer, receiver: KNativePointer, argumentsList: BigUint64Array, argumentsListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionHasTrailingCommaConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionSetTypeParams(context: KNativePointer, receiver: KNativePointer, typeParams: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionSetTrailingBlock(context: KNativePointer, receiver: KNativePointer, block: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionIsExtensionAccessorCall(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionTrailingBlockConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionSetIsTrailingBlockInNewLine(context: KNativePointer, receiver: KNativePointer, isNewLine: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionIsTrailingBlockInNewLineConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionSetIsTrailingCall(context: KNativePointer, receiver: KNativePointer, isTrailingCall: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionIsTrailingCallConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionIsETSConstructorCallConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CallExpressionIsDynamicCallConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateBigIntLiteral(context: KNativePointer, src: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateBigIntLiteral(context: KNativePointer, original: KNativePointer, src: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BigIntLiteralStrConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassElementId(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassElementIdConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassElementKey(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassElementKeyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassElementValue(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassElementSetValue(context: KNativePointer, receiver: KNativePointer, value: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassElementValueConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassElementOriginEnumMemberConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassElementSetOrigEnumMember(context: KNativePointer, receiver: KNativePointer, enumMember: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassElementIsPrivateElementConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassElementIsComputedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassElementToPrivateFieldKindConst(context: KNativePointer, receiver: KNativePointer, isStatic: KBoolean): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSImportType(context: KNativePointer, param: KNativePointer, typeParams: KNativePointer, qualifier: KNativePointer, isTypeof: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSImportType(context: KNativePointer, original: KNativePointer, param: KNativePointer, typeParams: KNativePointer, qualifier: KNativePointer, isTypeof: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSImportTypeParamConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSImportTypeTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSImportTypeQualifierConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSImportTypeIsTypeofConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTaggedTemplateExpression(context: KNativePointer, tag: KNativePointer, quasi: KNativePointer, typeParams: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTaggedTemplateExpression(context: KNativePointer, original: KNativePointer, tag: KNativePointer, quasi: KNativePointer, typeParams: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TaggedTemplateExpressionTagConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TaggedTemplateExpressionQuasiConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TaggedTemplateExpressionTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateFunctionDeclaration(context: KNativePointer, func: KNativePointer, annotations: BigUint64Array, annotationsSequenceLength: KUInt, isAnonymous: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateFunctionDeclaration(context: KNativePointer, original: KNativePointer, func: KNativePointer, annotations: BigUint64Array, annotationsSequenceLength: KUInt, isAnonymous: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateFunctionDeclaration1(context: KNativePointer, func: KNativePointer, isAnonymous: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateFunctionDeclaration1(context: KNativePointer, original: KNativePointer, func: KNativePointer, isAnonymous: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionDeclarationFunction(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionDeclarationIsAnonymousConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionDeclarationFunctionConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionDeclarationHasAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionDeclarationEmplaceAnnotation(context: KNativePointer, receiver: KNativePointer, source: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionDeclarationClearAnnotations(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionDeclarationDumpAnnotationsConst(context: KNativePointer, receiver: KNativePointer, dumper: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionDeclarationAnnotationsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionDeclarationAnnotations(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionDeclarationAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionDeclarationSetAnnotations(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionDeclarationSetAnnotations1(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSTypeReference(context: KNativePointer, part: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSTypeReference(context: KNativePointer, original: KNativePointer, part: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSTypeReferencePart(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSTypeReferencePartConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSTypeReferenceBaseNameConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSTypeReference(context: KNativePointer, typeName: KNativePointer, typeParams: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSTypeReference(context: KNativePointer, original: KNativePointer, typeName: KNativePointer, typeParams: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeReferenceTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeReferenceTypeNameConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeReferenceBaseNameConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateNamedType(context: KNativePointer, name: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateNamedType(context: KNativePointer, original: KNativePointer, name: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _NamedTypeNameConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _NamedTypeTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _NamedTypeIsNullableConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _NamedTypeSetNullable(context: KNativePointer, receiver: KNativePointer, nullable: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _NamedTypeSetNext(context: KNativePointer, receiver: KNativePointer, next: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _NamedTypeSetTypeParams(context: KNativePointer, receiver: KNativePointer, typeParams: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSFunctionType(context: KNativePointer, signature: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSFunctionType(context: KNativePointer, original: KNativePointer, signature: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSFunctionTypeTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSFunctionTypeTypeParams(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSFunctionTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSFunctionTypeReturnTypeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSFunctionTypeReturnType(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSFunctionTypeSetNullable(context: KNativePointer, receiver: KNativePointer, nullable: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTemplateElement(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTemplateElement(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTemplateElement1(context: KNativePointer, raw: KStringPtr, cooked: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTemplateElement1(context: KNativePointer, original: KNativePointer, raw: KStringPtr, cooked: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TemplateElementRawConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _TemplateElementCookedConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSInterfaceDeclaration(context: KNativePointer, _extends: BigUint64Array, _extendsSequenceLength: KUInt, id: KNativePointer, typeParams: KNativePointer, body: KNativePointer, isStatic: KBoolean, isExternal: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSInterfaceDeclaration(context: KNativePointer, original: KNativePointer, _extends: BigUint64Array, _extendsSequenceLength: KUInt, id: KNativePointer, typeParams: KNativePointer, body: KNativePointer, isStatic: KBoolean, isExternal: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationBody(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationBodyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationId(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationIdConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationInternalNameConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationSetInternalName(context: KNativePointer, receiver: KNativePointer, internalName: KStringPtr): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationIsStaticConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationIsFromExternalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationTypeParams(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationExtends(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationExtendsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationExtendsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationGetAnonClass(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationGetAnonClassConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationSetAnonClass(context: KNativePointer, receiver: KNativePointer, anonClass: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationEmplaceExtends(context: KNativePointer, receiver: KNativePointer, _extends: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationClearExtends(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationSetValueExtends(context: KNativePointer, receiver: KNativePointer, _extends: KNativePointer, index: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationHasAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationEmplaceAnnotation(context: KNativePointer, receiver: KNativePointer, source: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationClearAnnotations(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationDumpAnnotationsConst(context: KNativePointer, receiver: KNativePointer, dumper: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationAnnotationsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationAnnotations(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationSetAnnotations(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceDeclarationSetAnnotations1(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateVariableDeclaration(context: KNativePointer, kind: KInt, declarators: BigUint64Array, declaratorsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateVariableDeclaration(context: KNativePointer, original: KNativePointer, kind: KInt, declarators: BigUint64Array, declaratorsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclarationDeclaratorsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclarationDeclarators(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclarationDeclaratorsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclarationKindConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclarationGetDeclaratorByNameConst(context: KNativePointer, receiver: KNativePointer, name: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclarationHasAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclarationEmplaceAnnotation(context: KNativePointer, receiver: KNativePointer, source: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclarationClearAnnotations(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclarationDumpAnnotationsConst(context: KNativePointer, receiver: KNativePointer, dumper: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclarationAnnotationsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclarationAnnotations(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclarationAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclarationSetAnnotations(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclarationSetAnnotations1(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateUndefinedLiteral(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateUndefinedLiteral(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateMemberExpression(context: KNativePointer, object_arg: KNativePointer, property: KNativePointer, kind: KInt, computed: KBoolean, optional_arg: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateMemberExpression(context: KNativePointer, original: KNativePointer, object_arg: KNativePointer, property: KNativePointer, kind: KInt, computed: KBoolean, optional_arg: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _MemberExpressionObject(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _MemberExpressionObjectConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _MemberExpressionSetObject(context: KNativePointer, receiver: KNativePointer, object_arg: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _MemberExpressionSetProperty(context: KNativePointer, receiver: KNativePointer, prop: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _MemberExpressionProperty(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _MemberExpressionPropertyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _MemberExpressionIsComputedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _MemberExpressionKindConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _MemberExpressionAddMemberKind(context: KNativePointer, receiver: KNativePointer, kind: KInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _MemberExpressionHasMemberKindConst(context: KNativePointer, receiver: KNativePointer, kind: KInt): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _MemberExpressionRemoveMemberKind(context: KNativePointer, receiver: KNativePointer, kind: KInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _MemberExpressionIsIgnoreBoxConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _MemberExpressionSetIgnoreBox(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _MemberExpressionIsPrivateReferenceConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _MemberExpressionCompileToRegConst(context: KNativePointer, receiver: KNativePointer, pg: KNativePointer, objReg: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _MemberExpressionCompileToRegsConst(context: KNativePointer, receiver: KNativePointer, pg: KNativePointer, object_arg: KNativePointer, property: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSClassImplements(context: KNativePointer, expression: KNativePointer, typeParameters: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSClassImplements(context: KNativePointer, original: KNativePointer, expression: KNativePointer, typeParameters: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSClassImplements1(context: KNativePointer, expression: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSClassImplements1(context: KNativePointer, original: KNativePointer, expression: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSClassImplementsExpr(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSClassImplementsExprConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSClassImplementsTypeParametersConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSObjectKeyword(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSObjectKeyword(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSUnionType(context: KNativePointer, types: BigUint64Array, typesSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSUnionType(context: KNativePointer, original: KNativePointer, types: BigUint64Array, typesSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSUnionTypeTypesConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSUnionTypeSetValueTypesConst(context: KNativePointer, receiver: KNativePointer, type: KNativePointer, index: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSKeyofType(context: KNativePointer, type: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSKeyofType(context: KNativePointer, original: KNativePointer, type: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSKeyofTypeGetTypeRefConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSPropertySignature(context: KNativePointer, key: KNativePointer, typeAnnotation: KNativePointer, computed: KBoolean, optional_arg: KBoolean, readonly_arg: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSPropertySignature(context: KNativePointer, original: KNativePointer, key: KNativePointer, typeAnnotation: KNativePointer, computed: KBoolean, optional_arg: KBoolean, readonly_arg: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSPropertySignatureKeyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSPropertySignatureKey(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSPropertySignatureComputedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSPropertySignatureOptionalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSPropertySignatureReadonlyConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSPropertySignatureTypeAnnotationConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSPropertySignatureSetTsTypeAnnotation(context: KNativePointer, receiver: KNativePointer, typeAnnotation: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSConditionalType(context: KNativePointer, checkType: KNativePointer, extendsType: KNativePointer, trueType: KNativePointer, falseType: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSConditionalType(context: KNativePointer, original: KNativePointer, checkType: KNativePointer, extendsType: KNativePointer, trueType: KNativePointer, falseType: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSConditionalTypeCheckTypeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSConditionalTypeExtendsTypeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSConditionalTypeTrueTypeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSConditionalTypeFalseTypeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSLiteralType(context: KNativePointer, literal: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSLiteralType(context: KNativePointer, original: KNativePointer, literal: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSLiteralTypeLiteralConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSTypeAliasDeclaration(context: KNativePointer, id: KNativePointer, typeParams: KNativePointer, typeAnnotation: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSTypeAliasDeclaration(context: KNativePointer, original: KNativePointer, id: KNativePointer, typeParams: KNativePointer, typeAnnotation: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSTypeAliasDeclaration1(context: KNativePointer, id: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSTypeAliasDeclaration1(context: KNativePointer, original: KNativePointer, id: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAliasDeclarationId(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAliasDeclarationIdConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAliasDeclarationTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAliasDeclarationSetTypeParameters(context: KNativePointer, receiver: KNativePointer, typeParams: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAliasDeclarationClearTypeParamterTypes(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAliasDeclarationTypeAnnotationConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAliasDeclarationSetTsTypeAnnotation(context: KNativePointer, receiver: KNativePointer, typeAnnotation: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAliasDeclarationHasAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAliasDeclarationEmplaceAnnotation(context: KNativePointer, receiver: KNativePointer, source: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAliasDeclarationClearAnnotations(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAliasDeclarationDumpAnnotationsConst(context: KNativePointer, receiver: KNativePointer, dumper: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAliasDeclarationAnnotationsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAliasDeclarationAnnotations(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAliasDeclarationAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAliasDeclarationSetAnnotations(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAliasDeclarationSetAnnotations1(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateDebuggerStatement(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateDebuggerStatement(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateReturnStatement(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateReturnStatement(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateReturnStatement1(context: KNativePointer, argument: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateReturnStatement1(context: KNativePointer, original: KNativePointer, argument: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ReturnStatementArgument(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ReturnStatementArgumentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ReturnStatementSetArgument(context: KNativePointer, receiver: KNativePointer, arg: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ReturnStatementIsAsyncImplReturnConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateExportDefaultDeclaration(context: KNativePointer, decl: KNativePointer, exportEquals: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateExportDefaultDeclaration(context: KNativePointer, original: KNativePointer, decl: KNativePointer, exportEquals: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExportDefaultDeclarationDecl(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExportDefaultDeclarationDeclConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExportDefaultDeclarationIsExportEqualsConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateScriptFunction(context: KNativePointer, databody: KNativePointer, datasignature: KNativePointer, datafuncFlags: KInt, dataflags: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateScriptFunction(context: KNativePointer, original: KNativePointer, databody: KNativePointer, datasignature: KNativePointer, datafuncFlags: KInt, dataflags: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIdConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionId(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionParams(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionReturnStatementsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionReturnStatements(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionReturnStatementsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionTypeParams(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionBodyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionBody(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionAddReturnStatement(context: KNativePointer, receiver: KNativePointer, returnStatement: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionSetBody(context: KNativePointer, receiver: KNativePointer, body: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionReturnTypeAnnotationConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionReturnTypeAnnotation(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionSetReturnTypeAnnotation(context: KNativePointer, receiver: KNativePointer, node: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsEntryPointConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsGeneratorConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsAsyncFuncConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsAsyncImplFuncConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsArrowConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsOverloadConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsExternalOverloadConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsConstructorConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsGetterConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsSetterConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsExtensionAccessorConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsMethodConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsProxyConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsStaticBlockConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsEnumConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsHiddenConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsExternalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsImplicitSuperCallNeededConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionHasBodyConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionHasRestParameterConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionHasReturnStatementConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionHasThrowStatementConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsTrailingLambdaConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsSyntheticConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsDynamicConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionIsExtensionMethodConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionFlagsConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionHasReceiverConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionSetIdent(context: KNativePointer, receiver: KNativePointer, id: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionAddFlag(context: KNativePointer, receiver: KNativePointer, flags: KInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionClearFlag(context: KNativePointer, receiver: KNativePointer, flags: KInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionFormalParamsLengthConst(context: KNativePointer, receiver: KNativePointer): KUInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionSetAsyncPairMethod(context: KNativePointer, receiver: KNativePointer, asyncPairFunction: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionAsyncPairMethodConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionAsyncPairMethod(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionEmplaceReturnStatements(context: KNativePointer, receiver: KNativePointer, returnStatements: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionClearReturnStatements(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionSetValueReturnStatements(context: KNativePointer, receiver: KNativePointer, returnStatements: KNativePointer, index: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionEmplaceParams(context: KNativePointer, receiver: KNativePointer, params: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionSetParams(context: KNativePointer, receiver: KNativePointer, paramsList: BigUint64Array, paramsListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionClearParams(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionSetValueParams(context: KNativePointer, receiver: KNativePointer, params: KNativePointer, index: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionParamsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionHasAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionEmplaceAnnotation(context: KNativePointer, receiver: KNativePointer, source: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionClearAnnotations(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionDumpAnnotationsConst(context: KNativePointer, receiver: KNativePointer, dumper: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionAnnotationsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionAnnotations(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionSetAnnotations(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ScriptFunctionSetAnnotations1(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateClassDefinition(context: KNativePointer, ident: KNativePointer, typeParams: KNativePointer, superTypeParams: KNativePointer, _implements: BigUint64Array, _implementsSequenceLength: KUInt, ctor: KNativePointer, superClass: KNativePointer, body: BigUint64Array, bodySequenceLength: KUInt, modifiers: KInt, flags: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateClassDefinition(context: KNativePointer, original: KNativePointer, ident: KNativePointer, typeParams: KNativePointer, superTypeParams: KNativePointer, _implements: BigUint64Array, _implementsSequenceLength: KUInt, ctor: KNativePointer, superClass: KNativePointer, body: BigUint64Array, bodySequenceLength: KUInt, modifiers: KInt, flags: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateClassDefinition1(context: KNativePointer, ident: KNativePointer, body: BigUint64Array, bodySequenceLength: KUInt, modifiers: KInt, flags: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateClassDefinition1(context: KNativePointer, original: KNativePointer, ident: KNativePointer, body: BigUint64Array, bodySequenceLength: KUInt, modifiers: KInt, flags: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateClassDefinition2(context: KNativePointer, ident: KNativePointer, modifiers: KInt, flags: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateClassDefinition2(context: KNativePointer, original: KNativePointer, ident: KNativePointer, modifiers: KInt, flags: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIdentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIdent(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetIdent(context: KNativePointer, receiver: KNativePointer, ident: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionInternalNameConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSuper(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSuperConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetSuper(context: KNativePointer, receiver: KNativePointer, superClass: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIsGlobalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIsLocalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIsExternConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIsFromExternalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIsInnerConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIsGlobalInitializedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIsClassDefinitionCheckedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIsAnonymousConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIsIntEnumTransformedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIsStringEnumTransformedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIsEnumTransformedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIsNamespaceTransformedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIsLazyImportObjectClassConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIsFromStructConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIsInitInCctorConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionIsModuleConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetGlobalInitialized(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetInnerModifier(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetClassDefinitionChecked(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetAnonymousModifier(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetNamespaceTransformed(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetLazyImportObjectClass(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetFromStructModifier(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetInitInCctor(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionModifiersConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionAddProperties(context: KNativePointer, receiver: KNativePointer, body: BigUint64Array, bodySequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionBodyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionCtor(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionImplementsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionTypeParams(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSuperTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSuperTypeParams(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionLocalTypeCounter(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionLocalIndexConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionFunctionalReferenceReferencedMethodConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetFunctionalReferenceReferencedMethod(context: KNativePointer, receiver: KNativePointer, functionalReferenceReferencedMethod: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionLocalPrefixConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionOrigEnumDeclConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionGetAnonClass(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionCtorConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionHasPrivateMethodConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionHasNativeMethodConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionHasComputedInstanceFieldConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionHasMatchingPrivateKeyConst(context: KNativePointer, receiver: KNativePointer, name: KStringPtr): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionAddToExportedClasses(context: KNativePointer, receiver: KNativePointer, cls: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetModifiers(context: KNativePointer, receiver: KNativePointer, modifiers: KInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionEmplaceBody(context: KNativePointer, receiver: KNativePointer, body: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionClearBody(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetValueBody(context: KNativePointer, receiver: KNativePointer, body: KNativePointer, index: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionBody(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionBodyForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionEmplaceImplements(context: KNativePointer, receiver: KNativePointer, _implements: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionClearImplements(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetValueImplements(context: KNativePointer, receiver: KNativePointer, _implements: KNativePointer, index: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionImplements(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionImplementsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetCtor(context: KNativePointer, receiver: KNativePointer, ctor: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetTypeParams(context: KNativePointer, receiver: KNativePointer, typeParams: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetOrigEnumDecl(context: KNativePointer, receiver: KNativePointer, origEnumDecl: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetAnonClass(context: KNativePointer, receiver: KNativePointer, anonClass: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetInternalName(context: KNativePointer, receiver: KNativePointer, internalName: KStringPtr): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionHasAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionEmplaceAnnotation(context: KNativePointer, receiver: KNativePointer, source: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionClearAnnotations(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionDumpAnnotationsConst(context: KNativePointer, receiver: KNativePointer, dumper: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionAnnotationsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionAnnotations(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetAnnotations(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDefinitionSetAnnotations1(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateArrayExpression(context: KNativePointer, elements: BigUint64Array, elementsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateArrayExpression(context: KNativePointer, original: KNativePointer, elements: BigUint64Array, elementsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateArrayExpression1(context: KNativePointer, nodeType: KInt, elements: BigUint64Array, elementsSequenceLength: KUInt, trailingComma: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateArrayExpression1(context: KNativePointer, original: KNativePointer, nodeType: KInt, elements: BigUint64Array, elementsSequenceLength: KUInt, trailingComma: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrayExpressionGetElementNodeAtIdxConst(context: KNativePointer, receiver: KNativePointer, idx: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrayExpressionElementsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrayExpressionElements(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrayExpressionSetElements(context: KNativePointer, receiver: KNativePointer, elements: BigUint64Array, elementsSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrayExpressionIsDeclarationConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrayExpressionIsOptionalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrayExpressionSetDeclaration(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrayExpressionSetOptional(context: KNativePointer, receiver: KNativePointer, optional_arg: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrayExpressionClearPreferredType(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrayExpressionConvertibleToArrayPattern(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrayExpressionValidateExpression(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrayExpressionTrySetPreferredTypeForNestedArrayExprConst(context: KNativePointer, receiver: KNativePointer, nestedArrayExpr: KNativePointer, idx: KUInt): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrayExpressionTypeAnnotationConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrayExpressionSetTsTypeAnnotation(context: KNativePointer, receiver: KNativePointer, typeAnnotation: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSInterfaceBody(context: KNativePointer, body: BigUint64Array, bodySequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSInterfaceBody(context: KNativePointer, original: KNativePointer, body: BigUint64Array, bodySequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceBodyBody(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceBodyBodyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSTypeQuery(context: KNativePointer, exprName: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSTypeQuery(context: KNativePointer, original: KNativePointer, exprName: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeQueryExprNameConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSBigintKeyword(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSBigintKeyword(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateProperty(context: KNativePointer, key: KNativePointer, value: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateProperty(context: KNativePointer, original: KNativePointer, key: KNativePointer, value: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateProperty1(context: KNativePointer, kind: KInt, key: KNativePointer, value: KNativePointer, isMethod: KBoolean, isComputed: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateProperty1(context: KNativePointer, original: KNativePointer, kind: KInt, key: KNativePointer, value: KNativePointer, isMethod: KBoolean, isComputed: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _PropertyKey(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _PropertyKeyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _PropertyValueConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _PropertyValue(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _PropertyKindConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _PropertyIsMethodConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _PropertyIsShorthandConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _PropertyIsComputedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _PropertyIsAccessorConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _PropertyIsAccessorKind(context: KNativePointer, receiver: KNativePointer, kind: KInt): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _PropertyConvertibleToPatternProperty(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _PropertyValidateExpression(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateVariableDeclarator(context: KNativePointer, flag: KInt, ident: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateVariableDeclarator(context: KNativePointer, original: KNativePointer, flag: KInt, ident: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateVariableDeclarator1(context: KNativePointer, flag: KInt, ident: KNativePointer, init: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateVariableDeclarator1(context: KNativePointer, original: KNativePointer, flag: KInt, ident: KNativePointer, init: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclaratorInit(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclaratorInitConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclaratorSetInit(context: KNativePointer, receiver: KNativePointer, init: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclaratorId(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclaratorIdConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _VariableDeclaratorFlag(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateStringLiteral(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateStringLiteral(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateStringLiteral1(context: KNativePointer, str: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateStringLiteral1(context: KNativePointer, original: KNativePointer, str: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _StringLiteralStrConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSTypeAssertion(context: KNativePointer, typeAnnotation: KNativePointer, expression: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSTypeAssertion(context: KNativePointer, original: KNativePointer, typeAnnotation: KNativePointer, expression: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAssertionGetExpressionConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAssertionTypeAnnotationConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeAssertionSetTsTypeAnnotation(context: KNativePointer, receiver: KNativePointer, typeAnnotation: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSExternalModuleReference(context: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSExternalModuleReference(context: KNativePointer, original: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSExternalModuleReferenceExprConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSUndefinedKeyword(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSUndefinedKeyword(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSTuple(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSTuple(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSTuple1(context: KNativePointer, size: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSTuple1(context: KNativePointer, original: KNativePointer, size: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSTuple2(context: KNativePointer, typeList: BigUint64Array, typeListSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSTuple2(context: KNativePointer, original: KNativePointer, typeList: BigUint64Array, typeListSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSTupleGetTupleSizeConst(context: KNativePointer, receiver: KNativePointer): KUInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSTupleGetTupleTypeAnnotationsList(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSTupleGetTupleTypeAnnotationsListConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSTupleSetTypeAnnotationsList(context: KNativePointer, receiver: KNativePointer, typeNodeList: BigUint64Array, typeNodeListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSStringLiteralType(context: KNativePointer, value: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSStringLiteralType(context: KNativePointer, original: KNativePointer, value: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTryStatement(context: KNativePointer, block: KNativePointer, catchClauses: BigUint64Array, catchClausesSequenceLength: KUInt, finalizer: KNativePointer, finalizerInsertionsLabelPair: BigUint64Array, finalizerInsertionsLabelPairSequenceLength: KUInt, finalizerInsertionsStatement: BigUint64Array, finalizerInsertionsStatementSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTryStatement(context: KNativePointer, original: KNativePointer, block: KNativePointer, catchClauses: BigUint64Array, catchClausesSequenceLength: KUInt, finalizer: KNativePointer, finalizerInsertionsLabelPair: BigUint64Array, finalizerInsertionsLabelPairSequenceLength: KUInt, finalizerInsertionsStatement: BigUint64Array, finalizerInsertionsStatementSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTryStatement1(context: KNativePointer, other: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTryStatement1(context: KNativePointer, original: KNativePointer, other: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TryStatementFinallyBlockConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TryStatementBlockConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TryStatementHasFinalizerConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TryStatementHasDefaultCatchClauseConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TryStatementCatchClausesConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TryStatementFinallyCanCompleteNormallyConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TryStatementSetFinallyCanCompleteNormally(context: KNativePointer, receiver: KNativePointer, finallyCanCompleteNormally: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsProgramConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsStatementConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsExpressionConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsTypedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeAsTyped(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeAsTypedConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsBrokenStatementConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeAsExpression(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeAsExpressionConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeAsStatement(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeAsStatementConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeSetRange(context: KNativePointer, receiver: KNativePointer, loc: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeSetProgram(context: KNativePointer, receiver: KNativePointer, program: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeSetStart(context: KNativePointer, receiver: KNativePointer, start: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeSetEnd(context: KNativePointer, receiver: KNativePointer, end: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeProgramConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeStartConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeEndConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeRangeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeTypeConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeParent(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeParentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeSetParent(context: KNativePointer, receiver: KNativePointer, parent: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeDecoratorsPtrConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeAddDecorators(context: KNativePointer, receiver: KNativePointer, decorators: BigUint64Array, decoratorsSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeCanHaveDecoratorConst(context: KNativePointer, receiver: KNativePointer, inTs: KBoolean): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsReadonlyConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsReadonlyTypeConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsOptionalDeclarationConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsDefiniteConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsConstructorConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsOverrideConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeSetOverride(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsAsyncConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsSynchronizedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsNativeConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsConstConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsStaticConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsFinalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsAbstractConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsPublicConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsProtectedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsPrivateConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsInternalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsExportedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsDefaultExportedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsExportedTypeConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsDeclareConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsInConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsOutConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsSetterConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeAddModifier(context: KNativePointer, receiver: KNativePointer, flags: KInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeClearModifier(context: KNativePointer, receiver: KNativePointer, flags: KInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeModifiers(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeModifiersConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeHasExportAliasConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeAsClassElement(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeAsClassElementConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsScopeBearerConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeClearScope(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeGetTopStatement(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeGetTopStatementConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeClone(context: KNativePointer, receiver: KNativePointer, parent: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeDumpJSONConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeDumpEtsSrcConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeDumpDeclConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeDumpConst(context: KNativePointer, receiver: KNativePointer, dumper: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeDumpConst1(context: KNativePointer, receiver: KNativePointer, dumper: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeCompileConst(context: KNativePointer, receiver: KNativePointer, pg: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeCompileConst1(context: KNativePointer, receiver: KNativePointer, etsg: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeSetTransformedNode(context: KNativePointer, receiver: KNativePointer, transformationName: KStringPtr, transformedNode: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeAccept(context: KNativePointer, receiver: KNativePointer, v: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeSetOriginalNode(context: KNativePointer, receiver: KNativePointer, originalNode: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeOriginalNodeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeCleanUp(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeShallowClone(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeIsValidInCurrentPhaseConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeGetHistoryNodeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeGetOrCreateHistoryNodeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstNodeCleanCheckInformation(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateUnaryExpression(context: KNativePointer, argument: KNativePointer, unaryOperator: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateUnaryExpression(context: KNativePointer, original: KNativePointer, argument: KNativePointer, unaryOperator: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UnaryExpressionOperatorTypeConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _UnaryExpressionArgument(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UnaryExpressionArgumentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UnaryExpressionSetArgument(context: KNativePointer, receiver: KNativePointer, arg: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateForInStatement(context: KNativePointer, left: KNativePointer, right: KNativePointer, body: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateForInStatement(context: KNativePointer, original: KNativePointer, left: KNativePointer, right: KNativePointer, body: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForInStatementLeft(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForInStatementLeftConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForInStatementRight(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForInStatementRightConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForInStatementBody(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForInStatementBodyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateThisExpression(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateThisExpression(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSMethodSignature(context: KNativePointer, key: KNativePointer, signature: KNativePointer, computed: KBoolean, optional_arg: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSMethodSignature(context: KNativePointer, original: KNativePointer, key: KNativePointer, signature: KNativePointer, computed: KBoolean, optional_arg: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSMethodSignatureKeyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSMethodSignatureKey(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSMethodSignatureTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSMethodSignatureTypeParams(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSMethodSignatureParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSMethodSignatureReturnTypeAnnotationConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSMethodSignatureReturnTypeAnnotation(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSMethodSignatureComputedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSMethodSignatureOptionalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateBinaryExpression(context: KNativePointer, left: KNativePointer, right: KNativePointer, operatorType: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateBinaryExpression(context: KNativePointer, original: KNativePointer, left: KNativePointer, right: KNativePointer, operatorType: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BinaryExpressionLeftConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BinaryExpressionLeft(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BinaryExpressionRightConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BinaryExpressionRight(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BinaryExpressionResultConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BinaryExpressionResult(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BinaryExpressionOperatorTypeConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _BinaryExpressionIsLogicalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _BinaryExpressionIsLogicalExtendedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _BinaryExpressionIsBitwiseConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _BinaryExpressionIsArithmeticConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _BinaryExpressionSetLeft(context: KNativePointer, receiver: KNativePointer, expr: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _BinaryExpressionSetRight(context: KNativePointer, receiver: KNativePointer, expr: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _BinaryExpressionSetResult(context: KNativePointer, receiver: KNativePointer, expr: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _BinaryExpressionSetOperator(context: KNativePointer, receiver: KNativePointer, operatorType: KInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _BinaryExpressionCompileOperandsConst(context: KNativePointer, receiver: KNativePointer, etsg: KNativePointer, lhs: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateSuperExpression(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateSuperExpression(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateAssertStatement(context: KNativePointer, test: KNativePointer, second: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateAssertStatement(context: KNativePointer, original: KNativePointer, test: KNativePointer, second: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssertStatementTestConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssertStatementTest(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssertStatementSecondConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSStringKeyword(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSStringKeyword(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateAssignmentExpression(context: KNativePointer, left: KNativePointer, right: KNativePointer, assignmentOperator: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateAssignmentExpression(context: KNativePointer, original: KNativePointer, left: KNativePointer, right: KNativePointer, assignmentOperator: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateAssignmentExpression1(context: KNativePointer, type: KInt, left: KNativePointer, right: KNativePointer, assignmentOperator: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateAssignmentExpression1(context: KNativePointer, original: KNativePointer, type: KInt, left: KNativePointer, right: KNativePointer, assignmentOperator: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionLeftConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionLeft(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionRight(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionRightConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionSetRight(context: KNativePointer, receiver: KNativePointer, expr: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionSetLeft(context: KNativePointer, receiver: KNativePointer, expr: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionResultConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionResult(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionOperatorTypeConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionSetOperatorType(context: KNativePointer, receiver: KNativePointer, tokenType: KInt): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionSetResult(context: KNativePointer, receiver: KNativePointer, expr: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionIsLogicalExtendedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionSetIgnoreConstAssign(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionIsIgnoreConstAssignConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionConvertibleToAssignmentPatternLeft(context: KNativePointer, receiver: KNativePointer, mustBePattern: KBoolean): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionConvertibleToAssignmentPatternRight(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionConvertibleToAssignmentPattern(context: KNativePointer, receiver: KNativePointer, mustBePattern: KBoolean): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AssignmentExpressionCompilePatternConst(context: KNativePointer, receiver: KNativePointer, pg: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateExpressionStatement(context: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateExpressionStatement(context: KNativePointer, original: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExpressionStatementGetExpressionConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExpressionStatementGetExpression(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExpressionStatementSetExpression(context: KNativePointer, receiver: KNativePointer, expr: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSModule(context: KNativePointer, statementList: BigUint64Array, statementListSequenceLength: KUInt, ident: KNativePointer, flag: KInt, program: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSModule(context: KNativePointer, original: KNativePointer, statementList: BigUint64Array, statementListSequenceLength: KUInt, ident: KNativePointer, flag: KInt, program: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleIdent(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleIdentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleProgram(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleGlobalClassConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleGlobalClass(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleSetGlobalClass(context: KNativePointer, receiver: KNativePointer, globalClass: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleIsETSScriptConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleIsNamespaceConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleIsNamespaceChainLastNodeConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleSetNamespaceChainLastNode(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleProgramConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleHasAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleEmplaceAnnotation(context: KNativePointer, receiver: KNativePointer, source: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleClearAnnotations(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleDumpAnnotationsConst(context: KNativePointer, receiver: KNativePointer, dumper: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleAnnotationsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleAnnotations(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleSetAnnotations(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSModuleSetAnnotations1(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateMetaProperty(context: KNativePointer, kind: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateMetaProperty(context: KNativePointer, original: KNativePointer, kind: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _MetaPropertyKindConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSArrayType(context: KNativePointer, elementType: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSArrayType(context: KNativePointer, original: KNativePointer, elementType: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSArrayTypeElementTypeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSSignatureDeclaration(context: KNativePointer, kind: KInt, signature: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSSignatureDeclaration(context: KNativePointer, original: KNativePointer, kind: KInt, signature: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSSignatureDeclarationTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSSignatureDeclarationTypeParams(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSSignatureDeclarationParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSSignatureDeclarationReturnTypeAnnotationConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSSignatureDeclarationReturnTypeAnnotation(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSSignatureDeclarationKindConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateExportAllDeclaration(context: KNativePointer, source: KNativePointer, exported: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateExportAllDeclaration(context: KNativePointer, original: KNativePointer, source: KNativePointer, exported: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExportAllDeclarationSourceConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExportAllDeclarationExportedConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateExportSpecifier(context: KNativePointer, local: KNativePointer, exported: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateExportSpecifier(context: KNativePointer, original: KNativePointer, local: KNativePointer, exported: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExportSpecifierLocalConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExportSpecifierExportedConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExportSpecifierSetDefault(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExportSpecifierIsDefaultConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExportSpecifierSetConstantExpression(context: KNativePointer, receiver: KNativePointer, constantExpression: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExportSpecifierGetConstantExpressionConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSTupleType(context: KNativePointer, elementTypes: BigUint64Array, elementTypesSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSTupleType(context: KNativePointer, original: KNativePointer, elementTypes: BigUint64Array, elementTypesSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTupleTypeElementTypeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateFunctionExpression(context: KNativePointer, func: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateFunctionExpression(context: KNativePointer, original: KNativePointer, func: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateFunctionExpression1(context: KNativePointer, namedExpr: KNativePointer, func: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateFunctionExpression1(context: KNativePointer, original: KNativePointer, namedExpr: KNativePointer, func: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionExpressionFunctionConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionExpressionFunction(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionExpressionIsAnonymousConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionExpressionId(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSIndexSignature(context: KNativePointer, param: KNativePointer, typeAnnotation: KNativePointer, readonly_arg: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSIndexSignature(context: KNativePointer, original: KNativePointer, param: KNativePointer, typeAnnotation: KNativePointer, readonly_arg: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSIndexSignatureParamConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSIndexSignatureTypeAnnotationConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSIndexSignatureReadonlyConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSIndexSignatureKindConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSModuleDeclaration(context: KNativePointer, name: KNativePointer, body: KNativePointer, declare: KBoolean, _global: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSModuleDeclaration(context: KNativePointer, original: KNativePointer, name: KNativePointer, body: KNativePointer, declare: KBoolean, _global: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSModuleDeclarationNameConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSModuleDeclarationBodyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSModuleDeclarationGlobalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSModuleDeclarationIsExternalOrAmbientConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateImportDeclaration(context: KNativePointer, source: KNativePointer, specifiers: BigUint64Array, specifiersSequenceLength: KUInt, importKinds: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateImportDeclaration(context: KNativePointer, original: KNativePointer, source: KNativePointer, specifiers: BigUint64Array, specifiersSequenceLength: KUInt, importKinds: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportDeclarationEmplaceSpecifiers(context: KNativePointer, receiver: KNativePointer, source: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportDeclarationClearSpecifiers(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportDeclarationSetValueSpecifiers(context: KNativePointer, receiver: KNativePointer, source: KNativePointer, index: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportDeclarationSpecifiersForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportDeclarationSourceConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportDeclarationSource(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportDeclarationSpecifiersConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportDeclarationIsTypeKindConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSParenthesizedType(context: KNativePointer, type: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSParenthesizedType(context: KNativePointer, original: KNativePointer, type: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSParenthesizedTypeTypeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _LiteralIsFoldedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _LiteralSetFolded(context: KNativePointer, receiver: KNativePointer, folded: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateCharLiteral(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateCharLiteral(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSIntrinsicNode(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSIntrinsicNode(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSIntrinsicNode1(context: KNativePointer, other: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSIntrinsicNode1(context: KNativePointer, original: KNativePointer, other: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSIntrinsicNode2(context: KNativePointer, type: KInt, _arguments: BigUint64Array, _argumentsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSIntrinsicNode2(context: KNativePointer, original: KNativePointer, type: KInt, _arguments: BigUint64Array, _argumentsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSIntrinsicNodeTypeConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSIntrinsicNodeArgumentsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSPackageDeclaration(context: KNativePointer, name: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSPackageDeclaration(context: KNativePointer, original: KNativePointer, name: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSImportDeclaration(context: KNativePointer, importPath: KNativePointer, specifiers: BigUint64Array, specifiersSequenceLength: KUInt, importKinds: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSImportDeclaration(context: KNativePointer, original: KNativePointer, importPath: KNativePointer, specifiers: BigUint64Array, specifiersSequenceLength: KUInt, importKinds: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSImportDeclarationSetImportMetadata(context: KNativePointer, receiver: KNativePointer, importFlags: KInt, lang: KInt, resolvedSource: KStringPtr, declPath: KStringPtr, ohmUrl: KStringPtr): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSImportDeclarationDeclPathConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSImportDeclarationOhmUrlConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSImportDeclarationIsValidConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSImportDeclarationIsPureDynamicConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSImportDeclarationSetAssemblerName(context: KNativePointer, receiver: KNativePointer, assemblerName: KStringPtr): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSImportDeclarationAssemblerNameConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSImportDeclarationResolvedSourceConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSStructDeclaration(context: KNativePointer, def: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSStructDeclaration(context: KNativePointer, original: KNativePointer, def: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSModuleBlock(context: KNativePointer, statements: BigUint64Array, statementsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSModuleBlock(context: KNativePointer, original: KNativePointer, statements: BigUint64Array, statementsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSModuleBlockStatementsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSNewArrayInstanceExpression(context: KNativePointer, typeReference: KNativePointer, dimension: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSNewArrayInstanceExpression(context: KNativePointer, original: KNativePointer, typeReference: KNativePointer, dimension: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSNewArrayInstanceExpressionTypeReference(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSNewArrayInstanceExpressionTypeReferenceConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSNewArrayInstanceExpressionDimension(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSNewArrayInstanceExpressionDimensionConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSNewArrayInstanceExpressionSetDimension(context: KNativePointer, receiver: KNativePointer, dimension: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSNewArrayInstanceExpressionClearPreferredType(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateAnnotationDeclaration(context: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateAnnotationDeclaration(context: KNativePointer, original: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateAnnotationDeclaration1(context: KNativePointer, expr: KNativePointer, properties: BigUint64Array, propertiesSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateAnnotationDeclaration1(context: KNativePointer, original: KNativePointer, expr: KNativePointer, properties: BigUint64Array, propertiesSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationInternalNameConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationSetInternalName(context: KNativePointer, receiver: KNativePointer, internalName: KStringPtr): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationExprConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationExpr(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationProperties(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationPropertiesForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationPropertiesConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationAddProperties(context: KNativePointer, receiver: KNativePointer, properties: BigUint64Array, propertiesSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationIsSourceRetentionConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationIsBytecodeRetentionConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationIsRuntimeRetentionConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationSetSourceRetention(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationSetBytecodeRetention(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationSetRuntimeRetention(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationGetBaseNameConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationEmplaceProperties(context: KNativePointer, receiver: KNativePointer, properties: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationClearProperties(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationSetValueProperties(context: KNativePointer, receiver: KNativePointer, properties: KNativePointer, index: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationHasAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationEmplaceAnnotation(context: KNativePointer, receiver: KNativePointer, source: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationClearAnnotations(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationDumpAnnotationsConst(context: KNativePointer, receiver: KNativePointer, dumper: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationAnnotationsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationAnnotations(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationSetAnnotations(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationDeclarationSetAnnotations1(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateAnnotationUsage(context: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateAnnotationUsage(context: KNativePointer, original: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateAnnotationUsage1(context: KNativePointer, expr: KNativePointer, properties: BigUint64Array, propertiesSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateAnnotationUsage1(context: KNativePointer, original: KNativePointer, expr: KNativePointer, properties: BigUint64Array, propertiesSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationUsageExpr(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationUsageProperties(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationUsagePropertiesConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationUsageAddProperty(context: KNativePointer, receiver: KNativePointer, property: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationUsageSetProperties(context: KNativePointer, receiver: KNativePointer, properties: BigUint64Array, propertiesSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotationUsageGetBaseNameConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateEmptyStatement(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateEmptyStatement(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateEmptyStatement1(context: KNativePointer, isBrokenStatement: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateEmptyStatement1(context: KNativePointer, original: KNativePointer, isBrokenStatement: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _EmptyStatementIsBrokenStatement(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateWhileStatement(context: KNativePointer, test: KNativePointer, body: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateWhileStatement(context: KNativePointer, original: KNativePointer, test: KNativePointer, body: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _WhileStatementTestConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _WhileStatementTest(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _WhileStatementSetTest(context: KNativePointer, receiver: KNativePointer, test: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _WhileStatementBodyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _WhileStatementBody(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateFunctionSignature(context: KNativePointer, typeParams: KNativePointer, params: BigUint64Array, paramsSequenceLength: KUInt, returnTypeAnnotation: KNativePointer, hasReceiver: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionSignatureParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionSignatureParams(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionSignatureTypeParams(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionSignatureTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionSignatureReturnType(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionSignatureSetReturnType(context: KNativePointer, receiver: KNativePointer, type: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionSignatureReturnTypeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionSignatureClone(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _FunctionSignatureHasReceiverConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateChainExpression(context: KNativePointer, expression: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateChainExpression(context: KNativePointer, original: KNativePointer, expression: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ChainExpressionGetExpressionConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ChainExpressionGetExpression(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ChainExpressionCompileToRegConst(context: KNativePointer, receiver: KNativePointer, pg: KNativePointer, objReg: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSIntersectionType(context: KNativePointer, types: BigUint64Array, typesSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSIntersectionType(context: KNativePointer, original: KNativePointer, types: BigUint64Array, typesSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSIntersectionTypeTypesConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateUpdateExpression(context: KNativePointer, argument: KNativePointer, updateOperator: KInt, isPrefix: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateUpdateExpression(context: KNativePointer, original: KNativePointer, argument: KNativePointer, updateOperator: KInt, isPrefix: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateExpressionOperatorTypeConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateExpressionArgument(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateExpressionArgumentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateExpressionIsPrefixConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateBlockExpression(context: KNativePointer, statements: BigUint64Array, statementsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateBlockExpression(context: KNativePointer, original: KNativePointer, statements: BigUint64Array, statementsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BlockExpressionStatementsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BlockExpressionStatements(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BlockExpressionAddStatements(context: KNativePointer, receiver: KNativePointer, statements: BigUint64Array, statementsSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _BlockExpressionAddStatement(context: KNativePointer, receiver: KNativePointer, statement: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSTypeLiteral(context: KNativePointer, members: BigUint64Array, membersSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSTypeLiteral(context: KNativePointer, original: KNativePointer, members: BigUint64Array, membersSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeLiteralMembersConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSTypeParameter(context: KNativePointer, name: KNativePointer, constraint: KNativePointer, defaultType: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSTypeParameter(context: KNativePointer, original: KNativePointer, name: KNativePointer, constraint: KNativePointer, defaultType: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSTypeParameter1(context: KNativePointer, name: KNativePointer, constraint: KNativePointer, defaultType: KNativePointer, flags: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSTypeParameter1(context: KNativePointer, original: KNativePointer, name: KNativePointer, constraint: KNativePointer, defaultType: KNativePointer, flags: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterNameConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterName(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterConstraint(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterConstraintConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterSetConstraint(context: KNativePointer, receiver: KNativePointer, constraint: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterDefaultTypeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterSetDefaultType(context: KNativePointer, receiver: KNativePointer, defaultType: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterHasAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterEmplaceAnnotation(context: KNativePointer, receiver: KNativePointer, source: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterClearAnnotations(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterDumpAnnotationsConst(context: KNativePointer, receiver: KNativePointer, dumper: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterAnnotationsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterAnnotations(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterSetAnnotations(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterSetAnnotations1(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSBooleanKeyword(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSBooleanKeyword(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateSpreadElement(context: KNativePointer, nodeType: KInt, argument: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateSpreadElement(context: KNativePointer, original: KNativePointer, nodeType: KInt, argument: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _SpreadElementArgumentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _SpreadElementArgument(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _SpreadElementIsOptionalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _SpreadElementSetOptional(context: KNativePointer, receiver: KNativePointer, optional_arg: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _SpreadElementValidateExpression(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _SpreadElementConvertibleToRest(context: KNativePointer, receiver: KNativePointer, isDeclaration: KBoolean, allowPattern: KBoolean): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _SpreadElementTypeAnnotationConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _SpreadElementSetTsTypeAnnotation(context: KNativePointer, receiver: KNativePointer, typeAnnotation: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSTypePredicate(context: KNativePointer, parameterName: KNativePointer, typeAnnotation: KNativePointer, asserts: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSTypePredicate(context: KNativePointer, original: KNativePointer, parameterName: KNativePointer, typeAnnotation: KNativePointer, asserts: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypePredicateParameterNameConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypePredicateTypeAnnotationConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypePredicateAssertsConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateImportNamespaceSpecifier(context: KNativePointer, local: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateImportNamespaceSpecifier(context: KNativePointer, original: KNativePointer, local: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportNamespaceSpecifierLocal(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportNamespaceSpecifierLocalConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateExportNamedDeclaration(context: KNativePointer, source: KNativePointer, specifiers: BigUint64Array, specifiersSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateExportNamedDeclaration(context: KNativePointer, original: KNativePointer, source: KNativePointer, specifiers: BigUint64Array, specifiersSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateExportNamedDeclaration1(context: KNativePointer, decl: KNativePointer, specifiers: BigUint64Array, specifiersSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateExportNamedDeclaration1(context: KNativePointer, original: KNativePointer, decl: KNativePointer, specifiers: BigUint64Array, specifiersSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateExportNamedDeclaration2(context: KNativePointer, decl: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateExportNamedDeclaration2(context: KNativePointer, original: KNativePointer, decl: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExportNamedDeclarationDeclConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExportNamedDeclarationSourceConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExportNamedDeclarationSpecifiersConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExportNamedDeclarationReplaceSpecifiers(context: KNativePointer, receiver: KNativePointer, specifiers: BigUint64Array, specifiersSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSParameterExpression(context: KNativePointer, identOrSpread: KNativePointer, isOptional: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSParameterExpression(context: KNativePointer, original: KNativePointer, identOrSpread: KNativePointer, isOptional: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSParameterExpression1(context: KNativePointer, identOrSpread: KNativePointer, initializer: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSParameterExpression1(context: KNativePointer, original: KNativePointer, identOrSpread: KNativePointer, initializer: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionNameConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionIdentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionIdent(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionSetIdent(context: KNativePointer, receiver: KNativePointer, ident: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionSpread(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionSpreadConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionSetSpread(context: KNativePointer, receiver: KNativePointer, spread: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionRestParameterConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionRestParameter(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionInitializerConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionInitializer(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionSetLexerSaved(context: KNativePointer, receiver: KNativePointer, savedLexer: KStringPtr): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionLexerSavedConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionTypeAnnotationConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionTypeAnnotation(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionSetTypeAnnotation(context: KNativePointer, receiver: KNativePointer, typeNode: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionIsOptionalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionSetOptional(context: KNativePointer, receiver: KNativePointer, value: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionSetInitializer(context: KNativePointer, receiver: KNativePointer, initExpr: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionIsRestParameterConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionGetRequiredParamsConst(context: KNativePointer, receiver: KNativePointer): KUInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionSetRequiredParams(context: KNativePointer, receiver: KNativePointer, extraValue: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionHasAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionEmplaceAnnotation(context: KNativePointer, receiver: KNativePointer, source: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionClearAnnotations(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionDumpAnnotationsConst(context: KNativePointer, receiver: KNativePointer, dumper: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionAnnotationsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionAnnotations(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionSetAnnotations(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSParameterExpressionSetAnnotations1(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSTypeParameterInstantiation(context: KNativePointer, params: BigUint64Array, paramsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSTypeParameterInstantiation(context: KNativePointer, original: KNativePointer, params: BigUint64Array, paramsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterInstantiationParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateNullLiteral(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateNullLiteral(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSInferType(context: KNativePointer, typeParam: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSInferType(context: KNativePointer, original: KNativePointer, typeParam: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInferTypeTypeParamConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateSwitchCaseStatement(context: KNativePointer, test: KNativePointer, consequent: BigUint64Array, consequentSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateSwitchCaseStatement(context: KNativePointer, original: KNativePointer, test: KNativePointer, consequent: BigUint64Array, consequentSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _SwitchCaseStatementTest(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _SwitchCaseStatementTestConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _SwitchCaseStatementSetTest(context: KNativePointer, receiver: KNativePointer, test: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _SwitchCaseStatementConsequentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateYieldExpression(context: KNativePointer, argument: KNativePointer, isDelegate: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateYieldExpression(context: KNativePointer, original: KNativePointer, argument: KNativePointer, isDelegate: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _YieldExpressionHasDelegateConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _YieldExpressionArgumentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSImportEqualsDeclaration(context: KNativePointer, id: KNativePointer, moduleReference: KNativePointer, isExport: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSImportEqualsDeclaration(context: KNativePointer, original: KNativePointer, id: KNativePointer, moduleReference: KNativePointer, isExport: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSImportEqualsDeclarationIdConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSImportEqualsDeclarationModuleReferenceConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSImportEqualsDeclarationIsExportConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateBooleanLiteral(context: KNativePointer, value: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateBooleanLiteral(context: KNativePointer, original: KNativePointer, value: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BooleanLiteralValueConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSNumberKeyword(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSNumberKeyword(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateClassStaticBlock(context: KNativePointer, value: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateClassStaticBlock(context: KNativePointer, original: KNativePointer, value: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassStaticBlockFunction(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassStaticBlockFunctionConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassStaticBlockNameConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSNonNullExpression(context: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSNonNullExpression(context: KNativePointer, original: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSNonNullExpressionExprConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSNonNullExpressionExpr(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSNonNullExpressionSetExpr(context: KNativePointer, receiver: KNativePointer, expr: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreatePrefixAssertionExpression(context: KNativePointer, expr: KNativePointer, type: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdatePrefixAssertionExpression(context: KNativePointer, original: KNativePointer, expr: KNativePointer, type: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _PrefixAssertionExpressionExprConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _PrefixAssertionExpressionTypeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateClassExpression(context: KNativePointer, def: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateClassExpression(context: KNativePointer, original: KNativePointer, def: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassExpressionDefinitionConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateForOfStatement(context: KNativePointer, left: KNativePointer, right: KNativePointer, body: KNativePointer, isAwait: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateForOfStatement(context: KNativePointer, original: KNativePointer, left: KNativePointer, right: KNativePointer, body: KNativePointer, isAwait: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForOfStatementLeft(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForOfStatementLeftConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForOfStatementRight(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForOfStatementRightConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForOfStatementBody(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForOfStatementBodyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForOfStatementIsAwaitConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTemplateLiteral(context: KNativePointer, quasis: BigUint64Array, quasisSequenceLength: KUInt, expressions: BigUint64Array, expressionsSequenceLength: KUInt, multilineString: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTemplateLiteral(context: KNativePointer, original: KNativePointer, quasis: BigUint64Array, quasisSequenceLength: KUInt, expressions: BigUint64Array, expressionsSequenceLength: KUInt, multilineString: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TemplateLiteralQuasisConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TemplateLiteralExpressionsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TemplateLiteralGetMultilineStringConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSUnionType(context: KNativePointer, types: BigUint64Array, typesSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSUnionType(context: KNativePointer, original: KNativePointer, types: BigUint64Array, typesSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSUnionTypeTypesConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSUnknownKeyword(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSUnknownKeyword(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateIdentifier(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateIdentifier(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateIdentifier1(context: KNativePointer, name: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateIdentifier1(context: KNativePointer, original: KNativePointer, name: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateIdentifier2(context: KNativePointer, name: KStringPtr, typeAnnotation: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateIdentifier2(context: KNativePointer, original: KNativePointer, name: KStringPtr, typeAnnotation: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierNameConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierName(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierSetName(context: KNativePointer, receiver: KNativePointer, newName: KStringPtr): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierIsErrorPlaceHolderConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierIsOptionalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierSetOptional(context: KNativePointer, receiver: KNativePointer, optional_arg: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierIsReferenceConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierIsTdzConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierSetTdz(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierSetAccessor(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierIsAccessorConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierSetMutator(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierIsMutatorConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierIsReceiverConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierIsPrivateIdentConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierSetPrivate(context: KNativePointer, receiver: KNativePointer, isPrivate: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierIsIgnoreBoxConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierSetIgnoreBox(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierIsAnnotationDeclConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierSetAnnotationDecl(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierIsAnnotationUsageConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierSetAnnotationUsage(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierCloneReference(context: KNativePointer, receiver: KNativePointer, parent: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierValidateExpression(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierTypeAnnotationConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _IdentifierSetTsTypeAnnotation(context: KNativePointer, receiver: KNativePointer, typeAnnotation: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateOpaqueTypeNode1(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateOpaqueTypeNode1(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateBlockStatement(context: KNativePointer, statementList: BigUint64Array, statementListSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateBlockStatement(context: KNativePointer, original: KNativePointer, statementList: BigUint64Array, statementListSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BlockStatementStatementsForUpdates(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BlockStatementStatements(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BlockStatementStatementsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BlockStatementSetStatements(context: KNativePointer, receiver: KNativePointer, statementList: BigUint64Array, statementListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _BlockStatementAddStatements(context: KNativePointer, receiver: KNativePointer, statementList: BigUint64Array, statementListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _BlockStatementClearStatements(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _BlockStatementAddStatement(context: KNativePointer, receiver: KNativePointer, statement: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _BlockStatementAddStatement1(context: KNativePointer, receiver: KNativePointer, idx: KUInt, statement: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _BlockStatementAddTrailingBlock(context: KNativePointer, receiver: KNativePointer, stmt: KNativePointer, trailingBlock: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _BlockStatementSearchStatementInTrailingBlock(context: KNativePointer, receiver: KNativePointer, item: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateDirectEvalExpression(context: KNativePointer, callee: KNativePointer, _arguments: BigUint64Array, _argumentsSequenceLength: KUInt, typeParams: KNativePointer, optional_arg: KBoolean, parserStatus: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateDirectEvalExpression(context: KNativePointer, original: KNativePointer, callee: KNativePointer, _arguments: BigUint64Array, _argumentsSequenceLength: KUInt, typeParams: KNativePointer, optional_arg: KBoolean, parserStatus: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSTypeParameterDeclaration(context: KNativePointer, params: BigUint64Array, paramsSequenceLength: KUInt, requiredParams: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSTypeParameterDeclaration(context: KNativePointer, original: KNativePointer, params: BigUint64Array, paramsSequenceLength: KUInt, requiredParams: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterDeclarationParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterDeclarationAddParam(context: KNativePointer, receiver: KNativePointer, param: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterDeclarationSetValueParams(context: KNativePointer, receiver: KNativePointer, source: KNativePointer, index: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSTypeParameterDeclarationRequiredParamsConst(context: KNativePointer, receiver: KNativePointer): KUInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateMethodDefinition(context: KNativePointer, kind: KInt, key: KNativePointer, value: KNativePointer, modifiers: KInt, isComputed: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateMethodDefinition(context: KNativePointer, original: KNativePointer, kind: KInt, key: KNativePointer, value: KNativePointer, modifiers: KInt, isComputed: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionKindConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionIsConstructorConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionIsMethodConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionIsExtensionMethodConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionIsGetterConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionIsSetterConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionIsDefaultAccessModifierConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionSetDefaultAccessModifier(context: KNativePointer, receiver: KNativePointer, isDefault: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionOverloadsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionBaseOverloadMethodConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionBaseOverloadMethod(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionAsyncPairMethodConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionAsyncPairMethod(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionSetOverloads(context: KNativePointer, receiver: KNativePointer, overloads: BigUint64Array, overloadsSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionAddOverload(context: KNativePointer, receiver: KNativePointer, overload: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionSetBaseOverloadMethod(context: KNativePointer, receiver: KNativePointer, baseOverloadMethod: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionSetAsyncPairMethod(context: KNativePointer, receiver: KNativePointer, asyncPairMethod: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionHasOverload(context: KNativePointer, receiver: KNativePointer, overload: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionFunction(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionFunctionConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionInitializeOverloadInfo(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionEmplaceOverloads(context: KNativePointer, receiver: KNativePointer, overloads: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionClearOverloads(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _MethodDefinitionSetValueOverloads(context: KNativePointer, receiver: KNativePointer, overloads: KNativePointer, index: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateOverloadDeclaration(context: KNativePointer, key: KNativePointer, modifiers: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateOverloadDeclaration(context: KNativePointer, original: KNativePointer, key: KNativePointer, modifiers: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _OverloadDeclarationFlagConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _OverloadDeclarationOverloadedList(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _OverloadDeclarationSetOverloadedList(context: KNativePointer, receiver: KNativePointer, overloadedList: BigUint64Array, overloadedListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _OverloadDeclarationPushFront(context: KNativePointer, receiver: KNativePointer, overloadedExpression: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _OverloadDeclarationAddOverloadDeclFlag(context: KNativePointer, receiver: KNativePointer, overloadFlag: KInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _OverloadDeclarationHasOverloadDeclFlagConst(context: KNativePointer, receiver: KNativePointer, overloadFlag: KInt): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _OverloadDeclarationIsConstructorOverloadDeclaration(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _OverloadDeclarationIsFunctionOverloadDeclaration(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _OverloadDeclarationIsClassMethodOverloadDeclaration(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _OverloadDeclarationIsInterfaceMethodOverloadDeclaration(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _OverloadDeclarationDumpModifierConst(context: KNativePointer, receiver: KNativePointer, dumper: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSNullKeyword(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSNullKeyword(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSInterfaceHeritage(context: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSInterfaceHeritage(context: KNativePointer, original: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceHeritageExpr(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSInterfaceHeritageExprConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExpressionIsGroupedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExpressionSetGrouped(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExpressionAsLiteralConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExpressionAsLiteral(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExpressionIsLiteralConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExpressionIsTypeNodeConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExpressionIsAnnotatedExpressionConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExpressionAsTypeNode(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExpressionAsTypeNodeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExpressionAsAnnotatedExpression(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExpressionAsAnnotatedExpressionConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExpressionIsBrokenExpressionConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ExpressionToStringConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotatedExpressionTypeAnnotationConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AnnotatedExpressionSetTsTypeAnnotation(context: KNativePointer, receiver: KNativePointer, typeAnnotation: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _MaybeOptionalExpressionIsOptionalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _MaybeOptionalExpressionClearOptional(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateSrcDumper(context: KNativePointer, node: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateSrcDumper1(context: KNativePointer, node: KNativePointer, isDeclgen: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _SrcDumperAdd(context: KNativePointer, receiver: KNativePointer, str: KStringPtr): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _SrcDumperAdd1(context: KNativePointer, receiver: KNativePointer, i: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _SrcDumperAdd2(context: KNativePointer, receiver: KNativePointer, i: KInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _SrcDumperAdd3(context: KNativePointer, receiver: KNativePointer, i: KInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _SrcDumperAdd4(context: KNativePointer, receiver: KNativePointer, l: KLong): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _SrcDumperAdd5(context: KNativePointer, receiver: KNativePointer, f: KFloat): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _SrcDumperAdd6(context: KNativePointer, receiver: KNativePointer, d: KDouble): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _SrcDumperStrConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _SrcDumperIncrIndent(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _SrcDumperDecrIndent(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _SrcDumperEndl(context: KNativePointer, receiver: KNativePointer, num: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _SrcDumperIsDeclgenConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _SrcDumperDumpNode(context: KNativePointer, receiver: KNativePointer, key: KStringPtr): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _SrcDumperRemoveNode(context: KNativePointer, receiver: KNativePointer, key: KStringPtr): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _SrcDumperIsIndirectDepPhaseConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _SrcDumperRun(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSClassLiteral(context: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSClassLiteral(context: KNativePointer, original: KNativePointer, expr: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSClassLiteralExprConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateBreakStatement(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateBreakStatement(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateBreakStatement1(context: KNativePointer, ident: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateBreakStatement1(context: KNativePointer, original: KNativePointer, ident: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BreakStatementIdentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BreakStatementIdent(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BreakStatementTargetConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _BreakStatementHasTargetConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _BreakStatementSetTarget(context: KNativePointer, receiver: KNativePointer, target: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateRegExpLiteral(context: KNativePointer, pattern: KStringPtr, flags: KInt, flagsStr: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateRegExpLiteral(context: KNativePointer, original: KNativePointer, pattern: KStringPtr, flags: KInt, flagsStr: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _RegExpLiteralPatternConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _RegExpLiteralFlagsConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSMappedType(context: KNativePointer, typeParameter: KNativePointer, typeAnnotation: KNativePointer, readonly_arg: KInt, optional_arg: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSMappedType(context: KNativePointer, original: KNativePointer, typeParameter: KNativePointer, typeAnnotation: KNativePointer, readonly_arg: KInt, optional_arg: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSMappedTypeTypeParameter(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSMappedTypeTypeAnnotation(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSMappedTypeReadonly(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSMappedTypeOptional(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSAnyKeyword(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSAnyKeyword(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateClassDeclaration(context: KNativePointer, def: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateClassDeclaration(context: KNativePointer, original: KNativePointer, def: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDeclarationDefinition(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDeclarationDefinitionConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ClassDeclarationSetDefinition(context: KNativePointer, receiver: KNativePointer, def: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSIndexedAccessType(context: KNativePointer, objectType: KNativePointer, indexType: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSIndexedAccessType(context: KNativePointer, original: KNativePointer, objectType: KNativePointer, indexType: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSIndexedAccessTypeObjectTypeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSIndexedAccessTypeIndexTypeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSQualifiedName(context: KNativePointer, left: KNativePointer, right: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSQualifiedName(context: KNativePointer, original: KNativePointer, left: KNativePointer, right: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSQualifiedNameLeftConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSQualifiedNameLeft(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSQualifiedNameRightConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSQualifiedNameRight(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSQualifiedNameNameConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSQualifiedNameResolveLeftMostQualifiedName(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSQualifiedNameResolveLeftMostQualifiedNameConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateAwaitExpression(context: KNativePointer, argument: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateAwaitExpression(context: KNativePointer, original: KNativePointer, argument: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AwaitExpressionArgumentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateValidationInfo(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateValidationInfo1(context: KNativePointer, m: KStringPtr, p: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ValidationInfoFailConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateContinueStatement(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateContinueStatement(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateContinueStatement1(context: KNativePointer, ident: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateContinueStatement1(context: KNativePointer, original: KNativePointer, ident: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ContinueStatementIdentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ContinueStatementIdent(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ContinueStatementTargetConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ContinueStatementHasTargetConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ContinueStatementSetTarget(context: KNativePointer, receiver: KNativePointer, target: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSNewMultiDimArrayInstanceExpression(context: KNativePointer, typeReference: KNativePointer, dimensions: BigUint64Array, dimensionsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSNewMultiDimArrayInstanceExpression(context: KNativePointer, original: KNativePointer, typeReference: KNativePointer, dimensions: BigUint64Array, dimensionsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSNewMultiDimArrayInstanceExpression1(context: KNativePointer, other: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSNewMultiDimArrayInstanceExpression1(context: KNativePointer, original: KNativePointer, other: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSNewMultiDimArrayInstanceExpressionTypeReference(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSNewMultiDimArrayInstanceExpressionTypeReferenceConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSNewMultiDimArrayInstanceExpressionDimensions(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSNewMultiDimArrayInstanceExpressionDimensionsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSNewMultiDimArrayInstanceExpressionClearPreferredType(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSNamedTupleMember(context: KNativePointer, label: KNativePointer, elementType: KNativePointer, optional_arg: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSNamedTupleMember(context: KNativePointer, original: KNativePointer, label: KNativePointer, elementType: KNativePointer, optional_arg: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSNamedTupleMemberLabelConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSNamedTupleMemberElementType(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSNamedTupleMemberElementTypeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSNamedTupleMemberIsOptionalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateImportExpression(context: KNativePointer, source: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateImportExpression(context: KNativePointer, original: KNativePointer, source: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportExpressionSource(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ImportExpressionSourceConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateAstDumper(context: KNativePointer, node: KNativePointer, sourceCode: KStringPtr): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstDumperModifierToString(context: KNativePointer, receiver: KNativePointer, flags: KInt): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstDumperTypeOperatorToString(context: KNativePointer, receiver: KNativePointer, operatorType: KInt): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _AstDumperStrConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSNullType(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSNullType(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSUndefinedType(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSUndefinedType(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTypeofExpression(context: KNativePointer, argument: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTypeofExpression(context: KNativePointer, original: KNativePointer, argument: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TypeofExpressionArgumentConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSEnumMember(context: KNativePointer, key: KNativePointer, init: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSEnumMember(context: KNativePointer, original: KNativePointer, key: KNativePointer, init: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSEnumMember1(context: KNativePointer, key: KNativePointer, init: KNativePointer, isGenerated: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSEnumMember1(context: KNativePointer, original: KNativePointer, key: KNativePointer, init: KNativePointer, isGenerated: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumMemberKeyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumMemberKey(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumMemberInitConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumMemberInit(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumMemberIsGeneratedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSEnumMemberNameConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateSwitchStatement(context: KNativePointer, discriminant: KNativePointer, cases: BigUint64Array, casesSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateSwitchStatement(context: KNativePointer, original: KNativePointer, discriminant: KNativePointer, cases: BigUint64Array, casesSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _SwitchStatementDiscriminantConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _SwitchStatementDiscriminant(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _SwitchStatementSetDiscriminant(context: KNativePointer, receiver: KNativePointer, discriminant: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _SwitchStatementCasesConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _SwitchStatementCases(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateDoWhileStatement(context: KNativePointer, body: KNativePointer, test: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateDoWhileStatement(context: KNativePointer, original: KNativePointer, body: KNativePointer, test: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _DoWhileStatementBodyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _DoWhileStatementBody(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _DoWhileStatementTestConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _DoWhileStatementTest(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateCatchClause(context: KNativePointer, param: KNativePointer, body: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateCatchClause(context: KNativePointer, original: KNativePointer, param: KNativePointer, body: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateCatchClause1(context: KNativePointer, other: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateCatchClause1(context: KNativePointer, original: KNativePointer, other: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CatchClauseParam(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CatchClauseParamConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CatchClauseBody(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CatchClauseBodyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CatchClauseIsDefaultCatchClauseConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateSequenceExpression(context: KNativePointer, sequence_arg: BigUint64Array, sequence_argSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateSequenceExpression(context: KNativePointer, original: KNativePointer, sequence_arg: BigUint64Array, sequence_argSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _SequenceExpressionSequenceConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _SequenceExpressionSequence(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateArrowFunctionExpression(context: KNativePointer, func: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateArrowFunctionExpression(context: KNativePointer, original: KNativePointer, func: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateArrowFunctionExpression1(context: KNativePointer, other: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateArrowFunctionExpression1(context: KNativePointer, original: KNativePointer, other: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrowFunctionExpressionFunctionConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrowFunctionExpressionFunction(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrowFunctionExpressionCreateTypeAnnotation(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrowFunctionExpressionHasAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrowFunctionExpressionEmplaceAnnotation(context: KNativePointer, receiver: KNativePointer, source: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrowFunctionExpressionClearAnnotations(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrowFunctionExpressionDumpAnnotationsConst(context: KNativePointer, receiver: KNativePointer, dumper: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrowFunctionExpressionAnnotationsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrowFunctionExpressionAnnotations(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrowFunctionExpressionAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrowFunctionExpressionSetAnnotations(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArrowFunctionExpressionSetAnnotations1(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateOmittedExpression(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateOmittedExpression(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSNewClassInstanceExpression(context: KNativePointer, typeReference: KNativePointer, _arguments: BigUint64Array, _argumentsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSNewClassInstanceExpression(context: KNativePointer, original: KNativePointer, typeReference: KNativePointer, _arguments: BigUint64Array, _argumentsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSNewClassInstanceExpression1(context: KNativePointer, other: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSNewClassInstanceExpression1(context: KNativePointer, original: KNativePointer, other: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSNewClassInstanceExpressionGetTypeRefConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSNewClassInstanceExpressionGetArguments(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSNewClassInstanceExpressionGetArgumentsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSNewClassInstanceExpressionSetArguments(context: KNativePointer, receiver: KNativePointer, _arguments: BigUint64Array, _argumentsSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSNewClassInstanceExpressionAddToArgumentsFront(context: KNativePointer, receiver: KNativePointer, expr: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSAsExpression(context: KNativePointer, expression: KNativePointer, typeAnnotation: KNativePointer, isConst: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSAsExpression(context: KNativePointer, original: KNativePointer, expression: KNativePointer, typeAnnotation: KNativePointer, isConst: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSAsExpressionExprConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSAsExpressionExpr(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSAsExpressionSetExpr(context: KNativePointer, receiver: KNativePointer, expr: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSAsExpressionIsConstConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSAsExpressionSetUncheckedCast(context: KNativePointer, receiver: KNativePointer, isUncheckedCast: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSAsExpressionTypeAnnotationConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSAsExpressionSetTsTypeAnnotation(context: KNativePointer, receiver: KNativePointer, typeAnnotation: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateForUpdateStatement(context: KNativePointer, init: KNativePointer, test: KNativePointer, update: KNativePointer, body: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForUpdateStatementInit(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForUpdateStatementInitConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForUpdateStatementTest(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForUpdateStatementTestConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForUpdateStatementUpdateConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForUpdateStatementBody(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ForUpdateStatementBodyConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSTypeReferencePart(context: KNativePointer, name: KNativePointer, typeParams: KNativePointer, prev: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSTypeReferencePart(context: KNativePointer, original: KNativePointer, name: KNativePointer, typeParams: KNativePointer, prev: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSTypeReferencePart1(context: KNativePointer, name: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSTypeReferencePart1(context: KNativePointer, original: KNativePointer, name: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSTypeReferencePartPrevious(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSTypeReferencePartPreviousConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSTypeReferencePartName(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSTypeReferencePartTypeParams(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSTypeReferencePartTypeParamsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSTypeReferencePartNameConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSTypeReferencePartGetIdent(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSReExportDeclarationGetETSImportDeclarationsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSReExportDeclarationGetETSImportDeclarations(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSReExportDeclarationGetProgramPathConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSPrimitiveType(context: KNativePointer, type: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSPrimitiveType(context: KNativePointer, original: KNativePointer, type: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSPrimitiveTypeGetPrimitiveTypeConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _TypeNodeHasAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TypeNodeEmplaceAnnotation(context: KNativePointer, receiver: KNativePointer, source: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TypeNodeClearAnnotations(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TypeNodeDumpAnnotationsConst(context: KNativePointer, receiver: KNativePointer, dumper: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TypeNodeAnnotationsForUpdate(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TypeNodeAnnotations(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TypeNodeAnnotationsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TypeNodeSetAnnotations(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _TypeNodeSetAnnotations1(context: KNativePointer, receiver: KNativePointer, annotationList: BigUint64Array, annotationListSequenceLength: KUInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateNewExpression(context: KNativePointer, callee: KNativePointer, _arguments: BigUint64Array, _argumentsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateNewExpression(context: KNativePointer, original: KNativePointer, callee: KNativePointer, _arguments: BigUint64Array, _argumentsSequenceLength: KUInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _NewExpressionCalleeConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _NewExpressionArgumentsConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSParameterProperty(context: KNativePointer, accessibility: KInt, parameter: KNativePointer, readonly_arg: KBoolean, isStatic: KBoolean, isExport: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSParameterProperty(context: KNativePointer, original: KNativePointer, accessibility: KInt, parameter: KNativePointer, readonly_arg: KBoolean, isStatic: KBoolean, isExport: KBoolean): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSParameterPropertyAccessibilityConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSParameterPropertyReadonlyConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSParameterPropertyIsStaticConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSParameterPropertyIsExportConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _TSParameterPropertyParameterConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateETSWildcardType(context: KNativePointer, typeReference: KNativePointer, flags: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateETSWildcardType(context: KNativePointer, original: KNativePointer, typeReference: KNativePointer, flags: KInt): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSWildcardTypeTypeReference(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ETSWildcardTypeTypeReferenceConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateTSThisType(context: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _UpdateTSThisType(context: KNativePointer, original: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramSetKind(context: KNativePointer, receiver: KNativePointer, kind: KInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramPushVarBinder(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramPushChecker(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramKindConst(context: KNativePointer, receiver: KNativePointer): KInt { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramSourceCodeConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramSourceFilePathConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramSourceFileFolderConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramFileNameConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramFileNameWithExtensionConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramAbsoluteNameConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramResolvedFilePathConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramRelativeFilePathConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramSetRelativeFilePath(context: KNativePointer, receiver: KNativePointer, relPath: KStringPtr): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramAst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramAstConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramSetAst(context: KNativePointer, receiver: KNativePointer, ast: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramGlobalClass(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramGlobalClassConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramSetGlobalClass(context: KNativePointer, receiver: KNativePointer, globalClass: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramPackageStartConst(context: KNativePointer, receiver: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramSetPackageStart(context: KNativePointer, receiver: KNativePointer, start: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramSetSource(context: KNativePointer, receiver: KNativePointer, sourceCode: KStringPtr, sourceFilePath: KStringPtr, sourceFileFolder: KStringPtr): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramSetPackageInfo(context: KNativePointer, receiver: KNativePointer, name: KStringPtr, kind: KInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramModuleNameConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramModulePrefixConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramIsSeparateModuleConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramIsDeclarationModuleConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramIsPackageConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramIsDeclForDynamicStaticInteropConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramSetFlag(context: KNativePointer, receiver: KNativePointer, flag: KInt): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramGetFlagConst(context: KNativePointer, receiver: KNativePointer, flag: KInt): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramSetASTChecked(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramRemoveAstChecked(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramIsASTChecked(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramMarkASTAsLowered(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramIsASTLoweredConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramIsStdLibConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramIsGenAbcForExternalConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramSetGenAbcForExternalSources(context: KNativePointer, receiver: KNativePointer, genAbc: KBoolean): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramDumpConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramDumpSilentConst(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramIsDiedConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } + _ProgramAddFileDependencies(context: KNativePointer, receiver: KNativePointer, file: KStringPtr, depFile: KStringPtr): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _CreateArkTsConfig(context: KNativePointer, configPath: KStringPtr, de: KNativePointer): KNativePointer { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArkTsConfigResolveAllDependenciesInArkTsConfig(context: KNativePointer, receiver: KNativePointer): void { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArkTsConfigConfigPathConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArkTsConfigPackageConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArkTsConfigBaseUrlConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArkTsConfigRootDirConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArkTsConfigOutDirConst(context: KNativePointer, receiver: KNativePointer): KStringPtr { + throw new Error("This methods was not overloaded by native module initialization") + } + _ArkTsConfigUseUrlConst(context: KNativePointer, receiver: KNativePointer): KBoolean { + throw new Error("This methods was not overloaded by native module initialization") + } +} diff --git a/ets1.2/libarkts/src/generated/factory.ts b/ets1.2/libarkts/src/generated/factory.ts new file mode 100644 index 0000000000000000000000000000000000000000..530293ff5dec7fc3e1868b22ffc1ad3a09b69569 --- /dev/null +++ b/ets1.2/libarkts/src/generated/factory.ts @@ -0,0 +1,1287 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + isSameNativeObject, + unpackString, + updateNodeByNode +} from "../reexport-for-generated" + +import { AnnotationDeclaration } from "./peers/AnnotationDeclaration" +import { AnnotationUsage } from "./peers/AnnotationUsage" +import { ArrowFunctionExpression } from "./peers/ArrowFunctionExpression" +import { AssertStatement } from "./peers/AssertStatement" +import { AwaitExpression } from "./peers/AwaitExpression" +import { BigIntLiteral } from "./peers/BigIntLiteral" +import { BinaryExpression } from "./peers/BinaryExpression" +import { BlockExpression } from "./peers/BlockExpression" +import { BlockStatement } from "./peers/BlockStatement" +import { BooleanLiteral } from "./peers/BooleanLiteral" +import { BreakStatement } from "./peers/BreakStatement" +import { CatchClause } from "./peers/CatchClause" +import { ChainExpression } from "./peers/ChainExpression" +import { CharLiteral } from "./peers/CharLiteral" +import { ClassDeclaration } from "./peers/ClassDeclaration" +import { ClassDefinition } from "./peers/ClassDefinition" +import { ClassExpression } from "./peers/ClassExpression" +import { ConditionalExpression } from "./peers/ConditionalExpression" +import { ContinueStatement } from "./peers/ContinueStatement" +import { DebuggerStatement } from "./peers/DebuggerStatement" +import { Decorator } from "./peers/Decorator" +import { DoWhileStatement } from "./peers/DoWhileStatement" +import { ETSClassLiteral } from "./peers/ETSClassLiteral" +import { ETSIntrinsicNode } from "./peers/ETSIntrinsicNode" +import { ETSKeyofType } from "./peers/ETSKeyofType" +import { ETSNewArrayInstanceExpression } from "./peers/ETSNewArrayInstanceExpression" +import { ETSNewClassInstanceExpression } from "./peers/ETSNewClassInstanceExpression" +import { ETSNewMultiDimArrayInstanceExpression } from "./peers/ETSNewMultiDimArrayInstanceExpression" +import { ETSNullType } from "./peers/ETSNullType" +import { ETSPrimitiveType } from "./peers/ETSPrimitiveType" +import { ETSTypeReference } from "./peers/ETSTypeReference" +import { ETSTypeReferencePart } from "./peers/ETSTypeReferencePart" +import { ETSUndefinedType } from "./peers/ETSUndefinedType" +import { ETSUnionType } from "./peers/ETSUnionType" +import { EmptyStatement } from "./peers/EmptyStatement" +import { Es2pandaIntrinsicNodeType } from "./Es2pandaEnums" +import { Es2pandaMetaPropertyKind } from "./Es2pandaEnums" +import { Es2pandaModifierFlags } from "./Es2pandaEnums" +import { Es2pandaPrimitiveType } from "./Es2pandaEnums" +import { Es2pandaPropertyKind } from "./Es2pandaEnums" +import { Es2pandaTokenType } from "./Es2pandaEnums" +import { Es2pandaVariableDeclarationKind } from "./Es2pandaEnums" +import { ExportAllDeclaration } from "./peers/ExportAllDeclaration" +import { ExportDefaultDeclaration } from "./peers/ExportDefaultDeclaration" +import { ExportSpecifier } from "./peers/ExportSpecifier" +import { Expression } from "./peers/Expression" +import { ExpressionStatement } from "./peers/ExpressionStatement" +import { ForInStatement } from "./peers/ForInStatement" +import { ForOfStatement } from "./peers/ForOfStatement" +import { ForUpdateStatement } from "./peers/ForUpdateStatement" +import { FunctionDeclaration } from "./peers/FunctionDeclaration" +import { FunctionExpression } from "./peers/FunctionExpression" +import { FunctionSignature } from "./peers/FunctionSignature" +import { Identifier } from "./peers/Identifier" +import { IfStatement } from "./peers/IfStatement" +import { ImportDefaultSpecifier } from "./peers/ImportDefaultSpecifier" +import { ImportExpression } from "./peers/ImportExpression" +import { ImportNamespaceSpecifier } from "./peers/ImportNamespaceSpecifier" +import { ImportSpecifier } from "./peers/ImportSpecifier" +import { LabelledStatement } from "./peers/LabelledStatement" +import { MetaProperty } from "./peers/MetaProperty" +import { NamedType } from "./peers/NamedType" +import { NewExpression } from "./peers/NewExpression" +import { NullLiteral } from "./peers/NullLiteral" +import { OmittedExpression } from "./peers/OmittedExpression" +import { OpaqueTypeNode } from "./peers/OpaqueTypeNode" +import { PrefixAssertionExpression } from "./peers/PrefixAssertionExpression" +import { Property } from "./peers/Property" +import { ReturnStatement } from "./peers/ReturnStatement" +import { ScriptFunction } from "./peers/ScriptFunction" +import { SequenceExpression } from "./peers/SequenceExpression" +import { Statement } from "./peers/Statement" +import { StringLiteral } from "./peers/StringLiteral" +import { SuperExpression } from "./peers/SuperExpression" +import { SwitchCaseStatement } from "./peers/SwitchCaseStatement" +import { SwitchStatement } from "./peers/SwitchStatement" +import { TSAnyKeyword } from "./peers/TSAnyKeyword" +import { TSArrayType } from "./peers/TSArrayType" +import { TSAsExpression } from "./peers/TSAsExpression" +import { TSBigintKeyword } from "./peers/TSBigintKeyword" +import { TSBooleanKeyword } from "./peers/TSBooleanKeyword" +import { TSClassImplements } from "./peers/TSClassImplements" +import { TSConditionalType } from "./peers/TSConditionalType" +import { TSEnumMember } from "./peers/TSEnumMember" +import { TSExternalModuleReference } from "./peers/TSExternalModuleReference" +import { TSImportEqualsDeclaration } from "./peers/TSImportEqualsDeclaration" +import { TSImportType } from "./peers/TSImportType" +import { TSIndexSignature } from "./peers/TSIndexSignature" +import { TSIndexedAccessType } from "./peers/TSIndexedAccessType" +import { TSInferType } from "./peers/TSInferType" +import { TSInterfaceBody } from "./peers/TSInterfaceBody" +import { TSInterfaceHeritage } from "./peers/TSInterfaceHeritage" +import { TSIntersectionType } from "./peers/TSIntersectionType" +import { TSLiteralType } from "./peers/TSLiteralType" +import { TSModuleBlock } from "./peers/TSModuleBlock" +import { TSNamedTupleMember } from "./peers/TSNamedTupleMember" +import { TSNeverKeyword } from "./peers/TSNeverKeyword" +import { TSNonNullExpression } from "./peers/TSNonNullExpression" +import { TSNullKeyword } from "./peers/TSNullKeyword" +import { TSNumberKeyword } from "./peers/TSNumberKeyword" +import { TSObjectKeyword } from "./peers/TSObjectKeyword" +import { TSQualifiedName } from "./peers/TSQualifiedName" +import { TSStringKeyword } from "./peers/TSStringKeyword" +import { TSThisType } from "./peers/TSThisType" +import { TSTupleType } from "./peers/TSTupleType" +import { TSTypeAliasDeclaration } from "./peers/TSTypeAliasDeclaration" +import { TSTypeAssertion } from "./peers/TSTypeAssertion" +import { TSTypeLiteral } from "./peers/TSTypeLiteral" +import { TSTypeParameter } from "./peers/TSTypeParameter" +import { TSTypeParameterDeclaration } from "./peers/TSTypeParameterDeclaration" +import { TSTypeParameterInstantiation } from "./peers/TSTypeParameterInstantiation" +import { TSTypePredicate } from "./peers/TSTypePredicate" +import { TSTypeQuery } from "./peers/TSTypeQuery" +import { TSTypeReference } from "./peers/TSTypeReference" +import { TSUndefinedKeyword } from "./peers/TSUndefinedKeyword" +import { TSUnionType } from "./peers/TSUnionType" +import { TSUnknownKeyword } from "./peers/TSUnknownKeyword" +import { TSVoidKeyword } from "./peers/TSVoidKeyword" +import { TaggedTemplateExpression } from "./peers/TaggedTemplateExpression" +import { TemplateElement } from "./peers/TemplateElement" +import { TemplateLiteral } from "./peers/TemplateLiteral" +import { ThisExpression } from "./peers/ThisExpression" +import { ThrowStatement } from "./peers/ThrowStatement" +import { TypeNode } from "./peers/TypeNode" +import { TypeofExpression } from "./peers/TypeofExpression" +import { UnaryExpression } from "./peers/UnaryExpression" +import { UndefinedLiteral } from "./peers/UndefinedLiteral" +import { UpdateExpression } from "./peers/UpdateExpression" +import { VariableDeclaration } from "./peers/VariableDeclaration" +import { VariableDeclarator } from "./peers/VariableDeclarator" +import { WhileStatement } from "./peers/WhileStatement" +import { YieldExpression } from "./peers/YieldExpression" + +export const factory = { + createLabelledStatement(ident?: Identifier, body?: Statement): LabelledStatement { + return LabelledStatement.createLabelledStatement(ident, body) + } + , + updateLabelledStatement(original: LabelledStatement, ident?: Identifier, body?: Statement): LabelledStatement { + if (isSameNativeObject(ident, original.ident) && isSameNativeObject(body, original.body)) + return original + return updateNodeByNode(LabelledStatement.createLabelledStatement(ident, body), original) + } + , + createThrowStatement(argument?: Expression): ThrowStatement { + return ThrowStatement.createThrowStatement(argument) + } + , + updateThrowStatement(original: ThrowStatement, argument?: Expression): ThrowStatement { + if (isSameNativeObject(argument, original.argument)) + return original + return updateNodeByNode(ThrowStatement.createThrowStatement(argument), original) + } + , + createTSVoidKeyword(): TSVoidKeyword { + return TSVoidKeyword.createTSVoidKeyword() + } + , + updateTSVoidKeyword(original: TSVoidKeyword): TSVoidKeyword { + return updateNodeByNode(TSVoidKeyword.createTSVoidKeyword(), original) + } + , + createIfStatement(test?: Expression, consequent?: Statement, alternate?: Statement): IfStatement { + return IfStatement.createIfStatement(test, consequent, alternate) + } + , + updateIfStatement(original: IfStatement, test?: Expression, consequent?: Statement, alternate?: Statement): IfStatement { + if (isSameNativeObject(test, original.test) && isSameNativeObject(consequent, original.consequent) && isSameNativeObject(alternate, original.alternate)) + return original + return updateNodeByNode(IfStatement.createIfStatement(test, consequent, alternate), original) + } + , + createDecorator(expr?: Expression): Decorator { + return Decorator.createDecorator(expr) + } + , + updateDecorator(original: Decorator, expr?: Expression): Decorator { + if (isSameNativeObject(expr, original.expr)) + return original + return updateNodeByNode(Decorator.createDecorator(expr), original) + } + , + createTSNeverKeyword(): TSNeverKeyword { + return TSNeverKeyword.createTSNeverKeyword() + } + , + updateTSNeverKeyword(original: TSNeverKeyword): TSNeverKeyword { + return updateNodeByNode(TSNeverKeyword.createTSNeverKeyword(), original) + } + , + createImportDefaultSpecifier(local?: Identifier): ImportDefaultSpecifier { + return ImportDefaultSpecifier.createImportDefaultSpecifier(local) + } + , + updateImportDefaultSpecifier(original: ImportDefaultSpecifier, local?: Identifier): ImportDefaultSpecifier { + if (isSameNativeObject(local, original.local)) + return original + return updateNodeByNode(ImportDefaultSpecifier.createImportDefaultSpecifier(local), original) + } + , + createImportSpecifier(imported?: Identifier, local?: Identifier): ImportSpecifier { + return ImportSpecifier.createImportSpecifier(imported, local) + } + , + updateImportSpecifier(original: ImportSpecifier, imported?: Identifier, local?: Identifier): ImportSpecifier { + if (isSameNativeObject(imported, original.imported) && isSameNativeObject(local, original.local)) + return original + return updateNodeByNode(ImportSpecifier.createImportSpecifier(imported, local), original) + } + , + createConditionalExpression(test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression { + return ConditionalExpression.createConditionalExpression(test, consequent, alternate) + } + , + updateConditionalExpression(original: ConditionalExpression, test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression { + if (isSameNativeObject(test, original.test) && isSameNativeObject(consequent, original.consequent) && isSameNativeObject(alternate, original.alternate)) + return original + return updateNodeByNode(ConditionalExpression.createConditionalExpression(test, consequent, alternate), original) + } + , + createBigIntLiteral(str: string): BigIntLiteral { + return BigIntLiteral.createBigIntLiteral(str) + } + , + updateBigIntLiteral(original: BigIntLiteral, str: string): BigIntLiteral { + if (isSameNativeObject(str, original.str)) + return original + return updateNodeByNode(BigIntLiteral.createBigIntLiteral(str), original) + } + , + createTSImportType(param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType { + return TSImportType.createTSImportType(param, typeParams, qualifier, isTypeof) + } + , + updateTSImportType(original: TSImportType, param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType { + if (isSameNativeObject(param, original.param) && isSameNativeObject(typeParams, original.typeParams) && isSameNativeObject(qualifier, original.qualifier) && isSameNativeObject(isTypeof, original.isTypeof)) + return original + return updateNodeByNode(TSImportType.createTSImportType(param, typeParams, qualifier, isTypeof), original) + } + , + createTaggedTemplateExpression(tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression { + return TaggedTemplateExpression.createTaggedTemplateExpression(tag, quasi, typeParams) + } + , + updateTaggedTemplateExpression(original: TaggedTemplateExpression, tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression { + if (isSameNativeObject(tag, original.tag) && isSameNativeObject(quasi, original.quasi) && isSameNativeObject(typeParams, original.typeParams)) + return original + return updateNodeByNode(TaggedTemplateExpression.createTaggedTemplateExpression(tag, quasi, typeParams), original) + } + , + createFunctionDeclaration(_function: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], isAnonymous: boolean): FunctionDeclaration { + return FunctionDeclaration.createFunctionDeclaration(_function, annotations, isAnonymous) + } + , + updateFunctionDeclaration(original: FunctionDeclaration, _function: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], isAnonymous: boolean): FunctionDeclaration { + if (isSameNativeObject(_function, original.function) && isSameNativeObject(annotations, original.annotations) && isSameNativeObject(isAnonymous, original.isAnonymous)) + return original + return updateNodeByNode(FunctionDeclaration.createFunctionDeclaration(_function, annotations, isAnonymous), original) + } + , + createETSTypeReference(part?: ETSTypeReferencePart): ETSTypeReference { + return ETSTypeReference.createETSTypeReference(part) + } + , + updateETSTypeReference(original: ETSTypeReference, part?: ETSTypeReferencePart): ETSTypeReference { + if (isSameNativeObject(part, original.part)) + return original + return updateNodeByNode(ETSTypeReference.createETSTypeReference(part), original) + } + , + createTSTypeReference(typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference { + return TSTypeReference.createTSTypeReference(typeName, typeParams) + } + , + updateTSTypeReference(original: TSTypeReference, typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference { + if (isSameNativeObject(typeName, original.typeName) && isSameNativeObject(typeParams, original.typeParams)) + return original + return updateNodeByNode(TSTypeReference.createTSTypeReference(typeName, typeParams), original) + } + , + createNamedType(name?: Identifier): NamedType { + return NamedType.createNamedType(name) + } + , + updateNamedType(original: NamedType, name?: Identifier): NamedType { + if (isSameNativeObject(name, original.name)) + return original + return updateNodeByNode(NamedType.createNamedType(name), original) + } + , + createTemplateElement(raw: string, cooked: string): TemplateElement { + return TemplateElement.create1TemplateElement(raw, cooked) + } + , + updateTemplateElement(original: TemplateElement, raw: string, cooked: string): TemplateElement { + if (isSameNativeObject(raw, original.raw) && isSameNativeObject(cooked, original.cooked)) + return original + return updateNodeByNode(TemplateElement.create1TemplateElement(raw, cooked), original) + } + , + createVariableDeclaration(kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], annotations?: readonly AnnotationUsage[]): VariableDeclaration { + return VariableDeclaration.createVariableDeclaration(kind, declarators, annotations) + } + , + updateVariableDeclaration(original: VariableDeclaration, kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], annotations?: readonly AnnotationUsage[]): VariableDeclaration { + if (isSameNativeObject(kind, original.kind) && isSameNativeObject(declarators, original.declarators) && isSameNativeObject(annotations, original.annotations)) + return original + return updateNodeByNode(VariableDeclaration.createVariableDeclaration(kind, declarators, annotations), original) + } + , + createUndefinedLiteral(): UndefinedLiteral { + return UndefinedLiteral.createUndefinedLiteral() + } + , + updateUndefinedLiteral(original: UndefinedLiteral): UndefinedLiteral { + return updateNodeByNode(UndefinedLiteral.createUndefinedLiteral(), original) + } + , + createTSClassImplements(expr?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements { + return TSClassImplements.createTSClassImplements(expr, typeParameters) + } + , + updateTSClassImplements(original: TSClassImplements, expr?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements { + if (isSameNativeObject(expr, original.expr) && isSameNativeObject(typeParameters, original.typeParameters)) + return original + return updateNodeByNode(TSClassImplements.createTSClassImplements(expr, typeParameters), original) + } + , + createTSObjectKeyword(): TSObjectKeyword { + return TSObjectKeyword.createTSObjectKeyword() + } + , + updateTSObjectKeyword(original: TSObjectKeyword): TSObjectKeyword { + return updateNodeByNode(TSObjectKeyword.createTSObjectKeyword(), original) + } + , + createETSUnionType(types: readonly TypeNode[], annotations?: readonly AnnotationUsage[]): ETSUnionType { + return ETSUnionType.createETSUnionType(types, annotations) + } + , + updateETSUnionType(original: ETSUnionType, types: readonly TypeNode[], annotations?: readonly AnnotationUsage[]): ETSUnionType { + if (isSameNativeObject(types, original.types) && isSameNativeObject(annotations, original.annotations)) + return original + return updateNodeByNode(ETSUnionType.createETSUnionType(types, annotations), original) + } + , + createETSKeyofType(typeRef?: TypeNode): ETSKeyofType { + return ETSKeyofType.createETSKeyofType(typeRef) + } + , + updateETSKeyofType(original: ETSKeyofType, typeRef?: TypeNode): ETSKeyofType { + if (isSameNativeObject(typeRef, original.typeRef)) + return original + return updateNodeByNode(ETSKeyofType.createETSKeyofType(typeRef), original) + } + , + createTSConditionalType(checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType { + return TSConditionalType.createTSConditionalType(checkType, extendsType, trueType, falseType) + } + , + updateTSConditionalType(original: TSConditionalType, checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType { + if (isSameNativeObject(checkType, original.checkType) && isSameNativeObject(extendsType, original.extendsType) && isSameNativeObject(trueType, original.trueType) && isSameNativeObject(falseType, original.falseType)) + return original + return updateNodeByNode(TSConditionalType.createTSConditionalType(checkType, extendsType, trueType, falseType), original) + } + , + createTSLiteralType(literal?: Expression): TSLiteralType { + return TSLiteralType.createTSLiteralType(literal) + } + , + updateTSLiteralType(original: TSLiteralType, literal?: Expression): TSLiteralType { + if (isSameNativeObject(literal, original.literal)) + return original + return updateNodeByNode(TSLiteralType.createTSLiteralType(literal), original) + } + , + createTSTypeAliasDeclaration(id: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, typeAnnotation: TypeNode, annotations?: readonly AnnotationUsage[], modifierFlags?: Es2pandaModifierFlags): TSTypeAliasDeclaration { + return TSTypeAliasDeclaration.createTSTypeAliasDeclaration(id, typeParams, typeAnnotation, annotations, modifierFlags) + } + , + updateTSTypeAliasDeclaration(original: TSTypeAliasDeclaration, id: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, typeAnnotation: TypeNode, annotations?: readonly AnnotationUsage[], modifierFlags?: Es2pandaModifierFlags): TSTypeAliasDeclaration { + if (isSameNativeObject(id, original.id) && isSameNativeObject(typeParams, original.typeParams) && isSameNativeObject(typeAnnotation, original.typeAnnotation) && isSameNativeObject(annotations, original.annotations) && isSameNativeObject(modifierFlags, original.modifierFlags)) + return original + return updateNodeByNode(TSTypeAliasDeclaration.createTSTypeAliasDeclaration(id, typeParams, typeAnnotation, annotations, modifierFlags), original) + } + , + createDebuggerStatement(): DebuggerStatement { + return DebuggerStatement.createDebuggerStatement() + } + , + updateDebuggerStatement(original: DebuggerStatement): DebuggerStatement { + return updateNodeByNode(DebuggerStatement.createDebuggerStatement(), original) + } + , + createReturnStatement(argument?: Expression): ReturnStatement { + return ReturnStatement.create1ReturnStatement(argument) + } + , + updateReturnStatement(original: ReturnStatement, argument?: Expression): ReturnStatement { + if (isSameNativeObject(argument, original.argument)) + return original + return updateNodeByNode(ReturnStatement.create1ReturnStatement(argument), original) + } + , + createExportDefaultDeclaration(decl: AstNode | undefined, isExportEquals: boolean): ExportDefaultDeclaration { + return ExportDefaultDeclaration.createExportDefaultDeclaration(decl, isExportEquals) + } + , + updateExportDefaultDeclaration(original: ExportDefaultDeclaration, decl: AstNode | undefined, isExportEquals: boolean): ExportDefaultDeclaration { + if (isSameNativeObject(decl, original.decl) && isSameNativeObject(isExportEquals, original.isExportEquals)) + return original + return updateNodeByNode(ExportDefaultDeclaration.createExportDefaultDeclaration(decl, isExportEquals), original) + } + , + createTSInterfaceBody(body: readonly AstNode[]): TSInterfaceBody { + return TSInterfaceBody.createTSInterfaceBody(body) + } + , + updateTSInterfaceBody(original: TSInterfaceBody, body: readonly AstNode[]): TSInterfaceBody { + if (isSameNativeObject(body, original.body)) + return original + return updateNodeByNode(TSInterfaceBody.createTSInterfaceBody(body), original) + } + , + createTSTypeQuery(exprName?: Expression): TSTypeQuery { + return TSTypeQuery.createTSTypeQuery(exprName) + } + , + updateTSTypeQuery(original: TSTypeQuery, exprName?: Expression): TSTypeQuery { + if (isSameNativeObject(exprName, original.exprName)) + return original + return updateNodeByNode(TSTypeQuery.createTSTypeQuery(exprName), original) + } + , + createTSBigintKeyword(): TSBigintKeyword { + return TSBigintKeyword.createTSBigintKeyword() + } + , + updateTSBigintKeyword(original: TSBigintKeyword): TSBigintKeyword { + return updateNodeByNode(TSBigintKeyword.createTSBigintKeyword(), original) + } + , + createProperty(kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property { + return Property.create1Property(kind, key, value, isMethod, isComputed) + } + , + updateProperty(original: Property, kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property { + if (isSameNativeObject(kind, original.kind) && isSameNativeObject(key, original.key) && isSameNativeObject(value, original.value) && isSameNativeObject(isMethod, original.isMethod) && isSameNativeObject(isComputed, original.isComputed)) + return original + return updateNodeByNode(Property.create1Property(kind, key, value, isMethod, isComputed), original) + } + , + createStringLiteral(str: string): StringLiteral { + return StringLiteral.create1StringLiteral(str) + } + , + updateStringLiteral(original: StringLiteral, str: string): StringLiteral { + if (isSameNativeObject(str, original.str)) + return original + return updateNodeByNode(StringLiteral.create1StringLiteral(str), original) + } + , + createTSTypeAssertion(typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion { + return TSTypeAssertion.createTSTypeAssertion(typeAnnotation, expression) + } + , + updateTSTypeAssertion(original: TSTypeAssertion, typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion { + if (isSameNativeObject(typeAnnotation, original.typeAnnotation) && isSameNativeObject(expression, original.expression)) + return original + return updateNodeByNode(TSTypeAssertion.createTSTypeAssertion(typeAnnotation, expression), original) + } + , + createTSExternalModuleReference(expr?: Expression): TSExternalModuleReference { + return TSExternalModuleReference.createTSExternalModuleReference(expr) + } + , + updateTSExternalModuleReference(original: TSExternalModuleReference, expr?: Expression): TSExternalModuleReference { + if (isSameNativeObject(expr, original.expr)) + return original + return updateNodeByNode(TSExternalModuleReference.createTSExternalModuleReference(expr), original) + } + , + createTSUndefinedKeyword(): TSUndefinedKeyword { + return TSUndefinedKeyword.createTSUndefinedKeyword() + } + , + updateTSUndefinedKeyword(original: TSUndefinedKeyword): TSUndefinedKeyword { + return updateNodeByNode(TSUndefinedKeyword.createTSUndefinedKeyword(), original) + } + , + createUnaryExpression(argument: Expression | undefined, operatorType: Es2pandaTokenType): UnaryExpression { + return UnaryExpression.createUnaryExpression(argument, operatorType) + } + , + updateUnaryExpression(original: UnaryExpression, argument: Expression | undefined, operatorType: Es2pandaTokenType): UnaryExpression { + if (isSameNativeObject(argument, original.argument) && isSameNativeObject(operatorType, original.operatorType)) + return original + return updateNodeByNode(UnaryExpression.createUnaryExpression(argument, operatorType), original) + } + , + createForInStatement(left?: AstNode, right?: Expression, body?: Statement): ForInStatement { + return ForInStatement.createForInStatement(left, right, body) + } + , + updateForInStatement(original: ForInStatement, left?: AstNode, right?: Expression, body?: Statement): ForInStatement { + if (isSameNativeObject(left, original.left) && isSameNativeObject(right, original.right) && isSameNativeObject(body, original.body)) + return original + return updateNodeByNode(ForInStatement.createForInStatement(left, right, body), original) + } + , + createThisExpression(): ThisExpression { + return ThisExpression.createThisExpression() + } + , + updateThisExpression(original: ThisExpression): ThisExpression { + return updateNodeByNode(ThisExpression.createThisExpression(), original) + } + , + createBinaryExpression(left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression { + return BinaryExpression.createBinaryExpression(left, right, operatorType) + } + , + updateBinaryExpression(original: BinaryExpression, left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression { + if (isSameNativeObject(left, original.left) && isSameNativeObject(right, original.right) && isSameNativeObject(operatorType, original.operatorType)) + return original + return updateNodeByNode(BinaryExpression.createBinaryExpression(left, right, operatorType), original) + } + , + createSuperExpression(): SuperExpression { + return SuperExpression.createSuperExpression() + } + , + updateSuperExpression(original: SuperExpression): SuperExpression { + return updateNodeByNode(SuperExpression.createSuperExpression(), original) + } + , + createAssertStatement(test?: Expression, second?: Expression): AssertStatement { + return AssertStatement.createAssertStatement(test, second) + } + , + updateAssertStatement(original: AssertStatement, test?: Expression, second?: Expression): AssertStatement { + if (isSameNativeObject(test, original.test) && isSameNativeObject(second, original.second)) + return original + return updateNodeByNode(AssertStatement.createAssertStatement(test, second), original) + } + , + createTSStringKeyword(): TSStringKeyword { + return TSStringKeyword.createTSStringKeyword() + } + , + updateTSStringKeyword(original: TSStringKeyword): TSStringKeyword { + return updateNodeByNode(TSStringKeyword.createTSStringKeyword(), original) + } + , + createExpressionStatement(expression?: Expression): ExpressionStatement { + return ExpressionStatement.createExpressionStatement(expression) + } + , + updateExpressionStatement(original: ExpressionStatement, expression?: Expression): ExpressionStatement { + if (isSameNativeObject(expression, original.expression)) + return original + return updateNodeByNode(ExpressionStatement.createExpressionStatement(expression), original) + } + , + createMetaProperty(kind: Es2pandaMetaPropertyKind): MetaProperty { + return MetaProperty.createMetaProperty(kind) + } + , + updateMetaProperty(original: MetaProperty, kind: Es2pandaMetaPropertyKind): MetaProperty { + if (isSameNativeObject(kind, original.kind)) + return original + return updateNodeByNode(MetaProperty.createMetaProperty(kind), original) + } + , + createTSArrayType(elementType?: TypeNode): TSArrayType { + return TSArrayType.createTSArrayType(elementType) + } + , + updateTSArrayType(original: TSArrayType, elementType?: TypeNode): TSArrayType { + if (isSameNativeObject(elementType, original.elementType)) + return original + return updateNodeByNode(TSArrayType.createTSArrayType(elementType), original) + } + , + createExportAllDeclaration(source?: StringLiteral, exported?: Identifier): ExportAllDeclaration { + return ExportAllDeclaration.createExportAllDeclaration(source, exported) + } + , + updateExportAllDeclaration(original: ExportAllDeclaration, source?: StringLiteral, exported?: Identifier): ExportAllDeclaration { + if (isSameNativeObject(source, original.source) && isSameNativeObject(exported, original.exported)) + return original + return updateNodeByNode(ExportAllDeclaration.createExportAllDeclaration(source, exported), original) + } + , + createExportSpecifier(local?: Identifier, exported?: Identifier): ExportSpecifier { + return ExportSpecifier.createExportSpecifier(local, exported) + } + , + updateExportSpecifier(original: ExportSpecifier, local?: Identifier, exported?: Identifier): ExportSpecifier { + if (isSameNativeObject(local, original.local) && isSameNativeObject(exported, original.exported)) + return original + return updateNodeByNode(ExportSpecifier.createExportSpecifier(local, exported), original) + } + , + createTSTupleType(elementType: readonly TypeNode[]): TSTupleType { + return TSTupleType.createTSTupleType(elementType) + } + , + updateTSTupleType(original: TSTupleType, elementType: readonly TypeNode[]): TSTupleType { + if (isSameNativeObject(elementType, original.elementType)) + return original + return updateNodeByNode(TSTupleType.createTSTupleType(elementType), original) + } + , + createFunctionExpression(id?: Identifier, _function?: ScriptFunction): FunctionExpression { + return FunctionExpression.create1FunctionExpression(id, _function) + } + , + updateFunctionExpression(original: FunctionExpression, id?: Identifier, _function?: ScriptFunction): FunctionExpression { + if (isSameNativeObject(id, original.id) && isSameNativeObject(_function, original.function)) + return original + return updateNodeByNode(FunctionExpression.create1FunctionExpression(id, _function), original) + } + , + createTSIndexSignature(param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly: boolean): TSIndexSignature { + return TSIndexSignature.createTSIndexSignature(param, typeAnnotation, readonly) + } + , + updateTSIndexSignature(original: TSIndexSignature, param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly: boolean): TSIndexSignature { + if (isSameNativeObject(param, original.param) && isSameNativeObject(typeAnnotation, original.typeAnnotation) && isSameNativeObject(readonly, original.readonly)) + return original + return updateNodeByNode(TSIndexSignature.createTSIndexSignature(param, typeAnnotation, readonly), original) + } + , + createCharLiteral(): CharLiteral { + return CharLiteral.createCharLiteral() + } + , + updateCharLiteral(original: CharLiteral): CharLiteral { + return updateNodeByNode(CharLiteral.createCharLiteral(), original) + } + , + createETSIntrinsicNode(type: Es2pandaIntrinsicNodeType, _arguments: readonly Expression[]): ETSIntrinsicNode { + return ETSIntrinsicNode.create2ETSIntrinsicNode(type, _arguments) + } + , + updateETSIntrinsicNode(original: ETSIntrinsicNode, type: Es2pandaIntrinsicNodeType, _arguments: readonly Expression[]): ETSIntrinsicNode { + if (isSameNativeObject(type, original.type) && isSameNativeObject(_arguments, original.arguments)) + return original + return updateNodeByNode(ETSIntrinsicNode.create2ETSIntrinsicNode(type, _arguments), original) + } + , + createTSModuleBlock(statements: readonly Statement[]): TSModuleBlock { + return TSModuleBlock.createTSModuleBlock(statements) + } + , + updateTSModuleBlock(original: TSModuleBlock, statements: readonly Statement[]): TSModuleBlock { + if (isSameNativeObject(statements, original.statements)) + return original + return updateNodeByNode(TSModuleBlock.createTSModuleBlock(statements), original) + } + , + createETSNewArrayInstanceExpression(typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression { + return ETSNewArrayInstanceExpression.createETSNewArrayInstanceExpression(typeReference, dimension) + } + , + updateETSNewArrayInstanceExpression(original: ETSNewArrayInstanceExpression, typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression { + if (isSameNativeObject(typeReference, original.typeReference) && isSameNativeObject(dimension, original.dimension)) + return original + return updateNodeByNode(ETSNewArrayInstanceExpression.createETSNewArrayInstanceExpression(typeReference, dimension), original) + } + , + createAnnotationDeclaration(expr: Expression | undefined, properties: readonly AstNode[]): AnnotationDeclaration { + return AnnotationDeclaration.create1AnnotationDeclaration(expr, properties) + } + , + updateAnnotationDeclaration(original: AnnotationDeclaration, expr: Expression | undefined, properties: readonly AstNode[]): AnnotationDeclaration { + if (isSameNativeObject(expr, original.expr) && isSameNativeObject(properties, original.properties)) + return original + return updateNodeByNode(AnnotationDeclaration.create1AnnotationDeclaration(expr, properties), original) + } + , + createAnnotationUsage(expr: Expression | undefined, properties: readonly AstNode[]): AnnotationUsage { + return AnnotationUsage.create1AnnotationUsage(expr, properties) + } + , + updateAnnotationUsage(original: AnnotationUsage, expr: Expression | undefined, properties: readonly AstNode[]): AnnotationUsage { + if (isSameNativeObject(expr, original.expr) && isSameNativeObject(properties, original.properties)) + return original + return updateNodeByNode(AnnotationUsage.create1AnnotationUsage(expr, properties), original) + } + , + createEmptyStatement(isBrokenStatement: boolean): EmptyStatement { + return EmptyStatement.create1EmptyStatement(isBrokenStatement) + } + , + updateEmptyStatement(original: EmptyStatement, isBrokenStatement: boolean): EmptyStatement { + if (isSameNativeObject(isBrokenStatement, original.isBrokenStatement)) + return original + return updateNodeByNode(EmptyStatement.create1EmptyStatement(isBrokenStatement), original) + } + , + createWhileStatement(test?: Expression, body?: Statement): WhileStatement { + return WhileStatement.createWhileStatement(test, body) + } + , + updateWhileStatement(original: WhileStatement, test?: Expression, body?: Statement): WhileStatement { + if (isSameNativeObject(test, original.test) && isSameNativeObject(body, original.body)) + return original + return updateNodeByNode(WhileStatement.createWhileStatement(test, body), original) + } + , + createFunctionSignature(typeParams: TSTypeParameterDeclaration | undefined, params: readonly Expression[], returnType: TypeNode | undefined, hasReceiver: boolean): FunctionSignature { + return FunctionSignature.createFunctionSignature(typeParams, params, returnType, hasReceiver) + } + , + updateFunctionSignature(original: FunctionSignature, typeParams: TSTypeParameterDeclaration | undefined, params: readonly Expression[], returnType: TypeNode | undefined, hasReceiver: boolean): FunctionSignature { + if (isSameNativeObject(typeParams, original.typeParams) && isSameNativeObject(params, original.params) && isSameNativeObject(returnType, original.returnType) && isSameNativeObject(hasReceiver, original.hasReceiver)) + return original + return updateNodeByNode(FunctionSignature.createFunctionSignature(typeParams, params, returnType, hasReceiver), original) + } + , + createChainExpression(expression?: Expression): ChainExpression { + return ChainExpression.createChainExpression(expression) + } + , + updateChainExpression(original: ChainExpression, expression?: Expression): ChainExpression { + if (isSameNativeObject(expression, original.expression)) + return original + return updateNodeByNode(ChainExpression.createChainExpression(expression), original) + } + , + createTSIntersectionType(types: readonly Expression[]): TSIntersectionType { + return TSIntersectionType.createTSIntersectionType(types) + } + , + updateTSIntersectionType(original: TSIntersectionType, types: readonly Expression[]): TSIntersectionType { + if (isSameNativeObject(types, original.types)) + return original + return updateNodeByNode(TSIntersectionType.createTSIntersectionType(types), original) + } + , + createUpdateExpression(argument: Expression | undefined, operatorType: Es2pandaTokenType, isPrefix: boolean): UpdateExpression { + return UpdateExpression.createUpdateExpression(argument, operatorType, isPrefix) + } + , + updateUpdateExpression(original: UpdateExpression, argument: Expression | undefined, operatorType: Es2pandaTokenType, isPrefix: boolean): UpdateExpression { + if (isSameNativeObject(argument, original.argument) && isSameNativeObject(operatorType, original.operatorType) && isSameNativeObject(isPrefix, original.isPrefix)) + return original + return updateNodeByNode(UpdateExpression.createUpdateExpression(argument, operatorType, isPrefix), original) + } + , + createBlockExpression(statements: readonly Statement[]): BlockExpression { + return BlockExpression.createBlockExpression(statements) + } + , + updateBlockExpression(original: BlockExpression, statements: readonly Statement[]): BlockExpression { + if (isSameNativeObject(statements, original.statements)) + return original + return updateNodeByNode(BlockExpression.createBlockExpression(statements), original) + } + , + createTSTypeLiteral(members: readonly AstNode[]): TSTypeLiteral { + return TSTypeLiteral.createTSTypeLiteral(members) + } + , + updateTSTypeLiteral(original: TSTypeLiteral, members: readonly AstNode[]): TSTypeLiteral { + if (isSameNativeObject(members, original.members)) + return original + return updateNodeByNode(TSTypeLiteral.createTSTypeLiteral(members), original) + } + , + createTSBooleanKeyword(): TSBooleanKeyword { + return TSBooleanKeyword.createTSBooleanKeyword() + } + , + updateTSBooleanKeyword(original: TSBooleanKeyword): TSBooleanKeyword { + return updateNodeByNode(TSBooleanKeyword.createTSBooleanKeyword(), original) + } + , + createTSTypePredicate(parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate { + return TSTypePredicate.createTSTypePredicate(parameterName, typeAnnotation, asserts) + } + , + updateTSTypePredicate(original: TSTypePredicate, parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate { + if (isSameNativeObject(parameterName, original.parameterName) && isSameNativeObject(typeAnnotation, original.typeAnnotation) && isSameNativeObject(asserts, original.asserts)) + return original + return updateNodeByNode(TSTypePredicate.createTSTypePredicate(parameterName, typeAnnotation, asserts), original) + } + , + createImportNamespaceSpecifier(local?: Identifier): ImportNamespaceSpecifier { + return ImportNamespaceSpecifier.createImportNamespaceSpecifier(local) + } + , + updateImportNamespaceSpecifier(original: ImportNamespaceSpecifier, local?: Identifier): ImportNamespaceSpecifier { + if (isSameNativeObject(local, original.local)) + return original + return updateNodeByNode(ImportNamespaceSpecifier.createImportNamespaceSpecifier(local), original) + } + , + createTSTypeParameterInstantiation(params: readonly TypeNode[]): TSTypeParameterInstantiation { + return TSTypeParameterInstantiation.createTSTypeParameterInstantiation(params) + } + , + updateTSTypeParameterInstantiation(original: TSTypeParameterInstantiation, params: readonly TypeNode[]): TSTypeParameterInstantiation { + if (isSameNativeObject(params, original.params)) + return original + return updateNodeByNode(TSTypeParameterInstantiation.createTSTypeParameterInstantiation(params), original) + } + , + createNullLiteral(): NullLiteral { + return NullLiteral.createNullLiteral() + } + , + updateNullLiteral(original: NullLiteral): NullLiteral { + return updateNodeByNode(NullLiteral.createNullLiteral(), original) + } + , + createTSInferType(typeParam?: TSTypeParameter): TSInferType { + return TSInferType.createTSInferType(typeParam) + } + , + updateTSInferType(original: TSInferType, typeParam?: TSTypeParameter): TSInferType { + if (isSameNativeObject(typeParam, original.typeParam)) + return original + return updateNodeByNode(TSInferType.createTSInferType(typeParam), original) + } + , + createSwitchCaseStatement(test: Expression | undefined, consequent: readonly Statement[]): SwitchCaseStatement { + return SwitchCaseStatement.createSwitchCaseStatement(test, consequent) + } + , + updateSwitchCaseStatement(original: SwitchCaseStatement, test: Expression | undefined, consequent: readonly Statement[]): SwitchCaseStatement { + if (isSameNativeObject(test, original.test) && isSameNativeObject(consequent, original.consequent)) + return original + return updateNodeByNode(SwitchCaseStatement.createSwitchCaseStatement(test, consequent), original) + } + , + createYieldExpression(argument: Expression | undefined, hasDelegate: boolean): YieldExpression { + return YieldExpression.createYieldExpression(argument, hasDelegate) + } + , + updateYieldExpression(original: YieldExpression, argument: Expression | undefined, hasDelegate: boolean): YieldExpression { + if (isSameNativeObject(argument, original.argument) && isSameNativeObject(hasDelegate, original.hasDelegate)) + return original + return updateNodeByNode(YieldExpression.createYieldExpression(argument, hasDelegate), original) + } + , + createTSImportEqualsDeclaration(id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration { + return TSImportEqualsDeclaration.createTSImportEqualsDeclaration(id, moduleReference, isExport) + } + , + updateTSImportEqualsDeclaration(original: TSImportEqualsDeclaration, id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration { + if (isSameNativeObject(id, original.id) && isSameNativeObject(moduleReference, original.moduleReference) && isSameNativeObject(isExport, original.isExport)) + return original + return updateNodeByNode(TSImportEqualsDeclaration.createTSImportEqualsDeclaration(id, moduleReference, isExport), original) + } + , + createBooleanLiteral(value: boolean): BooleanLiteral { + return BooleanLiteral.createBooleanLiteral(value) + } + , + updateBooleanLiteral(original: BooleanLiteral, value: boolean): BooleanLiteral { + if (isSameNativeObject(value, original.value)) + return original + return updateNodeByNode(BooleanLiteral.createBooleanLiteral(value), original) + } + , + createTSNumberKeyword(): TSNumberKeyword { + return TSNumberKeyword.createTSNumberKeyword() + } + , + updateTSNumberKeyword(original: TSNumberKeyword): TSNumberKeyword { + return updateNodeByNode(TSNumberKeyword.createTSNumberKeyword(), original) + } + , + createTSNonNullExpression(expr?: Expression): TSNonNullExpression { + return TSNonNullExpression.createTSNonNullExpression(expr) + } + , + updateTSNonNullExpression(original: TSNonNullExpression, expr?: Expression): TSNonNullExpression { + if (isSameNativeObject(expr, original.expr)) + return original + return updateNodeByNode(TSNonNullExpression.createTSNonNullExpression(expr), original) + } + , + createPrefixAssertionExpression(expr?: Expression, type?: TypeNode): PrefixAssertionExpression { + return PrefixAssertionExpression.createPrefixAssertionExpression(expr, type) + } + , + updatePrefixAssertionExpression(original: PrefixAssertionExpression, expr?: Expression, type?: TypeNode): PrefixAssertionExpression { + if (isSameNativeObject(expr, original.expr) && isSameNativeObject(type, original.type)) + return original + return updateNodeByNode(PrefixAssertionExpression.createPrefixAssertionExpression(expr, type), original) + } + , + createClassExpression(definition?: ClassDefinition): ClassExpression { + return ClassExpression.createClassExpression(definition) + } + , + updateClassExpression(original: ClassExpression, definition?: ClassDefinition): ClassExpression { + if (isSameNativeObject(definition, original.definition)) + return original + return updateNodeByNode(ClassExpression.createClassExpression(definition), original) + } + , + createForOfStatement(left: AstNode | undefined, right: Expression | undefined, body: Statement | undefined, isAwait: boolean): ForOfStatement { + return ForOfStatement.createForOfStatement(left, right, body, isAwait) + } + , + updateForOfStatement(original: ForOfStatement, left: AstNode | undefined, right: Expression | undefined, body: Statement | undefined, isAwait: boolean): ForOfStatement { + if (isSameNativeObject(left, original.left) && isSameNativeObject(right, original.right) && isSameNativeObject(body, original.body) && isSameNativeObject(isAwait, original.isAwait)) + return original + return updateNodeByNode(ForOfStatement.createForOfStatement(left, right, body, isAwait), original) + } + , + createTemplateLiteral(quasis: readonly TemplateElement[], expressions: readonly Expression[], multilineString: string): TemplateLiteral { + return TemplateLiteral.createTemplateLiteral(quasis, expressions, multilineString) + } + , + updateTemplateLiteral(original: TemplateLiteral, quasis: readonly TemplateElement[], expressions: readonly Expression[], multilineString: string): TemplateLiteral { + if (isSameNativeObject(quasis, original.quasis) && isSameNativeObject(expressions, original.expressions) && isSameNativeObject(multilineString, original.multilineString)) + return original + return updateNodeByNode(TemplateLiteral.createTemplateLiteral(quasis, expressions, multilineString), original) + } + , + createTSUnionType(types: readonly TypeNode[]): TSUnionType { + return TSUnionType.createTSUnionType(types) + } + , + updateTSUnionType(original: TSUnionType, types: readonly TypeNode[]): TSUnionType { + if (isSameNativeObject(types, original.types)) + return original + return updateNodeByNode(TSUnionType.createTSUnionType(types), original) + } + , + createTSUnknownKeyword(): TSUnknownKeyword { + return TSUnknownKeyword.createTSUnknownKeyword() + } + , + updateTSUnknownKeyword(original: TSUnknownKeyword): TSUnknownKeyword { + return updateNodeByNode(TSUnknownKeyword.createTSUnknownKeyword(), original) + } + , + createIdentifier(name: string, typeAnnotation?: TypeNode): Identifier { + return Identifier.create2Identifier(name, typeAnnotation) + } + , + updateIdentifier(original: Identifier, name: string, typeAnnotation?: TypeNode): Identifier { + if (isSameNativeObject(name, original.name) && isSameNativeObject(typeAnnotation, original.typeAnnotation)) + return original + return updateNodeByNode(Identifier.create2Identifier(name, typeAnnotation), original) + } + , + createOpaqueTypeNode(): OpaqueTypeNode { + return OpaqueTypeNode.create1OpaqueTypeNode() + } + , + updateOpaqueTypeNode(original: OpaqueTypeNode): OpaqueTypeNode { + return updateNodeByNode(OpaqueTypeNode.create1OpaqueTypeNode(), original) + } + , + createTSTypeParameterDeclaration(params: readonly TSTypeParameter[], requiredParams: number): TSTypeParameterDeclaration { + return TSTypeParameterDeclaration.createTSTypeParameterDeclaration(params, requiredParams) + } + , + updateTSTypeParameterDeclaration(original: TSTypeParameterDeclaration, params: readonly TSTypeParameter[], requiredParams: number): TSTypeParameterDeclaration { + if (isSameNativeObject(params, original.params) && isSameNativeObject(requiredParams, original.requiredParams)) + return original + return updateNodeByNode(TSTypeParameterDeclaration.createTSTypeParameterDeclaration(params, requiredParams), original) + } + , + createTSNullKeyword(): TSNullKeyword { + return TSNullKeyword.createTSNullKeyword() + } + , + updateTSNullKeyword(original: TSNullKeyword): TSNullKeyword { + return updateNodeByNode(TSNullKeyword.createTSNullKeyword(), original) + } + , + createTSInterfaceHeritage(expr?: TypeNode): TSInterfaceHeritage { + return TSInterfaceHeritage.createTSInterfaceHeritage(expr) + } + , + updateTSInterfaceHeritage(original: TSInterfaceHeritage, expr?: TypeNode): TSInterfaceHeritage { + if (isSameNativeObject(expr, original.expr)) + return original + return updateNodeByNode(TSInterfaceHeritage.createTSInterfaceHeritage(expr), original) + } + , + createETSClassLiteral(expr?: TypeNode): ETSClassLiteral { + return ETSClassLiteral.createETSClassLiteral(expr) + } + , + updateETSClassLiteral(original: ETSClassLiteral, expr?: TypeNode): ETSClassLiteral { + if (isSameNativeObject(expr, original.expr)) + return original + return updateNodeByNode(ETSClassLiteral.createETSClassLiteral(expr), original) + } + , + createBreakStatement(ident?: Identifier): BreakStatement { + return BreakStatement.create1BreakStatement(ident) + } + , + updateBreakStatement(original: BreakStatement, ident?: Identifier): BreakStatement { + if (isSameNativeObject(ident, original.ident)) + return original + return updateNodeByNode(BreakStatement.create1BreakStatement(ident), original) + } + , + createTSAnyKeyword(): TSAnyKeyword { + return TSAnyKeyword.createTSAnyKeyword() + } + , + updateTSAnyKeyword(original: TSAnyKeyword): TSAnyKeyword { + return updateNodeByNode(TSAnyKeyword.createTSAnyKeyword(), original) + } + , + createClassDeclaration(definition: ClassDefinition, modifierFlags?: Es2pandaModifierFlags): ClassDeclaration { + return ClassDeclaration.createClassDeclaration(definition, modifierFlags) + } + , + updateClassDeclaration(original: ClassDeclaration, definition: ClassDefinition, modifierFlags?: Es2pandaModifierFlags): ClassDeclaration { + if (isSameNativeObject(definition, original.definition) && isSameNativeObject(modifierFlags, original.modifierFlags)) + return original + return updateNodeByNode(ClassDeclaration.createClassDeclaration(definition, modifierFlags), original) + } + , + createTSIndexedAccessType(objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType { + return TSIndexedAccessType.createTSIndexedAccessType(objectType, indexType) + } + , + updateTSIndexedAccessType(original: TSIndexedAccessType, objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType { + if (isSameNativeObject(objectType, original.objectType) && isSameNativeObject(indexType, original.indexType)) + return original + return updateNodeByNode(TSIndexedAccessType.createTSIndexedAccessType(objectType, indexType), original) + } + , + createTSQualifiedName(left?: Expression, right?: Identifier): TSQualifiedName { + return TSQualifiedName.createTSQualifiedName(left, right) + } + , + updateTSQualifiedName(original: TSQualifiedName, left?: Expression, right?: Identifier): TSQualifiedName { + if (isSameNativeObject(left, original.left) && isSameNativeObject(right, original.right)) + return original + return updateNodeByNode(TSQualifiedName.createTSQualifiedName(left, right), original) + } + , + createAwaitExpression(argument?: Expression): AwaitExpression { + return AwaitExpression.createAwaitExpression(argument) + } + , + updateAwaitExpression(original: AwaitExpression, argument?: Expression): AwaitExpression { + if (isSameNativeObject(argument, original.argument)) + return original + return updateNodeByNode(AwaitExpression.createAwaitExpression(argument), original) + } + , + createContinueStatement(ident?: Identifier): ContinueStatement { + return ContinueStatement.create1ContinueStatement(ident) + } + , + updateContinueStatement(original: ContinueStatement, ident?: Identifier): ContinueStatement { + if (isSameNativeObject(ident, original.ident)) + return original + return updateNodeByNode(ContinueStatement.create1ContinueStatement(ident), original) + } + , + createETSNewMultiDimArrayInstanceExpression(typeReference: TypeNode | undefined, dimensions: readonly Expression[]): ETSNewMultiDimArrayInstanceExpression { + return ETSNewMultiDimArrayInstanceExpression.createETSNewMultiDimArrayInstanceExpression(typeReference, dimensions) + } + , + updateETSNewMultiDimArrayInstanceExpression(original: ETSNewMultiDimArrayInstanceExpression, typeReference: TypeNode | undefined, dimensions: readonly Expression[]): ETSNewMultiDimArrayInstanceExpression { + if (isSameNativeObject(typeReference, original.typeReference) && isSameNativeObject(dimensions, original.dimensions)) + return original + return updateNodeByNode(ETSNewMultiDimArrayInstanceExpression.createETSNewMultiDimArrayInstanceExpression(typeReference, dimensions), original) + } + , + createTSNamedTupleMember(label: Expression | undefined, elementType: TypeNode | undefined, isOptional: boolean): TSNamedTupleMember { + return TSNamedTupleMember.createTSNamedTupleMember(label, elementType, isOptional) + } + , + updateTSNamedTupleMember(original: TSNamedTupleMember, label: Expression | undefined, elementType: TypeNode | undefined, isOptional: boolean): TSNamedTupleMember { + if (isSameNativeObject(label, original.label) && isSameNativeObject(elementType, original.elementType) && isSameNativeObject(isOptional, original.isOptional)) + return original + return updateNodeByNode(TSNamedTupleMember.createTSNamedTupleMember(label, elementType, isOptional), original) + } + , + createImportExpression(source?: Expression): ImportExpression { + return ImportExpression.createImportExpression(source) + } + , + updateImportExpression(original: ImportExpression, source?: Expression): ImportExpression { + if (isSameNativeObject(source, original.source)) + return original + return updateNodeByNode(ImportExpression.createImportExpression(source), original) + } + , + createETSNullType(): ETSNullType { + return ETSNullType.createETSNullType() + } + , + updateETSNullType(original: ETSNullType): ETSNullType { + return updateNodeByNode(ETSNullType.createETSNullType(), original) + } + , + createETSUndefinedType(): ETSUndefinedType { + return ETSUndefinedType.createETSUndefinedType() + } + , + updateETSUndefinedType(original: ETSUndefinedType): ETSUndefinedType { + return updateNodeByNode(ETSUndefinedType.createETSUndefinedType(), original) + } + , + createTypeofExpression(argument?: Expression): TypeofExpression { + return TypeofExpression.createTypeofExpression(argument) + } + , + updateTypeofExpression(original: TypeofExpression, argument?: Expression): TypeofExpression { + if (isSameNativeObject(argument, original.argument)) + return original + return updateNodeByNode(TypeofExpression.createTypeofExpression(argument), original) + } + , + createTSEnumMember(key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember { + return TSEnumMember.create1TSEnumMember(key, init, isGenerated) + } + , + updateTSEnumMember(original: TSEnumMember, key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember { + if (isSameNativeObject(key, original.key) && isSameNativeObject(init, original.init) && isSameNativeObject(isGenerated, original.isGenerated)) + return original + return updateNodeByNode(TSEnumMember.create1TSEnumMember(key, init, isGenerated), original) + } + , + createSwitchStatement(discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[]): SwitchStatement { + return SwitchStatement.createSwitchStatement(discriminant, cases) + } + , + updateSwitchStatement(original: SwitchStatement, discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[]): SwitchStatement { + if (isSameNativeObject(discriminant, original.discriminant) && isSameNativeObject(cases, original.cases)) + return original + return updateNodeByNode(SwitchStatement.createSwitchStatement(discriminant, cases), original) + } + , + createDoWhileStatement(body?: Statement, test?: Expression): DoWhileStatement { + return DoWhileStatement.createDoWhileStatement(body, test) + } + , + updateDoWhileStatement(original: DoWhileStatement, body?: Statement, test?: Expression): DoWhileStatement { + if (isSameNativeObject(body, original.body) && isSameNativeObject(test, original.test)) + return original + return updateNodeByNode(DoWhileStatement.createDoWhileStatement(body, test), original) + } + , + createCatchClause(param?: Expression, body?: BlockStatement): CatchClause { + return CatchClause.createCatchClause(param, body) + } + , + updateCatchClause(original: CatchClause, param?: Expression, body?: BlockStatement): CatchClause { + if (isSameNativeObject(param, original.param) && isSameNativeObject(body, original.body)) + return original + return updateNodeByNode(CatchClause.createCatchClause(param, body), original) + } + , + createSequenceExpression(sequence: readonly Expression[]): SequenceExpression { + return SequenceExpression.createSequenceExpression(sequence) + } + , + updateSequenceExpression(original: SequenceExpression, sequence: readonly Expression[]): SequenceExpression { + if (isSameNativeObject(sequence, original.sequence)) + return original + return updateNodeByNode(SequenceExpression.createSequenceExpression(sequence), original) + } + , + createArrowFunctionExpression(_function?: ScriptFunction, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression { + return ArrowFunctionExpression.createArrowFunctionExpression(_function, annotations) + } + , + updateArrowFunctionExpression(original: ArrowFunctionExpression, _function?: ScriptFunction, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression { + if (isSameNativeObject(_function, original.function) && isSameNativeObject(annotations, original.annotations)) + return original + return updateNodeByNode(ArrowFunctionExpression.createArrowFunctionExpression(_function, annotations), original) + } + , + createOmittedExpression(): OmittedExpression { + return OmittedExpression.createOmittedExpression() + } + , + updateOmittedExpression(original: OmittedExpression): OmittedExpression { + return updateNodeByNode(OmittedExpression.createOmittedExpression(), original) + } + , + createETSNewClassInstanceExpression(typeRef: Expression | undefined, _arguments: readonly Expression[]): ETSNewClassInstanceExpression { + return ETSNewClassInstanceExpression.createETSNewClassInstanceExpression(typeRef, _arguments) + } + , + updateETSNewClassInstanceExpression(original: ETSNewClassInstanceExpression, typeRef: Expression | undefined, _arguments: readonly Expression[]): ETSNewClassInstanceExpression { + if (isSameNativeObject(typeRef, original.typeRef) && isSameNativeObject(_arguments, original.arguments)) + return original + return updateNodeByNode(ETSNewClassInstanceExpression.createETSNewClassInstanceExpression(typeRef, _arguments), original) + } + , + createTSAsExpression(expr: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression { + return TSAsExpression.createTSAsExpression(expr, typeAnnotation, isConst) + } + , + updateTSAsExpression(original: TSAsExpression, expr: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression { + if (isSameNativeObject(expr, original.expr) && isSameNativeObject(typeAnnotation, original.typeAnnotation) && isSameNativeObject(isConst, original.isConst)) + return original + return updateNodeByNode(TSAsExpression.createTSAsExpression(expr, typeAnnotation, isConst), original) + } + , + createForUpdateStatement(init?: AstNode, test?: Expression, update?: Expression, body?: Statement): ForUpdateStatement { + return ForUpdateStatement.createForUpdateStatement(init, test, update, body) + } + , + updateForUpdateStatement(original: ForUpdateStatement, init?: AstNode, test?: Expression, update?: Expression, body?: Statement): ForUpdateStatement { + if (isSameNativeObject(init, original.init) && isSameNativeObject(test, original.test) && isSameNativeObject(update, original.update) && isSameNativeObject(body, original.body)) + return original + return updateNodeByNode(ForUpdateStatement.createForUpdateStatement(init, test, update, body), original) + } + , + createETSPrimitiveType(primitiveType: Es2pandaPrimitiveType): ETSPrimitiveType { + return ETSPrimitiveType.createETSPrimitiveType(primitiveType) + } + , + updateETSPrimitiveType(original: ETSPrimitiveType, primitiveType: Es2pandaPrimitiveType): ETSPrimitiveType { + if (isSameNativeObject(primitiveType, original.primitiveType)) + return original + return updateNodeByNode(ETSPrimitiveType.createETSPrimitiveType(primitiveType), original) + } + , + createNewExpression(callee: Expression | undefined, _arguments: readonly Expression[]): NewExpression { + return NewExpression.createNewExpression(callee, _arguments) + } + , + updateNewExpression(original: NewExpression, callee: Expression | undefined, _arguments: readonly Expression[]): NewExpression { + if (isSameNativeObject(callee, original.callee) && isSameNativeObject(_arguments, original.arguments)) + return original + return updateNodeByNode(NewExpression.createNewExpression(callee, _arguments), original) + } + , + createTSThisType(): TSThisType { + return TSThisType.createTSThisType() + } + , + updateTSThisType(original: TSThisType): TSThisType { + return updateNodeByNode(TSThisType.createTSThisType(), original) + } + , +} diff --git a/ets1.2/libarkts/src/generated/index.ts b/ets1.2/libarkts/src/generated/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..0f83da4c6f2c9f632a3d5f129159f6db9134b076 --- /dev/null +++ b/ets1.2/libarkts/src/generated/index.ts @@ -0,0 +1,222 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + + +export * from "./peers/SourcePosition" +export * from "./peers/SourceRange" +export * from "./peers/SrcDumper" +export * from "./peers/AstDumper" +export * from "./peers/LabelPair" +export * from "./peers/ScriptFunctionData" +export * from "./peers/ImportSource" +export * from "./peers/SignatureInfo" +export * from "./peers/ValidationInfo" +export * from "./peers/IndexInfo" +export * from "./peers/ObjectDescriptor" +export * from "./peers/ScopeFindResult" +export * from "./peers/BindingProps" +export * from "./peers/Declaration" +export * from "./peers/AstVisitor" +export * from "./peers/AstVerifier" +export * from "./peers/VerifierMessage" +export * from "./peers/CodeGen" +export * from "./peers/VReg" +export * from "./peers/IRNode" +export * from "./peers/ErrorLogger" +export * from "./peers/VerificationContext" +export * from "./peers/DynamicImportData" +export * from "./peers/SuggestionInfo" +export * from "./peers/DiagnosticInfo" +export * from "./peers/NumberLiteral" +export * from "./peers/TypedAstNode" +export * from "./peers/AnnotatedAstNode" +export * from "./peers/TypedStatement" +export * from "./peers/AnnotatedStatement" +export * from "./peers/LabelledStatement" +export * from "./peers/ThrowStatement" +export * from "./peers/ClassProperty" +export * from "./peers/TSVoidKeyword" +export * from "./peers/ETSFunctionType" +export * from "./peers/TSTypeOperator" +export * from "./peers/IfStatement" +export * from "./peers/TSConstructorType" +export * from "./peers/Decorator" +export * from "./peers/TSEnumDeclaration" +export * from "./peers/TSNeverKeyword" +export * from "./peers/ImportDefaultSpecifier" +export * from "./peers/ObjectExpression" +export * from "./peers/ImportSpecifier" +export * from "./peers/ConditionalExpression" +export * from "./peers/CallExpression" +export * from "./peers/BigIntLiteral" +export * from "./peers/ClassElement" +export * from "./peers/TSImportType" +export * from "./peers/TaggedTemplateExpression" +export * from "./peers/FunctionDeclaration" +export * from "./peers/ETSTypeReference" +export * from "./peers/TSTypeReference" +export * from "./peers/NamedType" +export * from "./peers/TSFunctionType" +export * from "./peers/TemplateElement" +export * from "./peers/TSInterfaceDeclaration" +export * from "./peers/VariableDeclaration" +export * from "./peers/UndefinedLiteral" +export * from "./peers/MemberExpression" +export * from "./peers/TSClassImplements" +export * from "./peers/TSObjectKeyword" +export * from "./peers/ETSUnionType" +export * from "./peers/ETSKeyofType" +export * from "./peers/TSPropertySignature" +export * from "./peers/TSConditionalType" +export * from "./peers/TSLiteralType" +export * from "./peers/TSTypeAliasDeclaration" +export * from "./peers/DebuggerStatement" +export * from "./peers/ReturnStatement" +export * from "./peers/ExportDefaultDeclaration" +export * from "./peers/ScriptFunction" +export * from "./peers/ClassDefinition" +export * from "./peers/ArrayExpression" +export * from "./peers/TSInterfaceBody" +export * from "./peers/TSTypeQuery" +export * from "./peers/TSBigintKeyword" +export * from "./peers/Property" +export * from "./peers/VariableDeclarator" +export * from "./peers/StringLiteral" +export * from "./peers/TSTypeAssertion" +export * from "./peers/TSExternalModuleReference" +export * from "./peers/TSUndefinedKeyword" +export * from "./peers/ETSTuple" +export * from "./peers/ETSStringLiteralType" +export * from "./peers/TryStatement" +export * from "./peers/UnaryExpression" +export * from "./peers/ForInStatement" +export * from "./peers/ThisExpression" +export * from "./peers/TSMethodSignature" +export * from "./peers/BinaryExpression" +export * from "./peers/SuperExpression" +export * from "./peers/AssertStatement" +export * from "./peers/TSStringKeyword" +export * from "./peers/AssignmentExpression" +export * from "./peers/ExpressionStatement" +export * from "./peers/ETSModule" +export * from "./peers/MetaProperty" +export * from "./peers/TSArrayType" +export * from "./peers/TSSignatureDeclaration" +export * from "./peers/ExportAllDeclaration" +export * from "./peers/ExportSpecifier" +export * from "./peers/TSTupleType" +export * from "./peers/FunctionExpression" +export * from "./peers/TSIndexSignature" +export * from "./peers/TSModuleDeclaration" +export * from "./peers/ImportDeclaration" +export * from "./peers/TSParenthesizedType" +export * from "./peers/Literal" +export * from "./peers/CharLiteral" +export * from "./peers/ETSIntrinsicNode" +export * from "./peers/ETSPackageDeclaration" +export * from "./peers/ETSImportDeclaration" +export * from "./peers/ETSStructDeclaration" +export * from "./peers/TSModuleBlock" +export * from "./peers/ETSNewArrayInstanceExpression" +export * from "./peers/LoopStatement" +export * from "./peers/AnnotationDeclaration" +export * from "./peers/AnnotationUsage" +export * from "./peers/EmptyStatement" +export * from "./peers/WhileStatement" +export * from "./peers/FunctionSignature" +export * from "./peers/ChainExpression" +export * from "./peers/TSIntersectionType" +export * from "./peers/UpdateExpression" +export * from "./peers/BlockExpression" +export * from "./peers/TSTypeLiteral" +export * from "./peers/TSTypeParameter" +export * from "./peers/TSBooleanKeyword" +export * from "./peers/SpreadElement" +export * from "./peers/TSTypePredicate" +export * from "./peers/ImportNamespaceSpecifier" +export * from "./peers/ExportNamedDeclaration" +export * from "./peers/ETSParameterExpression" +export * from "./peers/TSTypeParameterInstantiation" +export * from "./peers/NullLiteral" +export * from "./peers/TSInferType" +export * from "./peers/SwitchCaseStatement" +export * from "./peers/YieldExpression" +export * from "./peers/TSImportEqualsDeclaration" +export * from "./peers/BooleanLiteral" +export * from "./peers/TSNumberKeyword" +export * from "./peers/ClassStaticBlock" +export * from "./peers/TSNonNullExpression" +export * from "./peers/PrefixAssertionExpression" +export * from "./peers/ClassExpression" +export * from "./peers/ForOfStatement" +export * from "./peers/TemplateLiteral" +export * from "./peers/TSUnionType" +export * from "./peers/TSUnknownKeyword" +export * from "./peers/Identifier" +export * from "./peers/OpaqueTypeNode" +export * from "./peers/BlockStatement" +export * from "./peers/Statement" +export * from "./peers/DirectEvalExpression" +export * from "./peers/TSTypeParameterDeclaration" +export * from "./peers/MethodDefinition" +export * from "./peers/OverloadDeclaration" +export * from "./peers/TSNullKeyword" +export * from "./peers/TSInterfaceHeritage" +export * from "./peers/Expression" +export * from "./peers/AnnotatedExpression" +export * from "./peers/MaybeOptionalExpression" +export * from "./peers/SrcDumper" +export * from "./peers/ETSClassLiteral" +export * from "./peers/BreakStatement" +export * from "./peers/RegExpLiteral" +export * from "./peers/TSMappedType" +export * from "./peers/TSAnyKeyword" +export * from "./peers/ClassDeclaration" +export * from "./peers/TSIndexedAccessType" +export * from "./peers/TSQualifiedName" +export * from "./peers/AwaitExpression" +export * from "./peers/ValidationInfo" +export * from "./peers/ContinueStatement" +export * from "./peers/ETSNewMultiDimArrayInstanceExpression" +export * from "./peers/TSNamedTupleMember" +export * from "./peers/ImportExpression" +export * from "./peers/AstDumper" +export * from "./peers/ETSNullType" +export * from "./peers/ETSUndefinedType" +export * from "./peers/TypeofExpression" +export * from "./peers/TSEnumMember" +export * from "./peers/SwitchStatement" +export * from "./peers/DoWhileStatement" +export * from "./peers/CatchClause" +export * from "./peers/SequenceExpression" +export * from "./peers/ArrowFunctionExpression" +export * from "./peers/OmittedExpression" +export * from "./peers/ETSNewClassInstanceExpression" +export * from "./peers/TSAsExpression" +export * from "./peers/ForUpdateStatement" +export * from "./peers/ETSTypeReferencePart" +export * from "./peers/ETSReExportDeclaration" +export * from "./peers/ETSPrimitiveType" +export * from "./peers/TypeNode" +export * from "./peers/NewExpression" +export * from "./peers/TSParameterProperty" +export * from "./peers/ETSWildcardType" +export * from "./peers/TSThisType" +export * from "./peers/Program" +export * from "./peers/ArkTsConfig" diff --git a/ets1.2/libarkts/src/generated/peers/AnnotatedAstNode.ts b/ets1.2/libarkts/src/generated/peers/AnnotatedAstNode.ts new file mode 100644 index 0000000000000000000000000000000000000000..930b7293f3b26a52c23a5c915b050087ab1a6f55 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/AnnotatedAstNode.ts @@ -0,0 +1,45 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" + +export class AnnotatedAstNode extends AstNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + protected readonly brandAnnotatedAstNode: undefined +} +export function isAnnotatedAstNode(node: object | undefined): node is AnnotatedAstNode { + return node instanceof AnnotatedAstNode +} diff --git a/ets1.2/libarkts/src/generated/peers/AnnotatedExpression.ts b/ets1.2/libarkts/src/generated/peers/AnnotatedExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..4a0171c62d593cc8aaef245a2b79c2e527d46850 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/AnnotatedExpression.ts @@ -0,0 +1,55 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" + +export class AnnotatedExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + get typeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._AnnotatedExpressionTypeAnnotationConst(global.context, this.peer)) + } + /** @deprecated */ + setTsTypeAnnotation(typeAnnotation?: TypeNode): this { + global.generatedEs2panda._AnnotatedExpressionSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation)) + return this + } + protected readonly brandAnnotatedExpression: undefined +} +export function isAnnotatedExpression(node: object | undefined): node is AnnotatedExpression { + return node instanceof AnnotatedExpression +} diff --git a/ets1.2/libarkts/src/generated/peers/AnnotatedStatement.ts b/ets1.2/libarkts/src/generated/peers/AnnotatedStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..6757c3a8509ed2c47ad6bac15ea4910b94b0c381 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/AnnotatedStatement.ts @@ -0,0 +1,46 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Statement } from "./Statement" + +export class AnnotatedStatement extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + protected readonly brandAnnotatedStatement: undefined +} +export function isAnnotatedStatement(node: object | undefined): node is AnnotatedStatement { + return node instanceof AnnotatedStatement +} diff --git a/ets1.2/libarkts/src/generated/peers/AnnotationDeclaration.ts b/ets1.2/libarkts/src/generated/peers/AnnotationDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..3dc9a1e2b13bfa6ed125e727a234ffa7f68fae17 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/AnnotationDeclaration.ts @@ -0,0 +1,166 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotationUsage } from "./AnnotationUsage" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Identifier } from "./Identifier" +import { SrcDumper } from "./SrcDumper" +import { Statement } from "./Statement" + +export class AnnotationDeclaration extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create1AnnotationDeclaration(expr: Expression | undefined, properties: readonly AstNode[]): AnnotationDeclaration { + const result: AnnotationDeclaration = new AnnotationDeclaration(global.generatedEs2panda._CreateAnnotationDeclaration1(global.context, passNode(expr), passNodeArray(properties), properties.length), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION) + result.setChildrenParentPtr() + return result + } + static updateAnnotationDeclaration(original?: AnnotationDeclaration, expr?: Expression): AnnotationDeclaration { + const result: AnnotationDeclaration = new AnnotationDeclaration(global.generatedEs2panda._UpdateAnnotationDeclaration(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION) + result.setChildrenParentPtr() + return result + } + static update1AnnotationDeclaration(original: AnnotationDeclaration | undefined, expr: Expression | undefined, properties: readonly AstNode[]): AnnotationDeclaration { + const result: AnnotationDeclaration = new AnnotationDeclaration(global.generatedEs2panda._UpdateAnnotationDeclaration1(global.context, passNode(original), passNode(expr), passNodeArray(properties), properties.length), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION) + result.setChildrenParentPtr() + return result + } + get internalName(): string { + return unpackString(global.generatedEs2panda._AnnotationDeclarationInternalNameConst(global.context, this.peer)) + } + /** @deprecated */ + setInternalName(internalName: string): this { + global.generatedEs2panda._AnnotationDeclarationSetInternalName(global.context, this.peer, internalName) + return this + } + get expr(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AnnotationDeclarationExpr(global.context, this.peer)) + } + get properties(): readonly AstNode[] { + return unpackNodeArray(global.generatedEs2panda._AnnotationDeclarationProperties(global.context, this.peer)) + } + get propertiesForUpdate(): readonly AstNode[] { + return unpackNodeArray(global.generatedEs2panda._AnnotationDeclarationPropertiesForUpdate(global.context, this.peer)) + } + /** @deprecated */ + addProperties(properties: readonly AstNode[]): this { + global.generatedEs2panda._AnnotationDeclarationAddProperties(global.context, this.peer, passNodeArray(properties), properties.length) + return this + } + get isSourceRetention(): boolean { + return global.generatedEs2panda._AnnotationDeclarationIsSourceRetentionConst(global.context, this.peer) + } + get isBytecodeRetention(): boolean { + return global.generatedEs2panda._AnnotationDeclarationIsBytecodeRetentionConst(global.context, this.peer) + } + get isRuntimeRetention(): boolean { + return global.generatedEs2panda._AnnotationDeclarationIsRuntimeRetentionConst(global.context, this.peer) + } + /** @deprecated */ + setSourceRetention(): this { + global.generatedEs2panda._AnnotationDeclarationSetSourceRetention(global.context, this.peer) + return this + } + /** @deprecated */ + setBytecodeRetention(): this { + global.generatedEs2panda._AnnotationDeclarationSetBytecodeRetention(global.context, this.peer) + return this + } + /** @deprecated */ + setRuntimeRetention(): this { + global.generatedEs2panda._AnnotationDeclarationSetRuntimeRetention(global.context, this.peer) + return this + } + get baseName(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._AnnotationDeclarationGetBaseNameConst(global.context, this.peer)) + } + /** @deprecated */ + emplaceProperties(properties?: AstNode): this { + global.generatedEs2panda._AnnotationDeclarationEmplaceProperties(global.context, this.peer, passNode(properties)) + return this + } + /** @deprecated */ + clearProperties(): this { + global.generatedEs2panda._AnnotationDeclarationClearProperties(global.context, this.peer) + return this + } + /** @deprecated */ + setValueProperties(properties: AstNode | undefined, index: number): this { + global.generatedEs2panda._AnnotationDeclarationSetValueProperties(global.context, this.peer, passNode(properties), index) + return this + } + get hasAnnotations(): boolean { + return global.generatedEs2panda._AnnotationDeclarationHasAnnotationsConst(global.context, this.peer) + } + /** @deprecated */ + emplaceAnnotation(source?: AnnotationUsage): this { + global.generatedEs2panda._AnnotationDeclarationEmplaceAnnotation(global.context, this.peer, passNode(source)) + return this + } + /** @deprecated */ + clearAnnotations(): this { + global.generatedEs2panda._AnnotationDeclarationClearAnnotations(global.context, this.peer) + return this + } + /** @deprecated */ + dumpAnnotations(dumper?: SrcDumper): this { + global.generatedEs2panda._AnnotationDeclarationDumpAnnotationsConst(global.context, this.peer, passNode(dumper)) + return this + } + get annotationsForUpdate(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._AnnotationDeclarationAnnotationsForUpdate(global.context, this.peer)) + } + get annotations(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._AnnotationDeclarationAnnotations(global.context, this.peer)) + } + /** @deprecated */ + setAnnotations(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._AnnotationDeclarationSetAnnotations(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + /** @deprecated */ + setAnnotations1(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._AnnotationDeclarationSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + protected readonly brandAnnotationDeclaration: undefined +} +export function isAnnotationDeclaration(node: object | undefined): node is AnnotationDeclaration { + return node instanceof AnnotationDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION, (peer: KNativePointer) => new AnnotationDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/AnnotationUsage.ts b/ets1.2/libarkts/src/generated/peers/AnnotationUsage.ts new file mode 100644 index 0000000000000000000000000000000000000000..0803bc29221058eae2b1bd064f021dbdad9bd279 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/AnnotationUsage.ts @@ -0,0 +1,85 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Identifier } from "./Identifier" +import { Statement } from "./Statement" + +export class AnnotationUsage extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create1AnnotationUsage(expr: Expression | undefined, properties: readonly AstNode[]): AnnotationUsage { + const result: AnnotationUsage = new AnnotationUsage(global.generatedEs2panda._CreateAnnotationUsage1(global.context, passNode(expr), passNodeArray(properties), properties.length), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE) + result.setChildrenParentPtr() + return result + } + static updateAnnotationUsage(original?: AnnotationUsage, expr?: Expression): AnnotationUsage { + const result: AnnotationUsage = new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsage(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE) + result.setChildrenParentPtr() + return result + } + static update1AnnotationUsage(original: AnnotationUsage | undefined, expr: Expression | undefined, properties: readonly AstNode[]): AnnotationUsage { + const result: AnnotationUsage = new AnnotationUsage(global.generatedEs2panda._UpdateAnnotationUsage1(global.context, passNode(original), passNode(expr), passNodeArray(properties), properties.length), Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE) + result.setChildrenParentPtr() + return result + } + get expr(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AnnotationUsageExpr(global.context, this.peer)) + } + get properties(): readonly AstNode[] { + return unpackNodeArray(global.generatedEs2panda._AnnotationUsageProperties(global.context, this.peer)) + } + /** @deprecated */ + addProperty(property?: AstNode): this { + global.generatedEs2panda._AnnotationUsageAddProperty(global.context, this.peer, passNode(property)) + return this + } + /** @deprecated */ + setProperties(properties: readonly AstNode[]): this { + global.generatedEs2panda._AnnotationUsageSetProperties(global.context, this.peer, passNodeArray(properties), properties.length) + return this + } + get baseName(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._AnnotationUsageGetBaseNameConst(global.context, this.peer)) + } + protected readonly brandAnnotationUsage: undefined +} +export function isAnnotationUsage(node: object | undefined): node is AnnotationUsage { + return node instanceof AnnotationUsage +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE, (peer: KNativePointer) => new AnnotationUsage(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ArkTsConfig.ts b/ets1.2/libarkts/src/generated/peers/ArkTsConfig.ts new file mode 100644 index 0000000000000000000000000000000000000000..b4e6d4def0012ef6d79cf4bc93db92bf8fb65230 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ArkTsConfig.ts @@ -0,0 +1,71 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { ErrorLogger } from "./ErrorLogger" + +export class ArkTsConfig extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + static createArkTsConfig(configPath: string, de?: ErrorLogger): ArkTsConfig { + return new ArkTsConfig(global.generatedEs2panda._CreateArkTsConfig(global.context, configPath, passNode(de))) + } + /** @deprecated */ + resolveAllDependenciesInArkTsConfig(): this { + global.generatedEs2panda._ArkTsConfigResolveAllDependenciesInArkTsConfig(global.context, this.peer) + return this + } + get configPath(): string { + return unpackString(global.generatedEs2panda._ArkTsConfigConfigPathConst(global.context, this.peer)) + } + get package(): string { + return unpackString(global.generatedEs2panda._ArkTsConfigPackageConst(global.context, this.peer)) + } + get baseUrl(): string { + return unpackString(global.generatedEs2panda._ArkTsConfigBaseUrlConst(global.context, this.peer)) + } + get rootDir(): string { + return unpackString(global.generatedEs2panda._ArkTsConfigRootDirConst(global.context, this.peer)) + } + get outDir(): string { + return unpackString(global.generatedEs2panda._ArkTsConfigOutDirConst(global.context, this.peer)) + } + get useUrl(): boolean { + return global.generatedEs2panda._ArkTsConfigUseUrlConst(global.context, this.peer) + } + protected readonly brandArkTsConfig: undefined +} +export function isArkTsConfig(node: object | undefined): node is ArkTsConfig { + return node instanceof ArkTsConfig +} diff --git a/ets1.2/libarkts/src/generated/peers/ArrayExpression.ts b/ets1.2/libarkts/src/generated/peers/ArrayExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..f95fc212239f25c87f3759163dbc9171e343a010 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ArrayExpression.ts @@ -0,0 +1,110 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotatedExpression } from "./AnnotatedExpression" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" +import { ValidationInfo } from "./ValidationInfo" + +export class ArrayExpression extends AnnotatedExpression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create1ArrayExpression(nodeType: Es2pandaAstNodeType, elements: readonly Expression[], trailingComma: boolean): ArrayExpression { + const result: ArrayExpression = new ArrayExpression(global.generatedEs2panda._CreateArrayExpression1(global.context, nodeType, passNodeArray(elements), elements.length, trailingComma), Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateArrayExpression(original: ArrayExpression | undefined, elements: readonly Expression[]): ArrayExpression { + const result: ArrayExpression = new ArrayExpression(global.generatedEs2panda._UpdateArrayExpression(global.context, passNode(original), passNodeArray(elements), elements.length), Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static update1ArrayExpression(original: ArrayExpression | undefined, nodeType: Es2pandaAstNodeType, elements: readonly Expression[], trailingComma: boolean): ArrayExpression { + const result: ArrayExpression = new ArrayExpression(global.generatedEs2panda._UpdateArrayExpression1(global.context, passNode(original), nodeType, passNodeArray(elements), elements.length, trailingComma), Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get elements(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._ArrayExpressionElements(global.context, this.peer)) + } + /** @deprecated */ + setElements(elements: readonly Expression[]): this { + global.generatedEs2panda._ArrayExpressionSetElements(global.context, this.peer, passNodeArray(elements), elements.length) + return this + } + get isDeclaration(): boolean { + return global.generatedEs2panda._ArrayExpressionIsDeclarationConst(global.context, this.peer) + } + get isOptional(): boolean { + return global.generatedEs2panda._ArrayExpressionIsOptionalConst(global.context, this.peer) + } + /** @deprecated */ + setDeclaration(): this { + global.generatedEs2panda._ArrayExpressionSetDeclaration(global.context, this.peer) + return this + } + /** @deprecated */ + setOptional(optional_arg: boolean): this { + global.generatedEs2panda._ArrayExpressionSetOptional(global.context, this.peer, optional_arg) + return this + } + /** @deprecated */ + clearPreferredType(): this { + global.generatedEs2panda._ArrayExpressionClearPreferredType(global.context, this.peer) + return this + } + get convertibleToArrayPattern(): boolean { + return global.generatedEs2panda._ArrayExpressionConvertibleToArrayPattern(global.context, this.peer) + } + get validateExpression(): ValidationInfo | undefined { + return new ValidationInfo(global.generatedEs2panda._ArrayExpressionValidateExpression(global.context, this.peer)) + } + get typeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ArrayExpressionTypeAnnotationConst(global.context, this.peer)) + } + /** @deprecated */ + setTsTypeAnnotation(typeAnnotation?: TypeNode): this { + global.generatedEs2panda._ArrayExpressionSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation)) + return this + } + protected readonly brandArrayExpression: undefined +} +export function isArrayExpression(node: object | undefined): node is ArrayExpression { + return node instanceof ArrayExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION, (peer: KNativePointer) => new ArrayExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ARRAY_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ArrowFunctionExpression.ts b/ets1.2/libarkts/src/generated/peers/ArrowFunctionExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..cffde5648dbfcf6bf04af9e8e00b4d6dc8d42e14 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ArrowFunctionExpression.ts @@ -0,0 +1,120 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotationUsage } from "./AnnotationUsage" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { ScriptFunction } from "./ScriptFunction" +import { SrcDumper } from "./SrcDumper" +import { TypeNode } from "./TypeNode" + +export class ArrowFunctionExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createArrowFunctionExpression(func?: ScriptFunction, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression { + const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._CreateArrowFunctionExpression(global.context, passNode(func)), Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + static updateArrowFunctionExpression(original?: ArrowFunctionExpression, func?: ScriptFunction, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression { + const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression(global.context, passNode(original), passNode(func)), Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + static update1ArrowFunctionExpression(original?: ArrowFunctionExpression, other?: ArrowFunctionExpression, annotations?: readonly AnnotationUsage[]): ArrowFunctionExpression { + const result: ArrowFunctionExpression = new ArrowFunctionExpression(global.generatedEs2panda._UpdateArrowFunctionExpression1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + get function(): ScriptFunction | undefined { + return unpackNode(global.generatedEs2panda._ArrowFunctionExpressionFunction(global.context, this.peer)) + } + get createTypeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ArrowFunctionExpressionCreateTypeAnnotation(global.context, this.peer)) + } + get hasAnnotations(): boolean { + return global.generatedEs2panda._ArrowFunctionExpressionHasAnnotationsConst(global.context, this.peer) + } + /** @deprecated */ + emplaceAnnotation(source?: AnnotationUsage): this { + global.generatedEs2panda._ArrowFunctionExpressionEmplaceAnnotation(global.context, this.peer, passNode(source)) + return this + } + /** @deprecated */ + clearAnnotations(): this { + global.generatedEs2panda._ArrowFunctionExpressionClearAnnotations(global.context, this.peer) + return this + } + /** @deprecated */ + dumpAnnotations(dumper?: SrcDumper): this { + global.generatedEs2panda._ArrowFunctionExpressionDumpAnnotationsConst(global.context, this.peer, passNode(dumper)) + return this + } + get annotationsForUpdate(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._ArrowFunctionExpressionAnnotationsForUpdate(global.context, this.peer)) + } + get annotations(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._ArrowFunctionExpressionAnnotations(global.context, this.peer)) + } + /** @deprecated */ + setAnnotations(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._ArrowFunctionExpressionSetAnnotations(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + /** @deprecated */ + setAnnotations1(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._ArrowFunctionExpressionSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + protected readonly brandArrowFunctionExpression: undefined +} +export function isArrowFunctionExpression(node: object | undefined): node is ArrowFunctionExpression { + return node instanceof ArrowFunctionExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, (peer: KNativePointer) => new ArrowFunctionExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/AssertStatement.ts b/ets1.2/libarkts/src/generated/peers/AssertStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..57f68ff13dfd78163962e051f9855d14a6664340 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/AssertStatement.ts @@ -0,0 +1,66 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Statement } from "./Statement" + +export class AssertStatement extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createAssertStatement(test?: Expression, second?: Expression): AssertStatement { + const result: AssertStatement = new AssertStatement(global.generatedEs2panda._CreateAssertStatement(global.context, passNode(test), passNode(second)), Es2pandaAstNodeType.AST_NODE_TYPE_ASSERT_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateAssertStatement(original?: AssertStatement, test?: Expression, second?: Expression): AssertStatement { + const result: AssertStatement = new AssertStatement(global.generatedEs2panda._UpdateAssertStatement(global.context, passNode(original), passNode(test), passNode(second)), Es2pandaAstNodeType.AST_NODE_TYPE_ASSERT_STATEMENT) + result.setChildrenParentPtr() + return result + } + get test(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AssertStatementTest(global.context, this.peer)) + } + get second(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AssertStatementSecondConst(global.context, this.peer)) + } + protected readonly brandAssertStatement: undefined +} +export function isAssertStatement(node: object | undefined): node is AssertStatement { + return node instanceof AssertStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ASSERT_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ASSERT_STATEMENT, (peer: KNativePointer) => new AssertStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ASSERT_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/AssignmentExpression.ts b/ets1.2/libarkts/src/generated/peers/AssignmentExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..1464e887f0db62d910ad27c85a2339d512998495 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/AssignmentExpression.ts @@ -0,0 +1,112 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { CodeGen } from "./CodeGen" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaTokenType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class AssignmentExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create1AssignmentExpression(type: Es2pandaAstNodeType, left: Expression | undefined, right: Expression | undefined, assignmentOperator: Es2pandaTokenType): AssignmentExpression { + const result: AssignmentExpression = new AssignmentExpression(global.generatedEs2panda._CreateAssignmentExpression1(global.context, type, passNode(left), passNode(right), assignmentOperator), Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateAssignmentExpression(original: AssignmentExpression | undefined, left: Expression | undefined, right: Expression | undefined, assignmentOperator: Es2pandaTokenType): AssignmentExpression { + const result: AssignmentExpression = new AssignmentExpression(global.generatedEs2panda._UpdateAssignmentExpression(global.context, passNode(original), passNode(left), passNode(right), assignmentOperator), Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static update1AssignmentExpression(original: AssignmentExpression | undefined, type: Es2pandaAstNodeType, left: Expression | undefined, right: Expression | undefined, assignmentOperator: Es2pandaTokenType): AssignmentExpression { + const result: AssignmentExpression = new AssignmentExpression(global.generatedEs2panda._UpdateAssignmentExpression1(global.context, passNode(original), type, passNode(left), passNode(right), assignmentOperator), Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get left(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AssignmentExpressionLeft(global.context, this.peer)) + } + get right(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AssignmentExpressionRight(global.context, this.peer)) + } + /** @deprecated */ + setRight(expr?: Expression): this { + global.generatedEs2panda._AssignmentExpressionSetRight(global.context, this.peer, passNode(expr)) + return this + } + /** @deprecated */ + setLeft(expr?: Expression): this { + global.generatedEs2panda._AssignmentExpressionSetLeft(global.context, this.peer, passNode(expr)) + return this + } + get result(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AssignmentExpressionResult(global.context, this.peer)) + } + get operatorType(): Es2pandaTokenType { + return global.generatedEs2panda._AssignmentExpressionOperatorTypeConst(global.context, this.peer) + } + /** @deprecated */ + setResult(expr?: Expression): this { + global.generatedEs2panda._AssignmentExpressionSetResult(global.context, this.peer, passNode(expr)) + return this + } + get isLogicalExtended(): boolean { + return global.generatedEs2panda._AssignmentExpressionIsLogicalExtendedConst(global.context, this.peer) + } + /** @deprecated */ + setIgnoreConstAssign(): this { + global.generatedEs2panda._AssignmentExpressionSetIgnoreConstAssign(global.context, this.peer) + return this + } + get isIgnoreConstAssign(): boolean { + return global.generatedEs2panda._AssignmentExpressionIsIgnoreConstAssignConst(global.context, this.peer) + } + get convertibleToAssignmentPatternRight(): boolean { + return global.generatedEs2panda._AssignmentExpressionConvertibleToAssignmentPatternRight(global.context, this.peer) + } + /** @deprecated */ + compilePattern(pg?: CodeGen): this { + global.generatedEs2panda._AssignmentExpressionCompilePatternConst(global.context, this.peer, passNode(pg)) + return this + } + protected readonly brandAssignmentExpression: undefined +} +export function isAssignmentExpression(node: object | undefined): node is AssignmentExpression { + return node instanceof AssignmentExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION, (peer: KNativePointer) => new AssignmentExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/AstDumper.ts b/ets1.2/libarkts/src/generated/peers/AstDumper.ts new file mode 100644 index 0000000000000000000000000000000000000000..f96bc54b36ef1747025d4b3ca80cce472a5ebc65 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/AstDumper.ts @@ -0,0 +1,50 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class AstDumper extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + static createAstDumper(node: AstNode | undefined, sourceCode: string): AstDumper { + return new AstDumper(global.generatedEs2panda._CreateAstDumper(global.context, passNode(node), sourceCode)) + } + get str(): string { + return unpackString(global.generatedEs2panda._AstDumperStrConst(global.context, this.peer)) + } + protected readonly brandAstDumper: undefined +} +export function isAstDumper(node: object | undefined): node is AstDumper { + return node instanceof AstDumper +} diff --git a/ets1.2/libarkts/src/generated/peers/AstVerifier.ts b/ets1.2/libarkts/src/generated/peers/AstVerifier.ts new file mode 100644 index 0000000000000000000000000000000000000000..c25f66d6da935286fc91046064a26063500c2a07 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/AstVerifier.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class AstVerifier extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandAstVerifier: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/AstVisitor.ts b/ets1.2/libarkts/src/generated/peers/AstVisitor.ts new file mode 100644 index 0000000000000000000000000000000000000000..ea1fb832a415a5619190614ee0668870715719cd --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/AstVisitor.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class AstVisitor extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandAstVisitor: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/AwaitExpression.ts b/ets1.2/libarkts/src/generated/peers/AwaitExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..5212918326f98a29a5629504d09659cff7886b30 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/AwaitExpression.ts @@ -0,0 +1,62 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class AwaitExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createAwaitExpression(argument?: Expression): AwaitExpression { + const result: AwaitExpression = new AwaitExpression(global.generatedEs2panda._CreateAwaitExpression(global.context, passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateAwaitExpression(original?: AwaitExpression, argument?: Expression): AwaitExpression { + const result: AwaitExpression = new AwaitExpression(global.generatedEs2panda._UpdateAwaitExpression(global.context, passNode(original), passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get argument(): Expression | undefined { + return unpackNode(global.generatedEs2panda._AwaitExpressionArgumentConst(global.context, this.peer)) + } + protected readonly brandAwaitExpression: undefined +} +export function isAwaitExpression(node: object | undefined): node is AwaitExpression { + return node instanceof AwaitExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION, (peer: KNativePointer) => new AwaitExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/BigIntLiteral.ts b/ets1.2/libarkts/src/generated/peers/BigIntLiteral.ts new file mode 100644 index 0000000000000000000000000000000000000000..58794ab003583dde63288270b40fc916d98f9cdf --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/BigIntLiteral.ts @@ -0,0 +1,62 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Literal } from "./Literal" + +export class BigIntLiteral extends Literal { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createBigIntLiteral(src: string): BigIntLiteral { + const result: BigIntLiteral = new BigIntLiteral(global.generatedEs2panda._CreateBigIntLiteral(global.context, src), Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL) + result.setChildrenParentPtr() + return result + } + static updateBigIntLiteral(original: BigIntLiteral | undefined, src: string): BigIntLiteral { + const result: BigIntLiteral = new BigIntLiteral(global.generatedEs2panda._UpdateBigIntLiteral(global.context, passNode(original), src), Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL) + result.setChildrenParentPtr() + return result + } + get str(): string { + return unpackString(global.generatedEs2panda._BigIntLiteralStrConst(global.context, this.peer)) + } + protected readonly brandBigIntLiteral: undefined +} +export function isBigIntLiteral(node: object | undefined): node is BigIntLiteral { + return node instanceof BigIntLiteral +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL, (peer: KNativePointer) => new BigIntLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL)) +} diff --git a/ets1.2/libarkts/src/generated/peers/BinaryExpression.ts b/ets1.2/libarkts/src/generated/peers/BinaryExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..84cf5664c3605687b03bff124035be0f045c4bde --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/BinaryExpression.ts @@ -0,0 +1,111 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { CodeGen } from "./CodeGen" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaTokenType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { VReg } from "./VReg" + +export class BinaryExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createBinaryExpression(left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression { + const result: BinaryExpression = new BinaryExpression(global.generatedEs2panda._CreateBinaryExpression(global.context, passNode(left), passNode(right), operatorType), Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateBinaryExpression(original: BinaryExpression | undefined, left: Expression | undefined, right: Expression | undefined, operatorType: Es2pandaTokenType): BinaryExpression { + const result: BinaryExpression = new BinaryExpression(global.generatedEs2panda._UpdateBinaryExpression(global.context, passNode(original), passNode(left), passNode(right), operatorType), Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get left(): Expression | undefined { + return unpackNode(global.generatedEs2panda._BinaryExpressionLeft(global.context, this.peer)) + } + get right(): Expression | undefined { + return unpackNode(global.generatedEs2panda._BinaryExpressionRight(global.context, this.peer)) + } + get result(): Expression | undefined { + return unpackNode(global.generatedEs2panda._BinaryExpressionResult(global.context, this.peer)) + } + get operatorType(): Es2pandaTokenType { + return global.generatedEs2panda._BinaryExpressionOperatorTypeConst(global.context, this.peer) + } + get isLogical(): boolean { + return global.generatedEs2panda._BinaryExpressionIsLogicalConst(global.context, this.peer) + } + get isLogicalExtended(): boolean { + return global.generatedEs2panda._BinaryExpressionIsLogicalExtendedConst(global.context, this.peer) + } + get isBitwise(): boolean { + return global.generatedEs2panda._BinaryExpressionIsBitwiseConst(global.context, this.peer) + } + get isArithmetic(): boolean { + return global.generatedEs2panda._BinaryExpressionIsArithmeticConst(global.context, this.peer) + } + /** @deprecated */ + setLeft(expr?: Expression): this { + global.generatedEs2panda._BinaryExpressionSetLeft(global.context, this.peer, passNode(expr)) + return this + } + /** @deprecated */ + setRight(expr?: Expression): this { + global.generatedEs2panda._BinaryExpressionSetRight(global.context, this.peer, passNode(expr)) + return this + } + /** @deprecated */ + setResult(expr?: Expression): this { + global.generatedEs2panda._BinaryExpressionSetResult(global.context, this.peer, passNode(expr)) + return this + } + /** @deprecated */ + setOperator(operatorType: Es2pandaTokenType): this { + global.generatedEs2panda._BinaryExpressionSetOperator(global.context, this.peer, operatorType) + return this + } + /** @deprecated */ + compileOperands(etsg?: CodeGen, lhs?: VReg): this { + global.generatedEs2panda._BinaryExpressionCompileOperandsConst(global.context, this.peer, passNode(etsg), passNode(lhs)) + return this + } + protected readonly brandBinaryExpression: undefined +} +export function isBinaryExpression(node: object | undefined): node is BinaryExpression { + return node instanceof BinaryExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION, (peer: KNativePointer) => new BinaryExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/BindingProps.ts b/ets1.2/libarkts/src/generated/peers/BindingProps.ts new file mode 100644 index 0000000000000000000000000000000000000000..f401c83d3d4deff075e0d01bcb6ffa7842a8b9fe --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/BindingProps.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class BindingProps extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandBindingProps: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/BlockExpression.ts b/ets1.2/libarkts/src/generated/peers/BlockExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..d6f1760c432fc76a0c5d8945f9492442ea5ec73f --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/BlockExpression.ts @@ -0,0 +1,73 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Statement } from "./Statement" + +export class BlockExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createBlockExpression(statements: readonly Statement[]): BlockExpression { + const result: BlockExpression = new BlockExpression(global.generatedEs2panda._CreateBlockExpression(global.context, passNodeArray(statements), statements.length), Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateBlockExpression(original: BlockExpression | undefined, statements: readonly Statement[]): BlockExpression { + const result: BlockExpression = new BlockExpression(global.generatedEs2panda._UpdateBlockExpression(global.context, passNode(original), passNodeArray(statements), statements.length), Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get statements(): readonly Statement[] { + return unpackNodeArray(global.generatedEs2panda._BlockExpressionStatements(global.context, this.peer)) + } + /** @deprecated */ + addStatements(statements: readonly Statement[]): this { + global.generatedEs2panda._BlockExpressionAddStatements(global.context, this.peer, passNodeArray(statements), statements.length) + return this + } + /** @deprecated */ + addStatement(statement?: Statement): this { + global.generatedEs2panda._BlockExpressionAddStatement(global.context, this.peer, passNode(statement)) + return this + } + protected readonly brandBlockExpression: undefined +} +export function isBlockExpression(node: object | undefined): node is BlockExpression { + return node instanceof BlockExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION, (peer: KNativePointer) => new BlockExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/BlockStatement.ts b/ets1.2/libarkts/src/generated/peers/BlockStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..f1c1990f83ddc5002317aa5f046e329f2f7de685 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/BlockStatement.ts @@ -0,0 +1,95 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Statement } from "./Statement" + +export class BlockStatement extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createBlockStatement(statementList: readonly Statement[]): BlockStatement { + const result: BlockStatement = new BlockStatement(global.generatedEs2panda._CreateBlockStatement(global.context, passNodeArray(statementList), statementList.length), Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateBlockStatement(original: BlockStatement | undefined, statementList: readonly Statement[]): BlockStatement { + const result: BlockStatement = new BlockStatement(global.generatedEs2panda._UpdateBlockStatement(global.context, passNode(original), passNodeArray(statementList), statementList.length), Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT) + result.setChildrenParentPtr() + return result + } + get statementsForUpdates(): readonly Statement[] { + return unpackNodeArray(global.generatedEs2panda._BlockStatementStatementsForUpdates(global.context, this.peer)) + } + get statements(): readonly Statement[] { + return unpackNodeArray(global.generatedEs2panda._BlockStatementStatements(global.context, this.peer)) + } + /** @deprecated */ + setStatements(statementList: readonly Statement[]): this { + global.generatedEs2panda._BlockStatementSetStatements(global.context, this.peer, passNodeArray(statementList), statementList.length) + return this + } + /** @deprecated */ + addStatements(statementList: readonly Statement[]): this { + global.generatedEs2panda._BlockStatementAddStatements(global.context, this.peer, passNodeArray(statementList), statementList.length) + return this + } + /** @deprecated */ + clearStatements(): this { + global.generatedEs2panda._BlockStatementClearStatements(global.context, this.peer) + return this + } + /** @deprecated */ + addStatement(statement?: Statement): this { + global.generatedEs2panda._BlockStatementAddStatement(global.context, this.peer, passNode(statement)) + return this + } + /** @deprecated */ + addStatement1(idx: number, statement?: Statement): this { + global.generatedEs2panda._BlockStatementAddStatement1(global.context, this.peer, idx, passNode(statement)) + return this + } + /** @deprecated */ + addTrailingBlock(stmt?: AstNode, trailingBlock?: BlockStatement): this { + global.generatedEs2panda._BlockStatementAddTrailingBlock(global.context, this.peer, passNode(stmt), passNode(trailingBlock)) + return this + } + protected readonly brandBlockStatement: undefined +} +export function isBlockStatement(node: object | undefined): node is BlockStatement { + return node instanceof BlockStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, (peer: KNativePointer) => new BlockStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/BooleanLiteral.ts b/ets1.2/libarkts/src/generated/peers/BooleanLiteral.ts new file mode 100644 index 0000000000000000000000000000000000000000..491b4230248c5abe495d6720be16e589a4e1d873 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/BooleanLiteral.ts @@ -0,0 +1,62 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Literal } from "./Literal" + +export class BooleanLiteral extends Literal { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createBooleanLiteral(value: boolean): BooleanLiteral { + const result: BooleanLiteral = new BooleanLiteral(global.generatedEs2panda._CreateBooleanLiteral(global.context, value), Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL) + result.setChildrenParentPtr() + return result + } + static updateBooleanLiteral(original: BooleanLiteral | undefined, value: boolean): BooleanLiteral { + const result: BooleanLiteral = new BooleanLiteral(global.generatedEs2panda._UpdateBooleanLiteral(global.context, passNode(original), value), Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL) + result.setChildrenParentPtr() + return result + } + get value(): boolean { + return global.generatedEs2panda._BooleanLiteralValueConst(global.context, this.peer) + } + protected readonly brandBooleanLiteral: undefined +} +export function isBooleanLiteral(node: object | undefined): node is BooleanLiteral { + return node instanceof BooleanLiteral +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL, (peer: KNativePointer) => new BooleanLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL)) +} diff --git a/ets1.2/libarkts/src/generated/peers/BreakStatement.ts b/ets1.2/libarkts/src/generated/peers/BreakStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..98030c2ff0ee58a5b0f1e1bee1c19b79d8ff1ac5 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/BreakStatement.ts @@ -0,0 +1,79 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Identifier } from "./Identifier" +import { Statement } from "./Statement" + +export class BreakStatement extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create1BreakStatement(ident?: Identifier): BreakStatement { + const result: BreakStatement = new BreakStatement(global.generatedEs2panda._CreateBreakStatement1(global.context, passNode(ident)), Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateBreakStatement(original?: BreakStatement): BreakStatement { + const result: BreakStatement = new BreakStatement(global.generatedEs2panda._UpdateBreakStatement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT) + result.setChildrenParentPtr() + return result + } + static update1BreakStatement(original?: BreakStatement, ident?: Identifier): BreakStatement { + const result: BreakStatement = new BreakStatement(global.generatedEs2panda._UpdateBreakStatement1(global.context, passNode(original), passNode(ident)), Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT) + result.setChildrenParentPtr() + return result + } + get ident(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._BreakStatementIdent(global.context, this.peer)) + } + get target(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._BreakStatementTargetConst(global.context, this.peer)) + } + get hasTarget(): boolean { + return global.generatedEs2panda._BreakStatementHasTargetConst(global.context, this.peer) + } + /** @deprecated */ + setTarget(target?: AstNode): this { + global.generatedEs2panda._BreakStatementSetTarget(global.context, this.peer, passNode(target)) + return this + } + protected readonly brandBreakStatement: undefined +} +export function isBreakStatement(node: object | undefined): node is BreakStatement { + return node instanceof BreakStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT, (peer: KNativePointer) => new BreakStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/CallExpression.ts b/ets1.2/libarkts/src/generated/peers/CallExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..34bc1619a5293745921aee81b7a19e880e6d95dd --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/CallExpression.ts @@ -0,0 +1,130 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { BlockStatement } from "./BlockStatement" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { MaybeOptionalExpression } from "./MaybeOptionalExpression" +import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" + +export class CallExpression extends MaybeOptionalExpression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createCallExpression(callee: Expression | undefined, _arguments: readonly Expression[], typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, trailingComma: boolean, trailingBlock?: BlockStatement): CallExpression { + const result: CallExpression = new CallExpression(global.generatedEs2panda._CreateCallExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, trailingComma), Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION) + if (trailingBlock) + { + result.setTrailingBlock(trailingBlock) + } + result.setChildrenParentPtr() + return result + } + static update1CallExpression(original?: CallExpression, other?: CallExpression, trailingBlock?: BlockStatement): CallExpression { + const result: CallExpression = new CallExpression(global.generatedEs2panda._UpdateCallExpression1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION) + if (trailingBlock) + { + result.setTrailingBlock(trailingBlock) + } + result.setChildrenParentPtr() + return result + } + get callee(): Expression | undefined { + return unpackNode(global.generatedEs2panda._CallExpressionCallee(global.context, this.peer)) + } + /** @deprecated */ + setCallee(callee?: Expression): this { + global.generatedEs2panda._CallExpressionSetCallee(global.context, this.peer, passNode(callee)) + return this + } + get typeParams(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._CallExpressionTypeParams(global.context, this.peer)) + } + get arguments(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._CallExpressionArguments(global.context, this.peer)) + } + /** @deprecated */ + setArguments(argumentsList: readonly Expression[]): this { + global.generatedEs2panda._CallExpressionSetArguments(global.context, this.peer, passNodeArray(argumentsList), argumentsList.length) + return this + } + get hasTrailingComma(): boolean { + return global.generatedEs2panda._CallExpressionHasTrailingCommaConst(global.context, this.peer) + } + /** @deprecated */ + setTypeParams(typeParams?: TSTypeParameterInstantiation): this { + global.generatedEs2panda._CallExpressionSetTypeParams(global.context, this.peer, passNode(typeParams)) + return this + } + /** @deprecated */ + setTrailingBlock(block?: BlockStatement): this { + global.generatedEs2panda._CallExpressionSetTrailingBlock(global.context, this.peer, passNode(block)) + return this + } + get isExtensionAccessorCall(): boolean { + return global.generatedEs2panda._CallExpressionIsExtensionAccessorCall(global.context, this.peer) + } + get trailingBlock(): BlockStatement | undefined { + return unpackNode(global.generatedEs2panda._CallExpressionTrailingBlockConst(global.context, this.peer)) + } + /** @deprecated */ + setIsTrailingBlockInNewLine(isNewLine: boolean): this { + global.generatedEs2panda._CallExpressionSetIsTrailingBlockInNewLine(global.context, this.peer, isNewLine) + return this + } + get isTrailingBlockInNewLine(): boolean { + return global.generatedEs2panda._CallExpressionIsTrailingBlockInNewLineConst(global.context, this.peer) + } + /** @deprecated */ + setIsTrailingCall(isTrailingCall: boolean): this { + global.generatedEs2panda._CallExpressionSetIsTrailingCall(global.context, this.peer, isTrailingCall) + return this + } + get isTrailingCall(): boolean { + return global.generatedEs2panda._CallExpressionIsTrailingCallConst(global.context, this.peer) + } + get isETSConstructorCall(): boolean { + return global.generatedEs2panda._CallExpressionIsETSConstructorCallConst(global.context, this.peer) + } + get isDynamicCall(): boolean { + return global.generatedEs2panda._CallExpressionIsDynamicCallConst(global.context, this.peer) + } + protected readonly brandCallExpression: undefined +} +export function isCallExpression(node: object | undefined): node is CallExpression { + return node instanceof CallExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION, (peer: KNativePointer) => new CallExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/CatchClause.ts b/ets1.2/libarkts/src/generated/peers/CatchClause.ts new file mode 100644 index 0000000000000000000000000000000000000000..f81f34df8ad45e5446a3f7d0c60c70627c9694f7 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/CatchClause.ts @@ -0,0 +1,75 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { BlockStatement } from "./BlockStatement" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypedStatement } from "./TypedStatement" + +export class CatchClause extends TypedStatement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createCatchClause(param?: Expression, body?: BlockStatement): CatchClause { + const result: CatchClause = new CatchClause(global.generatedEs2panda._CreateCatchClause(global.context, passNode(param), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE) + result.setChildrenParentPtr() + return result + } + static updateCatchClause(original?: CatchClause, param?: Expression, body?: BlockStatement): CatchClause { + const result: CatchClause = new CatchClause(global.generatedEs2panda._UpdateCatchClause(global.context, passNode(original), passNode(param), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE) + result.setChildrenParentPtr() + return result + } + static update1CatchClause(original?: CatchClause, other?: CatchClause): CatchClause { + const result: CatchClause = new CatchClause(global.generatedEs2panda._UpdateCatchClause1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE) + result.setChildrenParentPtr() + return result + } + get param(): Expression | undefined { + return unpackNode(global.generatedEs2panda._CatchClauseParam(global.context, this.peer)) + } + get body(): BlockStatement | undefined { + return unpackNode(global.generatedEs2panda._CatchClauseBody(global.context, this.peer)) + } + get isDefaultCatchClause(): boolean { + return global.generatedEs2panda._CatchClauseIsDefaultCatchClauseConst(global.context, this.peer) + } + protected readonly brandCatchClause: undefined +} +export function isCatchClause(node: object | undefined): node is CatchClause { + return node instanceof CatchClause +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE, (peer: KNativePointer) => new CatchClause(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ChainExpression.ts b/ets1.2/libarkts/src/generated/peers/ChainExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..58ef313cf13a79b902e17571b6549fd6ae5a59bb --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ChainExpression.ts @@ -0,0 +1,69 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { CodeGen } from "./CodeGen" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { VReg } from "./VReg" + +export class ChainExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createChainExpression(expression?: Expression): ChainExpression { + const result: ChainExpression = new ChainExpression(global.generatedEs2panda._CreateChainExpression(global.context, passNode(expression)), Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateChainExpression(original?: ChainExpression, expression?: Expression): ChainExpression { + const result: ChainExpression = new ChainExpression(global.generatedEs2panda._UpdateChainExpression(global.context, passNode(original), passNode(expression)), Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get expression(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ChainExpressionGetExpression(global.context, this.peer)) + } + /** @deprecated */ + compileToReg(pg?: CodeGen, objReg?: VReg): this { + global.generatedEs2panda._ChainExpressionCompileToRegConst(global.context, this.peer, passNode(pg), passNode(objReg)) + return this + } + protected readonly brandChainExpression: undefined +} +export function isChainExpression(node: object | undefined): node is ChainExpression { + return node instanceof ChainExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION, (peer: KNativePointer) => new ChainExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/CharLiteral.ts b/ets1.2/libarkts/src/generated/peers/CharLiteral.ts new file mode 100644 index 0000000000000000000000000000000000000000..94abf277f8aac5bf5fc2b7e7dd22ae0543997348 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/CharLiteral.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Literal } from "./Literal" + +export class CharLiteral extends Literal { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createCharLiteral(): CharLiteral { + const result: CharLiteral = new CharLiteral(global.generatedEs2panda._CreateCharLiteral(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL) + result.setChildrenParentPtr() + return result + } + static updateCharLiteral(original?: CharLiteral): CharLiteral { + const result: CharLiteral = new CharLiteral(global.generatedEs2panda._UpdateCharLiteral(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL) + result.setChildrenParentPtr() + return result + } + protected readonly brandCharLiteral: undefined +} +export function isCharLiteral(node: object | undefined): node is CharLiteral { + return node instanceof CharLiteral +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL, (peer: KNativePointer) => new CharLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ClassDeclaration.ts b/ets1.2/libarkts/src/generated/peers/ClassDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..29c0de6c356b065bdaf529f78ea367153c7a3cae --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ClassDeclaration.ts @@ -0,0 +1,77 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { ClassDefinition } from "./ClassDefinition" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaModifierFlags } from "./../Es2pandaEnums" +import { Statement } from "./Statement" + +export class ClassDeclaration extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createClassDeclaration(def?: ClassDefinition, modifierFlags?: Es2pandaModifierFlags): ClassDeclaration { + const result: ClassDeclaration = new ClassDeclaration(global.generatedEs2panda._CreateClassDeclaration(global.context, passNode(def)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION) + if (modifierFlags) + { + result.modifierFlags = modifierFlags + } + result.setChildrenParentPtr() + return result + } + static updateClassDeclaration(original?: ClassDeclaration, def?: ClassDefinition, modifierFlags?: Es2pandaModifierFlags): ClassDeclaration { + const result: ClassDeclaration = new ClassDeclaration(global.generatedEs2panda._UpdateClassDeclaration(global.context, passNode(original), passNode(def)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION) + if (modifierFlags) + { + result.modifierFlags = modifierFlags + } + result.setChildrenParentPtr() + return result + } + get definition(): ClassDefinition { + return unpackNonNullableNode(global.generatedEs2panda._ClassDeclarationDefinition(global.context, this.peer)) + } + /** @deprecated */ + setDefinition(def?: ClassDefinition): this { + global.generatedEs2panda._ClassDeclarationSetDefinition(global.context, this.peer, passNode(def)) + return this + } + protected readonly brandClassDeclaration: undefined +} +export function isClassDeclaration(node: object | undefined): node is ClassDeclaration { + return node instanceof ClassDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION, (peer: KNativePointer) => new ClassDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ClassDefinition.ts b/ets1.2/libarkts/src/generated/peers/ClassDefinition.ts new file mode 100644 index 0000000000000000000000000000000000000000..976cb99ff3141d568264d1c368e83e33054df865 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ClassDefinition.ts @@ -0,0 +1,366 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotationUsage } from "./AnnotationUsage" +import { ClassDeclaration } from "./ClassDeclaration" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaClassDefinitionModifiers } from "./../Es2pandaEnums" +import { Es2pandaModifierFlags } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Identifier } from "./Identifier" +import { MethodDefinition } from "./MethodDefinition" +import { SrcDumper } from "./SrcDumper" +import { TSClassImplements } from "./TSClassImplements" +import { TSEnumDeclaration } from "./TSEnumDeclaration" +import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" +import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" +import { TypedAstNode } from "./TypedAstNode" +import { extension_ClassDefinitionSetBody } from "./../../reexport-for-generated" + +export class ClassDefinition extends TypedAstNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createClassDefinition(ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags, annotations?: readonly AnnotationUsage[]): ClassDefinition { + const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._CreateClassDefinition(global.context, passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), _implements.length, passNode(ctor), passNode(superClass), passNodeArray(body), body.length, modifiers, flags), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + static updateClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, typeParams: TSTypeParameterDeclaration | undefined, superTypeParams: TSTypeParameterInstantiation | undefined, _implements: readonly TSClassImplements[], ctor: MethodDefinition | undefined, superClass: Expression | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags, annotations?: readonly AnnotationUsage[]): ClassDefinition { + const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition(global.context, passNode(original), passNode(ident), passNode(typeParams), passNode(superTypeParams), passNodeArray(_implements), _implements.length, passNode(ctor), passNode(superClass), passNodeArray(body), body.length, modifiers, flags), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + static update1ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, body: readonly AstNode[], modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags, annotations?: readonly AnnotationUsage[]): ClassDefinition { + const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition1(global.context, passNode(original), passNode(ident), passNodeArray(body), body.length, modifiers, flags), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + static update2ClassDefinition(original: ClassDefinition | undefined, ident: Identifier | undefined, modifiers: Es2pandaClassDefinitionModifiers, flags: Es2pandaModifierFlags, annotations?: readonly AnnotationUsage[]): ClassDefinition { + const result: ClassDefinition = new ClassDefinition(global.generatedEs2panda._UpdateClassDefinition2(global.context, passNode(original), passNode(ident), modifiers, flags), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + get ident(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionIdent(global.context, this.peer)) + } + /** @deprecated */ + setIdent(ident?: Identifier): this { + global.generatedEs2panda._ClassDefinitionSetIdent(global.context, this.peer, passNode(ident)) + return this + } + get internalName(): string { + return unpackString(global.generatedEs2panda._ClassDefinitionInternalNameConst(global.context, this.peer)) + } + get super(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionSuper(global.context, this.peer)) + } + /** @deprecated */ + setSuper(superClass?: Expression): this { + global.generatedEs2panda._ClassDefinitionSetSuper(global.context, this.peer, passNode(superClass)) + return this + } + get isGlobal(): boolean { + return global.generatedEs2panda._ClassDefinitionIsGlobalConst(global.context, this.peer) + } + get isLocal(): boolean { + return global.generatedEs2panda._ClassDefinitionIsLocalConst(global.context, this.peer) + } + get isExtern(): boolean { + return global.generatedEs2panda._ClassDefinitionIsExternConst(global.context, this.peer) + } + get isFromExternal(): boolean { + return global.generatedEs2panda._ClassDefinitionIsFromExternalConst(global.context, this.peer) + } + get isInner(): boolean { + return global.generatedEs2panda._ClassDefinitionIsInnerConst(global.context, this.peer) + } + get isGlobalInitialized(): boolean { + return global.generatedEs2panda._ClassDefinitionIsGlobalInitializedConst(global.context, this.peer) + } + get isClassDefinitionChecked(): boolean { + return global.generatedEs2panda._ClassDefinitionIsClassDefinitionCheckedConst(global.context, this.peer) + } + get isAnonymous(): boolean { + return global.generatedEs2panda._ClassDefinitionIsAnonymousConst(global.context, this.peer) + } + get isIntEnumTransformed(): boolean { + return global.generatedEs2panda._ClassDefinitionIsIntEnumTransformedConst(global.context, this.peer) + } + get isStringEnumTransformed(): boolean { + return global.generatedEs2panda._ClassDefinitionIsStringEnumTransformedConst(global.context, this.peer) + } + get isEnumTransformed(): boolean { + return global.generatedEs2panda._ClassDefinitionIsEnumTransformedConst(global.context, this.peer) + } + get isNamespaceTransformed(): boolean { + return global.generatedEs2panda._ClassDefinitionIsNamespaceTransformedConst(global.context, this.peer) + } + get isLazyImportObjectClass(): boolean { + return global.generatedEs2panda._ClassDefinitionIsLazyImportObjectClassConst(global.context, this.peer) + } + get isFromStruct(): boolean { + return global.generatedEs2panda._ClassDefinitionIsFromStructConst(global.context, this.peer) + } + get isInitInCctor(): boolean { + return global.generatedEs2panda._ClassDefinitionIsInitInCctorConst(global.context, this.peer) + } + get isModule(): boolean { + return global.generatedEs2panda._ClassDefinitionIsModuleConst(global.context, this.peer) + } + /** @deprecated */ + setGlobalInitialized(): this { + global.generatedEs2panda._ClassDefinitionSetGlobalInitialized(global.context, this.peer) + return this + } + /** @deprecated */ + setInnerModifier(): this { + global.generatedEs2panda._ClassDefinitionSetInnerModifier(global.context, this.peer) + return this + } + /** @deprecated */ + setClassDefinitionChecked(): this { + global.generatedEs2panda._ClassDefinitionSetClassDefinitionChecked(global.context, this.peer) + return this + } + /** @deprecated */ + setAnonymousModifier(): this { + global.generatedEs2panda._ClassDefinitionSetAnonymousModifier(global.context, this.peer) + return this + } + /** @deprecated */ + setNamespaceTransformed(): this { + global.generatedEs2panda._ClassDefinitionSetNamespaceTransformed(global.context, this.peer) + return this + } + /** @deprecated */ + setLazyImportObjectClass(): this { + global.generatedEs2panda._ClassDefinitionSetLazyImportObjectClass(global.context, this.peer) + return this + } + /** @deprecated */ + setFromStructModifier(): this { + global.generatedEs2panda._ClassDefinitionSetFromStructModifier(global.context, this.peer) + return this + } + /** @deprecated */ + setInitInCctor(): this { + global.generatedEs2panda._ClassDefinitionSetInitInCctor(global.context, this.peer) + return this + } + get modifiers(): Es2pandaClassDefinitionModifiers { + return global.generatedEs2panda._ClassDefinitionModifiersConst(global.context, this.peer) + } + /** @deprecated */ + addProperties(body: readonly AstNode[]): this { + global.generatedEs2panda._ClassDefinitionAddProperties(global.context, this.peer, passNodeArray(body), body.length) + return this + } + get ctor(): MethodDefinition | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionCtor(global.context, this.peer)) + } + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionTypeParams(global.context, this.peer)) + } + get superTypeParams(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionSuperTypeParams(global.context, this.peer)) + } + get localTypeCounter(): number { + return global.generatedEs2panda._ClassDefinitionLocalTypeCounter(global.context, this.peer) + } + get localIndex(): number { + return global.generatedEs2panda._ClassDefinitionLocalIndexConst(global.context, this.peer) + } + get functionalReferenceReferencedMethod(): MethodDefinition | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionFunctionalReferenceReferencedMethodConst(global.context, this.peer)) + } + /** @deprecated */ + setFunctionalReferenceReferencedMethod(functionalReferenceReferencedMethod?: MethodDefinition): this { + global.generatedEs2panda._ClassDefinitionSetFunctionalReferenceReferencedMethod(global.context, this.peer, passNode(functionalReferenceReferencedMethod)) + return this + } + get localPrefix(): string { + return unpackString(global.generatedEs2panda._ClassDefinitionLocalPrefixConst(global.context, this.peer)) + } + get origEnumDecl(): TSEnumDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionOrigEnumDeclConst(global.context, this.peer)) + } + get anonClass(): ClassDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ClassDefinitionGetAnonClass(global.context, this.peer)) + } + get hasPrivateMethod(): boolean { + return global.generatedEs2panda._ClassDefinitionHasPrivateMethodConst(global.context, this.peer) + } + get hasNativeMethod(): boolean { + return global.generatedEs2panda._ClassDefinitionHasNativeMethodConst(global.context, this.peer) + } + get hasComputedInstanceField(): boolean { + return global.generatedEs2panda._ClassDefinitionHasComputedInstanceFieldConst(global.context, this.peer) + } + /** @deprecated */ + addToExportedClasses(cls?: ClassDeclaration): this { + global.generatedEs2panda._ClassDefinitionAddToExportedClasses(global.context, this.peer, passNode(cls)) + return this + } + /** @deprecated */ + setModifiers(modifiers: Es2pandaClassDefinitionModifiers): this { + global.generatedEs2panda._ClassDefinitionSetModifiers(global.context, this.peer, modifiers) + return this + } + /** @deprecated */ + emplaceBody(body?: AstNode): this { + global.generatedEs2panda._ClassDefinitionEmplaceBody(global.context, this.peer, passNode(body)) + return this + } + /** @deprecated */ + clearBody(): this { + global.generatedEs2panda._ClassDefinitionClearBody(global.context, this.peer) + return this + } + /** @deprecated */ + setValueBody(body: AstNode | undefined, index: number): this { + global.generatedEs2panda._ClassDefinitionSetValueBody(global.context, this.peer, passNode(body), index) + return this + } + get body(): readonly AstNode[] { + return unpackNodeArray(global.generatedEs2panda._ClassDefinitionBody(global.context, this.peer)) + } + get bodyForUpdate(): readonly AstNode[] { + return unpackNodeArray(global.generatedEs2panda._ClassDefinitionBodyForUpdate(global.context, this.peer)) + } + /** @deprecated */ + emplaceImplements(_implements?: TSClassImplements): this { + global.generatedEs2panda._ClassDefinitionEmplaceImplements(global.context, this.peer, passNode(_implements)) + return this + } + /** @deprecated */ + clearImplements(): this { + global.generatedEs2panda._ClassDefinitionClearImplements(global.context, this.peer) + return this + } + /** @deprecated */ + setValueImplements(_implements: TSClassImplements | undefined, index: number): this { + global.generatedEs2panda._ClassDefinitionSetValueImplements(global.context, this.peer, passNode(_implements), index) + return this + } + get implements(): readonly TSClassImplements[] { + return unpackNodeArray(global.generatedEs2panda._ClassDefinitionImplements(global.context, this.peer)) + } + get implementsForUpdate(): readonly TSClassImplements[] { + return unpackNodeArray(global.generatedEs2panda._ClassDefinitionImplementsForUpdate(global.context, this.peer)) + } + /** @deprecated */ + setCtor(ctor?: MethodDefinition): this { + global.generatedEs2panda._ClassDefinitionSetCtor(global.context, this.peer, passNode(ctor)) + return this + } + /** @deprecated */ + setTypeParams(typeParams?: TSTypeParameterDeclaration): this { + global.generatedEs2panda._ClassDefinitionSetTypeParams(global.context, this.peer, passNode(typeParams)) + return this + } + /** @deprecated */ + setOrigEnumDecl(origEnumDecl?: TSEnumDeclaration): this { + global.generatedEs2panda._ClassDefinitionSetOrigEnumDecl(global.context, this.peer, passNode(origEnumDecl)) + return this + } + /** @deprecated */ + setAnonClass(anonClass?: ClassDeclaration): this { + global.generatedEs2panda._ClassDefinitionSetAnonClass(global.context, this.peer, passNode(anonClass)) + return this + } + /** @deprecated */ + setInternalName(internalName: string): this { + global.generatedEs2panda._ClassDefinitionSetInternalName(global.context, this.peer, internalName) + return this + } + get hasAnnotations(): boolean { + return global.generatedEs2panda._ClassDefinitionHasAnnotationsConst(global.context, this.peer) + } + /** @deprecated */ + emplaceAnnotation(source?: AnnotationUsage): this { + global.generatedEs2panda._ClassDefinitionEmplaceAnnotation(global.context, this.peer, passNode(source)) + return this + } + /** @deprecated */ + clearAnnotations(): this { + global.generatedEs2panda._ClassDefinitionClearAnnotations(global.context, this.peer) + return this + } + /** @deprecated */ + dumpAnnotations(dumper?: SrcDumper): this { + global.generatedEs2panda._ClassDefinitionDumpAnnotationsConst(global.context, this.peer, passNode(dumper)) + return this + } + get annotationsForUpdate(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._ClassDefinitionAnnotationsForUpdate(global.context, this.peer)) + } + get annotations(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._ClassDefinitionAnnotations(global.context, this.peer)) + } + /** @deprecated */ + setAnnotations(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._ClassDefinitionSetAnnotations(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + /** @deprecated */ + setAnnotations1(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._ClassDefinitionSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + setBody = extension_ClassDefinitionSetBody + protected readonly brandClassDefinition: undefined +} +export function isClassDefinition(node: object | undefined): node is ClassDefinition { + return node instanceof ClassDefinition +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION, (peer: KNativePointer) => new ClassDefinition(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ClassElement.ts b/ets1.2/libarkts/src/generated/peers/ClassElement.ts new file mode 100644 index 0000000000000000000000000000000000000000..6108529adb414a7d37f5ae29368fac80a6222a10 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ClassElement.ts @@ -0,0 +1,77 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Identifier } from "./Identifier" +import { TSEnumMember } from "./TSEnumMember" +import { TypedStatement } from "./TypedStatement" + +export class ClassElement extends TypedStatement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + get id(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ClassElementId(global.context, this.peer)) + } + get key(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ClassElementKey(global.context, this.peer)) + } + get value(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ClassElementValue(global.context, this.peer)) + } + /** @deprecated */ + setValue(value?: Expression): this { + global.generatedEs2panda._ClassElementSetValue(global.context, this.peer, passNode(value)) + return this + } + get originEnumMember(): TSEnumMember | undefined { + return unpackNode(global.generatedEs2panda._ClassElementOriginEnumMemberConst(global.context, this.peer)) + } + /** @deprecated */ + setOrigEnumMember(enumMember?: TSEnumMember): this { + global.generatedEs2panda._ClassElementSetOrigEnumMember(global.context, this.peer, passNode(enumMember)) + return this + } + get isPrivateElement(): boolean { + return global.generatedEs2panda._ClassElementIsPrivateElementConst(global.context, this.peer) + } + get isComputed(): boolean { + return global.generatedEs2panda._ClassElementIsComputedConst(global.context, this.peer) + } + protected readonly brandClassElement: undefined +} +export function isClassElement(node: object | undefined): node is ClassElement { + return node instanceof ClassElement +} diff --git a/ets1.2/libarkts/src/generated/peers/ClassExpression.ts b/ets1.2/libarkts/src/generated/peers/ClassExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..3940738bc05fb4873e6a6f5b941259a3c8058419 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ClassExpression.ts @@ -0,0 +1,63 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { ClassDefinition } from "./ClassDefinition" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class ClassExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createClassExpression(def?: ClassDefinition): ClassExpression { + const result: ClassExpression = new ClassExpression(global.generatedEs2panda._CreateClassExpression(global.context, passNode(def)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateClassExpression(original?: ClassExpression, def?: ClassDefinition): ClassExpression { + const result: ClassExpression = new ClassExpression(global.generatedEs2panda._UpdateClassExpression(global.context, passNode(original), passNode(def)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get definition(): ClassDefinition | undefined { + return unpackNode(global.generatedEs2panda._ClassExpressionDefinitionConst(global.context, this.peer)) + } + protected readonly brandClassExpression: undefined +} +export function isClassExpression(node: object | undefined): node is ClassExpression { + return node instanceof ClassExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION, (peer: KNativePointer) => new ClassExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ClassProperty.ts b/ets1.2/libarkts/src/generated/peers/ClassProperty.ts new file mode 100644 index 0000000000000000000000000000000000000000..c686a277ac75a2405b0567c5b70a9f0ef5babf57 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ClassProperty.ts @@ -0,0 +1,138 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotationUsage } from "./AnnotationUsage" +import { ClassElement } from "./ClassElement" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaModifierFlags } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { SrcDumper } from "./SrcDumper" +import { TypeNode } from "./TypeNode" + +export class ClassProperty extends ClassElement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createClassProperty(key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean, annotations?: readonly AnnotationUsage[]): ClassProperty { + const result: ClassProperty = new ClassProperty(global.generatedEs2panda._CreateClassProperty(global.context, passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + static updateClassProperty(original: ClassProperty | undefined, key: Expression | undefined, value: Expression | undefined, typeAnnotation: TypeNode | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean, annotations?: readonly AnnotationUsage[]): ClassProperty { + const result: ClassProperty = new ClassProperty(global.generatedEs2panda._UpdateClassProperty(global.context, passNode(original), passNode(key), passNode(value), passNode(typeAnnotation), modifiers, isComputed), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + get isDefaultAccessModifier(): boolean { + return global.generatedEs2panda._ClassPropertyIsDefaultAccessModifierConst(global.context, this.peer) + } + /** @deprecated */ + setDefaultAccessModifier(isDefault: boolean): this { + global.generatedEs2panda._ClassPropertySetDefaultAccessModifier(global.context, this.peer, isDefault) + return this + } + get typeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ClassPropertyTypeAnnotationConst(global.context, this.peer)) + } + /** @deprecated */ + setTypeAnnotation(typeAnnotation?: TypeNode): this { + global.generatedEs2panda._ClassPropertySetTypeAnnotation(global.context, this.peer, passNode(typeAnnotation)) + return this + } + get needInitInStaticBlock(): boolean { + return global.generatedEs2panda._ClassPropertyNeedInitInStaticBlockConst(global.context, this.peer) + } + /** @deprecated */ + setNeedInitInStaticBlock(): this { + global.generatedEs2panda._ClassPropertySetNeedInitInStaticBlock(global.context, this.peer) + return this + } + get isImmediateInit(): boolean { + return global.generatedEs2panda._ClassPropertyIsImmediateInitConst(global.context, this.peer) + } + /** @deprecated */ + setIsImmediateInit(): this { + global.generatedEs2panda._ClassPropertySetIsImmediateInit(global.context, this.peer) + return this + } + get hasAnnotations(): boolean { + return global.generatedEs2panda._ClassPropertyHasAnnotationsConst(global.context, this.peer) + } + /** @deprecated */ + emplaceAnnotation(source?: AnnotationUsage): this { + global.generatedEs2panda._ClassPropertyEmplaceAnnotation(global.context, this.peer, passNode(source)) + return this + } + /** @deprecated */ + clearAnnotations(): this { + global.generatedEs2panda._ClassPropertyClearAnnotations(global.context, this.peer) + return this + } + /** @deprecated */ + dumpAnnotations(dumper?: SrcDumper): this { + global.generatedEs2panda._ClassPropertyDumpAnnotationsConst(global.context, this.peer, passNode(dumper)) + return this + } + get annotationsForUpdate(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._ClassPropertyAnnotationsForUpdate(global.context, this.peer)) + } + get annotations(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._ClassPropertyAnnotations(global.context, this.peer)) + } + /** @deprecated */ + setAnnotations(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._ClassPropertySetAnnotations(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + /** @deprecated */ + setAnnotations1(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._ClassPropertySetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + protected readonly brandClassProperty: undefined +} +export function isClassProperty(node: object | undefined): node is ClassProperty { + return node instanceof ClassProperty +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY, (peer: KNativePointer) => new ClassProperty(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ClassStaticBlock.ts b/ets1.2/libarkts/src/generated/peers/ClassStaticBlock.ts new file mode 100644 index 0000000000000000000000000000000000000000..5798b8d49255a86b8bc28910201ab2200b35bea6 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ClassStaticBlock.ts @@ -0,0 +1,67 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { ClassElement } from "./ClassElement" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { ScriptFunction } from "./ScriptFunction" + +export class ClassStaticBlock extends ClassElement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createClassStaticBlock(value?: Expression): ClassStaticBlock { + const result: ClassStaticBlock = new ClassStaticBlock(global.generatedEs2panda._CreateClassStaticBlock(global.context, passNode(value)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK) + result.setChildrenParentPtr() + return result + } + static updateClassStaticBlock(original?: ClassStaticBlock, value?: Expression): ClassStaticBlock { + const result: ClassStaticBlock = new ClassStaticBlock(global.generatedEs2panda._UpdateClassStaticBlock(global.context, passNode(original), passNode(value)), Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK) + result.setChildrenParentPtr() + return result + } + get function(): ScriptFunction | undefined { + return unpackNode(global.generatedEs2panda._ClassStaticBlockFunction(global.context, this.peer)) + } + get name(): string { + return unpackString(global.generatedEs2panda._ClassStaticBlockNameConst(global.context, this.peer)) + } + protected readonly brandClassStaticBlock: undefined +} +export function isClassStaticBlock(node: object | undefined): node is ClassStaticBlock { + return node instanceof ClassStaticBlock +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK, (peer: KNativePointer) => new ClassStaticBlock(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK)) +} diff --git a/ets1.2/libarkts/src/generated/peers/CodeGen.ts b/ets1.2/libarkts/src/generated/peers/CodeGen.ts new file mode 100644 index 0000000000000000000000000000000000000000..4272a4ef4c7907f554ce4578f42b62384f1f04ea --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/CodeGen.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class CodeGen extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandCodeGen: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/ConditionalExpression.ts b/ets1.2/libarkts/src/generated/peers/ConditionalExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..aa8166872ab5810a6b5fce26e54f082746d6e4d0 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ConditionalExpression.ts @@ -0,0 +1,83 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class ConditionalExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createConditionalExpression(test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression { + const result: ConditionalExpression = new ConditionalExpression(global.generatedEs2panda._CreateConditionalExpression(global.context, passNode(test), passNode(consequent), passNode(alternate)), Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateConditionalExpression(original?: ConditionalExpression, test?: Expression, consequent?: Expression, alternate?: Expression): ConditionalExpression { + const result: ConditionalExpression = new ConditionalExpression(global.generatedEs2panda._UpdateConditionalExpression(global.context, passNode(original), passNode(test), passNode(consequent), passNode(alternate)), Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get test(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ConditionalExpressionTest(global.context, this.peer)) + } + /** @deprecated */ + setTest(expr?: Expression): this { + global.generatedEs2panda._ConditionalExpressionSetTest(global.context, this.peer, passNode(expr)) + return this + } + get consequent(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ConditionalExpressionConsequent(global.context, this.peer)) + } + /** @deprecated */ + setConsequent(expr?: Expression): this { + global.generatedEs2panda._ConditionalExpressionSetConsequent(global.context, this.peer, passNode(expr)) + return this + } + get alternate(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ConditionalExpressionAlternate(global.context, this.peer)) + } + /** @deprecated */ + setAlternate(expr?: Expression): this { + global.generatedEs2panda._ConditionalExpressionSetAlternate(global.context, this.peer, passNode(expr)) + return this + } + protected readonly brandConditionalExpression: undefined +} +export function isConditionalExpression(node: object | undefined): node is ConditionalExpression { + return node instanceof ConditionalExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION, (peer: KNativePointer) => new ConditionalExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ContinueStatement.ts b/ets1.2/libarkts/src/generated/peers/ContinueStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..b17460e34beb7ccca930486c1d4350fb9ad17293 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ContinueStatement.ts @@ -0,0 +1,79 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Identifier } from "./Identifier" +import { Statement } from "./Statement" + +export class ContinueStatement extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create1ContinueStatement(ident?: Identifier): ContinueStatement { + const result: ContinueStatement = new ContinueStatement(global.generatedEs2panda._CreateContinueStatement1(global.context, passNode(ident)), Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateContinueStatement(original?: ContinueStatement): ContinueStatement { + const result: ContinueStatement = new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT) + result.setChildrenParentPtr() + return result + } + static update1ContinueStatement(original?: ContinueStatement, ident?: Identifier): ContinueStatement { + const result: ContinueStatement = new ContinueStatement(global.generatedEs2panda._UpdateContinueStatement1(global.context, passNode(original), passNode(ident)), Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT) + result.setChildrenParentPtr() + return result + } + get ident(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ContinueStatementIdent(global.context, this.peer)) + } + get target(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ContinueStatementTargetConst(global.context, this.peer)) + } + get hasTarget(): boolean { + return global.generatedEs2panda._ContinueStatementHasTargetConst(global.context, this.peer) + } + /** @deprecated */ + setTarget(target?: AstNode): this { + global.generatedEs2panda._ContinueStatementSetTarget(global.context, this.peer, passNode(target)) + return this + } + protected readonly brandContinueStatement: undefined +} +export function isContinueStatement(node: object | undefined): node is ContinueStatement { + return node instanceof ContinueStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT, (peer: KNativePointer) => new ContinueStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/DebuggerStatement.ts b/ets1.2/libarkts/src/generated/peers/DebuggerStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..c763d83060736c6bba94e806175e4d383ebf842d --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/DebuggerStatement.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Statement } from "./Statement" + +export class DebuggerStatement extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createDebuggerStatement(): DebuggerStatement { + const result: DebuggerStatement = new DebuggerStatement(global.generatedEs2panda._CreateDebuggerStatement(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateDebuggerStatement(original?: DebuggerStatement): DebuggerStatement { + const result: DebuggerStatement = new DebuggerStatement(global.generatedEs2panda._UpdateDebuggerStatement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT) + result.setChildrenParentPtr() + return result + } + protected readonly brandDebuggerStatement: undefined +} +export function isDebuggerStatement(node: object | undefined): node is DebuggerStatement { + return node instanceof DebuggerStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT, (peer: KNativePointer) => new DebuggerStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/Declaration.ts b/ets1.2/libarkts/src/generated/peers/Declaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..e4dd0dee221aff494700319818e353064f160f44 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/Declaration.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class Declaration extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandDeclaration: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/Decorator.ts b/ets1.2/libarkts/src/generated/peers/Decorator.ts new file mode 100644 index 0000000000000000000000000000000000000000..ce79b6c68f8037ce98fb813ef5c7cc590689d4bc --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/Decorator.ts @@ -0,0 +1,63 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Statement } from "./Statement" + +export class Decorator extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createDecorator(expr?: Expression): Decorator { + const result: Decorator = new Decorator(global.generatedEs2panda._CreateDecorator(global.context, passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR) + result.setChildrenParentPtr() + return result + } + static updateDecorator(original?: Decorator, expr?: Expression): Decorator { + const result: Decorator = new Decorator(global.generatedEs2panda._UpdateDecorator(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR) + result.setChildrenParentPtr() + return result + } + get expr(): Expression | undefined { + return unpackNode(global.generatedEs2panda._DecoratorExprConst(global.context, this.peer)) + } + protected readonly brandDecorator: undefined +} +export function isDecorator(node: object | undefined): node is Decorator { + return node instanceof Decorator +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR, (peer: KNativePointer) => new Decorator(peer, Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR)) +} diff --git a/ets1.2/libarkts/src/generated/peers/DiagnosticInfo.ts b/ets1.2/libarkts/src/generated/peers/DiagnosticInfo.ts new file mode 100644 index 0000000000000000000000000000000000000000..92984570c81e91dc1a0897976d6884a5be018781 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/DiagnosticInfo.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class DiagnosticInfo extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandDiagnosticInfo: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/DirectEvalExpression.ts b/ets1.2/libarkts/src/generated/peers/DirectEvalExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..7e1e558f7eb64660be5cbd6a04bdaa74021a560d --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/DirectEvalExpression.ts @@ -0,0 +1,61 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { CallExpression } from "./CallExpression" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" + +export class DirectEvalExpression extends CallExpression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createDirectEvalExpression(callee: Expression | undefined, _arguments: readonly Expression[], typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression { + const result: DirectEvalExpression = new DirectEvalExpression(global.generatedEs2panda._CreateDirectEvalExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, parserStatus), Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL) + result.setChildrenParentPtr() + return result + } + static updateDirectEvalExpression(original: DirectEvalExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[], typeParams: TSTypeParameterInstantiation | undefined, optional_arg: boolean, parserStatus: number): DirectEvalExpression { + const result: DirectEvalExpression = new DirectEvalExpression(global.generatedEs2panda._UpdateDirectEvalExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), _arguments.length, passNode(typeParams), optional_arg, parserStatus), Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL) + result.setChildrenParentPtr() + return result + } + protected readonly brandDirectEvalExpression: undefined +} +export function isDirectEvalExpression(node: object | undefined): node is DirectEvalExpression { + return node instanceof DirectEvalExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL, (peer: KNativePointer) => new DirectEvalExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL)) +} diff --git a/ets1.2/libarkts/src/generated/peers/DoWhileStatement.ts b/ets1.2/libarkts/src/generated/peers/DoWhileStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..f33db91c4b18697bfd5f793e0cf9a74f34e52f83 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/DoWhileStatement.ts @@ -0,0 +1,67 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { LoopStatement } from "./LoopStatement" +import { Statement } from "./Statement" + +export class DoWhileStatement extends LoopStatement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createDoWhileStatement(body?: Statement, test?: Expression): DoWhileStatement { + const result: DoWhileStatement = new DoWhileStatement(global.generatedEs2panda._CreateDoWhileStatement(global.context, passNode(body), passNode(test)), Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateDoWhileStatement(original?: DoWhileStatement, body?: Statement, test?: Expression): DoWhileStatement { + const result: DoWhileStatement = new DoWhileStatement(global.generatedEs2panda._UpdateDoWhileStatement(global.context, passNode(original), passNode(body), passNode(test)), Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT) + result.setChildrenParentPtr() + return result + } + get body(): Statement | undefined { + return unpackNode(global.generatedEs2panda._DoWhileStatementBody(global.context, this.peer)) + } + get test(): Expression | undefined { + return unpackNode(global.generatedEs2panda._DoWhileStatementTest(global.context, this.peer)) + } + protected readonly brandDoWhileStatement: undefined +} +export function isDoWhileStatement(node: object | undefined): node is DoWhileStatement { + return node instanceof DoWhileStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT, (peer: KNativePointer) => new DoWhileStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/DynamicImportData.ts b/ets1.2/libarkts/src/generated/peers/DynamicImportData.ts new file mode 100644 index 0000000000000000000000000000000000000000..83433099d013cf50c75c15ce02e2573e17b3d260 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/DynamicImportData.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class DynamicImportData extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandDynamicImportData: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSClassLiteral.ts b/ets1.2/libarkts/src/generated/peers/ETSClassLiteral.ts new file mode 100644 index 0000000000000000000000000000000000000000..9a37f0a822bf50d96d8708216bd782487734af57 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSClassLiteral.ts @@ -0,0 +1,63 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" + +export class ETSClassLiteral extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSClassLiteral(expr?: TypeNode): ETSClassLiteral { + const result: ETSClassLiteral = new ETSClassLiteral(global.generatedEs2panda._CreateETSClassLiteral(global.context, passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL) + result.setChildrenParentPtr() + return result + } + static updateETSClassLiteral(original?: ETSClassLiteral, expr?: TypeNode): ETSClassLiteral { + const result: ETSClassLiteral = new ETSClassLiteral(global.generatedEs2panda._UpdateETSClassLiteral(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL) + result.setChildrenParentPtr() + return result + } + get expr(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ETSClassLiteralExprConst(global.context, this.peer)) + } + protected readonly brandETSClassLiteral: undefined +} +export function isETSClassLiteral(node: object | undefined): node is ETSClassLiteral { + return node instanceof ETSClassLiteral +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL, (peer: KNativePointer) => new ETSClassLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSFunctionType.ts b/ets1.2/libarkts/src/generated/peers/ETSFunctionType.ts new file mode 100644 index 0000000000000000000000000000000000000000..2ad4075e630321be6a1d3cae605c3b7126d05fb1 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSFunctionType.ts @@ -0,0 +1,101 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotationUsage } from "./AnnotationUsage" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaScriptFunctionFlags } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { FunctionSignature } from "./FunctionSignature" +import { TSInterfaceDeclaration } from "./TSInterfaceDeclaration" +import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" +import { TypeNode } from "./TypeNode" + +export class ETSFunctionType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSFunctionType(signature: FunctionSignature | undefined, funcFlags: Es2pandaScriptFunctionFlags, annotations?: readonly AnnotationUsage[]): ETSFunctionType { + const result: ETSFunctionType = new ETSFunctionType(global.generatedEs2panda._CreateETSFunctionType(global.context, passNode(signature), funcFlags), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + static updateETSFunctionType(original: ETSFunctionType | undefined, signature: FunctionSignature | undefined, funcFlags: Es2pandaScriptFunctionFlags, annotations?: readonly AnnotationUsage[]): ETSFunctionType { + const result: ETSFunctionType = new ETSFunctionType(global.generatedEs2panda._UpdateETSFunctionType(global.context, passNode(original), passNode(signature), funcFlags), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ETSFunctionTypeTypeParams(global.context, this.peer)) + } + get params(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._ETSFunctionTypeParamsConst(global.context, this.peer)) + } + /** @deprecated */ + setParams(paramsList: readonly Expression[]): this { + global.generatedEs2panda._ETSFunctionTypeSetParams(global.context, this.peer, passNodeArray(paramsList), paramsList.length) + return this + } + get returnType(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ETSFunctionTypeReturnType(global.context, this.peer)) + } + get functionalInterface(): TSInterfaceDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ETSFunctionTypeFunctionalInterface(global.context, this.peer)) + } + /** @deprecated */ + setFunctionalInterface(functionalInterface?: TSInterfaceDeclaration): this { + global.generatedEs2panda._ETSFunctionTypeSetFunctionalInterface(global.context, this.peer, passNode(functionalInterface)) + return this + } + get flags(): Es2pandaScriptFunctionFlags { + return global.generatedEs2panda._ETSFunctionTypeFlags(global.context, this.peer) + } + get isExtensionFunction(): boolean { + return global.generatedEs2panda._ETSFunctionTypeIsExtensionFunctionConst(global.context, this.peer) + } + protected readonly brandETSFunctionType: undefined +} +export function isETSFunctionType(node: object | undefined): node is ETSFunctionType { + return node instanceof ETSFunctionType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE, (peer: KNativePointer) => new ETSFunctionType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSImportDeclaration.ts b/ets1.2/libarkts/src/generated/peers/ETSImportDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..1e0c9117ad5bfeff656572a4c4a8de432d894743 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSImportDeclaration.ts @@ -0,0 +1,91 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaId } from "./../Es2pandaEnums" +import { Es2pandaImportFlags } from "./../Es2pandaEnums" +import { Es2pandaImportKinds } from "./../Es2pandaEnums" +import { ImportDeclaration } from "./ImportDeclaration" +import { StringLiteral } from "./StringLiteral" + +export class ETSImportDeclaration extends ImportDeclaration { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSImportDeclaration(importPath: StringLiteral | undefined, specifiers: readonly AstNode[], importKinds: Es2pandaImportKinds): ETSImportDeclaration { + const result: ETSImportDeclaration = new ETSImportDeclaration(global.generatedEs2panda._CreateETSImportDeclaration(global.context, passNode(importPath), passNodeArray(specifiers), specifiers.length, importKinds), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION) + result.setChildrenParentPtr() + return result + } + static updateETSImportDeclaration(original: ETSImportDeclaration | undefined, importPath: StringLiteral | undefined, specifiers: readonly AstNode[], importKinds: Es2pandaImportKinds): ETSImportDeclaration { + const result: ETSImportDeclaration = new ETSImportDeclaration(global.generatedEs2panda._UpdateETSImportDeclaration(global.context, passNode(original), passNode(importPath), passNodeArray(specifiers), specifiers.length, importKinds), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION) + result.setChildrenParentPtr() + return result + } + /** @deprecated */ + setImportMetadata(importFlags: Es2pandaImportFlags, lang: Es2pandaId, resolvedSource: string, declPath: string, ohmUrl: string): this { + global.generatedEs2panda._ETSImportDeclarationSetImportMetadata(global.context, this.peer, importFlags, lang, resolvedSource, declPath, ohmUrl) + return this + } + get declPath(): string { + return unpackString(global.generatedEs2panda._ETSImportDeclarationDeclPathConst(global.context, this.peer)) + } + get ohmUrl(): string { + return unpackString(global.generatedEs2panda._ETSImportDeclarationOhmUrlConst(global.context, this.peer)) + } + get isValid(): boolean { + return global.generatedEs2panda._ETSImportDeclarationIsValidConst(global.context, this.peer) + } + get isPureDynamic(): boolean { + return global.generatedEs2panda._ETSImportDeclarationIsPureDynamicConst(global.context, this.peer) + } + /** @deprecated */ + setAssemblerName(assemblerName: string): this { + global.generatedEs2panda._ETSImportDeclarationSetAssemblerName(global.context, this.peer, assemblerName) + return this + } + get assemblerName(): string { + return unpackString(global.generatedEs2panda._ETSImportDeclarationAssemblerNameConst(global.context, this.peer)) + } + get resolvedSource(): string { + return unpackString(global.generatedEs2panda._ETSImportDeclarationResolvedSourceConst(global.context, this.peer)) + } + protected readonly brandETSImportDeclaration: undefined +} +export function isETSImportDeclaration(node: object | undefined): node is ETSImportDeclaration { + return node instanceof ETSImportDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, (peer: KNativePointer) => new ETSImportDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSIntrinsicNode.ts b/ets1.2/libarkts/src/generated/peers/ETSIntrinsicNode.ts new file mode 100644 index 0000000000000000000000000000000000000000..4852a83ab41df9aba36771efdbc671a580f7ab60 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSIntrinsicNode.ts @@ -0,0 +1,76 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaIntrinsicNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class ETSIntrinsicNode extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create2ETSIntrinsicNode(type: Es2pandaIntrinsicNodeType, _arguments: readonly Expression[]): ETSIntrinsicNode { + const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._CreateETSIntrinsicNode2(global.context, type, passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE) + result.setChildrenParentPtr() + return result + } + static updateETSIntrinsicNode(original?: ETSIntrinsicNode): ETSIntrinsicNode { + const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE) + result.setChildrenParentPtr() + return result + } + static update1ETSIntrinsicNode(original?: ETSIntrinsicNode, other?: ETSIntrinsicNode): ETSIntrinsicNode { + const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE) + result.setChildrenParentPtr() + return result + } + static update2ETSIntrinsicNode(original: ETSIntrinsicNode | undefined, type: Es2pandaIntrinsicNodeType, _arguments: readonly Expression[]): ETSIntrinsicNode { + const result: ETSIntrinsicNode = new ETSIntrinsicNode(global.generatedEs2panda._UpdateETSIntrinsicNode2(global.context, passNode(original), type, passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE) + result.setChildrenParentPtr() + return result + } + get type(): Es2pandaIntrinsicNodeType { + return global.generatedEs2panda._ETSIntrinsicNodeTypeConst(global.context, this.peer) + } + get arguments(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._ETSIntrinsicNodeArgumentsConst(global.context, this.peer)) + } + protected readonly brandETSIntrinsicNode: undefined +} +export function isETSIntrinsicNode(node: object | undefined): node is ETSIntrinsicNode { + return node instanceof ETSIntrinsicNode +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE, (peer: KNativePointer) => new ETSIntrinsicNode(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_INTRINSIC_NODE_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSKeyofType.ts b/ets1.2/libarkts/src/generated/peers/ETSKeyofType.ts new file mode 100644 index 0000000000000000000000000000000000000000..c1f536a6ef559e187e70d6ab4ce99606795d7b87 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSKeyofType.ts @@ -0,0 +1,62 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class ETSKeyofType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSKeyofType(type?: TypeNode): ETSKeyofType { + const result: ETSKeyofType = new ETSKeyofType(global.generatedEs2panda._CreateETSKeyofType(global.context, passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE) + result.setChildrenParentPtr() + return result + } + static updateETSKeyofType(original?: ETSKeyofType, type?: TypeNode): ETSKeyofType { + const result: ETSKeyofType = new ETSKeyofType(global.generatedEs2panda._UpdateETSKeyofType(global.context, passNode(original), passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE) + result.setChildrenParentPtr() + return result + } + get typeRef(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ETSKeyofTypeGetTypeRefConst(global.context, this.peer)) + } + protected readonly brandETSKeyofType: undefined +} +export function isETSKeyofType(node: object | undefined): node is ETSKeyofType { + return node instanceof ETSKeyofType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE, (peer: KNativePointer) => new ETSKeyofType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_KEYOF_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSModule.ts b/ets1.2/libarkts/src/generated/peers/ETSModule.ts new file mode 100644 index 0000000000000000000000000000000000000000..438cde1591a93d356323fd9a4868563e096e5e40 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSModule.ts @@ -0,0 +1,130 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotationUsage } from "./AnnotationUsage" +import { BlockStatement } from "./BlockStatement" +import { ClassDefinition } from "./ClassDefinition" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaModuleFlag } from "./../Es2pandaEnums" +import { Identifier } from "./Identifier" +import { Program } from "./Program" +import { SrcDumper } from "./SrcDumper" +import { Statement } from "./Statement" +import { extension_ETSModuleGetNamespaceFlag } from "./../../reexport-for-generated" + +export class ETSModule extends BlockStatement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSModule(statementList: readonly Statement[], ident: Identifier | undefined, flag: Es2pandaModuleFlag, program?: Program): ETSModule { + const result: ETSModule = new ETSModule(global.generatedEs2panda._CreateETSModule(global.context, passNodeArray(statementList), statementList.length, passNode(ident), flag, passNode(program)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) + result.setChildrenParentPtr() + return result + } + static updateETSModule(original: ETSModule | undefined, statementList: readonly Statement[], ident: Identifier | undefined, flag: Es2pandaModuleFlag, program?: Program): ETSModule { + const result: ETSModule = new ETSModule(global.generatedEs2panda._UpdateETSModule(global.context, passNode(original), passNodeArray(statementList), statementList.length, passNode(ident), flag, passNode(program)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE) + result.setChildrenParentPtr() + return result + } + get ident(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ETSModuleIdent(global.context, this.peer)) + } + get program(): Program | undefined { + return new Program(global.generatedEs2panda._ETSModuleProgram(global.context, this.peer)) + } + get globalClass(): ClassDefinition | undefined { + return unpackNode(global.generatedEs2panda._ETSModuleGlobalClass(global.context, this.peer)) + } + /** @deprecated */ + setGlobalClass(globalClass?: ClassDefinition): this { + global.generatedEs2panda._ETSModuleSetGlobalClass(global.context, this.peer, passNode(globalClass)) + return this + } + get isETSScript(): boolean { + return global.generatedEs2panda._ETSModuleIsETSScriptConst(global.context, this.peer) + } + get isNamespace(): boolean { + return global.generatedEs2panda._ETSModuleIsNamespaceConst(global.context, this.peer) + } + get isNamespaceChainLastNode(): boolean { + return global.generatedEs2panda._ETSModuleIsNamespaceChainLastNodeConst(global.context, this.peer) + } + /** @deprecated */ + setNamespaceChainLastNode(): this { + global.generatedEs2panda._ETSModuleSetNamespaceChainLastNode(global.context, this.peer) + return this + } + get hasAnnotations(): boolean { + return global.generatedEs2panda._ETSModuleHasAnnotationsConst(global.context, this.peer) + } + /** @deprecated */ + emplaceAnnotation(source?: AnnotationUsage): this { + global.generatedEs2panda._ETSModuleEmplaceAnnotation(global.context, this.peer, passNode(source)) + return this + } + /** @deprecated */ + clearAnnotations(): this { + global.generatedEs2panda._ETSModuleClearAnnotations(global.context, this.peer) + return this + } + /** @deprecated */ + dumpAnnotations(dumper?: SrcDumper): this { + global.generatedEs2panda._ETSModuleDumpAnnotationsConst(global.context, this.peer, passNode(dumper)) + return this + } + get annotationsForUpdate(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._ETSModuleAnnotationsForUpdate(global.context, this.peer)) + } + get annotations(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._ETSModuleAnnotations(global.context, this.peer)) + } + /** @deprecated */ + setAnnotations(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._ETSModuleSetAnnotations(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + /** @deprecated */ + setAnnotations1(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._ETSModuleSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + getNamespaceFlag = extension_ETSModuleGetNamespaceFlag + protected readonly brandETSModule: undefined +} +export function isETSModule(node: object | undefined): node is ETSModule { + return node instanceof ETSModule +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, (peer: KNativePointer) => new ETSModule(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts b/ets1.2/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..ec6e899176f9494e5b14c39112a324cb7d6e2d2f --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSNewArrayInstanceExpression.ts @@ -0,0 +1,76 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" + +export class ETSNewArrayInstanceExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSNewArrayInstanceExpression(typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression { + const result: ETSNewArrayInstanceExpression = new ETSNewArrayInstanceExpression(global.generatedEs2panda._CreateETSNewArrayInstanceExpression(global.context, passNode(typeReference), passNode(dimension)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateETSNewArrayInstanceExpression(original?: ETSNewArrayInstanceExpression, typeReference?: TypeNode, dimension?: Expression): ETSNewArrayInstanceExpression { + const result: ETSNewArrayInstanceExpression = new ETSNewArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNode(dimension)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get typeReference(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ETSNewArrayInstanceExpressionTypeReference(global.context, this.peer)) + } + get dimension(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ETSNewArrayInstanceExpressionDimension(global.context, this.peer)) + } + /** @deprecated */ + setDimension(dimension?: Expression): this { + global.generatedEs2panda._ETSNewArrayInstanceExpressionSetDimension(global.context, this.peer, passNode(dimension)) + return this + } + /** @deprecated */ + clearPreferredType(): this { + global.generatedEs2panda._ETSNewArrayInstanceExpressionClearPreferredType(global.context, this.peer) + return this + } + protected readonly brandETSNewArrayInstanceExpression: undefined +} +export function isETSNewArrayInstanceExpression(node: object | undefined): node is ETSNewArrayInstanceExpression { + return node instanceof ETSNewArrayInstanceExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewArrayInstanceExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts b/ets1.2/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..d515affd2a5c76a898f6e1ae9d7fc416041f79bd --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSNewClassInstanceExpression.ts @@ -0,0 +1,80 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class ETSNewClassInstanceExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSNewClassInstanceExpression(typeReference: Expression | undefined, _arguments: readonly Expression[]): ETSNewClassInstanceExpression { + const result: ETSNewClassInstanceExpression = new ETSNewClassInstanceExpression(global.generatedEs2panda._CreateETSNewClassInstanceExpression(global.context, passNode(typeReference), passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateETSNewClassInstanceExpression(original: ETSNewClassInstanceExpression | undefined, typeReference: Expression | undefined, _arguments: readonly Expression[]): ETSNewClassInstanceExpression { + const result: ETSNewClassInstanceExpression = new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static update1ETSNewClassInstanceExpression(original?: ETSNewClassInstanceExpression, other?: ETSNewClassInstanceExpression): ETSNewClassInstanceExpression { + const result: ETSNewClassInstanceExpression = new ETSNewClassInstanceExpression(global.generatedEs2panda._UpdateETSNewClassInstanceExpression1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get typeRef(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ETSNewClassInstanceExpressionGetTypeRefConst(global.context, this.peer)) + } + get arguments(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._ETSNewClassInstanceExpressionGetArguments(global.context, this.peer)) + } + /** @deprecated */ + setArguments(_arguments: readonly Expression[]): this { + global.generatedEs2panda._ETSNewClassInstanceExpressionSetArguments(global.context, this.peer, passNodeArray(_arguments), _arguments.length) + return this + } + /** @deprecated */ + addToArgumentsFront(expr?: Expression): this { + global.generatedEs2panda._ETSNewClassInstanceExpressionAddToArgumentsFront(global.context, this.peer, passNode(expr)) + return this + } + protected readonly brandETSNewClassInstanceExpression: undefined +} +export function isETSNewClassInstanceExpression(node: object | undefined): node is ETSNewClassInstanceExpression { + return node instanceof ETSNewClassInstanceExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewClassInstanceExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts b/ets1.2/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..0ad0fced930c8ed699690eaf72c6cb1ce03f3fea --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSNewMultiDimArrayInstanceExpression.ts @@ -0,0 +1,76 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" + +export class ETSNewMultiDimArrayInstanceExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSNewMultiDimArrayInstanceExpression(typeReference: TypeNode | undefined, dimensions: readonly Expression[]): ETSNewMultiDimArrayInstanceExpression { + const result: ETSNewMultiDimArrayInstanceExpression = new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._CreateETSNewMultiDimArrayInstanceExpression(global.context, passNode(typeReference), passNodeArray(dimensions), dimensions.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateETSNewMultiDimArrayInstanceExpression(original: ETSNewMultiDimArrayInstanceExpression | undefined, typeReference: TypeNode | undefined, dimensions: readonly Expression[]): ETSNewMultiDimArrayInstanceExpression { + const result: ETSNewMultiDimArrayInstanceExpression = new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression(global.context, passNode(original), passNode(typeReference), passNodeArray(dimensions), dimensions.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static update1ETSNewMultiDimArrayInstanceExpression(original?: ETSNewMultiDimArrayInstanceExpression, other?: ETSNewMultiDimArrayInstanceExpression): ETSNewMultiDimArrayInstanceExpression { + const result: ETSNewMultiDimArrayInstanceExpression = new ETSNewMultiDimArrayInstanceExpression(global.generatedEs2panda._UpdateETSNewMultiDimArrayInstanceExpression1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get typeReference(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ETSNewMultiDimArrayInstanceExpressionTypeReference(global.context, this.peer)) + } + get dimensions(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._ETSNewMultiDimArrayInstanceExpressionDimensions(global.context, this.peer)) + } + /** @deprecated */ + clearPreferredType(): this { + global.generatedEs2panda._ETSNewMultiDimArrayInstanceExpressionClearPreferredType(global.context, this.peer) + return this + } + protected readonly brandETSNewMultiDimArrayInstanceExpression: undefined +} +export function isETSNewMultiDimArrayInstanceExpression(node: object | undefined): node is ETSNewMultiDimArrayInstanceExpression { + return node instanceof ETSNewMultiDimArrayInstanceExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION, (peer: KNativePointer) => new ETSNewMultiDimArrayInstanceExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSNullType.ts b/ets1.2/libarkts/src/generated/peers/ETSNullType.ts new file mode 100644 index 0000000000000000000000000000000000000000..35768af96dded3d33d29fca9fbbcbec6f688e2a0 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSNullType.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class ETSNullType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSNullType(): ETSNullType { + const result: ETSNullType = new ETSNullType(global.generatedEs2panda._CreateETSNullType(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE) + result.setChildrenParentPtr() + return result + } + static updateETSNullType(original?: ETSNullType): ETSNullType { + const result: ETSNullType = new ETSNullType(global.generatedEs2panda._UpdateETSNullType(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE) + result.setChildrenParentPtr() + return result + } + protected readonly brandETSNullType: undefined +} +export function isETSNullType(node: object | undefined): node is ETSNullType { + return node instanceof ETSNullType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE, (peer: KNativePointer) => new ETSNullType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSPackageDeclaration.ts b/ets1.2/libarkts/src/generated/peers/ETSPackageDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..fa6f3f1b3c1d136cc6475081b7adc078cf30d548 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSPackageDeclaration.ts @@ -0,0 +1,60 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Statement } from "./Statement" + +export class ETSPackageDeclaration extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSPackageDeclaration(name?: Expression): ETSPackageDeclaration { + const result: ETSPackageDeclaration = new ETSPackageDeclaration(global.generatedEs2panda._CreateETSPackageDeclaration(global.context, passNode(name)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION) + result.setChildrenParentPtr() + return result + } + static updateETSPackageDeclaration(original?: ETSPackageDeclaration, name?: Expression): ETSPackageDeclaration { + const result: ETSPackageDeclaration = new ETSPackageDeclaration(global.generatedEs2panda._UpdateETSPackageDeclaration(global.context, passNode(original), passNode(name)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION) + result.setChildrenParentPtr() + return result + } + protected readonly brandETSPackageDeclaration: undefined +} +export function isETSPackageDeclaration(node: object | undefined): node is ETSPackageDeclaration { + return node instanceof ETSPackageDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION, (peer: KNativePointer) => new ETSPackageDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSParameterExpression.ts b/ets1.2/libarkts/src/generated/peers/ETSParameterExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..bb3f3d713757adc0ff56e882cde6da55b6849b7c --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSParameterExpression.ts @@ -0,0 +1,190 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotatedExpression } from "./AnnotatedExpression" +import { AnnotationUsage } from "./AnnotationUsage" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Identifier } from "./Identifier" +import { SpreadElement } from "./SpreadElement" +import { SrcDumper } from "./SrcDumper" +import { TypeNode } from "./TypeNode" + +export class ETSParameterExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSParameterExpression(identOrSpread: AnnotatedExpression | undefined, isOptional: boolean, annotations?: readonly AnnotationUsage[]): ETSParameterExpression { + const result: ETSParameterExpression = new ETSParameterExpression(global.generatedEs2panda._CreateETSParameterExpression(global.context, passNode(identOrSpread), isOptional), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + static updateETSParameterExpression(original: ETSParameterExpression | undefined, identOrSpread: AnnotatedExpression | undefined, isOptional: boolean, annotations?: readonly AnnotationUsage[]): ETSParameterExpression { + const result: ETSParameterExpression = new ETSParameterExpression(global.generatedEs2panda._UpdateETSParameterExpression(global.context, passNode(original), passNode(identOrSpread), isOptional), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + static create1ETSParameterExpression(identOrSpread?: AnnotatedExpression, initializer?: Expression, annotations?: readonly AnnotationUsage[]): ETSParameterExpression { + const result: ETSParameterExpression = new ETSParameterExpression(global.generatedEs2panda._CreateETSParameterExpression1(global.context, passNode(identOrSpread), passNode(initializer)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + static update1ETSParameterExpression(original?: ETSParameterExpression, identOrSpread?: AnnotatedExpression, initializer?: Expression, annotations?: readonly AnnotationUsage[]): ETSParameterExpression { + const result: ETSParameterExpression = new ETSParameterExpression(global.generatedEs2panda._UpdateETSParameterExpression1(global.context, passNode(original), passNode(identOrSpread), passNode(initializer)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + get name(): string { + return unpackString(global.generatedEs2panda._ETSParameterExpressionNameConst(global.context, this.peer)) + } + get ident(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ETSParameterExpressionIdent(global.context, this.peer)) + } + /** @deprecated */ + setIdent(ident?: Identifier): this { + global.generatedEs2panda._ETSParameterExpressionSetIdent(global.context, this.peer, passNode(ident)) + return this + } + get spread(): SpreadElement | undefined { + return unpackNode(global.generatedEs2panda._ETSParameterExpressionSpread(global.context, this.peer)) + } + /** @deprecated */ + setSpread(spread?: SpreadElement): this { + global.generatedEs2panda._ETSParameterExpressionSetSpread(global.context, this.peer, passNode(spread)) + return this + } + get restParameter(): SpreadElement | undefined { + return unpackNode(global.generatedEs2panda._ETSParameterExpressionRestParameter(global.context, this.peer)) + } + get initializer(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ETSParameterExpressionInitializer(global.context, this.peer)) + } + /** @deprecated */ + setLexerSaved(savedLexer: string): this { + global.generatedEs2panda._ETSParameterExpressionSetLexerSaved(global.context, this.peer, savedLexer) + return this + } + get lexerSaved(): string { + return unpackString(global.generatedEs2panda._ETSParameterExpressionLexerSavedConst(global.context, this.peer)) + } + get typeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ETSParameterExpressionTypeAnnotation(global.context, this.peer)) + } + /** @deprecated */ + setTypeAnnotation(typeNode?: TypeNode): this { + global.generatedEs2panda._ETSParameterExpressionSetTypeAnnotation(global.context, this.peer, passNode(typeNode)) + return this + } + get isOptional(): boolean { + return global.generatedEs2panda._ETSParameterExpressionIsOptionalConst(global.context, this.peer) + } + /** @deprecated */ + setOptional(value: boolean): this { + global.generatedEs2panda._ETSParameterExpressionSetOptional(global.context, this.peer, value) + return this + } + /** @deprecated */ + setInitializer(initExpr?: Expression): this { + global.generatedEs2panda._ETSParameterExpressionSetInitializer(global.context, this.peer, passNode(initExpr)) + return this + } + get isRestParameter(): boolean { + return global.generatedEs2panda._ETSParameterExpressionIsRestParameterConst(global.context, this.peer) + } + get requiredParams(): number { + return global.generatedEs2panda._ETSParameterExpressionGetRequiredParamsConst(global.context, this.peer) + } + /** @deprecated */ + setRequiredParams(extraValue: number): this { + global.generatedEs2panda._ETSParameterExpressionSetRequiredParams(global.context, this.peer, extraValue) + return this + } + get hasAnnotations(): boolean { + return global.generatedEs2panda._ETSParameterExpressionHasAnnotationsConst(global.context, this.peer) + } + /** @deprecated */ + emplaceAnnotation(source?: AnnotationUsage): this { + global.generatedEs2panda._ETSParameterExpressionEmplaceAnnotation(global.context, this.peer, passNode(source)) + return this + } + /** @deprecated */ + clearAnnotations(): this { + global.generatedEs2panda._ETSParameterExpressionClearAnnotations(global.context, this.peer) + return this + } + /** @deprecated */ + dumpAnnotations(dumper?: SrcDumper): this { + global.generatedEs2panda._ETSParameterExpressionDumpAnnotationsConst(global.context, this.peer, passNode(dumper)) + return this + } + get annotationsForUpdate(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._ETSParameterExpressionAnnotationsForUpdate(global.context, this.peer)) + } + get annotations(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._ETSParameterExpressionAnnotations(global.context, this.peer)) + } + /** @deprecated */ + setAnnotations(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._ETSParameterExpressionSetAnnotations(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + /** @deprecated */ + setAnnotations1(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._ETSParameterExpressionSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + protected readonly brandETSParameterExpression: undefined +} +export function isETSParameterExpression(node: object | undefined): node is ETSParameterExpression { + return node instanceof ETSParameterExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION, (peer: KNativePointer) => new ETSParameterExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSPrimitiveType.ts b/ets1.2/libarkts/src/generated/peers/ETSPrimitiveType.ts new file mode 100644 index 0000000000000000000000000000000000000000..025d8f7f5d67405113a21a637a7897857bc35833 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSPrimitiveType.ts @@ -0,0 +1,63 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaPrimitiveType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class ETSPrimitiveType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSPrimitiveType(type: Es2pandaPrimitiveType): ETSPrimitiveType { + const result: ETSPrimitiveType = new ETSPrimitiveType(global.generatedEs2panda._CreateETSPrimitiveType(global.context, type), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE) + result.setChildrenParentPtr() + return result + } + static updateETSPrimitiveType(original: ETSPrimitiveType | undefined, type: Es2pandaPrimitiveType): ETSPrimitiveType { + const result: ETSPrimitiveType = new ETSPrimitiveType(global.generatedEs2panda._UpdateETSPrimitiveType(global.context, passNode(original), type), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE) + result.setChildrenParentPtr() + return result + } + get primitiveType(): Es2pandaPrimitiveType { + return global.generatedEs2panda._ETSPrimitiveTypeGetPrimitiveTypeConst(global.context, this.peer) + } + protected readonly brandETSPrimitiveType: undefined +} +export function isETSPrimitiveType(node: object | undefined): node is ETSPrimitiveType { + return node instanceof ETSPrimitiveType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE, (peer: KNativePointer) => new ETSPrimitiveType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSReExportDeclaration.ts b/ets1.2/libarkts/src/generated/peers/ETSReExportDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..95383709d6e1666ba7ba6b4d7d466a47be3f8b6d --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSReExportDeclaration.ts @@ -0,0 +1,56 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { ETSImportDeclaration } from "./ETSImportDeclaration" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Statement } from "./Statement" + +export class ETSReExportDeclaration extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + get eTSImportDeclarations(): ETSImportDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ETSReExportDeclarationGetETSImportDeclarations(global.context, this.peer)) + } + get programPath(): string { + return unpackString(global.generatedEs2panda._ETSReExportDeclarationGetProgramPathConst(global.context, this.peer)) + } + protected readonly brandETSReExportDeclaration: undefined +} +export function isETSReExportDeclaration(node: object | undefined): node is ETSReExportDeclaration { + return node instanceof ETSReExportDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_REEXPORT_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_REEXPORT_STATEMENT, (peer: KNativePointer) => new ETSReExportDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_REEXPORT_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSStringLiteralType.ts b/ets1.2/libarkts/src/generated/peers/ETSStringLiteralType.ts new file mode 100644 index 0000000000000000000000000000000000000000..e2e3ab49b0e7e0d0a65f1aaf72dc41c359f54c2d --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSStringLiteralType.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class ETSStringLiteralType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSStringLiteralType(value: string): ETSStringLiteralType { + const result: ETSStringLiteralType = new ETSStringLiteralType(global.generatedEs2panda._CreateETSStringLiteralType(global.context, value), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_STRING_LITERAL_TYPE) + result.setChildrenParentPtr() + return result + } + static updateETSStringLiteralType(original: ETSStringLiteralType | undefined, value: string): ETSStringLiteralType { + const result: ETSStringLiteralType = new ETSStringLiteralType(global.generatedEs2panda._UpdateETSStringLiteralType(global.context, passNode(original), value), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_STRING_LITERAL_TYPE) + result.setChildrenParentPtr() + return result + } + protected readonly brandETSStringLiteralType: undefined +} +export function isETSStringLiteralType(node: object | undefined): node is ETSStringLiteralType { + return node instanceof ETSStringLiteralType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_STRING_LITERAL_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_STRING_LITERAL_TYPE, (peer: KNativePointer) => new ETSStringLiteralType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_STRING_LITERAL_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSStructDeclaration.ts b/ets1.2/libarkts/src/generated/peers/ETSStructDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..f5f8537d7600a3eba7818407080fbe1c37e969d6 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSStructDeclaration.ts @@ -0,0 +1,60 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { ClassDeclaration } from "./ClassDeclaration" +import { ClassDefinition } from "./ClassDefinition" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" + +export class ETSStructDeclaration extends ClassDeclaration { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSStructDeclaration(def?: ClassDefinition): ETSStructDeclaration { + const result: ETSStructDeclaration = new ETSStructDeclaration(global.generatedEs2panda._CreateETSStructDeclaration(global.context, passNode(def)), Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION) + result.setChildrenParentPtr() + return result + } + static updateETSStructDeclaration(original?: ETSStructDeclaration, def?: ClassDefinition): ETSStructDeclaration { + const result: ETSStructDeclaration = new ETSStructDeclaration(global.generatedEs2panda._UpdateETSStructDeclaration(global.context, passNode(original), passNode(def)), Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION) + result.setChildrenParentPtr() + return result + } + protected readonly brandETSStructDeclaration: undefined +} +export function isETSStructDeclaration(node: object | undefined): node is ETSStructDeclaration { + return node instanceof ETSStructDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION, (peer: KNativePointer) => new ETSStructDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSTuple.ts b/ets1.2/libarkts/src/generated/peers/ETSTuple.ts new file mode 100644 index 0000000000000000000000000000000000000000..31e503decc52439c374bd5708894b6fb47f44d81 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSTuple.ts @@ -0,0 +1,90 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class ETSTuple extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSTuple(): ETSTuple { + const result: ETSTuple = new ETSTuple(global.generatedEs2panda._CreateETSTuple(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE) + result.setChildrenParentPtr() + return result + } + static updateETSTuple(original?: ETSTuple): ETSTuple { + const result: ETSTuple = new ETSTuple(global.generatedEs2panda._UpdateETSTuple(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE) + result.setChildrenParentPtr() + return result + } + static create1ETSTuple(size: number): ETSTuple { + const result: ETSTuple = new ETSTuple(global.generatedEs2panda._CreateETSTuple1(global.context, size), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE) + result.setChildrenParentPtr() + return result + } + static update1ETSTuple(original: ETSTuple | undefined, size: number): ETSTuple { + const result: ETSTuple = new ETSTuple(global.generatedEs2panda._UpdateETSTuple1(global.context, passNode(original), size), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE) + result.setChildrenParentPtr() + return result + } + static create2ETSTuple(typeList: readonly TypeNode[]): ETSTuple { + const result: ETSTuple = new ETSTuple(global.generatedEs2panda._CreateETSTuple2(global.context, passNodeArray(typeList), typeList.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE) + result.setChildrenParentPtr() + return result + } + static update2ETSTuple(original: ETSTuple | undefined, typeList: readonly TypeNode[]): ETSTuple { + const result: ETSTuple = new ETSTuple(global.generatedEs2panda._UpdateETSTuple2(global.context, passNode(original), passNodeArray(typeList), typeList.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE) + result.setChildrenParentPtr() + return result + } + get tupleSize(): number { + return global.generatedEs2panda._ETSTupleGetTupleSizeConst(global.context, this.peer) + } + get tupleTypeAnnotationsList(): readonly TypeNode[] { + return unpackNodeArray(global.generatedEs2panda._ETSTupleGetTupleTypeAnnotationsList(global.context, this.peer)) + } + /** @deprecated */ + setTypeAnnotationsList(typeNodeList: readonly TypeNode[]): this { + global.generatedEs2panda._ETSTupleSetTypeAnnotationsList(global.context, this.peer, passNodeArray(typeNodeList), typeNodeList.length) + return this + } + protected readonly brandETSTuple: undefined +} +export function isETSTuple(node: object | undefined): node is ETSTuple { + return node instanceof ETSTuple +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE, (peer: KNativePointer) => new ETSTuple(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSTypeReference.ts b/ets1.2/libarkts/src/generated/peers/ETSTypeReference.ts new file mode 100644 index 0000000000000000000000000000000000000000..172c570ef707a305362b1c6d7a560b187e59f623 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSTypeReference.ts @@ -0,0 +1,67 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { ETSTypeReferencePart } from "./ETSTypeReferencePart" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Identifier } from "./Identifier" +import { TypeNode } from "./TypeNode" + +export class ETSTypeReference extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSTypeReference(part?: ETSTypeReferencePart): ETSTypeReference { + const result: ETSTypeReference = new ETSTypeReference(global.generatedEs2panda._CreateETSTypeReference(global.context, passNode(part)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE) + result.setChildrenParentPtr() + return result + } + static updateETSTypeReference(original?: ETSTypeReference, part?: ETSTypeReferencePart): ETSTypeReference { + const result: ETSTypeReference = new ETSTypeReference(global.generatedEs2panda._UpdateETSTypeReference(global.context, passNode(original), passNode(part)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE) + result.setChildrenParentPtr() + return result + } + get part(): ETSTypeReferencePart | undefined { + return unpackNode(global.generatedEs2panda._ETSTypeReferencePart(global.context, this.peer)) + } + get baseName(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ETSTypeReferenceBaseNameConst(global.context, this.peer)) + } + protected readonly brandETSTypeReference: undefined +} +export function isETSTypeReference(node: object | undefined): node is ETSTypeReference { + return node instanceof ETSTypeReference +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE, (peer: KNativePointer) => new ETSTypeReference(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSTypeReferencePart.ts b/ets1.2/libarkts/src/generated/peers/ETSTypeReferencePart.ts new file mode 100644 index 0000000000000000000000000000000000000000..070ff11e3f34baf8a10daa28f38dadd2305138b5 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSTypeReferencePart.ts @@ -0,0 +1,79 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Identifier } from "./Identifier" +import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" +import { TypeNode } from "./TypeNode" + +export class ETSTypeReferencePart extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSTypeReferencePart(name?: Expression, typeParams?: TSTypeParameterInstantiation, prev?: ETSTypeReferencePart): ETSTypeReferencePart { + const result: ETSTypeReferencePart = new ETSTypeReferencePart(global.generatedEs2panda._CreateETSTypeReferencePart(global.context, passNode(name), passNode(typeParams), passNode(prev)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART) + result.setChildrenParentPtr() + return result + } + static updateETSTypeReferencePart(original?: ETSTypeReferencePart, name?: Expression, typeParams?: TSTypeParameterInstantiation, prev?: ETSTypeReferencePart): ETSTypeReferencePart { + const result: ETSTypeReferencePart = new ETSTypeReferencePart(global.generatedEs2panda._UpdateETSTypeReferencePart(global.context, passNode(original), passNode(name), passNode(typeParams), passNode(prev)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART) + result.setChildrenParentPtr() + return result + } + static update1ETSTypeReferencePart(original?: ETSTypeReferencePart, name?: Expression): ETSTypeReferencePart { + const result: ETSTypeReferencePart = new ETSTypeReferencePart(global.generatedEs2panda._UpdateETSTypeReferencePart1(global.context, passNode(original), passNode(name)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART) + result.setChildrenParentPtr() + return result + } + get previous(): ETSTypeReferencePart | undefined { + return unpackNode(global.generatedEs2panda._ETSTypeReferencePartPrevious(global.context, this.peer)) + } + get name(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ETSTypeReferencePartName(global.context, this.peer)) + } + get typeParams(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._ETSTypeReferencePartTypeParams(global.context, this.peer)) + } + get ident(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ETSTypeReferencePartGetIdent(global.context, this.peer)) + } + protected readonly brandETSTypeReferencePart: undefined +} +export function isETSTypeReferencePart(node: object | undefined): node is ETSTypeReferencePart { + return node instanceof ETSTypeReferencePart +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART, (peer: KNativePointer) => new ETSTypeReferencePart(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSUndefinedType.ts b/ets1.2/libarkts/src/generated/peers/ETSUndefinedType.ts new file mode 100644 index 0000000000000000000000000000000000000000..245d5e6916ae80b430eee2e7fd35032c3f8212bc --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSUndefinedType.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class ETSUndefinedType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSUndefinedType(): ETSUndefinedType { + const result: ETSUndefinedType = new ETSUndefinedType(global.generatedEs2panda._CreateETSUndefinedType(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE) + result.setChildrenParentPtr() + return result + } + static updateETSUndefinedType(original?: ETSUndefinedType): ETSUndefinedType { + const result: ETSUndefinedType = new ETSUndefinedType(global.generatedEs2panda._UpdateETSUndefinedType(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE) + result.setChildrenParentPtr() + return result + } + protected readonly brandETSUndefinedType: undefined +} +export function isETSUndefinedType(node: object | undefined): node is ETSUndefinedType { + return node instanceof ETSUndefinedType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE, (peer: KNativePointer) => new ETSUndefinedType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSUnionType.ts b/ets1.2/libarkts/src/generated/peers/ETSUnionType.ts new file mode 100644 index 0000000000000000000000000000000000000000..217c508434f7a45cac217a4a99326d27564ae083 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSUnionType.ts @@ -0,0 +1,76 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotationUsage } from "./AnnotationUsage" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class ETSUnionType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSUnionType(types: readonly TypeNode[], annotations?: readonly AnnotationUsage[]): ETSUnionType { + const result: ETSUnionType = new ETSUnionType(global.generatedEs2panda._CreateETSUnionType(global.context, passNodeArray(types), types.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + static updateETSUnionType(original: ETSUnionType | undefined, types: readonly TypeNode[], annotations?: readonly AnnotationUsage[]): ETSUnionType { + const result: ETSUnionType = new ETSUnionType(global.generatedEs2panda._UpdateETSUnionType(global.context, passNode(original), passNodeArray(types), types.length), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + get types(): readonly TypeNode[] { + return unpackNodeArray(global.generatedEs2panda._ETSUnionTypeTypesConst(global.context, this.peer)) + } + /** @deprecated */ + setValueTypes(type: TypeNode | undefined, index: number): this { + global.generatedEs2panda._ETSUnionTypeSetValueTypesConst(global.context, this.peer, passNode(type), index) + return this + } + protected readonly brandETSUnionType: undefined +} +export function isETSUnionType(node: object | undefined): node is ETSUnionType { + return node instanceof ETSUnionType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE, (peer: KNativePointer) => new ETSUnionType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ETSWildcardType.ts b/ets1.2/libarkts/src/generated/peers/ETSWildcardType.ts new file mode 100644 index 0000000000000000000000000000000000000000..e3367060ea68be7e0fd5df22f24cd330e62246d6 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ETSWildcardType.ts @@ -0,0 +1,64 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { ETSTypeReference } from "./ETSTypeReference" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaModifierFlags } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class ETSWildcardType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createETSWildcardType(typeReference: ETSTypeReference | undefined, flags: Es2pandaModifierFlags): ETSWildcardType { + const result: ETSWildcardType = new ETSWildcardType(global.generatedEs2panda._CreateETSWildcardType(global.context, passNode(typeReference), flags), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_WILDCARD_TYPE) + result.setChildrenParentPtr() + return result + } + static updateETSWildcardType(original: ETSWildcardType | undefined, typeReference: ETSTypeReference | undefined, flags: Es2pandaModifierFlags): ETSWildcardType { + const result: ETSWildcardType = new ETSWildcardType(global.generatedEs2panda._UpdateETSWildcardType(global.context, passNode(original), passNode(typeReference), flags), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_WILDCARD_TYPE) + result.setChildrenParentPtr() + return result + } + get typeReference(): ETSTypeReference | undefined { + return unpackNode(global.generatedEs2panda._ETSWildcardTypeTypeReference(global.context, this.peer)) + } + protected readonly brandETSWildcardType: undefined +} +export function isETSWildcardType(node: object | undefined): node is ETSWildcardType { + return node instanceof ETSWildcardType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_WILDCARD_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_ETS_WILDCARD_TYPE, (peer: KNativePointer) => new ETSWildcardType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_WILDCARD_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/EmptyStatement.ts b/ets1.2/libarkts/src/generated/peers/EmptyStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..58fdc5fe4b9c28553eb01280d1058173abe82ce6 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/EmptyStatement.ts @@ -0,0 +1,67 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Statement } from "./Statement" + +export class EmptyStatement extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create1EmptyStatement(isBrokenStatement: boolean): EmptyStatement { + const result: EmptyStatement = new EmptyStatement(global.generatedEs2panda._CreateEmptyStatement1(global.context, isBrokenStatement), Es2pandaAstNodeType.AST_NODE_TYPE_EMPTY_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateEmptyStatement(original?: EmptyStatement): EmptyStatement { + const result: EmptyStatement = new EmptyStatement(global.generatedEs2panda._UpdateEmptyStatement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_EMPTY_STATEMENT) + result.setChildrenParentPtr() + return result + } + static update1EmptyStatement(original: EmptyStatement | undefined, isBrokenStatement: boolean): EmptyStatement { + const result: EmptyStatement = new EmptyStatement(global.generatedEs2panda._UpdateEmptyStatement1(global.context, passNode(original), isBrokenStatement), Es2pandaAstNodeType.AST_NODE_TYPE_EMPTY_STATEMENT) + result.setChildrenParentPtr() + return result + } + get isBrokenStatement(): boolean { + return global.generatedEs2panda._EmptyStatementIsBrokenStatement(global.context, this.peer) + } + protected readonly brandEmptyStatement: undefined +} +export function isEmptyStatement(node: object | undefined): node is EmptyStatement { + return node instanceof EmptyStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_EMPTY_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EMPTY_STATEMENT, (peer: KNativePointer) => new EmptyStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_EMPTY_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ErrorLogger.ts b/ets1.2/libarkts/src/generated/peers/ErrorLogger.ts new file mode 100644 index 0000000000000000000000000000000000000000..dc18c7ea1c668bde5f85ed70b2375ec65983f603 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ErrorLogger.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class ErrorLogger extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandErrorLogger: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/ExportAllDeclaration.ts b/ets1.2/libarkts/src/generated/peers/ExportAllDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..2a058bdc480546032af4337ba8fbd5f0357d36f4 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ExportAllDeclaration.ts @@ -0,0 +1,67 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Identifier } from "./Identifier" +import { Statement } from "./Statement" +import { StringLiteral } from "./StringLiteral" + +export class ExportAllDeclaration extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createExportAllDeclaration(source?: StringLiteral, exported?: Identifier): ExportAllDeclaration { + const result: ExportAllDeclaration = new ExportAllDeclaration(global.generatedEs2panda._CreateExportAllDeclaration(global.context, passNode(source), passNode(exported)), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_ALL_DECLARATION) + result.setChildrenParentPtr() + return result + } + static updateExportAllDeclaration(original?: ExportAllDeclaration, source?: StringLiteral, exported?: Identifier): ExportAllDeclaration { + const result: ExportAllDeclaration = new ExportAllDeclaration(global.generatedEs2panda._UpdateExportAllDeclaration(global.context, passNode(original), passNode(source), passNode(exported)), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_ALL_DECLARATION) + result.setChildrenParentPtr() + return result + } + get source(): StringLiteral | undefined { + return unpackNode(global.generatedEs2panda._ExportAllDeclarationSourceConst(global.context, this.peer)) + } + get exported(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ExportAllDeclarationExportedConst(global.context, this.peer)) + } + protected readonly brandExportAllDeclaration: undefined +} +export function isExportAllDeclaration(node: object | undefined): node is ExportAllDeclaration { + return node instanceof ExportAllDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_ALL_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_ALL_DECLARATION, (peer: KNativePointer) => new ExportAllDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_ALL_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ExportDefaultDeclaration.ts b/ets1.2/libarkts/src/generated/peers/ExportDefaultDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..5328778584bc72555d235f99c504dde152d0e65c --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ExportDefaultDeclaration.ts @@ -0,0 +1,65 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Statement } from "./Statement" + +export class ExportDefaultDeclaration extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createExportDefaultDeclaration(decl: AstNode | undefined, exportEquals: boolean): ExportDefaultDeclaration { + const result: ExportDefaultDeclaration = new ExportDefaultDeclaration(global.generatedEs2panda._CreateExportDefaultDeclaration(global.context, passNode(decl), exportEquals), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_DEFAULT_DECLARATION) + result.setChildrenParentPtr() + return result + } + static updateExportDefaultDeclaration(original: ExportDefaultDeclaration | undefined, decl: AstNode | undefined, exportEquals: boolean): ExportDefaultDeclaration { + const result: ExportDefaultDeclaration = new ExportDefaultDeclaration(global.generatedEs2panda._UpdateExportDefaultDeclaration(global.context, passNode(original), passNode(decl), exportEquals), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_DEFAULT_DECLARATION) + result.setChildrenParentPtr() + return result + } + get decl(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ExportDefaultDeclarationDecl(global.context, this.peer)) + } + get isExportEquals(): boolean { + return global.generatedEs2panda._ExportDefaultDeclarationIsExportEqualsConst(global.context, this.peer) + } + protected readonly brandExportDefaultDeclaration: undefined +} +export function isExportDefaultDeclaration(node: object | undefined): node is ExportDefaultDeclaration { + return node instanceof ExportDefaultDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_DEFAULT_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_DEFAULT_DECLARATION, (peer: KNativePointer) => new ExportDefaultDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_DEFAULT_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ExportNamedDeclaration.ts b/ets1.2/libarkts/src/generated/peers/ExportNamedDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..84436c8b42d318669644a47bd3dbe074f35e878a --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ExportNamedDeclaration.ts @@ -0,0 +1,95 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { ExportSpecifier } from "./ExportSpecifier" +import { Statement } from "./Statement" +import { StringLiteral } from "./StringLiteral" + +export class ExportNamedDeclaration extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createExportNamedDeclaration(source: StringLiteral | undefined, specifiers: readonly ExportSpecifier[]): ExportNamedDeclaration { + const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiers.length), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION) + result.setChildrenParentPtr() + return result + } + static updateExportNamedDeclaration(original: ExportNamedDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly ExportSpecifier[]): ExportNamedDeclaration { + const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiers.length), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION) + result.setChildrenParentPtr() + return result + } + static create1ExportNamedDeclaration(decl: AstNode | undefined, specifiers: readonly ExportSpecifier[]): ExportNamedDeclaration { + const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration1(global.context, passNode(decl), passNodeArray(specifiers), specifiers.length), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION) + result.setChildrenParentPtr() + return result + } + static update1ExportNamedDeclaration(original: ExportNamedDeclaration | undefined, decl: AstNode | undefined, specifiers: readonly ExportSpecifier[]): ExportNamedDeclaration { + const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration1(global.context, passNode(original), passNode(decl), passNodeArray(specifiers), specifiers.length), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION) + result.setChildrenParentPtr() + return result + } + static create2ExportNamedDeclaration(decl?: AstNode): ExportNamedDeclaration { + const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._CreateExportNamedDeclaration2(global.context, passNode(decl)), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION) + result.setChildrenParentPtr() + return result + } + static update2ExportNamedDeclaration(original?: ExportNamedDeclaration, decl?: AstNode): ExportNamedDeclaration { + const result: ExportNamedDeclaration = new ExportNamedDeclaration(global.generatedEs2panda._UpdateExportNamedDeclaration2(global.context, passNode(original), passNode(decl)), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION) + result.setChildrenParentPtr() + return result + } + get decl(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ExportNamedDeclarationDeclConst(global.context, this.peer)) + } + get source(): StringLiteral | undefined { + return unpackNode(global.generatedEs2panda._ExportNamedDeclarationSourceConst(global.context, this.peer)) + } + get specifiers(): readonly ExportSpecifier[] { + return unpackNodeArray(global.generatedEs2panda._ExportNamedDeclarationSpecifiersConst(global.context, this.peer)) + } + /** @deprecated */ + replaceSpecifiers(specifiers: readonly ExportSpecifier[]): this { + global.generatedEs2panda._ExportNamedDeclarationReplaceSpecifiers(global.context, this.peer, passNodeArray(specifiers), specifiers.length) + return this + } + protected readonly brandExportNamedDeclaration: undefined +} +export function isExportNamedDeclaration(node: object | undefined): node is ExportNamedDeclaration { + return node instanceof ExportNamedDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION, (peer: KNativePointer) => new ExportNamedDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ExportSpecifier.ts b/ets1.2/libarkts/src/generated/peers/ExportSpecifier.ts new file mode 100644 index 0000000000000000000000000000000000000000..63f1b5c9265fd69e2aa932f16fd939318cc971db --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ExportSpecifier.ts @@ -0,0 +1,83 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Identifier } from "./Identifier" +import { Statement } from "./Statement" + +export class ExportSpecifier extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createExportSpecifier(local?: Identifier, exported?: Identifier): ExportSpecifier { + const result: ExportSpecifier = new ExportSpecifier(global.generatedEs2panda._CreateExportSpecifier(global.context, passNode(local), passNode(exported)), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_SPECIFIER) + result.setChildrenParentPtr() + return result + } + static updateExportSpecifier(original?: ExportSpecifier, local?: Identifier, exported?: Identifier): ExportSpecifier { + const result: ExportSpecifier = new ExportSpecifier(global.generatedEs2panda._UpdateExportSpecifier(global.context, passNode(original), passNode(local), passNode(exported)), Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_SPECIFIER) + result.setChildrenParentPtr() + return result + } + get local(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ExportSpecifierLocalConst(global.context, this.peer)) + } + get exported(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ExportSpecifierExportedConst(global.context, this.peer)) + } + /** @deprecated */ + setDefault(): this { + global.generatedEs2panda._ExportSpecifierSetDefault(global.context, this.peer) + return this + } + get isDefault(): boolean { + return global.generatedEs2panda._ExportSpecifierIsDefaultConst(global.context, this.peer) + } + /** @deprecated */ + setConstantExpression(constantExpression?: Expression): this { + global.generatedEs2panda._ExportSpecifierSetConstantExpression(global.context, this.peer, passNode(constantExpression)) + return this + } + get constantExpression(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ExportSpecifierGetConstantExpressionConst(global.context, this.peer)) + } + protected readonly brandExportSpecifier: undefined +} +export function isExportSpecifier(node: object | undefined): node is ExportSpecifier { + return node instanceof ExportSpecifier +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_SPECIFIER)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_SPECIFIER, (peer: KNativePointer) => new ExportSpecifier(peer, Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_SPECIFIER)) +} diff --git a/ets1.2/libarkts/src/generated/peers/Expression.ts b/ets1.2/libarkts/src/generated/peers/Expression.ts new file mode 100644 index 0000000000000000000000000000000000000000..dde646264c282ee0b6d4fdb2d76ca7a6bd175f72 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/Expression.ts @@ -0,0 +1,85 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotatedExpression } from "./AnnotatedExpression" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Literal } from "./Literal" +import { TypeNode } from "./TypeNode" +import { TypedAstNode } from "./TypedAstNode" +import { extension_ExpressionGetPreferredTypePointer } from "./../../reexport-for-generated" +import { extension_ExpressionSetPreferredTypePointer } from "./../../reexport-for-generated" + +export class Expression extends TypedAstNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + get isGrouped(): boolean { + return global.generatedEs2panda._ExpressionIsGroupedConst(global.context, this.peer) + } + /** @deprecated */ + setGrouped(): this { + global.generatedEs2panda._ExpressionSetGrouped(global.context, this.peer) + return this + } + get asLiteral(): Literal | undefined { + return unpackNode(global.generatedEs2panda._ExpressionAsLiteral(global.context, this.peer)) + } + get isLiteral(): boolean { + return global.generatedEs2panda._ExpressionIsLiteralConst(global.context, this.peer) + } + get isTypeNode(): boolean { + return global.generatedEs2panda._ExpressionIsTypeNodeConst(global.context, this.peer) + } + get isAnnotatedExpression(): boolean { + return global.generatedEs2panda._ExpressionIsAnnotatedExpressionConst(global.context, this.peer) + } + get asTypeNode(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ExpressionAsTypeNode(global.context, this.peer)) + } + get asAnnotatedExpression(): AnnotatedExpression | undefined { + return unpackNode(global.generatedEs2panda._ExpressionAsAnnotatedExpression(global.context, this.peer)) + } + get isBrokenExpression(): boolean { + return global.generatedEs2panda._ExpressionIsBrokenExpressionConst(global.context, this.peer) + } + get toString(): string { + return unpackString(global.generatedEs2panda._ExpressionToStringConst(global.context, this.peer)) + } + getPreferredTypePointer = extension_ExpressionGetPreferredTypePointer + setPreferredTypePointer = extension_ExpressionSetPreferredTypePointer + protected readonly brandExpression: undefined +} +export function isExpression(node: object | undefined): node is Expression { + return node instanceof Expression +} diff --git a/ets1.2/libarkts/src/generated/peers/ExpressionStatement.ts b/ets1.2/libarkts/src/generated/peers/ExpressionStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..3565df7c24e7485793358787a88d2c941d239814 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ExpressionStatement.ts @@ -0,0 +1,68 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Statement } from "./Statement" + +export class ExpressionStatement extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createExpressionStatement(expr?: Expression): ExpressionStatement { + const result: ExpressionStatement = new ExpressionStatement(global.generatedEs2panda._CreateExpressionStatement(global.context, passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateExpressionStatement(original?: ExpressionStatement, expr?: Expression): ExpressionStatement { + const result: ExpressionStatement = new ExpressionStatement(global.generatedEs2panda._UpdateExpressionStatement(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT) + result.setChildrenParentPtr() + return result + } + get expression(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ExpressionStatementGetExpression(global.context, this.peer)) + } + /** @deprecated */ + setExpression(expr?: Expression): this { + global.generatedEs2panda._ExpressionStatementSetExpression(global.context, this.peer, passNode(expr)) + return this + } + protected readonly brandExpressionStatement: undefined +} +export function isExpressionStatement(node: object | undefined): node is ExpressionStatement { + return node instanceof ExpressionStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT, (peer: KNativePointer) => new ExpressionStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ForInStatement.ts b/ets1.2/libarkts/src/generated/peers/ForInStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..a44658c764e67c31072225a8701174ca8c7cea4b --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ForInStatement.ts @@ -0,0 +1,70 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { LoopStatement } from "./LoopStatement" +import { Statement } from "./Statement" + +export class ForInStatement extends LoopStatement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createForInStatement(left?: AstNode, right?: Expression, body?: Statement): ForInStatement { + const result: ForInStatement = new ForInStatement(global.generatedEs2panda._CreateForInStatement(global.context, passNode(left), passNode(right), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateForInStatement(original?: ForInStatement, left?: AstNode, right?: Expression, body?: Statement): ForInStatement { + const result: ForInStatement = new ForInStatement(global.generatedEs2panda._UpdateForInStatement(global.context, passNode(original), passNode(left), passNode(right), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT) + result.setChildrenParentPtr() + return result + } + get left(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ForInStatementLeft(global.context, this.peer)) + } + get right(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ForInStatementRight(global.context, this.peer)) + } + get body(): Statement | undefined { + return unpackNode(global.generatedEs2panda._ForInStatementBody(global.context, this.peer)) + } + protected readonly brandForInStatement: undefined +} +export function isForInStatement(node: object | undefined): node is ForInStatement { + return node instanceof ForInStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT, (peer: KNativePointer) => new ForInStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ForOfStatement.ts b/ets1.2/libarkts/src/generated/peers/ForOfStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..bb54c37b21f2463961d0f11b6b835b528f2855a7 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ForOfStatement.ts @@ -0,0 +1,73 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { LoopStatement } from "./LoopStatement" +import { Statement } from "./Statement" + +export class ForOfStatement extends LoopStatement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createForOfStatement(left: AstNode | undefined, right: Expression | undefined, body: Statement | undefined, isAwait: boolean): ForOfStatement { + const result: ForOfStatement = new ForOfStatement(global.generatedEs2panda._CreateForOfStatement(global.context, passNode(left), passNode(right), passNode(body), isAwait), Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateForOfStatement(original: ForOfStatement | undefined, left: AstNode | undefined, right: Expression | undefined, body: Statement | undefined, isAwait: boolean): ForOfStatement { + const result: ForOfStatement = new ForOfStatement(global.generatedEs2panda._UpdateForOfStatement(global.context, passNode(original), passNode(left), passNode(right), passNode(body), isAwait), Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT) + result.setChildrenParentPtr() + return result + } + get left(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ForOfStatementLeft(global.context, this.peer)) + } + get right(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ForOfStatementRight(global.context, this.peer)) + } + get body(): Statement | undefined { + return unpackNode(global.generatedEs2panda._ForOfStatementBody(global.context, this.peer)) + } + get isAwait(): boolean { + return global.generatedEs2panda._ForOfStatementIsAwaitConst(global.context, this.peer) + } + protected readonly brandForOfStatement: undefined +} +export function isForOfStatement(node: object | undefined): node is ForOfStatement { + return node instanceof ForOfStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT, (peer: KNativePointer) => new ForOfStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ForUpdateStatement.ts b/ets1.2/libarkts/src/generated/peers/ForUpdateStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..660fe66086500ba90ca74cf0b63b64c6e8575a91 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ForUpdateStatement.ts @@ -0,0 +1,68 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { LoopStatement } from "./LoopStatement" +import { Statement } from "./Statement" + +export class ForUpdateStatement extends LoopStatement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createForUpdateStatement(init?: AstNode, test?: Expression, update?: Expression, body?: Statement): ForUpdateStatement { + const result: ForUpdateStatement = new ForUpdateStatement(global.generatedEs2panda._CreateForUpdateStatement(global.context, passNode(init), passNode(test), passNode(update), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT) + result.setChildrenParentPtr() + return result + } + get init(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ForUpdateStatementInit(global.context, this.peer)) + } + get test(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ForUpdateStatementTest(global.context, this.peer)) + } + get update(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ForUpdateStatementUpdateConst(global.context, this.peer)) + } + get body(): Statement | undefined { + return unpackNode(global.generatedEs2panda._ForUpdateStatementBody(global.context, this.peer)) + } + protected readonly brandForUpdateStatement: undefined +} +export function isForUpdateStatement(node: object | undefined): node is ForUpdateStatement { + return node instanceof ForUpdateStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT, (peer: KNativePointer) => new ForUpdateStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/FunctionDeclaration.ts b/ets1.2/libarkts/src/generated/peers/FunctionDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..8b3d5fa9e1fb3b536deeaa5b0f0bad3ca31096ed --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/FunctionDeclaration.ts @@ -0,0 +1,107 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotationUsage } from "./AnnotationUsage" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { ScriptFunction } from "./ScriptFunction" +import { SrcDumper } from "./SrcDumper" +import { Statement } from "./Statement" + +export class FunctionDeclaration extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createFunctionDeclaration(func: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], isAnonymous: boolean): FunctionDeclaration { + const result: FunctionDeclaration = new FunctionDeclaration(global.generatedEs2panda._CreateFunctionDeclaration(global.context, passNode(func), passNodeArray(annotations), annotations.length, isAnonymous), Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION) + result.setChildrenParentPtr() + return result + } + static updateFunctionDeclaration(original: FunctionDeclaration | undefined, func: ScriptFunction | undefined, annotations: readonly AnnotationUsage[], isAnonymous: boolean): FunctionDeclaration { + const result: FunctionDeclaration = new FunctionDeclaration(global.generatedEs2panda._UpdateFunctionDeclaration(global.context, passNode(original), passNode(func), passNodeArray(annotations), annotations.length, isAnonymous), Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION) + result.setChildrenParentPtr() + return result + } + static update1FunctionDeclaration(original: FunctionDeclaration | undefined, func: ScriptFunction | undefined, isAnonymous: boolean): FunctionDeclaration { + const result: FunctionDeclaration = new FunctionDeclaration(global.generatedEs2panda._UpdateFunctionDeclaration1(global.context, passNode(original), passNode(func), isAnonymous), Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION) + result.setChildrenParentPtr() + return result + } + get function(): ScriptFunction | undefined { + return unpackNode(global.generatedEs2panda._FunctionDeclarationFunction(global.context, this.peer)) + } + get isAnonymous(): boolean { + return global.generatedEs2panda._FunctionDeclarationIsAnonymousConst(global.context, this.peer) + } + get hasAnnotations(): boolean { + return global.generatedEs2panda._FunctionDeclarationHasAnnotationsConst(global.context, this.peer) + } + /** @deprecated */ + emplaceAnnotation(source?: AnnotationUsage): this { + global.generatedEs2panda._FunctionDeclarationEmplaceAnnotation(global.context, this.peer, passNode(source)) + return this + } + /** @deprecated */ + clearAnnotations(): this { + global.generatedEs2panda._FunctionDeclarationClearAnnotations(global.context, this.peer) + return this + } + /** @deprecated */ + dumpAnnotations(dumper?: SrcDumper): this { + global.generatedEs2panda._FunctionDeclarationDumpAnnotationsConst(global.context, this.peer, passNode(dumper)) + return this + } + get annotationsForUpdate(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._FunctionDeclarationAnnotationsForUpdate(global.context, this.peer)) + } + get annotations(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._FunctionDeclarationAnnotations(global.context, this.peer)) + } + /** @deprecated */ + setAnnotations(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._FunctionDeclarationSetAnnotations(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + /** @deprecated */ + setAnnotations1(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._FunctionDeclarationSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + protected readonly brandFunctionDeclaration: undefined +} +export function isFunctionDeclaration(node: object | undefined): node is FunctionDeclaration { + return node instanceof FunctionDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION, (peer: KNativePointer) => new FunctionDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/FunctionExpression.ts b/ets1.2/libarkts/src/generated/peers/FunctionExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..28d50892a226f23aacdc62795048ca1dadc68445 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/FunctionExpression.ts @@ -0,0 +1,75 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Identifier } from "./Identifier" +import { ScriptFunction } from "./ScriptFunction" + +export class FunctionExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create1FunctionExpression(namedExpr?: Identifier, func?: ScriptFunction): FunctionExpression { + const result: FunctionExpression = new FunctionExpression(global.generatedEs2panda._CreateFunctionExpression1(global.context, passNode(namedExpr), passNode(func)), Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateFunctionExpression(original?: FunctionExpression, func?: ScriptFunction): FunctionExpression { + const result: FunctionExpression = new FunctionExpression(global.generatedEs2panda._UpdateFunctionExpression(global.context, passNode(original), passNode(func)), Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static update1FunctionExpression(original?: FunctionExpression, namedExpr?: Identifier, func?: ScriptFunction): FunctionExpression { + const result: FunctionExpression = new FunctionExpression(global.generatedEs2panda._UpdateFunctionExpression1(global.context, passNode(original), passNode(namedExpr), passNode(func)), Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get function(): ScriptFunction | undefined { + return unpackNode(global.generatedEs2panda._FunctionExpressionFunction(global.context, this.peer)) + } + get isAnonymous(): boolean { + return global.generatedEs2panda._FunctionExpressionIsAnonymousConst(global.context, this.peer) + } + get id(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._FunctionExpressionId(global.context, this.peer)) + } + protected readonly brandFunctionExpression: undefined +} +export function isFunctionExpression(node: object | undefined): node is FunctionExpression { + return node instanceof FunctionExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION, (peer: KNativePointer) => new FunctionExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/FunctionSignature.ts b/ets1.2/libarkts/src/generated/peers/FunctionSignature.ts new file mode 100644 index 0000000000000000000000000000000000000000..740fffa833d47553508622eaeb5d75ef8fd2370d --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/FunctionSignature.ts @@ -0,0 +1,70 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Expression } from "./Expression" +import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" +import { TypeNode } from "./TypeNode" + +export class FunctionSignature extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + static createFunctionSignature(typeParams: TSTypeParameterDeclaration | undefined, params: readonly Expression[], returnTypeAnnotation: TypeNode | undefined, hasReceiver: boolean): FunctionSignature { + return new FunctionSignature(global.generatedEs2panda._CreateFunctionSignature(global.context, passNode(typeParams), passNodeArray(params), params.length, passNode(returnTypeAnnotation), hasReceiver)) + } + get params(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._FunctionSignatureParams(global.context, this.peer)) + } + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._FunctionSignatureTypeParams(global.context, this.peer)) + } + get returnType(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._FunctionSignatureReturnType(global.context, this.peer)) + } + /** @deprecated */ + setReturnType(type?: TypeNode): this { + global.generatedEs2panda._FunctionSignatureSetReturnType(global.context, this.peer, passNode(type)) + return this + } + get clone(): FunctionSignature | undefined { + return new FunctionSignature(global.generatedEs2panda._FunctionSignatureClone(global.context, this.peer)) + } + get hasReceiver(): boolean { + return global.generatedEs2panda._FunctionSignatureHasReceiverConst(global.context, this.peer) + } + protected readonly brandFunctionSignature: undefined +} +export function isFunctionSignature(node: object | undefined): node is FunctionSignature { + return node instanceof FunctionSignature +} diff --git a/ets1.2/libarkts/src/generated/peers/IRNode.ts b/ets1.2/libarkts/src/generated/peers/IRNode.ts new file mode 100644 index 0000000000000000000000000000000000000000..7de6aa46aca14bce0c3b8504e8207b4d4c20d005 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/IRNode.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class IRNode extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandIRNode: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/Identifier.ts b/ets1.2/libarkts/src/generated/peers/Identifier.ts new file mode 100644 index 0000000000000000000000000000000000000000..130f284188ff7c72e092187008aae44ff47a969b --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/Identifier.ts @@ -0,0 +1,163 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotatedExpression } from "./AnnotatedExpression" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" +import { ValidationInfo } from "./ValidationInfo" + +export class Identifier extends AnnotatedExpression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create2Identifier(name: string, typeAnnotation?: TypeNode): Identifier { + const result: Identifier = new Identifier(global.generatedEs2panda._CreateIdentifier2(global.context, name, passNode(typeAnnotation)), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER) + result.setChildrenParentPtr() + return result + } + static updateIdentifier(original?: Identifier): Identifier { + const result: Identifier = new Identifier(global.generatedEs2panda._UpdateIdentifier(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER) + result.setChildrenParentPtr() + return result + } + static update1Identifier(original: Identifier | undefined, name: string): Identifier { + const result: Identifier = new Identifier(global.generatedEs2panda._UpdateIdentifier1(global.context, passNode(original), name), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER) + result.setChildrenParentPtr() + return result + } + static update2Identifier(original: Identifier | undefined, name: string, typeAnnotation?: TypeNode): Identifier { + const result: Identifier = new Identifier(global.generatedEs2panda._UpdateIdentifier2(global.context, passNode(original), name, passNode(typeAnnotation)), Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER) + result.setChildrenParentPtr() + return result + } + get name(): string { + return unpackString(global.generatedEs2panda._IdentifierName(global.context, this.peer)) + } + /** @deprecated */ + setName(newName: string): this { + global.generatedEs2panda._IdentifierSetName(global.context, this.peer, newName) + return this + } + get isErrorPlaceHolder(): boolean { + return global.generatedEs2panda._IdentifierIsErrorPlaceHolderConst(global.context, this.peer) + } + get isOptional(): boolean { + return global.generatedEs2panda._IdentifierIsOptionalConst(global.context, this.peer) + } + /** @deprecated */ + setOptional(optional_arg: boolean): this { + global.generatedEs2panda._IdentifierSetOptional(global.context, this.peer, optional_arg) + return this + } + get isReference(): boolean { + return global.generatedEs2panda._IdentifierIsReferenceConst(global.context, this.peer) + } + get isTdz(): boolean { + return global.generatedEs2panda._IdentifierIsTdzConst(global.context, this.peer) + } + /** @deprecated */ + setTdz(): this { + global.generatedEs2panda._IdentifierSetTdz(global.context, this.peer) + return this + } + /** @deprecated */ + setAccessor(): this { + global.generatedEs2panda._IdentifierSetAccessor(global.context, this.peer) + return this + } + get isAccessor(): boolean { + return global.generatedEs2panda._IdentifierIsAccessorConst(global.context, this.peer) + } + /** @deprecated */ + setMutator(): this { + global.generatedEs2panda._IdentifierSetMutator(global.context, this.peer) + return this + } + get isMutator(): boolean { + return global.generatedEs2panda._IdentifierIsMutatorConst(global.context, this.peer) + } + get isReceiver(): boolean { + return global.generatedEs2panda._IdentifierIsReceiverConst(global.context, this.peer) + } + get isPrivateIdent(): boolean { + return global.generatedEs2panda._IdentifierIsPrivateIdentConst(global.context, this.peer) + } + /** @deprecated */ + setPrivate(isPrivate: boolean): this { + global.generatedEs2panda._IdentifierSetPrivate(global.context, this.peer, isPrivate) + return this + } + get isIgnoreBox(): boolean { + return global.generatedEs2panda._IdentifierIsIgnoreBoxConst(global.context, this.peer) + } + /** @deprecated */ + setIgnoreBox(): this { + global.generatedEs2panda._IdentifierSetIgnoreBox(global.context, this.peer) + return this + } + get isAnnotationDecl(): boolean { + return global.generatedEs2panda._IdentifierIsAnnotationDeclConst(global.context, this.peer) + } + /** @deprecated */ + setAnnotationDecl(): this { + global.generatedEs2panda._IdentifierSetAnnotationDecl(global.context, this.peer) + return this + } + get isAnnotationUsage(): boolean { + return global.generatedEs2panda._IdentifierIsAnnotationUsageConst(global.context, this.peer) + } + /** @deprecated */ + setAnnotationUsage(): this { + global.generatedEs2panda._IdentifierSetAnnotationUsage(global.context, this.peer) + return this + } + get validateExpression(): ValidationInfo | undefined { + return new ValidationInfo(global.generatedEs2panda._IdentifierValidateExpression(global.context, this.peer)) + } + get typeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._IdentifierTypeAnnotationConst(global.context, this.peer)) + } + /** @deprecated */ + setTsTypeAnnotation(typeAnnotation?: TypeNode): this { + global.generatedEs2panda._IdentifierSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation)) + return this + } + protected readonly brandIdentifier: undefined +} +export function isIdentifier(node: object | undefined): node is Identifier { + return node instanceof Identifier +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER, (peer: KNativePointer) => new Identifier(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER)) +} diff --git a/ets1.2/libarkts/src/generated/peers/IfStatement.ts b/ets1.2/libarkts/src/generated/peers/IfStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..3fb9854a539409ff9acc472a179aaba98f1ed50d --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/IfStatement.ts @@ -0,0 +1,79 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Statement } from "./Statement" + +export class IfStatement extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createIfStatement(test?: Expression, consequent?: Statement, alternate?: Statement): IfStatement { + const result: IfStatement = new IfStatement(global.generatedEs2panda._CreateIfStatement(global.context, passNode(test), passNode(consequent), passNode(alternate)), Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateIfStatement(original?: IfStatement, test?: Expression, consequent?: Statement, alternate?: Statement): IfStatement { + const result: IfStatement = new IfStatement(global.generatedEs2panda._UpdateIfStatement(global.context, passNode(original), passNode(test), passNode(consequent), passNode(alternate)), Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT) + result.setChildrenParentPtr() + return result + } + get test(): Expression | undefined { + return unpackNode(global.generatedEs2panda._IfStatementTest(global.context, this.peer)) + } + /** @deprecated */ + setTest(test?: Expression): this { + global.generatedEs2panda._IfStatementSetTest(global.context, this.peer, passNode(test)) + return this + } + get consequent(): Statement | undefined { + return unpackNode(global.generatedEs2panda._IfStatementConsequent(global.context, this.peer)) + } + get alternate(): Statement | undefined { + return unpackNode(global.generatedEs2panda._IfStatementAlternate(global.context, this.peer)) + } + /** @deprecated */ + setAlternate(alternate?: Statement): this { + global.generatedEs2panda._IfStatementSetAlternate(global.context, this.peer, passNode(alternate)) + return this + } + protected readonly brandIfStatement: undefined +} +export function isIfStatement(node: object | undefined): node is IfStatement { + return node instanceof IfStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT, (peer: KNativePointer) => new IfStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ImportDeclaration.ts b/ets1.2/libarkts/src/generated/peers/ImportDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..51d6943edb3251667afa744cb23608b840c261c8 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ImportDeclaration.ts @@ -0,0 +1,88 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaImportKinds } from "./../Es2pandaEnums" +import { Statement } from "./Statement" +import { StringLiteral } from "./StringLiteral" + +export class ImportDeclaration extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createImportDeclaration(source: StringLiteral | undefined, specifiers: readonly AstNode[], importKinds: Es2pandaImportKinds): ImportDeclaration { + const result: ImportDeclaration = new ImportDeclaration(global.generatedEs2panda._CreateImportDeclaration(global.context, passNode(source), passNodeArray(specifiers), specifiers.length, importKinds), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION) + result.setChildrenParentPtr() + return result + } + static updateImportDeclaration(original: ImportDeclaration | undefined, source: StringLiteral | undefined, specifiers: readonly AstNode[], importKinds: Es2pandaImportKinds): ImportDeclaration { + const result: ImportDeclaration = new ImportDeclaration(global.generatedEs2panda._UpdateImportDeclaration(global.context, passNode(original), passNode(source), passNodeArray(specifiers), specifiers.length, importKinds), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION) + result.setChildrenParentPtr() + return result + } + /** @deprecated */ + emplaceSpecifiers(source?: AstNode): this { + global.generatedEs2panda._ImportDeclarationEmplaceSpecifiers(global.context, this.peer, passNode(source)) + return this + } + /** @deprecated */ + clearSpecifiers(): this { + global.generatedEs2panda._ImportDeclarationClearSpecifiers(global.context, this.peer) + return this + } + /** @deprecated */ + setValueSpecifiers(source: AstNode | undefined, index: number): this { + global.generatedEs2panda._ImportDeclarationSetValueSpecifiers(global.context, this.peer, passNode(source), index) + return this + } + get specifiersForUpdate(): readonly AstNode[] { + return unpackNodeArray(global.generatedEs2panda._ImportDeclarationSpecifiersForUpdate(global.context, this.peer)) + } + get source(): StringLiteral | undefined { + return unpackNode(global.generatedEs2panda._ImportDeclarationSource(global.context, this.peer)) + } + get specifiers(): readonly AstNode[] { + return unpackNodeArray(global.generatedEs2panda._ImportDeclarationSpecifiersConst(global.context, this.peer)) + } + get isTypeKind(): boolean { + return global.generatedEs2panda._ImportDeclarationIsTypeKindConst(global.context, this.peer) + } + protected readonly brandImportDeclaration: undefined +} +export function isImportDeclaration(node: object | undefined): node is ImportDeclaration { + return node instanceof ImportDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION, (peer: KNativePointer) => new ImportDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ImportDefaultSpecifier.ts b/ets1.2/libarkts/src/generated/peers/ImportDefaultSpecifier.ts new file mode 100644 index 0000000000000000000000000000000000000000..85ea5be32136e2beffd766c2ae2b356df55d79c8 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ImportDefaultSpecifier.ts @@ -0,0 +1,63 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Identifier } from "./Identifier" +import { Statement } from "./Statement" + +export class ImportDefaultSpecifier extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createImportDefaultSpecifier(local?: Identifier): ImportDefaultSpecifier { + const result: ImportDefaultSpecifier = new ImportDefaultSpecifier(global.generatedEs2panda._CreateImportDefaultSpecifier(global.context, passNode(local)), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DEFAULT_SPECIFIER) + result.setChildrenParentPtr() + return result + } + static updateImportDefaultSpecifier(original?: ImportDefaultSpecifier, local?: Identifier): ImportDefaultSpecifier { + const result: ImportDefaultSpecifier = new ImportDefaultSpecifier(global.generatedEs2panda._UpdateImportDefaultSpecifier(global.context, passNode(original), passNode(local)), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DEFAULT_SPECIFIER) + result.setChildrenParentPtr() + return result + } + get local(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ImportDefaultSpecifierLocal(global.context, this.peer)) + } + protected readonly brandImportDefaultSpecifier: undefined +} +export function isImportDefaultSpecifier(node: object | undefined): node is ImportDefaultSpecifier { + return node instanceof ImportDefaultSpecifier +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DEFAULT_SPECIFIER)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DEFAULT_SPECIFIER, (peer: KNativePointer) => new ImportDefaultSpecifier(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DEFAULT_SPECIFIER)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ImportExpression.ts b/ets1.2/libarkts/src/generated/peers/ImportExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..e10ea108baeb43ee56d9923340e34f24daa6a50b --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ImportExpression.ts @@ -0,0 +1,62 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class ImportExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createImportExpression(source?: Expression): ImportExpression { + const result: ImportExpression = new ImportExpression(global.generatedEs2panda._CreateImportExpression(global.context, passNode(source)), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateImportExpression(original?: ImportExpression, source?: Expression): ImportExpression { + const result: ImportExpression = new ImportExpression(global.generatedEs2panda._UpdateImportExpression(global.context, passNode(original), passNode(source)), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get source(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ImportExpressionSource(global.context, this.peer)) + } + protected readonly brandImportExpression: undefined +} +export function isImportExpression(node: object | undefined): node is ImportExpression { + return node instanceof ImportExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_EXPRESSION, (peer: KNativePointer) => new ImportExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts b/ets1.2/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts new file mode 100644 index 0000000000000000000000000000000000000000..72f6f5da23f161cbd354947ce2dd93f767fefe09 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ImportNamespaceSpecifier.ts @@ -0,0 +1,63 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Identifier } from "./Identifier" +import { Statement } from "./Statement" + +export class ImportNamespaceSpecifier extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createImportNamespaceSpecifier(local?: Identifier): ImportNamespaceSpecifier { + const result: ImportNamespaceSpecifier = new ImportNamespaceSpecifier(global.generatedEs2panda._CreateImportNamespaceSpecifier(global.context, passNode(local)), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_NAMESPACE_SPECIFIER) + result.setChildrenParentPtr() + return result + } + static updateImportNamespaceSpecifier(original?: ImportNamespaceSpecifier, local?: Identifier): ImportNamespaceSpecifier { + const result: ImportNamespaceSpecifier = new ImportNamespaceSpecifier(global.generatedEs2panda._UpdateImportNamespaceSpecifier(global.context, passNode(original), passNode(local)), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_NAMESPACE_SPECIFIER) + result.setChildrenParentPtr() + return result + } + get local(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ImportNamespaceSpecifierLocal(global.context, this.peer)) + } + protected readonly brandImportNamespaceSpecifier: undefined +} +export function isImportNamespaceSpecifier(node: object | undefined): node is ImportNamespaceSpecifier { + return node instanceof ImportNamespaceSpecifier +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_NAMESPACE_SPECIFIER)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_NAMESPACE_SPECIFIER, (peer: KNativePointer) => new ImportNamespaceSpecifier(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_NAMESPACE_SPECIFIER)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ImportSource.ts b/ets1.2/libarkts/src/generated/peers/ImportSource.ts new file mode 100644 index 0000000000000000000000000000000000000000..f3a7c1dfb643712c436e42cbf8e3f3870adba289 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ImportSource.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class ImportSource extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandImportSource: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/ImportSpecifier.ts b/ets1.2/libarkts/src/generated/peers/ImportSpecifier.ts new file mode 100644 index 0000000000000000000000000000000000000000..2d7dd40b0344d264b96bc04413ba4492756d5273 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ImportSpecifier.ts @@ -0,0 +1,74 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Identifier } from "./Identifier" +import { Statement } from "./Statement" + +export class ImportSpecifier extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createImportSpecifier(imported?: Identifier, local?: Identifier): ImportSpecifier { + const result: ImportSpecifier = new ImportSpecifier(global.generatedEs2panda._CreateImportSpecifier(global.context, passNode(imported), passNode(local)), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER) + result.setChildrenParentPtr() + return result + } + static updateImportSpecifier(original?: ImportSpecifier, imported?: Identifier, local?: Identifier): ImportSpecifier { + const result: ImportSpecifier = new ImportSpecifier(global.generatedEs2panda._UpdateImportSpecifier(global.context, passNode(original), passNode(imported), passNode(local)), Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER) + result.setChildrenParentPtr() + return result + } + get imported(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ImportSpecifierImported(global.context, this.peer)) + } + get local(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ImportSpecifierLocal(global.context, this.peer)) + } + get isRemovable(): boolean { + return global.generatedEs2panda._ImportSpecifierIsRemovableConst(global.context, this.peer) + } + /** @deprecated */ + setRemovable(isRemovable: boolean): this { + global.generatedEs2panda._ImportSpecifierSetRemovable(global.context, this.peer, isRemovable) + return this + } + protected readonly brandImportSpecifier: undefined +} +export function isImportSpecifier(node: object | undefined): node is ImportSpecifier { + return node instanceof ImportSpecifier +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER, (peer: KNativePointer) => new ImportSpecifier(peer, Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER)) +} diff --git a/ets1.2/libarkts/src/generated/peers/IndexInfo.ts b/ets1.2/libarkts/src/generated/peers/IndexInfo.ts new file mode 100644 index 0000000000000000000000000000000000000000..82407f68952cfdb7fda3ea57e1f4bab217552e16 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/IndexInfo.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class IndexInfo extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandIndexInfo: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/LabelPair.ts b/ets1.2/libarkts/src/generated/peers/LabelPair.ts new file mode 100644 index 0000000000000000000000000000000000000000..4b472593c8fe9535f3ad947122bbea53ff075482 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/LabelPair.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class LabelPair extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandLabelPair: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/LabelledStatement.ts b/ets1.2/libarkts/src/generated/peers/LabelledStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..c5c441d3f099fd8a7fd4e9fbe4d84ee9793a2070 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/LabelledStatement.ts @@ -0,0 +1,69 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Identifier } from "./Identifier" +import { Statement } from "./Statement" + +export class LabelledStatement extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createLabelledStatement(ident?: Identifier, body?: Statement): LabelledStatement { + const result: LabelledStatement = new LabelledStatement(global.generatedEs2panda._CreateLabelledStatement(global.context, passNode(ident), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_LABELLED_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateLabelledStatement(original?: LabelledStatement, ident?: Identifier, body?: Statement): LabelledStatement { + const result: LabelledStatement = new LabelledStatement(global.generatedEs2panda._UpdateLabelledStatement(global.context, passNode(original), passNode(ident), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_LABELLED_STATEMENT) + result.setChildrenParentPtr() + return result + } + get body(): Statement | undefined { + return unpackNode(global.generatedEs2panda._LabelledStatementBody(global.context, this.peer)) + } + get ident(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._LabelledStatementIdent(global.context, this.peer)) + } + get referencedStatement(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._LabelledStatementGetReferencedStatementConst(global.context, this.peer)) + } + protected readonly brandLabelledStatement: undefined +} +export function isLabelledStatement(node: object | undefined): node is LabelledStatement { + return node instanceof LabelledStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_LABELLED_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_LABELLED_STATEMENT, (peer: KNativePointer) => new LabelledStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_LABELLED_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/Literal.ts b/ets1.2/libarkts/src/generated/peers/Literal.ts new file mode 100644 index 0000000000000000000000000000000000000000..c8c20aa35886e6756fa999504bb8d32716675286 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/Literal.ts @@ -0,0 +1,54 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class Literal extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + get isFolded(): boolean { + return global.generatedEs2panda._LiteralIsFoldedConst(global.context, this.peer) + } + /** @deprecated */ + setFolded(folded: boolean): this { + global.generatedEs2panda._LiteralSetFolded(global.context, this.peer, folded) + return this + } + protected readonly brandLiteral: undefined +} +export function isLiteral(node: object | undefined): node is Literal { + return node instanceof Literal +} diff --git a/ets1.2/libarkts/src/generated/peers/LoopStatement.ts b/ets1.2/libarkts/src/generated/peers/LoopStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..d02bc72d9fb85687f2361b0f660df1dbd93487b4 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/LoopStatement.ts @@ -0,0 +1,46 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Statement } from "./Statement" + +export class LoopStatement extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + protected readonly brandLoopStatement: undefined +} +export function isLoopStatement(node: object | undefined): node is LoopStatement { + return node instanceof LoopStatement +} diff --git a/ets1.2/libarkts/src/generated/peers/MaybeOptionalExpression.ts b/ets1.2/libarkts/src/generated/peers/MaybeOptionalExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..bdfeee561443d848d6fd8ba4a60d5eeb899b32c4 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/MaybeOptionalExpression.ts @@ -0,0 +1,54 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class MaybeOptionalExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + get isOptional(): boolean { + return global.generatedEs2panda._MaybeOptionalExpressionIsOptionalConst(global.context, this.peer) + } + /** @deprecated */ + clearOptional(): this { + global.generatedEs2panda._MaybeOptionalExpressionClearOptional(global.context, this.peer) + return this + } + protected readonly brandMaybeOptionalExpression: undefined +} +export function isMaybeOptionalExpression(node: object | undefined): node is MaybeOptionalExpression { + return node instanceof MaybeOptionalExpression +} diff --git a/ets1.2/libarkts/src/generated/peers/MemberExpression.ts b/ets1.2/libarkts/src/generated/peers/MemberExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..941c2302795274734a6a474c9c2b35bd6372fda3 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/MemberExpression.ts @@ -0,0 +1,116 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { CodeGen } from "./CodeGen" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaMemberExpressionKind } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { MaybeOptionalExpression } from "./MaybeOptionalExpression" +import { VReg } from "./VReg" + +export class MemberExpression extends MaybeOptionalExpression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createMemberExpression(object_arg: Expression | undefined, property: Expression | undefined, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression { + const result: MemberExpression = new MemberExpression(global.generatedEs2panda._CreateMemberExpression(global.context, passNode(object_arg), passNode(property), kind, computed, optional_arg), Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateMemberExpression(original: MemberExpression | undefined, object_arg: Expression | undefined, property: Expression | undefined, kind: Es2pandaMemberExpressionKind, computed: boolean, optional_arg: boolean): MemberExpression { + const result: MemberExpression = new MemberExpression(global.generatedEs2panda._UpdateMemberExpression(global.context, passNode(original), passNode(object_arg), passNode(property), kind, computed, optional_arg), Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get object(): Expression | undefined { + return unpackNode(global.generatedEs2panda._MemberExpressionObject(global.context, this.peer)) + } + /** @deprecated */ + setObject(object_arg?: Expression): this { + global.generatedEs2panda._MemberExpressionSetObject(global.context, this.peer, passNode(object_arg)) + return this + } + /** @deprecated */ + setProperty(prop?: Expression): this { + global.generatedEs2panda._MemberExpressionSetProperty(global.context, this.peer, passNode(prop)) + return this + } + get property(): Expression | undefined { + return unpackNode(global.generatedEs2panda._MemberExpressionProperty(global.context, this.peer)) + } + get isComputed(): boolean { + return global.generatedEs2panda._MemberExpressionIsComputedConst(global.context, this.peer) + } + get kind(): Es2pandaMemberExpressionKind { + return global.generatedEs2panda._MemberExpressionKindConst(global.context, this.peer) + } + /** @deprecated */ + addMemberKind(kind: Es2pandaMemberExpressionKind): this { + global.generatedEs2panda._MemberExpressionAddMemberKind(global.context, this.peer, kind) + return this + } + /** @deprecated */ + removeMemberKind(kind: Es2pandaMemberExpressionKind): this { + global.generatedEs2panda._MemberExpressionRemoveMemberKind(global.context, this.peer, kind) + return this + } + get isIgnoreBox(): boolean { + return global.generatedEs2panda._MemberExpressionIsIgnoreBoxConst(global.context, this.peer) + } + /** @deprecated */ + setIgnoreBox(): this { + global.generatedEs2panda._MemberExpressionSetIgnoreBox(global.context, this.peer) + return this + } + get isPrivateReference(): boolean { + return global.generatedEs2panda._MemberExpressionIsPrivateReferenceConst(global.context, this.peer) + } + /** @deprecated */ + compileToReg(pg?: CodeGen, objReg?: VReg): this { + global.generatedEs2panda._MemberExpressionCompileToRegConst(global.context, this.peer, passNode(pg), passNode(objReg)) + return this + } + /** @deprecated */ + compileToRegs(pg?: CodeGen, object_arg?: VReg, property?: VReg): this { + global.generatedEs2panda._MemberExpressionCompileToRegsConst(global.context, this.peer, passNode(pg), passNode(object_arg), passNode(property)) + return this + } + protected readonly brandMemberExpression: undefined +} +export function isMemberExpression(node: object | undefined): node is MemberExpression { + return node instanceof MemberExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION, (peer: KNativePointer) => new MemberExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/MetaProperty.ts b/ets1.2/libarkts/src/generated/peers/MetaProperty.ts new file mode 100644 index 0000000000000000000000000000000000000000..7c6797f0a8b9ed3764cdf6949d2e2e51fdf2256d --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/MetaProperty.ts @@ -0,0 +1,63 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaMetaPropertyKind } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class MetaProperty extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createMetaProperty(kind: Es2pandaMetaPropertyKind): MetaProperty { + const result: MetaProperty = new MetaProperty(global.generatedEs2panda._CreateMetaProperty(global.context, kind), Es2pandaAstNodeType.AST_NODE_TYPE_META_PROPERTY_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateMetaProperty(original: MetaProperty | undefined, kind: Es2pandaMetaPropertyKind): MetaProperty { + const result: MetaProperty = new MetaProperty(global.generatedEs2panda._UpdateMetaProperty(global.context, passNode(original), kind), Es2pandaAstNodeType.AST_NODE_TYPE_META_PROPERTY_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get kind(): Es2pandaMetaPropertyKind { + return global.generatedEs2panda._MetaPropertyKindConst(global.context, this.peer) + } + protected readonly brandMetaProperty: undefined +} +export function isMetaProperty(node: object | undefined): node is MetaProperty { + return node instanceof MetaProperty +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_META_PROPERTY_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_META_PROPERTY_EXPRESSION, (peer: KNativePointer) => new MetaProperty(peer, Es2pandaAstNodeType.AST_NODE_TYPE_META_PROPERTY_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/MethodDefinition.ts b/ets1.2/libarkts/src/generated/peers/MethodDefinition.ts new file mode 100644 index 0000000000000000000000000000000000000000..b85eca1c6fd1a1be952a65fe72f090abe925d22f --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/MethodDefinition.ts @@ -0,0 +1,153 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { ClassElement } from "./ClassElement" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaMethodDefinitionKind } from "./../Es2pandaEnums" +import { Es2pandaModifierFlags } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { ScriptFunction } from "./ScriptFunction" +import { extension_MethodDefinitionOnUpdate } from "./../../reexport-for-generated" +import { extension_MethodDefinitionSetChildrenParentPtr } from "./../../reexport-for-generated" + +export class MethodDefinition extends ClassElement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createMethodDefinition(kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean, overloads?: readonly MethodDefinition[]): MethodDefinition { + const result: MethodDefinition = new MethodDefinition(global.generatedEs2panda._CreateMethodDefinition(global.context, kind, passNode(key), passNode(value), modifiers, isComputed), Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION) + if (overloads) + { + result.setOverloads(overloads) + } + result.setChildrenParentPtr() + return result + } + static updateMethodDefinition(original: MethodDefinition | undefined, kind: Es2pandaMethodDefinitionKind, key: Expression | undefined, value: Expression | undefined, modifiers: Es2pandaModifierFlags, isComputed: boolean, overloads?: readonly MethodDefinition[]): MethodDefinition { + const result: MethodDefinition = new MethodDefinition(global.generatedEs2panda._UpdateMethodDefinition(global.context, passNode(original), kind, passNode(key), passNode(value), modifiers, isComputed), Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION) + if (overloads) + { + result.setOverloads(overloads) + } + result.setChildrenParentPtr() + return result + } + get kind(): Es2pandaMethodDefinitionKind { + return global.generatedEs2panda._MethodDefinitionKindConst(global.context, this.peer) + } + get isConstructor(): boolean { + return global.generatedEs2panda._MethodDefinitionIsConstructorConst(global.context, this.peer) + } + get isMethod(): boolean { + return global.generatedEs2panda._MethodDefinitionIsMethodConst(global.context, this.peer) + } + get isExtensionMethod(): boolean { + return global.generatedEs2panda._MethodDefinitionIsExtensionMethodConst(global.context, this.peer) + } + get isGetter(): boolean { + return global.generatedEs2panda._MethodDefinitionIsGetterConst(global.context, this.peer) + } + get isSetter(): boolean { + return global.generatedEs2panda._MethodDefinitionIsSetterConst(global.context, this.peer) + } + get isDefaultAccessModifier(): boolean { + return global.generatedEs2panda._MethodDefinitionIsDefaultAccessModifierConst(global.context, this.peer) + } + /** @deprecated */ + setDefaultAccessModifier(isDefault: boolean): this { + global.generatedEs2panda._MethodDefinitionSetDefaultAccessModifier(global.context, this.peer, isDefault) + return this + } + get overloads(): readonly MethodDefinition[] { + return unpackNodeArray(global.generatedEs2panda._MethodDefinitionOverloadsConst(global.context, this.peer)) + } + get baseOverloadMethod(): MethodDefinition | undefined { + return unpackNode(global.generatedEs2panda._MethodDefinitionBaseOverloadMethod(global.context, this.peer)) + } + get asyncPairMethod(): MethodDefinition | undefined { + return unpackNode(global.generatedEs2panda._MethodDefinitionAsyncPairMethod(global.context, this.peer)) + } + /** @deprecated */ + setOverloads(overloads: readonly MethodDefinition[]): this { + global.generatedEs2panda._MethodDefinitionSetOverloads(global.context, this.peer, passNodeArray(overloads), overloads.length) + return this + } + /** @deprecated */ + addOverload(overload?: MethodDefinition): this { + global.generatedEs2panda._MethodDefinitionAddOverload(global.context, this.peer, passNode(overload)) + return this + } + /** @deprecated */ + setBaseOverloadMethod(baseOverloadMethod?: MethodDefinition): this { + global.generatedEs2panda._MethodDefinitionSetBaseOverloadMethod(global.context, this.peer, passNode(baseOverloadMethod)) + return this + } + /** @deprecated */ + setAsyncPairMethod(asyncPairMethod?: MethodDefinition): this { + global.generatedEs2panda._MethodDefinitionSetAsyncPairMethod(global.context, this.peer, passNode(asyncPairMethod)) + return this + } + get function(): ScriptFunction | undefined { + return unpackNode(global.generatedEs2panda._MethodDefinitionFunction(global.context, this.peer)) + } + /** @deprecated */ + initializeOverloadInfo(): this { + global.generatedEs2panda._MethodDefinitionInitializeOverloadInfo(global.context, this.peer) + return this + } + /** @deprecated */ + emplaceOverloads(overloads?: MethodDefinition): this { + global.generatedEs2panda._MethodDefinitionEmplaceOverloads(global.context, this.peer, passNode(overloads)) + return this + } + /** @deprecated */ + clearOverloads(): this { + global.generatedEs2panda._MethodDefinitionClearOverloads(global.context, this.peer) + return this + } + /** @deprecated */ + setValueOverloads(overloads: MethodDefinition | undefined, index: number): this { + global.generatedEs2panda._MethodDefinitionSetValueOverloads(global.context, this.peer, passNode(overloads), index) + return this + } + setChildrenParentPtr = extension_MethodDefinitionSetChildrenParentPtr + onUpdate = extension_MethodDefinitionOnUpdate + protected readonly brandMethodDefinition: undefined +} +export function isMethodDefinition(node: object | undefined): node is MethodDefinition { + return node instanceof MethodDefinition +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION, (peer: KNativePointer) => new MethodDefinition(peer, Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/NamedType.ts b/ets1.2/libarkts/src/generated/peers/NamedType.ts new file mode 100644 index 0000000000000000000000000000000000000000..95ca0809a9d83e86a1d08b39430fe54a4ac0810d --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/NamedType.ts @@ -0,0 +1,85 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Identifier } from "./Identifier" +import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" +import { TypeNode } from "./TypeNode" + +export class NamedType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createNamedType(name?: Identifier): NamedType { + const result: NamedType = new NamedType(global.generatedEs2panda._CreateNamedType(global.context, passNode(name)), Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE) + result.setChildrenParentPtr() + return result + } + static updateNamedType(original?: NamedType, name?: Identifier): NamedType { + const result: NamedType = new NamedType(global.generatedEs2panda._UpdateNamedType(global.context, passNode(original), passNode(name)), Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE) + result.setChildrenParentPtr() + return result + } + get name(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._NamedTypeNameConst(global.context, this.peer)) + } + get typeParams(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._NamedTypeTypeParamsConst(global.context, this.peer)) + } + get isNullable(): boolean { + return global.generatedEs2panda._NamedTypeIsNullableConst(global.context, this.peer) + } + /** @deprecated */ + setNullable(nullable: boolean): this { + global.generatedEs2panda._NamedTypeSetNullable(global.context, this.peer, nullable) + return this + } + /** @deprecated */ + setNext(next?: NamedType): this { + global.generatedEs2panda._NamedTypeSetNext(global.context, this.peer, passNode(next)) + return this + } + /** @deprecated */ + setTypeParams(typeParams?: TSTypeParameterInstantiation): this { + global.generatedEs2panda._NamedTypeSetTypeParams(global.context, this.peer, passNode(typeParams)) + return this + } + protected readonly brandNamedType: undefined +} +export function isNamedType(node: object | undefined): node is NamedType { + return node instanceof NamedType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE, (peer: KNativePointer) => new NamedType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/NewExpression.ts b/ets1.2/libarkts/src/generated/peers/NewExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..b7a47fcfd38b0f5324d821d2e393b07606a0b125 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/NewExpression.ts @@ -0,0 +1,65 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class NewExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createNewExpression(callee: Expression | undefined, _arguments: readonly Expression[]): NewExpression { + const result: NewExpression = new NewExpression(global.generatedEs2panda._CreateNewExpression(global.context, passNode(callee), passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateNewExpression(original: NewExpression | undefined, callee: Expression | undefined, _arguments: readonly Expression[]): NewExpression { + const result: NewExpression = new NewExpression(global.generatedEs2panda._UpdateNewExpression(global.context, passNode(original), passNode(callee), passNodeArray(_arguments), _arguments.length), Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get callee(): Expression | undefined { + return unpackNode(global.generatedEs2panda._NewExpressionCalleeConst(global.context, this.peer)) + } + get arguments(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._NewExpressionArgumentsConst(global.context, this.peer)) + } + protected readonly brandNewExpression: undefined +} +export function isNewExpression(node: object | undefined): node is NewExpression { + return node instanceof NewExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION, (peer: KNativePointer) => new NewExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/NullLiteral.ts b/ets1.2/libarkts/src/generated/peers/NullLiteral.ts new file mode 100644 index 0000000000000000000000000000000000000000..b6faa23156ef6a2123abf4df6d3486f6000f0413 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/NullLiteral.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Literal } from "./Literal" + +export class NullLiteral extends Literal { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createNullLiteral(): NullLiteral { + const result: NullLiteral = new NullLiteral(global.generatedEs2panda._CreateNullLiteral(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL) + result.setChildrenParentPtr() + return result + } + static updateNullLiteral(original?: NullLiteral): NullLiteral { + const result: NullLiteral = new NullLiteral(global.generatedEs2panda._UpdateNullLiteral(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL) + result.setChildrenParentPtr() + return result + } + protected readonly brandNullLiteral: undefined +} +export function isNullLiteral(node: object | undefined): node is NullLiteral { + return node instanceof NullLiteral +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL, (peer: KNativePointer) => new NullLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL)) +} diff --git a/ets1.2/libarkts/src/generated/peers/NumberLiteral.ts b/ets1.2/libarkts/src/generated/peers/NumberLiteral.ts new file mode 100644 index 0000000000000000000000000000000000000000..ef5c9b4e042cb4ac5e50a019c7fa2f9b8fa43dbb --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/NumberLiteral.ts @@ -0,0 +1,79 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Literal } from "./Literal" +import { extension_NumberLiteralValue } from "./../../reexport-for-generated" + +export class NumberLiteral extends Literal { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createNumberLiteral(value: number): AstNode { + const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._CreateNumberLiteral(global.context, value), Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL) + result.setChildrenParentPtr() + return result + } + static updateNumberLiteral(original: AstNode | undefined, value: number): AstNode { + const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral(global.context, passNode(original), value), Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL) + result.setChildrenParentPtr() + return result + } + static update1NumberLiteral(original: AstNode | undefined, value: number): AstNode { + const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral1(global.context, passNode(original), value), Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL) + result.setChildrenParentPtr() + return result + } + static update2NumberLiteral(original: AstNode | undefined, value: number): AstNode { + const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral2(global.context, passNode(original), value), Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL) + result.setChildrenParentPtr() + return result + } + static update3NumberLiteral(original: AstNode | undefined, value: number): AstNode { + const result: NumberLiteral = new NumberLiteral(global.generatedEs2panda._UpdateNumberLiteral3(global.context, passNode(original), value), Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL) + result.setChildrenParentPtr() + return result + } + get str(): string { + return unpackString(global.generatedEs2panda._NumberLiteralStrConst(global.context, this.peer)) + } + value = extension_NumberLiteralValue + protected readonly brandNumberLiteral: undefined +} +export function isNumberLiteral(node: object | undefined): node is NumberLiteral { + return node instanceof NumberLiteral +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, (peer: KNativePointer) => new NumberLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ObjectDescriptor.ts b/ets1.2/libarkts/src/generated/peers/ObjectDescriptor.ts new file mode 100644 index 0000000000000000000000000000000000000000..f5425a8be6e525ad345a835ec2ef3df5513e486f --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ObjectDescriptor.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class ObjectDescriptor extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandObjectDescriptor: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/ObjectExpression.ts b/ets1.2/libarkts/src/generated/peers/ObjectExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..ab02e2cb2f953a4ec0cc3f0261e41203a976b853 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ObjectExpression.ts @@ -0,0 +1,95 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotatedExpression } from "./AnnotatedExpression" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" +import { ValidationInfo } from "./ValidationInfo" + +export class ObjectExpression extends AnnotatedExpression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createObjectExpression(nodeType: Es2pandaAstNodeType, properties: readonly Expression[], trailingComma: boolean): ObjectExpression { + const result: ObjectExpression = new ObjectExpression(global.generatedEs2panda._CreateObjectExpression(global.context, nodeType, passNodeArray(properties), properties.length, trailingComma), Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateObjectExpression(original: ObjectExpression | undefined, nodeType: Es2pandaAstNodeType, properties: readonly Expression[], trailingComma: boolean): ObjectExpression { + const result: ObjectExpression = new ObjectExpression(global.generatedEs2panda._UpdateObjectExpression(global.context, passNode(original), nodeType, passNodeArray(properties), properties.length, trailingComma), Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get properties(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._ObjectExpressionPropertiesConst(global.context, this.peer)) + } + get isDeclaration(): boolean { + return global.generatedEs2panda._ObjectExpressionIsDeclarationConst(global.context, this.peer) + } + get isOptional(): boolean { + return global.generatedEs2panda._ObjectExpressionIsOptionalConst(global.context, this.peer) + } + get validateExpression(): ValidationInfo | undefined { + return new ValidationInfo(global.generatedEs2panda._ObjectExpressionValidateExpression(global.context, this.peer)) + } + get convertibleToObjectPattern(): boolean { + return global.generatedEs2panda._ObjectExpressionConvertibleToObjectPattern(global.context, this.peer) + } + /** @deprecated */ + setDeclaration(): this { + global.generatedEs2panda._ObjectExpressionSetDeclaration(global.context, this.peer) + return this + } + /** @deprecated */ + setOptional(optional_arg: boolean): this { + global.generatedEs2panda._ObjectExpressionSetOptional(global.context, this.peer, optional_arg) + return this + } + get typeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ObjectExpressionTypeAnnotationConst(global.context, this.peer)) + } + /** @deprecated */ + setTsTypeAnnotation(typeAnnotation?: TypeNode): this { + global.generatedEs2panda._ObjectExpressionSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation)) + return this + } + protected readonly brandObjectExpression: undefined +} +export function isObjectExpression(node: object | undefined): node is ObjectExpression { + return node instanceof ObjectExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION, (peer: KNativePointer) => new ObjectExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_OBJECT_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/OmittedExpression.ts b/ets1.2/libarkts/src/generated/peers/OmittedExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..efa2bdee981d312edf623587e0e2a4ef968558cb --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/OmittedExpression.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class OmittedExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createOmittedExpression(): OmittedExpression { + const result: OmittedExpression = new OmittedExpression(global.generatedEs2panda._CreateOmittedExpression(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateOmittedExpression(original?: OmittedExpression): OmittedExpression { + const result: OmittedExpression = new OmittedExpression(global.generatedEs2panda._UpdateOmittedExpression(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION) + result.setChildrenParentPtr() + return result + } + protected readonly brandOmittedExpression: undefined +} +export function isOmittedExpression(node: object | undefined): node is OmittedExpression { + return node instanceof OmittedExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION, (peer: KNativePointer) => new OmittedExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/OpaqueTypeNode.ts b/ets1.2/libarkts/src/generated/peers/OpaqueTypeNode.ts new file mode 100644 index 0000000000000000000000000000000000000000..cb697f7ca4fe19ad75400d68bb9702c51ac49e1c --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/OpaqueTypeNode.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class OpaqueTypeNode extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create1OpaqueTypeNode(): OpaqueTypeNode { + const result: OpaqueTypeNode = new OpaqueTypeNode(global.generatedEs2panda._CreateOpaqueTypeNode1(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE) + result.setChildrenParentPtr() + return result + } + static update1OpaqueTypeNode(original?: OpaqueTypeNode): OpaqueTypeNode { + const result: OpaqueTypeNode = new OpaqueTypeNode(global.generatedEs2panda._UpdateOpaqueTypeNode1(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE) + result.setChildrenParentPtr() + return result + } + protected readonly brandOpaqueTypeNode: undefined +} +export function isOpaqueTypeNode(node: object | undefined): node is OpaqueTypeNode { + return node instanceof OpaqueTypeNode +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE, (peer: KNativePointer) => new OpaqueTypeNode(peer, Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/OverloadDeclaration.ts b/ets1.2/libarkts/src/generated/peers/OverloadDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..618c71a764c02c85c119466e468b9a1a438212eb --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/OverloadDeclaration.ts @@ -0,0 +1,102 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { ClassElement } from "./ClassElement" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaModifierFlags } from "./../Es2pandaEnums" +import { Es2pandaOverloadDeclFlags } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Identifier } from "./Identifier" +import { SrcDumper } from "./SrcDumper" + +export class OverloadDeclaration extends ClassElement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createOverloadDeclaration(key: Expression | undefined, modifiers: Es2pandaModifierFlags): OverloadDeclaration { + const result: OverloadDeclaration = new OverloadDeclaration(global.generatedEs2panda._CreateOverloadDeclaration(global.context, passNode(key), modifiers), Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION) + result.setChildrenParentPtr() + return result + } + static updateOverloadDeclaration(original: OverloadDeclaration | undefined, key: Expression | undefined, modifiers: Es2pandaModifierFlags): OverloadDeclaration { + const result: OverloadDeclaration = new OverloadDeclaration(global.generatedEs2panda._UpdateOverloadDeclaration(global.context, passNode(original), passNode(key), modifiers), Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION) + result.setChildrenParentPtr() + return result + } + get flag(): Es2pandaOverloadDeclFlags { + return global.generatedEs2panda._OverloadDeclarationFlagConst(global.context, this.peer) + } + get overloadedList(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._OverloadDeclarationOverloadedList(global.context, this.peer)) + } + /** @deprecated */ + setOverloadedList(overloadedList: readonly Expression[]): this { + global.generatedEs2panda._OverloadDeclarationSetOverloadedList(global.context, this.peer, passNodeArray(overloadedList), overloadedList.length) + return this + } + /** @deprecated */ + pushFront(overloadedExpression?: Identifier): this { + global.generatedEs2panda._OverloadDeclarationPushFront(global.context, this.peer, passNode(overloadedExpression)) + return this + } + /** @deprecated */ + addOverloadDeclFlag(overloadFlag: Es2pandaOverloadDeclFlags): this { + global.generatedEs2panda._OverloadDeclarationAddOverloadDeclFlag(global.context, this.peer, overloadFlag) + return this + } + get isConstructorOverloadDeclaration(): boolean { + return global.generatedEs2panda._OverloadDeclarationIsConstructorOverloadDeclaration(global.context, this.peer) + } + get isFunctionOverloadDeclaration(): boolean { + return global.generatedEs2panda._OverloadDeclarationIsFunctionOverloadDeclaration(global.context, this.peer) + } + get isClassMethodOverloadDeclaration(): boolean { + return global.generatedEs2panda._OverloadDeclarationIsClassMethodOverloadDeclaration(global.context, this.peer) + } + get isInterfaceMethodOverloadDeclaration(): boolean { + return global.generatedEs2panda._OverloadDeclarationIsInterfaceMethodOverloadDeclaration(global.context, this.peer) + } + /** @deprecated */ + dumpModifier(dumper?: SrcDumper): this { + global.generatedEs2panda._OverloadDeclarationDumpModifierConst(global.context, this.peer, passNode(dumper)) + return this + } + protected readonly brandOverloadDeclaration: undefined +} +export function isOverloadDeclaration(node: object | undefined): node is OverloadDeclaration { + return node instanceof OverloadDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION, (peer: KNativePointer) => new OverloadDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_OVERLOAD_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/PrefixAssertionExpression.ts b/ets1.2/libarkts/src/generated/peers/PrefixAssertionExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..f693038b33a5b8e77e761a470104778aa1acc467 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/PrefixAssertionExpression.ts @@ -0,0 +1,66 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" + +export class PrefixAssertionExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createPrefixAssertionExpression(expr?: Expression, type?: TypeNode): PrefixAssertionExpression { + const result: PrefixAssertionExpression = new PrefixAssertionExpression(global.generatedEs2panda._CreatePrefixAssertionExpression(global.context, passNode(expr), passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updatePrefixAssertionExpression(original?: PrefixAssertionExpression, expr?: Expression, type?: TypeNode): PrefixAssertionExpression { + const result: PrefixAssertionExpression = new PrefixAssertionExpression(global.generatedEs2panda._UpdatePrefixAssertionExpression(global.context, passNode(original), passNode(expr), passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get expr(): Expression | undefined { + return unpackNode(global.generatedEs2panda._PrefixAssertionExpressionExprConst(global.context, this.peer)) + } + get type(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._PrefixAssertionExpressionTypeConst(global.context, this.peer)) + } + protected readonly brandPrefixAssertionExpression: undefined +} +export function isPrefixAssertionExpression(node: object | undefined): node is PrefixAssertionExpression { + return node instanceof PrefixAssertionExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION, (peer: KNativePointer) => new PrefixAssertionExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/Program.ts b/ets1.2/libarkts/src/generated/peers/Program.ts new file mode 100644 index 0000000000000000000000000000000000000000..a1d31feb5e84534965961ea87585d80561b71bb7 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/Program.ts @@ -0,0 +1,204 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { BlockStatement } from "./BlockStatement" +import { ClassDefinition } from "./ClassDefinition" +import { Es2pandaModuleKind } from "./../Es2pandaEnums" +import { Es2pandaProgramFlags } from "./../Es2pandaEnums" +import { Es2pandaScriptKind } from "./../Es2pandaEnums" +import { SourcePosition } from "./SourcePosition" +import { extension_ProgramGetExternalSources } from "./../../reexport-for-generated" + +export class Program extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + /** @deprecated */ + setKind(kind: Es2pandaScriptKind): this { + global.generatedEs2panda._ProgramSetKind(global.context, this.peer, kind) + return this + } + /** @deprecated */ + pushVarBinder(): this { + global.generatedEs2panda._ProgramPushVarBinder(global.context, this.peer) + return this + } + /** @deprecated */ + pushChecker(): this { + global.generatedEs2panda._ProgramPushChecker(global.context, this.peer) + return this + } + get kind(): Es2pandaScriptKind { + return global.generatedEs2panda._ProgramKindConst(global.context, this.peer) + } + get sourceCode(): string { + return unpackString(global.generatedEs2panda._ProgramSourceCodeConst(global.context, this.peer)) + } + get sourceFilePath(): string { + return unpackString(global.generatedEs2panda._ProgramSourceFilePathConst(global.context, this.peer)) + } + get sourceFileFolder(): string { + return unpackString(global.generatedEs2panda._ProgramSourceFileFolderConst(global.context, this.peer)) + } + get fileName(): string { + return unpackString(global.generatedEs2panda._ProgramFileNameConst(global.context, this.peer)) + } + get fileNameWithExtension(): string { + return unpackString(global.generatedEs2panda._ProgramFileNameWithExtensionConst(global.context, this.peer)) + } + get absoluteName(): string { + return unpackString(global.generatedEs2panda._ProgramAbsoluteNameConst(global.context, this.peer)) + } + get resolvedFilePath(): string { + return unpackString(global.generatedEs2panda._ProgramResolvedFilePathConst(global.context, this.peer)) + } + get relativeFilePath(): string { + return unpackString(global.generatedEs2panda._ProgramRelativeFilePathConst(global.context, this.peer)) + } + /** @deprecated */ + setRelativeFilePath(relPath: string): this { + global.generatedEs2panda._ProgramSetRelativeFilePath(global.context, this.peer, relPath) + return this + } + get ast(): BlockStatement { + return unpackNonNullableNode(global.generatedEs2panda._ProgramAst(global.context, this.peer)) + } + /** @deprecated */ + setAst(ast?: BlockStatement): this { + global.generatedEs2panda._ProgramSetAst(global.context, this.peer, passNode(ast)) + return this + } + get globalClass(): ClassDefinition | undefined { + return unpackNode(global.generatedEs2panda._ProgramGlobalClass(global.context, this.peer)) + } + /** @deprecated */ + setGlobalClass(globalClass?: ClassDefinition): this { + global.generatedEs2panda._ProgramSetGlobalClass(global.context, this.peer, passNode(globalClass)) + return this + } + get packageStart(): SourcePosition | undefined { + return new SourcePosition(global.generatedEs2panda._ProgramPackageStartConst(global.context, this.peer)) + } + /** @deprecated */ + setPackageStart(start?: SourcePosition): this { + global.generatedEs2panda._ProgramSetPackageStart(global.context, this.peer, passNode(start)) + return this + } + /** @deprecated */ + setSource(sourceCode: string, sourceFilePath: string, sourceFileFolder: string): this { + global.generatedEs2panda._ProgramSetSource(global.context, this.peer, sourceCode, sourceFilePath, sourceFileFolder) + return this + } + /** @deprecated */ + setPackageInfo(name: string, kind: Es2pandaModuleKind): this { + global.generatedEs2panda._ProgramSetPackageInfo(global.context, this.peer, name, kind) + return this + } + get moduleName(): string { + return unpackString(global.generatedEs2panda._ProgramModuleNameConst(global.context, this.peer)) + } + get modulePrefix(): string { + return unpackString(global.generatedEs2panda._ProgramModulePrefixConst(global.context, this.peer)) + } + get isSeparateModule(): boolean { + return global.generatedEs2panda._ProgramIsSeparateModuleConst(global.context, this.peer) + } + get isDeclarationModule(): boolean { + return global.generatedEs2panda._ProgramIsDeclarationModuleConst(global.context, this.peer) + } + get isPackage(): boolean { + return global.generatedEs2panda._ProgramIsPackageConst(global.context, this.peer) + } + get isDeclForDynamicStaticInterop(): boolean { + return global.generatedEs2panda._ProgramIsDeclForDynamicStaticInteropConst(global.context, this.peer) + } + /** @deprecated */ + setFlag(flag: Es2pandaProgramFlags): this { + global.generatedEs2panda._ProgramSetFlag(global.context, this.peer, flag) + return this + } + /** @deprecated */ + setASTChecked(): this { + global.generatedEs2panda._ProgramSetASTChecked(global.context, this.peer) + return this + } + /** @deprecated */ + removeAstChecked(): this { + global.generatedEs2panda._ProgramRemoveAstChecked(global.context, this.peer) + return this + } + get isASTChecked(): boolean { + return global.generatedEs2panda._ProgramIsASTChecked(global.context, this.peer) + } + /** @deprecated */ + markASTAsLowered(): this { + global.generatedEs2panda._ProgramMarkASTAsLowered(global.context, this.peer) + return this + } + get isASTLowered(): boolean { + return global.generatedEs2panda._ProgramIsASTLoweredConst(global.context, this.peer) + } + get isStdLib(): boolean { + return global.generatedEs2panda._ProgramIsStdLibConst(global.context, this.peer) + } + get isGenAbcForExternal(): boolean { + return global.generatedEs2panda._ProgramIsGenAbcForExternalConst(global.context, this.peer) + } + /** @deprecated */ + setGenAbcForExternalSources(genAbc: boolean): this { + global.generatedEs2panda._ProgramSetGenAbcForExternalSources(global.context, this.peer, genAbc) + return this + } + get dump(): string { + return unpackString(global.generatedEs2panda._ProgramDumpConst(global.context, this.peer)) + } + /** @deprecated */ + dumpSilent(): this { + global.generatedEs2panda._ProgramDumpSilentConst(global.context, this.peer) + return this + } + get isDied(): boolean { + return global.generatedEs2panda._ProgramIsDiedConst(global.context, this.peer) + } + /** @deprecated */ + addFileDependencies(file: string, depFile: string): this { + global.generatedEs2panda._ProgramAddFileDependencies(global.context, this.peer, file, depFile) + return this + } + getExternalSources = extension_ProgramGetExternalSources + protected readonly brandProgram: undefined +} +export function isProgram(node: object | undefined): node is Program { + return node instanceof Program +} diff --git a/ets1.2/libarkts/src/generated/peers/Property.ts b/ets1.2/libarkts/src/generated/peers/Property.ts new file mode 100644 index 0000000000000000000000000000000000000000..f8e62621e6cc153855092f29fa4647cc29336026 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/Property.ts @@ -0,0 +1,93 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaPropertyKind } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { ValidationInfo } from "./ValidationInfo" + +export class Property extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create1Property(kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property { + const result: Property = new Property(global.generatedEs2panda._CreateProperty1(global.context, kind, passNode(key), passNode(value), isMethod, isComputed), Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY) + result.setChildrenParentPtr() + return result + } + static updateProperty(original?: Property, key?: Expression, value?: Expression): Property { + const result: Property = new Property(global.generatedEs2panda._UpdateProperty(global.context, passNode(original), passNode(key), passNode(value)), Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY) + result.setChildrenParentPtr() + return result + } + static update1Property(original: Property | undefined, kind: Es2pandaPropertyKind, key: Expression | undefined, value: Expression | undefined, isMethod: boolean, isComputed: boolean): Property { + const result: Property = new Property(global.generatedEs2panda._UpdateProperty1(global.context, passNode(original), kind, passNode(key), passNode(value), isMethod, isComputed), Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY) + result.setChildrenParentPtr() + return result + } + get key(): Expression | undefined { + return unpackNode(global.generatedEs2panda._PropertyKey(global.context, this.peer)) + } + get value(): Expression | undefined { + return unpackNode(global.generatedEs2panda._PropertyValue(global.context, this.peer)) + } + get kind(): Es2pandaPropertyKind { + return global.generatedEs2panda._PropertyKindConst(global.context, this.peer) + } + get isMethod(): boolean { + return global.generatedEs2panda._PropertyIsMethodConst(global.context, this.peer) + } + get isShorthand(): boolean { + return global.generatedEs2panda._PropertyIsShorthandConst(global.context, this.peer) + } + get isComputed(): boolean { + return global.generatedEs2panda._PropertyIsComputedConst(global.context, this.peer) + } + get isAccessor(): boolean { + return global.generatedEs2panda._PropertyIsAccessorConst(global.context, this.peer) + } + get convertibleToPatternProperty(): boolean { + return global.generatedEs2panda._PropertyConvertibleToPatternProperty(global.context, this.peer) + } + get validateExpression(): ValidationInfo | undefined { + return new ValidationInfo(global.generatedEs2panda._PropertyValidateExpression(global.context, this.peer)) + } + protected readonly brandProperty: undefined +} +export function isProperty(node: object | undefined): node is Property { + return node instanceof Property +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY, (peer: KNativePointer) => new Property(peer, Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY)) +} diff --git a/ets1.2/libarkts/src/generated/peers/RegExpLiteral.ts b/ets1.2/libarkts/src/generated/peers/RegExpLiteral.ts new file mode 100644 index 0000000000000000000000000000000000000000..56edc663f50c00c7fb642895a246dd7b36405545 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/RegExpLiteral.ts @@ -0,0 +1,66 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaRegExpFlags } from "./../Es2pandaEnums" +import { Literal } from "./Literal" + +export class RegExpLiteral extends Literal { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createRegExpLiteral(pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral { + const result: RegExpLiteral = new RegExpLiteral(global.generatedEs2panda._CreateRegExpLiteral(global.context, pattern, flags, flagsStr), Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL) + result.setChildrenParentPtr() + return result + } + static updateRegExpLiteral(original: RegExpLiteral | undefined, pattern: string, flags: Es2pandaRegExpFlags, flagsStr: string): RegExpLiteral { + const result: RegExpLiteral = new RegExpLiteral(global.generatedEs2panda._UpdateRegExpLiteral(global.context, passNode(original), pattern, flags, flagsStr), Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL) + result.setChildrenParentPtr() + return result + } + get pattern(): string { + return unpackString(global.generatedEs2panda._RegExpLiteralPatternConst(global.context, this.peer)) + } + get flags(): Es2pandaRegExpFlags { + return global.generatedEs2panda._RegExpLiteralFlagsConst(global.context, this.peer) + } + protected readonly brandRegExpLiteral: undefined +} +export function isRegExpLiteral(node: object | undefined): node is RegExpLiteral { + return node instanceof RegExpLiteral +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL, (peer: KNativePointer) => new RegExpLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ReturnStatement.ts b/ets1.2/libarkts/src/generated/peers/ReturnStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..ec8168bb4c4e77ef17a6050e6564e0fabc1552ca --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ReturnStatement.ts @@ -0,0 +1,76 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Statement } from "./Statement" + +export class ReturnStatement extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create1ReturnStatement(argument?: Expression): ReturnStatement { + const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._CreateReturnStatement1(global.context, passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateReturnStatement(original?: ReturnStatement): ReturnStatement { + const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT) + result.setChildrenParentPtr() + return result + } + static update1ReturnStatement(original?: ReturnStatement, argument?: Expression): ReturnStatement { + const result: ReturnStatement = new ReturnStatement(global.generatedEs2panda._UpdateReturnStatement1(global.context, passNode(original), passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT) + result.setChildrenParentPtr() + return result + } + get argument(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ReturnStatementArgument(global.context, this.peer)) + } + /** @deprecated */ + setArgument(arg?: Expression): this { + global.generatedEs2panda._ReturnStatementSetArgument(global.context, this.peer, passNode(arg)) + return this + } + get isAsyncImplReturn(): boolean { + return global.generatedEs2panda._ReturnStatementIsAsyncImplReturnConst(global.context, this.peer) + } + protected readonly brandReturnStatement: undefined +} +export function isReturnStatement(node: object | undefined): node is ReturnStatement { + return node instanceof ReturnStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, (peer: KNativePointer) => new ReturnStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ScopeFindResult.ts b/ets1.2/libarkts/src/generated/peers/ScopeFindResult.ts new file mode 100644 index 0000000000000000000000000000000000000000..86792937aaeceb1e5d3c4078f20f71126c88e288 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ScopeFindResult.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class ScopeFindResult extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandScopeFindResult: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/ScriptFunction.ts b/ets1.2/libarkts/src/generated/peers/ScriptFunction.ts new file mode 100644 index 0000000000000000000000000000000000000000..f0f861376cb5817c5dcfb2d666bbd8c88d1f6cef --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ScriptFunction.ts @@ -0,0 +1,309 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotationUsage } from "./AnnotationUsage" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaScriptFunctionFlags } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { FunctionSignature } from "./FunctionSignature" +import { Identifier } from "./Identifier" +import { ReturnStatement } from "./ReturnStatement" +import { SrcDumper } from "./SrcDumper" +import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" +import { TypeNode } from "./TypeNode" +import { extension_ScriptFunctionGetPreferredReturnTypePointer } from "./../../reexport-for-generated" +import { extension_ScriptFunctionGetSignaturePointer } from "./../../reexport-for-generated" +import { extension_ScriptFunctionSetPreferredReturnTypePointer } from "./../../reexport-for-generated" +import { extension_ScriptFunctionSetSignaturePointer } from "./../../reexport-for-generated" + +export class ScriptFunction extends AstNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createScriptFunction(databody: AstNode | undefined, datasignature: FunctionSignature | undefined, datafuncFlags: number, dataflags: number, ident?: Identifier, annotations?: readonly AnnotationUsage[]): ScriptFunction { + const result: ScriptFunction = new ScriptFunction(global.generatedEs2panda._CreateScriptFunction(global.context, passNode(databody), passNode(datasignature), datafuncFlags, dataflags), Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION) + if (ident) + { + result.setIdent(ident) + } + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + static updateScriptFunction(original: ScriptFunction | undefined, databody: AstNode | undefined, datasignature: FunctionSignature | undefined, datafuncFlags: number, dataflags: number, ident?: Identifier, annotations?: readonly AnnotationUsage[]): ScriptFunction { + const result: ScriptFunction = new ScriptFunction(global.generatedEs2panda._UpdateScriptFunction(global.context, passNode(original), passNode(databody), passNode(datasignature), datafuncFlags, dataflags), Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION) + if (ident) + { + result.setIdent(ident) + } + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + get id(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._ScriptFunctionId(global.context, this.peer)) + } + get params(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._ScriptFunctionParams(global.context, this.peer)) + } + get returnStatements(): readonly ReturnStatement[] { + return unpackNodeArray(global.generatedEs2panda._ScriptFunctionReturnStatements(global.context, this.peer)) + } + get returnStatementsForUpdate(): readonly ReturnStatement[] { + return unpackNodeArray(global.generatedEs2panda._ScriptFunctionReturnStatementsForUpdate(global.context, this.peer)) + } + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._ScriptFunctionTypeParams(global.context, this.peer)) + } + get body(): AstNode | undefined { + return unpackNode(global.generatedEs2panda._ScriptFunctionBody(global.context, this.peer)) + } + /** @deprecated */ + addReturnStatement(returnStatement?: ReturnStatement): this { + global.generatedEs2panda._ScriptFunctionAddReturnStatement(global.context, this.peer, passNode(returnStatement)) + return this + } + /** @deprecated */ + setBody(body?: AstNode): this { + global.generatedEs2panda._ScriptFunctionSetBody(global.context, this.peer, passNode(body)) + return this + } + get returnTypeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._ScriptFunctionReturnTypeAnnotation(global.context, this.peer)) + } + /** @deprecated */ + setReturnTypeAnnotation(node?: TypeNode): this { + global.generatedEs2panda._ScriptFunctionSetReturnTypeAnnotation(global.context, this.peer, passNode(node)) + return this + } + get isEntryPoint(): boolean { + return global.generatedEs2panda._ScriptFunctionIsEntryPointConst(global.context, this.peer) + } + get isGenerator(): boolean { + return global.generatedEs2panda._ScriptFunctionIsGeneratorConst(global.context, this.peer) + } + get isAsyncFunc(): boolean { + return global.generatedEs2panda._ScriptFunctionIsAsyncFuncConst(global.context, this.peer) + } + get isAsyncImplFunc(): boolean { + return global.generatedEs2panda._ScriptFunctionIsAsyncImplFuncConst(global.context, this.peer) + } + get isArrow(): boolean { + return global.generatedEs2panda._ScriptFunctionIsArrowConst(global.context, this.peer) + } + get isOverload(): boolean { + return global.generatedEs2panda._ScriptFunctionIsOverloadConst(global.context, this.peer) + } + get isExternalOverload(): boolean { + return global.generatedEs2panda._ScriptFunctionIsExternalOverloadConst(global.context, this.peer) + } + get isConstructor(): boolean { + return global.generatedEs2panda._ScriptFunctionIsConstructorConst(global.context, this.peer) + } + get isGetter(): boolean { + return global.generatedEs2panda._ScriptFunctionIsGetterConst(global.context, this.peer) + } + get isSetter(): boolean { + return global.generatedEs2panda._ScriptFunctionIsSetterConst(global.context, this.peer) + } + get isExtensionAccessor(): boolean { + return global.generatedEs2panda._ScriptFunctionIsExtensionAccessorConst(global.context, this.peer) + } + get isMethod(): boolean { + return global.generatedEs2panda._ScriptFunctionIsMethodConst(global.context, this.peer) + } + get isProxy(): boolean { + return global.generatedEs2panda._ScriptFunctionIsProxyConst(global.context, this.peer) + } + get isStaticBlock(): boolean { + return global.generatedEs2panda._ScriptFunctionIsStaticBlockConst(global.context, this.peer) + } + get isEnum(): boolean { + return global.generatedEs2panda._ScriptFunctionIsEnumConst(global.context, this.peer) + } + get isHidden(): boolean { + return global.generatedEs2panda._ScriptFunctionIsHiddenConst(global.context, this.peer) + } + get isExternal(): boolean { + return global.generatedEs2panda._ScriptFunctionIsExternalConst(global.context, this.peer) + } + get isImplicitSuperCallNeeded(): boolean { + return global.generatedEs2panda._ScriptFunctionIsImplicitSuperCallNeededConst(global.context, this.peer) + } + get hasBody(): boolean { + return global.generatedEs2panda._ScriptFunctionHasBodyConst(global.context, this.peer) + } + get hasRestParameter(): boolean { + return global.generatedEs2panda._ScriptFunctionHasRestParameterConst(global.context, this.peer) + } + get hasReturnStatement(): boolean { + return global.generatedEs2panda._ScriptFunctionHasReturnStatementConst(global.context, this.peer) + } + get hasThrowStatement(): boolean { + return global.generatedEs2panda._ScriptFunctionHasThrowStatementConst(global.context, this.peer) + } + get isTrailingLambda(): boolean { + return global.generatedEs2panda._ScriptFunctionIsTrailingLambdaConst(global.context, this.peer) + } + get isSynthetic(): boolean { + return global.generatedEs2panda._ScriptFunctionIsSyntheticConst(global.context, this.peer) + } + get isDynamic(): boolean { + return global.generatedEs2panda._ScriptFunctionIsDynamicConst(global.context, this.peer) + } + get isExtensionMethod(): boolean { + return global.generatedEs2panda._ScriptFunctionIsExtensionMethodConst(global.context, this.peer) + } + get flags(): Es2pandaScriptFunctionFlags { + return global.generatedEs2panda._ScriptFunctionFlagsConst(global.context, this.peer) + } + get hasReceiver(): boolean { + return global.generatedEs2panda._ScriptFunctionHasReceiverConst(global.context, this.peer) + } + /** @deprecated */ + setIdent(id: Identifier): this { + global.generatedEs2panda._ScriptFunctionSetIdent(global.context, this.peer, passNode(id)) + return this + } + /** @deprecated */ + addFlag(flags: Es2pandaScriptFunctionFlags): this { + global.generatedEs2panda._ScriptFunctionAddFlag(global.context, this.peer, flags) + return this + } + /** @deprecated */ + clearFlag(flags: Es2pandaScriptFunctionFlags): this { + global.generatedEs2panda._ScriptFunctionClearFlag(global.context, this.peer, flags) + return this + } + get formalParamsLength(): number { + return global.generatedEs2panda._ScriptFunctionFormalParamsLengthConst(global.context, this.peer) + } + /** @deprecated */ + setAsyncPairMethod(asyncPairFunction?: ScriptFunction): this { + global.generatedEs2panda._ScriptFunctionSetAsyncPairMethod(global.context, this.peer, passNode(asyncPairFunction)) + return this + } + get asyncPairMethod(): ScriptFunction | undefined { + return unpackNode(global.generatedEs2panda._ScriptFunctionAsyncPairMethod(global.context, this.peer)) + } + /** @deprecated */ + emplaceReturnStatements(returnStatements?: ReturnStatement): this { + global.generatedEs2panda._ScriptFunctionEmplaceReturnStatements(global.context, this.peer, passNode(returnStatements)) + return this + } + /** @deprecated */ + clearReturnStatements(): this { + global.generatedEs2panda._ScriptFunctionClearReturnStatements(global.context, this.peer) + return this + } + /** @deprecated */ + setValueReturnStatements(returnStatements: ReturnStatement | undefined, index: number): this { + global.generatedEs2panda._ScriptFunctionSetValueReturnStatements(global.context, this.peer, passNode(returnStatements), index) + return this + } + /** @deprecated */ + emplaceParams(params?: Expression): this { + global.generatedEs2panda._ScriptFunctionEmplaceParams(global.context, this.peer, passNode(params)) + return this + } + /** @deprecated */ + setParams(paramsList: readonly Expression[]): this { + global.generatedEs2panda._ScriptFunctionSetParams(global.context, this.peer, passNodeArray(paramsList), paramsList.length) + return this + } + /** @deprecated */ + clearParams(): this { + global.generatedEs2panda._ScriptFunctionClearParams(global.context, this.peer) + return this + } + /** @deprecated */ + setValueParams(params: Expression | undefined, index: number): this { + global.generatedEs2panda._ScriptFunctionSetValueParams(global.context, this.peer, passNode(params), index) + return this + } + get paramsForUpdate(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._ScriptFunctionParamsForUpdate(global.context, this.peer)) + } + get hasAnnotations(): boolean { + return global.generatedEs2panda._ScriptFunctionHasAnnotationsConst(global.context, this.peer) + } + /** @deprecated */ + emplaceAnnotation(source?: AnnotationUsage): this { + global.generatedEs2panda._ScriptFunctionEmplaceAnnotation(global.context, this.peer, passNode(source)) + return this + } + /** @deprecated */ + clearAnnotations(): this { + global.generatedEs2panda._ScriptFunctionClearAnnotations(global.context, this.peer) + return this + } + /** @deprecated */ + dumpAnnotations(dumper?: SrcDumper): this { + global.generatedEs2panda._ScriptFunctionDumpAnnotationsConst(global.context, this.peer, passNode(dumper)) + return this + } + get annotationsForUpdate(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._ScriptFunctionAnnotationsForUpdate(global.context, this.peer)) + } + get annotations(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._ScriptFunctionAnnotations(global.context, this.peer)) + } + /** @deprecated */ + setAnnotations(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._ScriptFunctionSetAnnotations(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + /** @deprecated */ + setAnnotations1(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._ScriptFunctionSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + getSignaturePointer = extension_ScriptFunctionGetSignaturePointer + setSignaturePointer = extension_ScriptFunctionSetSignaturePointer + getPreferredReturnTypePointer = extension_ScriptFunctionGetPreferredReturnTypePointer + setPreferredReturnTypePointer = extension_ScriptFunctionSetPreferredReturnTypePointer + protected readonly brandScriptFunction: undefined +} +export function isScriptFunction(node: object | undefined): node is ScriptFunction { + return node instanceof ScriptFunction +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION, (peer: KNativePointer) => new ScriptFunction(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ScriptFunctionData.ts b/ets1.2/libarkts/src/generated/peers/ScriptFunctionData.ts new file mode 100644 index 0000000000000000000000000000000000000000..4745973aa5971073a04413ed554c1aa5ec14091e --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ScriptFunctionData.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class ScriptFunctionData extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandScriptFunctionData: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/SequenceExpression.ts b/ets1.2/libarkts/src/generated/peers/SequenceExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..68ee4fbdacfdf6b4fb3d07bc6fa88e325138ea42 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/SequenceExpression.ts @@ -0,0 +1,62 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class SequenceExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createSequenceExpression(sequence_arg: readonly Expression[]): SequenceExpression { + const result: SequenceExpression = new SequenceExpression(global.generatedEs2panda._CreateSequenceExpression(global.context, passNodeArray(sequence_arg), sequence_arg.length), Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateSequenceExpression(original: SequenceExpression | undefined, sequence_arg: readonly Expression[]): SequenceExpression { + const result: SequenceExpression = new SequenceExpression(global.generatedEs2panda._UpdateSequenceExpression(global.context, passNode(original), passNodeArray(sequence_arg), sequence_arg.length), Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get sequence(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._SequenceExpressionSequence(global.context, this.peer)) + } + protected readonly brandSequenceExpression: undefined +} +export function isSequenceExpression(node: object | undefined): node is SequenceExpression { + return node instanceof SequenceExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION, (peer: KNativePointer) => new SequenceExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/SignatureInfo.ts b/ets1.2/libarkts/src/generated/peers/SignatureInfo.ts new file mode 100644 index 0000000000000000000000000000000000000000..7ea77fdceecc29a0869a57622fb9034d7c9f4ee9 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/SignatureInfo.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class SignatureInfo extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandSignatureInfo: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/SourcePosition.ts b/ets1.2/libarkts/src/generated/peers/SourcePosition.ts new file mode 100644 index 0000000000000000000000000000000000000000..8309bce5b4041d275d80ecab1d67ddc3f7fcd16b --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/SourcePosition.ts @@ -0,0 +1,47 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { extension_SourcePositionGetCol } from "./../../reexport-for-generated" +import { extension_SourcePositionGetLine } from "./../../reexport-for-generated" +import { extension_SourcePositionToString } from "./../../reexport-for-generated" + +export class SourcePosition extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + getLine = extension_SourcePositionGetLine + getCol = extension_SourcePositionGetCol + toString = extension_SourcePositionToString + protected readonly brandSourcePosition: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/SourceRange.ts b/ets1.2/libarkts/src/generated/peers/SourceRange.ts new file mode 100644 index 0000000000000000000000000000000000000000..1b388713bd90ee9904670f938ad48e00ad71cab9 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/SourceRange.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class SourceRange extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandSourceRange: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/SpreadElement.ts b/ets1.2/libarkts/src/generated/peers/SpreadElement.ts new file mode 100644 index 0000000000000000000000000000000000000000..d853a91cc344042847f7b4392e81b666af65ddea --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/SpreadElement.ts @@ -0,0 +1,84 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotatedExpression } from "./AnnotatedExpression" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" +import { ValidationInfo } from "./ValidationInfo" + +export class SpreadElement extends AnnotatedExpression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createSpreadElement(nodeType: Es2pandaAstNodeType, argument?: Expression): SpreadElement { + const result: SpreadElement = new SpreadElement(global.generatedEs2panda._CreateSpreadElement(global.context, nodeType, passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT) + result.setChildrenParentPtr() + return result + } + static updateSpreadElement(original: SpreadElement | undefined, nodeType: Es2pandaAstNodeType, argument?: Expression): SpreadElement { + const result: SpreadElement = new SpreadElement(global.generatedEs2panda._UpdateSpreadElement(global.context, passNode(original), nodeType, passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT) + result.setChildrenParentPtr() + return result + } + get argument(): Expression | undefined { + return unpackNode(global.generatedEs2panda._SpreadElementArgument(global.context, this.peer)) + } + get isOptional(): boolean { + return global.generatedEs2panda._SpreadElementIsOptionalConst(global.context, this.peer) + } + /** @deprecated */ + setOptional(optional_arg: boolean): this { + global.generatedEs2panda._SpreadElementSetOptional(global.context, this.peer, optional_arg) + return this + } + get validateExpression(): ValidationInfo | undefined { + return new ValidationInfo(global.generatedEs2panda._SpreadElementValidateExpression(global.context, this.peer)) + } + get typeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._SpreadElementTypeAnnotationConst(global.context, this.peer)) + } + /** @deprecated */ + setTsTypeAnnotation(typeAnnotation?: TypeNode): this { + global.generatedEs2panda._SpreadElementSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation)) + return this + } + protected readonly brandSpreadElement: undefined +} +export function isSpreadElement(node: object | undefined): node is SpreadElement { + return node instanceof SpreadElement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT, (peer: KNativePointer) => new SpreadElement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/SrcDumper.ts b/ets1.2/libarkts/src/generated/peers/SrcDumper.ts new file mode 100644 index 0000000000000000000000000000000000000000..4c750b7e9205a85587b1496d84867559124fd872 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/SrcDumper.ts @@ -0,0 +1,121 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class SrcDumper extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + static create1SrcDumper(node: AstNode | undefined, isDeclgen: boolean): SrcDumper { + return new SrcDumper(global.generatedEs2panda._CreateSrcDumper1(global.context, passNode(node), isDeclgen)) + } + /** @deprecated */ + add(str: string): this { + global.generatedEs2panda._SrcDumperAdd(global.context, this.peer, str) + return this + } + /** @deprecated */ + add1(i: number): this { + global.generatedEs2panda._SrcDumperAdd1(global.context, this.peer, i) + return this + } + /** @deprecated */ + add2(i: number): this { + global.generatedEs2panda._SrcDumperAdd2(global.context, this.peer, i) + return this + } + /** @deprecated */ + add3(i: number): this { + global.generatedEs2panda._SrcDumperAdd3(global.context, this.peer, i) + return this + } + /** @deprecated */ + add4(l: number): this { + global.generatedEs2panda._SrcDumperAdd4(global.context, this.peer, l) + return this + } + /** @deprecated */ + add5(f: number): this { + global.generatedEs2panda._SrcDumperAdd5(global.context, this.peer, f) + return this + } + /** @deprecated */ + add6(d: number): this { + global.generatedEs2panda._SrcDumperAdd6(global.context, this.peer, d) + return this + } + get str(): string { + return unpackString(global.generatedEs2panda._SrcDumperStrConst(global.context, this.peer)) + } + /** @deprecated */ + incrIndent(): this { + global.generatedEs2panda._SrcDumperIncrIndent(global.context, this.peer) + return this + } + /** @deprecated */ + decrIndent(): this { + global.generatedEs2panda._SrcDumperDecrIndent(global.context, this.peer) + return this + } + /** @deprecated */ + endl(num: number): this { + global.generatedEs2panda._SrcDumperEndl(global.context, this.peer, num) + return this + } + get isDeclgen(): boolean { + return global.generatedEs2panda._SrcDumperIsDeclgenConst(global.context, this.peer) + } + /** @deprecated */ + dumpNode(key: string): this { + global.generatedEs2panda._SrcDumperDumpNode(global.context, this.peer, key) + return this + } + /** @deprecated */ + removeNode(key: string): this { + global.generatedEs2panda._SrcDumperRemoveNode(global.context, this.peer, key) + return this + } + get isIndirectDepPhase(): boolean { + return global.generatedEs2panda._SrcDumperIsIndirectDepPhaseConst(global.context, this.peer) + } + /** @deprecated */ + run(): this { + global.generatedEs2panda._SrcDumperRun(global.context, this.peer) + return this + } + protected readonly brandSrcDumper: undefined +} +export function isSrcDumper(node: object | undefined): node is SrcDumper { + return node instanceof SrcDumper +} diff --git a/ets1.2/libarkts/src/generated/peers/Statement.ts b/ets1.2/libarkts/src/generated/peers/Statement.ts new file mode 100644 index 0000000000000000000000000000000000000000..1ebab571e91678788c20ec2ae550f73712a291ca --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/Statement.ts @@ -0,0 +1,45 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" + +export class Statement extends AstNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + protected readonly brandStatement: undefined +} +export function isStatement(node: object | undefined): node is Statement { + return node instanceof Statement +} diff --git a/ets1.2/libarkts/src/generated/peers/StringLiteral.ts b/ets1.2/libarkts/src/generated/peers/StringLiteral.ts new file mode 100644 index 0000000000000000000000000000000000000000..0e6ba1802151353d05a9c8f7933aa9870adc3557 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/StringLiteral.ts @@ -0,0 +1,67 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Literal } from "./Literal" + +export class StringLiteral extends Literal { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create1StringLiteral(str: string): StringLiteral { + const result: StringLiteral = new StringLiteral(global.generatedEs2panda._CreateStringLiteral1(global.context, str), Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL) + result.setChildrenParentPtr() + return result + } + static updateStringLiteral(original?: StringLiteral): StringLiteral { + const result: StringLiteral = new StringLiteral(global.generatedEs2panda._UpdateStringLiteral(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL) + result.setChildrenParentPtr() + return result + } + static update1StringLiteral(original: StringLiteral | undefined, str: string): StringLiteral { + const result: StringLiteral = new StringLiteral(global.generatedEs2panda._UpdateStringLiteral1(global.context, passNode(original), str), Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL) + result.setChildrenParentPtr() + return result + } + get str(): string { + return unpackString(global.generatedEs2panda._StringLiteralStrConst(global.context, this.peer)) + } + protected readonly brandStringLiteral: undefined +} +export function isStringLiteral(node: object | undefined): node is StringLiteral { + return node instanceof StringLiteral +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL, (peer: KNativePointer) => new StringLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL)) +} diff --git a/ets1.2/libarkts/src/generated/peers/SuggestionInfo.ts b/ets1.2/libarkts/src/generated/peers/SuggestionInfo.ts new file mode 100644 index 0000000000000000000000000000000000000000..a4d620bb51714c6f4ba87537bce829235aee1bf3 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/SuggestionInfo.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class SuggestionInfo extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandSuggestionInfo: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/SuperExpression.ts b/ets1.2/libarkts/src/generated/peers/SuperExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..490544812f02f0953ca143d9155cc89dec9491be --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/SuperExpression.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class SuperExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createSuperExpression(): SuperExpression { + const result: SuperExpression = new SuperExpression(global.generatedEs2panda._CreateSuperExpression(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateSuperExpression(original?: SuperExpression): SuperExpression { + const result: SuperExpression = new SuperExpression(global.generatedEs2panda._UpdateSuperExpression(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION) + result.setChildrenParentPtr() + return result + } + protected readonly brandSuperExpression: undefined +} +export function isSuperExpression(node: object | undefined): node is SuperExpression { + return node instanceof SuperExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, (peer: KNativePointer) => new SuperExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/SwitchCaseStatement.ts b/ets1.2/libarkts/src/generated/peers/SwitchCaseStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..4e4efe0c3db6406b7ab6ca51643c81e20c193653 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/SwitchCaseStatement.ts @@ -0,0 +1,71 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Statement } from "./Statement" + +export class SwitchCaseStatement extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createSwitchCaseStatement(test: Expression | undefined, consequent: readonly Statement[]): SwitchCaseStatement { + const result: SwitchCaseStatement = new SwitchCaseStatement(global.generatedEs2panda._CreateSwitchCaseStatement(global.context, passNode(test), passNodeArray(consequent), consequent.length), Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateSwitchCaseStatement(original: SwitchCaseStatement | undefined, test: Expression | undefined, consequent: readonly Statement[]): SwitchCaseStatement { + const result: SwitchCaseStatement = new SwitchCaseStatement(global.generatedEs2panda._UpdateSwitchCaseStatement(global.context, passNode(original), passNode(test), passNodeArray(consequent), consequent.length), Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT) + result.setChildrenParentPtr() + return result + } + get test(): Expression | undefined { + return unpackNode(global.generatedEs2panda._SwitchCaseStatementTest(global.context, this.peer)) + } + /** @deprecated */ + setTest(test?: Expression): this { + global.generatedEs2panda._SwitchCaseStatementSetTest(global.context, this.peer, passNode(test)) + return this + } + get consequent(): readonly Statement[] { + return unpackNodeArray(global.generatedEs2panda._SwitchCaseStatementConsequentConst(global.context, this.peer)) + } + protected readonly brandSwitchCaseStatement: undefined +} +export function isSwitchCaseStatement(node: object | undefined): node is SwitchCaseStatement { + return node instanceof SwitchCaseStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT, (peer: KNativePointer) => new SwitchCaseStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/SwitchStatement.ts b/ets1.2/libarkts/src/generated/peers/SwitchStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..60e9e3567d5eb8805cd2f315102d520908bae334 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/SwitchStatement.ts @@ -0,0 +1,72 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Statement } from "./Statement" +import { SwitchCaseStatement } from "./SwitchCaseStatement" + +export class SwitchStatement extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createSwitchStatement(discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[]): SwitchStatement { + const result: SwitchStatement = new SwitchStatement(global.generatedEs2panda._CreateSwitchStatement(global.context, passNode(discriminant), passNodeArray(cases), cases.length), Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateSwitchStatement(original: SwitchStatement | undefined, discriminant: Expression | undefined, cases: readonly SwitchCaseStatement[]): SwitchStatement { + const result: SwitchStatement = new SwitchStatement(global.generatedEs2panda._UpdateSwitchStatement(global.context, passNode(original), passNode(discriminant), passNodeArray(cases), cases.length), Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT) + result.setChildrenParentPtr() + return result + } + get discriminant(): Expression | undefined { + return unpackNode(global.generatedEs2panda._SwitchStatementDiscriminant(global.context, this.peer)) + } + /** @deprecated */ + setDiscriminant(discriminant?: Expression): this { + global.generatedEs2panda._SwitchStatementSetDiscriminant(global.context, this.peer, passNode(discriminant)) + return this + } + get cases(): readonly SwitchCaseStatement[] { + return unpackNodeArray(global.generatedEs2panda._SwitchStatementCases(global.context, this.peer)) + } + protected readonly brandSwitchStatement: undefined +} +export function isSwitchStatement(node: object | undefined): node is SwitchStatement { + return node instanceof SwitchStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT, (peer: KNativePointer) => new SwitchStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSAnyKeyword.ts b/ets1.2/libarkts/src/generated/peers/TSAnyKeyword.ts new file mode 100644 index 0000000000000000000000000000000000000000..9d4805cf201de649b41f45fcb783a95f76545a36 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSAnyKeyword.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSAnyKeyword extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSAnyKeyword(): TSAnyKeyword { + const result: TSAnyKeyword = new TSAnyKeyword(global.generatedEs2panda._CreateTSAnyKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD) + result.setChildrenParentPtr() + return result + } + static updateTSAnyKeyword(original?: TSAnyKeyword): TSAnyKeyword { + const result: TSAnyKeyword = new TSAnyKeyword(global.generatedEs2panda._UpdateTSAnyKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD) + result.setChildrenParentPtr() + return result + } + protected readonly brandTSAnyKeyword: undefined +} +export function isTSAnyKeyword(node: object | undefined): node is TSAnyKeyword { + return node instanceof TSAnyKeyword +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD, (peer: KNativePointer) => new TSAnyKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSArrayType.ts b/ets1.2/libarkts/src/generated/peers/TSArrayType.ts new file mode 100644 index 0000000000000000000000000000000000000000..4ae71bd9d149a19b3b6f036914c6d4f38e3733ec --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSArrayType.ts @@ -0,0 +1,62 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSArrayType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSArrayType(elementType?: TypeNode): TSArrayType { + const result: TSArrayType = new TSArrayType(global.generatedEs2panda._CreateTSArrayType(global.context, passNode(elementType)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE) + result.setChildrenParentPtr() + return result + } + static updateTSArrayType(original?: TSArrayType, elementType?: TypeNode): TSArrayType { + const result: TSArrayType = new TSArrayType(global.generatedEs2panda._UpdateTSArrayType(global.context, passNode(original), passNode(elementType)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE) + result.setChildrenParentPtr() + return result + } + get elementType(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSArrayTypeElementTypeConst(global.context, this.peer)) + } + protected readonly brandTSArrayType: undefined +} +export function isTSArrayType(node: object | undefined): node is TSArrayType { + return node instanceof TSArrayType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE, (peer: KNativePointer) => new TSArrayType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSAsExpression.ts b/ets1.2/libarkts/src/generated/peers/TSAsExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..25cb9383403d78c0738f3300e4c73be9666e4b4f --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSAsExpression.ts @@ -0,0 +1,85 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotatedExpression } from "./AnnotatedExpression" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" + +export class TSAsExpression extends AnnotatedExpression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSAsExpression(expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression { + const result: TSAsExpression = new TSAsExpression(global.generatedEs2panda._CreateTSAsExpression(global.context, passNode(expression), passNode(typeAnnotation), isConst), Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateTSAsExpression(original: TSAsExpression | undefined, expression: Expression | undefined, typeAnnotation: TypeNode | undefined, isConst: boolean): TSAsExpression { + const result: TSAsExpression = new TSAsExpression(global.generatedEs2panda._UpdateTSAsExpression(global.context, passNode(original), passNode(expression), passNode(typeAnnotation), isConst), Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get expr(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSAsExpressionExpr(global.context, this.peer)) + } + /** @deprecated */ + setExpr(expr?: Expression): this { + global.generatedEs2panda._TSAsExpressionSetExpr(global.context, this.peer, passNode(expr)) + return this + } + get isConst(): boolean { + return global.generatedEs2panda._TSAsExpressionIsConstConst(global.context, this.peer) + } + /** @deprecated */ + setUncheckedCast(isUncheckedCast: boolean): this { + global.generatedEs2panda._TSAsExpressionSetUncheckedCast(global.context, this.peer, isUncheckedCast) + return this + } + get typeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSAsExpressionTypeAnnotationConst(global.context, this.peer)) + } + /** @deprecated */ + setTsTypeAnnotation(typeAnnotation?: TypeNode): this { + global.generatedEs2panda._TSAsExpressionSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation)) + return this + } + protected readonly brandTSAsExpression: undefined +} +export function isTSAsExpression(node: object | undefined): node is TSAsExpression { + return node instanceof TSAsExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION, (peer: KNativePointer) => new TSAsExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSBigintKeyword.ts b/ets1.2/libarkts/src/generated/peers/TSBigintKeyword.ts new file mode 100644 index 0000000000000000000000000000000000000000..34f7db9b7d6fa899da3c3cdee30638db9d507216 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSBigintKeyword.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSBigintKeyword extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSBigintKeyword(): TSBigintKeyword { + const result: TSBigintKeyword = new TSBigintKeyword(global.generatedEs2panda._CreateTSBigintKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_BIGINT_KEYWORD) + result.setChildrenParentPtr() + return result + } + static updateTSBigintKeyword(original?: TSBigintKeyword): TSBigintKeyword { + const result: TSBigintKeyword = new TSBigintKeyword(global.generatedEs2panda._UpdateTSBigintKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_BIGINT_KEYWORD) + result.setChildrenParentPtr() + return result + } + protected readonly brandTSBigintKeyword: undefined +} +export function isTSBigintKeyword(node: object | undefined): node is TSBigintKeyword { + return node instanceof TSBigintKeyword +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_BIGINT_KEYWORD)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_BIGINT_KEYWORD, (peer: KNativePointer) => new TSBigintKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_BIGINT_KEYWORD)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSBooleanKeyword.ts b/ets1.2/libarkts/src/generated/peers/TSBooleanKeyword.ts new file mode 100644 index 0000000000000000000000000000000000000000..fcf646c44604ea27f488ffc296593191a433c5cb --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSBooleanKeyword.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSBooleanKeyword extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSBooleanKeyword(): TSBooleanKeyword { + const result: TSBooleanKeyword = new TSBooleanKeyword(global.generatedEs2panda._CreateTSBooleanKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_BOOLEAN_KEYWORD) + result.setChildrenParentPtr() + return result + } + static updateTSBooleanKeyword(original?: TSBooleanKeyword): TSBooleanKeyword { + const result: TSBooleanKeyword = new TSBooleanKeyword(global.generatedEs2panda._UpdateTSBooleanKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_BOOLEAN_KEYWORD) + result.setChildrenParentPtr() + return result + } + protected readonly brandTSBooleanKeyword: undefined +} +export function isTSBooleanKeyword(node: object | undefined): node is TSBooleanKeyword { + return node instanceof TSBooleanKeyword +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_BOOLEAN_KEYWORD)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_BOOLEAN_KEYWORD, (peer: KNativePointer) => new TSBooleanKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_BOOLEAN_KEYWORD)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSClassImplements.ts b/ets1.2/libarkts/src/generated/peers/TSClassImplements.ts new file mode 100644 index 0000000000000000000000000000000000000000..35010b673a88bcd9163f6397661562361348c82f --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSClassImplements.ts @@ -0,0 +1,71 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" + +export class TSClassImplements extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSClassImplements(expression?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements { + const result: TSClassImplements = new TSClassImplements(global.generatedEs2panda._CreateTSClassImplements(global.context, passNode(expression), passNode(typeParameters)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS) + result.setChildrenParentPtr() + return result + } + static updateTSClassImplements(original?: TSClassImplements, expression?: Expression, typeParameters?: TSTypeParameterInstantiation): TSClassImplements { + const result: TSClassImplements = new TSClassImplements(global.generatedEs2panda._UpdateTSClassImplements(global.context, passNode(original), passNode(expression), passNode(typeParameters)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS) + result.setChildrenParentPtr() + return result + } + static update1TSClassImplements(original?: TSClassImplements, expression?: Expression): TSClassImplements { + const result: TSClassImplements = new TSClassImplements(global.generatedEs2panda._UpdateTSClassImplements1(global.context, passNode(original), passNode(expression)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS) + result.setChildrenParentPtr() + return result + } + get expr(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSClassImplementsExpr(global.context, this.peer)) + } + get typeParameters(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._TSClassImplementsTypeParametersConst(global.context, this.peer)) + } + protected readonly brandTSClassImplements: undefined +} +export function isTSClassImplements(node: object | undefined): node is TSClassImplements { + return node instanceof TSClassImplements +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS, (peer: KNativePointer) => new TSClassImplements(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSConditionalType.ts b/ets1.2/libarkts/src/generated/peers/TSConditionalType.ts new file mode 100644 index 0000000000000000000000000000000000000000..523b1b957f7102d1cb22782bcedd3197cdf96faf --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSConditionalType.ts @@ -0,0 +1,72 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" + +export class TSConditionalType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSConditionalType(checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType { + const result: TSConditionalType = new TSConditionalType(global.generatedEs2panda._CreateTSConditionalType(global.context, passNode(checkType), passNode(extendsType), passNode(trueType), passNode(falseType)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONDITIONAL_TYPE) + result.setChildrenParentPtr() + return result + } + static updateTSConditionalType(original?: TSConditionalType, checkType?: Expression, extendsType?: Expression, trueType?: Expression, falseType?: Expression): TSConditionalType { + const result: TSConditionalType = new TSConditionalType(global.generatedEs2panda._UpdateTSConditionalType(global.context, passNode(original), passNode(checkType), passNode(extendsType), passNode(trueType), passNode(falseType)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONDITIONAL_TYPE) + result.setChildrenParentPtr() + return result + } + get checkType(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSConditionalTypeCheckTypeConst(global.context, this.peer)) + } + get extendsType(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSConditionalTypeExtendsTypeConst(global.context, this.peer)) + } + get trueType(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSConditionalTypeTrueTypeConst(global.context, this.peer)) + } + get falseType(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSConditionalTypeFalseTypeConst(global.context, this.peer)) + } + protected readonly brandTSConditionalType: undefined +} +export function isTSConditionalType(node: object | undefined): node is TSConditionalType { + return node instanceof TSConditionalType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONDITIONAL_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONDITIONAL_TYPE, (peer: KNativePointer) => new TSConditionalType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONDITIONAL_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSConstructorType.ts b/ets1.2/libarkts/src/generated/peers/TSConstructorType.ts new file mode 100644 index 0000000000000000000000000000000000000000..b07f9d66f5cd06c5ce4d2c8ca85d622d106548e5 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSConstructorType.ts @@ -0,0 +1,74 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { FunctionSignature } from "./FunctionSignature" +import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" +import { TypeNode } from "./TypeNode" + +export class TSConstructorType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSConstructorType(signature: FunctionSignature | undefined, abstract: boolean): TSConstructorType { + const result: TSConstructorType = new TSConstructorType(global.generatedEs2panda._CreateTSConstructorType(global.context, passNode(signature), abstract), Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONSTRUCTOR_TYPE) + result.setChildrenParentPtr() + return result + } + static updateTSConstructorType(original: TSConstructorType | undefined, signature: FunctionSignature | undefined, abstract: boolean): TSConstructorType { + const result: TSConstructorType = new TSConstructorType(global.generatedEs2panda._UpdateTSConstructorType(global.context, passNode(original), passNode(signature), abstract), Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONSTRUCTOR_TYPE) + result.setChildrenParentPtr() + return result + } + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSConstructorTypeTypeParams(global.context, this.peer)) + } + get params(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._TSConstructorTypeParamsConst(global.context, this.peer)) + } + get returnType(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSConstructorTypeReturnType(global.context, this.peer)) + } + get abstract(): boolean { + return global.generatedEs2panda._TSConstructorTypeAbstractConst(global.context, this.peer) + } + protected readonly brandTSConstructorType: undefined +} +export function isTSConstructorType(node: object | undefined): node is TSConstructorType { + return node instanceof TSConstructorType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONSTRUCTOR_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONSTRUCTOR_TYPE, (peer: KNativePointer) => new TSConstructorType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONSTRUCTOR_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSEnumDeclaration.ts b/ets1.2/libarkts/src/generated/peers/TSEnumDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..ac9665a979b5c20a8b48ed6ae1c58b56f144abf1 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSEnumDeclaration.ts @@ -0,0 +1,113 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { ClassDefinition } from "./ClassDefinition" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Identifier } from "./Identifier" +import { TypeNode } from "./TypeNode" +import { TypedStatement } from "./TypedStatement" + +export class TSEnumDeclaration extends TypedStatement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create1TSEnumDeclaration(key: Identifier | undefined, members: readonly AstNode[], isConst: boolean, isStatic: boolean, isDeclare: boolean, typeNode?: TypeNode): TSEnumDeclaration { + const result: TSEnumDeclaration = new TSEnumDeclaration(global.generatedEs2panda._CreateTSEnumDeclaration1(global.context, passNode(key), passNodeArray(members), members.length, isConst, isStatic, isDeclare, passNode(typeNode)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION) + result.setChildrenParentPtr() + return result + } + static updateTSEnumDeclaration(original: TSEnumDeclaration | undefined, key: Identifier | undefined, members: readonly AstNode[], isConst: boolean, isStatic: boolean, isDeclare: boolean): TSEnumDeclaration { + const result: TSEnumDeclaration = new TSEnumDeclaration(global.generatedEs2panda._UpdateTSEnumDeclaration(global.context, passNode(original), passNode(key), passNodeArray(members), members.length, isConst, isStatic, isDeclare), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION) + result.setChildrenParentPtr() + return result + } + static update1TSEnumDeclaration(original: TSEnumDeclaration | undefined, key: Identifier | undefined, members: readonly AstNode[], isConst: boolean, isStatic: boolean, isDeclare: boolean, typeNode?: TypeNode): TSEnumDeclaration { + const result: TSEnumDeclaration = new TSEnumDeclaration(global.generatedEs2panda._UpdateTSEnumDeclaration1(global.context, passNode(original), passNode(key), passNodeArray(members), members.length, isConst, isStatic, isDeclare, passNode(typeNode)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION) + result.setChildrenParentPtr() + return result + } + get typeNodes(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSEnumDeclarationTypeNodes(global.context, this.peer)) + } + get key(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSEnumDeclarationKey(global.context, this.peer)) + } + get members(): readonly AstNode[] { + return unpackNodeArray(global.generatedEs2panda._TSEnumDeclarationMembersConst(global.context, this.peer)) + } + get internalName(): string { + return unpackString(global.generatedEs2panda._TSEnumDeclarationInternalNameConst(global.context, this.peer)) + } + /** @deprecated */ + setInternalName(internalName: string): this { + global.generatedEs2panda._TSEnumDeclarationSetInternalName(global.context, this.peer, internalName) + return this + } + get boxedClass(): ClassDefinition | undefined { + return unpackNode(global.generatedEs2panda._TSEnumDeclarationBoxedClassConst(global.context, this.peer)) + } + /** @deprecated */ + setBoxedClass(boxedClass?: ClassDefinition): this { + global.generatedEs2panda._TSEnumDeclarationSetBoxedClass(global.context, this.peer, passNode(boxedClass)) + return this + } + get isConst(): boolean { + return global.generatedEs2panda._TSEnumDeclarationIsConstConst(global.context, this.peer) + } + /** @deprecated */ + emplaceMembers(source?: AstNode): this { + global.generatedEs2panda._TSEnumDeclarationEmplaceMembers(global.context, this.peer, passNode(source)) + return this + } + /** @deprecated */ + clearMembers(): this { + global.generatedEs2panda._TSEnumDeclarationClearMembers(global.context, this.peer) + return this + } + /** @deprecated */ + setValueMembers(source: AstNode | undefined, index: number): this { + global.generatedEs2panda._TSEnumDeclarationSetValueMembers(global.context, this.peer, passNode(source), index) + return this + } + get membersForUpdate(): readonly AstNode[] { + return unpackNodeArray(global.generatedEs2panda._TSEnumDeclarationMembersForUpdate(global.context, this.peer)) + } + protected readonly brandTSEnumDeclaration: undefined +} +export function isTSEnumDeclaration(node: object | undefined): node is TSEnumDeclaration { + return node instanceof TSEnumDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION, (peer: KNativePointer) => new TSEnumDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSEnumMember.ts b/ets1.2/libarkts/src/generated/peers/TSEnumMember.ts new file mode 100644 index 0000000000000000000000000000000000000000..db8ba6cfd0504f9fedcc75a4412341aa6d48ca9d --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSEnumMember.ts @@ -0,0 +1,77 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Statement } from "./Statement" + +export class TSEnumMember extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create1TSEnumMember(key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember { + const result: TSEnumMember = new TSEnumMember(global.generatedEs2panda._CreateTSEnumMember1(global.context, passNode(key), passNode(init), isGenerated), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER) + result.setChildrenParentPtr() + return result + } + static updateTSEnumMember(original?: TSEnumMember, key?: Expression, init?: Expression): TSEnumMember { + const result: TSEnumMember = new TSEnumMember(global.generatedEs2panda._UpdateTSEnumMember(global.context, passNode(original), passNode(key), passNode(init)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER) + result.setChildrenParentPtr() + return result + } + static update1TSEnumMember(original: TSEnumMember | undefined, key: Expression | undefined, init: Expression | undefined, isGenerated: boolean): TSEnumMember { + const result: TSEnumMember = new TSEnumMember(global.generatedEs2panda._UpdateTSEnumMember1(global.context, passNode(original), passNode(key), passNode(init), isGenerated), Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER) + result.setChildrenParentPtr() + return result + } + get key(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSEnumMemberKey(global.context, this.peer)) + } + get init(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSEnumMemberInit(global.context, this.peer)) + } + get isGenerated(): boolean { + return global.generatedEs2panda._TSEnumMemberIsGeneratedConst(global.context, this.peer) + } + get name(): string { + return unpackString(global.generatedEs2panda._TSEnumMemberNameConst(global.context, this.peer)) + } + protected readonly brandTSEnumMember: undefined +} +export function isTSEnumMember(node: object | undefined): node is TSEnumMember { + return node instanceof TSEnumMember +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER, (peer: KNativePointer) => new TSEnumMember(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSExternalModuleReference.ts b/ets1.2/libarkts/src/generated/peers/TSExternalModuleReference.ts new file mode 100644 index 0000000000000000000000000000000000000000..105c01bc22e60369e7d998bca021afb1e438e940 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSExternalModuleReference.ts @@ -0,0 +1,62 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class TSExternalModuleReference extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSExternalModuleReference(expr?: Expression): TSExternalModuleReference { + const result: TSExternalModuleReference = new TSExternalModuleReference(global.generatedEs2panda._CreateTSExternalModuleReference(global.context, passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_EXTERNAL_MODULE_REFERENCE) + result.setChildrenParentPtr() + return result + } + static updateTSExternalModuleReference(original?: TSExternalModuleReference, expr?: Expression): TSExternalModuleReference { + const result: TSExternalModuleReference = new TSExternalModuleReference(global.generatedEs2panda._UpdateTSExternalModuleReference(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_EXTERNAL_MODULE_REFERENCE) + result.setChildrenParentPtr() + return result + } + get expr(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSExternalModuleReferenceExprConst(global.context, this.peer)) + } + protected readonly brandTSExternalModuleReference: undefined +} +export function isTSExternalModuleReference(node: object | undefined): node is TSExternalModuleReference { + return node instanceof TSExternalModuleReference +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_EXTERNAL_MODULE_REFERENCE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_EXTERNAL_MODULE_REFERENCE, (peer: KNativePointer) => new TSExternalModuleReference(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_EXTERNAL_MODULE_REFERENCE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSFunctionType.ts b/ets1.2/libarkts/src/generated/peers/TSFunctionType.ts new file mode 100644 index 0000000000000000000000000000000000000000..b0a2674a456c4db307121cc85e03b261e695f19d --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSFunctionType.ts @@ -0,0 +1,76 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { FunctionSignature } from "./FunctionSignature" +import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" +import { TypeNode } from "./TypeNode" + +export class TSFunctionType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSFunctionType(signature?: FunctionSignature): TSFunctionType { + const result: TSFunctionType = new TSFunctionType(global.generatedEs2panda._CreateTSFunctionType(global.context, passNode(signature)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_FUNCTION_TYPE) + result.setChildrenParentPtr() + return result + } + static updateTSFunctionType(original?: TSFunctionType, signature?: FunctionSignature): TSFunctionType { + const result: TSFunctionType = new TSFunctionType(global.generatedEs2panda._UpdateTSFunctionType(global.context, passNode(original), passNode(signature)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_FUNCTION_TYPE) + result.setChildrenParentPtr() + return result + } + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSFunctionTypeTypeParams(global.context, this.peer)) + } + get params(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._TSFunctionTypeParamsConst(global.context, this.peer)) + } + get returnType(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSFunctionTypeReturnType(global.context, this.peer)) + } + /** @deprecated */ + setNullable(nullable: boolean): this { + global.generatedEs2panda._TSFunctionTypeSetNullable(global.context, this.peer, nullable) + return this + } + protected readonly brandTSFunctionType: undefined +} +export function isTSFunctionType(node: object | undefined): node is TSFunctionType { + return node instanceof TSFunctionType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_FUNCTION_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_FUNCTION_TYPE, (peer: KNativePointer) => new TSFunctionType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_FUNCTION_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts b/ets1.2/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..c6e05cfe387ad549bd480349d8609373f8a789f6 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSImportEqualsDeclaration.ts @@ -0,0 +1,70 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Identifier } from "./Identifier" +import { Statement } from "./Statement" + +export class TSImportEqualsDeclaration extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSImportEqualsDeclaration(id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration { + const result: TSImportEqualsDeclaration = new TSImportEqualsDeclaration(global.generatedEs2panda._CreateTSImportEqualsDeclaration(global.context, passNode(id), passNode(moduleReference), isExport), Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_EQUALS_DECLARATION) + result.setChildrenParentPtr() + return result + } + static updateTSImportEqualsDeclaration(original: TSImportEqualsDeclaration | undefined, id: Identifier | undefined, moduleReference: Expression | undefined, isExport: boolean): TSImportEqualsDeclaration { + const result: TSImportEqualsDeclaration = new TSImportEqualsDeclaration(global.generatedEs2panda._UpdateTSImportEqualsDeclaration(global.context, passNode(original), passNode(id), passNode(moduleReference), isExport), Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_EQUALS_DECLARATION) + result.setChildrenParentPtr() + return result + } + get id(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSImportEqualsDeclarationIdConst(global.context, this.peer)) + } + get moduleReference(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSImportEqualsDeclarationModuleReferenceConst(global.context, this.peer)) + } + get isExport(): boolean { + return global.generatedEs2panda._TSImportEqualsDeclarationIsExportConst(global.context, this.peer) + } + protected readonly brandTSImportEqualsDeclaration: undefined +} +export function isTSImportEqualsDeclaration(node: object | undefined): node is TSImportEqualsDeclaration { + return node instanceof TSImportEqualsDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_EQUALS_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_EQUALS_DECLARATION, (peer: KNativePointer) => new TSImportEqualsDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_EQUALS_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSImportType.ts b/ets1.2/libarkts/src/generated/peers/TSImportType.ts new file mode 100644 index 0000000000000000000000000000000000000000..597fcbfeac70d8473f7f88f1f4a0f22c31692c08 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSImportType.ts @@ -0,0 +1,73 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" +import { TypeNode } from "./TypeNode" + +export class TSImportType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSImportType(param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType { + const result: TSImportType = new TSImportType(global.generatedEs2panda._CreateTSImportType(global.context, passNode(param), passNode(typeParams), passNode(qualifier), isTypeof), Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_TYPE) + result.setChildrenParentPtr() + return result + } + static updateTSImportType(original: TSImportType | undefined, param: Expression | undefined, typeParams: TSTypeParameterInstantiation | undefined, qualifier: Expression | undefined, isTypeof: boolean): TSImportType { + const result: TSImportType = new TSImportType(global.generatedEs2panda._UpdateTSImportType(global.context, passNode(original), passNode(param), passNode(typeParams), passNode(qualifier), isTypeof), Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_TYPE) + result.setChildrenParentPtr() + return result + } + get param(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSImportTypeParamConst(global.context, this.peer)) + } + get typeParams(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._TSImportTypeTypeParamsConst(global.context, this.peer)) + } + get qualifier(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSImportTypeQualifierConst(global.context, this.peer)) + } + get isTypeof(): boolean { + return global.generatedEs2panda._TSImportTypeIsTypeofConst(global.context, this.peer) + } + protected readonly brandTSImportType: undefined +} +export function isTSImportType(node: object | undefined): node is TSImportType { + return node instanceof TSImportType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_TYPE, (peer: KNativePointer) => new TSImportType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSIndexSignature.ts b/ets1.2/libarkts/src/generated/peers/TSIndexSignature.ts new file mode 100644 index 0000000000000000000000000000000000000000..086f13ce66267341321d8b2985b5ee5c6f84adf4 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSIndexSignature.ts @@ -0,0 +1,74 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaTSIndexSignatureKind } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" +import { TypedAstNode } from "./TypedAstNode" + +export class TSIndexSignature extends TypedAstNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSIndexSignature(param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: boolean): TSIndexSignature { + const result: TSIndexSignature = new TSIndexSignature(global.generatedEs2panda._CreateTSIndexSignature(global.context, passNode(param), passNode(typeAnnotation), readonly_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEX_SIGNATURE) + result.setChildrenParentPtr() + return result + } + static updateTSIndexSignature(original: TSIndexSignature | undefined, param: Expression | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: boolean): TSIndexSignature { + const result: TSIndexSignature = new TSIndexSignature(global.generatedEs2panda._UpdateTSIndexSignature(global.context, passNode(original), passNode(param), passNode(typeAnnotation), readonly_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEX_SIGNATURE) + result.setChildrenParentPtr() + return result + } + get param(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSIndexSignatureParamConst(global.context, this.peer)) + } + get typeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSIndexSignatureTypeAnnotationConst(global.context, this.peer)) + } + get readonly(): boolean { + return global.generatedEs2panda._TSIndexSignatureReadonlyConst(global.context, this.peer) + } + get kind(): Es2pandaTSIndexSignatureKind { + return global.generatedEs2panda._TSIndexSignatureKindConst(global.context, this.peer) + } + protected readonly brandTSIndexSignature: undefined +} +export function isTSIndexSignature(node: object | undefined): node is TSIndexSignature { + return node instanceof TSIndexSignature +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEX_SIGNATURE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEX_SIGNATURE, (peer: KNativePointer) => new TSIndexSignature(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEX_SIGNATURE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSIndexedAccessType.ts b/ets1.2/libarkts/src/generated/peers/TSIndexedAccessType.ts new file mode 100644 index 0000000000000000000000000000000000000000..a72141a4633af29e5e4825f0bfcd404458194355 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSIndexedAccessType.ts @@ -0,0 +1,65 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSIndexedAccessType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSIndexedAccessType(objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType { + const result: TSIndexedAccessType = new TSIndexedAccessType(global.generatedEs2panda._CreateTSIndexedAccessType(global.context, passNode(objectType), passNode(indexType)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEXED_ACCESS_TYPE) + result.setChildrenParentPtr() + return result + } + static updateTSIndexedAccessType(original?: TSIndexedAccessType, objectType?: TypeNode, indexType?: TypeNode): TSIndexedAccessType { + const result: TSIndexedAccessType = new TSIndexedAccessType(global.generatedEs2panda._UpdateTSIndexedAccessType(global.context, passNode(original), passNode(objectType), passNode(indexType)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEXED_ACCESS_TYPE) + result.setChildrenParentPtr() + return result + } + get objectType(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSIndexedAccessTypeObjectTypeConst(global.context, this.peer)) + } + get indexType(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSIndexedAccessTypeIndexTypeConst(global.context, this.peer)) + } + protected readonly brandTSIndexedAccessType: undefined +} +export function isTSIndexedAccessType(node: object | undefined): node is TSIndexedAccessType { + return node instanceof TSIndexedAccessType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEXED_ACCESS_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEXED_ACCESS_TYPE, (peer: KNativePointer) => new TSIndexedAccessType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEXED_ACCESS_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSInferType.ts b/ets1.2/libarkts/src/generated/peers/TSInferType.ts new file mode 100644 index 0000000000000000000000000000000000000000..bcdffc898fd17b155dba31979fb74981f7525c8b --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSInferType.ts @@ -0,0 +1,63 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TSTypeParameter } from "./TSTypeParameter" +import { TypeNode } from "./TypeNode" + +export class TSInferType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSInferType(typeParam?: TSTypeParameter): TSInferType { + const result: TSInferType = new TSInferType(global.generatedEs2panda._CreateTSInferType(global.context, passNode(typeParam)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INFER_TYPE) + result.setChildrenParentPtr() + return result + } + static updateTSInferType(original?: TSInferType, typeParam?: TSTypeParameter): TSInferType { + const result: TSInferType = new TSInferType(global.generatedEs2panda._UpdateTSInferType(global.context, passNode(original), passNode(typeParam)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INFER_TYPE) + result.setChildrenParentPtr() + return result + } + get typeParam(): TSTypeParameter | undefined { + return unpackNode(global.generatedEs2panda._TSInferTypeTypeParamConst(global.context, this.peer)) + } + protected readonly brandTSInferType: undefined +} +export function isTSInferType(node: object | undefined): node is TSInferType { + return node instanceof TSInferType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INFER_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INFER_TYPE, (peer: KNativePointer) => new TSInferType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_INFER_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSInterfaceBody.ts b/ets1.2/libarkts/src/generated/peers/TSInterfaceBody.ts new file mode 100644 index 0000000000000000000000000000000000000000..ab9f866a7cc5e1d22142bf862cc43d32df3e3065 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSInterfaceBody.ts @@ -0,0 +1,62 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class TSInterfaceBody extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSInterfaceBody(body: readonly AstNode[]): TSInterfaceBody { + const result: TSInterfaceBody = new TSInterfaceBody(global.generatedEs2panda._CreateTSInterfaceBody(global.context, passNodeArray(body), body.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY) + result.setChildrenParentPtr() + return result + } + static updateTSInterfaceBody(original: TSInterfaceBody | undefined, body: readonly AstNode[]): TSInterfaceBody { + const result: TSInterfaceBody = new TSInterfaceBody(global.generatedEs2panda._UpdateTSInterfaceBody(global.context, passNode(original), passNodeArray(body), body.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY) + result.setChildrenParentPtr() + return result + } + get body(): readonly AstNode[] { + return unpackNodeArray(global.generatedEs2panda._TSInterfaceBodyBody(global.context, this.peer)) + } + protected readonly brandTSInterfaceBody: undefined +} +export function isTSInterfaceBody(node: object | undefined): node is TSInterfaceBody { + return node instanceof TSInterfaceBody +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY, (peer: KNativePointer) => new TSInterfaceBody(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSInterfaceDeclaration.ts b/ets1.2/libarkts/src/generated/peers/TSInterfaceDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..7caedfd252a8ccb6b72c4adc3a5cb4edab689de3 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSInterfaceDeclaration.ts @@ -0,0 +1,161 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotationUsage } from "./AnnotationUsage" +import { ClassDeclaration } from "./ClassDeclaration" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaModifierFlags } from "./../Es2pandaEnums" +import { Identifier } from "./Identifier" +import { SrcDumper } from "./SrcDumper" +import { TSInterfaceBody } from "./TSInterfaceBody" +import { TSInterfaceHeritage } from "./TSInterfaceHeritage" +import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" +import { TypedStatement } from "./TypedStatement" + +export class TSInterfaceDeclaration extends TypedStatement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSInterfaceDeclaration(_extends: readonly TSInterfaceHeritage[], id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean, modifierFlags?: Es2pandaModifierFlags): TSInterfaceDeclaration { + const result: TSInterfaceDeclaration = new TSInterfaceDeclaration(global.generatedEs2panda._CreateTSInterfaceDeclaration(global.context, passNodeArray(_extends), _extends.length, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION) + if (modifierFlags) + { + result.modifierFlags = modifierFlags + } + result.setChildrenParentPtr() + return result + } + static updateTSInterfaceDeclaration(original: TSInterfaceDeclaration | undefined, _extends: readonly TSInterfaceHeritage[], id: AstNode | undefined, typeParams: AstNode | undefined, body: AstNode | undefined, isStatic: boolean, isExternal: boolean, modifierFlags?: Es2pandaModifierFlags): TSInterfaceDeclaration { + const result: TSInterfaceDeclaration = new TSInterfaceDeclaration(global.generatedEs2panda._UpdateTSInterfaceDeclaration(global.context, passNode(original), passNodeArray(_extends), _extends.length, passNode(id), passNode(typeParams), passNode(body), isStatic, isExternal), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION) + if (modifierFlags) + { + result.modifierFlags = modifierFlags + } + result.setChildrenParentPtr() + return result + } + get body(): TSInterfaceBody | undefined { + return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationBody(global.context, this.peer)) + } + get id(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationId(global.context, this.peer)) + } + get internalName(): string { + return unpackString(global.generatedEs2panda._TSInterfaceDeclarationInternalNameConst(global.context, this.peer)) + } + /** @deprecated */ + setInternalName(internalName: string): this { + global.generatedEs2panda._TSInterfaceDeclarationSetInternalName(global.context, this.peer, internalName) + return this + } + get isStatic(): boolean { + return global.generatedEs2panda._TSInterfaceDeclarationIsStaticConst(global.context, this.peer) + } + get isFromExternal(): boolean { + return global.generatedEs2panda._TSInterfaceDeclarationIsFromExternalConst(global.context, this.peer) + } + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationTypeParams(global.context, this.peer)) + } + get extends(): readonly TSInterfaceHeritage[] { + return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationExtends(global.context, this.peer)) + } + get extendsForUpdate(): readonly TSInterfaceHeritage[] { + return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationExtendsForUpdate(global.context, this.peer)) + } + get anonClass(): ClassDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSInterfaceDeclarationGetAnonClass(global.context, this.peer)) + } + /** @deprecated */ + setAnonClass(anonClass?: ClassDeclaration): this { + global.generatedEs2panda._TSInterfaceDeclarationSetAnonClass(global.context, this.peer, passNode(anonClass)) + return this + } + /** @deprecated */ + emplaceExtends(_extends?: TSInterfaceHeritage): this { + global.generatedEs2panda._TSInterfaceDeclarationEmplaceExtends(global.context, this.peer, passNode(_extends)) + return this + } + /** @deprecated */ + clearExtends(): this { + global.generatedEs2panda._TSInterfaceDeclarationClearExtends(global.context, this.peer) + return this + } + /** @deprecated */ + setValueExtends(_extends: TSInterfaceHeritage | undefined, index: number): this { + global.generatedEs2panda._TSInterfaceDeclarationSetValueExtends(global.context, this.peer, passNode(_extends), index) + return this + } + get hasAnnotations(): boolean { + return global.generatedEs2panda._TSInterfaceDeclarationHasAnnotationsConst(global.context, this.peer) + } + /** @deprecated */ + emplaceAnnotation(source?: AnnotationUsage): this { + global.generatedEs2panda._TSInterfaceDeclarationEmplaceAnnotation(global.context, this.peer, passNode(source)) + return this + } + /** @deprecated */ + clearAnnotations(): this { + global.generatedEs2panda._TSInterfaceDeclarationClearAnnotations(global.context, this.peer) + return this + } + /** @deprecated */ + dumpAnnotations(dumper?: SrcDumper): this { + global.generatedEs2panda._TSInterfaceDeclarationDumpAnnotationsConst(global.context, this.peer, passNode(dumper)) + return this + } + get annotationsForUpdate(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationAnnotationsForUpdate(global.context, this.peer)) + } + get annotations(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._TSInterfaceDeclarationAnnotations(global.context, this.peer)) + } + /** @deprecated */ + setAnnotations(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._TSInterfaceDeclarationSetAnnotations(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + /** @deprecated */ + setAnnotations1(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._TSInterfaceDeclarationSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + protected readonly brandTSInterfaceDeclaration: undefined +} +export function isTSInterfaceDeclaration(node: object | undefined): node is TSInterfaceDeclaration { + return node instanceof TSInterfaceDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION, (peer: KNativePointer) => new TSInterfaceDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSInterfaceHeritage.ts b/ets1.2/libarkts/src/generated/peers/TSInterfaceHeritage.ts new file mode 100644 index 0000000000000000000000000000000000000000..80c68978d76401933d17ec8b2d830c29e0f01d8b --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSInterfaceHeritage.ts @@ -0,0 +1,63 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" + +export class TSInterfaceHeritage extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSInterfaceHeritage(expr?: TypeNode): TSInterfaceHeritage { + const result: TSInterfaceHeritage = new TSInterfaceHeritage(global.generatedEs2panda._CreateTSInterfaceHeritage(global.context, passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_HERITAGE) + result.setChildrenParentPtr() + return result + } + static updateTSInterfaceHeritage(original?: TSInterfaceHeritage, expr?: TypeNode): TSInterfaceHeritage { + const result: TSInterfaceHeritage = new TSInterfaceHeritage(global.generatedEs2panda._UpdateTSInterfaceHeritage(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_HERITAGE) + result.setChildrenParentPtr() + return result + } + get expr(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSInterfaceHeritageExpr(global.context, this.peer)) + } + protected readonly brandTSInterfaceHeritage: undefined +} +export function isTSInterfaceHeritage(node: object | undefined): node is TSInterfaceHeritage { + return node instanceof TSInterfaceHeritage +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_HERITAGE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_HERITAGE, (peer: KNativePointer) => new TSInterfaceHeritage(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_HERITAGE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSIntersectionType.ts b/ets1.2/libarkts/src/generated/peers/TSIntersectionType.ts new file mode 100644 index 0000000000000000000000000000000000000000..77016132fc6f3e4a18ebdfff5be52248c30cce85 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSIntersectionType.ts @@ -0,0 +1,63 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" + +export class TSIntersectionType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSIntersectionType(types: readonly Expression[]): TSIntersectionType { + const result: TSIntersectionType = new TSIntersectionType(global.generatedEs2panda._CreateTSIntersectionType(global.context, passNodeArray(types), types.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERSECTION_TYPE) + result.setChildrenParentPtr() + return result + } + static updateTSIntersectionType(original: TSIntersectionType | undefined, types: readonly Expression[]): TSIntersectionType { + const result: TSIntersectionType = new TSIntersectionType(global.generatedEs2panda._UpdateTSIntersectionType(global.context, passNode(original), passNodeArray(types), types.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERSECTION_TYPE) + result.setChildrenParentPtr() + return result + } + get types(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._TSIntersectionTypeTypesConst(global.context, this.peer)) + } + protected readonly brandTSIntersectionType: undefined +} +export function isTSIntersectionType(node: object | undefined): node is TSIntersectionType { + return node instanceof TSIntersectionType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERSECTION_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERSECTION_TYPE, (peer: KNativePointer) => new TSIntersectionType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERSECTION_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSLiteralType.ts b/ets1.2/libarkts/src/generated/peers/TSLiteralType.ts new file mode 100644 index 0000000000000000000000000000000000000000..52d3042fbc14cfb05fc65f0325aa306375b38272 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSLiteralType.ts @@ -0,0 +1,63 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" + +export class TSLiteralType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSLiteralType(literal?: Expression): TSLiteralType { + const result: TSLiteralType = new TSLiteralType(global.generatedEs2panda._CreateTSLiteralType(global.context, passNode(literal)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_LITERAL_TYPE) + result.setChildrenParentPtr() + return result + } + static updateTSLiteralType(original?: TSLiteralType, literal?: Expression): TSLiteralType { + const result: TSLiteralType = new TSLiteralType(global.generatedEs2panda._UpdateTSLiteralType(global.context, passNode(original), passNode(literal)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_LITERAL_TYPE) + result.setChildrenParentPtr() + return result + } + get literal(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSLiteralTypeLiteralConst(global.context, this.peer)) + } + protected readonly brandTSLiteralType: undefined +} +export function isTSLiteralType(node: object | undefined): node is TSLiteralType { + return node instanceof TSLiteralType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_LITERAL_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_LITERAL_TYPE, (peer: KNativePointer) => new TSLiteralType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_LITERAL_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSMappedType.ts b/ets1.2/libarkts/src/generated/peers/TSMappedType.ts new file mode 100644 index 0000000000000000000000000000000000000000..8ac038c73f4ba1a1e0fe882ff2d97a4d62afc087 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSMappedType.ts @@ -0,0 +1,73 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaMappedOption } from "./../Es2pandaEnums" +import { TSTypeParameter } from "./TSTypeParameter" +import { TypeNode } from "./TypeNode" + +export class TSMappedType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSMappedType(typeParameter: TSTypeParameter | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType { + const result: TSMappedType = new TSMappedType(global.generatedEs2panda._CreateTSMappedType(global.context, passNode(typeParameter), passNode(typeAnnotation), readonly_arg, optional_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_MAPPED_TYPE) + result.setChildrenParentPtr() + return result + } + static updateTSMappedType(original: TSMappedType | undefined, typeParameter: TSTypeParameter | undefined, typeAnnotation: TypeNode | undefined, readonly_arg: Es2pandaMappedOption, optional_arg: Es2pandaMappedOption): TSMappedType { + const result: TSMappedType = new TSMappedType(global.generatedEs2panda._UpdateTSMappedType(global.context, passNode(original), passNode(typeParameter), passNode(typeAnnotation), readonly_arg, optional_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_MAPPED_TYPE) + result.setChildrenParentPtr() + return result + } + get typeParameter(): TSTypeParameter | undefined { + return unpackNode(global.generatedEs2panda._TSMappedTypeTypeParameter(global.context, this.peer)) + } + get typeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSMappedTypeTypeAnnotation(global.context, this.peer)) + } + get readonly(): Es2pandaMappedOption { + return global.generatedEs2panda._TSMappedTypeReadonly(global.context, this.peer) + } + get optional(): Es2pandaMappedOption { + return global.generatedEs2panda._TSMappedTypeOptional(global.context, this.peer) + } + protected readonly brandTSMappedType: undefined +} +export function isTSMappedType(node: object | undefined): node is TSMappedType { + return node instanceof TSMappedType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_MAPPED_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_MAPPED_TYPE, (peer: KNativePointer) => new TSMappedType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_MAPPED_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSMethodSignature.ts b/ets1.2/libarkts/src/generated/peers/TSMethodSignature.ts new file mode 100644 index 0000000000000000000000000000000000000000..f6cdfa5786db76fd6ab1b3e3f6379f2f00176853 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSMethodSignature.ts @@ -0,0 +1,80 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { FunctionSignature } from "./FunctionSignature" +import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" +import { TypeNode } from "./TypeNode" + +export class TSMethodSignature extends AstNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSMethodSignature(key: Expression | undefined, signature: FunctionSignature | undefined, computed: boolean, optional_arg: boolean): TSMethodSignature { + const result: TSMethodSignature = new TSMethodSignature(global.generatedEs2panda._CreateTSMethodSignature(global.context, passNode(key), passNode(signature), computed, optional_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_METHOD_SIGNATURE) + result.setChildrenParentPtr() + return result + } + static updateTSMethodSignature(original: TSMethodSignature | undefined, key: Expression | undefined, signature: FunctionSignature | undefined, computed: boolean, optional_arg: boolean): TSMethodSignature { + const result: TSMethodSignature = new TSMethodSignature(global.generatedEs2panda._UpdateTSMethodSignature(global.context, passNode(original), passNode(key), passNode(signature), computed, optional_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_METHOD_SIGNATURE) + result.setChildrenParentPtr() + return result + } + get key(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSMethodSignatureKey(global.context, this.peer)) + } + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSMethodSignatureTypeParams(global.context, this.peer)) + } + get params(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._TSMethodSignatureParamsConst(global.context, this.peer)) + } + get returnTypeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSMethodSignatureReturnTypeAnnotation(global.context, this.peer)) + } + get computed(): boolean { + return global.generatedEs2panda._TSMethodSignatureComputedConst(global.context, this.peer) + } + get optional(): boolean { + return global.generatedEs2panda._TSMethodSignatureOptionalConst(global.context, this.peer) + } + protected readonly brandTSMethodSignature: undefined +} +export function isTSMethodSignature(node: object | undefined): node is TSMethodSignature { + return node instanceof TSMethodSignature +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_METHOD_SIGNATURE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_METHOD_SIGNATURE, (peer: KNativePointer) => new TSMethodSignature(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_METHOD_SIGNATURE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSModuleBlock.ts b/ets1.2/libarkts/src/generated/peers/TSModuleBlock.ts new file mode 100644 index 0000000000000000000000000000000000000000..181fcf35bab7be67047eccbd23a140302ea7726c --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSModuleBlock.ts @@ -0,0 +1,62 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Statement } from "./Statement" + +export class TSModuleBlock extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSModuleBlock(statements: readonly Statement[]): TSModuleBlock { + const result: TSModuleBlock = new TSModuleBlock(global.generatedEs2panda._CreateTSModuleBlock(global.context, passNodeArray(statements), statements.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_BLOCK) + result.setChildrenParentPtr() + return result + } + static updateTSModuleBlock(original: TSModuleBlock | undefined, statements: readonly Statement[]): TSModuleBlock { + const result: TSModuleBlock = new TSModuleBlock(global.generatedEs2panda._UpdateTSModuleBlock(global.context, passNode(original), passNodeArray(statements), statements.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_BLOCK) + result.setChildrenParentPtr() + return result + } + get statements(): readonly Statement[] { + return unpackNodeArray(global.generatedEs2panda._TSModuleBlockStatementsConst(global.context, this.peer)) + } + protected readonly brandTSModuleBlock: undefined +} +export function isTSModuleBlock(node: object | undefined): node is TSModuleBlock { + return node instanceof TSModuleBlock +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_BLOCK)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_BLOCK, (peer: KNativePointer) => new TSModuleBlock(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_BLOCK)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSModuleDeclaration.ts b/ets1.2/libarkts/src/generated/peers/TSModuleDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..5f4e64f97e63f4d8a1f9018b1f334c09478ae19f --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSModuleDeclaration.ts @@ -0,0 +1,72 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Statement } from "./Statement" + +export class TSModuleDeclaration extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSModuleDeclaration(name: Expression | undefined, body: Statement | undefined, declare: boolean, _global: boolean): TSModuleDeclaration { + const result: TSModuleDeclaration = new TSModuleDeclaration(global.generatedEs2panda._CreateTSModuleDeclaration(global.context, passNode(name), passNode(body), declare, _global), Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_DECLARATION) + result.setChildrenParentPtr() + return result + } + static updateTSModuleDeclaration(original: TSModuleDeclaration | undefined, name: Expression | undefined, body: Statement | undefined, declare: boolean, _global: boolean): TSModuleDeclaration { + const result: TSModuleDeclaration = new TSModuleDeclaration(global.generatedEs2panda._UpdateTSModuleDeclaration(global.context, passNode(original), passNode(name), passNode(body), declare, _global), Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_DECLARATION) + result.setChildrenParentPtr() + return result + } + get name(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSModuleDeclarationNameConst(global.context, this.peer)) + } + get body(): Statement | undefined { + return unpackNode(global.generatedEs2panda._TSModuleDeclarationBodyConst(global.context, this.peer)) + } + get global(): boolean { + return global.generatedEs2panda._TSModuleDeclarationGlobalConst(global.context, this.peer) + } + get isExternalOrAmbient(): boolean { + return global.generatedEs2panda._TSModuleDeclarationIsExternalOrAmbientConst(global.context, this.peer) + } + protected readonly brandTSModuleDeclaration: undefined +} +export function isTSModuleDeclaration(node: object | undefined): node is TSModuleDeclaration { + return node instanceof TSModuleDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_DECLARATION, (peer: KNativePointer) => new TSModuleDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSNamedTupleMember.ts b/ets1.2/libarkts/src/generated/peers/TSNamedTupleMember.ts new file mode 100644 index 0000000000000000000000000000000000000000..3a0605ad5c44c64036747e7a0ed48e4cf6914d75 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSNamedTupleMember.ts @@ -0,0 +1,69 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" + +export class TSNamedTupleMember extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSNamedTupleMember(label: Expression | undefined, elementType: TypeNode | undefined, optional_arg: boolean): TSNamedTupleMember { + const result: TSNamedTupleMember = new TSNamedTupleMember(global.generatedEs2panda._CreateTSNamedTupleMember(global.context, passNode(label), passNode(elementType), optional_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NAMED_TUPLE_MEMBER) + result.setChildrenParentPtr() + return result + } + static updateTSNamedTupleMember(original: TSNamedTupleMember | undefined, label: Expression | undefined, elementType: TypeNode | undefined, optional_arg: boolean): TSNamedTupleMember { + const result: TSNamedTupleMember = new TSNamedTupleMember(global.generatedEs2panda._UpdateTSNamedTupleMember(global.context, passNode(original), passNode(label), passNode(elementType), optional_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NAMED_TUPLE_MEMBER) + result.setChildrenParentPtr() + return result + } + get label(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSNamedTupleMemberLabelConst(global.context, this.peer)) + } + get elementType(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSNamedTupleMemberElementType(global.context, this.peer)) + } + get isOptional(): boolean { + return global.generatedEs2panda._TSNamedTupleMemberIsOptionalConst(global.context, this.peer) + } + protected readonly brandTSNamedTupleMember: undefined +} +export function isTSNamedTupleMember(node: object | undefined): node is TSNamedTupleMember { + return node instanceof TSNamedTupleMember +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NAMED_TUPLE_MEMBER)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NAMED_TUPLE_MEMBER, (peer: KNativePointer) => new TSNamedTupleMember(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_NAMED_TUPLE_MEMBER)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSNeverKeyword.ts b/ets1.2/libarkts/src/generated/peers/TSNeverKeyword.ts new file mode 100644 index 0000000000000000000000000000000000000000..510fe11dfb1c3f42fdbd8cffa3c9468251f42a78 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSNeverKeyword.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSNeverKeyword extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSNeverKeyword(): TSNeverKeyword { + const result: TSNeverKeyword = new TSNeverKeyword(global.generatedEs2panda._CreateTSNeverKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NEVER_KEYWORD) + result.setChildrenParentPtr() + return result + } + static updateTSNeverKeyword(original?: TSNeverKeyword): TSNeverKeyword { + const result: TSNeverKeyword = new TSNeverKeyword(global.generatedEs2panda._UpdateTSNeverKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NEVER_KEYWORD) + result.setChildrenParentPtr() + return result + } + protected readonly brandTSNeverKeyword: undefined +} +export function isTSNeverKeyword(node: object | undefined): node is TSNeverKeyword { + return node instanceof TSNeverKeyword +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NEVER_KEYWORD)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NEVER_KEYWORD, (peer: KNativePointer) => new TSNeverKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_NEVER_KEYWORD)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSNonNullExpression.ts b/ets1.2/libarkts/src/generated/peers/TSNonNullExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..ce5902b24371aa71958dbb058999e1673e77e4aa --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSNonNullExpression.ts @@ -0,0 +1,67 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class TSNonNullExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSNonNullExpression(expr?: Expression): TSNonNullExpression { + const result: TSNonNullExpression = new TSNonNullExpression(global.generatedEs2panda._CreateTSNonNullExpression(global.context, passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NON_NULL_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateTSNonNullExpression(original?: TSNonNullExpression, expr?: Expression): TSNonNullExpression { + const result: TSNonNullExpression = new TSNonNullExpression(global.generatedEs2panda._UpdateTSNonNullExpression(global.context, passNode(original), passNode(expr)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NON_NULL_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get expr(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSNonNullExpressionExpr(global.context, this.peer)) + } + /** @deprecated */ + setExpr(expr?: Expression): this { + global.generatedEs2panda._TSNonNullExpressionSetExpr(global.context, this.peer, passNode(expr)) + return this + } + protected readonly brandTSNonNullExpression: undefined +} +export function isTSNonNullExpression(node: object | undefined): node is TSNonNullExpression { + return node instanceof TSNonNullExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NON_NULL_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NON_NULL_EXPRESSION, (peer: KNativePointer) => new TSNonNullExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_NON_NULL_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSNullKeyword.ts b/ets1.2/libarkts/src/generated/peers/TSNullKeyword.ts new file mode 100644 index 0000000000000000000000000000000000000000..80141b4aeb03fb0b40dc9bf7097317dc4627705a --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSNullKeyword.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSNullKeyword extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSNullKeyword(): TSNullKeyword { + const result: TSNullKeyword = new TSNullKeyword(global.generatedEs2panda._CreateTSNullKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NULL_KEYWORD) + result.setChildrenParentPtr() + return result + } + static updateTSNullKeyword(original?: TSNullKeyword): TSNullKeyword { + const result: TSNullKeyword = new TSNullKeyword(global.generatedEs2panda._UpdateTSNullKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NULL_KEYWORD) + result.setChildrenParentPtr() + return result + } + protected readonly brandTSNullKeyword: undefined +} +export function isTSNullKeyword(node: object | undefined): node is TSNullKeyword { + return node instanceof TSNullKeyword +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NULL_KEYWORD)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NULL_KEYWORD, (peer: KNativePointer) => new TSNullKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_NULL_KEYWORD)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSNumberKeyword.ts b/ets1.2/libarkts/src/generated/peers/TSNumberKeyword.ts new file mode 100644 index 0000000000000000000000000000000000000000..2560896b2c1ab17d9bd48146949c621a5f7b7067 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSNumberKeyword.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSNumberKeyword extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSNumberKeyword(): TSNumberKeyword { + const result: TSNumberKeyword = new TSNumberKeyword(global.generatedEs2panda._CreateTSNumberKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD) + result.setChildrenParentPtr() + return result + } + static updateTSNumberKeyword(original?: TSNumberKeyword): TSNumberKeyword { + const result: TSNumberKeyword = new TSNumberKeyword(global.generatedEs2panda._UpdateTSNumberKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD) + result.setChildrenParentPtr() + return result + } + protected readonly brandTSNumberKeyword: undefined +} +export function isTSNumberKeyword(node: object | undefined): node is TSNumberKeyword { + return node instanceof TSNumberKeyword +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD, (peer: KNativePointer) => new TSNumberKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSObjectKeyword.ts b/ets1.2/libarkts/src/generated/peers/TSObjectKeyword.ts new file mode 100644 index 0000000000000000000000000000000000000000..792b814c67e80aaf16438b767b4a1557b5725340 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSObjectKeyword.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSObjectKeyword extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSObjectKeyword(): TSObjectKeyword { + const result: TSObjectKeyword = new TSObjectKeyword(global.generatedEs2panda._CreateTSObjectKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD) + result.setChildrenParentPtr() + return result + } + static updateTSObjectKeyword(original?: TSObjectKeyword): TSObjectKeyword { + const result: TSObjectKeyword = new TSObjectKeyword(global.generatedEs2panda._UpdateTSObjectKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD) + result.setChildrenParentPtr() + return result + } + protected readonly brandTSObjectKeyword: undefined +} +export function isTSObjectKeyword(node: object | undefined): node is TSObjectKeyword { + return node instanceof TSObjectKeyword +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD, (peer: KNativePointer) => new TSObjectKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSParameterProperty.ts b/ets1.2/libarkts/src/generated/peers/TSParameterProperty.ts new file mode 100644 index 0000000000000000000000000000000000000000..98b91024a5c29e32a818fab4ecffff08ad13131d --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSParameterProperty.ts @@ -0,0 +1,75 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAccessibilityOption } from "./../Es2pandaEnums" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class TSParameterProperty extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSParameterProperty(accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty { + const result: TSParameterProperty = new TSParameterProperty(global.generatedEs2panda._CreateTSParameterProperty(global.context, accessibility, passNode(parameter), readonly_arg, isStatic, isExport), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY) + result.setChildrenParentPtr() + return result + } + static updateTSParameterProperty(original: TSParameterProperty | undefined, accessibility: Es2pandaAccessibilityOption, parameter: Expression | undefined, readonly_arg: boolean, isStatic: boolean, isExport: boolean): TSParameterProperty { + const result: TSParameterProperty = new TSParameterProperty(global.generatedEs2panda._UpdateTSParameterProperty(global.context, passNode(original), accessibility, passNode(parameter), readonly_arg, isStatic, isExport), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY) + result.setChildrenParentPtr() + return result + } + get accessibility(): Es2pandaAccessibilityOption { + return global.generatedEs2panda._TSParameterPropertyAccessibilityConst(global.context, this.peer) + } + get readonly(): boolean { + return global.generatedEs2panda._TSParameterPropertyReadonlyConst(global.context, this.peer) + } + get isStatic(): boolean { + return global.generatedEs2panda._TSParameterPropertyIsStaticConst(global.context, this.peer) + } + get isExport(): boolean { + return global.generatedEs2panda._TSParameterPropertyIsExportConst(global.context, this.peer) + } + get parameter(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSParameterPropertyParameterConst(global.context, this.peer)) + } + protected readonly brandTSParameterProperty: undefined +} +export function isTSParameterProperty(node: object | undefined): node is TSParameterProperty { + return node instanceof TSParameterProperty +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY, (peer: KNativePointer) => new TSParameterProperty(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSParenthesizedType.ts b/ets1.2/libarkts/src/generated/peers/TSParenthesizedType.ts new file mode 100644 index 0000000000000000000000000000000000000000..fbeac852a52bf31e0b9edb10f415348cc1424f40 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSParenthesizedType.ts @@ -0,0 +1,63 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" + +export class TSParenthesizedType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSParenthesizedType(type?: TypeNode): TSParenthesizedType { + const result: TSParenthesizedType = new TSParenthesizedType(global.generatedEs2panda._CreateTSParenthesizedType(global.context, passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE) + result.setChildrenParentPtr() + return result + } + static updateTSParenthesizedType(original?: TSParenthesizedType, type?: TypeNode): TSParenthesizedType { + const result: TSParenthesizedType = new TSParenthesizedType(global.generatedEs2panda._UpdateTSParenthesizedType(global.context, passNode(original), passNode(type)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE) + result.setChildrenParentPtr() + return result + } + get type(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSParenthesizedTypeTypeConst(global.context, this.peer)) + } + protected readonly brandTSParenthesizedType: undefined +} +export function isTSParenthesizedType(node: object | undefined): node is TSParenthesizedType { + return node instanceof TSParenthesizedType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE, (peer: KNativePointer) => new TSParenthesizedType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSPropertySignature.ts b/ets1.2/libarkts/src/generated/peers/TSPropertySignature.ts new file mode 100644 index 0000000000000000000000000000000000000000..c145d4d2a716d1a0c00549e0553d7b920228c127 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSPropertySignature.ts @@ -0,0 +1,81 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotatedAstNode } from "./AnnotatedAstNode" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" + +export class TSPropertySignature extends AnnotatedAstNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSPropertySignature(key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature { + const result: TSPropertySignature = new TSPropertySignature(global.generatedEs2panda._CreateTSPropertySignature(global.context, passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE) + result.setChildrenParentPtr() + return result + } + static updateTSPropertySignature(original: TSPropertySignature | undefined, key: Expression | undefined, typeAnnotation: TypeNode | undefined, computed: boolean, optional_arg: boolean, readonly_arg: boolean): TSPropertySignature { + const result: TSPropertySignature = new TSPropertySignature(global.generatedEs2panda._UpdateTSPropertySignature(global.context, passNode(original), passNode(key), passNode(typeAnnotation), computed, optional_arg, readonly_arg), Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE) + result.setChildrenParentPtr() + return result + } + get key(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSPropertySignatureKey(global.context, this.peer)) + } + get computed(): boolean { + return global.generatedEs2panda._TSPropertySignatureComputedConst(global.context, this.peer) + } + get optional(): boolean { + return global.generatedEs2panda._TSPropertySignatureOptionalConst(global.context, this.peer) + } + get readonly(): boolean { + return global.generatedEs2panda._TSPropertySignatureReadonlyConst(global.context, this.peer) + } + get typeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSPropertySignatureTypeAnnotationConst(global.context, this.peer)) + } + /** @deprecated */ + setTsTypeAnnotation(typeAnnotation?: TypeNode): this { + global.generatedEs2panda._TSPropertySignatureSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation)) + return this + } + protected readonly brandTSPropertySignature: undefined +} +export function isTSPropertySignature(node: object | undefined): node is TSPropertySignature { + return node instanceof TSPropertySignature +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE, (peer: KNativePointer) => new TSPropertySignature(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSQualifiedName.ts b/ets1.2/libarkts/src/generated/peers/TSQualifiedName.ts new file mode 100644 index 0000000000000000000000000000000000000000..af3047dc36f1a6bd467e51a8e2fcb164d86c4829 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSQualifiedName.ts @@ -0,0 +1,72 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Identifier } from "./Identifier" + +export class TSQualifiedName extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSQualifiedName(left?: Expression, right?: Identifier): TSQualifiedName { + const result: TSQualifiedName = new TSQualifiedName(global.generatedEs2panda._CreateTSQualifiedName(global.context, passNode(left), passNode(right)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME) + result.setChildrenParentPtr() + return result + } + static updateTSQualifiedName(original?: TSQualifiedName, left?: Expression, right?: Identifier): TSQualifiedName { + const result: TSQualifiedName = new TSQualifiedName(global.generatedEs2panda._UpdateTSQualifiedName(global.context, passNode(original), passNode(left), passNode(right)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME) + result.setChildrenParentPtr() + return result + } + get left(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSQualifiedNameLeft(global.context, this.peer)) + } + get right(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSQualifiedNameRight(global.context, this.peer)) + } + get name(): string { + return unpackString(global.generatedEs2panda._TSQualifiedNameNameConst(global.context, this.peer)) + } + get resolveLeftMostQualifiedName(): TSQualifiedName | undefined { + return unpackNode(global.generatedEs2panda._TSQualifiedNameResolveLeftMostQualifiedName(global.context, this.peer)) + } + protected readonly brandTSQualifiedName: undefined +} +export function isTSQualifiedName(node: object | undefined): node is TSQualifiedName { + return node instanceof TSQualifiedName +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME, (peer: KNativePointer) => new TSQualifiedName(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSSignatureDeclaration.ts b/ets1.2/libarkts/src/generated/peers/TSSignatureDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..c47244030fa8d4845b8541565de9a36a8a4d46bb --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSSignatureDeclaration.ts @@ -0,0 +1,76 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaTSSignatureDeclarationKind } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { FunctionSignature } from "./FunctionSignature" +import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" +import { TypeNode } from "./TypeNode" +import { TypedAstNode } from "./TypedAstNode" + +export class TSSignatureDeclaration extends TypedAstNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSSignatureDeclaration(kind: Es2pandaTSSignatureDeclarationKind, signature?: FunctionSignature): TSSignatureDeclaration { + const result: TSSignatureDeclaration = new TSSignatureDeclaration(global.generatedEs2panda._CreateTSSignatureDeclaration(global.context, kind, passNode(signature)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION) + result.setChildrenParentPtr() + return result + } + static updateTSSignatureDeclaration(original: TSSignatureDeclaration | undefined, kind: Es2pandaTSSignatureDeclarationKind, signature?: FunctionSignature): TSSignatureDeclaration { + const result: TSSignatureDeclaration = new TSSignatureDeclaration(global.generatedEs2panda._UpdateTSSignatureDeclaration(global.context, passNode(original), kind, passNode(signature)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION) + result.setChildrenParentPtr() + return result + } + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSSignatureDeclarationTypeParams(global.context, this.peer)) + } + get params(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._TSSignatureDeclarationParamsConst(global.context, this.peer)) + } + get returnTypeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSSignatureDeclarationReturnTypeAnnotation(global.context, this.peer)) + } + get kind(): Es2pandaTSSignatureDeclarationKind { + return global.generatedEs2panda._TSSignatureDeclarationKindConst(global.context, this.peer) + } + protected readonly brandTSSignatureDeclaration: undefined +} +export function isTSSignatureDeclaration(node: object | undefined): node is TSSignatureDeclaration { + return node instanceof TSSignatureDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION, (peer: KNativePointer) => new TSSignatureDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSStringKeyword.ts b/ets1.2/libarkts/src/generated/peers/TSStringKeyword.ts new file mode 100644 index 0000000000000000000000000000000000000000..5fbc447b29c10e0f44ca6b5b82007f6c864b3c8f --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSStringKeyword.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSStringKeyword extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSStringKeyword(): TSStringKeyword { + const result: TSStringKeyword = new TSStringKeyword(global.generatedEs2panda._CreateTSStringKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD) + result.setChildrenParentPtr() + return result + } + static updateTSStringKeyword(original?: TSStringKeyword): TSStringKeyword { + const result: TSStringKeyword = new TSStringKeyword(global.generatedEs2panda._UpdateTSStringKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD) + result.setChildrenParentPtr() + return result + } + protected readonly brandTSStringKeyword: undefined +} +export function isTSStringKeyword(node: object | undefined): node is TSStringKeyword { + return node instanceof TSStringKeyword +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD, (peer: KNativePointer) => new TSStringKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSThisType.ts b/ets1.2/libarkts/src/generated/peers/TSThisType.ts new file mode 100644 index 0000000000000000000000000000000000000000..d148187388ce3cba931c10ef3adc0386ce7ff285 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSThisType.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSThisType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSThisType(): TSThisType { + const result: TSThisType = new TSThisType(global.generatedEs2panda._CreateTSThisType(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE) + result.setChildrenParentPtr() + return result + } + static updateTSThisType(original?: TSThisType): TSThisType { + const result: TSThisType = new TSThisType(global.generatedEs2panda._UpdateTSThisType(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE) + result.setChildrenParentPtr() + return result + } + protected readonly brandTSThisType: undefined +} +export function isTSThisType(node: object | undefined): node is TSThisType { + return node instanceof TSThisType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE, (peer: KNativePointer) => new TSThisType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSTupleType.ts b/ets1.2/libarkts/src/generated/peers/TSTupleType.ts new file mode 100644 index 0000000000000000000000000000000000000000..ea6c847cffd0829173238120033344a1993976bb --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSTupleType.ts @@ -0,0 +1,62 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSTupleType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSTupleType(elementTypes: readonly TypeNode[]): TSTupleType { + const result: TSTupleType = new TSTupleType(global.generatedEs2panda._CreateTSTupleType(global.context, passNodeArray(elementTypes), elementTypes.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE) + result.setChildrenParentPtr() + return result + } + static updateTSTupleType(original: TSTupleType | undefined, elementTypes: readonly TypeNode[]): TSTupleType { + const result: TSTupleType = new TSTupleType(global.generatedEs2panda._UpdateTSTupleType(global.context, passNode(original), passNodeArray(elementTypes), elementTypes.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE) + result.setChildrenParentPtr() + return result + } + get elementType(): readonly TypeNode[] { + return unpackNodeArray(global.generatedEs2panda._TSTupleTypeElementTypeConst(global.context, this.peer)) + } + protected readonly brandTSTupleType: undefined +} +export function isTSTupleType(node: object | undefined): node is TSTupleType { + return node instanceof TSTupleType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE, (peer: KNativePointer) => new TSTupleType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts b/ets1.2/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..060ea866642375d3f70c39733f170b243339bbf7 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSTypeAliasDeclaration.ts @@ -0,0 +1,152 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotatedStatement } from "./AnnotatedStatement" +import { AnnotationUsage } from "./AnnotationUsage" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaModifierFlags } from "./../Es2pandaEnums" +import { Identifier } from "./Identifier" +import { SrcDumper } from "./SrcDumper" +import { TSTypeParameterDeclaration } from "./TSTypeParameterDeclaration" +import { TypeNode } from "./TypeNode" + +export class TSTypeAliasDeclaration extends AnnotatedStatement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSTypeAliasDeclaration(id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode, annotations?: readonly AnnotationUsage[], modifierFlags?: Es2pandaModifierFlags): TSTypeAliasDeclaration { + const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._CreateTSTypeAliasDeclaration(global.context, passNode(id), passNode(typeParams), passNode(typeAnnotation)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION) + if (annotations) + { + result.setAnnotations(annotations) + } + if (modifierFlags) + { + result.modifierFlags = modifierFlags + } + result.setChildrenParentPtr() + return result + } + static updateTSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier, typeParams?: TSTypeParameterDeclaration, typeAnnotation?: TypeNode, annotations?: readonly AnnotationUsage[], modifierFlags?: Es2pandaModifierFlags): TSTypeAliasDeclaration { + const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration(global.context, passNode(original), passNode(id), passNode(typeParams), passNode(typeAnnotation)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION) + if (annotations) + { + result.setAnnotations(annotations) + } + if (modifierFlags) + { + result.modifierFlags = modifierFlags + } + result.setChildrenParentPtr() + return result + } + static update1TSTypeAliasDeclaration(original?: TSTypeAliasDeclaration, id?: Identifier, annotations?: readonly AnnotationUsage[], modifierFlags?: Es2pandaModifierFlags): TSTypeAliasDeclaration { + const result: TSTypeAliasDeclaration = new TSTypeAliasDeclaration(global.generatedEs2panda._UpdateTSTypeAliasDeclaration1(global.context, passNode(original), passNode(id)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION) + if (annotations) + { + result.setAnnotations(annotations) + } + if (modifierFlags) + { + result.modifierFlags = modifierFlags + } + result.setChildrenParentPtr() + return result + } + get id(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSTypeAliasDeclarationId(global.context, this.peer)) + } + get typeParams(): TSTypeParameterDeclaration | undefined { + return unpackNode(global.generatedEs2panda._TSTypeAliasDeclarationTypeParamsConst(global.context, this.peer)) + } + /** @deprecated */ + setTypeParameters(typeParams?: TSTypeParameterDeclaration): this { + global.generatedEs2panda._TSTypeAliasDeclarationSetTypeParameters(global.context, this.peer, passNode(typeParams)) + return this + } + /** @deprecated */ + clearTypeParamterTypes(): this { + global.generatedEs2panda._TSTypeAliasDeclarationClearTypeParamterTypes(global.context, this.peer) + return this + } + get typeAnnotation(): TypeNode { + return unpackNonNullableNode(global.generatedEs2panda._TSTypeAliasDeclarationTypeAnnotationConst(global.context, this.peer)) + } + /** @deprecated */ + setTsTypeAnnotation(typeAnnotation?: TypeNode): this { + global.generatedEs2panda._TSTypeAliasDeclarationSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation)) + return this + } + get hasAnnotations(): boolean { + return global.generatedEs2panda._TSTypeAliasDeclarationHasAnnotationsConst(global.context, this.peer) + } + /** @deprecated */ + emplaceAnnotation(source?: AnnotationUsage): this { + global.generatedEs2panda._TSTypeAliasDeclarationEmplaceAnnotation(global.context, this.peer, passNode(source)) + return this + } + /** @deprecated */ + clearAnnotations(): this { + global.generatedEs2panda._TSTypeAliasDeclarationClearAnnotations(global.context, this.peer) + return this + } + /** @deprecated */ + dumpAnnotations(dumper?: SrcDumper): this { + global.generatedEs2panda._TSTypeAliasDeclarationDumpAnnotationsConst(global.context, this.peer, passNode(dumper)) + return this + } + get annotationsForUpdate(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._TSTypeAliasDeclarationAnnotationsForUpdate(global.context, this.peer)) + } + get annotations(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._TSTypeAliasDeclarationAnnotations(global.context, this.peer)) + } + /** @deprecated */ + setAnnotations(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._TSTypeAliasDeclarationSetAnnotations(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + /** @deprecated */ + setAnnotations1(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._TSTypeAliasDeclarationSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + protected readonly brandTSTypeAliasDeclaration: undefined +} +export function isTSTypeAliasDeclaration(node: object | undefined): node is TSTypeAliasDeclaration { + return node instanceof TSTypeAliasDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION, (peer: KNativePointer) => new TSTypeAliasDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSTypeAssertion.ts b/ets1.2/libarkts/src/generated/peers/TSTypeAssertion.ts new file mode 100644 index 0000000000000000000000000000000000000000..3df36d052cdd74acff44645218533a9892769562 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSTypeAssertion.ts @@ -0,0 +1,72 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotatedExpression } from "./AnnotatedExpression" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" + +export class TSTypeAssertion extends AnnotatedExpression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSTypeAssertion(typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion { + const result: TSTypeAssertion = new TSTypeAssertion(global.generatedEs2panda._CreateTSTypeAssertion(global.context, passNode(typeAnnotation), passNode(expression)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION) + result.setChildrenParentPtr() + return result + } + static updateTSTypeAssertion(original?: TSTypeAssertion, typeAnnotation?: TypeNode, expression?: Expression): TSTypeAssertion { + const result: TSTypeAssertion = new TSTypeAssertion(global.generatedEs2panda._UpdateTSTypeAssertion(global.context, passNode(original), passNode(typeAnnotation), passNode(expression)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION) + result.setChildrenParentPtr() + return result + } + get expression(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSTypeAssertionGetExpressionConst(global.context, this.peer)) + } + get typeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSTypeAssertionTypeAnnotationConst(global.context, this.peer)) + } + /** @deprecated */ + setTsTypeAnnotation(typeAnnotation?: TypeNode): this { + global.generatedEs2panda._TSTypeAssertionSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation)) + return this + } + protected readonly brandTSTypeAssertion: undefined +} +export function isTSTypeAssertion(node: object | undefined): node is TSTypeAssertion { + return node instanceof TSTypeAssertion +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION, (peer: KNativePointer) => new TSTypeAssertion(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSTypeLiteral.ts b/ets1.2/libarkts/src/generated/peers/TSTypeLiteral.ts new file mode 100644 index 0000000000000000000000000000000000000000..a77d723c70ba8143915b418ac0dfc6feec1ab5fa --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSTypeLiteral.ts @@ -0,0 +1,62 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSTypeLiteral extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSTypeLiteral(members: readonly AstNode[]): TSTypeLiteral { + const result: TSTypeLiteral = new TSTypeLiteral(global.generatedEs2panda._CreateTSTypeLiteral(global.context, passNodeArray(members), members.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL) + result.setChildrenParentPtr() + return result + } + static updateTSTypeLiteral(original: TSTypeLiteral | undefined, members: readonly AstNode[]): TSTypeLiteral { + const result: TSTypeLiteral = new TSTypeLiteral(global.generatedEs2panda._UpdateTSTypeLiteral(global.context, passNode(original), passNodeArray(members), members.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL) + result.setChildrenParentPtr() + return result + } + get members(): readonly AstNode[] { + return unpackNodeArray(global.generatedEs2panda._TSTypeLiteralMembersConst(global.context, this.peer)) + } + protected readonly brandTSTypeLiteral: undefined +} +export function isTSTypeLiteral(node: object | undefined): node is TSTypeLiteral { + return node instanceof TSTypeLiteral +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL, (peer: KNativePointer) => new TSTypeLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSTypeOperator.ts b/ets1.2/libarkts/src/generated/peers/TSTypeOperator.ts new file mode 100644 index 0000000000000000000000000000000000000000..ff536f22e3652ee44e27e1b5a7bc29687e180974 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSTypeOperator.ts @@ -0,0 +1,72 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaTSOperatorType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSTypeOperator extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSTypeOperator(type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator { + const result: TSTypeOperator = new TSTypeOperator(global.generatedEs2panda._CreateTSTypeOperator(global.context, passNode(type), operatorType), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR) + result.setChildrenParentPtr() + return result + } + static updateTSTypeOperator(original: TSTypeOperator | undefined, type: TypeNode | undefined, operatorType: Es2pandaTSOperatorType): TSTypeOperator { + const result: TSTypeOperator = new TSTypeOperator(global.generatedEs2panda._UpdateTSTypeOperator(global.context, passNode(original), passNode(type), operatorType), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR) + result.setChildrenParentPtr() + return result + } + get type(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSTypeOperatorTypeConst(global.context, this.peer)) + } + get isReadonly(): boolean { + return global.generatedEs2panda._TSTypeOperatorIsReadonlyConst(global.context, this.peer) + } + get isKeyof(): boolean { + return global.generatedEs2panda._TSTypeOperatorIsKeyofConst(global.context, this.peer) + } + get isUnique(): boolean { + return global.generatedEs2panda._TSTypeOperatorIsUniqueConst(global.context, this.peer) + } + protected readonly brandTSTypeOperator: undefined +} +export function isTSTypeOperator(node: object | undefined): node is TSTypeOperator { + return node instanceof TSTypeOperator +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR, (peer: KNativePointer) => new TSTypeOperator(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSTypeParameter.ts b/ets1.2/libarkts/src/generated/peers/TSTypeParameter.ts new file mode 100644 index 0000000000000000000000000000000000000000..50037ac11660358cb43cb10f7167a8e310a4f026 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSTypeParameter.ts @@ -0,0 +1,122 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotationUsage } from "./AnnotationUsage" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaModifierFlags } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Identifier } from "./Identifier" +import { SrcDumper } from "./SrcDumper" +import { TypeNode } from "./TypeNode" + +export class TSTypeParameter extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create1TSTypeParameter(name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter { + const result: TSTypeParameter = new TSTypeParameter(global.generatedEs2panda._CreateTSTypeParameter1(global.context, passNode(name), passNode(constraint), passNode(defaultType), flags), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER) + result.setChildrenParentPtr() + return result + } + static updateTSTypeParameter(original?: TSTypeParameter, name?: Identifier, constraint?: TypeNode, defaultType?: TypeNode): TSTypeParameter { + const result: TSTypeParameter = new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER) + result.setChildrenParentPtr() + return result + } + static update1TSTypeParameter(original: TSTypeParameter | undefined, name: Identifier | undefined, constraint: TypeNode | undefined, defaultType: TypeNode | undefined, flags: Es2pandaModifierFlags): TSTypeParameter { + const result: TSTypeParameter = new TSTypeParameter(global.generatedEs2panda._UpdateTSTypeParameter1(global.context, passNode(original), passNode(name), passNode(constraint), passNode(defaultType), flags), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER) + result.setChildrenParentPtr() + return result + } + get name(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSTypeParameterName(global.context, this.peer)) + } + get constraint(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSTypeParameterConstraint(global.context, this.peer)) + } + /** @deprecated */ + setConstraint(constraint?: TypeNode): this { + global.generatedEs2panda._TSTypeParameterSetConstraint(global.context, this.peer, passNode(constraint)) + return this + } + get defaultType(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSTypeParameterDefaultTypeConst(global.context, this.peer)) + } + /** @deprecated */ + setDefaultType(defaultType?: TypeNode): this { + global.generatedEs2panda._TSTypeParameterSetDefaultType(global.context, this.peer, passNode(defaultType)) + return this + } + get hasAnnotations(): boolean { + return global.generatedEs2panda._TSTypeParameterHasAnnotationsConst(global.context, this.peer) + } + /** @deprecated */ + emplaceAnnotation(source?: AnnotationUsage): this { + global.generatedEs2panda._TSTypeParameterEmplaceAnnotation(global.context, this.peer, passNode(source)) + return this + } + /** @deprecated */ + clearAnnotations(): this { + global.generatedEs2panda._TSTypeParameterClearAnnotations(global.context, this.peer) + return this + } + /** @deprecated */ + dumpAnnotations(dumper?: SrcDumper): this { + global.generatedEs2panda._TSTypeParameterDumpAnnotationsConst(global.context, this.peer, passNode(dumper)) + return this + } + get annotationsForUpdate(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._TSTypeParameterAnnotationsForUpdate(global.context, this.peer)) + } + get annotations(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._TSTypeParameterAnnotations(global.context, this.peer)) + } + /** @deprecated */ + setAnnotations(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._TSTypeParameterSetAnnotations(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + /** @deprecated */ + setAnnotations1(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._TSTypeParameterSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + protected readonly brandTSTypeParameter: undefined +} +export function isTSTypeParameter(node: object | undefined): node is TSTypeParameter { + return node instanceof TSTypeParameter +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER, (peer: KNativePointer) => new TSTypeParameter(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts b/ets1.2/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..2682a3771fde8afd2b6a231e4c9d30d875a80388 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSTypeParameterDeclaration.ts @@ -0,0 +1,76 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TSTypeParameter } from "./TSTypeParameter" + +export class TSTypeParameterDeclaration extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSTypeParameterDeclaration(params: readonly TSTypeParameter[], requiredParams: number): TSTypeParameterDeclaration { + const result: TSTypeParameterDeclaration = new TSTypeParameterDeclaration(global.generatedEs2panda._CreateTSTypeParameterDeclaration(global.context, passNodeArray(params), params.length, requiredParams), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION) + result.setChildrenParentPtr() + return result + } + static updateTSTypeParameterDeclaration(original: TSTypeParameterDeclaration | undefined, params: readonly TSTypeParameter[], requiredParams: number): TSTypeParameterDeclaration { + const result: TSTypeParameterDeclaration = new TSTypeParameterDeclaration(global.generatedEs2panda._UpdateTSTypeParameterDeclaration(global.context, passNode(original), passNodeArray(params), params.length, requiredParams), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION) + result.setChildrenParentPtr() + return result + } + get params(): readonly TSTypeParameter[] { + return unpackNodeArray(global.generatedEs2panda._TSTypeParameterDeclarationParamsConst(global.context, this.peer)) + } + /** @deprecated */ + addParam(param?: TSTypeParameter): this { + global.generatedEs2panda._TSTypeParameterDeclarationAddParam(global.context, this.peer, passNode(param)) + return this + } + /** @deprecated */ + setValueParams(source: TSTypeParameter | undefined, index: number): this { + global.generatedEs2panda._TSTypeParameterDeclarationSetValueParams(global.context, this.peer, passNode(source), index) + return this + } + get requiredParams(): number { + return global.generatedEs2panda._TSTypeParameterDeclarationRequiredParamsConst(global.context, this.peer) + } + protected readonly brandTSTypeParameterDeclaration: undefined +} +export function isTSTypeParameterDeclaration(node: object | undefined): node is TSTypeParameterDeclaration { + return node instanceof TSTypeParameterDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION, (peer: KNativePointer) => new TSTypeParameterDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts b/ets1.2/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts new file mode 100644 index 0000000000000000000000000000000000000000..700560a938e916e3c1227fba61101ae97c426b36 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSTypeParameterInstantiation.ts @@ -0,0 +1,63 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" + +export class TSTypeParameterInstantiation extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSTypeParameterInstantiation(params: readonly TypeNode[]): TSTypeParameterInstantiation { + const result: TSTypeParameterInstantiation = new TSTypeParameterInstantiation(global.generatedEs2panda._CreateTSTypeParameterInstantiation(global.context, passNodeArray(params), params.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION) + result.setChildrenParentPtr() + return result + } + static updateTSTypeParameterInstantiation(original: TSTypeParameterInstantiation | undefined, params: readonly TypeNode[]): TSTypeParameterInstantiation { + const result: TSTypeParameterInstantiation = new TSTypeParameterInstantiation(global.generatedEs2panda._UpdateTSTypeParameterInstantiation(global.context, passNode(original), passNodeArray(params), params.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION) + result.setChildrenParentPtr() + return result + } + get params(): readonly TypeNode[] { + return unpackNodeArray(global.generatedEs2panda._TSTypeParameterInstantiationParamsConst(global.context, this.peer)) + } + protected readonly brandTSTypeParameterInstantiation: undefined +} +export function isTSTypeParameterInstantiation(node: object | undefined): node is TSTypeParameterInstantiation { + return node instanceof TSTypeParameterInstantiation +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION, (peer: KNativePointer) => new TSTypeParameterInstantiation(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSTypePredicate.ts b/ets1.2/libarkts/src/generated/peers/TSTypePredicate.ts new file mode 100644 index 0000000000000000000000000000000000000000..b2207003604535f900bf3017c0e47cf3424d4840 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSTypePredicate.ts @@ -0,0 +1,69 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" + +export class TSTypePredicate extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSTypePredicate(parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate { + const result: TSTypePredicate = new TSTypePredicate(global.generatedEs2panda._CreateTSTypePredicate(global.context, passNode(parameterName), passNode(typeAnnotation), asserts), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE) + result.setChildrenParentPtr() + return result + } + static updateTSTypePredicate(original: TSTypePredicate | undefined, parameterName: Expression | undefined, typeAnnotation: TypeNode | undefined, asserts: boolean): TSTypePredicate { + const result: TSTypePredicate = new TSTypePredicate(global.generatedEs2panda._UpdateTSTypePredicate(global.context, passNode(original), passNode(parameterName), passNode(typeAnnotation), asserts), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE) + result.setChildrenParentPtr() + return result + } + get parameterName(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSTypePredicateParameterNameConst(global.context, this.peer)) + } + get typeAnnotation(): TypeNode | undefined { + return unpackNode(global.generatedEs2panda._TSTypePredicateTypeAnnotationConst(global.context, this.peer)) + } + get asserts(): boolean { + return global.generatedEs2panda._TSTypePredicateAssertsConst(global.context, this.peer) + } + protected readonly brandTSTypePredicate: undefined +} +export function isTSTypePredicate(node: object | undefined): node is TSTypePredicate { + return node instanceof TSTypePredicate +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE, (peer: KNativePointer) => new TSTypePredicate(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSTypeQuery.ts b/ets1.2/libarkts/src/generated/peers/TSTypeQuery.ts new file mode 100644 index 0000000000000000000000000000000000000000..4d16ee411c4ba9384ad344a704bc46a540dd54ed --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSTypeQuery.ts @@ -0,0 +1,63 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypeNode } from "./TypeNode" + +export class TSTypeQuery extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSTypeQuery(exprName?: Expression): TSTypeQuery { + const result: TSTypeQuery = new TSTypeQuery(global.generatedEs2panda._CreateTSTypeQuery(global.context, passNode(exprName)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY) + result.setChildrenParentPtr() + return result + } + static updateTSTypeQuery(original?: TSTypeQuery, exprName?: Expression): TSTypeQuery { + const result: TSTypeQuery = new TSTypeQuery(global.generatedEs2panda._UpdateTSTypeQuery(global.context, passNode(original), passNode(exprName)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY) + result.setChildrenParentPtr() + return result + } + get exprName(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSTypeQueryExprNameConst(global.context, this.peer)) + } + protected readonly brandTSTypeQuery: undefined +} +export function isTSTypeQuery(node: object | undefined): node is TSTypeQuery { + return node instanceof TSTypeQuery +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY, (peer: KNativePointer) => new TSTypeQuery(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSTypeReference.ts b/ets1.2/libarkts/src/generated/peers/TSTypeReference.ts new file mode 100644 index 0000000000000000000000000000000000000000..f71b1957d3a139d0a579af291e647283b89fcf0d --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSTypeReference.ts @@ -0,0 +1,71 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Identifier } from "./Identifier" +import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" +import { TypeNode } from "./TypeNode" + +export class TSTypeReference extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSTypeReference(typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference { + const result: TSTypeReference = new TSTypeReference(global.generatedEs2panda._CreateTSTypeReference(global.context, passNode(typeName), passNode(typeParams)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_REFERENCE) + result.setChildrenParentPtr() + return result + } + static updateTSTypeReference(original?: TSTypeReference, typeName?: Expression, typeParams?: TSTypeParameterInstantiation): TSTypeReference { + const result: TSTypeReference = new TSTypeReference(global.generatedEs2panda._UpdateTSTypeReference(global.context, passNode(original), passNode(typeName), passNode(typeParams)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_REFERENCE) + result.setChildrenParentPtr() + return result + } + get typeParams(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._TSTypeReferenceTypeParamsConst(global.context, this.peer)) + } + get typeName(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TSTypeReferenceTypeNameConst(global.context, this.peer)) + } + get baseName(): Identifier | undefined { + return unpackNode(global.generatedEs2panda._TSTypeReferenceBaseNameConst(global.context, this.peer)) + } + protected readonly brandTSTypeReference: undefined +} +export function isTSTypeReference(node: object | undefined): node is TSTypeReference { + return node instanceof TSTypeReference +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_REFERENCE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_REFERENCE, (peer: KNativePointer) => new TSTypeReference(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_REFERENCE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSUndefinedKeyword.ts b/ets1.2/libarkts/src/generated/peers/TSUndefinedKeyword.ts new file mode 100644 index 0000000000000000000000000000000000000000..db9649c8cb75aca8431496d1258b85f9df97cf06 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSUndefinedKeyword.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSUndefinedKeyword extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSUndefinedKeyword(): TSUndefinedKeyword { + const result: TSUndefinedKeyword = new TSUndefinedKeyword(global.generatedEs2panda._CreateTSUndefinedKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD) + result.setChildrenParentPtr() + return result + } + static updateTSUndefinedKeyword(original?: TSUndefinedKeyword): TSUndefinedKeyword { + const result: TSUndefinedKeyword = new TSUndefinedKeyword(global.generatedEs2panda._UpdateTSUndefinedKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD) + result.setChildrenParentPtr() + return result + } + protected readonly brandTSUndefinedKeyword: undefined +} +export function isTSUndefinedKeyword(node: object | undefined): node is TSUndefinedKeyword { + return node instanceof TSUndefinedKeyword +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD, (peer: KNativePointer) => new TSUndefinedKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSUnionType.ts b/ets1.2/libarkts/src/generated/peers/TSUnionType.ts new file mode 100644 index 0000000000000000000000000000000000000000..96d119aacbb41cc2142bcdebaf72076053a36c8b --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSUnionType.ts @@ -0,0 +1,62 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSUnionType extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSUnionType(types: readonly TypeNode[]): TSUnionType { + const result: TSUnionType = new TSUnionType(global.generatedEs2panda._CreateTSUnionType(global.context, passNodeArray(types), types.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE) + result.setChildrenParentPtr() + return result + } + static updateTSUnionType(original: TSUnionType | undefined, types: readonly TypeNode[]): TSUnionType { + const result: TSUnionType = new TSUnionType(global.generatedEs2panda._UpdateTSUnionType(global.context, passNode(original), passNodeArray(types), types.length), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE) + result.setChildrenParentPtr() + return result + } + get types(): readonly TypeNode[] { + return unpackNodeArray(global.generatedEs2panda._TSUnionTypeTypesConst(global.context, this.peer)) + } + protected readonly brandTSUnionType: undefined +} +export function isTSUnionType(node: object | undefined): node is TSUnionType { + return node instanceof TSUnionType +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE, (peer: KNativePointer) => new TSUnionType(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSUnknownKeyword.ts b/ets1.2/libarkts/src/generated/peers/TSUnknownKeyword.ts new file mode 100644 index 0000000000000000000000000000000000000000..7992dfff754a077aeaabbf322eae3bc0d7632398 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSUnknownKeyword.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSUnknownKeyword extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSUnknownKeyword(): TSUnknownKeyword { + const result: TSUnknownKeyword = new TSUnknownKeyword(global.generatedEs2panda._CreateTSUnknownKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD) + result.setChildrenParentPtr() + return result + } + static updateTSUnknownKeyword(original?: TSUnknownKeyword): TSUnknownKeyword { + const result: TSUnknownKeyword = new TSUnknownKeyword(global.generatedEs2panda._UpdateTSUnknownKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD) + result.setChildrenParentPtr() + return result + } + protected readonly brandTSUnknownKeyword: undefined +} +export function isTSUnknownKeyword(node: object | undefined): node is TSUnknownKeyword { + return node instanceof TSUnknownKeyword +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD, (peer: KNativePointer) => new TSUnknownKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TSVoidKeyword.ts b/ets1.2/libarkts/src/generated/peers/TSVoidKeyword.ts new file mode 100644 index 0000000000000000000000000000000000000000..e5935a79f0dac798b5b599554a440150a84c220f --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TSVoidKeyword.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { TypeNode } from "./TypeNode" + +export class TSVoidKeyword extends TypeNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTSVoidKeyword(): TSVoidKeyword { + const result: TSVoidKeyword = new TSVoidKeyword(global.generatedEs2panda._CreateTSVoidKeyword(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD) + result.setChildrenParentPtr() + return result + } + static updateTSVoidKeyword(original?: TSVoidKeyword): TSVoidKeyword { + const result: TSVoidKeyword = new TSVoidKeyword(global.generatedEs2panda._UpdateTSVoidKeyword(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD) + result.setChildrenParentPtr() + return result + } + protected readonly brandTSVoidKeyword: undefined +} +export function isTSVoidKeyword(node: object | undefined): node is TSVoidKeyword { + return node instanceof TSVoidKeyword +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD, (peer: KNativePointer) => new TSVoidKeyword(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TaggedTemplateExpression.ts b/ets1.2/libarkts/src/generated/peers/TaggedTemplateExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..2b148c17278fa5d214bde84070d03d5c9b5229ea --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TaggedTemplateExpression.ts @@ -0,0 +1,70 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TSTypeParameterInstantiation } from "./TSTypeParameterInstantiation" +import { TemplateLiteral } from "./TemplateLiteral" + +export class TaggedTemplateExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTaggedTemplateExpression(tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression { + const result: TaggedTemplateExpression = new TaggedTemplateExpression(global.generatedEs2panda._CreateTaggedTemplateExpression(global.context, passNode(tag), passNode(quasi), passNode(typeParams)), Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateTaggedTemplateExpression(original?: TaggedTemplateExpression, tag?: Expression, quasi?: TemplateLiteral, typeParams?: TSTypeParameterInstantiation): TaggedTemplateExpression { + const result: TaggedTemplateExpression = new TaggedTemplateExpression(global.generatedEs2panda._UpdateTaggedTemplateExpression(global.context, passNode(original), passNode(tag), passNode(quasi), passNode(typeParams)), Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get tag(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TaggedTemplateExpressionTagConst(global.context, this.peer)) + } + get quasi(): TemplateLiteral | undefined { + return unpackNode(global.generatedEs2panda._TaggedTemplateExpressionQuasiConst(global.context, this.peer)) + } + get typeParams(): TSTypeParameterInstantiation | undefined { + return unpackNode(global.generatedEs2panda._TaggedTemplateExpressionTypeParamsConst(global.context, this.peer)) + } + protected readonly brandTaggedTemplateExpression: undefined +} +export function isTaggedTemplateExpression(node: object | undefined): node is TaggedTemplateExpression { + return node instanceof TaggedTemplateExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION, (peer: KNativePointer) => new TaggedTemplateExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TemplateElement.ts b/ets1.2/libarkts/src/generated/peers/TemplateElement.ts new file mode 100644 index 0000000000000000000000000000000000000000..1158a11bdd3c66bd80a2827013d0f66cd00f647f --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TemplateElement.ts @@ -0,0 +1,70 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class TemplateElement extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create1TemplateElement(raw: string, cooked: string): TemplateElement { + const result: TemplateElement = new TemplateElement(global.generatedEs2panda._CreateTemplateElement1(global.context, raw, cooked), Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT) + result.setChildrenParentPtr() + return result + } + static updateTemplateElement(original?: TemplateElement): TemplateElement { + const result: TemplateElement = new TemplateElement(global.generatedEs2panda._UpdateTemplateElement(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT) + result.setChildrenParentPtr() + return result + } + static update1TemplateElement(original: TemplateElement | undefined, raw: string, cooked: string): TemplateElement { + const result: TemplateElement = new TemplateElement(global.generatedEs2panda._UpdateTemplateElement1(global.context, passNode(original), raw, cooked), Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT) + result.setChildrenParentPtr() + return result + } + get raw(): string { + return unpackString(global.generatedEs2panda._TemplateElementRawConst(global.context, this.peer)) + } + get cooked(): string { + return unpackString(global.generatedEs2panda._TemplateElementCookedConst(global.context, this.peer)) + } + protected readonly brandTemplateElement: undefined +} +export function isTemplateElement(node: object | undefined): node is TemplateElement { + return node instanceof TemplateElement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT, (peer: KNativePointer) => new TemplateElement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TemplateLiteral.ts b/ets1.2/libarkts/src/generated/peers/TemplateLiteral.ts new file mode 100644 index 0000000000000000000000000000000000000000..b4d6780259b0ccaefb37ca5cc3004a0ae0e5668b --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TemplateLiteral.ts @@ -0,0 +1,69 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TemplateElement } from "./TemplateElement" + +export class TemplateLiteral extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTemplateLiteral(quasis: readonly TemplateElement[], expressions: readonly Expression[], multilineString: string): TemplateLiteral { + const result: TemplateLiteral = new TemplateLiteral(global.generatedEs2panda._CreateTemplateLiteral(global.context, passNodeArray(quasis), quasis.length, passNodeArray(expressions), expressions.length, multilineString), Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL) + result.setChildrenParentPtr() + return result + } + static updateTemplateLiteral(original: TemplateLiteral | undefined, quasis: readonly TemplateElement[], expressions: readonly Expression[], multilineString: string): TemplateLiteral { + const result: TemplateLiteral = new TemplateLiteral(global.generatedEs2panda._UpdateTemplateLiteral(global.context, passNode(original), passNodeArray(quasis), quasis.length, passNodeArray(expressions), expressions.length, multilineString), Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL) + result.setChildrenParentPtr() + return result + } + get quasis(): readonly TemplateElement[] { + return unpackNodeArray(global.generatedEs2panda._TemplateLiteralQuasisConst(global.context, this.peer)) + } + get expressions(): readonly Expression[] { + return unpackNodeArray(global.generatedEs2panda._TemplateLiteralExpressionsConst(global.context, this.peer)) + } + get multilineString(): string { + return unpackString(global.generatedEs2panda._TemplateLiteralGetMultilineStringConst(global.context, this.peer)) + } + protected readonly brandTemplateLiteral: undefined +} +export function isTemplateLiteral(node: object | undefined): node is TemplateLiteral { + return node instanceof TemplateLiteral +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL, (peer: KNativePointer) => new TemplateLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ThisExpression.ts b/ets1.2/libarkts/src/generated/peers/ThisExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..06c494b701d68af7eee0989abe6904b1cbaf4020 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ThisExpression.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class ThisExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createThisExpression(): ThisExpression { + const result: ThisExpression = new ThisExpression(global.generatedEs2panda._CreateThisExpression(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_THIS_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateThisExpression(original?: ThisExpression): ThisExpression { + const result: ThisExpression = new ThisExpression(global.generatedEs2panda._UpdateThisExpression(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_THIS_EXPRESSION) + result.setChildrenParentPtr() + return result + } + protected readonly brandThisExpression: undefined +} +export function isThisExpression(node: object | undefined): node is ThisExpression { + return node instanceof ThisExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_THIS_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_THIS_EXPRESSION, (peer: KNativePointer) => new ThisExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_THIS_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/ThrowStatement.ts b/ets1.2/libarkts/src/generated/peers/ThrowStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..184a854bccb990c3e16a4de05e940dde20bc923f --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ThrowStatement.ts @@ -0,0 +1,63 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { Statement } from "./Statement" + +export class ThrowStatement extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createThrowStatement(argument?: Expression): ThrowStatement { + const result: ThrowStatement = new ThrowStatement(global.generatedEs2panda._CreateThrowStatement(global.context, passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_THROW_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateThrowStatement(original?: ThrowStatement, argument?: Expression): ThrowStatement { + const result: ThrowStatement = new ThrowStatement(global.generatedEs2panda._UpdateThrowStatement(global.context, passNode(original), passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_THROW_STATEMENT) + result.setChildrenParentPtr() + return result + } + get argument(): Expression | undefined { + return unpackNode(global.generatedEs2panda._ThrowStatementArgumentConst(global.context, this.peer)) + } + protected readonly brandThrowStatement: undefined +} +export function isThrowStatement(node: object | undefined): node is ThrowStatement { + return node instanceof ThrowStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_THROW_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_THROW_STATEMENT, (peer: KNativePointer) => new ThrowStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_THROW_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TryStatement.ts b/ets1.2/libarkts/src/generated/peers/TryStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..28376d9e3a35dde1a9c4b4bf5f1b9b5b98ae3cd1 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TryStatement.ts @@ -0,0 +1,90 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { BlockStatement } from "./BlockStatement" +import { CatchClause } from "./CatchClause" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { LabelPair } from "./LabelPair" +import { Statement } from "./Statement" + +export class TryStatement extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTryStatement(block: BlockStatement | undefined, catchClauses: readonly CatchClause[], finalizer: BlockStatement | undefined, finalizerInsertionsLabelPair: readonly LabelPair[], finalizerInsertionsStatement: readonly Statement[]): TryStatement { + const result: TryStatement = new TryStatement(global.generatedEs2panda._CreateTryStatement(global.context, passNode(block), passNodeArray(catchClauses), catchClauses.length, passNode(finalizer), passNodeArray(finalizerInsertionsLabelPair), finalizerInsertionsLabelPair.length, passNodeArray(finalizerInsertionsStatement), finalizerInsertionsStatement.length), Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateTryStatement(original: TryStatement | undefined, block: BlockStatement | undefined, catchClauses: readonly CatchClause[], finalizer: BlockStatement | undefined, finalizerInsertionsLabelPair: readonly LabelPair[], finalizerInsertionsStatement: readonly Statement[]): TryStatement { + const result: TryStatement = new TryStatement(global.generatedEs2panda._UpdateTryStatement(global.context, passNode(original), passNode(block), passNodeArray(catchClauses), catchClauses.length, passNode(finalizer), passNodeArray(finalizerInsertionsLabelPair), finalizerInsertionsLabelPair.length, passNodeArray(finalizerInsertionsStatement), finalizerInsertionsStatement.length), Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT) + result.setChildrenParentPtr() + return result + } + static update1TryStatement(original?: TryStatement, other?: TryStatement): TryStatement { + const result: TryStatement = new TryStatement(global.generatedEs2panda._UpdateTryStatement1(global.context, passNode(original), passNode(other)), Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT) + result.setChildrenParentPtr() + return result + } + get finallyBlock(): BlockStatement | undefined { + return unpackNode(global.generatedEs2panda._TryStatementFinallyBlockConst(global.context, this.peer)) + } + get block(): BlockStatement | undefined { + return unpackNode(global.generatedEs2panda._TryStatementBlockConst(global.context, this.peer)) + } + get hasFinalizer(): boolean { + return global.generatedEs2panda._TryStatementHasFinalizerConst(global.context, this.peer) + } + get hasDefaultCatchClause(): boolean { + return global.generatedEs2panda._TryStatementHasDefaultCatchClauseConst(global.context, this.peer) + } + get catchClauses(): readonly CatchClause[] { + return unpackNodeArray(global.generatedEs2panda._TryStatementCatchClausesConst(global.context, this.peer)) + } + get finallyCanCompleteNormally(): boolean { + return global.generatedEs2panda._TryStatementFinallyCanCompleteNormallyConst(global.context, this.peer) + } + /** @deprecated */ + setFinallyCanCompleteNormally(finallyCanCompleteNormally: boolean): this { + global.generatedEs2panda._TryStatementSetFinallyCanCompleteNormally(global.context, this.peer, finallyCanCompleteNormally) + return this + } + protected readonly brandTryStatement: undefined +} +export function isTryStatement(node: object | undefined): node is TryStatement { + return node instanceof TryStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT, (peer: KNativePointer) => new TryStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/TypeNode.ts b/ets1.2/libarkts/src/generated/peers/TypeNode.ts new file mode 100644 index 0000000000000000000000000000000000000000..c06674cc49da7f2414572068235fab5dfa3b05f1 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TypeNode.ts @@ -0,0 +1,82 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotationUsage } from "./AnnotationUsage" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { SrcDumper } from "./SrcDumper" + +export class TypeNode extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + get hasAnnotations(): boolean { + return global.generatedEs2panda._TypeNodeHasAnnotationsConst(global.context, this.peer) + } + /** @deprecated */ + emplaceAnnotation(source?: AnnotationUsage): this { + global.generatedEs2panda._TypeNodeEmplaceAnnotation(global.context, this.peer, passNode(source)) + return this + } + /** @deprecated */ + clearAnnotations(): this { + global.generatedEs2panda._TypeNodeClearAnnotations(global.context, this.peer) + return this + } + /** @deprecated */ + dumpAnnotations(dumper?: SrcDumper): this { + global.generatedEs2panda._TypeNodeDumpAnnotationsConst(global.context, this.peer, passNode(dumper)) + return this + } + get annotationsForUpdate(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._TypeNodeAnnotationsForUpdate(global.context, this.peer)) + } + get annotations(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._TypeNodeAnnotations(global.context, this.peer)) + } + /** @deprecated */ + setAnnotations(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._TypeNodeSetAnnotations(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + /** @deprecated */ + setAnnotations1(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._TypeNodeSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + protected readonly brandTypeNode: undefined +} +export function isTypeNode(node: object | undefined): node is TypeNode { + return node instanceof TypeNode +} diff --git a/ets1.2/libarkts/src/generated/peers/TypedAstNode.ts b/ets1.2/libarkts/src/generated/peers/TypedAstNode.ts new file mode 100644 index 0000000000000000000000000000000000000000..fabf268ae0d89749d3d427060aae4f300a447b68 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TypedAstNode.ts @@ -0,0 +1,45 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" + +export class TypedAstNode extends AstNode { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + protected readonly brandTypedAstNode: undefined +} +export function isTypedAstNode(node: object | undefined): node is TypedAstNode { + return node instanceof TypedAstNode +} diff --git a/ets1.2/libarkts/src/generated/peers/TypedStatement.ts b/ets1.2/libarkts/src/generated/peers/TypedStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..4070d382e0ff74432fd220575110fb335f9edc81 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TypedStatement.ts @@ -0,0 +1,46 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Statement } from "./Statement" + +export class TypedStatement extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + protected readonly brandTypedStatement: undefined +} +export function isTypedStatement(node: object | undefined): node is TypedStatement { + return node instanceof TypedStatement +} diff --git a/ets1.2/libarkts/src/generated/peers/TypeofExpression.ts b/ets1.2/libarkts/src/generated/peers/TypeofExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..d68760a7477ca599381ede9bc882686ed9c4580c --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/TypeofExpression.ts @@ -0,0 +1,62 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class TypeofExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createTypeofExpression(argument?: Expression): TypeofExpression { + const result: TypeofExpression = new TypeofExpression(global.generatedEs2panda._CreateTypeofExpression(global.context, passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_TYPEOF_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateTypeofExpression(original?: TypeofExpression, argument?: Expression): TypeofExpression { + const result: TypeofExpression = new TypeofExpression(global.generatedEs2panda._UpdateTypeofExpression(global.context, passNode(original), passNode(argument)), Es2pandaAstNodeType.AST_NODE_TYPE_TYPEOF_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get argument(): Expression | undefined { + return unpackNode(global.generatedEs2panda._TypeofExpressionArgumentConst(global.context, this.peer)) + } + protected readonly brandTypeofExpression: undefined +} +export function isTypeofExpression(node: object | undefined): node is TypeofExpression { + return node instanceof TypeofExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_TYPEOF_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_TYPEOF_EXPRESSION, (peer: KNativePointer) => new TypeofExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_TYPEOF_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/UnaryExpression.ts b/ets1.2/libarkts/src/generated/peers/UnaryExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..b9bcd64225fa67d689e2d7a63a1be3c8d0281417 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/UnaryExpression.ts @@ -0,0 +1,71 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaTokenType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class UnaryExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createUnaryExpression(argument: Expression | undefined, unaryOperator: Es2pandaTokenType): UnaryExpression { + const result: UnaryExpression = new UnaryExpression(global.generatedEs2panda._CreateUnaryExpression(global.context, passNode(argument), unaryOperator), Es2pandaAstNodeType.AST_NODE_TYPE_UNARY_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateUnaryExpression(original: UnaryExpression | undefined, argument: Expression | undefined, unaryOperator: Es2pandaTokenType): UnaryExpression { + const result: UnaryExpression = new UnaryExpression(global.generatedEs2panda._UpdateUnaryExpression(global.context, passNode(original), passNode(argument), unaryOperator), Es2pandaAstNodeType.AST_NODE_TYPE_UNARY_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get operatorType(): Es2pandaTokenType { + return global.generatedEs2panda._UnaryExpressionOperatorTypeConst(global.context, this.peer) + } + get argument(): Expression | undefined { + return unpackNode(global.generatedEs2panda._UnaryExpressionArgument(global.context, this.peer)) + } + /** @deprecated */ + setArgument(arg?: Expression): this { + global.generatedEs2panda._UnaryExpressionSetArgument(global.context, this.peer, passNode(arg)) + return this + } + protected readonly brandUnaryExpression: undefined +} +export function isUnaryExpression(node: object | undefined): node is UnaryExpression { + return node instanceof UnaryExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_UNARY_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_UNARY_EXPRESSION, (peer: KNativePointer) => new UnaryExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_UNARY_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/UndefinedLiteral.ts b/ets1.2/libarkts/src/generated/peers/UndefinedLiteral.ts new file mode 100644 index 0000000000000000000000000000000000000000..4bc40796198f6ec8d3ffacc01abef36288cdefb0 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/UndefinedLiteral.ts @@ -0,0 +1,59 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Literal } from "./Literal" + +export class UndefinedLiteral extends Literal { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createUndefinedLiteral(): UndefinedLiteral { + const result: UndefinedLiteral = new UndefinedLiteral(global.generatedEs2panda._CreateUndefinedLiteral(global.context), Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL) + result.setChildrenParentPtr() + return result + } + static updateUndefinedLiteral(original?: UndefinedLiteral): UndefinedLiteral { + const result: UndefinedLiteral = new UndefinedLiteral(global.generatedEs2panda._UpdateUndefinedLiteral(global.context, passNode(original)), Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL) + result.setChildrenParentPtr() + return result + } + protected readonly brandUndefinedLiteral: undefined +} +export function isUndefinedLiteral(node: object | undefined): node is UndefinedLiteral { + return node instanceof UndefinedLiteral +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL, (peer: KNativePointer) => new UndefinedLiteral(peer, Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL)) +} diff --git a/ets1.2/libarkts/src/generated/peers/UpdateExpression.ts b/ets1.2/libarkts/src/generated/peers/UpdateExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..e56b7fb03d1b59ee250f331a788ca51f49e51b90 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/UpdateExpression.ts @@ -0,0 +1,69 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaTokenType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class UpdateExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createUpdateExpression(argument: Expression | undefined, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression { + const result: UpdateExpression = new UpdateExpression(global.generatedEs2panda._CreateUpdateExpression(global.context, passNode(argument), updateOperator, isPrefix), Es2pandaAstNodeType.AST_NODE_TYPE_UPDATE_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateUpdateExpression(original: UpdateExpression | undefined, argument: Expression | undefined, updateOperator: Es2pandaTokenType, isPrefix: boolean): UpdateExpression { + const result: UpdateExpression = new UpdateExpression(global.generatedEs2panda._UpdateUpdateExpression(global.context, passNode(original), passNode(argument), updateOperator, isPrefix), Es2pandaAstNodeType.AST_NODE_TYPE_UPDATE_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get operatorType(): Es2pandaTokenType { + return global.generatedEs2panda._UpdateExpressionOperatorTypeConst(global.context, this.peer) + } + get argument(): Expression | undefined { + return unpackNode(global.generatedEs2panda._UpdateExpressionArgument(global.context, this.peer)) + } + get isPrefix(): boolean { + return global.generatedEs2panda._UpdateExpressionIsPrefixConst(global.context, this.peer) + } + protected readonly brandUpdateExpression: undefined +} +export function isUpdateExpression(node: object | undefined): node is UpdateExpression { + return node instanceof UpdateExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_UPDATE_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_UPDATE_EXPRESSION, (peer: KNativePointer) => new UpdateExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_UPDATE_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/VReg.ts b/ets1.2/libarkts/src/generated/peers/VReg.ts new file mode 100644 index 0000000000000000000000000000000000000000..5871cd606c9611af0296fa6d8be85c694d3f40a5 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/VReg.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class VReg extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandVReg: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/ValidationInfo.ts b/ets1.2/libarkts/src/generated/peers/ValidationInfo.ts new file mode 100644 index 0000000000000000000000000000000000000000..adb0df6bb54cfa1863b3ec0b23b23217e29da0d6 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/ValidationInfo.ts @@ -0,0 +1,51 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { SourcePosition } from "./SourcePosition" + +export class ValidationInfo extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + static create1ValidationInfo(m: string, p?: SourcePosition): ValidationInfo { + return new ValidationInfo(global.generatedEs2panda._CreateValidationInfo1(global.context, m, passNode(p))) + } + get fail(): boolean { + return global.generatedEs2panda._ValidationInfoFailConst(global.context, this.peer) + } + protected readonly brandValidationInfo: undefined +} +export function isValidationInfo(node: object | undefined): node is ValidationInfo { + return node instanceof ValidationInfo +} diff --git a/ets1.2/libarkts/src/generated/peers/VariableDeclaration.ts b/ets1.2/libarkts/src/generated/peers/VariableDeclaration.ts new file mode 100644 index 0000000000000000000000000000000000000000..3ee86944aa92e0b81f60f188aaee5e4b005fc142 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/VariableDeclaration.ts @@ -0,0 +1,114 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { AnnotationUsage } from "./AnnotationUsage" +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaVariableDeclarationKind } from "./../Es2pandaEnums" +import { SrcDumper } from "./SrcDumper" +import { Statement } from "./Statement" +import { VariableDeclarator } from "./VariableDeclarator" + +export class VariableDeclaration extends Statement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createVariableDeclaration(kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], annotations?: readonly AnnotationUsage[]): VariableDeclaration { + const result: VariableDeclaration = new VariableDeclaration(global.generatedEs2panda._CreateVariableDeclaration(global.context, kind, passNodeArray(declarators), declarators.length), Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + static updateVariableDeclaration(original: VariableDeclaration | undefined, kind: Es2pandaVariableDeclarationKind, declarators: readonly VariableDeclarator[], annotations?: readonly AnnotationUsage[]): VariableDeclaration { + const result: VariableDeclaration = new VariableDeclaration(global.generatedEs2panda._UpdateVariableDeclaration(global.context, passNode(original), kind, passNodeArray(declarators), declarators.length), Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION) + if (annotations) + { + result.setAnnotations(annotations) + } + result.setChildrenParentPtr() + return result + } + get declarators(): readonly VariableDeclarator[] { + return unpackNodeArray(global.generatedEs2panda._VariableDeclarationDeclarators(global.context, this.peer)) + } + get declaratorsForUpdate(): readonly VariableDeclarator[] { + return unpackNodeArray(global.generatedEs2panda._VariableDeclarationDeclaratorsForUpdate(global.context, this.peer)) + } + get kind(): Es2pandaVariableDeclarationKind { + return global.generatedEs2panda._VariableDeclarationKindConst(global.context, this.peer) + } + get hasAnnotations(): boolean { + return global.generatedEs2panda._VariableDeclarationHasAnnotationsConst(global.context, this.peer) + } + /** @deprecated */ + emplaceAnnotation(source?: AnnotationUsage): this { + global.generatedEs2panda._VariableDeclarationEmplaceAnnotation(global.context, this.peer, passNode(source)) + return this + } + /** @deprecated */ + clearAnnotations(): this { + global.generatedEs2panda._VariableDeclarationClearAnnotations(global.context, this.peer) + return this + } + /** @deprecated */ + dumpAnnotations(dumper?: SrcDumper): this { + global.generatedEs2panda._VariableDeclarationDumpAnnotationsConst(global.context, this.peer, passNode(dumper)) + return this + } + get annotationsForUpdate(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._VariableDeclarationAnnotationsForUpdate(global.context, this.peer)) + } + get annotations(): readonly AnnotationUsage[] { + return unpackNodeArray(global.generatedEs2panda._VariableDeclarationAnnotations(global.context, this.peer)) + } + /** @deprecated */ + setAnnotations(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._VariableDeclarationSetAnnotations(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + /** @deprecated */ + setAnnotations1(annotationList: readonly AnnotationUsage[]): this { + global.generatedEs2panda._VariableDeclarationSetAnnotations1(global.context, this.peer, passNodeArray(annotationList), annotationList.length) + return this + } + protected readonly brandVariableDeclaration: undefined +} +export function isVariableDeclaration(node: object | undefined): node is VariableDeclaration { + return node instanceof VariableDeclaration +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION, (peer: KNativePointer) => new VariableDeclaration(peer, Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION)) +} diff --git a/ets1.2/libarkts/src/generated/peers/VariableDeclarator.ts b/ets1.2/libarkts/src/generated/peers/VariableDeclarator.ts new file mode 100644 index 0000000000000000000000000000000000000000..5355e971a1dd83c47b0876f24da292fa21169dca --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/VariableDeclarator.ts @@ -0,0 +1,80 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Es2pandaVariableDeclaratorFlag } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { TypedStatement } from "./TypedStatement" + +export class VariableDeclarator extends TypedStatement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static create1VariableDeclarator(flag: Es2pandaVariableDeclaratorFlag, ident?: Expression, init?: Expression): VariableDeclarator { + const result: VariableDeclarator = new VariableDeclarator(global.generatedEs2panda._CreateVariableDeclarator1(global.context, flag, passNode(ident), passNode(init)), Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR) + result.setChildrenParentPtr() + return result + } + static updateVariableDeclarator(original: VariableDeclarator | undefined, flag: Es2pandaVariableDeclaratorFlag, ident?: Expression): VariableDeclarator { + const result: VariableDeclarator = new VariableDeclarator(global.generatedEs2panda._UpdateVariableDeclarator(global.context, passNode(original), flag, passNode(ident)), Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR) + result.setChildrenParentPtr() + return result + } + static update1VariableDeclarator(original: VariableDeclarator | undefined, flag: Es2pandaVariableDeclaratorFlag, ident?: Expression, init?: Expression): VariableDeclarator { + const result: VariableDeclarator = new VariableDeclarator(global.generatedEs2panda._UpdateVariableDeclarator1(global.context, passNode(original), flag, passNode(ident), passNode(init)), Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR) + result.setChildrenParentPtr() + return result + } + get init(): Expression | undefined { + return unpackNode(global.generatedEs2panda._VariableDeclaratorInit(global.context, this.peer)) + } + /** @deprecated */ + setInit(init?: Expression): this { + global.generatedEs2panda._VariableDeclaratorSetInit(global.context, this.peer, passNode(init)) + return this + } + get id(): Expression | undefined { + return unpackNode(global.generatedEs2panda._VariableDeclaratorId(global.context, this.peer)) + } + get flag(): Es2pandaVariableDeclaratorFlag { + return global.generatedEs2panda._VariableDeclaratorFlag(global.context, this.peer) + } + protected readonly brandVariableDeclarator: undefined +} +export function isVariableDeclarator(node: object | undefined): node is VariableDeclarator { + return node instanceof VariableDeclarator +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR, (peer: KNativePointer) => new VariableDeclarator(peer, Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR)) +} diff --git a/ets1.2/libarkts/src/generated/peers/VerificationContext.ts b/ets1.2/libarkts/src/generated/peers/VerificationContext.ts new file mode 100644 index 0000000000000000000000000000000000000000..d2340ecd42b51a7be6c873a17afc8e20edf085ba --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/VerificationContext.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class VerificationContext extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandVerificationContext: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/VerifierMessage.ts b/ets1.2/libarkts/src/generated/peers/VerifierMessage.ts new file mode 100644 index 0000000000000000000000000000000000000000..15482293a397c06647c0f8c1481229bd361b380e --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/VerifierMessage.ts @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + + +export class VerifierMessage extends ArktsObject { + constructor(pointer: KNativePointer) { + super(pointer) + } + protected readonly brandVerifierMessage: undefined +} diff --git a/ets1.2/libarkts/src/generated/peers/WhileStatement.ts b/ets1.2/libarkts/src/generated/peers/WhileStatement.ts new file mode 100644 index 0000000000000000000000000000000000000000..c597fdc8017cf5d16b9910407901911dd1325083 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/WhileStatement.ts @@ -0,0 +1,72 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" +import { LoopStatement } from "./LoopStatement" +import { Statement } from "./Statement" + +export class WhileStatement extends LoopStatement { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createWhileStatement(test?: Expression, body?: Statement): WhileStatement { + const result: WhileStatement = new WhileStatement(global.generatedEs2panda._CreateWhileStatement(global.context, passNode(test), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_WHILE_STATEMENT) + result.setChildrenParentPtr() + return result + } + static updateWhileStatement(original?: WhileStatement, test?: Expression, body?: Statement): WhileStatement { + const result: WhileStatement = new WhileStatement(global.generatedEs2panda._UpdateWhileStatement(global.context, passNode(original), passNode(test), passNode(body)), Es2pandaAstNodeType.AST_NODE_TYPE_WHILE_STATEMENT) + result.setChildrenParentPtr() + return result + } + get test(): Expression | undefined { + return unpackNode(global.generatedEs2panda._WhileStatementTest(global.context, this.peer)) + } + /** @deprecated */ + setTest(test?: Expression): this { + global.generatedEs2panda._WhileStatementSetTest(global.context, this.peer, passNode(test)) + return this + } + get body(): Statement | undefined { + return unpackNode(global.generatedEs2panda._WhileStatementBody(global.context, this.peer)) + } + protected readonly brandWhileStatement: undefined +} +export function isWhileStatement(node: object | undefined): node is WhileStatement { + return node instanceof WhileStatement +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_WHILE_STATEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_WHILE_STATEMENT, (peer: KNativePointer) => new WhileStatement(peer, Es2pandaAstNodeType.AST_NODE_TYPE_WHILE_STATEMENT)) +} diff --git a/ets1.2/libarkts/src/generated/peers/YieldExpression.ts b/ets1.2/libarkts/src/generated/peers/YieldExpression.ts new file mode 100644 index 0000000000000000000000000000000000000000..1e8b074ebb8cb800fc38f29aa2923a5ab0ce5239 --- /dev/null +++ b/ets1.2/libarkts/src/generated/peers/YieldExpression.ts @@ -0,0 +1,65 @@ +/* + * Copyright (c) 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. + */ + +/* + * THIS FILE IS AUTOGENERATED BY arktscgen. DO NOT EDIT MANUALLY! + */ + +import { + global, + passNode, + passNodeArray, + unpackNonNullableNode, + unpackNode, + unpackNodeArray, + assertValidPeer, + AstNode, + KNativePointer, + nodeByType, + ArktsObject, + unpackString +} from "../../reexport-for-generated" + +import { Es2pandaAstNodeType } from "./../Es2pandaEnums" +import { Expression } from "./Expression" + +export class YieldExpression extends Expression { + constructor(pointer: KNativePointer, astNodeType: Es2pandaAstNodeType) { + super(pointer, astNodeType) + } + static createYieldExpression(argument: Expression | undefined, isDelegate: boolean): YieldExpression { + const result: YieldExpression = new YieldExpression(global.generatedEs2panda._CreateYieldExpression(global.context, passNode(argument), isDelegate), Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION) + result.setChildrenParentPtr() + return result + } + static updateYieldExpression(original: YieldExpression | undefined, argument: Expression | undefined, isDelegate: boolean): YieldExpression { + const result: YieldExpression = new YieldExpression(global.generatedEs2panda._UpdateYieldExpression(global.context, passNode(original), passNode(argument), isDelegate), Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION) + result.setChildrenParentPtr() + return result + } + get hasDelegate(): boolean { + return global.generatedEs2panda._YieldExpressionHasDelegateConst(global.context, this.peer) + } + get argument(): Expression | undefined { + return unpackNode(global.generatedEs2panda._YieldExpressionArgumentConst(global.context, this.peer)) + } + protected readonly brandYieldExpression: undefined +} +export function isYieldExpression(node: object | undefined): node is YieldExpression { + return node instanceof YieldExpression +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION, (peer: KNativePointer) => new YieldExpression(peer, Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION)) +} diff --git a/ets1.2/libarkts/src/index.ts b/ets1.2/libarkts/src/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..730181a83a64bc2512cfd06fe7dbfa841a0bd7ad --- /dev/null +++ b/ets1.2/libarkts/src/index.ts @@ -0,0 +1,46 @@ +/* + * 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. + */ + +export * from "./checkSdk" +export * from "./utils" +export * from "./reexport-for-generated" +export * from "./generated/Es2pandaEnums" +export * from "./generated" + +export * from "./arkts-api/utilities/private" +export * from "./arkts-api/utilities/public" +export * from "./arkts-api/factory/nodeFactory" +export * from "./arkts-api/visitor" +export * from "./arkts-api/AbstractVisitor" +export * from "./arkts-api/ChainExpressionFilter" +export * from "./arkts-api/plugins" +export * from "./arkts-api/ImportStorage" +export * from "./arkts-api/ProgramProvider" +export * from "./arkts-api/node-utilities/Program" +export * from "./arkts-api/node-utilities/ArkTsConfig" + +export * from "./arkts-api/peers/AstNode" +export * from "./arkts-api/peers/Config" +export * from "./arkts-api/peers/Context" +export { GlobalContext } from "./arkts-api/peers/Context" +export * from "./arkts-api/peers/ExternalSource" +export * from "./arkts-api/peers/ImportPathManager" +export * from "./arkts-api/peers/Options" +export { global as arktsGlobal } from "./arkts-api/static/global" +export * from "./arkts-api/static/globalUtils" +export * as arkts from "./arkts-api" + +export * from "./plugin-utils" +export * from "./tracer" diff --git a/ets1.2/libarkts/src/plugin-utils.ts b/ets1.2/libarkts/src/plugin-utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..6cfd9ff5bef0d13280d6ec3a2f3ed0913f37230f --- /dev/null +++ b/ets1.2/libarkts/src/plugin-utils.ts @@ -0,0 +1,134 @@ +/* + * 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 { + Es2pandaContextState, + PluginContext, + ImportStorage, + arktsGlobal, + ChainExpressionFilter, + ProgramTransformer, + Program, + ProgramProvider, + CompilationOptions, + dumpProgramSrcFormatted, +} from "./arkts-api" +import { Tracer } from "./tracer" + +export interface RunTransformerHooks { + onProgramTransformStart?(options: CompilationOptions, program: Program): void + onProgramTransformEnd?(options: CompilationOptions, program: Program): void +} + +class ASTCache { + processedPrograms = new Set() + constructor() { } + find(program: Program): boolean { + return this.processedPrograms.has(program.absoluteName) + } + update(program: Program) { + this.processedPrograms.add(program.absoluteName) + } +} + +export class DumpingHooks implements RunTransformerHooks { + constructor(private state: Es2pandaContextState, private pluginName: string, private dumpAst: boolean = false) { + if (process.env.KOALA_DUMP_PLUGIN_AST) { + this.dumpAst = true + } + } + onProgramTransformStart(options: CompilationOptions, program: Program) { + if (this.dumpAst) { + console.log(`BEFORE ${this.pluginName}:`) + dumpProgramSrcFormatted(program, true) + } + if (!options.isProgramForCodegeneration) arktsGlobal.profiler.transformDepStarted() + } + onProgramTransformEnd(options: CompilationOptions, program: Program) { + if (!options.isProgramForCodegeneration) arktsGlobal.profiler.transformDepEnded(this.state, this.pluginName) + if (this.dumpAst) { + console.log(`AFTER ${this.pluginName}:`) + dumpProgramSrcFormatted(program, true) + } + } +} + + +export function runTransformerOnProgram(program: Program, options: CompilationOptions, transform: ProgramTransformer | undefined, pluginContext: PluginContext, hooks: RunTransformerHooks = {}) { + arktsGlobal.filePath = program.absoluteName + + Tracer.startProgramTracing(program) + + // Perform some additional actions before the transformation start + hooks.onProgramTransformStart?.(options, program) + + // Save currently existing imports in the program + const importStorage = new ImportStorage(program, options.state == Es2pandaContextState.ES2PANDA_STATE_PARSED) + + // Run the plugin itself + transform?.(program, options, pluginContext) + + // Run some common plugins that should be run after plugin usage and depends on the current state + stateSpecificPostFilters(program, options.state) + + // Update internal import information based on import modification by plugin + importStorage.update() + + // Perform some additional actions after the transformation end + hooks.onProgramTransformEnd?.(options, program) + + Tracer.stopProgramTracing() +} + +export function runTransformer(prog: Program, state: Es2pandaContextState, transform: ProgramTransformer | undefined, pluginContext: PluginContext, hooks: RunTransformerHooks = {}) { + // Program provider used to provide programs to transformer dynamically relative to inserted imports + const provider = new ProgramProvider(prog) + + // The first program provided by program provider is the main program + let currentProgram = provider.next() + let isMainProgram = true + + while (currentProgram) { + // Options passed to plugin and hooks + const options: CompilationOptions = { + isProgramForCodegeneration: isProgramForCodegeneration(currentProgram, isMainProgram), + state, + } + + runTransformerOnProgram(currentProgram, options, transform, pluginContext, hooks) + + // The first program is always the main program + isMainProgram = false + + // Proceed to the next program + currentProgram = provider.next() + } +} + +function stateSpecificPostFilters(program: Program, state: Es2pandaContextState) { + if (state == Es2pandaContextState.ES2PANDA_STATE_CHECKED) { + program.setAst(new ChainExpressionFilter().visitor(program.ast)) + } +} + +function isProgramForCodegeneration( + program: Program, + isMainProgram: boolean, +): boolean { + if (!arktsGlobal.isContextGenerateAbcForExternalSourceFiles) { + return isMainProgram + } + return program.isGenAbcForExternal +} diff --git a/ets1.2/libarkts/src/reexport-for-generated.ts b/ets1.2/libarkts/src/reexport-for-generated.ts new file mode 100644 index 0000000000000000000000000000000000000000..824c34447a9b30091ca62115514dd13459808d2c --- /dev/null +++ b/ets1.2/libarkts/src/reexport-for-generated.ts @@ -0,0 +1,51 @@ +/* + * Copyright (c) 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. + */ +export { KNativePointer } from "@koalaui/interop" +export { AstNode } from "./arkts-api/peers/AstNode" +export { ArktsObject, isSameNativeObject } from "./arkts-api/peers/ArktsObject" +export { NodeCache } from "./arkts-api/node-cache" +export { + passNode, + unpackNonNullableNode, + unpackNodeArray, + passNodeArray, + unpackNode, + unpackNonNullableObject, + unpackString, + unpackObject, + assertValidPeer, + updateNodeByNode +} from "./arkts-api/utilities/private" +export { nodeByType } from "./arkts-api/class-by-peer" +export { global } from "./arkts-api/static/global" +export { Es2pandaMemberExpressionKind } from "./generated/Es2pandaEnums" +export { + extension_ETSModuleGetNamespaceFlag, + extension_MethodDefinitionOnUpdate, + extension_MethodDefinitionSetChildrenParentPtr, + extension_ScriptFunctionGetSignaturePointer, + extension_ScriptFunctionSetSignaturePointer, + extension_ScriptFunctionGetPreferredReturnTypePointer, + extension_ScriptFunctionSetPreferredReturnTypePointer, + extension_ExpressionGetPreferredTypePointer, + extension_ExpressionSetPreferredTypePointer, + extension_ProgramGetExternalSources, + extension_SourcePositionGetCol, + extension_SourcePositionGetLine, + extension_SourcePositionToString, + extension_NumberLiteralValue, + extension_ScriptFunctionSetParams, + extension_ClassDefinitionSetBody, +} from "./arkts-api/utilities/extensions" diff --git a/ets1.2/libarkts/src/tracer.ts b/ets1.2/libarkts/src/tracer.ts new file mode 100644 index 0000000000000000000000000000000000000000..10a5773fd49c52edd5f91870f14f860c85741d05 --- /dev/null +++ b/ets1.2/libarkts/src/tracer.ts @@ -0,0 +1,172 @@ +/* + * 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 * as fs from "node:fs" +import * as path from "node:path" +import { Program } from "./generated" +import { global } from "./arkts-api/static/global" + +export class Tracer { + static traceDir: string + static GlobalTracer: Tracer + static Tracers: Map + static LRUTracer: Tracer | undefined + + static startGlobalTracing(outDir: string) { + Tracer.traceDir = path.join(outDir, 'trace') + fs.rmSync(Tracer.traceDir, { force: true, recursive: true }) + const globalTraceFile = path.join(Tracer.traceDir, '.global.txt') + + Tracer.GlobalTracer = new Tracer(globalTraceFile) + Tracer.pushContext('tracer') + traceGlobal(() => `Trace file created at ${globalTraceFile}`, true) + + Tracer.Tracers = new Map() + } + + static startProgramTracing(program: Program) { + if (!Tracer.GlobalTracer) { + return + } + const programPath = program.absoluteName + if (programPath == "") { + return + } + const suggestedTracer = Tracer.Tracers.get(programPath) + if (suggestedTracer) { + Tracer.LRUTracer = suggestedTracer + return + } + if (!global.arktsconfig) { + throw new Error("global.arktsconfig should be set for tracer usage") + } + const relative = path.relative(global.arktsconfig?.baseUrl, programPath) + const traceFileSuggestedPath = relative.startsWith('..') + ? path.join(this.traceDir, 'external', program.absoluteName.slice(1)) + : path.join(this.traceDir, relative) + Tracer.LRUTracer = new Tracer( + path.join(path.dirname(traceFileSuggestedPath), path.basename(traceFileSuggestedPath, path.extname(traceFileSuggestedPath)) + '.txt'), + programPath + ) + } + + static stopProgramTracing() { + Tracer.LRUTracer = undefined + } + + static stopGlobalTracing() { + Tracer.GlobalTracer.traceEventsStats() + } + + private constructor(private traceFilePath: string, inputFilePath?: string) { + if (!fs.existsSync(path.dirname(traceFilePath))) { + fs.mkdirSync(path.dirname(traceFilePath), { recursive: true }) + } + if (inputFilePath) { + Tracer.Tracers.set(inputFilePath, this) + } + } + + trace(traceLog: string | undefined | void) { + if (!traceLog) { + return + } + const lastContext = Tracer.lastContext() + fs.appendFileSync(this.traceFilePath, `[${lastContext.padStart(12)}] ${traceLog}\n`, 'utf-8') + } + + events: Map | undefined + eventsPerContext: Map > | undefined + + recordEvent(event: string) { + if (!this.events) { + this.events = new Map() + } + this.events.set(event, (this.events.get(event) ?? 0) + 1) + + if (!this.eventsPerContext) { + this.eventsPerContext = new Map >() + } + if (!this.eventsPerContext.has(Tracer.lastContext())) { + this.eventsPerContext.set(Tracer.lastContext(), new Map()) + } + const eventsPerContext = this.eventsPerContext.get(Tracer.lastContext()) + eventsPerContext?.set(event, (eventsPerContext.get(event) ?? 0) + 1) + } + + traceEventsStats() { + if (this.events && this.eventsPerContext) { + const maxLength = Math.max( + ...[...this.events.keys()].map(it => `Event "${it}"`.length), + ...[...this.eventsPerContext?.keys()].map(it => ` in context [${it}]`.length), + ) + this.trace(`Events stats:`) + this.events.forEach((eventCnt: number, event: string) => { + this.trace(`${`Event "${event}"`.padEnd(maxLength)}: ${eventCnt}`) + this.eventsPerContext?.forEach((localizedEventsMap: Map, context: string) => { + localizedEventsMap.forEach((localizedEventCnt: number, localizedEvent: string) => { + if (localizedEvent == event) { + this.trace(`${` in context [${context}]`.padEnd(maxLength)}: ${localizedEventCnt}`) + } + }) + }) + }) + } else { + this.trace('No events recorded') + } + Tracer.popContext() + } + + private static contexts: string[] = [] + + static lastContext() { + return Tracer.contexts[Tracer.contexts.length - 1] + } + + static pushContext(newContext: string) { + Tracer.contexts.push(newContext) + } + + static popContext() { + Tracer.contexts.pop() + } +} + +export function traceGlobal(traceLog: () => string | undefined | void, forceLogToConsole: boolean = false) { + if (forceLogToConsole) { + const result = traceLog() + if (result) { + console.log(`[${Tracer.lastContext()}] ${result}`) + } + } + if (!Tracer.GlobalTracer) { + return + } + Tracer.GlobalTracer.trace(traceLog()) +} + +export function trace(event: string, traceLog: () => string | undefined | void, forceLogToConsole: boolean = false) { + if (forceLogToConsole) { + const result = traceLog() + if (result) { + console.log(`[${Tracer.lastContext()}] ${result}`) + } + } + if (!Tracer.GlobalTracer) { + return + } + Tracer.LRUTracer?.trace(traceLog()) + Tracer.GlobalTracer.recordEvent(event) +} diff --git a/ets1.2/libarkts/src/ts-api/factory/nodeFactory.ts b/ets1.2/libarkts/src/ts-api/factory/nodeFactory.ts new file mode 100644 index 0000000000000000000000000000000000000000..641ff6588520ae760776958ed128457fed389402 --- /dev/null +++ b/ets1.2/libarkts/src/ts-api/factory/nodeFactory.ts @@ -0,0 +1,1390 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { throwError } from "../../utils" +import * as ts from "@koalaui/ets-tsc" +import * as arkts from "../../arkts-api" + +import { + passNode, + passNodeArray, + passToken, + passModifiersToScriptFunction, + passModifiers, + passIdentifier, + passTypeParams, + passVariableDeclarationKind, +} from "../utilities/private" +import { + SyntaxKind, + NodeFlags, +} from "../static/enums" +import { + Es2pandaContextState, + Es2pandaPrimitiveType, + Es2pandaMethodDefinitionKind, + Es2pandaModifierFlags, + Es2pandaScriptFunctionFlags, + Es2pandaMemberExpressionKind, + Es2pandaClassDefinitionModifiers, + Es2pandaVariableDeclarationKind, + Es2pandaVariableDeclaratorFlag, +} from "../../arkts-api" +import { + // ts types: + Modifier, + BinaryOperatorToken, + + Node, + Token, + Identifier, + StringLiteral, + FunctionDeclaration, + Block, + KeywordTypeNode, + PropertyAccessExpression, + ParameterDeclaration, + ReturnStatement, + IfStatement, + ExpressionStatement, + CallExpression, + ArrowFunction, + TypeReferenceNode, + BinaryExpression, + FunctionTypeNode, + TypeNode, + Expression, + Statement, + SourceFile, + ClassElement, + MethodDeclaration, + ConstructorDeclaration, + TypeParameterDeclaration, + NumericLiteral, + ClassDeclaration, + VariableDeclaration, + VariableDeclarationList, + VariableStatement, + UnionTypeNode, + SuperExpression, + ParenthesizedExpression, + ImportDeclaration, + ImportClause, + ImportSpecifier, +} from "../types" + +// Improve: add flags and base +export function createNodeFactory() { + return { + createSourceFile, + updateSourceFile, + createIdentifier, + createStringLiteral, + createNumericLiteral, + createFunctionDeclaration, + updateFunctionDeclaration, + createParameterDeclaration, + updateParameterDeclaration, + createETSTypeReferenceNode, + updateTypeReferenceNode, + createKeywordTypeNode, + createBlock, + updateBlock, + createExpressionStatement, + updateExpressionStatement, + createReturnStatement, + updateReturnStatement, + createPropertyAccessExpression, + updatePropertyAccessExpression, + createCallExpression, + updateCallExpression, + createIfStatement, + updateIfStatement, + createToken, + createBinaryExpression, + updateBinaryExpression, + createArrowFunction, + updateArrowFunction, + createFunctionTypeNode, + updateFunctionTypeNode, + createMethodDeclaration, + updateMethodDeclaration, + createConstructorDeclaration, + updateConstructorDeclaration, + createTypeParameterDeclaration, + updateTypeParameterDeclaration, + createClassDeclaration, + updateClassDeclaration, + createVariableDeclarationList, + updateVariableDeclarationList, + createVariableStatement, + updateVariableStatement, + createVariableDeclaration, + updateVariableDeclaration, + createETSUnionTypeNode, + updateETSUnionTypeNode, + createSuper, + updateSuper, + createParenthesizedExpression, + updateParenthesizedExpression, + // createImportDeclaration, + createImportSpecifier, + } + + // @api + // function createSourceFile( + // statements: readonly Statement[], + // endOfFileToken: EndOfFileToken, + // flags: NodeFlags, + // ): SourceFile; + function createSourceFile(source: string, state: Es2pandaContextState = Es2pandaContextState.ES2PANDA_STATE_PARSED): SourceFile { + const node = arkts.EtsScript.createFromSource(source, state) + return new SourceFile(node) + } + + // Improve: fix (now doesn't create a new node) + // @api + // updateSourceFile( + // node: SourceFile, + // statements: readonly Statement[], + // isDeclarationFile?: boolean, + // referencedFiles?: readonly FileReference[], + // typeReferences?: readonly FileReference[], + // hasNoDefaultLib?: boolean, + // libReferences?: readonly FileReference[] + // ): SourceFile; + function updateSourceFile( + node: SourceFile, + statements: readonly Statement[] + ): SourceFile { + return new SourceFile( + arkts.EtsScript.updateByStatements( + node.node, + passNodeArray(statements) + ) + ) + } + + // @api + // createIdentifier( + // text: string + // ): Identifier; + function createIdentifier( + text: string, + typeAnnotation?: TypeNode | undefined + ): Identifier { + return new Identifier( + arkts.factory.createIdentifier( + text, + passNode(typeAnnotation) + ) + ) + } + + // @api + // createStringLiteral( + // text: string, + // isSingleQuote?: boolean + // ): StringLiteral; + function createStringLiteral( + str: string + ): StringLiteral { + return new StringLiteral( + arkts.factory.createStringLiteral( + str + ) + ) + } + + // @api + // createNumericLiteral( + // value: string | number, + // numericLiteralFlags: TokenFlags = TokenFlags.None + // ): NumericLiteral { + function createNumericLiteral( + value: number + ): NumericLiteral { + return new NumericLiteral( + arkts.factory.createNumberLiteral( + value + ) + ) + } + + // @api + // createVariableDeclarationList( + // declarations: readonly VariableDeclaration[], + // flags = NodeFlags.None + // ): VariableDeclarationList + function createVariableDeclarationList( + declarations: readonly VariableDeclaration[], + flags: NodeFlags = NodeFlags.None + ): VariableDeclarationList { + return new VariableDeclarationList( + arkts.factory.createVariableDeclaration( + passModifiers([]), + passVariableDeclarationKind(flags), + passNodeArray(declarations) + ) + ) + } + + // @api + // updateVariableDeclarationList( + // node: VariableDeclarationList, + // declarations: readonly VariableDeclaration[] + // ): VariableDeclarationList + function updateVariableDeclarationList( + node: VariableDeclarationList, + declarations: readonly VariableDeclaration[] + ): VariableDeclarationList { + return new VariableDeclarationList( + arkts.factory.updateVariableDeclaration( + node.node, + passModifiers([]), + passVariableDeclarationKind(node.flags), + passNodeArray(declarations) + ) + ) + } + + // @api + // createVariableStatement( + // modifiers: readonly ModifierLike[] | undefined, + // declarationList: VariableDeclarationList | readonly VariableDeclaration[] + // ): VariableStatement + function createVariableStatement( + modifiers: readonly Modifier[] | undefined, + declarationList: VariableDeclarationList | readonly VariableDeclaration[] + ): VariableStatement { + const node: arkts.VariableDeclaration = (declarationList instanceof VariableDeclarationList) ? declarationList.node : createVariableDeclarationList(declarationList, undefined).node + return new VariableStatement( + arkts.factory.createVariableDeclaration( + passModifiers(modifiers), + node.declarationKind, + node.declarators + ) + ) + } + + // @api + // updateVariableStatement( + // node: VariableStatement, + // modifiers: readonly ModifierLike[] | undefined, + // declarationList: VariableDeclarationList + // ): VariableStatement + function updateVariableStatement( + node: VariableStatement, + modifiers: readonly Modifier[] | undefined, + declarationList: VariableDeclarationList + ): VariableStatement { + return new VariableStatement( + arkts.factory.updateVariableDeclaration( + node.node, + passModifiers(modifiers), + declarationList.node.declarationKind, + declarationList.node.declarators + ) + ) + } + + // @api + // createVariableDeclaration( + // name: string | BindingName, + // exclamationToken: ExclamationToken | undefined, + // type: TypeNode | undefined, + // initializer: Expression | undefined + // ): VariableDeclaration + function createVariableDeclaration( + name: string | Identifier, + exclamationToken: undefined, + type: TypeNode | undefined, + initializer: Expression | undefined + ): VariableDeclaration { + return new VariableDeclaration( + arkts.factory.createVariableDeclarator( + // Improve: maybe incorrect + Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_UNKNOWN, + passIdentifier(name, type), + passNode(initializer) + ) + ) + } + + // @api + // function updateVariableDeclaration( + // node: VariableDeclaration, + // name: BindingName, + // exclamationToken: ExclamationToken | undefined, + // type: TypeNode | undefined, + // initializer: Expression | undefined + // ): VariableDeclaration + function updateVariableDeclaration( + node: VariableDeclaration, + name: Identifier, + exclamationToken: undefined, + type: TypeNode | undefined, + initializer: Expression | undefined + ): VariableDeclaration { + return new VariableDeclaration( + arkts.factory.updateVariableDeclarator( + node.node, + // Improve: maybe incorrect + Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_UNKNOWN, + passIdentifier(name, type), + passNode(initializer) + ) + ) + } + + // @api + // createFunctionDeclaration( + // modifiers: readonly ModifierLike[] | undefined, + // asteriskToken: AsteriskToken | undefined, + // name: string | Identifier | undefined, + // typeParameters: readonly TypeParameterDeclaration[] | undefined, + // parameters: readonly ParameterDeclaration[], + // type: TypeNode | undefined, + // body: Block | undefined + // ): FunctionDeclaration; + function createFunctionDeclaration( + modifiers: readonly Modifier[] | undefined, + asteriskToken: undefined, + name: string | Identifier | undefined, + typeParameters: readonly TypeParameterDeclaration[] | undefined, + parameters: readonly ParameterDeclaration[], + type: TypeNode | undefined, + body: Block | undefined + ): FunctionDeclaration { + return new FunctionDeclaration( + arkts.factory.createFunctionDeclaration( + arkts.factory.createScriptFunction( + body?.node, + arkts.FunctionSignature.create( + passTypeParams(typeParameters), + passNodeArray(parameters), + type?.node + ), + 0, + passModifiers(modifiers) | Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC | Es2pandaModifierFlags.MODIFIER_FLAGS_STATIC, + body === undefined, + passIdentifier(name) + ), + false + ) + ) + } + + // @api + // updateFunctionDeclaration( + // node: FunctionDeclaration, + // modifiers: readonly ModifierLike[] | undefined, + // asteriskToken: AsteriskToken | undefined, + // name: Identifier | undefined, + // typeParameters: readonly TypeParameterDeclaration[] | undefined, + // parameters: readonly ParameterDeclaration[], + // type: TypeNode | undefined, + // body: Block | undefined + // ): FunctionDeclaration; + function updateFunctionDeclaration( + node: FunctionDeclaration, + modifiers: readonly Modifier[] | undefined, + asteriskToken: undefined, + name: Identifier | undefined, + typeParameters: readonly TypeParameterDeclaration[] | undefined, + parameters: readonly ParameterDeclaration[], + type: TypeNode | undefined, + body: Block | undefined + ): FunctionDeclaration { + return new FunctionDeclaration( + arkts.factory.updateFunctionDeclaration( + node.node, + arkts.factory.updateScriptFunction( + node.node.scriptFunction, + body?.node, + arkts.FunctionSignature.create( + passTypeParams(typeParameters), + passNodeArray(parameters), + type?.node + ), + 0, + passModifiers(modifiers) | Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC | Es2pandaModifierFlags.MODIFIER_FLAGS_STATIC, + body === undefined, + passIdentifier(name) + ), + false + ) + ) + } + + // @api + // createParameterDeclaration( + // modifiers: readonly ModifierLike[] | undefined, + // dotDotDotToken: DotDotDotToken | undefined, + // name: string | BindingName, + // questionToken?: QuestionToken, + // type?: TypeNode, + // initializer?: Expression + // ): ParameterDeclaration; + function createParameterDeclaration( + modifiers: readonly Modifier[] | undefined, + dotDotDotToken: undefined, + name: string | Identifier, + questionToken?: undefined, + type?: TypeNode, + initializer?: Expression + ): ParameterDeclaration { + return new ParameterDeclaration( + arkts.factory.createParameterDeclaration( + arkts.factory.createIdentifier( + (name instanceof Identifier) ? name.node.name : name, + type?.node + ), + initializer?.node + ) + ) + } + + // @api + // function updateParameterDeclaration( + // node: ParameterDeclaration, + // modifiers: readonly ModifierLike[] | undefined, + // dotDotDotToken: DotDotDotToken | undefined, + // name: string | BindingName, + // questionToken: QuestionToken | undefined, + // type: TypeNode | undefined, + // initializer: Expression | undefined, + // ): ParameterDeclaration + function updateParameterDeclaration( + node: ParameterDeclaration, + modifiers: readonly Modifier[] | undefined, + dotDotDotToken: undefined, + name: string | Identifier, + questionToken?: undefined, + type?: TypeNode, + initializer?: Expression + ): ParameterDeclaration { + return new ParameterDeclaration( + arkts.factory.updateParameterDeclaration( + node.node, + arkts.factory.createIdentifier( + (name instanceof Identifier) ? name.node.name : name, + type?.node + ), + initializer?.node + ) + ) + } + + // @api + // createTypeParameterDeclaration( + // modifiers: readonly Modifier[] | undefined, + // name: string | Identifier, + // constraint?: TypeNode, + // defaultType?: TypeNode + // ): TypeParameterDeclaration; + function createTypeParameterDeclaration( + modifiers: readonly Modifier[] | undefined, + name: string | Identifier, + constraint?: TypeNode, + defaultType?: TypeNode + ): TypeParameterDeclaration { + return new TypeParameterDeclaration( + arkts.factory.createTypeParameter( + passIdentifier(name), + constraint?.node, + defaultType?.node, + passModifiers(modifiers) + ) + ) + } + + // @api + // function updateTypeParameterDeclaration( + // node: TypeParameterDeclaration, + // modifiers: readonly Modifier[] | undefined, + // name: Identifier, + // constraint: TypeNode | undefined, + // defaultType: TypeNode | undefined + // ): TypeParameterDeclaration + function updateTypeParameterDeclaration( + node: TypeParameterDeclaration, + modifiers: readonly Modifier[] | undefined, + name: string | Identifier, + constraint?: TypeNode, + defaultType?: TypeNode + ): TypeParameterDeclaration { + return new TypeParameterDeclaration( + arkts.factory.updateTypeParameter( + node.node, + passIdentifier(name), + constraint?.node, + defaultType?.node, + passModifiers(modifiers) + ) + ) + } + + // @api + // createETSUnionTypeNode( + // types: readonly TypeNode[] + // ): UnionTypeNode + function createETSUnionTypeNode( + types: readonly TypeNode[] + ): UnionTypeNode { + return new UnionTypeNode( + arkts.factory.createETSUnionType( + passNodeArray(types) + ) + ) + } + + // @api + // function updateETSUnionTypeNode( + // node: UnionTypeNode, + // types: NodeArray + // ): UnionTypeNode + function updateETSUnionTypeNode( + node: UnionTypeNode, + types: readonly TypeNode[] + ): UnionTypeNode { + return new UnionTypeNode( + arkts.factory.updateETSUnionType( + node.node, + passNodeArray(types) + ) + ) + + } + + // @api + // createETSTypeReferenceNode( + // typeName: string | EntityName, + // typeArguments?: readonly TypeNode[] + // ): TypeReferenceNode; + function createETSTypeReferenceNode( + typeName: Identifier, + typeArguments?: undefined + ): TypeReferenceNode { + return new TypeReferenceNode( + arkts.factory.createETSTypeReferenceFromId( + typeName.node + ) + ) + } + + // @api + // function updateTypeReferenceNode( + // node: TypeReferenceNode, + // typeName: EntityName, + // typeArguments: NodeArray | undefined + // ): TypeReferenceNode + function updateTypeReferenceNode( + node: TypeReferenceNode, + typeName: Identifier, + typeArguments?: undefined + ): TypeReferenceNode { + return new TypeReferenceNode( + arkts.factory.updateTypeReferenceFromId( + node.node, + typeName.node + ) + ) + } + + // @api + // createKeywordTypeNode( + // kind: TKind + // ): KeywordTypeNode; + function createKeywordTypeNode( + TKind: ts.KeywordTypeSyntaxKind + ): KeywordTypeNode { + function createKeywordTypeNodeFromString( + keyword: string + ): KeywordTypeNode { + return new KeywordTypeNode( + arkts.factory.createETSTypeReferenceFromId( + arkts.factory.createIdentifier( + keyword + ) + ) + ) + } + + function createKeywordTypeNodeFromKind( + kind: number + ): KeywordTypeNode { + return new KeywordTypeNode( + arkts.factory.createPrimitiveType( + kind + ) + ) + } + + const keywords = new Map([ + [ts.SyntaxKind.NumberKeyword, createKeywordTypeNodeFromString("number")], + [ts.SyntaxKind.StringKeyword, createKeywordTypeNodeFromString("string")], + [ts.SyntaxKind.AnyKeyword, createKeywordTypeNodeFromString("any")], + [ts.SyntaxKind.VoidKeyword, createKeywordTypeNodeFromKind(8)], + ]) + return keywords.get(TKind) ?? throwError('unsupported keyword') + } + + // @api + // createBlock( + // statements: readonly Statement[], + // multiLine?: boolean + // ): Block; + function createBlock( + statements: readonly Statement[], + multiline?: boolean + ): Block { + return new Block( + arkts.factory.createBlock( + passNodeArray(statements) + ) + ) + } + + // @api + // updateBlock( + // node: Block, + // statements: readonly Statement[] + // ): Block; + function updateBlock( + node: Block, + statements: readonly Statement[] + ): Block { + return new Block( + arkts.factory.updateBlock( + node.node, + passNodeArray(statements) + ) + ) + } + + // @api + // createExpressionStatement( + // expression: Expression + // ): ExpressionStatement; + function createExpressionStatement( + expression: Expression + ): ExpressionStatement { + return new ExpressionStatement( + arkts.factory.createExpressionStatement( + expression.node + ) + ) + } + + // @api + // updateExpressionStatement( + // node: ExpressionStatement, + // expression: Expression + // ): ExpressionStatement; + function updateExpressionStatement( + node: ExpressionStatement, + expression: Expression + ): ExpressionStatement { + return new ExpressionStatement( + arkts.factory.updateExpressionStatement( + node.node, + expression.node + ) + ) + } + + // @api + // createReturnStatement( + // expression?: Expression + // ): ReturnStatement; + function createReturnStatement( + expression: Expression + ): ReturnStatement { + return new ReturnStatement( + arkts.factory.createReturnStatement( + expression.node + ) + ) + } + + // @api + // function updateReturnStatement( + // node: ReturnStatement, + // expression: Expression | undefined + // ): ReturnStatement + function updateReturnStatement( + node: ReturnStatement, + expression: Expression + ): ReturnStatement { + return new ReturnStatement( + arkts.factory.updateReturnStatement( + node.node, + expression.node + ) + ) + } + + // @api + // createPropertyAccessExpression( + // expression: Expression, + // name: string | MemberName + // ): PropertyAccessExpression; + function createPropertyAccessExpression( + expression: Expression, + name: string | Identifier + ): PropertyAccessExpression { + return new PropertyAccessExpression( + arkts.factory.createMemberExpression( + expression.node, + passIdentifier(name), + Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ) + ) + } + + // @api + // updatePropertyAccessExpression( + // node: PropertyAccessExpression, + // expression: Expression, + // name: MemberName + // ): PropertyAccessExpression; + function updatePropertyAccessExpression( + node: PropertyAccessExpression, + expression: Expression, + name: Identifier + ): PropertyAccessExpression { + return new PropertyAccessExpression( + arkts.factory.updateMemberExpression( + node.node, + expression.node, + passIdentifier(name), + Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ) + ) + } + + // @api + // createCallExpression( + // expression: Expression, + // typeArguments: readonly TypeNode[] | undefined, + // argumentsArray: readonly Expression[] | undefined + // ): CallExpression; + function createCallExpression( + expression: Expression, + typeArguments: readonly TypeNode[] | undefined, + argumentsArray: readonly Expression[] | undefined + ): CallExpression { + return new CallExpression( + arkts.factory.createCallExpression( + expression.node, + (typeArguments !== undefined) ? + arkts.factory.createTypeParameterDeclaration(passNodeArray(typeArguments)) : undefined, + passNodeArray(argumentsArray) + ) + ) + } + + // @api + // updateCallExpression( + // node: CallExpression, + // expression: Expression, + // typeArguments: readonly TypeNode[] | undefined, + // argumentsArray: readonly Expression[] + // ): CallExpression; + function updateCallExpression( + node: CallExpression, + expression: Expression, + typeArguments: readonly TypeNode[] | undefined, + argumentsArray: readonly Expression[] | undefined + ): CallExpression { + return new CallExpression( + arkts.factory.updateCallExpression( + node.node, + expression.node, + (typeArguments !== undefined) ? + arkts.factory.createTypeParameterDeclaration(passNodeArray(typeArguments)) : undefined, + passNodeArray(argumentsArray) + ) + ) + } + + // @api + // createIfStatement( + // expression: Expression, + // thenStatement: Statement, + // elseStatement?: Statement + // ): IfStatement; + function createIfStatement( + expression: Expression, + thenStatement: Statement, + elseStatement?: undefined + ): IfStatement { + return new IfStatement( + arkts.factory.createIfStatement( + passNode(expression), + passNode(thenStatement), + passNode(elseStatement), + ) + ) + } + + // @api + // updateIfStatement( + // expression: Expression, + // thenStatement: Statement, + // elseStatement: Statement | undefined + // ): IfStatement; + function updateIfStatement( + node: IfStatement, + expression: Expression, + thenStatement: Statement, + elseStatement?: undefined + ): IfStatement { + return new IfStatement( + arkts.factory.updateIfStatement( + node.node, + passNode(expression), + passNode(thenStatement), + passNode(elseStatement), + ) + ) + } + + // Improve: rewrite maybe + // @api + // createToken( + // token: SyntaxKind._ + // ): _; + function createToken( + token: TKind + ) { + return new Token(token) + } + + // @api + // createBinaryExpression( + // left: Expression, + // operator: BinaryOperator | BinaryOperatorToken, + // right: Expression + // ): BinaryExpression; + function createBinaryExpression( + left: Expression, + operator: BinaryOperatorToken, + right: Expression + ): BinaryExpression { + return new BinaryExpression( + arkts.factory.createBinaryExpression( + passNode(left), + passToken(operator), + passNode(right), + ) + ) + } + + // @api + // function updateBinaryExpression( + // node: BinaryExpression, + // left: Expression, + // operator: BinaryOperatorToken, + // right: Expression + // ): BinaryExpression + function updateBinaryExpression( + node: BinaryExpression, + left: Expression, + operator: BinaryOperatorToken, + right: Expression + ): BinaryExpression { + return new BinaryExpression( + arkts.factory.updateBinaryExpression( + node.node, + passNode(left), + passToken(operator), + passNode(right), + ) + ) + } + + // @api + // createArrowFunction( + // modifiers: readonly Modifier[] | undefined, + // typeParameters: readonly TypeParameterDeclaration[] | undefined, + // parameters: readonly ParameterDeclaration[], + // type: TypeNode | undefined, + // equalsGreaterThanToken: EqualsGreaterThanToken | undefined, + // body: ConciseBody + // ): ArrowFunction; + function createArrowFunction( + modifiers: readonly Modifier[] | undefined, + typeParameters: readonly TypeParameterDeclaration[] | undefined, + parameters: readonly ParameterDeclaration[], + type: TypeNode | undefined, + equalsGreaterThanToken: Token | undefined, + body: Block + ) { + return new ArrowFunction( + arkts.factory.createArrowFunction( + arkts.factory.createScriptFunction( + passNode(body), + arkts.FunctionSignature.create( + passTypeParams(typeParameters), + passNodeArray(parameters), + passNode(type) + ), + passModifiersToScriptFunction(modifiers) | Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW, + passModifiers(modifiers) | Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + false, + undefined + ) + ) + ) + } + + // @api + // function updateArrowFunction( + // node: ArrowFunction, + // modifiers: readonly Modifier[] | undefined, + // typeParameters: readonly TypeParameterDeclaration[] | undefined, + // parameters: readonly ParameterDeclaration[], + // type: TypeNode | undefined, + // equalsGreaterThanToken: EqualsGreaterThanToken, + // body: ConciseBody, + // ): ArrowFunction + function updateArrowFunction( + node: ArrowFunction, + modifiers: readonly Modifier[] | undefined, + typeParameters: readonly TypeParameterDeclaration[] | undefined, + parameters: readonly ParameterDeclaration[], + type: undefined, + equalsGreaterThanToken: Token | undefined, + body: Block, + ): ArrowFunction { + return new ArrowFunction( + arkts.factory.updateArrowFunction( + node.node, + arkts.factory.updateScriptFunction( + node.node.scriptFunction, + passNode(body), + arkts.FunctionSignature.create( + passTypeParams(typeParameters), + passNodeArray(parameters), + passNode(type) + ), + passModifiersToScriptFunction(modifiers) | Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ARROW, + passModifiers(modifiers) | Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + false, + undefined + ) + ) + ) + } + + // @api + // function createClassDeclaration( + // modifiers: readonly ModifierLike[] | undefined, + // name: string | Identifier | undefined, + // typeParameters: readonly TypeParameterDeclaration[] | undefined, + // heritageClauses: readonly HeritageClause[] | undefined, + // members: readonly ClassElement[], + // ): ClassDeclaration + function createClassDeclaration( + modifiers: readonly Modifier[] | undefined, + name: string | Identifier | undefined, + typeParameters: readonly TypeParameterDeclaration[] | undefined, + heritageClauses: readonly TypeParameterDeclaration[] | undefined, + members: readonly ClassElement[] + ): ClassDeclaration { + return new ClassDeclaration( + arkts.factory.createClassDeclaration( + arkts.factory.createClassDefinition( + passIdentifier(name), + passNodeArray(members), + // passModifiers(modifiers) | es2panda_ModifierFlags.MODIFIER_FLAGS_PUBLIC | es2panda_ModifierFlags.MODIFIER_FLAGS_STATIC, + Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + // Improve: pass through modifiers + Es2pandaClassDefinitionModifiers.CLASS_DEFINITION_MODIFIERS_NONE, + passTypeParams(typeParameters), + undefined + ) + ) + ) + } + + // @api + // updateClassDeclaration( + // node: ClassDeclaration, + // modifiers: readonly ModifierLike[] | undefined, + // name: Identifier | undefined, + // typeParameters: readonly TypeParameterDeclaration[] | undefined, + // heritageClauses: readonly HeritageClause[] | undefined, + // members: readonly ClassElement[] + // ): ClassDeclaration; + function updateClassDeclaration( + node: ClassDeclaration, + modifiers: readonly Modifier[] | undefined, + name: Identifier | undefined, + typeParameters: readonly TypeParameterDeclaration[] | undefined, + heritageClauses: undefined, + members: readonly ClassElement[] + ): ClassDeclaration { + return new ClassDeclaration( + arkts.factory.updateClassDeclaration( + node.node, + arkts.factory.updateClassDefinition( + node.node.definition, + passIdentifier(name), + passNodeArray(members), + // passModifiers(modifiers) | es2panda_ModifierFlags.MODIFIER_FLAGS_PUBLIC | es2panda_ModifierFlags.MODIFIER_FLAGS_STATIC, + Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + // Improve: pass through modifiers + Es2pandaClassDefinitionModifiers.CLASS_DEFINITION_MODIFIERS_NONE, + passTypeParams(typeParameters) + ) + ) + ) + } + + // @api + // tsc: createFunctionTypeNode( + // typeParameters: readonly TypeParameterDeclaration[] | undefined, + // parameters: readonly ParameterDeclaration[], + // type: TypeNode + // ): FunctionTypeNode; + function createFunctionTypeNode( + typeParameters: readonly TypeParameterDeclaration[] | undefined, + parameters: readonly ParameterDeclaration[], + type: TypeNode + ): FunctionTypeNode { + return new FunctionTypeNode( + arkts.factory.createFunctionType( + arkts.FunctionSignature.create( + passTypeParams(typeParameters), + passNodeArray(parameters), + passNode(type) + ), + Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_NONE + ) + ) + } + + // @api + // function updateFunctionTypeNode( + // node: FunctionTypeNode, + // typeParameters: NodeArray | undefined, + // parameters: NodeArray, + // type: TypeNode, + // ): FunctionTypeNode + function updateFunctionTypeNode( + node: FunctionTypeNode, + typeParameters: readonly TypeParameterDeclaration[] | undefined, + parameters: readonly ParameterDeclaration[], + type: TypeNode + ): FunctionTypeNode { + return new FunctionTypeNode( + arkts.factory.updateFunctionType( + node.node, + arkts.FunctionSignature.create( + passTypeParams(typeParameters), + passNodeArray(parameters), + passNode(type) + ), + Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_NONE + ) + ) + } + + // Improve: fix modifiers + // @api + // createMethodDeclaration( + // modifiers: readonly ModifierLike[] | undefined, + // asteriskToken: AsteriskToken | undefined, + // name: string | PropertyName, + // questionToken: QuestionToken | undefined, + // typeParameters: readonly TypeParameterDeclaration[] | undefined, + // parameters: readonly ParameterDeclaration[], + // type: TypeNode | undefined, + // body: Block | undefined + // ): MethodDeclaration; + function createMethodDeclaration( + modifiers: readonly Modifier[] | undefined, + asteriskToken: undefined, + name: string | Identifier, + questionToken: undefined, + typeParameters: readonly TypeParameterDeclaration[] | undefined, + parameters: readonly ParameterDeclaration[], + type: TypeNode | undefined, + body: Block | undefined + ): MethodDeclaration { + const _name = passIdentifier(name) + return new MethodDeclaration( + arkts.factory.createMethodDefinition( + Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD, + _name, + arkts.factory.createFunctionExpression( + arkts.factory.createScriptFunction( + passNode(body), + arkts.FunctionSignature.create( + passTypeParams(typeParameters), + passNodeArray(parameters), + passNode(type) + ), + 0, + passModifiers(modifiers) | Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC || Es2pandaModifierFlags.MODIFIER_FLAGS_STATIC, + false, + _name + ) + ), + passModifiers(modifiers), + false + ) + ) + } + + // @api + // tsc: updateMethodDeclaration( + // node: MethodDeclaration, + // modifiers: readonly ModifierLike[] | undefined, + // asteriskToken: AsteriskToken | undefined, + // name: PropertyName, + // questionToken: QuestionToken | undefined, + // typeParameters: readonly TypeParameterDeclaration[] | undefined, + // parameters: readonly ParameterDeclaration[], + // type: TypeNode | undefined, + // body: Block | undefined + // ): MethodDeclaration; + function updateMethodDeclaration( + node: MethodDeclaration, + modifiers: readonly Modifier[] | undefined, + asteriskToken: undefined, + name: Identifier, + questionToken: undefined, + typeParameters: readonly TypeParameterDeclaration[] | undefined, + parameters: readonly ParameterDeclaration[], + type: undefined, + body: Block | undefined + ): MethodDeclaration { + const _name = passIdentifier(name) + return new MethodDeclaration( + arkts.factory.updateMethodDefinition( + node.node, + Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD, + _name, + arkts.factory.createFunctionExpression( + // Improve: maybe fix + arkts.factory.updateScriptFunction( + node.node.scriptFunction, + passNode(body), + arkts.FunctionSignature.create( + passTypeParams(typeParameters), + passNodeArray(parameters), + passNode(type) + ), + 0, + passModifiers(modifiers) | Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC || Es2pandaModifierFlags.MODIFIER_FLAGS_STATIC, + false, + _name + ) + ), + passModifiers(modifiers), + false + ) + ) + } + + // @api + // createConstructorDeclaration( + // modifiers: readonly ModifierLike[] | undefined, + // parameters: readonly ParameterDeclaration[], + // body: Block | undefined + // ): ConstructorDeclaration; + function createConstructorDeclaration( + modifiers: readonly Modifier[] | undefined, + parameters: readonly ParameterDeclaration[], + body: Block | undefined + ): ConstructorDeclaration { + const _name = arkts.factory.createIdentifier( + "constructor" + ) + return new ConstructorDeclaration( + arkts.factory.createMethodDefinition( + Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_CONSTRUCTOR, + _name, + arkts.factory.createFunctionExpression( + arkts.factory.createScriptFunction( + passNode(body), + arkts.FunctionSignature.create( + undefined, + passNodeArray(parameters), + // Improve: change to void maybe + undefined + ), + passModifiersToScriptFunction(modifiers) | Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_CONSTRUCTOR, + passModifiers(modifiers) | Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC | Es2pandaModifierFlags.MODIFIER_FLAGS_CONSTRUCTOR, + false, + _name + ) + ), + passModifiers(modifiers) | Es2pandaModifierFlags.MODIFIER_FLAGS_CONSTRUCTOR, + false + ) + ) + } + + // @api + // function updateConstructorDeclaration( + // node: ConstructorDeclaration, + // modifiers: readonly ModifierLike[] | undefined, + // parameters: readonly ParameterDeclaration[], + // body: Block | undefined, + // ): ConstructorDeclaration + function updateConstructorDeclaration( + node: ConstructorDeclaration, + modifiers: readonly Modifier[] | undefined, + parameters: readonly ParameterDeclaration[], + body: Block | undefined + ): ConstructorDeclaration { + const _name = arkts.factory.updateIdentifier( + node.node.name, + "constructor" + ) + return new ConstructorDeclaration( + arkts.factory.updateMethodDefinition( + node.node, + Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_CONSTRUCTOR, + _name, + arkts.factory.createFunctionExpression( + // Improve: maybe fix + arkts.factory.updateScriptFunction( + node.node.scriptFunction, + passNode(body), + arkts.FunctionSignature.create( + undefined, + passNodeArray(parameters), + // Improve: change to void maybe + undefined + ), + passModifiersToScriptFunction(modifiers) | Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_CONSTRUCTOR, + passModifiers(modifiers) | Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC | Es2pandaModifierFlags.MODIFIER_FLAGS_CONSTRUCTOR, + false, + _name + ) + ), + passModifiers(modifiers) | Es2pandaModifierFlags.MODIFIER_FLAGS_CONSTRUCTOR, + false + ) + ) + + } + + // @api + // tsc: createSuper( + // ): SuperExpression; + function createSuper( + ): SuperExpression { + return new SuperExpression( + arkts.factory.createSuperExpression() + ) + } + + // @api + // tsc: updateSuper( + // node: SuperExpression + // ): SuperExpression; + function updateSuper( + node: SuperExpression + ): SuperExpression { + return new SuperExpression( + arkts.factory.updateSuperExpression( + node.node, + ) + ) + } + + // @api + // tsc: createParenthesizedExpression( + // expression: Expression + // ): ParenthesizedExpression; + function createParenthesizedExpression( + expression: Expression + ): ParenthesizedExpression { + return expression + // Improve: + // return new ParenthesizedExpression( + // expression + // ) + } + + // @api + // tsc: updateParenthesizedExpression( + // node: ParenthesizedExpression, + // expression: Expression + // ): ParenthesizedExpression; + function updateParenthesizedExpression( + node: ParenthesizedExpression, + expression: Expression + ): ParenthesizedExpression { + return expression + // Improve: + // return new ParenthesizedExpression( + // expression + // ) + } + + // // @api + // // createImportDeclaration( + // // decorators: readonly Decorator[] | undefined, + // // modifiers: readonly Modifier[] | undefined, + // // importClause: ImportClause | undefined, + // // moduleSpecifier: Expression, + // // assertClause?: AssertClause + // // ): ImportDeclaration; + // function createImportDeclaration( + // decorators: undefined, + // modifiers: readonly Modifier[] | undefined, + // importClause: ImportClause | undefined, + // moduleSpecifier: StringLiteral, + // assertClause?: undefined + // ): ImportDeclaration { + // return new ImportDeclaration( + // arkts.EtsImportDeclaration.create( + // undefined, + // arkts.ImportSource.create(moduleSpecifier.node), + + // ) + // ) + // } + + // @api + // createImportSpecifier( + // isTypeOnly: boolean, + // propertyName: Identifier | undefined, + // name: Identifier + // ): ImportSpecifier; + function createImportSpecifier( + isTypeOnly: boolean, + propertyName: Identifier | undefined, + name: Identifier + ): ImportSpecifier { + return new ImportSpecifier( + name.node + ) + } +} + +export const factory = createNodeFactory(); diff --git a/ets1.2/libarkts/src/ts-api/factory/nodeTests.ts b/ets1.2/libarkts/src/ts-api/factory/nodeTests.ts new file mode 100644 index 0000000000000000000000000000000000000000..d108973f6f6d71daed654069d533cb86a8d8e02c --- /dev/null +++ b/ets1.2/libarkts/src/ts-api/factory/nodeTests.ts @@ -0,0 +1,125 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { SyntaxKind, } from "@koalaui/ets-tsc" + +import { + ArrowFunction, + Block, + CallExpression, + ClassDeclaration, + ExpressionStatement, + FunctionDeclaration, + FunctionExpression, + FunctionTypeNode, + GetAccessorDeclaration, + Identifier, + MethodDeclaration, + MethodSignature, + Node, + ParameterDeclaration, + PropertyAccessExpression, + PropertyDeclaration, + PropertySignature, + SetAccessorDeclaration, + SourceFile, + VariableDeclaration, + VariableDeclarationList, + VariableStatement, +} from "../types" + +export function isIdentifier(node: Node): node is Identifier { + return node.kind === SyntaxKind.Identifier +} + +export function isCallExpression(node: Node): node is CallExpression { + return node.kind === SyntaxKind.CallExpression +} + +export function isPropertyAccessExpression(node: Node): node is PropertyAccessExpression { + return node.kind === SyntaxKind.PropertyAccessExpression +} + +export function isFunctionDeclaration(node: Node): node is FunctionDeclaration { + return node.kind === SyntaxKind.FunctionDeclaration +} + +export function isMethodDeclaration(node: Node): node is MethodDeclaration { + return node.kind === SyntaxKind.MethodDeclaration +} + +export function isSourceFile(node: Node): node is SourceFile { + return node.kind === SyntaxKind.SourceFile +} + +export function isExpressionStatement(node: Node): node is ExpressionStatement { + return node.kind === SyntaxKind.ExpressionStatement +} + +export function isArrowFunction(node: Node): node is ArrowFunction { + return node.kind === SyntaxKind.ArrowFunction +} + +export function isClassDeclaration(node: Node): node is ClassDeclaration { + return node.kind === SyntaxKind.ClassDeclaration +} + +export function isBlock(node: Node): node is Block { + return node.kind === SyntaxKind.Block +} + +export function isFunctionExpression(node: Node): node is FunctionExpression { + return node.kind === SyntaxKind.FunctionExpression +} + +export function isParameter(node: Node): node is ParameterDeclaration { + return node.kind === SyntaxKind.Parameter +} + +export function isVariableDeclaration(node: Node): node is VariableDeclaration { + return node.kind === SyntaxKind.VariableDeclaration +} + +export function isVariableDeclarationList(node: Node): node is VariableDeclarationList { + return node.kind === SyntaxKind.VariableDeclarationList +} + +export function isPropertyDeclaration(node: Node): node is PropertyDeclaration { + return node.kind === SyntaxKind.PropertyDeclaration +} + +export function isPropertySignature(node: Node): node is PropertySignature { + return node.kind === SyntaxKind.PropertySignature +} + +export function isFunctionTypeNode(node: Node): node is FunctionTypeNode { + return node.kind === SyntaxKind.FunctionType +} + +export function isMethodSignature(node: Node): node is MethodSignature { + return node.kind === SyntaxKind.MethodSignature +} + +export function isGetAccessorDeclaration(node: Node): node is GetAccessorDeclaration { + return node.kind === SyntaxKind.GetAccessor +} + +export function isSetAccessorDeclaration(node: Node): node is SetAccessorDeclaration { + return node.kind === SyntaxKind.SetAccessor +} + +export function isVariableStatement(node: Node): node is VariableStatement { + return node.kind === SyntaxKind.VariableStatement +} diff --git a/ets1.2/libarkts/src/ts-api/index.ts b/ets1.2/libarkts/src/ts-api/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..439eb8086b290dd4a39a7f2f2908fe7dd5574e9d --- /dev/null +++ b/ets1.2/libarkts/src/ts-api/index.ts @@ -0,0 +1,35 @@ +/* + * 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. + */ + +// Improve: remove private export +export * from "./utilities/private" +export * from "./utilities/public" +export * from "./types" +export * from "./factory/nodeFactory" +export * from "./factory/nodeTests" +export { + visitEachChild, +} from "./visitor/visitor" +export { + SyntaxKind, + NodeFlags, +} from "./static/enums" + +// from ArkTS api +export * from "../arkts-api/static/global" +export { + Es2pandaContextState as ContextState, + Es2pandaPrimitiveType as Es2pandaPrimitiveType, +} from "../arkts-api" diff --git a/ets1.2/libarkts/src/ts-api/static/enums.ts b/ets1.2/libarkts/src/ts-api/static/enums.ts new file mode 100644 index 0000000000000000000000000000000000000000..78dc895df7ecda4ff446e39b9edd61d465cd5eec --- /dev/null +++ b/ets1.2/libarkts/src/ts-api/static/enums.ts @@ -0,0 +1,18 @@ +/* + * 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. + */ + +export { SyntaxKind } from "@koalaui/ets-tsc" +export { TokenSyntaxKind } from "@koalaui/ets-tsc" +export { NodeFlags } from "@koalaui/ets-tsc" diff --git a/ets1.2/libarkts/src/ts-api/types.ts b/ets1.2/libarkts/src/ts-api/types.ts new file mode 100644 index 0000000000000000000000000000000000000000..dd265808a583e65d04266365a1eaa63c292f4310 --- /dev/null +++ b/ets1.2/libarkts/src/ts-api/types.ts @@ -0,0 +1,935 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as ts from "@koalaui/ets-tsc" +import * as arkts from "../arkts-api" + +import { throwError } from "../utils" +import { + passModifiers, + emptyImplementation, + unpackModifiers, + unpackNode, + unpackNodeArray, + unpackVariableDeclarationKind, +} from "./utilities/private" +import { SyntaxKind } from "./static/enums" + +// Improve: write implementation +export interface TransformationContext {} + +// Improve: write implementation +export interface Program {} + +// Improve: remove U type param +export type NodeArray, U extends arkts.AstNode | undefined = arkts.AstNode | undefined> = ts.NodeArray + +export abstract class Node implements ts.Node { + constructor(node: T) { + this.node = node + } + + readonly node: T + + // Improve: remove any + get parent(): any { + if (this.node === undefined) { + throwError('trying to get parent of undefined _node') + } + return unpackNode(this.node.parent) + } + + set parent(node: Node) { + if (this.node === undefined) { + throwError('trying to set parent of undefined') + } + if (node.node === undefined) { + throwError('trying to set parent to undefined') + } + this.node.parent = node.node + } + + set modifiers(flags: readonly Modifier[] | undefined) { + if (this.node === undefined) { + throwError('trying to set modifiers of undefined') + } + this.node.modifiers = passModifiers(flags) + } + + get modifiers(): NodeArray { + return unpackModifiers(this.node?.modifiers) + } + + abstract kind: SyntaxKind + + // Improve: + forEachChild(cbNode: (node: ts.Node) => T | undefined, cbNodeArray?: ((nodes: ts.NodeArray) => T | undefined) | undefined): T | undefined { throw new Error("Method not implemented.") } + getSourceFile(): ts.SourceFile { throw new Error("Method not implemented.") } + getChildCount(sourceFile?: ts.SourceFile | undefined): number { throw new Error("Method not implemented.") } + getChildAt(index: number, sourceFile?: ts.SourceFile | undefined): ts.Node { throw new Error("Method not implemented.") } + getChildren(sourceFile?: ts.SourceFile | undefined): ts.Node[] { throw new Error("Method not implemented.") } + + getStart(sourceFile?: ts.SourceFile | undefined, includeJsDocComment?: boolean | undefined): number { throw new Error("Method not implemented.") } + getFullStart(): number { throw new Error("Method not implemented.") } + getEnd(): number { throw new Error("Method not implemented.") } + getWidth(sourceFile?: ts.SourceFileLike | undefined): number { throw new Error("Method not implemented.") } + getFullWidth(): number { throw new Error("Method not implemented.") } + getLeadingTriviaWidth(sourceFile?: ts.SourceFile | undefined): number { throw new Error("Method not implemented.") } + getFullText(sourceFile?: ts.SourceFile | undefined): string { throw new Error("Method not implemented.") } + getText(sourceFile?: ts.SourceFile | undefined): string { throw new Error("Method not implemented.") } + getFirstToken(sourceFile?: ts.SourceFile | undefined): ts.Node | undefined { throw new Error("Method not implemented.") } + getLastToken(sourceFile?: ts.SourceFile | undefined): ts.Node | undefined { throw new Error("Method not implemented.") } + + get symbol(): ts.Symbol { return emptyImplementation() } + get flags(): ts.NodeFlags { return emptyImplementation() } + get pos(): number { return emptyImplementation() } + get end(): number { return emptyImplementation() } +} + +// Improve: add all tokens +export type BinaryOperator = + | ts.SyntaxKind.PlusToken + | ts.SyntaxKind.MinusToken + + | ts.SyntaxKind.AsteriskToken + +export type BinaryOperatorToken = Token; + +// Improve: rethink maybe (temporary solution) +export class Token extends Node { + constructor(kind: TKind) { + super(undefined) + this.kind = kind + } + + readonly kind: TKind; +} + +export type ModifierSyntaxKind = + // | SyntaxKind.ConstructorKeyword + | SyntaxKind.AbstractKeyword + | SyntaxKind.AccessorKeyword + | SyntaxKind.AsyncKeyword + | SyntaxKind.ConstKeyword + | SyntaxKind.DeclareKeyword + | SyntaxKind.DefaultKeyword + | SyntaxKind.ExportKeyword + | SyntaxKind.InKeyword + | SyntaxKind.PrivateKeyword + | SyntaxKind.ProtectedKeyword + | SyntaxKind.PublicKeyword + | SyntaxKind.ReadonlyKeyword + | SyntaxKind.OutKeyword + | SyntaxKind.OverrideKeyword + | SyntaxKind.StaticKeyword; + +export class Modifier extends Node { + constructor(kind: ModifierSyntaxKind) { + super(undefined) + this.kind = kind + } + + public toString(): string { + return `${this.kind}` + } + + kind: ModifierSyntaxKind +} + +export abstract class Expression extends Node implements ts.Expression { + // Improve: support minimal interface + _expressionBrand: any +} + +export class FunctionDeclaration extends Node implements ts.FunctionDeclaration, FunctionLikeDeclarationBase { + constructor(node: arkts.FunctionDeclaration) { + super(node) + this.name = unpackNode(node.name) + this.body = unpackNode(node.body) + this.typeParameters = unpackNodeArray(node.typeParamsDecl?.parameters) + this.type = unpackNode(node.returnType) + this.parameters = unpackNodeArray(node.parameters) + } + + readonly name?: Identifier | undefined + readonly body?: Block | undefined + readonly typeParameters?: NodeArray | undefined + readonly type?: TypeNode | undefined + readonly parameters: NodeArray + readonly kind: ts.SyntaxKind.FunctionDeclaration = ts.SyntaxKind.FunctionDeclaration + + // brands + _functionLikeDeclarationBrand: any + _declarationBrand: any + _statementBrand: any +} + +export class FunctionExpression extends Node implements ts.FunctionExpression, FunctionLikeDeclarationBase { + constructor(node: arkts.FunctionExpression) { + super(node) + this.name = unpackNode(node.scriptFunction.ident) + if (node.scriptFunction.body === undefined) { + throwError('body expected to be not undefined') + } + this.body = unpackNode(node.scriptFunction.body) + this.parameters = unpackNodeArray(node.scriptFunction.parameters) + } + + readonly name?: Identifier + readonly body: Block + readonly parameters: NodeArray + readonly kind: ts.SyntaxKind.FunctionExpression = ts.SyntaxKind.FunctionExpression + + // brands + _primaryExpressionBrand: any + _memberExpressionBrand: any + _leftHandSideExpressionBrand: any + _updateExpressionBrand: any + _unaryExpressionBrand: any + _expressionBrand: any + _functionLikeDeclarationBrand: any + _declarationBrand: any +} + +export class Identifier extends Node implements ts.Identifier, Expression { + constructor(node: arkts.Identifier) { + super(node) + this.text = node.name + } + + readonly text: string + readonly kind: ts.SyntaxKind.Identifier = ts.SyntaxKind.Identifier + + // Improve: + get escapedText(): ts.__String { return emptyImplementation() } + + // brands + _primaryExpressionBrand: any + _memberExpressionBrand: any + _leftHandSideExpressionBrand: any + _updateExpressionBrand: any + _unaryExpressionBrand: any + _expressionBrand: any + _declarationBrand: any +} + +export class PrivateIdentifier extends Node implements ts.PrivateIdentifier, Expression { + constructor(node: arkts.Identifier) { + super(node) + this.text = node.name + if (!node.isPrivate) { + throwError('identifier expected to be private') + } + } + + readonly text: string + readonly kind: ts.SyntaxKind.PrivateIdentifier = ts.SyntaxKind.PrivateIdentifier + + // Improve: + get escapedText(): ts.__String { return emptyImplementation() } + + // brands + _primaryExpressionBrand: any + _memberExpressionBrand: any + _leftHandSideExpressionBrand: any + _updateExpressionBrand: any + _unaryExpressionBrand: any + _expressionBrand: any + _declarationBrand: any +} + +export abstract class Statement extends Node implements ts.Statement { + // brands + _statementBrand: any +} + +export class Block extends Node implements ts.Block { + constructor(node: arkts.BlockStatement) { + super(node) + this.statements = unpackNodeArray(node.statements) + } + + readonly statements: NodeArray + readonly kind: ts.SyntaxKind.Block = ts.SyntaxKind.Block + + // brands + _statementBrand: any +} + +export class SourceFile extends Node implements ts.SourceFile { + constructor(node: arkts.EtsScript) { + super(node) + + this.statements = unpackNodeArray(this.node.statements) + } + + readonly statements: NodeArray + readonly kind: ts.SyntaxKind.SourceFile = ts.SyntaxKind.SourceFile + + // Improve: + getLineAndCharacterOfPosition(pos: number): ts.LineAndCharacter { throw new Error("Method not implemented.") } + getLineEndOfPosition(pos: number): number { throw new Error("Method not implemented.") } + getLineStarts(): readonly number[] { throw new Error("Method not implemented.") } + getPositionOfLineAndCharacter(line: number, character: number): number { throw new Error("Method not implemented.") } + update(newText: string, textChangeRange: ts.TextChangeRange): ts.SourceFile { throw new Error("Method not implemented.") } + get endOfFileToken(): ts.Token { return emptyImplementation() } + get fileName(): string { return emptyImplementation() } + get text() { return emptyImplementation() } + get amdDependencies(): readonly ts.AmdDependency[] { return emptyImplementation() } + get referencedFiles(): readonly ts.FileReference[] { return emptyImplementation() } + get typeReferenceDirectives(): readonly ts.FileReference[] { return emptyImplementation() } + get libReferenceDirectives(): readonly ts.FileReference[] { return emptyImplementation() } + get languageVariant(): ts.LanguageVariant { return emptyImplementation() } + get isDeclarationFile(): boolean { return emptyImplementation() } + get hasNoDefaultLib(): boolean { return emptyImplementation() } + get languageVersion(): ts.ScriptTarget { return emptyImplementation() } + + // brands + _declarationBrand: any +} + +export abstract class LeftHandSideExpression extends Node implements ts.LeftHandSideExpression, Expression { + // brands + _leftHandSideExpressionBrand: any + _updateExpressionBrand: any + _unaryExpressionBrand: any + _expressionBrand: any +} + +export class ExpressionStatement extends Node implements ts.ExpressionStatement, Statement { + constructor(node: arkts.ExpressionStatement) { + super(node) + this.expression = unpackNode(this.node.expression) + } + + readonly expression: Expression + readonly kind: ts.SyntaxKind.ExpressionStatement = ts.SyntaxKind.ExpressionStatement + + // brands + _statementBrand: any +} + +export class CallExpression extends Node implements ts.CallExpression, LeftHandSideExpression { + constructor(node: arkts.CallExpression) { + super(node) + this.expression = unpackNode(node.expression) + this.arguments = unpackNodeArray(node.arguments) + } + + readonly expression: LeftHandSideExpression + readonly arguments: NodeArray + readonly kind: ts.SyntaxKind.CallExpression = ts.SyntaxKind.CallExpression + + // brands + _leftHandSideExpressionBrand: any + _updateExpressionBrand: any + _unaryExpressionBrand: any + _expressionBrand: any + _declarationBrand: any +} + +export class PropertyAccessExpression extends Node implements ts.PropertyAccessExpression, Expression { + constructor(node: arkts.MemberExpression) { + super(node) + this.expression = unpackNode(node.object) + this.name = unpackNode(node.property) + } + + readonly expression: LeftHandSideExpression + readonly name: Identifier + readonly kind: ts.SyntaxKind.PropertyAccessExpression = ts.SyntaxKind.PropertyAccessExpression + + // brands + _memberExpressionBrand: any + _leftHandSideExpressionBrand: any + _updateExpressionBrand: any + _unaryExpressionBrand: any + _expressionBrand: any + _declarationBrand: any +} + +export class StringLiteral extends Node implements ts.StringLiteral { + constructor(node: arkts.StringLiteral) { + super(node) + + this.text = node.str + } + + readonly text: string + readonly kind: ts.SyntaxKind.StringLiteral = ts.SyntaxKind.StringLiteral + + // brands + _literalExpressionBrand: any + _primaryExpressionBrand: any + _memberExpressionBrand: any + _leftHandSideExpressionBrand: any + _updateExpressionBrand: any + _unaryExpressionBrand: any + _expressionBrand: any + _declarationBrand: any +} + +export class ClassDeclaration extends Node implements ts.ClassDeclaration { + constructor(node: arkts.ClassDeclaration) { + super(node) + this.name = unpackNode(node.definition.name) + this.members = unpackNodeArray(node.definition.members) + this.typeParameters = unpackNodeArray(node.definition.typeParamsDecl?.parameters) + } + + readonly name: Identifier + readonly members: NodeArray + readonly typeParameters?: NodeArray + readonly kind: ts.SyntaxKind.ClassDeclaration = ts.SyntaxKind.ClassDeclaration + + // brands + _declarationBrand: any + _statementBrand: any +} + +export abstract class ClassElement extends Node implements ts.ClassElement { + // brands + _declarationBrand: any + _classElementBrand: any +} + +export type MemberName = Identifier | PrivateIdentifier; + +// Improve: support +// export type PropertyName = Identifier | StringLiteral | NumericLiteral | ts.ComputedPropertyName | PrivateIdentifier; +export type PropertyName = Identifier | StringLiteral | NumericLiteral | PrivateIdentifier; + +// Improve: support +export type DeclarationName = + | PropertyName + // | JsxAttributeName + // | StringLiteralLike + // | ElementAccessExpression + // | BindingPattern + // | EntityNameExpression; + +export interface Declaration extends Node {} + +export abstract class NamedDeclaration extends Node implements ts.NamedDeclaration, Declaration { + readonly name?: DeclarationName; + + // brands + _declarationBrand: any +} + +export type SignatureDeclaration = ts.CallSignatureDeclaration | ts.ConstructSignatureDeclaration | MethodSignature | ts.IndexSignatureDeclaration | FunctionTypeNode | ts.ConstructorTypeNode | ts.JSDocFunctionType | FunctionDeclaration | MethodDeclaration | ConstructorDeclaration | ts.AccessorDeclaration | FunctionExpression | ArrowFunction; + +export interface SignatureDeclarationBase extends NamedDeclaration {} + +export type VariableLikeDeclaration = ts.VariableDeclaration | ParameterDeclaration | ts.BindingElement | PropertyDeclaration | ts.PropertyAssignment | PropertySignature | ts.JsxAttribute | ts.ShorthandPropertyAssignment | ts.EnumMember | ts.JSDocPropertyTag | ts.JSDocParameterTag; + +export interface FunctionLikeDeclarationBase extends SignatureDeclarationBase { + // brands + _functionLikeDeclarationBrand: any; +} + +// Improve: support +// export type FunctionLikeDeclaration = FunctionDeclaration | MethodDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration | ConstructorDeclaration | FunctionExpression | ArrowFunction; +export type FunctionLikeDeclaration = FunctionDeclaration | MethodDeclaration | ConstructorDeclaration | FunctionExpression | ArrowFunction; + +export class MethodSignature extends Node implements ts.MethodSignature, SignatureDeclarationBase { + constructor(node: arkts.AstNode) { + super(node) + } + + // readonly name: PropertyName + // readonly parameters: NodeArray + readonly kind: ts.SyntaxKind.MethodSignature = ts.SyntaxKind.MethodSignature + + // Improve: + name: any + parameters: any + + // brands + _declarationBrand: any + _typeElementBrand: any +} + +// export class MethodDeclaration extends Node implements ts.MethodDeclaration, FunctionLikeDeclarationBase, ClassElement { +export class MethodDeclaration extends Node implements ts.MethodDeclaration, ClassElement { + constructor(node: arkts.MethodDefinition) { + super(node) + this.name = unpackNode(node.name) + this.parameters = unpackNodeArray(node.scriptFunction.parameters) + this.body = unpackNode(node.scriptFunction.body) + } + + // tsc: readonly name?: PropertyName + readonly name: Identifier + readonly parameters: NodeArray + // tsc: readonly body?: FunctionBody | undefined + readonly body?: Block | undefined + readonly kind: ts.SyntaxKind.MethodDeclaration = ts.SyntaxKind.MethodDeclaration + + // brands + _functionLikeDeclarationBrand: any + _classElementBrand: any + _objectLiteralBrand: any + _declarationBrand: any +} + +// export class ConstructorDeclaration extends Node implements ts.ConstructorDeclaration, FunctionLikeDeclarationBase, ClassElement { +export class ConstructorDeclaration extends Node implements ts.ConstructorDeclaration, ClassElement { + constructor(node: arkts.MethodDefinition) { + super(node) + this.name = unpackNode(node.name) + this.parameters = unpackNodeArray(node.scriptFunction.parameters) + this.body = unpackNode(node.scriptFunction.body) + } + + // ts: readonly name?: PropertyName + readonly name: Identifier + readonly parameters: NodeArray + // ts: readonly body?: FunctionBody | undefined + readonly body?: Block + readonly kind: ts.SyntaxKind.Constructor = ts.SyntaxKind.Constructor + + // brands + _functionLikeDeclarationBrand: any + _classElementBrand: any + _objectLiteralBrand: any + _declarationBrand: any +} + +// Improve: specify arkts.AstNode type +export class PropertySignature extends Node implements ts.TypeElement { + constructor(node: arkts.AstNode) { + super(node) + } + + readonly name?: PropertyName + readonly kind: ts.SyntaxKind.PropertySignature = ts.SyntaxKind.PropertySignature + + // brands + _typeElementBrand: any + _declarationBrand: any +} + +// Improve: specify arkts.AstNode type +export class PropertyDeclaration extends Node implements ts.PropertyDeclaration, ClassElement { + constructor(node: arkts.AstNode) { + super(node) + } + + readonly kind: ts.SyntaxKind.PropertyDeclaration = ts.SyntaxKind.PropertyDeclaration + + // Improve: + name: any + + // brands + _classElementBrand: any + _declarationBrand: any +} + +// Improve: specify arkts.AstNode type +export class GetAccessorDeclaration extends Node implements ts.GetAccessorDeclaration, FunctionLikeDeclarationBase, ClassElement { + constructor(node: arkts.AstNode) { + super(node) + } + + // readonly name: PropertyName + // readonly parameters: NodeArray + readonly kind: ts.SyntaxKind.GetAccessor = ts.SyntaxKind.GetAccessor + + // Improve: + name: any + parameters: any + + // brands + _functionLikeDeclarationBrand: any + _declarationBrand: any + _classElementBrand: any + _typeElementBrand: any + _objectLiteralBrand: any +} + +// Improve: specify arkts.AstNode type +export class SetAccessorDeclaration extends Node implements ts.SetAccessorDeclaration, FunctionLikeDeclarationBase, ClassElement { + constructor(node: arkts.AstNode) { + super(node) + } + + // readonly name: PropertyName + // readonly parameters: NodeArray + readonly kind: ts.SyntaxKind.SetAccessor = ts.SyntaxKind.SetAccessor + + // Improve: + name: any + parameters: any + + // brands + _functionLikeDeclarationBrand: any + _declarationBrand: any + _classElementBrand: any + _typeElementBrand: any + _objectLiteralBrand: any +} + +export class ParameterDeclaration extends Node implements ts.ParameterDeclaration, NamedDeclaration { + constructor(node: arkts.ETSParameterExpression) { + super(node) + } + + readonly kind: ts.SyntaxKind.Parameter = ts.SyntaxKind.Parameter + + // Improve: + name: any + + // brands + _declarationBrand: any +} + +export type BindingName = Identifier | ts.BindingPattern; + +export class VariableStatement extends Node implements ts.VariableStatement { + constructor(node: arkts.VariableDeclaration) { + super(node) + this.declarationList = new VariableDeclarationList(node) + } + + readonly declarationList: VariableDeclarationList + readonly kind: ts.SyntaxKind.VariableStatement = ts.SyntaxKind.VariableStatement + + // brands + _statementBrand: any +} + +export class VariableDeclarationList extends Node implements ts.VariableDeclarationList { + constructor(node: arkts.VariableDeclaration) { + super(node) + this.declarations = unpackNodeArray(node.declarators) + } + + readonly declarations: NodeArray + get flags(): ts.NodeFlags { return unpackVariableDeclarationKind(this.node.declarationKind) } + readonly kind: ts.SyntaxKind.VariableDeclarationList = ts.SyntaxKind.VariableDeclarationList +} + +export class VariableDeclaration extends Node implements ts.VariableDeclaration, NamedDeclaration { + constructor(node: arkts.VariableDeclarator) { + super(node) + this.name = unpackNode(node.name) + } + + readonly name: Identifier + readonly kind: ts.SyntaxKind.VariableDeclaration = ts.SyntaxKind.VariableDeclaration + + // brands + _declarationBrand: any +} + +export class TypeParameterDeclaration extends Node implements ts.TypeParameterDeclaration { + constructor(node: arkts.TSTypeParameter) { + super(node) + this.name = unpackNode(node.name) + } + + readonly name: Identifier + readonly kind: ts.SyntaxKind.TypeParameter = ts.SyntaxKind.TypeParameter + + // brands + _declarationBrand: any +} + +export abstract class TypeNode extends Node implements ts.TypeNode { + // brands + _typeNodeBrand: any +} + +export class KeywordTypeNode extends Node implements ts.KeywordTypeNode, TypeNode { + constructor(node: arkts.ETSPrimitiveType | arkts.ETSTypeReference) { + super(node) + } + + readonly kind: ts.KeywordTypeSyntaxKind = ts.SyntaxKind.UnknownKeyword + + // brands + _typeNodeBrand: any +} + +export class TypeReferenceNode extends Node implements ts.TypeReferenceNode, TypeNode { + constructor(node: arkts.AstNode) { + super(node) + } + + readonly kind: ts.SyntaxKind.TypeReference = ts.SyntaxKind.TypeReference + + // Improve: + typeName: any + + // brands + _typeNodeBrand: any +} + +export class FunctionTypeNode extends Node implements ts.FunctionTypeNode, TypeNode, SignatureDeclarationBase { + constructor(node: arkts.AstNode) { + super(node) + } + + readonly name?: DeclarationName + readonly kind: ts.SyntaxKind.FunctionType = ts.SyntaxKind.FunctionType + + // Improve: support minimal interface + parameters: any + type: any + + // brands + _typeNodeBrand: any + _declarationBrand: any +} + +export class UnionTypeNode extends Node implements ts.UnionTypeNode, TypeNode { + constructor(node: arkts.ETSUnionType) { + super(node) + this.types = unpackNodeArray(node.types) + } + + readonly types: NodeArray + readonly kind: ts.SyntaxKind.UnionType = ts.SyntaxKind.UnionType + + // brands + _typeNodeBrand: any +} + +export class ReturnStatement extends Node implements ts.ReturnStatement, Statement { + constructor(node: arkts.ReturnStatement) { + super(node) + this.expression = unpackNode(node.argument) + } + + readonly expression: Expression | undefined + readonly kind: ts.SyntaxKind.ReturnStatement = ts.SyntaxKind.ReturnStatement + + // brands + _statementBrand: any +} + +export class IfStatement extends Node implements ts.IfStatement { + constructor(node: arkts.IfStatement) { + super(node) + } + + readonly kind: ts.SyntaxKind.IfStatement = ts.SyntaxKind.IfStatement + + // Improve: + thenStatement: any + expression: any + + // brands + _statementBrand: any +} + +export class BinaryExpression extends Node implements ts.BinaryExpression { + constructor(node: arkts.BinaryExpression) { + super(node) + } + + readonly kind: ts.SyntaxKind.BinaryExpression = ts.SyntaxKind.BinaryExpression + + // Improve: + left: any + right: any + operatorToken: any + + // brands + _expressionBrand: any + _declarationBrand: any +} + +export class AssignmentExpression extends Node implements ts.AssignmentExpression { + constructor(node: arkts.AssignmentExpression) { + super(node) + } + + readonly kind: ts.SyntaxKind.BinaryExpression = ts.SyntaxKind.BinaryExpression + + // Improve: + right: any + left: any + operatorToken: any + + // brands + _expressionBrand: any + _declarationBrand: any +} + +export class ArrowFunction extends Node implements ts.ArrowFunction { + constructor(node: arkts.ArrowFunctionExpression) { + super(node) + if (node.scriptFunction.body === undefined) { + throwError('node.scriptFunction.body not expected to be undefined') + } + this.body = unpackNode(node.scriptFunction.body) + this.parameters = unpackNodeArray(node.scriptFunction.parameters) + } + + get name(): never { return throwError(`name doesn't exist for ArrowFunction`) } + readonly body: Block + readonly parameters: NodeArray + readonly kind: ts.SyntaxKind.ArrowFunction = ts.SyntaxKind.ArrowFunction + + // Improve: + equalsGreaterThanToken: any + + // brands + _expressionBrand: any + _functionLikeDeclarationBrand: any + _declarationBrand: any +} + +export class NumericLiteral extends Node implements ts.NumericLiteral, Declaration { + constructor(node: arkts.NumberLiteral) { + super(node) + + this.text = `${node.value}` + } + + readonly text: string + readonly kind: ts.SyntaxKind.NumericLiteral = ts.SyntaxKind.NumericLiteral + + // brands + _literalExpressionBrand: any + _declarationBrand: any + _primaryExpressionBrand: any + _memberExpressionBrand: any + _leftHandSideExpressionBrand: any + _updateExpressionBrand: any + _unaryExpressionBrand: any + _expressionBrand: any +} + +export class SuperExpression extends Node implements ts.SuperExpression { + constructor(node: arkts.SuperExpression) { + super(node) + } + + readonly kind: ts.SyntaxKind.SuperKeyword = ts.SyntaxKind.SuperKeyword + + // brands + _primaryExpressionBrand: any + _memberExpressionBrand: any + _leftHandSideExpressionBrand: any + _updateExpressionBrand: any + _unaryExpressionBrand: any + _expressionBrand: any +} + +export class HeritageClause extends Node implements ts.HeritageClause { + constructor(node: arkts.SuperExpression) { + super(node) + } + + readonly kind: ts.SyntaxKind.HeritageClause = ts.SyntaxKind.HeritageClause + // token: ts.SyntaxKind.ExtendsKeyword | ts.SyntaxKind.ImplementsKeyword + // types: ts.NodeArray + + // Improve: + token: any + types: any +} + + +// Improve: there is no ParenthesizedExpression in ArkTS, +// so for temporary solution we're just gonna ignore this type of nodes +// and replace it with Expression underneath +export type ParenthesizedExpression = Expression +// export class ParenthesizedExpression extends Node implements ts.ParenthesizedExpression { +// constructor(expression: Expression) { +// super(undefined) +// this.expression = expression +// } + +// readonly expression: Expression +// readonly kind: ts.SyntaxKind.ParenthesizedExpression = ts.SyntaxKind.ParenthesizedExpression + +// // brands +// _primaryExpressionBrand: any +// _memberExpressionBrand: any +// _leftHandSideExpressionBrand: any +// _updateExpressionBrand: any +// _unaryExpressionBrand: any +// _expressionBrand: any +// } + +// Improve: +export class ImportDeclaration extends Node implements ts.ImportDeclaration { + constructor(node: arkts.UnsupportedNode) { + super(node) + } + + readonly kind: ts.SyntaxKind.ImportDeclaration = ts.SyntaxKind.ImportDeclaration + + // Improve: + moduleSpecifier: any + + // brands + _statementBrand: any +} + +// Improve: +export class ImportClause extends Node implements ts.ImportClause { + constructor(node: arkts.UnsupportedNode) { + super(node) + } + + readonly kind: ts.SyntaxKind.ImportClause = ts.SyntaxKind.ImportClause + + // Improve: + isTypeOnly: any + + // brands + _declarationBrand: any +} + +// Improve: +export class NamedImports extends Node implements ts.NamedImports { + constructor(node: arkts.UnsupportedNode) { + super(node) + } + + readonly kind: ts.SyntaxKind.NamedImports = ts.SyntaxKind.NamedImports + + // Improve: + elements: any +} + +export class ImportSpecifier extends Node implements ts.ImportSpecifier { + constructor(node: arkts.Identifier) { + super(node) + this.name = unpackNode(this.node) + } + + readonly name: Identifier + readonly kind: ts.SyntaxKind.ImportSpecifier = ts.SyntaxKind.ImportSpecifier + + // Improve: + isTypeOnly: any + + // brands + _declarationBrand: any +} + +export class UnsupportedNode extends Node implements ts.Node { + constructor(node: arkts.AstNode) { + super(node) + } + + readonly kind: ts.SyntaxKind = SyntaxKind.Unknown +} diff --git a/ets1.2/libarkts/src/ts-api/utilities/private.ts b/ets1.2/libarkts/src/ts-api/utilities/private.ts new file mode 100644 index 0000000000000000000000000000000000000000..060c3d5c7f9d60925aef9b263e6e89fe479075b8 --- /dev/null +++ b/ets1.2/libarkts/src/ts-api/utilities/private.ts @@ -0,0 +1,289 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { throwError } from "../../utils" + +import * as ts from "../" +import * as arkts from "../../arkts-api" + +import { KInt } from "@koalaui/interop" +import { + SyntaxKind, + TokenSyntaxKind, + NodeFlags, +} from "../static/enums" +import { + Es2pandaAstNodeType, + Es2pandaModifierFlags, + Es2pandaScriptFunctionFlags, + Es2pandaTokenType, + Es2pandaVariableDeclarationKind, +} from "../../arkts-api" + +export function emptyImplementation(): any { + throwError("Not yet implemented") +} + +type kindTypes = + | { new (node: arkts.AstNode): ts.Node } + | { new (node: arkts.Identifier): ts.Identifier } + | { new (node: arkts.EtsScript): ts.SourceFile } + | { new (node: arkts.StringLiteral): ts.StringLiteral } + | { new (node: arkts.NumberLiteral): ts.NumericLiteral } + | { new (node: arkts.ExpressionStatement): ts.ExpressionStatement } + | { new (node: arkts.FunctionDeclaration): ts.FunctionDeclaration } + | { new (node: arkts.ReturnStatement): ts.ReturnStatement } + | { new (node: arkts.ETSParameterExpression): ts.ParameterDeclaration } + | { new (node: arkts.CallExpression): ts.CallExpression } + | { new (node: arkts.BlockStatement): ts.Block } + | { new (node: arkts.TSTypeParameter): ts.TypeParameterDeclaration} + | { new (node: arkts.MemberExpression): ts.PropertyAccessExpression} + | { new (node: arkts.IfStatement): ts.IfStatement} + | { new (node: arkts.ETSTypeReference): ts.TypeReferenceNode } + | { new (node: arkts.ETSPrimitiveType | arkts.ETSTypeReference): ts.KeywordTypeNode } + | { new (node: arkts.BinaryExpression): ts.BinaryExpression } + | { new (node: arkts.ETSUnionType): ts.UnionTypeNode } + | { new (node: arkts.ArrowFunctionExpression): ts.ArrowFunction } + | { new (node: arkts.ClassDeclaration): ts.ClassDeclaration } + | { new (node: arkts.MethodDefinition): ts.MethodDeclaration } + | { new (node: arkts.VariableDeclarator): ts.VariableDeclaration } + | { new (node: arkts.VariableDeclaration): ts.VariableStatement } + +export function classByEtsNode(node: arkts.AstNode) { + const types = + new Map([ + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, ts.SourceFile], + [Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER, ts.Identifier], + [Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL, ts.StringLiteral], + [Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, ts.NumericLiteral], + [Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT, ts.ExpressionStatement], + [Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION, ts.FunctionDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, ts.ReturnStatement], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION, ts.ParameterDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION, ts.CallExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, ts.Block], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE, ts.TypeReferenceNode], + [Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER, ts.TypeParameterDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION, ts.PropertyAccessExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT, ts.IfStatement], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE, ts.KeywordTypeNode], + [Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION, ts.BinaryExpression], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE, ts.UnionTypeNode], + [Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, ts.ArrowFunction], + [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION, ts.ClassDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION, ts.MethodDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION, ts.VariableStatement], + [Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR, ts.VariableDeclaration], + [Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, ts.SuperExpression], + + [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK, ts.UnsupportedNode], + [Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY, ts.UnsupportedNode], + [Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, ts.UnsupportedNode], + ]) + + return types.get(node.type) ?? throwError(`UNSUPPORTED NODE (ts): ${Es2pandaAstNodeType[node.type]}`) +} + +// Improve: add checks for casts in functions below + +export function unpackNode >(node: U): T +export function unpackNode >(node: U): T | undefined +export function unpackNode >(node: U): T | undefined { + if (node === undefined) { + return undefined + } + return (new (classByEtsNode(node))(node as any)) as T +} + +export function passNode(node: ts.Node): T +export function passNode(node: ts.Node | undefined): T | undefined +export function passNode(node: ts.Node | undefined): T | undefined { + if (node === undefined) { + return undefined + } + return (node.node as T) ?? throwError('trying to pass non-compatible node') +} + +export function unpackNodeArray >(nodes: readonly U[]): ts.NodeArray +export function unpackNodeArray >(nodes: readonly U[] | undefined): ts.NodeArray | undefined +export function unpackNodeArray >(nodes: readonly U[] | undefined): ts.NodeArray | undefined { + return nodes?.map((node: U) => unpackNode(node)) as ReadonlyArray > as ts.NodeArray +} + +export function passNodeArray(nodes: readonly ts.Node[]): T[] +export function passNodeArray(nodes: readonly ts.Node[] | undefined): T[] | undefined +export function passNodeArray(nodes: readonly ts.Node[] | undefined): T[] | undefined { + return nodes?.map((node: ts.Node) => passNode(node)) +} + +export function passIdentifier(node: ts.Identifier | string, typeAnnotation?: ts.TypeNode): arkts.Identifier +export function passIdentifier(node: ts.Identifier | string | undefined, typeAnnotation?: ts.TypeNode): arkts.Identifier | undefined +export function passIdentifier(node: ts.Identifier | string | undefined, typeAnnotation?: ts.TypeNode): arkts.Identifier | undefined { + if (node === undefined) { + return undefined + } + if (node instanceof ts.Identifier) { + if (typeAnnotation === undefined) { + return node.node + } + return arkts.Identifier.create( + node.node.name, + passNode(typeAnnotation) + ) + } + return arkts.Identifier.create( + node, + passNode(typeAnnotation) + ) +} + +// Improve: support optional params +export function passTypeParams(params: readonly ts.TypeParameterDeclaration[] | undefined): arkts.TSTypeParameterDeclaration | undefined { + if (params === undefined) { + return undefined + } + return arkts.factory.createTypeParameterDeclaration( + passNodeArray(params) + ) +} + +export function unpackModifiers(modifiers: KInt | undefined): ts.NodeArray { + const translation = new Map([ + // [Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, SyntaxKind.UnknownKeyword], + // [Es2pandaModifierFlags.MODIFIER_FLAGS_CONSTRUCTOR, SyntaxKind.ConstructorKeyword], + + [Es2pandaModifierFlags.MODIFIER_FLAGS_ABSTRACT, SyntaxKind.AbstractKeyword], + // Improve: unsupported + // [Es2pandaModifierFlags. , SyntaxKind.AccessorKeyword], + [Es2pandaModifierFlags.MODIFIER_FLAGS_ASYNC, SyntaxKind.AsyncKeyword], + [Es2pandaModifierFlags.MODIFIER_FLAGS_CONST, SyntaxKind.ConstKeyword], + [Es2pandaModifierFlags.MODIFIER_FLAGS_DECLARE, SyntaxKind.DeclareKeyword], + // Improve: choose one + // [Es2pandaModifierFlags.MODIFIER_FLAGS_DEFAULT_EXPORT, SyntaxKind.DefaultClause], + // [Es2pandaModifierFlags.MODIFIER_FLAGS_DEFAULT_EXPORT, SyntaxKind.DefaultKeyword], + [Es2pandaModifierFlags.MODIFIER_FLAGS_EXPORT, SyntaxKind.ExportKeyword], + [Es2pandaModifierFlags.MODIFIER_FLAGS_IN, SyntaxKind.InKeyword], + [Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE, SyntaxKind.PrivateKeyword], + [Es2pandaModifierFlags.MODIFIER_FLAGS_PROTECTED, SyntaxKind.ProtectedKeyword], + [Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC, SyntaxKind.PublicKeyword], + [Es2pandaModifierFlags.MODIFIER_FLAGS_OUT, SyntaxKind.OutKeyword], + [Es2pandaModifierFlags.MODIFIER_FLAGS_OVERRIDE, SyntaxKind.OverrideKeyword], + [Es2pandaModifierFlags.MODIFIER_FLAGS_READONLY, SyntaxKind.ReadonlyKeyword], + [Es2pandaModifierFlags.MODIFIER_FLAGS_STATIC, SyntaxKind.StaticKeyword], + ]) + + const bits = function*(flags: KInt) { + let bit: KInt = 1 + while (flags >= bit) { + if ((flags & bit) > 0) { + yield bit + } + bit <<= 1 + } + } + if (modifiers === undefined) { + return [] as ReadonlyArray as ts.NodeArray + } + let mods: ts.Modifier[] = [] + for (const bit of bits(modifiers)) { + mods.push(new ts.Modifier(translation.get(bit) ?? throwError(`Unsupported modifier: ${bit}`))) + } + return mods as ReadonlyArray as ts.NodeArray +} + +export function passModifiers(modifiers: ReadonlyArray | undefined): KInt { + const translation = new Map([ + // [SyntaxKind.UnknownKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_NONE], + // [SyntaxKind.ConstructorKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_CONSTRUCTOR], + + [SyntaxKind.AbstractKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_ABSTRACT], + // Improve: unsupported + // [SyntaxKind.AccessorKeyword, Es2pandaModifierFlags.], + [SyntaxKind.AsyncKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_ASYNC], + [SyntaxKind.ConstKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_CONST], + [SyntaxKind.DeclareKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_DECLARE], + [SyntaxKind.DefaultKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_DEFAULT_EXPORT], + [SyntaxKind.ExportKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_EXPORT], + [SyntaxKind.InKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_IN], + [SyntaxKind.PrivateKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_PRIVATE], + [SyntaxKind.ProtectedKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_PROTECTED], + [SyntaxKind.PublicKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC], + [SyntaxKind.OutKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_OUT], + [SyntaxKind.OverrideKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_OVERRIDE], + [SyntaxKind.ReadonlyKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_READONLY], + [SyntaxKind.StaticKeyword, Es2pandaModifierFlags.MODIFIER_FLAGS_STATIC], + ]) + + if (modifiers === undefined) { + return Es2pandaModifierFlags.MODIFIER_FLAGS_NONE + } + return modifiers + .map((mod: ts.Modifier | undefined | Es2pandaModifierFlags) => { + if (mod === undefined) { + return Es2pandaModifierFlags.MODIFIER_FLAGS_NONE + } + if (typeof mod === 'object') { + return translation.get(mod.kind) ?? throwError(`Unsupported modifier: ${mod.kind}`) + } + return mod + }) + .reduce( + (prev, curr) => (prev | curr), + Es2pandaModifierFlags.MODIFIER_FLAGS_NONE + ) +} + +export function passToken(token: ts.Token): KInt { + const translation = new Map([ + [SyntaxKind.PlusToken, Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_PLUS], + [SyntaxKind.MinusToken, Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_MINUS], + [SyntaxKind.AsteriskToken, Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_MULTIPLY], + ]) + + return translation.get(token.kind) ?? throwError('unsupported token') +} + +export function passModifiersToScriptFunction(modifiers: readonly ts.Modifier[] | undefined): KInt { + const translation = new Map([ + [SyntaxKind.StaticKeyword, Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_STATIC_BLOCK], + [SyntaxKind.AsyncKeyword, Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_ASYNC], + [SyntaxKind.PublicKeyword, Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_NONE], + ]) + + return modifiers?.reduce( + (prev, curr) => prev | (translation.get(curr.kind) ?? throwError(`Unsupported ScriptFunction flag: ${curr.kind}`)), + Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_NONE + ) ?? Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_NONE +} + +export function passVariableDeclarationKind(flags: NodeFlags): Es2pandaVariableDeclarationKind { + const translation = new Map([ + [NodeFlags.Const, Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_CONST], + [NodeFlags.Let, Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET], + [NodeFlags.None, Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_VAR], + ]) + + return translation.get(flags) ?? throwError('unsupported VariableDeclarationKind') +} + +export function unpackVariableDeclarationKind(kind: Es2pandaVariableDeclarationKind): NodeFlags { + const translation = new Map([ + [Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_CONST, NodeFlags.Const], + [Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_LET, NodeFlags.Let], + [Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_VAR, NodeFlags.None], + ]) + + return translation.get(kind) ?? throwError('unsupported VariableDeclarationKind') +} diff --git a/ets1.2/libarkts/src/ts-api/utilities/public.ts b/ets1.2/libarkts/src/ts-api/utilities/public.ts new file mode 100644 index 0000000000000000000000000000000000000000..4cde32c6a1b4d8f0d5c1311cdf24b3c03139a7a4 --- /dev/null +++ b/ets1.2/libarkts/src/ts-api/utilities/public.ts @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { global } from "../../arkts-api/static/global" +import { throwError } from "../../utils" +import * as ts from "../." +import { KNativePointer, nullptr } from "@koalaui/interop" +import { unpackNonNullableNode } from "../../arkts-api" + +export { proceedToState, startChecker } from "../../arkts-api" + +// Improve: like in arkts utils +export function getDecl(node: ts.Node): ts.Node | undefined { + if (node.node === undefined) { + throwError('there is no arkts pair of ts node (unable to getDecl)') + } + let decl: KNativePointer = node.node.peer + decl = global.es2panda._AstNodeVariableConst(global.context, decl) + if (decl === nullptr) { + return undefined + } + decl = global.es2panda._VariableDeclaration(global.context, decl) + if (decl === nullptr) { + return undefined + } + decl = global.es2panda._DeclNode(global.context, decl) + if (decl === nullptr) { + return undefined + } + return ts.unpackNode(unpackNonNullableNode(decl)) +} + +// Improve: like in arkts utils +export function getOriginalNode(node: ts.Node): ts.Node { + if (node.node === undefined) { + // Improve: fix this + throwError('there is no arkts pair of ts node (unable to getOriginalNode)') + } + if (node.node.originalPeer === nullptr) { + return node + } + return ts.unpackNode(unpackNonNullableNode(node.node.originalPeer)) +} diff --git a/ets1.2/libarkts/src/ts-api/visitor/visitor.ts b/ets1.2/libarkts/src/ts-api/visitor/visitor.ts new file mode 100644 index 0000000000000000000000000000000000000000..37865884037c29a62e28398e00248baf80c65e61 --- /dev/null +++ b/ets1.2/libarkts/src/ts-api/visitor/visitor.ts @@ -0,0 +1,155 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { throwError } from "../../utils" + +import * as ts from "../." +import { factory } from "../factory/nodeFactory" +import { SyntaxKind } from "../static/enums" + +type Visitor = (node: ts.Node) => ts.Node + +// Improve: rethink (remove as) +function nodeVisitor(node: T, visitor: Visitor): T { + if (node === undefined) { + return node + } + return visitor(node) as T +} + +// Improve: rethink (remove as) +function nodesVisitor | undefined>(nodes: TIn, visitor: Visitor): T[] | TIn { + if (nodes === undefined) { + return nodes + } + return nodes.map(node => visitor(node) as T) +} + +type VisitEachChildFunction = (node: T, visitor: Visitor) => T + +// Improve: add more nodes +type HasChildren = + | ts.SourceFile + | ts.FunctionDeclaration + | ts.ExpressionStatement + | ts.CallExpression + | ts.PropertyAccessExpression + | ts.ClassDeclaration + | ts.MethodDeclaration + | ts.Block + | ts.VariableStatement + | ts.VariableDeclarationList + +type VisitEachChildTable = { [TNode in HasChildren as TNode["kind"]]: VisitEachChildFunction } + +// Improve: add more nodes +const visitEachChildTable: VisitEachChildTable = { + [SyntaxKind.SourceFile]: function (node: ts.SourceFile, visitor: Visitor) { + return factory.updateSourceFile( + node, + nodesVisitor(node.statements, visitor) + ) + }, + [SyntaxKind.FunctionDeclaration]: function (node: ts.FunctionDeclaration, visitor: Visitor) { + return factory.updateFunctionDeclaration( + node, + node.modifiers, + undefined, + nodeVisitor(node.name, visitor), + nodesVisitor(node.typeParameters, visitor), + nodesVisitor(node.parameters, visitor), + nodeVisitor(node.type, visitor), + nodeVisitor(node.body, visitor), + ) + }, + [SyntaxKind.ExpressionStatement]: function (node: ts.ExpressionStatement, visitor: Visitor) { + return factory.updateExpressionStatement( + node, + nodeVisitor(node.expression, visitor) + ) + }, + [SyntaxKind.CallExpression]: function (node: ts.CallExpression, visitor: Visitor) { + return factory.updateCallExpression( + node, + nodeVisitor(node.expression, visitor), + undefined, + nodesVisitor(node.arguments, visitor) + ) + }, + [SyntaxKind.PropertyAccessExpression]: function (node: ts.PropertyAccessExpression, visitor: Visitor) { + return factory.updatePropertyAccessExpression( + node, + nodeVisitor(node.expression, visitor), + nodeVisitor(node.name, visitor) + ) + }, + [SyntaxKind.ClassDeclaration]: function (node: ts.ClassDeclaration, visitor: Visitor) { + return factory.updateClassDeclaration( + node, + undefined, + nodeVisitor(node.name, visitor), + undefined, + undefined, + nodesVisitor(node.members, visitor) + ) + }, + [SyntaxKind.MethodDeclaration]: function (node: ts.MethodDeclaration, visitor: Visitor) { + return factory.updateMethodDeclaration( + node, + undefined, + undefined, + nodeVisitor(node.name, visitor), + undefined, + undefined, + nodesVisitor(node.parameters, visitor), + undefined, + nodeVisitor(node.body, visitor), + ) + }, + [SyntaxKind.Block]: function (node: ts.Block, visitor: Visitor) { + return factory.updateBlock( + node, + nodesVisitor(node.statements, visitor), + ) + }, + [SyntaxKind.VariableStatement]: function (node: ts.VariableStatement, visitor: Visitor) { + return factory.updateVariableStatement( + node, + undefined, + nodeVisitor(node.declarationList, visitor), + ) + }, + [SyntaxKind.VariableDeclarationList]: function (node: ts.VariableDeclarationList, visitor: Visitor) { + return factory.updateVariableDeclarationList( + node, + nodesVisitor(node.declarations, visitor), + ) + }, +} + +function nodeHasChildren(node: ts.Node): node is HasChildren { + return node.kind in visitEachChildTable +} + +export function visitEachChild( + node: T, + visitor: Visitor +): T { + const visitFunc = (visitEachChildTable as Record | undefined>)[node.kind]; + if (nodeHasChildren(node) && visitFunc === undefined) { + throwError('Unsupported node kind: ' + node.kind) + } + return (visitFunc === undefined) ? node : visitFunc(node, visitor); +} diff --git a/ets1.2/libarkts/src/utils.ts b/ets1.2/libarkts/src/utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..9fc372018108f2a9414c3c9d11a52311973e8852 --- /dev/null +++ b/ets1.2/libarkts/src/utils.ts @@ -0,0 +1,224 @@ +/* + * 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. + */ + +export function throwError(error: string): never { + throw new Error(error) +} + +export function withWarning(value: T, message: string): T { + // console.warn(message) + return value +} + +export function isNumber(value: any): value is number { + return typeof value === `number` +} + +function replacePercentOutsideStrings(code: string): string { + const stringPattern = /("[^"]*"|'[^']*'|`[^`]*`)/g; + const percentPattern = /(?(); + strings.forEach((string) => { + const placeholder = `__STRING_PLACEHOLDER_${placeholderCounter++}__`; + placeholderMap.set(placeholder, string); + code = code.replace(string, placeholder); + }); + + code = code.replace(percentPattern, '_'); + + placeholderMap.forEach((originalString, placeholder) => { + code = code.replace(new RegExp(placeholder, 'g'), originalString); + }); + + return code; +} + +function replaceIllegalHashes(code: string): string { + const stringPattern = /("[^"]*"|'[^']*'|`[^`]*`)/g; + const strings = code.match(stringPattern) || []; + + let placeholderCounter = 0; + const placeholderMap = new Map(); + strings.forEach((string) => { + const placeholder = `__STRING_PLACEHOLDER_${placeholderCounter++}__`; + placeholderMap.set(placeholder, string); + code = code.replace(string, placeholder); + }); + + code = code.replace(/#/g, '_'); + + placeholderMap.forEach((originalString, placeholder) => { + code = code.replace(new RegExp(placeholder, 'g'), originalString); + }); + + return code; +} + +function replaceGensymWrappers(code: string): string { + const indices = [...code.matchAll(/\({let/g)].map(it => it.index) + const replacements: string[][] = [] + for (var i of indices) { + if (!i) { + continue + } + var j = i + 1, depth = 1 + while (j < code.length) { + if (code[j] == '(') { + depth++ + } + if (code[j] == ')') { + depth-- + } + if (depth == 0) { + break + } + j++ + } + + if (j == code.length) { + continue + } + + const base = code.substring(i, j + 1) + if (base.match(/\({let/)?.length! > 1) { // don't touch if contains nested constructions + continue + } + const fixed = base.replaceAll(/^\({let ([_%a-zA-Z0-9]+?) = (?!\({let)([\s\S]*?);\n([\s\S]*?)}\)$/g, + (match, name: string, val: string, expr: string) => { + let rightExpr = expr.slice(expr.lastIndexOf(name) + name.length, -1) + if (rightExpr[0] != '.') { + rightExpr = `.${rightExpr}` + } + return `(${val}?${rightExpr})` + } + ) + replacements.push([base, fixed]) + } + for (var [b, f] of replacements) { + code = code.replace(b, f) + } + return code +} + +function addExports(code: string): string { + const exportAstNodes = [" enum", "let", "const", "class", "abstract class", "@Entry() @Component() final class", "@Component() final class", "interface", "@interface", "type", "enum", "final class", "function", + "declare interface", "@memo_stable() declare interface", "@memo_stable() interface", + "@Retention({policy:\"SOURCE\"}) @interface", "@memo() function", "@memo_entry() function", "@memo_intrinsic() function", + ] + exportAstNodes.forEach((astNodeText) => { + code = code.replaceAll(`\n${astNodeText}`, `\nexport ${astNodeText}`) + } + ) + // Improve: this is a temporary workaround and should be replaced with a proper import/export handling in future + code = code.replaceAll(/\n(@memo\(\) @BuilderLambda\(\{value:"\w+"\}\)) function/g, '\n$1 export function') + const fix = [ + ["export @memo() function", "@memo() export function"], + ["export @memo_entry() function", "@memo_entry() export function"], + ["export @memo_intrinsic() function", "@memo_intrinsic() export function"], + ["export @memo_stable()", "@memo_stable() export"], + ["export class OhosRouter", "export default class OhosRouter"] + ] + for (var [f, t] of fix) { + code = code.replaceAll(f, t) + } + return code.replaceAll("\nexport function main()", "\nfunction main()") +} + +function excludePartialInterfaces(code: string): string { + return code + .replaceAll(/export interface (.*)\$partial<>([\s\S]*?)}/g, '') + .replaceAll(/interface (.*)\$partial<>([\s\S]*?)}/g, '') +} + +function fixEnums(code: string) { + const lines = code.split('\n') + const enums = [] + for (let i = 0; i + 1 < lines.length; i++) { + if (lines[i].trimStart().startsWith(`export final class`) + && lines[i + 1].trimStart().startsWith(`private readonly _ordinal`) + ) { + const name = lines[i].split(' ')[3] + enums.push(name) + } + } + enums.forEach((name) => { + const regexp = new RegExp(`${name}\\.(\\w+)(.)`, `g`) + code = code.replaceAll(regexp, (match, p1, p2) => { + if (!p1.startsWith('_') && p2 == ":") { // this colon is for switch case, not for type + return `${name}.${p1}.valueOf()${p2}` + } + return match + }) + const idents = [...code.matchAll(new RegExp(`(\\w+?)([\\W])(\\w+?): ${name}`, `g`))].filter(it => it[1] != "readonly" && it[1] != "_get").map(it => it[3]) + // work manually with a couple of cases not to write one more bracket parser + if (code.includes(`const eventKind = (deserializer.readInt32() as CallbackEventKind);`)) { + // this is for file arkui/src/generated/peers/CallbacksChecker.ts + idents.push(`eventKind`) + code = code.replace(`const eventKind = (deserializer.readInt32() as CallbackEventKind);`, `const eventKind = CallbackEventKind.fromValue(deserializer.readInt32());`) + } + if (code.includes(`switch ((type as EventType))`)) { + // this is for file arkui/src/Application.ts + code = code.replace(`switch ((type as EventType))`, `switch (type)`) + } + idents.forEach((id) => { + code = code.replaceAll(`${id} as int32`, `${id}.valueOf()`) + code = code.replaceAll(`switch (${id})`, `switch (${id}.valueOf())`) + }) + }) + return code +} + +function fixEmptyDeclareNamespace(code: string): string { + const lines = code.split('\n') + for (let i = 0; i < lines.length; i++) { + if (lines[i].startsWith('export declare namespace') && !lines[i].endsWith('{')) { + lines[i] += ' {}' + } + } + return lines.join('\n') +} + +/* + Improve: + The lowerings insert %% and other special symbols into names of temporary variables. + Until we keep feeding ast dumps back to the parser this function is needed. + */ +export function filterSource(text: string): string { + //console.error("====") + // console.error(text.split('\n').map((it, index) => `${`${index + 1}`.padStart(4)} |${it}`).join('\n')) + const dumperUnwrappers = [ + addExports, + fixEmptyDeclareNamespace, + fixEnums, + replaceGensymWrappers, // nested + replaceGensymWrappers, // nested + replaceGensymWrappers, + replaceIllegalHashes, + replacePercentOutsideStrings, + excludePartialInterfaces, + (code: string) => code.replaceAll("", "_cctor_"), + (code: string) => code.replaceAll("public constructor() {}", ""), + ] + // console.error("====") + // 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) +} + +export function getEnumName(enumType: any, value: number): string | undefined { + return enumType[value]; +} \ No newline at end of file diff --git a/ets1.2/libarkts/test/arkts-api/expressions/call-expression.test.ts b/ets1.2/libarkts/test/arkts-api/expressions/call-expression.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..3132fc8dee3e6c019dfb718b87a078fb4c850ead --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/expressions/call-expression.test.ts @@ -0,0 +1,73 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as util from "../../test-util" +import * as arkts from "../../../src/arkts-api" + +suite(util.basename(__filename), () => { + test("sample-1", function() { + const sample_in = + ` + function _() {}; + ` + + const sample_out = + ` + function _() {}; + console.log('out') + ` + + let script = arkts.createETSModuleFromSource(sample_in) + + script = arkts.factory.updateETSModule( + script, + [ + script.statements[0], + arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier( + 'console' + ), + arkts.Identifier.create2Identifier( + 'log' + ), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + [ + arkts.factory.createStringLiteral( + 'out' + ) + ], + undefined, + false, + false, + undefined, + ) + ) + ], + script.ident, + script.getNamespaceFlag(), + script.program, + ) + + util.ARKTS_TEST_ASSERTION( + script, + sample_out + ) + }) +}) diff --git a/ets1.2/libarkts/test/arkts-api/functions/create.test.ts b/ets1.2/libarkts/test/arkts-api/functions/create.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..d222e07f1c73862420e76c235fecf1fe12f58649 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/functions/create.test.ts @@ -0,0 +1,262 @@ +/* + * Copyright (c) 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 util from "../../test-util" +import * as arkts from "../../../src/arkts-api" + +suite(util.basename(__filename), () => { + test("sample-1", function() { + const sample_in = + ` + function _() {}; + ` + + const sample_out = + ` + function _() {}; + function foo() { + console.log("AAA") + } + foo() + ` + + let script = arkts.createETSModuleFromSource(sample_in) + + const scriptFunc = + arkts.factory.createScriptFunction( + arkts.factory.createBlockStatement( + [ + arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier( + 'console' + ), + arkts.factory.createIdentifier( + 'log' + ), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + [ + arkts.factory.createStringLiteral( + 'AAA' + ) + ], + undefined, + false, + false, + undefined, + ) + ) + ] + ), + undefined, + [], + undefined, + false, + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_NONE, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC | arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_STATIC, + arkts.factory.createIdentifier("foo"), + undefined, + ) + + const funcDecl = + arkts.factory.createFunctionDeclaration( + scriptFunc, + [], + false + ) + funcDecl.updateModifiers(scriptFunc.modifierFlags) + + script = arkts.factory.updateETSModule( + script, + [ + script.statements[0], + funcDecl, + arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createIdentifier( + 'foo' + ), + [], + undefined, + false, + false, + undefined, + ) + ) + ], + script.ident, + script.getNamespaceFlag(), + script.program, + ) + + util.ARKTS_TEST_ASSERTION( + script, + sample_out + ) + }) + + test("sample-2", function() { + const sample_in = + ` + function _() {}; + ` + + const sample_out = + ` + function _() {}; + function foo(x: int, y: string = "bbb") { + console.log(x) + console.log(y) + } + foo(0) + ` + + let script = arkts.createETSModuleFromSource(sample_in) + + const scriptFunc = + arkts.factory.createScriptFunction( + arkts.factory.createBlockStatement( + [ + arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier( + 'console' + ), + arkts.factory.createIdentifier( + 'log' + ), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + [ + arkts.factory.createIdentifier( + 'x' + ) + ], + undefined, + false, + false, + undefined, + ) + ), + arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createMemberExpression( + arkts.factory.createIdentifier( + 'console' + ), + arkts.factory.createIdentifier( + 'log' + ), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ), + [ + arkts.factory.createIdentifier( + 'y' + ) + ], + undefined, + false, + false, + undefined, + ) + ) + ] + ), + undefined, + [ + arkts.factory.createETSParameterExpression( + arkts.factory.createIdentifier( + 'x', + arkts.factory.createETSPrimitiveType( + arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_INT + ) + ), + false + ), + arkts.factory.createETSParameterExpression( + arkts.factory.createIdentifier( + 'y', + arkts.factory.createETSTypeReference( + arkts.factory.createETSTypeReferencePart( + arkts.factory.createIdentifier( + 'string' + ) + ) + ) + ), + false, + arkts.factory.createStringLiteral( + 'bbb' + ) + ) + ], + undefined, + false, + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_NONE, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC | arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_STATIC, + arkts.factory.createIdentifier("foo"), + undefined, + ) + + const funcDecl = + arkts.factory.createFunctionDeclaration( + scriptFunc, + [], + false + ) + funcDecl.updateModifiers(scriptFunc.modifierFlags) + + script = arkts.factory.updateETSModule( + script, + [ + script.statements[0], + funcDecl, + arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createIdentifier( + 'foo' + ), + [ + arkts.factory.createNumberLiteral( + 0 + ) + ], + undefined, + false, + false, + undefined, + ) + ) + ], + script.ident, + script.getNamespaceFlag(), + script.program, + ) + + util.ARKTS_TEST_ASSERTION( + script, + sample_out + ) + }) +}) diff --git a/ets1.2/libarkts/test/arkts-api/general/annotations.test.ts b/ets1.2/libarkts/test/arkts-api/general/annotations.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..f6564beff7b60458e139afb6c6a39391ca1f11bf --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/general/annotations.test.ts @@ -0,0 +1,48 @@ +/* + * Copyright (c) 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 util from "../../test-util" +import * as arkts from "../../../src/arkts-api" +import { assert } from "@koalaui/harness" + +suite(util.basename(__filename), () => { + test("annotated-function-1", function() { + const sample_in = + ` + @annotation1 + @annotation2 + function foo() {} + ` + + let script = arkts.createETSModuleFromSource( + sample_in, + arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED + ) + + const annotations = arkts.getAnnotations(script.statements[0]) + + const names = annotations.map((annot) => { + if (annot.expr === undefined) { + throw new Error('annotation expression is undefined') + } + if (!arkts.isIdentifier(annot.expr)) { + throw new Error('annotation expected to be Identifier') + } + return annot.expr.name + }) + + assert.equal(names.join(', '), 'annotation1, annotation2') + }) +}) diff --git a/ets1.2/libarkts/test/arkts-api/general/basic.test.ts b/ets1.2/libarkts/test/arkts-api/general/basic.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..e76d7c4bbc45371129b970f9aaa36ea341b59ec8 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/general/basic.test.ts @@ -0,0 +1,49 @@ +/* + * Copyright (c) 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 util from "../../test-util" +import * as arkts from "../../../src/arkts-api" + +suite(util.basename(__filename), () => { + test("sample-1", function() { + const sample_in = + ` + ` + + let script = arkts.createETSModuleFromSource(sample_in) + + script = arkts.factory.updateETSModule( + script, + [ + arkts.factory.createExpressionStatement( + arkts.factory.createIdentifier( + 'abc' + ) + ) + ], + script.ident, + script.getNamespaceFlag(), + script.program, + ) + + util.ARKTS_TEST_ASSERTION( + script, + ` + abc + `, + arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED + ) + }) +}) diff --git a/ets1.2/libarkts/test/arkts-api/general/jsdoc.test.ts b/ets1.2/libarkts/test/arkts-api/general/jsdoc.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..ee4890ba3bf217899a3d0114f8887c72330969f3 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/general/jsdoc.test.ts @@ -0,0 +1,86 @@ +/* + * 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 * as util from "../../test-util" +import * as arkts from "../../../src/arkts-api" +import { assert } from "@koalaui/harness" +import { + isMethodDefinition, + isBlockStatement, + isClassDeclaration, + isFunctionDeclaration, + isStatement, + isTSTypeAliasDeclaration, + isClassProperty, + getJsDoc, + isIdentifier +} from "../../../src/arkts-api" + +suite(util.basename(__filename), () => { + const comments: string[] = [ + '/** Regular function */' , + '/** Type T */', + '/** Class A */', + '/** Method */', + '/** Return type */', + '/** Property */', + ] + + test("jsdoc", function() { + const sample_in = ` + ${comments[0]} + export function foo(); + ${comments[1]} + type T = int; + ${comments[2]} + export class A { + ${comments[3]} + a_foo(): // colon here + ${comments[4]} + void {} + ${comments[5]} + private a_prop: number = 1 + }` + + let script = arkts.createETSModuleFromSource( + sample_in, + arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED + ) + + const jsdocs: (string | undefined)[] = [] + for (const stmt of script.statements) { + jsdocs.push(getJsDoc(stmt)) + if (isClassDeclaration(stmt)) { + const body = stmt.definition?.body ?? [] + for (const node of body) { + jsdocs.push(getJsDoc(node)) + + if (isMethodDefinition(node) && isIdentifier(node.key) && + node.key.name === 'a_foo' && node.function?.returnTypeAnnotation) { + jsdocs.push(getJsDoc(node.function?.returnTypeAnnotation)) + } + } + } + } + + assert.equal( + comments + .concat('') // implicit ctor returns undefined + .join(','), + jsdocs + .join(',') + ) + }) +}) diff --git a/ets1.2/libarkts/test/arkts-api/general/recheck.test.ts b/ets1.2/libarkts/test/arkts-api/general/recheck.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..d26b01d7c1a5abff3cfdc4311d1fb8181c89307a --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/general/recheck.test.ts @@ -0,0 +1,189 @@ +/* + * Copyright (c) 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 util from "../../test-util" +import * as arkts from "../../../src/arkts-api" + +const PANDA_SDK_PATH = process.env.PANDA_SDK_PATH ?? '../../incremental/tools/panda/node_modules/@panda/sdk' + +function createConfig() { + arkts.arktsGlobal.config = arkts.Config.create([ + '_', + '--arktsconfig', + 'arktsconfig.json', + './plugins/input/main.ets', + '--extension', + 'ets', + '--stdlib', + `${PANDA_SDK_PATH}/ets/stdlib`, + '--output', + './build/main.abc' + ]).peer +} + +class RenameTestFunction extends arkts.AbstractVisitor { + visitor(node: arkts.BlockStatement): arkts.BlockStatement + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + const node = this.visitEachChild(beforeChildren) + // Don't change name at checked state, add another import + if (arkts.isImportDeclaration(node)) return node + if (arkts.isIdentifier(node) && node.name == "testFunction") { + return arkts.factory.createIdentifier("testFunctionChanged") + } + return node + } +} + + +suite(util.basename(__filename), () => { + + + test("add import at parsed state and proceed to checked", function() { + createConfig() + arkts.initVisitsTable() + + const code = + ` + console.log("test") + ` + + arkts.arktsGlobal.filePath = "./plugins/input/main.ets" + arkts.arktsGlobal.compilerContext = arkts.Context.createFromString(code) + + arkts.proceedToState(arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED) + + const program = arkts.arktsGlobal.compilerContext!.program + const importStorage = new arkts.ImportStorage(program, true) + const module = program.ast as arkts.ETSModule + + program.setAst( + arkts.factory.updateETSModule( + module, + [ + arkts.factory.createETSImportDeclaration( + arkts.factory.createStringLiteral( + './library' + ), + [ + arkts.factory.createImportSpecifier( + arkts.factory.createIdentifier( + 'testFunction' + ), + arkts.factory.createIdentifier( + 'testFunction' + ) + ) + ], + arkts.Es2pandaImportKinds.IMPORT_KINDS_ALL, + ), + ...module.statements, + ], + module.ident, + module.getNamespaceFlag(), + module.program, + ) + ) + importStorage.update() + + arkts.proceedToState(arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED) + + arkts.recheckContext() + + util.assert.equal( + program.ast.dumpSrc(), ` +import { testFunction as testFunction } from "./library"; + +function main() {} + + +`, + `invalid result: ${program.ast.dumpSrc()}`) + + arkts.proceedToState(arkts.Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED) + }) + + test("change function name in main program and in dependency", function() { + createConfig() + arkts.initVisitsTable() + + const code = + ` + import { testFunction } from "./library" + testFunction() + ` + + arkts.arktsGlobal.filePath = "./plugins/input/main.ets" + arkts.arktsGlobal.compilerContext = arkts.Context.createFromString(code) + + arkts.proceedToState(arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED) + + const program = arkts.arktsGlobal.compilerContext!.program + const importStorage = new arkts.ImportStorage(program, true) + const module = program.ast as arkts.ETSModule + + arkts.arktsGlobal.compilerContext!.program.getExternalSources().forEach(it => { + if (!it.getName().includes("library")) return + it.programs.forEach(program => { + program.setAst(new RenameTestFunction().visitor(program.ast)) + }) + }) + + program.setAst( + arkts.factory.updateETSModule( + module, + [ + arkts.factory.updateETSImportDeclaration( + module.statements[0] as arkts.ETSImportDeclaration, + arkts.factory.createStringLiteral( + './library' + ), + [ + arkts.factory.createImportSpecifier( + arkts.factory.createIdentifier( + 'testFunctionChanged' + ), + arkts.factory.createIdentifier( + 'testFunctionChanged' + ) + ) + ], + arkts.Es2pandaImportKinds.IMPORT_KINDS_ALL, + ), + ...module.statements.slice(1), + ], + module.ident, + module.getNamespaceFlag(), + module.program, + ) + ) + + program.setAst(new RenameTestFunction().visitor(program.ast)) + + importStorage.update() + arkts.recheckContext() + + util.assert.equal( + program.ast.dumpSrc(), ` +import { testFunctionChanged as testFunctionChanged } from "./library"; + +function main() {} + + +`, + `invalid result: ${program.ast.dumpSrc()}`) + + arkts.proceedToState(arkts.Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED) + }) +}) diff --git a/ets1.2/libarkts/test/arkts-api/import-export/import.test.ts b/ets1.2/libarkts/test/arkts-api/import-export/import.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..a4727774f54da7c2007c05245cd332913f2fe1ea --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/import-export/import.test.ts @@ -0,0 +1,242 @@ +/* + * Copyright (c) 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 util from "../../test-util" +import * as arkts from "../../../src/arkts-api" +import { global } from "../../../src/arkts-api/static/global" + + +suite(util.basename(__filename), () => { + test("sample-1", function() { + const sample_in = + ` + ` + + let script = arkts.createETSModuleFromSource(sample_in) + + script = arkts.factory.updateETSModule( + script, + [ + arkts.factory.createETSImportDeclaration( + arkts.factory.createStringLiteral( + './variable' + ), + [ + arkts.factory.createImportSpecifier( + arkts.factory.createIdentifier( + 'X' + ), + arkts.factory.createIdentifier( + 'X' + ) + ) + ], + arkts.Es2pandaImportKinds.IMPORT_KINDS_ALL, + ) + ], + script.ident, + script.getNamespaceFlag(), + script.program, + ) + + util.ARKTS_TEST_ASSERTION( + script, + ` + import { X } from "./variable" + `, + arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED + ) + }) + + test("sample-2-rewrite", function() { + const sample_in = + ` + import { Y } from "./variable" + ` + + let script = arkts.createETSModuleFromSource(sample_in) + const importDeclaration = script.statements[0] as arkts.ETSImportDeclaration + + script = arkts.factory.updateETSModule( + script, + [ + arkts.factory.createETSImportDeclaration( + arkts.factory.createStringLiteral( + './variable' + ), + [ + arkts.factory.createImportSpecifier( + arkts.factory.createIdentifier( + 'X' + ), + arkts.factory.createIdentifier( + 'X' + ) + ) + ], + arkts.Es2pandaImportKinds.IMPORT_KINDS_ALL, + ), + ...script.statements, + ], + script.ident, + script.getNamespaceFlag(), + script.program, + ) + + util.ARKTS_TEST_ASSERTION( + script, + ` + import { X } from "./variable" + import { Y } from "./variable" + `, + arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED + ) + }) + + test("rewrite-imported-variable", function() { + const sample_in = + ` + import { Y } from "./variable" + + function main() { + console.log(X) + } + ` + + let script = arkts.createETSModuleFromSource(sample_in) + const importDeclaration = script.statements[0] as arkts.ETSImportDeclaration + + script = arkts.factory.updateETSModule( + script, + [ + arkts.factory.createETSImportDeclaration( + arkts.factory.createStringLiteral( + './variable' + ), + [ + arkts.factory.createImportSpecifier( + arkts.factory.createIdentifier( + 'X' + ), + arkts.factory.createIdentifier( + 'X' + ) + ) + ], + arkts.Es2pandaImportKinds.IMPORT_KINDS_ALL, + ), + ...script.statements, + ], + script.ident, + script.getNamespaceFlag(), + script.program, + ) + + util.ARKTS_TEST_ASSERTION( + script, + ` + import { X } from "./variable" + import { Y } from "./variable" + + function main() { + console.log(X) + } + `, + arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED + ) + + // util.cleanGenerated() + // util.fileToAbc(`./input/variable.sts`, true) + // util.contextToAbc() + // util.runAbc(`./generated/main.abc`, ['./generated/variable.abc']) + }) + + test("rewrite-imported-function", function() { + const sample_in = + ` + import { f } from "./f" + function main() {} + ` + + let script = arkts.createETSModuleFromSource(sample_in) + const functionDeclaration: arkts.FunctionDeclaration = script.statements[1] as arkts.FunctionDeclaration + const scriptFunction: arkts.ScriptFunction = functionDeclaration.function! + + const newScriptFunc = + arkts.factory.updateScriptFunction( + scriptFunction, + arkts.factory.createBlockStatement( + [ + arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createIdentifier( + 'f' + ), + [], + undefined, + false, + false, + undefined, + ) + ) + ] + ), + undefined, + [], + undefined, + false, + scriptFunction.flags, + scriptFunction.modifierFlags, + scriptFunction.id!, + undefined, + ) + + const newFuncDecl = + arkts.factory.updateFunctionDeclaration( + functionDeclaration, + newScriptFunc, + [], + false + ) + newFuncDecl.updateModifiers(newScriptFunc.modifierFlags) + + script = arkts.factory.updateETSModule( + script, + [ + script.statements[0], + newFuncDecl + ], + script.ident, + script.getNamespaceFlag(), + script.program, + ) + + util.ARKTS_TEST_ASSERTION( + script, + ` + import { f } from "./f" + function main() { + f() + } + `, + arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED + ) + + // util.cleanGenerated() + // util.fileToAbc(`./input/f.sts`, true) + // util.contextToAbc() + // util.runAbc(`./generated/main.abc`, ['./generated/f.abc']) + }) +}) diff --git a/ets1.2/libarkts/test/arkts-api/recheck/arktsconfig.json b/ets1.2/libarkts/test/arkts-api/recheck/arktsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..a0a1a87886101252b596d34ce445bf2d2e8f63ca --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/arktsconfig.json @@ -0,0 +1,7 @@ +{ + "compilerOptions": { + "outDir": "./build/abc", + "baseUrl": "." + }, + "include": ["./**/*.ts"] +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/constructor/index.ts b/ets1.2/libarkts/test/arkts-api/recheck/constructor/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..52b9b2e2e6c8825934e12877936cd3e5f1a3644f --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/constructor/index.ts @@ -0,0 +1,52 @@ +/* + * 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 * as arkts from "../../../../src/arkts-api" + +class ConstructorWithOverload extends arkts.AbstractVisitor { + visitor(beforeChildren: arkts.BlockStatement): arkts.BlockStatement + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + const node = this.visitEachChild(beforeChildren) + if (arkts.isScriptFunction(node) && node.id?.name == "constructor") { + return arkts.factory.updateScriptFunction( + node, + arkts.factory.createBlockStatement( + [ + + arkts.factory.createIfStatement( + arkts.factory.createBooleanLiteral(true), + arkts.factory.createReturnStatement(), + undefined + ), + ...(arkts.isBlockStatement(node.body) ? node.body.statements : []), + ] + ), + node.typeParams, + node.params, + node.returnTypeAnnotation, + node.hasReceiver, + node.flags, + node.modifierFlags, + node.id, + node.annotations + ) + } + return node + } +} + +export function constructorWithOverload(program: arkts.Program) { + program.setAst(new ConstructorWithOverload().visitor(program.ast)) +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/constructor/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/constructor/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..77d192544a663c738c67499d9f27c4c843da3fae --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/constructor/main.ets @@ -0,0 +1,5 @@ + +class XXX { + constructor(x: ()=>void, y?: ()=>void) { + } +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/exports/add-export/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/exports/add-export/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..9eaf755df9b31441fb402e15a469477e02fc4bab --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/exports/add-export/dump-src/main.ets @@ -0,0 +1,13 @@ + +import { C as C } from "./library"; + +import { f as f } from "./library"; + +function main() {} + + +class D { + public c = new C(); + +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/exports/add-export/index.ts b/ets1.2/libarkts/test/arkts-api/recheck/exports/add-export/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..d131f3cd2b7e0c17b1ec32b04b131eb728aea640 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/exports/add-export/index.ts @@ -0,0 +1,95 @@ +/* + * 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 * as arkts from "../../../../../src/arkts-api" + +class ExportClass extends arkts.AbstractVisitor { + visitor(beforeChildren: arkts.BlockStatement): arkts.BlockStatement + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + const node = this.visitEachChild(beforeChildren) + if (arkts.isClassDeclaration(node) && node.definition?.ident?.name == "C") { + node.modifierFlags |= arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_EXPORT + } + return node + } +} + +export function addUseImportClassSameFileAndExportClass(program: arkts.Program, options: arkts.CompilationOptions) { + if (options.isProgramForCodegeneration) { + const module = program.ast as arkts.ETSModule + program.setAst( + arkts.factory.updateETSModule( + module, + [ + // import { C as C } from "./library" + arkts.factory.createETSImportDeclaration( + arkts.factory.createStringLiteral( + './library' + ), + [ + arkts.factory.createImportSpecifier( + arkts.factory.createIdentifier( + 'C' + ), + arkts.factory.createIdentifier( + 'C' + ) + ) + ], + arkts.Es2pandaImportKinds.IMPORT_KINDS_ALL + ), + ...module.statements, + // class D { + // c = new C() + // } + arkts.factory.createClassDeclaration( + arkts.factory.createClassDefinition( + arkts.factory.createIdentifier("D"), + undefined, + undefined, + [], + undefined, + undefined, + [ + arkts.factory.createClassProperty( + arkts.factory.createIdentifier("c"), + arkts.factory.createETSNewClassInstanceExpression( + arkts.factory.createETSTypeReference( + arkts.factory.createETSTypeReferencePart( + arkts.factory.createIdentifier("C") + ) + ), + [] + ), + undefined, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + false, + ) + ], + arkts.Es2pandaClassDefinitionModifiers.CLASS_DEFINITION_MODIFIERS_CLASS_DECL, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + ) + ) + ], + module.ident, + module.getNamespaceFlag(), + module.program, + ) + ) + } else { + program.setAst(new ExportClass().visitor(program.ast)) + } + return program +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/exports/add-export/library.ets b/ets1.2/libarkts/test/arkts-api/recheck/exports/add-export/library.ets new file mode 100644 index 0000000000000000000000000000000000000000..17667d2341a877d57ac6ff421ca1386ba4bebf22 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/exports/add-export/library.ets @@ -0,0 +1,20 @@ +/* + * 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. + */ + +export declare function f(): void + +class C { + +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/exports/add-export/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/exports/add-export/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..0d31540d6ff2d83b82b231e29cd1d5fab27c2fb3 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/exports/add-export/main.ets @@ -0,0 +1,18 @@ +/* + * 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 { f } from "./library" + +f() diff --git a/ets1.2/libarkts/test/arkts-api/recheck/exports/basic/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/exports/basic/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..9eaf755df9b31441fb402e15a469477e02fc4bab --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/exports/basic/dump-src/main.ets @@ -0,0 +1,13 @@ + +import { C as C } from "./library"; + +import { f as f } from "./library"; + +function main() {} + + +class D { + public c = new C(); + +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/exports/basic/index.ts b/ets1.2/libarkts/test/arkts-api/recheck/exports/basic/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..5d0f11addf0773a775a92f1a4e80a150b67ac3f7 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/exports/basic/index.ts @@ -0,0 +1,82 @@ +/* + * 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 * as arkts from "../../../../../src/arkts-api" + +export function addUseImportClassSameFile(program: arkts.Program, options: arkts.CompilationOptions) { + if (options.isProgramForCodegeneration) { + const module = program.ast as arkts.ETSModule + program.setAst( + arkts.factory.updateETSModule( + module, + [ + // import { C as C } from "./library" + arkts.factory.createETSImportDeclaration( + arkts.factory.createStringLiteral( + './library' + ), + [ + arkts.factory.createImportSpecifier( + arkts.factory.createIdentifier( + 'C' + ), + arkts.factory.createIdentifier( + 'C' + ) + ) + ], + arkts.Es2pandaImportKinds.IMPORT_KINDS_ALL + ), + ...module.statements, + // class D { + // c = new C() + // } + arkts.factory.createClassDeclaration( + arkts.factory.createClassDefinition( + arkts.factory.createIdentifier("D"), + undefined, + undefined, + [], + undefined, + undefined, + [ + arkts.factory.createClassProperty( + arkts.factory.createIdentifier("c"), + arkts.factory.createETSNewClassInstanceExpression( + arkts.factory.createETSTypeReference( + arkts.factory.createETSTypeReferencePart( + arkts.factory.createIdentifier("C") + ) + ), + [] + ), + undefined, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + false, + ) + ], + arkts.Es2pandaClassDefinitionModifiers.CLASS_DEFINITION_MODIFIERS_CLASS_DECL, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + ) + ) + ], + module.ident, + module.getNamespaceFlag(), + module.program, + ) + ) + } + return program +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/exports/basic/library.ets b/ets1.2/libarkts/test/arkts-api/recheck/exports/basic/library.ets new file mode 100644 index 0000000000000000000000000000000000000000..7e717b8cc8fe9f36fc58fc44a7b7c450a9278568 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/exports/basic/library.ets @@ -0,0 +1,20 @@ +/* + * 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. + */ + +export declare function f(): void + +export class C { + +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/exports/basic/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/exports/basic/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..0d31540d6ff2d83b82b231e29cd1d5fab27c2fb3 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/exports/basic/main.ets @@ -0,0 +1,18 @@ +/* + * 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 { f } from "./library" + +f() diff --git a/ets1.2/libarkts/test/arkts-api/recheck/exports/create-class/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/exports/create-class/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..9eaf755df9b31441fb402e15a469477e02fc4bab --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/exports/create-class/dump-src/main.ets @@ -0,0 +1,13 @@ + +import { C as C } from "./library"; + +import { f as f } from "./library"; + +function main() {} + + +class D { + public c = new C(); + +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/exports/create-class/index.ts b/ets1.2/libarkts/test/arkts-api/recheck/exports/create-class/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..15d194c3b1834f66a82861277d040caa89c33aa6 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/exports/create-class/index.ts @@ -0,0 +1,135 @@ +/* + * 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 * as arkts from "../../../../../src/arkts-api" + +export function addUseImportClassSameFileAndCreateClass(program: arkts.Program, options: arkts.CompilationOptions) { + if (options.isProgramForCodegeneration) { + const module = program.ast as arkts.ETSModule + program.setAst( + arkts.factory.updateETSModule( + module, + [ + // import { C as C } from "./library" + arkts.factory.createETSImportDeclaration( + arkts.factory.createStringLiteral( + './library' + ), + [ + arkts.factory.createImportSpecifier( + arkts.factory.createIdentifier( + 'C' + ), + arkts.factory.createIdentifier( + 'C' + ) + ) + ], + arkts.Es2pandaImportKinds.IMPORT_KINDS_ALL + ), + ...module.statements, + // class D { + // c = new C() + // } + arkts.factory.createClassDeclaration( + arkts.factory.createClassDefinition( + arkts.factory.createIdentifier("D"), + undefined, + undefined, + [], + undefined, + undefined, + [ + arkts.factory.createClassProperty( + arkts.factory.createIdentifier("c"), + arkts.factory.createETSNewClassInstanceExpression( + arkts.factory.createETSTypeReference( + arkts.factory.createETSTypeReferencePart( + arkts.factory.createIdentifier("C") + ) + ), + [] + ), + undefined, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + false, + ) + ], + arkts.Es2pandaClassDefinitionModifiers.CLASS_DEFINITION_MODIFIERS_CLASS_DECL, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + ) + ) + ], + module.ident, + module.getNamespaceFlag(), + module.program, + ) + ) + } else { + const module = program.ast as arkts.ETSModule + program.setAst( + arkts.factory.updateETSModule( + module, + [ + ...module.statements, + arkts.factory.createClassDeclaration( + arkts.factory.createClassDefinition( + arkts.factory.createIdentifier( + "C" + ), + undefined, + undefined, + [], + undefined, + undefined, + [ + arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_CONSTRUCTOR, + arkts.factory.createIdentifier("constructor"), + arkts.factory.createFunctionExpression( + arkts.factory.createIdentifier("constructor"), + arkts.factory.createScriptFunction( + arkts.factory.createBlockStatement( + [], + ), + undefined, + [], + undefined, + false, + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_CONSTRUCTOR, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + arkts.factory.createIdentifier("constructor"), + [], + ) + ), + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_CONSTRUCTOR, + false, + [], + ), + ], + arkts.Es2pandaClassDefinitionModifiers.CLASS_DEFINITION_MODIFIERS_CLASS_DECL, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + ), + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_EXPORT, + ) + ], + module.ident, + module.getNamespaceFlag(), + module.program, + ) + ) + } + return program +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/exports/create-class/library.ets b/ets1.2/libarkts/test/arkts-api/recheck/exports/create-class/library.ets new file mode 100644 index 0000000000000000000000000000000000000000..e97afd392c7f7a88b99ca7f3112d4b7c93111e28 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/exports/create-class/library.ets @@ -0,0 +1,16 @@ +/* + * 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. + */ + +export declare function f(): void diff --git a/ets1.2/libarkts/test/arkts-api/recheck/exports/create-class/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/exports/create-class/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..0d31540d6ff2d83b82b231e29cd1d5fab27c2fb3 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/exports/create-class/main.ets @@ -0,0 +1,18 @@ +/* + * 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 { f } from "./library" + +f() diff --git a/ets1.2/libarkts/test/arkts-api/recheck/exports/struct-to-class/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/exports/struct-to-class/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..9eaf755df9b31441fb402e15a469477e02fc4bab --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/exports/struct-to-class/dump-src/main.ets @@ -0,0 +1,13 @@ + +import { C as C } from "./library"; + +import { f as f } from "./library"; + +function main() {} + + +class D { + public c = new C(); + +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/exports/struct-to-class/index.ts b/ets1.2/libarkts/test/arkts-api/recheck/exports/struct-to-class/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..959a6d6459fd1e75b3fd15f4a6ee2bcbe095e66a --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/exports/struct-to-class/index.ts @@ -0,0 +1,115 @@ +/* + * 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 * as arkts from "../../../../../src/arkts-api" + +class StructToClass extends arkts.AbstractVisitor { + visitor(beforeChildren: arkts.BlockStatement): arkts.BlockStatement + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + const node = this.visitEachChild(beforeChildren) + if (arkts.isETSStructDeclaration(node)) { + return arkts.factory.createClassDeclaration( + node.definition, + ) + } + return node + } +} + +export function rewriteStructToClass(program: arkts.Program, options: arkts.CompilationOptions) { + if (!options.isProgramForCodegeneration) { + program.setAst(new StructToClass().visitor(program.ast)) + } + return program +} + +class ExportClass extends arkts.AbstractVisitor { + visitor(beforeChildren: arkts.BlockStatement): arkts.BlockStatement + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + const node = this.visitEachChild(beforeChildren) + if (arkts.isClassDeclaration(node) && node.definition?.ident?.name == "C") { + node.modifierFlags |= arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_EXPORT + } + return node + } +} + +export function addUseImportClassSameFileAfterRewritingStructToClass(program: arkts.Program, options: arkts.CompilationOptions) { + if (options.isProgramForCodegeneration) { + const module = program.ast as arkts.ETSModule + program.setAst( + arkts.factory.updateETSModule( + module, + [ + // import { C as C } from "./library" + arkts.factory.createETSImportDeclaration( + arkts.factory.createStringLiteral( + './library' + ), + [ + arkts.factory.createImportSpecifier( + arkts.factory.createIdentifier( + 'C' + ), + arkts.factory.createIdentifier( + 'C' + ) + ) + ], + arkts.Es2pandaImportKinds.IMPORT_KINDS_ALL + ), + ...module.statements, + // class D { + // c = new C() + // } + arkts.factory.createClassDeclaration( + arkts.factory.createClassDefinition( + arkts.factory.createIdentifier("D"), + undefined, + undefined, + [], + undefined, + undefined, + [ + arkts.factory.createClassProperty( + arkts.factory.createIdentifier("c"), + arkts.factory.createETSNewClassInstanceExpression( + arkts.factory.createETSTypeReference( + arkts.factory.createETSTypeReferencePart( + arkts.factory.createIdentifier("C") + ) + ), + [] + ), + undefined, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + false, + ) + ], + arkts.Es2pandaClassDefinitionModifiers.CLASS_DEFINITION_MODIFIERS_CLASS_DECL, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_NONE, + ) + ) + ], + module.ident, + module.getNamespaceFlag(), + module.program, + ) + ) + } else { + program.setAst(new ExportClass().visitor(program.ast as arkts.ETSModule)) + } + return program +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/exports/struct-to-class/library.ets b/ets1.2/libarkts/test/arkts-api/recheck/exports/struct-to-class/library.ets new file mode 100644 index 0000000000000000000000000000000000000000..a84fea72c678bb42746294822a766a583a988bfb --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/exports/struct-to-class/library.ets @@ -0,0 +1,20 @@ +/* + * 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. + */ + +export declare function f(): void + +struct C { + +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/exports/struct-to-class/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/exports/struct-to-class/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..0d31540d6ff2d83b82b231e29cd1d5fab27c2fb3 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/exports/struct-to-class/main.ets @@ -0,0 +1,18 @@ +/* + * 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 { f } from "./library" + +f() diff --git a/ets1.2/libarkts/test/arkts-api/recheck/imports/add-new-file/index.ts b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-new-file/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..39557636fc77d7c24784db40b2ea95259dcd66d2 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-new-file/index.ts @@ -0,0 +1,50 @@ +/* + * 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 * as arkts from "../../../../../src/arkts-api" + +export function addImportNewFile(program: arkts.Program, options: arkts.CompilationOptions) { + if (options.isProgramForCodegeneration) { + const module = program.ast as arkts.ETSModule + program.setAst( + arkts.factory.updateETSModule( + module, + [ + arkts.factory.createETSImportDeclaration( + arkts.factory.createStringLiteral( + './library' + ), + [ + arkts.factory.createImportSpecifier( + arkts.factory.createIdentifier( + 'testFunction' + ), + arkts.factory.createIdentifier( + 'testFunction' + ) + ) + ], + arkts.Es2pandaImportKinds.IMPORT_KINDS_ALL + ), + ...module.statements, + ], + module.ident, + module.getNamespaceFlag(), + module.program, + ) + ) + } + return program +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/imports/add-new-file/library.ts b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-new-file/library.ts new file mode 100644 index 0000000000000000000000000000000000000000..a38c17c74a063eff1f70187e96138f96995ea380 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-new-file/library.ts @@ -0,0 +1,21 @@ +/* + * 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. + */ + +export function testFunction(): string { + return "yes" +} +export function anotherFunction(): string { + return "no" +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/imports/add-new-file/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-new-file/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..0310cbba14b1342ebfa00b5e78ee9f4ef3ff4251 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-new-file/main.ets @@ -0,0 +1,2 @@ + +console.log("test") diff --git a/ets1.2/libarkts/test/arkts-api/recheck/imports/add-same-file/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-same-file/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..80be4243ee2d39b464902ae6e8e2b101eacf7cfb --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-same-file/dump-src/main.ets @@ -0,0 +1,8 @@ + +import { testFunction as testFunction } from "./library"; + +import { anotherFunction as anotherFunction } from "./library"; + +function main() {} + + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/imports/add-same-file/index.ts b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-same-file/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..cd6e17d76ab0bb803766d600f67ef462de29f5e8 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-same-file/index.ts @@ -0,0 +1,50 @@ +/* + * 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 * as arkts from "../../../../../src/arkts-api" + +export function addImportSameFile(program: arkts.Program, options: arkts.CompilationOptions) { + if (options.isProgramForCodegeneration) { + const module = program.ast as arkts.ETSModule + program.setAst( + arkts.factory.updateETSModule( + module, + [ + arkts.factory.createETSImportDeclaration( + arkts.factory.createStringLiteral( + './library' + ), + [ + arkts.factory.createImportSpecifier( + arkts.factory.createIdentifier( + 'testFunction' + ), + arkts.factory.createIdentifier( + 'testFunction' + ) + ) + ], + arkts.Es2pandaImportKinds.IMPORT_KINDS_ALL + ), + ...module.statements, + ], + module.ident, + module.getNamespaceFlag(), + module.program, + ) + ) + } + return program +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/imports/add-same-file/library.ts b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-same-file/library.ts new file mode 100644 index 0000000000000000000000000000000000000000..a38c17c74a063eff1f70187e96138f96995ea380 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-same-file/library.ts @@ -0,0 +1,21 @@ +/* + * 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. + */ + +export function testFunction(): string { + return "yes" +} +export function anotherFunction(): string { + return "no" +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/imports/add-same-file/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-same-file/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..e5adb0b5d7e06cd2b8854e19cf1654f6998c4f3b --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-same-file/main.ets @@ -0,0 +1,17 @@ +/* + * 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 { anotherFunction } from "./library" +console.log("test") diff --git a/ets1.2/libarkts/test/arkts-api/recheck/imports/add-use-same-file/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-use-same-file/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..492e1126581a2fc42fec384a15e544deb4ddb667 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-use-same-file/dump-src/main.ets @@ -0,0 +1,9 @@ + +import { testFunction as testFunction } from "./library"; + +import { anotherFunction as anotherFunction } from "./library"; + +function main() {} + + +testFunction() diff --git a/ets1.2/libarkts/test/arkts-api/recheck/imports/add-use-same-file/index.ts b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-use-same-file/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..5e21a8ab7b1bb3839c51144b3fb2958a47f63b34 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-use-same-file/index.ts @@ -0,0 +1,60 @@ +/* + * 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 * as arkts from "../../../../../src/arkts-api" + +export function addUseImportSameFile(program: arkts.Program, options: arkts.CompilationOptions) { + if (options.isProgramForCodegeneration) { + const module = program.ast as arkts.ETSModule + program.setAst( + arkts.factory.updateETSModule( + module, + [ + arkts.factory.createETSImportDeclaration( + arkts.factory.createStringLiteral( + './library' + ), + [ + arkts.factory.createImportSpecifier( + arkts.factory.createIdentifier( + 'testFunction' + ), + arkts.factory.createIdentifier( + 'testFunction' + ) + ) + ], + arkts.Es2pandaImportKinds.IMPORT_KINDS_ALL + ), + ...module.statements, + arkts.factory.createExpressionStatement( + arkts.factory.createCallExpression( + arkts.factory.createIdentifier("testFunction"), + [], + undefined, + false, + false, + undefined + ) + ) + ], + module.ident, + module.getNamespaceFlag(), + module.program, + ) + ) + } + return program +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/imports/add-use-same-file/library.ts b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-use-same-file/library.ts new file mode 100644 index 0000000000000000000000000000000000000000..a38c17c74a063eff1f70187e96138f96995ea380 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-use-same-file/library.ts @@ -0,0 +1,21 @@ +/* + * 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. + */ + +export function testFunction(): string { + return "yes" +} +export function anotherFunction(): string { + return "no" +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/imports/add-use-same-file/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-use-same-file/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..e5adb0b5d7e06cd2b8854e19cf1654f6998c4f3b --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/imports/add-use-same-file/main.ets @@ -0,0 +1,17 @@ +/* + * 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 { anotherFunction } from "./library" +console.log("test") diff --git a/ets1.2/libarkts/test/arkts-api/recheck/imports/recursive/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/imports/recursive/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..951b36b32a961171c56b877adc32650dc850e4c1 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/imports/recursive/dump-src/main.ets @@ -0,0 +1,8 @@ + +import { One as One } from "./one_recursive"; + +import { Two as Two } from "./two_recursive"; + +function main() {} + + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/imports/recursive/index.ts b/ets1.2/libarkts/test/arkts-api/recheck/imports/recursive/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..43a9433ed75236cfbdcd96732626e88b0debf71f --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/imports/recursive/index.ts @@ -0,0 +1,51 @@ +/* + * 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 * as arkts from "../../../../../src/arkts-api" + +class InsertParameter extends arkts.AbstractVisitor { + visitor(beforeChildren: arkts.BlockStatement): arkts.BlockStatement + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + const node = this.visitEachChild(beforeChildren) + if (arkts.isScriptFunction(node) && + (node.id?.name == "one" || node.id?.name == "two") ) { + + return arkts.factory.updateScriptFunction( + node, + node.body, + node.typeParams, + [ + arkts.factory.createETSParameterExpression( + arkts.factory.createIdentifier("createdParam", arkts.factory.createETSPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_BOOLEAN)), + false, + undefined, + undefined + ) + ], + node.returnTypeAnnotation, + node.hasReceiver, + node.flags, + node.modifierFlags, + node.id, + node.annotations + ) + } + return node + } +} + +export function insertParameter(program: arkts.Program) { + program.setAst(new InsertParameter().visitor(program.ast)) +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/imports/recursive/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/imports/recursive/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..2e116ff7b2489399a52958a87ec48c2cd32e8f00 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/imports/recursive/main.ets @@ -0,0 +1,17 @@ +/* + * 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 { One } from "./one_recursive" +import { Two } from "./two_recursive" diff --git a/ets1.2/libarkts/test/arkts-api/recheck/imports/recursive/one_recursive.ts b/ets1.2/libarkts/test/arkts-api/recheck/imports/recursive/one_recursive.ts new file mode 100644 index 0000000000000000000000000000000000000000..bbc749b12407dc1c9f4cc453571e6f6798a6ab74 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/imports/recursive/one_recursive.ts @@ -0,0 +1,23 @@ +/* + * 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 { Two } from "./two_recursive" + +export interface One { + two(): Two { + throw new Error("") + } +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/imports/recursive/two_recursive.ts b/ets1.2/libarkts/test/arkts-api/recheck/imports/recursive/two_recursive.ts new file mode 100644 index 0000000000000000000000000000000000000000..ee28528bd7bc288ede551b0cf379c62cfa4d2443 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/imports/recursive/two_recursive.ts @@ -0,0 +1,23 @@ +/* + * 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 { One } from "./one_recursive" + +export interface Two { + one(): One { + throw new Error("") + } +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/lambda/unchanged/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/lambda/unchanged/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..e7e3006e6ceee557942ab27068d7f8cd993e6cb4 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/lambda/unchanged/dump-src/main.ets @@ -0,0 +1,29 @@ + +function main() {} + +function foo(): void { + HasInstantiate.$_instantiate((() => { + return new HasInstantiate(); + }), "foo"); +} + +function hasTrailing(first?: string, trailing?: (()=> void)): void { + ({let gensym%%_1040 = trailing; + (((gensym%%_1040) == (null)) ? undefined : gensym%%_1040())}); +} + +function bar(zzz: string): void { + hasTrailing("xxx"); + hasTrailing("xxx", (() => { + const d = zzz; + })); +} + + +class HasInstantiate { + public static $_instantiate(factory: (()=> HasInstantiate), arg: string) {} + + public constructor() {} + +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/lambda/unchanged/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/lambda/unchanged/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..354f2045d2f6220667a3bd4a009adb2ab91ef0f0 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/lambda/unchanged/main.ets @@ -0,0 +1,23 @@ + +class HasInstantiate { + static $_instantiate(factory: () => HasInstantiate, arg: string) { + } +} + +function foo(): void { + HasInstantiate("foo") +} + +function hasTrailing(first?: string, trailing?: () => void): void { + trailing?.() +} + +function bar(zzz: string): void { + + hasTrailing("xxx") + + hasTrailing("xxx") { + const d = zzz + } +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/optional/add-chain/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/optional/add-chain/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..35279acf0194c3296e5a80d7fbf3461335d59268 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/optional/add-chain/dump-src/main.ets @@ -0,0 +1,17 @@ + +function main() {} + +function someFunc(value: (SomeClass | undefined)): void { + let x: (SomeClass | undefined) = value; + let zzz = ({let chaintmp%%_0 = x; + (((chaintmp%%_0) === (undefined)) ? undefined : chaintmp%%_0.y)}); +} + + +class SomeClass { + public y: string = "yyy"; + + public constructor() {} + +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/optional/add-chain/index.ts b/ets1.2/libarkts/test/arkts-api/recheck/optional/add-chain/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..b5aa8a49ae77ca60a3a89bdb7b4bcaea784c1138 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/optional/add-chain/index.ts @@ -0,0 +1,47 @@ +/* + * 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 * as arkts from "../../../../../src/arkts-api" + +class AddOptionalChain extends arkts.AbstractVisitor { + visitor(beforeChildren: arkts.BlockStatement): arkts.BlockStatement + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + const node = this.visitEachChild(beforeChildren) + if (arkts.isVariableDeclarator(node) && arkts.isIdentifier(node.id) && node.id.name == "zzz") { + return arkts.factory.updateVariableDeclarator( + node, + node.flag, + node.id, + arkts.factory.createChainExpression( + arkts.factory.createMemberExpression( + + arkts.factory.createIdentifier("x"), + arkts.factory.createIdentifier("y"), + arkts.Es2pandaMemberExpressionKind.MEMBER_EXPRESSION_KIND_PROPERTY_ACCESS, + false, + false + ) + ) + + ) + } + return node + } +} + +export function addOptionalChain(program: arkts.Program) { + const inserted = new AddOptionalChain().visitor(program.ast) + return program.setAst(new arkts.ChainExpressionFilter().visitor(inserted)) +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/optional/add-chain/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/optional/add-chain/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..e53234f414663b13d1e9c2460b68bd1073816d82 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/optional/add-chain/main.ets @@ -0,0 +1,9 @@ +class SomeClass { + y: string = "yyy" +} + +function someFunc(value: SomeClass|undefined): void { + let x: SomeClass|undefined = value + let zzz = x?.y +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/optional/unchanged/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/optional/unchanged/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..3f5b3689359ac7caa026bd432c064fbbf4f0f48e --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/optional/unchanged/dump-src/main.ets @@ -0,0 +1,17 @@ + +function main() {} + +function foo(x: (X | undefined)) { + let zzz = ({let gensym%%_890 = ({let gensym%%_889 = x; + (((gensym%%_889) == (null)) ? undefined : gensym%%_889.y)}); + (((gensym%%_890) == (null)) ? undefined : gensym%%_890.length)}); +} + + +class X { + public y?: (string | undefined); + + public constructor() {} + +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/optional/unchanged/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/optional/unchanged/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..492728c84a335682a8c692e9cc1a3b59063005c0 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/optional/unchanged/main.ets @@ -0,0 +1,9 @@ + +class X { + y?: string +} + +function foo(x: X|undefined) { + let zzz = x?.y?.length +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/overloads/getter-setter/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/overloads/getter-setter/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..f062e25a6f26c89d6ded757a5185163c6bcb7fe8 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/overloads/getter-setter/dump-src/main.ets @@ -0,0 +1,11 @@ + +function main() {} + + +interface I { + get f(): ((createdParam: boolean)=> void) + + set f(f: ((createdParam: boolean)=> void)) + +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/overloads/getter-setter/index.ts b/ets1.2/libarkts/test/arkts-api/recheck/overloads/getter-setter/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..f305ebeda4518463e1b0e94ce3d8226ee502dfac --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/overloads/getter-setter/index.ts @@ -0,0 +1,46 @@ +/* + * 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 * as arkts from "../../../../../src/arkts-api" + +class InsertParameterToType extends arkts.AbstractVisitor { + visitor(beforeChildren: arkts.BlockStatement): arkts.BlockStatement + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + const node = this.visitEachChild(beforeChildren) + if (arkts.isETSFunctionType(node)) { + return arkts.factory.createETSFunctionType( + node.typeParams, + [ + arkts.factory.createETSParameterExpression( + arkts.factory.createIdentifier("createdParam", arkts.factory.createETSPrimitiveType(arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_BOOLEAN)), + false, + undefined, + undefined + ), + ...node.params + ], + node.returnType, + node.isExtensionFunction, + node.flags, + node.annotations, + ) + } + return node + } +} + +export function insertParameterToType(program: arkts.Program) { + program.setAst(new InsertParameterToType().visitor(program.ast)) +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/overloads/getter-setter/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/overloads/getter-setter/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..d158146d3da863a3fb8feefc4390b28771ec0c5c --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/overloads/getter-setter/main.ets @@ -0,0 +1,19 @@ +/* + * 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. + */ + +interface I { + set f(f: () => void) + get f(): () => void +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/recheck.test.ts b/ets1.2/libarkts/test/arkts-api/recheck/recheck.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..28e8936831ae07ab692da0c3ce23860f475bf757 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/recheck.test.ts @@ -0,0 +1,293 @@ +/* + * Copyright (c) 2024-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 fs from "node:fs" +import * as util from "../../test-util" +import * as arkts from "../../../src" +import { constructorWithOverload } from "./constructor" +import { updateTopLevelClass } from "./simple" +import { renameClass } from "./simple/rename-class" +import { addClassMethod } from "./simple/add-class-method" +import { addVariableDeclaration } from "./simple/add-variable" +import { addThisReference } from "./this" +import { insertParameterToType } from "./overloads/getter-setter" +import { insertParameter } from "./imports/recursive" +import { addImportSameFile } from "./imports/add-same-file" +import { addUseImportSameFile } from "./imports/add-use-same-file" +import { addImportNewFile } from "./imports/add-new-file" +import { addOptionalChain } from "./optional/add-chain" +import { addUseImportClassSameFile } from "./exports/basic" +import { addUseImportClassSameFileAndExportClass } from "./exports/add-export" +import { addUseImportClassSameFileAndCreateClass } from "./exports/create-class" +import { addUseImportClassSameFileAfterRewritingStructToClass, rewriteStructToClass } from "./exports/struct-to-class" + +const DIR = './test/arkts-api/recheck' +const PANDA_SDK_PATH = process.env.PANDA_SDK_PATH ?? '../../incremental/tools/panda/node_modules/@panda/sdk' + +function createConfig(file: string) { + fs.mkdirSync(`${DIR}/build/abc/${file}`, { recursive: true }) + arkts.arktsGlobal.filePath = `${DIR}/${file}/main.ets` + arkts.arktsGlobal.config = arkts.Config.create([ + '_', + '--arktsconfig', + `${DIR}/arktsconfig.json`, + `${DIR}/${file}/main.ets`, + '--extension', + 'ets', + '--stdlib', + `${PANDA_SDK_PATH}/ets/stdlib`, + '--output', + `${DIR}/build/abc/${file}/main.abc` + ]).peer + + arkts.initVisitsTable() +} + +function createContext(file: string) { + const code = fs.readFileSync(`${DIR}/${file}/main.ets`, 'utf-8') + arkts.arktsGlobal.filePath = `${DIR}/${file}/main.ets` + arkts.arktsGlobal.compilerContext = arkts.Context.createFromString(code) +} + +function proceedToParsed() { + arkts.proceedToState(arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED) +} + +function proceedToChecked() { + arkts.proceedToState(arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED) +} + +function applyTransformOnState(transform?: arkts.ProgramTransformer, state: arkts.Es2pandaContextState = arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED) { + arkts.runTransformer(arkts.arktsGlobal.compilerContext!.program, state, transform, new arkts.PluginContextImpl(), {}) +} + +function recheck() { + arkts.recheckSubtree(arkts.createETSModuleFromContext()) +} + +function dumpSrc(file: string) { + const src = arkts.createETSModuleFromContext().dumpSrc() + fs.mkdirSync(`${DIR}/${file}/dump-src`, { recursive: true }) + fs.writeFileSync(`${DIR}/${file}/dump-src/main.ets`, src) +} + +function dumpJson(file: string) { + const json = arkts.createETSModuleFromContext().dumpJson() + fs.mkdirSync(`${DIR}/${file}/dump-json`, { recursive: true }) + fs.writeFileSync(`${DIR}/${file}/dump-json/main.json`, json) +} + +function assertSrc(file: string) { + const src = arkts.createETSModuleFromContext().dumpSrc() + const expected = fs.readFileSync(`${DIR}/${file}/dump-src/main.ets`, 'utf-8') + util.assert.equal(filterGensym(src), filterGensym(expected)) +} + +function assertJson(file: string) { + const json = arkts.createETSModuleFromContext().dumpJson() + const expected = fs.readFileSync(`${DIR}/${file}/dump-json/main.json`, 'utf-8') + util.assert.equal(json, expected) +} + +function filterGensym(value: string): string { + return value.replaceAll(/gensym%%_[0-9]*/g, "gensym_XXX") +} + +function proceedToBin() { + arkts.proceedToState(arkts.Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED) +} + +interface TestOptions { + skipSrc?: boolean, + skipJson?: boolean, +} + +const defaultTestOptions: TestOptions = { + skipSrc: false, + skipJson: true, +} + +function runTest( + file: string, + transform?: arkts.ProgramTransformer, + userOptions: TestOptions = defaultTestOptions +) { + const options = { + skipSrc: userOptions.skipSrc ?? defaultTestOptions.skipSrc, + skipJson: userOptions.skipJson ?? defaultTestOptions.skipJson, + } + createConfig(file) + createContext(file) + proceedToChecked() + applyTransformOnState(transform) + recheck() + if (process.env.TEST_GOLDEN == "1") { + if (!options.skipSrc) dumpSrc(file) + if (!options.skipJson) dumpJson(file) + } else { + if (!options.skipSrc) assertSrc(file) + if (!options.skipJson) assertJson(file) + } + proceedToBin() +} + +function runTestWithParsedTransform( + file: string, + parsedTransform?: arkts.ProgramTransformer, + transform?: arkts.ProgramTransformer, + userOptions: TestOptions = defaultTestOptions +) { + const options = { + skipSrc: userOptions.skipSrc ?? defaultTestOptions.skipSrc, + skipJson: userOptions.skipJson ?? defaultTestOptions.skipJson, + } + createConfig(file) + createContext(file) + proceedToParsed() + applyTransformOnState(parsedTransform, arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED) + proceedToChecked() + applyTransformOnState(transform) + recheck() + if (process.env.TEST_GOLDEN == "1") { + if (!options.skipSrc) dumpSrc(file) + if (!options.skipJson) dumpJson(file) + } else { + if (!options.skipSrc) assertSrc(file) + if (!options.skipJson) assertJson(file) + } + proceedToBin() +} + +suite(util.basename(__filename), () => { + suite('static', () => { + test("function", () => { + runTest('static/function', undefined) + }) + + test.skip("public setter", () => { + runTest('static/public-setter', undefined) + }) + + test.skip("constructor with overload", () => { + runTest('static/constructor', undefined) + }) + + // es2panda issue 24821 + test.skip("property", () => { + runTest('static/property', undefined) + }) + + test("typed property", () => { + runTest('static/typed-property', undefined) + }) + + test("trailing block", () => { + runTest('static/trailing-block', undefined) + }) + + test("import type", () => { + runTest('static/import-type', undefined) + }) + + test("import all", () => { + runTest('static/import-all', undefined) + }) + }) + + suite('simple', () => { + test('rename class', () => { + runTest('simple/rename-class', (program: arkts.Program) => { + program.setAst(updateTopLevelClass(program.ast as arkts.ETSModule, renameClass)) + }) + }) + + test('add class method', () => { + runTest('simple/add-class-method', (program: arkts.Program) => { + program.setAst(updateTopLevelClass(program.ast as arkts.ETSModule, addClassMethod)) + }) + }) + + test('add variable declaration', () => { + runTest('simple/add-variable', (program: arkts.Program) => { + program.setAst(updateTopLevelClass(program.ast as arkts.ETSModule, addVariableDeclaration)) + }) + }) + }) + + test.skip('constructor', () => { + runTest('constructor', constructorWithOverload) + }) + + test('add this reference', () => { + runTest('this', addThisReference) + }) + + suite('optional', () => { + test('pass optional unchanged', () => { + runTest('optional/unchanged', undefined) + }) + test('add optional chain', () => { + runTest('optional/add-chain', addOptionalChain) + }) + }) + + suite('lambda', () => { + test('compiler produced lambdas unchanged', () => { + runTest('lambda/unchanged', undefined) + }) + }) + + suite('imports', () => { + test('add another import from the same file with dedicated API', () => { + runTest('imports/add-same-file', addImportSameFile) + }) + + test('add another import from the same file with dedicated API and use it', () => { + runTest('imports/add-use-same-file', addUseImportSameFile) + }) + + test.skip('add import from the new file with dedicated API', () => { + runTest('imports/add-new-file', addImportNewFile) + }) + + test('recursive', () => { + runTest('imports/recursive', insertParameter) + }) + }) + + suite('overloads', () => { + test('getter and setter both modified simultaneously', () => { + runTest('overloads/getter-setter', insertParameterToType) + }) + }) + + suite('exports', () => { + test('import existing exported class', () => { + runTest('exports/basic', addUseImportClassSameFile) + }) + + test('import existing not exported class', () => { + runTest('exports/add-export', addUseImportClassSameFileAndExportClass) + }) + + test('import created class', () => { + runTest('exports/create-class', addUseImportClassSameFileAndCreateClass) + }) + + test('export struct as class', () => { + runTestWithParsedTransform('exports/struct-to-class', rewriteStructToClass, addUseImportClassSameFileAfterRewritingStructToClass) + }) + }) +}) diff --git a/ets1.2/libarkts/test/arkts-api/recheck/simple/add-class-method/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/simple/add-class-method/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..aeb6e10b7585d74241c6c72e8833eb7f75cd286d --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/simple/add-class-method/dump-src/main.ets @@ -0,0 +1,13 @@ + +function main() {} + + +class C { + public g(): double { + return 5; + } + + public constructor() {} + +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/simple/add-class-method/index.ts b/ets1.2/libarkts/test/arkts-api/recheck/simple/add-class-method/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..38d3ebcdc721a3fae4da12417286efb8e754d5af --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/simple/add-class-method/index.ts @@ -0,0 +1,59 @@ +/* + * 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 * as arkts from "../../../../../src/arkts-api" + +export function addClassMethod(node: arkts.ClassDefinition) { + return arkts.factory.updateClassDefinition( + node, + node.ident, + node.typeParams, + node.superTypeParams, + node.implements, + undefined, + node.super, + [ + arkts.factory.createMethodDefinition( + arkts.Es2pandaMethodDefinitionKind.METHOD_DEFINITION_KIND_METHOD, + arkts.factory.createIdentifier("g"), + arkts.factory.createFunctionExpression( + arkts.factory.createIdentifier("g"), + arkts.factory.createScriptFunction( + arkts.factory.createBlockStatement([ + arkts.factory.createReturnStatement( + arkts.factory.createNumberLiteral(5) + ) + ]), + undefined, + [], + arkts.factory.createETSPrimitiveType( + arkts.Es2pandaPrimitiveType.PRIMITIVE_TYPE_DOUBLE, + ), + false, + arkts.Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_METHOD, + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC, + arkts.factory.createIdentifier("g"), + undefined, + ) + ), + arkts.Es2pandaModifierFlags.MODIFIER_FLAGS_PUBLIC, + false, + ), + ...node.body, + ], + node.modifiers, + node.modifierFlags + ) +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/simple/add-class-method/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/simple/add-class-method/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..96041f4f2bd132009d7c06ce704d10ef206d9d2e --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/simple/add-class-method/main.ets @@ -0,0 +1,17 @@ +/* + * 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. + */ + +class C { +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/simple/add-variable/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/simple/add-variable/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..534b4a38d65bdaafd82b2f68e4a7ea83cc620f1e --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/simple/add-variable/dump-src/main.ets @@ -0,0 +1,13 @@ + +function main() {} + + +class C { + public f(): void { + const x = ((1) + (4)); + } + + public constructor() {} + +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/simple/add-variable/index.ts b/ets1.2/libarkts/test/arkts-api/recheck/simple/add-variable/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..fd15fbbd215fa8164344c27a7b8e55dee2c6e648 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/simple/add-variable/index.ts @@ -0,0 +1,90 @@ +/* + * 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 "../../../../../src/arkts-api" + +export function addVariableDeclaration(node: arkts.ClassDefinition) { + return arkts.factory.updateClassDefinition( + node, + node.ident, + node.typeParams, + node.superTypeParams, + node.implements, + undefined, + node.super, + [ + ...node.body.map((node: arkts.AstNode) => { + if (!arkts.isMethodDefinition(node)) { + return node + } + if (node.id?.name != "f") { + return node + } + if (!arkts.isFunctionExpression(node.value)) { + return node + } + const func = node.value.function + if (!func || !arkts.isBlockStatement(func.body)) { + return node + } + return arkts.factory.updateMethodDefinition( + node, + node.kind, + node.key, + arkts.factory.updateFunctionExpression( + node.value, + node.id, + arkts.factory.updateScriptFunction( + func, + arkts.factory.updateBlockStatement( + func.body, + [ + arkts.factory.createVariableDeclaration( + arkts.Es2pandaVariableDeclarationKind.VARIABLE_DECLARATION_KIND_CONST, + [ + arkts.factory.createVariableDeclarator( + arkts.Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_CONST, + arkts.factory.createIdentifier("x"), + arkts.factory.createBinaryExpression( + arkts.factory.createNumberLiteral(1), + arkts.factory.createNumberLiteral(4), + arkts.Es2pandaTokenType.TOKEN_TYPE_PUNCTUATOR_PLUS, + ), + ), + ], + ), + ...func.body.statements, + ], + ), + func.typeParams, + func.params, + func.returnTypeAnnotation, + func.hasReceiver, + func.flags, + func.modifierFlags, + func.id, + func.annotations, + ), + ), + node.modifierFlags, + node.isComputed, + node.overloads, + ) + }) + ], + node.modifiers, + node.modifierFlags + ) +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/simple/add-variable/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/simple/add-variable/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..408125c2b4b2a22a708ba13ff54bae651b3285ab --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/simple/add-variable/main.ets @@ -0,0 +1,19 @@ +/* + * 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. + */ + +class C { + f(): void { + } +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/simple/index.ts b/ets1.2/libarkts/test/arkts-api/recheck/simple/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..1966eff8eadb63a6eed9a979938dcdcccf9a9b77 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/simple/index.ts @@ -0,0 +1,45 @@ +/* + * 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 * as arkts from "../../../../src/arkts-api" + +export function updateTopLevelClass( + module: arkts.ETSModule, + update: (node: arkts.ClassDefinition) => arkts.ClassDefinition +) { + return arkts.factory.updateETSModule( + module, + [ + ...module.statements.map((node) => { + if (!arkts.isClassDeclaration(node)) { + return node + } + if (!arkts.isClassDefinition(node.definition)) { + return node + } + if (node.definition.ident?.name == "C") { + return arkts.factory.updateClassDeclaration( + node, + update(node.definition) + ) + } + return node + }) + ], + module.ident, + module.getNamespaceFlag(), + module.program, + ) +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/simple/rename-class/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/simple/rename-class/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..b91d6ad10f82db415ab0d794ff579a81e70b4eaf --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/simple/rename-class/dump-src/main.ets @@ -0,0 +1,11 @@ + +function main() {} + + +class D { + public f(): void {} + + public constructor() {} + +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/simple/rename-class/index.ts b/ets1.2/libarkts/test/arkts-api/recheck/simple/rename-class/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..c930e924aaef3abee06b1b8546217c8432a6302e --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/simple/rename-class/index.ts @@ -0,0 +1,34 @@ +/* + * 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 * as arkts from "../../../../../src/arkts-api" + +export function renameClass(node: arkts.ClassDefinition) { + return arkts.factory.updateClassDefinition( + node, + node.ident ? arkts.factory.updateIdentifier( + node.ident, + "D" + ) : undefined, + node.typeParams, + node.superTypeParams, + node.implements, + undefined, + node.super, + node.body, + node.modifiers, + node.modifierFlags + ) +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/simple/rename-class/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/simple/rename-class/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..64541ccc260c088a2955cf31b3c121a797d76cc5 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/simple/rename-class/main.ets @@ -0,0 +1,19 @@ +/* + * 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. + */ + +class C { + f(): void { + } +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/constructor/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/static/constructor/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..2339dcfc717a53690eeaa38d4b19582c77009c97 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/constructor/dump-src/main.ets @@ -0,0 +1,14 @@ + +function main(): void {} + + + +class XXX { + constructor(x: (()=> void)) { + this(x, undefined); + } + + public constructor(x: (()=> void), y: (()=> void) | undefined) {} + +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/constructor/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/static/constructor/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..5916c50417c70fbdc10c4def077c165df6dfd3b1 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/constructor/main.ets @@ -0,0 +1,19 @@ +/* + * 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. + */ + +class XXX { + constructor(x: ()=>void, y?: ()=>void) { + } +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/function/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/static/function/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..2d4ba9e9542eef9fd8300f31f22fa900e9e907f1 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/function/dump-src/main.ets @@ -0,0 +1,6 @@ + +function main() {} + +function foo(): void {} + + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/function/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/static/function/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..2c0360369803ad3484835777dd439988186dd684 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/function/main.ets @@ -0,0 +1,16 @@ +/* + * 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. + */ + +function foo(): void {} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/import-all/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/static/import-all/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..ee631c93e23b358831ded14d64532f1d8ab85af0 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/import-all/dump-src/main.ets @@ -0,0 +1,6 @@ + +import * as library from "./library"; + +function main() {} + + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/import-all/library.ts b/ets1.2/libarkts/test/arkts-api/recheck/static/import-all/library.ts new file mode 100644 index 0000000000000000000000000000000000000000..e76c034cae87408f2f5f2d2fd654168933a11512 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/import-all/library.ts @@ -0,0 +1,27 @@ +/* + * 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. + */ + +export class Scope { + static scope(): Scope { + throw new Error("") + } + cached(): T { + throw new Error("") + } +} + +export interface ExportedType { + scope( value: () => V ) +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/import-all/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/static/import-all/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..802b16326bf22b7a1bb6cc7f7a2b78ef75d113b2 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/import-all/main.ets @@ -0,0 +1,16 @@ +/* + * 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 * as library from "./library" diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/import-type/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/static/import-type/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..93843db2f86c0880c4140912875b10383a2ac10d --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/import-type/dump-src/main.ets @@ -0,0 +1,6 @@ + +import { ExportedType as ExportedType } from "./library"; + +function main() {} + + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/import-type/library.ts b/ets1.2/libarkts/test/arkts-api/recheck/static/import-type/library.ts new file mode 100644 index 0000000000000000000000000000000000000000..e76c034cae87408f2f5f2d2fd654168933a11512 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/import-type/library.ts @@ -0,0 +1,27 @@ +/* + * 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. + */ + +export class Scope { + static scope(): Scope { + throw new Error("") + } + cached(): T { + throw new Error("") + } +} + +export interface ExportedType { + scope( value: () => V ) +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/import-type/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/static/import-type/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..8bef6f3001b4084331c94ce3d2e6d5a1a081b042 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/import-type/main.ets @@ -0,0 +1,16 @@ +/* + * 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 { ExportedType } from "./library" diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/property/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/static/property/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..0cdc54eb9ec5b3611e1d7dbf889b35e5a28ebad7 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/property/main.ets @@ -0,0 +1,8 @@ + +interface I { + prop: boolean +} + +class C implements I { + prop = true +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/public-setter/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/static/public-setter/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..49c59c1b4c0232bd99f2233abbaa0683bc149290 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/public-setter/dump-src/main.ets @@ -0,0 +1,24 @@ + +import { AnimatedState as AnimatedState, one as one } from "./library"; + +let x: (AnimatedState | undefined); + +function main(): void {} + +if (x) { + x!.paused = true +} + +class AnimatedStateImpl implements AnimatedState { + set paused(paused: boolean) { + throw new Error(""); + } + + public get paused(): boolean { + throw new Error(""); + } + + public constructor() {} + +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/public-setter/library.ts b/ets1.2/libarkts/test/arkts-api/recheck/static/public-setter/library.ts new file mode 100644 index 0000000000000000000000000000000000000000..7f38c5ffaf4ab7b9ef62e4f354b41e36e4d74ffe --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/public-setter/library.ts @@ -0,0 +1,31 @@ +/* + * 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. + */ + +export interface AnimatedState { + paused: boolean +} + +class AnimatedStateImpl implements AnimatedState { + get paused(): boolean { + throw new Error("") + } + set paused(paused: boolean) { + throw new Error("") + } +} + +export function one() { + +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/public-setter/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/static/public-setter/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..f9676161864d3b65e9526fe9880d95e2ecc00560 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/public-setter/main.ets @@ -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 { AnimatedState, one } from "./library" + +let x: AnimatedState|undefined +if (x) x!.paused = true +class AnimatedStateImpl implements AnimatedState { + get paused(): boolean { + throw new Error("") + } + set paused(paused: boolean) { + throw new Error("") + } +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/trailing-block/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/static/trailing-block/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..b8097f64c43fb3fc4f2ceda9cd56bafefa384fcc --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/trailing-block/dump-src/main.ets @@ -0,0 +1,17 @@ + +function main() {} + + +class C { + public f(arg: (()=> void)): void {} + + public g(): void { + this.f((() => { + const x = 11; + })); + } + + public constructor() {} + +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/trailing-block/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/static/trailing-block/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..826ec914b9842dead5985b3faeda05d8dca60c01 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/trailing-block/main.ets @@ -0,0 +1,24 @@ +/* + * 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. + */ + +class C { + f(arg: () => void): void { } + + g(): void { + this.f() { + const x = 6 + 5 + } + } +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/typed-property/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/static/typed-property/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..db418dc18a268bf936bee3b83bc3f4a2a7cb4c12 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/typed-property/dump-src/main.ets @@ -0,0 +1,27 @@ + +function main() {} + + +interface I { + set prop(prop: boolean) + + get prop(): boolean + +} + +class C implements I { + public constructor() {} + + private _$property$_prop: boolean = true; + + set prop(_$property$_prop: boolean) { + this._$property$_prop = _$property$_prop; + return; + } + + public get prop(): boolean { + return this._$property$_prop; + } + +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/static/typed-property/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/static/typed-property/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..6cddab31224d58a02616fa2f571345d2600dee4d --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/static/typed-property/main.ets @@ -0,0 +1,22 @@ +/* + * 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. + */ + +interface I { + prop: boolean +} + +class C implements I { + prop: boolean = true +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/this/dump-src/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/this/dump-src/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..814a569298a5c056e8dcbdc3855ab35db73a0679 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/this/dump-src/main.ets @@ -0,0 +1,14 @@ + +function main() {} + + +class A { + public no_this(): void { + this; + console.log("test"); + } + + public constructor() {} + +} + diff --git a/ets1.2/libarkts/test/arkts-api/recheck/this/index.ts b/ets1.2/libarkts/test/arkts-api/recheck/this/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..65a35d8756ced9c843e5f6ae3a5472ec5c08eeb2 --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/this/index.ts @@ -0,0 +1,50 @@ +/* + * 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 * as arkts from "../../../../src/arkts-api" + +class AddThisReference extends arkts.AbstractVisitor { + visitor(beforeChildren: arkts.BlockStatement): arkts.BlockStatement + visitor(beforeChildren: arkts.AstNode): arkts.AstNode { + const node = this.visitEachChild(beforeChildren) + if (arkts.isScriptFunction(node) && node.id?.name == "no_this") { + return arkts.factory.updateScriptFunction( + node, + arkts.factory.createBlockStatement( + [ + + arkts.factory.createExpressionStatement( + arkts.factory.createThisExpression() + ), + ...(arkts.isBlockStatement(node.body) ? node.body.statements : []), + ] + ), + node.typeParams, + node.params, + node.returnTypeAnnotation, + node.hasReceiver, + node.flags, + node.modifierFlags, + node.id, + node.annotations + ) + } + return node + } +} + +export function addThisReference(program: arkts.Program) { + program.setAst(new AddThisReference().visitor(program.ast)) +} diff --git a/ets1.2/libarkts/test/arkts-api/recheck/this/main.ets b/ets1.2/libarkts/test/arkts-api/recheck/this/main.ets new file mode 100644 index 0000000000000000000000000000000000000000..c3dc450b6b52592337bedf34a59673ca6ac9129a --- /dev/null +++ b/ets1.2/libarkts/test/arkts-api/recheck/this/main.ets @@ -0,0 +1,20 @@ +/* + * 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. + */ + +class A { + no_this(): void { + console.log("test") + } +} diff --git a/ets1.2/libarkts/test/test-util.ts b/ets1.2/libarkts/test/test-util.ts new file mode 100644 index 0000000000000000000000000000000000000000..929043298dd306482e56eda96bf9c272d4035c8f --- /dev/null +++ b/ets1.2/libarkts/test/test-util.ts @@ -0,0 +1,158 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import { global } from "../src/arkts-api/static/global" +import * as arkts from "../src/arkts-api" + +import * as pth from "path" +import { assert } from "@koalaui/harness" +import { exec, execSync } from "child_process" + +export { Es2pandaNativeModule } from "../src/Es2pandaNativeModule" +export { assert } from "@koalaui/harness" + +export function alignText(text: string): string { + const lines = text.replace(/\t/gy, ' ').split('\n') + + const shift = + lines + .map((str: string) => str.search(/\S/)) + .reduce( + (prev: number, curr: number) => { + if (prev === -1) { + return curr + } + if (curr === -1) { + return prev + } + return Math.min(prev, curr) + } + ) + return lines.map(str => str.slice((shift === -1) ? 0 : shift)).join('\n').trim() +} + +export function basename(fileName: string) { + return pth.basename(fileName).split('.')[0] +} + +export function assertEqualsSource(sourceResult: string, sourceExpect: string, message?: string) { + assert.equal( + sourceResult.trim().split('\n').map((line: string) => line.trim()).join('\n'), + sourceExpect.trim().split('\n').map((line: string) => line.trim()).join('\n'), + message + ) +} + +export function ARKTS_TEST_ASSERTION(node: arkts.ETSModule, source: string, state?: arkts.Es2pandaContextState) { + const finalState: arkts.Es2pandaContextState = (() => { + if (state !== undefined) { + return state + } + if (process.env.STATE_CHECKED !== undefined) { + return arkts.Es2pandaContextState.ES2PANDA_STATE_CHECKED + } + return arkts.Es2pandaContextState.ES2PANDA_STATE_PARSED + })() + arkts.proceedToState(finalState) + + const ast = node.dumpJson() + const src = node.dumpSrc() + const dump = node.dump() + global.es2panda._DestroyContext(global.context) + + try { + const script = arkts.createETSModuleFromSource(source, finalState) + assertEqualsSource(src, script.dumpSrc(), 'Error on SOURCE comparison') + assert.equal(ast, script.dumpJson(), 'Error on JSON comparison') + assert.equal(dump, script.dump(), 'Error on DUMP comparison') + } finally { + global.es2panda._DestroyContext(global.context) + } +} + + + +export function cleanGenerated(): void { + exec('npm run clean:generated') +} + +export function fileToAbc(path: string, isModule?: boolean): void { + const file = pth.basename(path).split('.')[0] + + execSync(`../../../incremental/tools/panda/node_modules/@panda/sdk/linux_host_tools/bin/es2panda ${path} --arktsconfig ./arktsconfig.json ${isModule ? '--ets-module' : ''}`) + execSync('mkdir -p ./generated') + execSync(`mv ./${file}.abc ./generated/${file}.abc`) +} + +export function contextToAbc(): void { + arkts.proceedToState(arkts.Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED) + // Improve: get name of file + execSync('mkdir -p ./generated') + execSync('mv ./main.abc ./generated/main.abc') +} + +export function runAbc(path: string = './generated/main.abc', modules?: readonly string[]): void { + const modulesStr: string = (modules === undefined) ? '' : (':' + modules.join(':')) + + exec(`../../incremental/tools/panda/node_modules/@panda/sdk/linux_host_tools/bin/ark --load-runtimes=ets --boot-panda-files=../../incremental/tools/panda/node_modules/@panda/sdk/ets/etsstdlib.abc${modulesStr} ${path} ETSGLOBAL::main`, + (error: any, stdout: string, stderr: string) => { + if (error !== null) { + assert(false, `failed to run abc: ${error}`) + } + console.log(`stdout: ${stdout}`); + console.log(`stderr: ${stderr}`); + } + ) +} + +export function assertEqualsBinaryOutput(output: string, ctx: Mocha.Context): void { + if (process.env.TEST_BIN === undefined) { + ctx.skip() + } + try { + contextToAbc() + exec( + 'npm run run:abc', + (error: any, stdout: string, stderr: string) => { + if (error !== null) { + assert(false, `failed to run abc: ${error}`) + } + const lines = stdout.trim().split('\n') + assert(lines.length >= 2) + assert.equal(lines[0], '> run:abc') + assert.equal(stderr, '') + if (lines.length === 2) { + assert.equal('', output.trim()) + } else { + assert.equal(lines.splice(2).join('\n').trim(), output.trim()) + } + } + ) + } finally { + global.es2panda._DestroyContext(global.context) + } +} + +export function trimLines(value: string): string { + return value.split('\n').map(it => it.trim()).join('\n') +} + +export function equalTrimming(value1: string, value2: string, message: string) { + return assert.equal( + trimLines(value1), + trimLines(value2), + message + ) +} diff --git a/ets1.2/libarkts/test/ts-api/classes/heritage/extends.test.ts b/ets1.2/libarkts/test/ts-api/classes/heritage/extends.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..8a57a64cb8571fcb6f097cc3a6840e540ac44f43 --- /dev/null +++ b/ets1.2/libarkts/test/ts-api/classes/heritage/extends.test.ts @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as util from "../../../test-util" +import * as ts from "../../../../src/ts-api" +import { factory } from "../../../../src/ts-api" + +// Improve: +suite.skip(util.basename(__filename), () => { + test("sample-1", function() { + const sample_in = + ` + abstract class A {}; + abstract class C {}; + interface D {}; + class B extends A implements C, D {}; + ` + + let sourceFile = factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + // sourceFile = factory.updateSourceFile( + // sourceFile, + // [ + // factory.createClassDeclaration( + // [ + // factory.createToken(ts.SyntaxKind.AbstractKeyword) + // ], + // factory.createIdentifier("A"), + // undefined, + // undefined, + // [] + // ), + // factory.createClassDeclaration( + // undefined, + // factory.createIdentifier("B"), + // undefined, + // [ + // factory.createHeritageClause( + // ts.SyntaxKind.ExtendsKeyword, + // [ + // factory.createExpressionWithTypeArguments( + // factory.createIdentifier("A"), + // undefined + // ) + // ] + // ) + // ], + // [] + // ) + // ] + // ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + abstract class A {}; + class B extends A {}; + ` + ) + }) +}) diff --git a/ets1.2/libarkts/test/ts-api/cross/cross.test.ts b/ets1.2/libarkts/test/ts-api/cross/cross.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..de273c4aa9f445211ab1277e1431dce527eee9f6 --- /dev/null +++ b/ets1.2/libarkts/test/ts-api/cross/cross.test.ts @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as util from "../../test-util" +import * as ts from "../../../src/ts-api" + +suite.skip(util.basename(__filename), () => { + test("imported-function-call", function() { + const sample_in = + ` + import { X } from "./variable" + + export function main() { + console.log(X) + } + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + util.cleanGenerated() + util.fileToAbc(`./input/variable.sts`, true) + util.contextToAbc() + util.runAbc(`./generated/main.abc`, ['./generated/variable.abc']) + }) + + test("rewrite-imported-function-call", function() { + const sample_in = + ` + import { X } from "./variable" + + export function main() { + console.log(Y) + } + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + util.cleanGenerated() + util.fileToAbc(`./input/variable.sts`, true) + util.contextToAbc() + util.runAbc(`./generated/main.abc`, ['./generated/variable.abc']) + }) +}) diff --git a/ets1.2/libarkts/test/ts-api/functions/function-declaration/create-function-declaration.test.ts b/ets1.2/libarkts/test/ts-api/functions/function-declaration/create-function-declaration.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..fd329a7337bee2010ad65c242a9d01debc4fea2e --- /dev/null +++ b/ets1.2/libarkts/test/ts-api/functions/function-declaration/create-function-declaration.test.ts @@ -0,0 +1,442 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as util from "../../../test-util" +import * as ts from "../../../../src/ts-api" +import { factory } from "../../../../src/ts-api" + +suite.skip(util.basename(__filename), () => { + test("empty-function", function() { + // function test_func() { + // // empty + // } + + const sample_in = `` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + const funcDecl = ts.factory.createFunctionDeclaration( + undefined, + undefined, + ts.factory.createIdentifier("test_func"), + undefined, + [], + undefined, + ts.factory.createBlock( + [], + true + ) + ) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + funcDecl + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function test_func() {} + `, + ts.ContextState.ES2PANDA_STATE_PARSED, + ) + }) + + test("empty-function-with-param", function() { + const sample_in = `` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + const funcParams = [ + ts.factory.createParameterDeclaration( + undefined, + undefined, + ts.factory.createIdentifier("x"), + undefined, + ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword), + undefined + ) + ] + const funcDecl = ts.factory.createFunctionDeclaration( + undefined, + undefined, + ts.factory.createIdentifier("test_func"), + undefined, + funcParams, + undefined, + ts.factory.createBlock( + [], + true + ) + ) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + funcDecl + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function test_func(x: number) {} + `, + ts.ContextState.ES2PANDA_STATE_PARSED, + ) + }) + + test("empty-function-with-string-param", function() { + // function test_func(x: string) { + // // empty + // } + + const sample_in = `` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + const funcParams = [ + ts.factory.createParameterDeclaration( + undefined, + undefined, + ts.factory.createIdentifier("x"), + undefined, + ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), + undefined + ) + ] + const funcDecl = ts.factory.createFunctionDeclaration( + undefined, + undefined, + ts.factory.createIdentifier("test_func"), + undefined, + funcParams, + undefined, + ts.factory.createBlock( + [], + true + ) + ) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + funcDecl + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function test_func(x: string) {} + `, + ts.ContextState.ES2PANDA_STATE_PARSED, + ) + }) + + test("async-empty-function", function() { + // async function test_func() {} + + const sample_in = `` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + const funcDecl = ts.factory.createFunctionDeclaration( + [ + ts.factory.createToken(ts.SyntaxKind.AsyncKeyword) + ], + undefined, + ts.factory.createIdentifier("test_func"), + undefined, + [], + undefined, + ts.factory.createBlock( + [], + true + ) + ) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + funcDecl + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + async function test_func() {} + `, + ts.ContextState.ES2PANDA_STATE_PARSED, + ) + }) + + test.skip("empty-method-with-public-static-modifiers", function() { + const sample_in = + ` + class A { + } + ` + + let sourceFile = factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + let classDecl = sourceFile.statements[0] + util.assert(ts.isClassDeclaration(classDecl)) + + classDecl = factory.updateClassDeclaration( + classDecl, + undefined, + factory.createIdentifier("A"), + undefined, + undefined, + [ + factory.createMethodDeclaration( + [ + factory.createToken(ts.SyntaxKind.PublicKeyword), + factory.createToken(ts.SyntaxKind.StaticKeyword) + ], + undefined, + factory.createIdentifier("test_func"), + undefined, + undefined, + [], + undefined, + factory.createBlock( + [], + false + ) + ), + factory.createConstructorDeclaration( + [ + factory.createToken(ts.SyntaxKind.PublicKeyword) + ], + [], + factory.createBlock( + [], + false + ) + ) + ] + ) + + sourceFile = factory.updateSourceFile( + sourceFile, + [ + classDecl + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + class A { + public static test_func() {} + + public constructor() {} + + } + `, + ts.ContextState.ES2PANDA_STATE_PARSED, + ) + }) + + test("function-with-type-parameters", function() { + // function test_func(): void {} + + const sample_in = + ` + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + const funcDecl = ts.factory.createFunctionDeclaration( + undefined, + undefined, + ts.factory.createIdentifier("test_func"), + [ + ts.factory.createTSTypeParameterDeclaration( + undefined, + ts.factory.createIdentifier("T"), + undefined, + undefined + ), + ts.factory.createTSTypeParameterDeclaration( + undefined, + ts.factory.createIdentifier("K"), + undefined, + undefined + ) + ], + [], + ts.factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword), + ts.factory.createBlock( + [], + true + ) + ) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + funcDecl + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function test_func(): void {} + `, + ts.ContextState.ES2PANDA_STATE_PARSED, + ) + }) + + // Improve: change 0 -> 777 (waiting fix) + test("sample-1", function() { + const sample_in = + ` + console.log("OK") + ` + + let sourceFile = factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + const funcDecl = factory.createFunctionDeclaration( + undefined, + undefined, + factory.createIdentifier("foo"), + undefined, + [ + factory.createParameterDeclaration( + undefined, + undefined, + factory.createIdentifier("x"), + undefined, + factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword), + factory.createNumericLiteral(0) + ), + factory.createParameterDeclaration( + undefined, + undefined, + factory.createIdentifier("y"), + undefined, + factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), + factory.createStringLiteral("abc") + ) + ], + factory.createETSUnionTypeNode([ + factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword), + factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword) + ]), + factory.createBlock( + [factory.createReturnStatement(factory.createBinaryExpression( + factory.createIdentifier("x"), + factory.createToken(ts.SyntaxKind.PlusToken), + factory.createIdentifier("y") + ))], + true + ) + ) + + sourceFile = factory.updateSourceFile( + sourceFile, + [ + funcDecl, + sourceFile.statements[0] + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function foo(x: number = 0, y: string = "abc"): number | string { + return x + y + } + console.log("OK") + ` + ) + }) + + // Improve: change 0 -> 777 (waiting fix) + test("sample-2", function() { + const sample_in = + ` + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + const funcDecl = ts.factory.createFunctionDeclaration( + undefined, + undefined, + ts.factory.createIdentifier("foo"), + undefined, + [ + ts.factory.createParameterDeclaration( + undefined, + undefined, + ts.factory.createIdentifier("x"), + undefined, + ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword), + ts.factory.createNumericLiteral(0) + ), + ts.factory.createParameterDeclaration( + undefined, + undefined, + ts.factory.createIdentifier("y"), + undefined, + ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), + ts.factory.createStringLiteral("abc") + ) + ], + ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword), + ts.factory.createBlock( + [ + ts.factory.createReturnStatement( + ts.factory.createIdentifier("x") + ) + ], + true + ) + ) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + funcDecl, + // sourceFile.statements[0] + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function foo(x: number = 0, y: string = "abc"): number { + return x + } + `, + ts.ContextState.ES2PANDA_STATE_PARSED + ) + }) +}) diff --git a/ets1.2/libarkts/test/ts-api/functions/function-declaration/update-function-declaration.test.ts b/ets1.2/libarkts/test/ts-api/functions/function-declaration/update-function-declaration.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..ed3b74fe70182bc40478dc2bd9a5308c63621911 --- /dev/null +++ b/ets1.2/libarkts/test/ts-api/functions/function-declaration/update-function-declaration.test.ts @@ -0,0 +1,567 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as util from "../../../test-util" +import * as ts from "../../../../src/ts-api" + +suite.skip(util.basename(__filename), () => { + // adding y: string to signature + test("update-name-and-add-param-to-function", function() { + // function new_test_func(x: number, y: string) { + // // empty + // } + + const sample_in = + ` + function test_func(x: number) { + // empty + } + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + let testFunc = sourceFile.statements[0] + util.assert(ts.isFunctionDeclaration(testFunc)) + + const newParam = ts.factory.createParameterDeclaration( + undefined, + undefined, + ts.factory.createIdentifier("y"), + undefined, + ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), + undefined + ) + testFunc = ts.factory.updateFunctionDeclaration( + testFunc, + undefined, + undefined, + ts.factory.createIdentifier("new_test_func"), + undefined, + [ + ...testFunc.parameters, + newParam + ], + undefined, + testFunc.body + ) + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + testFunc + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function new_test_func(x: number, y: string) {} + ` + ) + }) + + // adding memo params to signature + test("add-params-to-memo-function", function() { + // function foo(__memo_context: __memo_context_type, __memo_id: __memo_id_type, x: number) { + // // empty + // } + + const sample_in = + ` + function foo(x: number) { + // empty + } + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + let testFunc = sourceFile.statements[0] + util.assert(ts.isFunctionDeclaration(testFunc)) + + testFunc = util.addMemoParamsToFunctionDeclaration(testFunc) + util.assert(ts.isFunctionDeclaration(testFunc)) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + testFunc + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function foo(__memo_context: __memo_context_type, __memo_id: __memo_id_type, x: number) {} + `, + ts.ContextState.ES2PANDA_STATE_PARSED, + ) + }) + + // adding identifier x + test("add-identifier-to-function-body", function() { + // function foo() { + // x + // } + + const sample_in = + ` + function foo(x: string) { + // empty + } + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + let testFunc = sourceFile.statements[0] + util.assert(ts.isFunctionDeclaration(testFunc)) + util.assert(testFunc.body !== undefined) + + let body_statements = [ + ...testFunc.body.statements, + ts.factory.createExpressionStatement(ts.factory.createIdentifier("x")) + ] + + testFunc = ts.factory.updateFunctionDeclaration( + testFunc, + undefined, + undefined, + testFunc.name, + undefined, + testFunc.parameters, + undefined, + ts.factory.updateBlock( + testFunc.body, + body_statements + ) + ) + util.assert(ts.isFunctionDeclaration(testFunc)) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + testFunc + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function foo(x: string) { + x + } + ` + ) + }) + + // adding __memo_scope.recache + test("add-property-access-expression-to-function-body", function() { + // function foo() { + // __memo_scope.recache + // } + + const sample_in = + ` + function foo() { + // empty + } + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + let testFunc = sourceFile.statements[0] + util.assert(ts.isFunctionDeclaration(testFunc)) + util.assert(testFunc.body !== undefined) + + let body_statements = [ + ...testFunc.body.statements, + ts.factory.createExpressionStatement( + ts.factory.createPropertyAccessExpression( + ts.factory.createIdentifier("__memo_scope"), + ts.factory.createIdentifier("recache") + ) + ) + ] + + testFunc = ts.factory.updateFunctionDeclaration( + testFunc, + undefined, + undefined, + testFunc.name, + undefined, + testFunc.parameters, + undefined, + ts.factory.updateBlock( + testFunc.body, + body_statements + ) + ) + util.assert(ts.isFunctionDeclaration(testFunc)) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + testFunc + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function foo() { + __memo_scope.recache; + } + `, + ts.ContextState.ES2PANDA_STATE_PARSED, + ) + }) + + // body memo rewrite (adding return statement) + test("add-return-statement-to-function-body", function() { + // function foo() { + // return __memo_scope.recache() + // } + + const sample_in = + ` + function foo() { + // empty + } + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + let testFunc = sourceFile.statements[0] + util.assert(ts.isFunctionDeclaration(testFunc)) + util.assert(testFunc.body !== undefined) + + let body_statements = [ + ...testFunc.body.statements, + ts.factory.createReturnStatement( + ts.factory.createCallExpression( + ts.factory.createPropertyAccessExpression( + ts.factory.createIdentifier("__memo_scope"), + ts.factory.createIdentifier("recache") + ), + undefined, + undefined + ) + ) + ] + + testFunc = ts.factory.updateFunctionDeclaration( + testFunc, + undefined, + undefined, + testFunc.name, + undefined, + testFunc.parameters, + undefined, + ts.factory.updateBlock( + testFunc.body, + body_statements + ) + ) + util.assert(ts.isFunctionDeclaration(testFunc)) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + testFunc + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function foo() { + return __memo_scope.recache(); + } + `, + ts.ContextState.ES2PANDA_STATE_PARSED, + ) + }) + + // body memo rewrite (adding if statement) + test("add-if-statement-to-function-body", function() { + // function foo() { + // if (__memo_scope.unchanged) + // return __memo_scope.cached + // } + + const sample_in = + ` + function foo() { + // empty + } + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + let testFunc = sourceFile.statements[0] + util.assert(ts.isFunctionDeclaration(testFunc)) + util.assert(testFunc.body !== undefined) + + let body_statements = [ + ts.factory.createIfStatement( + ts.factory.createPropertyAccessExpression( + ts.factory.createIdentifier("__memo_scope"), + ts.factory.createIdentifier("unchanged") + ), + ts.factory.createBlock([ + ts.factory.createReturnStatement( + ts.factory.createPropertyAccessExpression( + ts.factory.createIdentifier("__memo_scope"), + ts.factory.createIdentifier("cached") + ) + ) + ]), + undefined + ), + ...testFunc.body.statements + ] + + testFunc = ts.factory.updateFunctionDeclaration( + testFunc, + undefined, + undefined, + testFunc.name, + undefined, + testFunc.parameters, + undefined, + ts.factory.updateBlock( + testFunc.body, + body_statements + ) + ) + util.assert(ts.isFunctionDeclaration(testFunc)) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + testFunc + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function foo() { + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + } + `, + ts.ContextState.ES2PANDA_STATE_PARSED, + ) + }) + + // body memo rewrite + test("function-declaration-memo-rewrite", function() { + // function foo(__memo_context: __memo_context_type, __memo_id: __memo_id_type) { + // if (__memo_scope.unchanged) + // return __memo_scope.cached + // content(__memo_context, __memo_id + "key_id_main.ts") + // return __memo_scope.recache() + // } + + const sample_in = + ` + function foo() { + // empty + } + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + let testFunc = sourceFile.statements[0] + util.assert(ts.isFunctionDeclaration(testFunc)) + util.assert(testFunc.body !== undefined) + + let body_statements = [ + ts.factory.createIfStatement( + ts.factory.createPropertyAccessExpression( + ts.factory.createIdentifier("__memo_scope"), + ts.factory.createIdentifier("unchanged") + ), + ts.factory.createBlock([ + 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") + ) + ] + )), + ts.factory.createReturnStatement( + ts.factory.createCallExpression( + ts.factory.createPropertyAccessExpression( + ts.factory.createIdentifier("__memo_scope"), + ts.factory.createIdentifier("recache") + ), + undefined, + undefined + ) + ), + ...testFunc.body.statements + ] + + testFunc = util.addMemoParamsToFunctionDeclaration(testFunc) + util.assert(ts.isFunctionDeclaration(testFunc)) + util.assert(testFunc.body !== undefined) + + testFunc = ts.factory.updateFunctionDeclaration( + testFunc, + undefined, + undefined, + testFunc.name, + undefined, + testFunc.parameters, + undefined, + ts.factory.updateBlock( + testFunc.body, + body_statements + ) + ) + util.assert(ts.isFunctionDeclaration(testFunc)) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + testFunc + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function foo(__memo_context: __memo_context_type, __memo_id: __memo_id_type) { + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + content(__memo_context, ((__memo_id) + ("key_id_main.ts"))); + return __memo_scope.recache(); + } + `, + ts.ContextState.ES2PANDA_STATE_PARSED, + ) + }) + + test("return-lambda", function() { + const sample_in = + ` + function foo() {} + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + let testFunc = sourceFile.statements[0] + util.assert(ts.isFunctionDeclaration(testFunc)) + + testFunc = ts.factory.updateFunctionDeclaration( + testFunc, + undefined, + undefined, + ts.factory.createIdentifier("foo"), + undefined, + [ + ts.factory.createParameterDeclaration( + undefined, + undefined, + ts.factory.createIdentifier("x"), + undefined, + ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), + undefined + ) + ], + undefined, + ts.factory.createBlock( + [ + ts.factory.createReturnStatement( + ts.factory.createCallExpression( + ts.factory.createParenthesizedExpression( + ts.factory.createArrowFunction( + undefined, + undefined, + [ + ts.factory.createParameterDeclaration( + undefined, + undefined, + ts.factory.createIdentifier("val"), + undefined, + ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), + ts.factory.createIdentifier("x") + ) + ], + undefined, + ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), + ts.factory.createBlock( + [ + ts.factory.createExpressionStatement( + ts.factory.createIdentifier("val") + ) + ], + false + ) + ) + ), + undefined, + [] + ) + ) + ], + true + ) + ) + util.assert(ts.isFunctionDeclaration(testFunc)) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + testFunc + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function foo(x: string) { + return ((val: string = x) => { val })() + } + `, + ts.ContextState.ES2PANDA_STATE_PARSED, + ) + }) +}) diff --git a/ets1.2/libarkts/test/ts-api/functions/lambda-function/builder-lambda.test.ts b/ets1.2/libarkts/test/ts-api/functions/lambda-function/builder-lambda.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..8fd8ffb5f9c7115c533a0fdc4473102f58fa97a3 --- /dev/null +++ b/ets1.2/libarkts/test/ts-api/functions/lambda-function/builder-lambda.test.ts @@ -0,0 +1,166 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as util from "../../../test-util" +import * as ts from "../../../../src/ts-api" + +suite.skip(util.basename(__filename), () => { + test("adding-lambda-param-to-signature", function() { + // _Foo((instance: string) => { + // // empty + // }, "label"); + + const sample_in = + ` + Foo("label") + + function Foo(text: string): void { + console.log(text) + } + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + const newName = "_Foo" + const paramName = "instance" + + const firstStatement = sourceFile.statements[0] + util.assert(ts.isExpressionStatement(firstStatement)) + const node = firstStatement.expression + util.assert(ts.isCallExpression(node)) + + const instanceLambdaBody = ts.factory.createBlock([]) + const lambdaParams = [ + ts.factory.createParameterDeclaration( + undefined, + undefined, + ts.factory.createIdentifier(paramName), + undefined, + ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), + undefined + ) + ] + + const lambda = ts.factory.createArrowFunction( + undefined, + undefined, + lambdaParams, + undefined, + undefined, + instanceLambdaBody + ) + + const result = ts.factory.updateCallExpression( + node, + ts.factory.createIdentifier(newName), + undefined, + [ + lambda, + ...node.arguments + ] + ) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + ts.factory.createExpressionStatement(result) + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + _Foo(((instance: string) => {}), "label") + `, + ts.ContextState.ES2PANDA_STATE_PARSED, + ) + }) + + test("adding-body-to-lambda-param", function() { + // _Foo((instance: string) => { + // instance.bar().qux(); + // }, "label1", "label2"); + + const sample_in = + ` + Foo(instance.bar().qux(), "label1", "label2") + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + const newName = "_Foo" + const paramName = "instance" + + const firstStatement = sourceFile.statements[0] + util.assert(ts.isExpressionStatement(firstStatement)) + + const node = firstStatement.expression + util.assert(ts.isCallExpression(node)) + + const instanceLambdaBody = ts.factory.createBlock([ + ts.factory.createExpressionStatement( + node.arguments[0] + ) + ]) + const lambdaParams = [ + ts.factory.createParameterDeclaration( + undefined, + undefined, + ts.factory.createIdentifier(paramName), + undefined, + ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), + undefined + ) + ] + + const lambda = ts.factory.createArrowFunction( + undefined, + undefined, + lambdaParams, + undefined, + undefined, + instanceLambdaBody + ) + + const result = ts.factory.updateCallExpression( + node, + ts.factory.createIdentifier(newName), + undefined, + [ + lambda, + ...node.arguments.slice(1) + ] + ) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + ts.factory.createExpressionStatement(result) + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + _Foo(((instance: string) => { + instance.bar().qux(); + }), "label1", "label2") + `, + ts.ContextState.ES2PANDA_STATE_PARSED, + ) + }) +}) diff --git a/ets1.2/libarkts/test/ts-api/functions/lambda-function/lambda-param-memoization.test.ts b/ets1.2/libarkts/test/ts-api/functions/lambda-function/lambda-param-memoization.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..2982ad6eaa21113e6345af17cd86d0977e908e49 --- /dev/null +++ b/ets1.2/libarkts/test/ts-api/functions/lambda-function/lambda-param-memoization.test.ts @@ -0,0 +1,169 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as util from "../../../test-util" +import * as ts from "../../../../src/ts-api" + +suite.skip(util.basename(__filename), () => { + // full memo rewrite + test("memo-function-with-lambda-memo-param", function() { + // function foo( + // __memo_context: __memo_context_type, + // __memo_id: __memo_id_type, + // content: (__memo_context: __memo_context_type, __memo_id: __memo_id_type) => void + // ) { + // if (__memo_scope.unchanged) + // return __memo_scope.cached + // content(__memo_context, __memo_id + "key_id_main.ts") + // return __memo_scope.recache() + // } + + const sample_in = + ` + function foo( + content: () => void + ) { + content() + } + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + let testFunc = sourceFile.statements[0] + util.assert(ts.isFunctionDeclaration(testFunc)) + + let body_statements = [ + ts.factory.createIfStatement( + ts.factory.createPropertyAccessExpression( + ts.factory.createIdentifier("__memo_scope"), + ts.factory.createIdentifier("unchanged") + ), + ts.factory.createBlock([ + 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") + ) + ] + )), + ts.factory.createReturnStatement( + ts.factory.createCallExpression( + ts.factory.createPropertyAccessExpression( + ts.factory.createIdentifier("__memo_scope"), + ts.factory.createIdentifier("recache") + ), + undefined, + undefined + ) + ) + ] + + testFunc = util.addMemoParamsToFunctionDeclaration(testFunc) + util.assert(ts.isFunctionDeclaration(testFunc)) + util.assert(testFunc.body !== undefined) + + const newLambdaParams = [ + ts.factory.createParameterDeclaration( + undefined, + undefined, + ts.factory.createIdentifier("__memo_context"), + undefined, + ts.factory.createETSTypeReferenceNode( + ts.factory.createIdentifier("__memo_context_type"), + undefined + ) + ), + ts.factory.createParameterDeclaration( + undefined, + undefined, + ts.factory.createIdentifier("__memo_id"), + undefined, + ts.factory.createETSTypeReferenceNode( + ts.factory.createIdentifier("__memo_id_type"), + undefined + ), + ) + ] + + const newLambdaParam = ts.factory.createParameterDeclaration( + undefined, + undefined, + ts.factory.createIdentifier("content"), + undefined, + ts.factory.createFunctionTypeNode( + undefined, + newLambdaParams, + ts.factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword) + ), + undefined + ) + + testFunc = ts.factory.updateFunctionDeclaration( + testFunc, + undefined, + undefined, + testFunc.name, + undefined, + [ + testFunc.parameters[0], + testFunc.parameters[1], + newLambdaParam + ], + undefined, + ts.factory.updateBlock( + testFunc.body, + body_statements + ) + ) + util.assert(ts.isFunctionDeclaration(testFunc)) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + testFunc + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function foo(__memo_context: __memo_context_type, __memo_id: __memo_id_type, content: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)) { + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + content(__memo_context, ((__memo_id) + ("key_id_main.ts"))); + return __memo_scope.recache(); + } + `, + ts.ContextState.ES2PANDA_STATE_PARSED, + ) + }) +}) diff --git a/ets1.2/libarkts/test/ts-api/general/abc-gen.test.ts b/ets1.2/libarkts/test/ts-api/general/abc-gen.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..0a8411de1c3e965ef51d80ddcfc59605c7635b4c --- /dev/null +++ b/ets1.2/libarkts/test/ts-api/general/abc-gen.test.ts @@ -0,0 +1,190 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as util from "../../test-util" +import * as ts from "../../../src/ts-api" + +// tests for abc generation (now failing on CI) +suite.skip(util.basename(__filename), () => { + test("updating-expression-statement", function() { + const sample_in = + ` + function foo(lambda: (instance: string) => string): void { + console.log(lambda("ABC")) + } + + foo((instance: string) => { return instance }) + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + const expressionStatement = sourceFile.statements[1] + util.assert(ts.isExpressionStatement(expressionStatement)) + + const newStatements = [ + sourceFile.statements[0], + ts.factory.updateExpressionStatement( + expressionStatement, + expressionStatement.expression + ) + ] + + ts.factory.updateSourceFile(sourceFile, newStatements) + + util.assertEqualsBinaryOutput('ABC', this) + }) + + test("updating-function-declaration", function() { + const sample_in = + ` + function foo(): void { + console.log("A") + return + } + + foo() + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + const funcDecl = sourceFile.statements[0] + util.assert(ts.isFunctionDeclaration(funcDecl)) + + const newStatements = [ + ts.factory.updateFunctionDeclaration( + funcDecl, + undefined, + undefined, + funcDecl.name, + undefined, + funcDecl.parameters, + undefined, + funcDecl.body, + ), + sourceFile.statements[1], + ] + + ts.factory.updateSourceFile(sourceFile, newStatements) + + util.assertEqualsBinaryOutput('A', this) + }) + + test("updating-lambda-call", function() { + const sample_in = + ` + function foo(builder: () => void) {} + foo(() => {}) + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + const exprStatement = sourceFile.statements[1] + util.assert(ts.isExpressionStatement(exprStatement)) + const callExpr = exprStatement.expression + util.assert(ts.isCallExpression(callExpr)) + + util.assert(ts.isArrowFunction(callExpr.arguments[0])) + const lambdaArg = + ts.factory.createArrowFunction( + undefined, + undefined, + [], + undefined, + undefined, + callExpr.arguments[0].body + ) + + util.assert(ts.isIdentifier(callExpr.expression)) + const newStatements = [ + sourceFile.statements[0], + ts.factory.updateExpressionStatement( + exprStatement, + ts.factory.updateCallExpression( + callExpr, + ts.factory.createIdentifier('foo'), + undefined, + [ + lambdaArg, + ] + ) + ) + ] + ts.factory.updateSourceFile(sourceFile, newStatements) + + util.assertEqualsBinaryOutput('', this) + }) + + test("changing-variable-annotation", function() { + const sample_in = + ` + class A {} + + let x: AB + + console.log("ok") + ` + + let sourceFile = ts.factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + const varDecl = sourceFile.statements[1] + util.assert(ts.isVariableStatement(varDecl)) + + const declList = varDecl.declarationList + util.assert(ts.isVariableDeclarationList(declList)) + + const x = declList.declarations[0] + util.assert(ts.isVariableDeclaration(x)) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + sourceFile.statements[0], + ts.factory.updateVariableStatement( + varDecl, + undefined, + // declList + ts.factory.createVariableDeclarationList( + [ts.factory.createVariableDeclaration( + ts.factory.createIdentifier("x"), + undefined, + ts.factory.createETSTypeReferenceNode( + ts.factory.createIdentifier("A") + ), + undefined + )], + undefined + ) + ), + sourceFile.statements[2] + ] + ) + + util.assertEqualsBinaryOutput('ok', this) + }) + + test.skip("function-expression", function() { + const sample_in = + ` + const foo = function() { console.log("abc"); }; + foo(); + ` + + ts.factory.createSourceFile(sample_in) + util.assertEqualsBinaryOutput('abc', this) + }) +}) diff --git a/ets1.2/libarkts/test/ts-api/general/basic.test.ts b/ets1.2/libarkts/test/ts-api/general/basic.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..8f5a1a236a6ac581d1846d10fb330a240dec3523 --- /dev/null +++ b/ets1.2/libarkts/test/ts-api/general/basic.test.ts @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as util from "../../test-util" +import * as ts from "../../../src/ts-api" +import { factory } from "../../../src/ts-api" + +suite.skip(util.basename(__filename), () => { + test("sample-1", function() { + const sample_in = + ` + ` + + let sourceFile = factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + sourceFile = factory.updateSourceFile( + sourceFile, + [ + factory.createExpressionStatement( + factory.createIdentifier("abc") + ) + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + abc + `, + ts.ContextState.ES2PANDA_STATE_PARSED + ) + }) + + test("sample-2", function() { + const sample_in = + ` + ` + + let sourceFile = factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + sourceFile = factory.updateSourceFile( + sourceFile, + [ + factory.createFunctionDeclaration( + undefined, + undefined, + factory.createIdentifier("test"), + undefined, + [], + undefined, + factory.createBlock( + [], + true + ) + ) + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function test() {} + `, + ts.ContextState.ES2PANDA_STATE_PARSED + ) + }) + + test("sample-3", function() { + const sample_in = + ` + ` + + let sourceFile = factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + sourceFile = factory.updateSourceFile( + sourceFile, + [ + factory.createFunctionDeclaration( + undefined, + undefined, + factory.createIdentifier("test"), + undefined, + [ + factory.createParameterDeclaration( + undefined, + undefined, + factory.createIdentifier("x"), + undefined, + factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), + undefined + ) + ], + factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword), + factory.createBlock( + [ + factory.createReturnStatement( + factory.createNumericLiteral(0) + ) + ], + true + ) + ) + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function test(x: string): number { + return 0; + } + `, + ts.ContextState.ES2PANDA_STATE_PARSED + ) + }) + + test("sample-4", function() { + const sample_in = + ` + ` + + let sourceFile = factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + sourceFile = factory.updateSourceFile( + sourceFile, + [ + factory.createFunctionDeclaration( + undefined, + undefined, + factory.createIdentifier("test"), + [ + factory.createTSTypeParameterDeclaration( + undefined, + factory.createIdentifier("T"), + factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), + undefined + ) + ], + [ + factory.createParameterDeclaration( + undefined, + undefined, + factory.createIdentifier("x"), + undefined, + factory.createETSTypeReferenceNode( + factory.createIdentifier("T"), + undefined + ), + undefined + ) + ], + factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), + factory.createBlock( + [ + factory.createReturnStatement( + factory.createStringLiteral("aaa") + ) + ], + true + ) + ) + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function test(x: T): string { + return "aaa" + } + `, + ts.ContextState.ES2PANDA_STATE_PARSED + ) + }) +}) diff --git a/ets1.2/libarkts/test/ts-api/general/import.test.ts b/ets1.2/libarkts/test/ts-api/general/import.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..8f649094a1aa83dc9f4d14a26a8b66b984e9ce68 --- /dev/null +++ b/ets1.2/libarkts/test/ts-api/general/import.test.ts @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as util from "../../test-util" +import * as ts from "../../../src/ts-api" + +suite.skip(util.basename(__filename), () => { + // Improve: doesn't running now, but compiles (config gets only one file) + test("sample-1", function() { + const sample_in = + ` + import { TEST } from "./export" + console.log(TEST) + ` + + // util.getDefaultSetup(sample_in) + + // util.generateBinAndRun() + }) + + test("sample-2", function() { + const sample_in = + ` + import { power as F } from "std/math" + console.log(F(2, 10)) + ` + + // util.getDefaultSetup(sample_in) + + // arkts.proceedToState(arkts.ContextState.ES2PANDA_STATE_CHECKED) + + // const classDecl = arkts.nodeByPeer(util.getStatement(1)) + // util.assert(arkts.isClassDeclaration(classDecl)) + + // const method = classDecl.members[1] + // util.assert(arkts.isMethodDeclaration(method)) + + // const body = method.body! + // util.assert(arkts.isBlock(body)) + + // const exprStatement = body.statements[0] + // util.assert(arkts.isExpressionStatement(exprStatement)) + + // const callExpr = exprStatement.expression + // util.assert(arkts.isCallExpression(callExpr)) + + // const F = callExpr.arguments[0] + // util.assert(arkts.isCallExpression(F)) + + // const ident = F.expression + // util.assert(arkts.isIdentifier(ident)) + + // console.log(arkts.dumpJsonNode(ident)) + + // const decl = arkts.getDecl(ident) + // if (decl !== undefined) { + // console.log(arkts.dumpJsonNode(decl)) + // } else { + // console.log(decl) + // } + + // util.generateBinAndRun() + }) +}) diff --git a/ets1.2/libarkts/test/ts-api/import-export/import.test.ts b/ets1.2/libarkts/test/ts-api/import-export/import.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..66c2928a22acbc045c59ad72df28aa3787591c5b --- /dev/null +++ b/ets1.2/libarkts/test/ts-api/import-export/import.test.ts @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as util from "../../test-util" +import * as ts from "../../../src/ts-api" +import { factory } from "../../../src/ts-api" + +// Improve: +suite.skip(util.basename(__filename), () => { + test("sample-1", function() { + const sample_in = + ` + import { X } from "./variable" + ` + + let sourceFile = factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + // sourceFile = factory.updateSourceFile( + // sourceFile, + // [ + // factory.createImportDeclaration( + // undefined, + // factory.createImportClause( + // false, + // undefined, + // factory.createNamedImports( + // [ + // factory.createImportSpecifier( + // false, + // undefined, + // factory.createIdentifier("X") + // ) + // ] + // ) + // ), + // factory.createStringLiteral("./variable"), + // undefined + // ) + // ] + // ) + + // util.assertEqualsAfter( + // sourceFile, + // ` + // import { X } from "./variable" + // `, + // ts.ContextState.ES2PANDA_STATE_PARSED + // ) + }) +}) diff --git a/ets1.2/libarkts/test/ts-api/keyword-super/in-constructor.test.ts b/ets1.2/libarkts/test/ts-api/keyword-super/in-constructor.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..c51ab999aca8459253ab482f2bbbe0e7e2c16489 --- /dev/null +++ b/ets1.2/libarkts/test/ts-api/keyword-super/in-constructor.test.ts @@ -0,0 +1,109 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as util from "../../test-util" +import * as ts from "../../../src/ts-api" +import { factory } from "../../../src/ts-api" + +// Improve: +suite.skip(util.basename(__filename), () => { + test("sample-1", function() { + const sample_in = + ` + ` + + let sourceFile = factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + // sourceFile = factory.updateSourceFile( + // sourceFile, + // [ + // factory.createClassDeclaration( + // [factory.createToken(ts.SyntaxKind.AbstractKeyword)], + // factory.createIdentifier("A"), + // undefined, + // undefined, + // [factory.createConstructorDeclaration( + // undefined, + // [factory.createParameterDeclaration( + // undefined, + // undefined, + // factory.createIdentifier("x"), + // undefined, + // factory.createETSTypeReferenceNode( + // factory.createIdentifier("int"), + // undefined + // ), + // undefined + // )], + // factory.createBlock( + // [], + // false + // ) + // )] + // ), + // factory.createClassDeclaration( + // undefined, + // factory.createIdentifier("B"), + // undefined, + // [factory.createHeritageClause( + // ts.SyntaxKind.ExtendsKeyword, + // [factory.createExpressionWithTypeArguments( + // factory.createIdentifier("A"), + // undefined + // )] + // )], + // [factory.createConstructorDeclaration( + // undefined, + // [factory.createParameterDeclaration( + // undefined, + // undefined, + // factory.createIdentifier("x"), + // undefined, + // factory.createETSTypeReferenceNode( + // factory.createIdentifier("int"), + // undefined + // ), + // undefined + // )], + // factory.createBlock( + // [factory.createExpressionStatement(factory.createCallExpression( + // factory.createSuper(), + // undefined, + // [factory.createIdentifier("x")] + // ))], + // true + // ) + // )] + // ) + // ] + // ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + abstract class A { + constructor(x: int) {} + }; + + class B extends A { + constructor(x: int) { + super(x) + } + } + ` + ) + }) +}) diff --git a/ets1.2/libarkts/test/ts-api/variables/create-variable.test.ts b/ets1.2/libarkts/test/ts-api/variables/create-variable.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..18fa959be431b68ca87325e2ae7002a6fcadbe72 --- /dev/null +++ b/ets1.2/libarkts/test/ts-api/variables/create-variable.test.ts @@ -0,0 +1,264 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as util from "../../test-util" +import * as ts from "../../../src/ts-api" +import { factory } from "../../../src/ts-api" + +suite.skip(util.basename(__filename), () => { + test("const-number", function() { + const sample_in = + ` + function f() {} + ` + + let sourceFile = factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + const varDecl = factory.createVariableStatement( + undefined, + factory.createVariableDeclarationList( + [ + factory.createVariableDeclaration( + factory.createIdentifier("x"), + undefined, + factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword), + factory.createNumericLiteral(0) + ) + ], + ts.NodeFlags.Const + ) + ) + + const f = sourceFile.statements[0] + util.assert(ts.isFunctionDeclaration(f)) + + sourceFile = factory.updateSourceFile( + sourceFile, + [ + factory.updateFunctionDeclaration( + f, + f.modifiers, + undefined, + f.name, + f.typeParameters, + f.parameters, + f.type, + factory.createBlock([ + varDecl + ]) + ) + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function f() { + const x: number = 0 + } + ` + ) + }) + + test("declaration-list", function() { + // const x: number = 0, y: string = "a", z = 0 + + const sample_in = `const x = 1` + + let sourceFile = factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + const varStatement = sourceFile.statements[0] + util.assert(ts.isVariableStatement(varStatement)) + + sourceFile = ts.factory.updateSourceFile( + sourceFile, + [ + factory.updateVariableStatement( + varStatement, + [ + // Improve: not ok maybe (problem with ModifierFlags) + factory.createToken(ts.SyntaxKind.PublicKeyword), + factory.createToken(ts.SyntaxKind.StaticKeyword), + factory.createToken(ts.SyntaxKind.ConstKeyword), + ], + factory.createVariableDeclarationList( + [ + factory.createVariableDeclaration( + factory.createIdentifier("x"), + undefined, + factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword), + factory.createNumericLiteral(0) + ), + factory.createVariableDeclaration( + factory.createIdentifier("y"), + undefined, + factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), + factory.createStringLiteral("a") + ), + factory.createVariableDeclaration( + factory.createIdentifier("z"), + undefined, + undefined, + factory.createNumericLiteral(0) + ) + ], + ts.NodeFlags.Const + ) + ) + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + const x: number = 0, y: string = "a", z = 0 + ` + ) + }) + + test.skip("let-vars", function() { + const sample_in = + ` + const x = 0 + ` + + let sourceFile = factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + const varStatement = sourceFile.statements[0] + util.assert(ts.isVariableStatement(varStatement)) + + sourceFile = factory.updateSourceFile( + sourceFile, + [ + factory.updateVariableStatement( + varStatement, + [ + // Improve: not ok maybe (problem with ModifierFlags) + factory.createToken(ts.SyntaxKind.PublicKeyword), + factory.createToken(ts.SyntaxKind.StaticKeyword), + ], + factory.createVariableDeclarationList( + [ + factory.createVariableDeclaration( + factory.createIdentifier("x"), + undefined, + factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword), + factory.createNumericLiteral(0) + ), + factory.createVariableDeclaration( + factory.createIdentifier("y"), + undefined, + factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), + factory.createStringLiteral("a") + ), + factory.createVariableDeclaration( + factory.createIdentifier("z"), + undefined, + undefined, + factory.createNumericLiteral(0) + ) + ], + ts.NodeFlags.Let + ) + ) + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + let x: number = 0, y: string = "a", z = 0 + ` + ) + }) + + test("parenthesized-expression", function() { + const sample_in = + ` + ` + + let sourceFile = factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + sourceFile = factory.updateSourceFile( + sourceFile, + [ + factory.createVariableStatement( + [ + // Improve: not ok maybe (problem with ModifierFlags) + factory.createToken(ts.SyntaxKind.PublicKeyword), + factory.createToken(ts.SyntaxKind.StaticKeyword), + factory.createToken(ts.SyntaxKind.ConstKeyword), + ], + factory.createVariableDeclarationList( + [ + factory.createVariableDeclaration( + factory.createIdentifier("x"), + undefined, + factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword), + factory.createBinaryExpression( + factory.createParenthesizedExpression( + factory.createBinaryExpression( + factory.createNumericLiteral(0), + factory.createToken(ts.SyntaxKind.PlusToken), + factory.createNumericLiteral(0) + ) + ), + factory.createToken(ts.SyntaxKind.AsteriskToken), + factory.createNumericLiteral(0) + ) + ) + ], + ts.NodeFlags.Const + ) + ) + ] + ) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + const x: number = (0 + 0) * 0 + ` + ) + }) + + test.skip("question-mark", function() { + const sample_in = + ` + function foo(x?: number | undefined) { + console.log(x); + } + foo() + ` + + let sourceFile = factory.createSourceFile(sample_in) + util.assert(ts.isSourceFile(sourceFile)) + + util.TS_TEST_ASSERTION( + sourceFile, + ` + function foo(x?: number | undefined) { + console.log(x); + } + foo() + `, + ts.ContextState.ES2PANDA_STATE_PARSED + ) + }) +}) diff --git a/ets1.2/libarkts/test/ts-api/visitors-and-transformers/analysis-visitor.test.ts b/ets1.2/libarkts/test/ts-api/visitors-and-transformers/analysis-visitor.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..357d2204347ddb88855aa555e0007fe4927384cc --- /dev/null +++ b/ets1.2/libarkts/test/ts-api/visitors-and-transformers/analysis-visitor.test.ts @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// import * as util from "../../test-util" +// import * as ts from "../../../src/ts-api" +// import { AnalysisVisitor } from "../../../plugins/src/analysis-visitor" +// import { Tracer } from "../../../plugins/src/util" +// import { Rewrite } from "../../../plugins/src/transformation-context" +// +// suite(util.getSuiteTitle(__filename), () => { +// test("sample-1", function() { +// const sample_in = +// ` +// const _memo_x: string = "A" +// +// function _memo_foo() {} +// +// _memo_foo() +// ` +// +// let sourceFile = ts.factory.createSourceFile(sample_in) +// util.assert(ts.isSourceFile(sourceFile)) +// +// // ts.proceedToState(ts.ContextState.ES2PANDA_STATE_CHECKED) +// +// const options = {} +// +// const tracer = new Tracer(options) +// const rewrite = new Rewrite(sourceFile, options) +// +// const result = new AnalysisVisitor(tracer, rewrite).visitor(sourceFile) +// util.assert(ts.isSourceFile(result)) +// +// util.assert(rewrite.functionTable.size === 1) +// util.assert(rewrite.callTable.size === 1) +// util.assert(rewrite.variableTable.size === 1) +// }) +// }) diff --git a/ets1.2/libarkts/test/ts-api/visitors-and-transformers/builder-lambda-rewrite.test.ts b/ets1.2/libarkts/test/ts-api/visitors-and-transformers/builder-lambda-rewrite.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..45c1407fb1516d38c04f2159a28f09c7fe7f5b45 --- /dev/null +++ b/ets1.2/libarkts/test/ts-api/visitors-and-transformers/builder-lambda-rewrite.test.ts @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// import * as util from "../../test-util" +// import * as ts from "../../../src/ts-api" +// import { factory } from "../../../src/ts-api" +// import { BuilderLambdaTransformer } from "../../../plugins/src/builder-lambda-transformer" +// +// suite.skip(util.getSuiteTitle(__filename), () => { +// test("builder-lambda-transformer-sample-1", function() { +// // foo((instance: string) => { +// // return instance; +// // }, "label"); +// +// const sample_in = +// ` +// _BuilderLambdaCall_foo("label") +// ` +// +// let sourceFile = factory.createSourceFile(sample_in) +// util.assert(ts.isSourceFile(sourceFile)) +// +// const builderLambdaTransformer = new BuilderLambdaTransformer() +// +// const result = builderLambdaTransformer.visitor(sourceFile) +// util.assert(ts.isSourceFile(result)) +// +// util.TS_TEST_ASSERTION( +// result, +// ` +// foo(((instance: string) => { +// return instance; +// }), "label") +// `, +// ts.ContextState.ES2PANDA_STATE_PARSED, +// ) +// }) +// +// test("builder-lambda-transformer-sample-2", function() { +// // foo((instance: string) => { +// // return instance.bar().qux(); +// // }, "label1", "label2"); +// +// const sample_in = +// ` +// _BuilderLambdaCall_foo("label1", "label2").bar().qux() +// ` +// +// let sourceFile = factory.createSourceFile(sample_in) +// util.assert(ts.isSourceFile(sourceFile)) +// +// const builderLambdaTransformer = new BuilderLambdaTransformer() +// +// const result = builderLambdaTransformer.visitor(sourceFile) +// util.assert(ts.isSourceFile(result)) +// +// util.TS_TEST_ASSERTION( +// result, +// ` +// foo(((instance: string) => { +// return instance.bar().qux(); +// }), "label1", "label2") +// `, +// ts.ContextState.ES2PANDA_STATE_PARSED, +// ) +// }) +// +// // Improve: update nodes properly (now failing to generate bin) +// test("builder-lambda-transformer-sample-3", function() { +// // function Foo(builder: (instance: string) => string, arg1: string): void { +// // console.log(arg1 + builder("ABC")) +// // } +// // Foo((instance: string) => { +// // return instance.charAt(1) +// // }, "> second_char_of_ABC: ") +// +// const sample_in = +// ` +// function Foo(builder: (instance: string) => string, arg1: string): void { +// console.log(arg1 + builder("ABC")) +// } +// +// _BuilderLambdaCall_Foo("> second_char_of_ABC: ").charAt(1) +// ` +// +// let sourceFile = factory.createSourceFile(sample_in) +// util.assert(ts.isSourceFile(sourceFile)) +// +// const builderLambdaTransformer = new BuilderLambdaTransformer() +// +// const result = builderLambdaTransformer.visitor(sourceFile) +// util.assert(ts.isSourceFile(result)) +// +// util.TS_TEST_ASSERTION( +// result, +// ` +// function Foo(builder: ((instance: string)=> string), arg1: string): void { +// console.log(((arg1) + (builder("ABC")))); +// } +// +// Foo(((instance: string) => { +// return instance.charAt(1); +// }), "> second_char_of_ABC: ") +// `, +// ts.ContextState.ES2PANDA_STATE_PARSED, +// ) +// }) +// }) diff --git a/ets1.2/libarkts/test/ts-api/visitors-and-transformers/function-rewrite.test.ts b/ets1.2/libarkts/test/ts-api/visitors-and-transformers/function-rewrite.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..acd40a0249789f7ed6eca281739326f802637c94 --- /dev/null +++ b/ets1.2/libarkts/test/ts-api/visitors-and-transformers/function-rewrite.test.ts @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// import * as util from "../../test-util" +// import * as ts from "../../../src/ts-api" +// import global from "src/arkts-api/static/global" +// import { FunctionTransformer } from "../../../plugins/src/function-transformer" +// import { PrintVisitor } from "../../../plugins/src/print-visitor" +// +// suite.skip(util.getSuiteTitle(__filename), () => { +// test("function-transformer-sample-1", function() { +// const sample_in = +// ` +// const x: string = "A" +// +// function _REWRITE_foo() { +// console.log("FUNC CALLED: " + x) +// } +// +// _REWRITE_foo() +// ` +// +// const sourceFile = ts.factory.createSourceFile(sample_in, ts.ContextState.ES2PANDA_STATE_CHECKED) +// util.assert(ts.isSourceFile(sourceFile)) +// +// // util.nativeModule._VarBinderSetContext(global.context) +// // util.nativeModule._VarBinderSetProgram(global.context) +// // util.nativeModule._VarBinderSetGenStdLib(global.context, false) +// // util.nativeModule._VarBinderInitTopScope(global.context) +// // util.nativeModule._VarBinderIdentifierAnalysis(global.context) +// +// const result = (new FunctionTransformer()).visitor(sourceFile) +// util.assert(ts.isSourceFile(result)) +// +// util.TS_TEST_ASSERTION( +// sourceFile, +// ` +// const x: string = "A" +// +// function foo(x: string) { +// console.log("FUNC CALLED: " + x) +// } +// +// foo("SAMPLE") +// `, +// ts.ContextState.ES2PANDA_STATE_CHECKED, +// ) +// +// // Improve: +// util.nativeModule._VarBinderInitTopScope(global.context) +// util.nativeModule._VarBinderIdentifierAnalysis(global.context) +// ts.proceedToState(ts.ContextState.ES2PANDA_STATE_BIN_GENERATED) +// }) +// }) diff --git a/ets1.2/libarkts/test/ts-api/visitors-and-transformers/memo-rewrite.test.ts b/ets1.2/libarkts/test/ts-api/visitors-and-transformers/memo-rewrite.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..2aa9d54d53f53f74a95b73e8b93e854371e7a217 --- /dev/null +++ b/ets1.2/libarkts/test/ts-api/visitors-and-transformers/memo-rewrite.test.ts @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as util from "../../test-util" +import * as ts from "../../../src/ts-api" +import { MemoTransformer } from "../../../plugins/src/memo-transformer" + +suite.skip(util.basename(__filename), () => { + test("memo-transformer-sample-1", function() { + const sample_in = + ` + function _MEMO_foo() { + console.log("MEMO FUNC CALLED!") + } + + _MEMO_foo() + ` + + // util.getDefaultSetup(sample_in) + + // arkts.proceedToState(arkts.ContextState.ES2PANDA_STATE_CHECKED) + + // const sourceFile = arkts.makeView(util.AstProvider.provideAst()) + + // const memoTransformer = new MemoTransformer() + // const transformed = memoTransformer.visitor(sourceFile) + + // console.log(arkts.dumpSrcNode(sourceFile)) + }) +}) diff --git a/ets1.2/libarkts/test/ts-api/visitors-and-transformers/print-visitor.test.ts b/ets1.2/libarkts/test/ts-api/visitors-and-transformers/print-visitor.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..736a67e53db03887c81855e15bea58c92bd16f96 --- /dev/null +++ b/ets1.2/libarkts/test/ts-api/visitors-and-transformers/print-visitor.test.ts @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// import * as ts from "../../../src/ts-api" +// import * as util from "../../test-util" +// import { PrintVisitor } from "../../../plugins/src/print-visitor" +// +// suite.skip(util.getSuiteTitle(__filename), () => { +// test("sample-1", function() { +// const source = +// ` +// class Base { +// public a: int = 1; +// public method() { +// this.a = 2; +// } +// } +// class Derived extends Base {} +// function foo() { +// } +// function goo() { +// } +// function main(): void { +// let derived: Base = new Derived(); +// derived.method(); +// } +// ` +// const expected = +// ` +// SourceFile (mods: []) +// ClassDeclaration (mods: [1,4]) +// Identifier (mods: []) +// PropertyDeclaration (mods: [4]) +// MethodDeclaration (mods: [4]) +// Identifier (mods: []) +// Block (mods: []) +// ExpressionStatement (mods: []) +// AssignmentExpression (mods: []) +// MethodDeclaration (mods: []) +// Identifier (mods: []) +// Block (mods: []) +// ClassDeclaration (mods: [1,4]) +// Identifier (mods: []) +// MethodDeclaration (mods: []) +// Identifier (mods: []) +// Block (mods: []) +// FunctionDeclaration (mods: [1,4]) +// Identifier (mods: []) +// Block (mods: []) +// FunctionDeclaration (mods: [1,4]) +// Identifier (mods: []) +// Block (mods: []) +// FunctionDeclaration (mods: [1,4]) +// Identifier (mods: []) +// ETSPrimitiveType (mods: []) +// Block (mods: []) +// VariableStatement (mods: []) +// VariableDeclarationList (mods: []) +// VariableDeclaration (mods: []) +// ExpressionStatement (mods: []) +// CallExpression (mods: []) +// PropertyAccessExpression (mods: []) +// Identifier (mods: []) +// Identifier (mods: []) +// ` +// let sourceFile = ts.factory.createSourceFile(source) +// const output = (new PrintVisitor()).astToString(sourceFile) +// +// util.assert.equal(util.alignText(output), util.alignText(expected)) +// }) +// }) diff --git a/ets1.2/libarkts/test/tsconfig.json b/ets1.2/libarkts/test/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..b66a126a9af084f18e03fae9afd97279dcdb50cc --- /dev/null +++ b/ets1.2/libarkts/test/tsconfig.json @@ -0,0 +1,17 @@ +{ + "extends": "@koalaui/build-common/tsconfig.json", + "compilerOptions": { + "rootDir": "../", + "baseUrl": "../", + "outDir": "build/test", + "module": "CommonJS" + }, + "include": [ + "../src/**/*.ts", + "../test/**/*.ts", + "../examples/**/*.ts" + ], + "exclude": [ + "./ts-api/**/*" + ] +} diff --git a/ets1.2/libarkts/tools/issue_gen.mjs b/ets1.2/libarkts/tools/issue_gen.mjs new file mode 100644 index 0000000000000000000000000000000000000000..f6e1bae225e72caa1425b042a35ae91328099180 --- /dev/null +++ b/ets1.2/libarkts/tools/issue_gen.mjs @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2022-2023 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import * as fs from 'fs' +import * as path from 'path' + +process.chdir(path.resolve('./')) + +const issue_src = fs.readFileSync('../playground/src/playground.cc', { encoding: 'utf8', flag: 'r' }) + +const component_src = +` +### Component + +Plugin API + +` + +const revision_src = +` +### Revision + +"@panda/sdk": "1.5.0-dev.9184" + +` + +const reproduction_src = +` +### Reproduction + +\`\`\` +${issue_src} +\`\`\` + +` + +// Improve: +const log = `` + +const log_src = +` +### Log + +\`\`\` +${log} +\`\`\` +` + +console.log( + component_src + + revision_src + + reproduction_src + + log_src +) diff --git a/ets1.2/libarkts/tsconfig.host.json b/ets1.2/libarkts/tsconfig.host.json new file mode 100644 index 0000000000000000000000000000000000000000..73e04374e272aef15efa9265a13b154c18adbeca --- /dev/null +++ b/ets1.2/libarkts/tsconfig.host.json @@ -0,0 +1,12 @@ +{ + "extends": "@koalaui/build-common/tsconfig.json", + "compilerOptions": { + "outDir": "build", + "baseUrl": ".", + "rootDir": "./src-host", + "module": "esnext" + }, + "include": [ + "./src-host/**/*.ts" + ] +} diff --git a/ets1.2/libarkts/tsconfig.json b/ets1.2/libarkts/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..baa252e2361b92a1b9fcd3e31be0f6d29d9db982 --- /dev/null +++ b/ets1.2/libarkts/tsconfig.json @@ -0,0 +1,16 @@ +{ + "extends": "@koalaui/build-common/tsconfig.json", + "compilerOptions": { + "outDir": "build", + "baseUrl": ".", + "rootDir": "./src", + "module": "esnext", + "tsBuildInfoFile": "./build/tsconfig.tsbuildinfo" + }, + "include": [ + "./src/**/*.ts" + ], + "exclude": [ + "./src/ts-api/**/*.ts" + ] +} diff --git a/ets1.2/libarkts/tsconfig.plugin.json b/ets1.2/libarkts/tsconfig.plugin.json new file mode 100644 index 0000000000000000000000000000000000000000..b984e32b04420e5823c5b0ce024c019aefedcb8d --- /dev/null +++ b/ets1.2/libarkts/tsconfig.plugin.json @@ -0,0 +1,12 @@ +{ + "extends": "@koalaui/build-common/tsconfig.json", + "compilerOptions": { + "outDir": "build/plugins", + "baseUrl": ".", + "rootDir": "./plugins", + "module": "esnext" + }, + "include": [ + "./plugins/src/**/*.ts" + ] +} diff --git a/ets1.2/tests_memo/function-declarations/argument-call.test.ts b/ets1.2/tests_memo/function-declarations/argument-call.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..a3d7d2909665884324dfb5ca82cacde1f7be36f9 --- /dev/null +++ b/ets1.2/tests_memo/function-declarations/argument-call.test.ts @@ -0,0 +1,109 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const FUNCTION_DIR_PATH: string = 'memo/functions'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'argument-call.ets')]; + +const pluginTester = new PluginTester('test memo function', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@functions.OptionalParametersAnnotation({minArgCount:3}) function memo_arg_call(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg1: number, arg2: ((x: number)=> number), @memo() arg3: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, x: number)=> number), arg4?: ((x: number)=> number), @memo() arg5?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, x: number)=> number)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 5); + const __memo_parameter_arg1 = __memo_scope.param(0, arg1), __memo_parameter_arg2 = __memo_scope.param(1, arg2), __memo_parameter_arg3 = __memo_scope.param(2, arg3), __memo_parameter_arg4 = __memo_scope.param(3, arg4), __memo_parameter_arg5 = __memo_scope.param(4, arg5); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + __memo_parameter_arg2.value(__memo_parameter_arg1.value); + __memo_parameter_arg3.value(__memo_context, ((__memo_id) + ()), __memo_parameter_arg1.value); + ({let gensym%%_ = __memo_parameter_arg4.value; + (((gensym%%_) == (null)) ? undefined : gensym%%_(__memo_parameter_arg1.value))}); + ({let gensym%%_ = __memo_parameter_arg5.value; + (((gensym%%_) == (null)) ? undefined : gensym%%_(__memo_context, ((__memo_id) + ()), __memo_parameter_arg1.value))}); + { + __memo_scope.recache(); + return; + } +} +@functions.OptionalParametersAnnotation({minArgCount:1}) function memo_arg_call_with_lowering(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg1: number, arg4?: ((x: number)=> number), @memo() arg5?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, x: number)=> number)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 3); + const __memo_parameter_arg1 = __memo_scope.param(0, arg1), __memo_parameter_arg4 = __memo_scope.param(1, arg4), __memo_parameter_arg5 = __memo_scope.param(2, arg5); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + let gensym___ = __memo_parameter_arg4.value; + (((gensym___) == (null)) ? undefined : gensym___(__memo_parameter_arg1.value)); + } + { + let gensym___ = __memo_parameter_arg5.value; + (((gensym___) == (null)) ? undefined : gensym___(__memo_context, ((__memo_id) + ()), __memo_parameter_arg1.value)); + } + { + __memo_scope.recache(); + return; + } +} +@functions.OptionalParametersAnnotation({minArgCount:0}) function args_with_default_values(__memo_context: __memo_context_type, __memo_id: __memo_id_type, gensym%%_?: int, @memo() gensym%%_?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> int), gensym%%_?: int, arg4?: int): void { + let arg1: int = (((gensym%%_) !== (undefined)) ? gensym%%_ : (10 as int)); + let arg2: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> int) = (((gensym%%_) !== (undefined)) ? gensym%%_ : (((__memo_context: __memo_context_type, __memo_id: __memo_id_type): int => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(20); + }) as ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> int))); + let arg3: int = (((gensym%%_) !== (undefined)) ? gensym%%_ : (arg1 as int)); + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 4); + const __memo_parameter_arg1 = __memo_scope.param(0, arg1), __memo_parameter_arg2 = __memo_scope.param(1, arg2), __memo_parameter_arg3 = __memo_scope.param(2, arg3), __memo_parameter_arg4 = __memo_scope.param(3, arg4); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + console.log(__memo_parameter_arg1.value, __memo_parameter_arg2.value, __memo_parameter_arg3.value, __memo_parameter_arg4.value); + console.log(__memo_parameter_arg2.value(__memo_context, ((__memo_id) + ()))); + { + __memo_scope.recache(); + return; + } +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform argument calls in functions', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/function-declarations/declare-and-call.test.ts b/ets1.2/tests_memo/function-declarations/declare-and-call.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..db15946ae06df9c3a9bf9d0d1037a027fae86831 --- /dev/null +++ b/ets1.2/tests_memo/function-declarations/declare-and-call.test.ts @@ -0,0 +1,90 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const FUNCTION_DIR_PATH: string = 'memo/functions'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'declare-and-call.ets'), +]; + +const pluginTester = new PluginTester('test memo function', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + funcA(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } +}); +@memo() function funcA(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void +function funcB(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + funcA(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } +} +class A { + public foo(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + funcA(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform declare functions and calls', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/function-declarations/inner-functions.test.ts b/ets1.2/tests_memo/function-declarations/inner-functions.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..8e549464318354654d0303cbc1adda98572cd928 --- /dev/null +++ b/ets1.2/tests_memo/function-declarations/inner-functions.test.ts @@ -0,0 +1,112 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const FUNCTION_DIR_PATH: string = 'memo/functions'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'inner-functions.ets'), +]; + +const pluginTester = new PluginTester('test memo function', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +function foo(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } +} +function bar(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + const qux = @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + foo(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } + }); + const other = (() => {}); + { + __memo_scope.recache(); + return; + } +} +class A { + public goo(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + let func = (() => {}); + let func2 = @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + foo(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } + }); + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform inner functions', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/function-declarations/non-void-return-type.test.ts b/ets1.2/tests_memo/function-declarations/non-void-return-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..19b061ad6bc38ec118d84e479fc4e5404308b882 --- /dev/null +++ b/ets1.2/tests_memo/function-declarations/non-void-return-type.test.ts @@ -0,0 +1,112 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const FUNCTION_DIR_PATH: string = 'memo/functions'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'non-void-return-type.ets'), +]; + +const pluginTester = new PluginTester('test memo function', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +function funcNum(__memo_context: __memo_context_type, __memo_id: __memo_id_type): number { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(1); +} +function funcStr(__memo_context: __memo_context_type, __memo_id: __memo_id_type): string { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(\"1\"); +} +function funcBool(__memo_context: __memo_context_type, __memo_id: __memo_id_type): boolean { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(false); +} +function funcA(__memo_context: __memo_context_type, __memo_id: __memo_id_type): A { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache({ + str: \"1\", + }); +} +function funcB(__memo_context: __memo_context_type, __memo_id: __memo_id_type): B { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(((str: string) => {})); +} +function funcC(__memo_context: __memo_context_type, __memo_id: __memo_id_type): C { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(new C(\"1\")); +} +function funcD(__memo_context: __memo_context_type, __memo_id: __memo_id_type): (()=> void) { + const __memo_scope = __memo_context.scope<(()=> void)>(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache((() => {})); +} +interface A { + set str(str: string) + get str(): string +} +type B = ((str: string)=> void); +class C { + public str: string; + public constructor(str: string) { + this.str = str; + } +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform functions with non-void return type', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/function-declarations/type-reference.test.ts b/ets1.2/tests_memo/function-declarations/type-reference.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..7db7cd676d57630897af74cb9328c96c2d64e75d --- /dev/null +++ b/ets1.2/tests_memo/function-declarations/type-reference.test.ts @@ -0,0 +1,92 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const FUNCTION_DIR_PATH: string = 'memo/functions'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'type-reference.ets'), +]; + +const pluginTester = new PluginTester('test memo function', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() function A(__memo_context: __memo_context_type, __memo_id: __memo_id_type): Attribute +function func(__memo_context: __memo_context_type, __memo_id: __memo_id_type): ItemBuilder { + const __memo_scope = __memo_context.scope>(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(((__memo_context: __memo_context_type, __memo_id: __memo_id_type, item: Item): void => {})); +} +@memo() type ItemBuilder = ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, item: Item)=> void); +interface Item { + set item(item: T) + get item(): T +} +interface Attribute { + @memo() each(__memo_context: __memo_context_type, __memo_id: __memo_id_type, @memo() itemGenerator: ItemBuilder): Attribute +} +class B { + public build(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + A(__memo_context, ((__memo_id) + ())).each(__memo_context, ((__memo_id) + ()), ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, ri: Item): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_ri = __memo_scope.param(0, ri); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform functions with type reference', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/function-declarations/void-return-type.test.ts b/ets1.2/tests_memo/function-declarations/void-return-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..08c0eb3bdde9bba0673ab6a0c22cf7af771eda8c --- /dev/null +++ b/ets1.2/tests_memo/function-declarations/void-return-type.test.ts @@ -0,0 +1,61 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const FUNCTION_DIR_PATH: string = 'memo/functions'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'void-return-type.ets'), +]; + +const pluginTester = new PluginTester('test memo function', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +function func(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform functions with void return type', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/lambda-literals/argument-call.test.ts b/ets1.2/tests_memo/lambda-literals/argument-call.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..f23a8d2529875eded121b1b681d55546030393d1 --- /dev/null +++ b/ets1.2/tests_memo/lambda-literals/argument-call.test.ts @@ -0,0 +1,173 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const LAMBDA_DIR_PATH: string = 'memo/lambdas'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, LAMBDA_DIR_PATH, 'argument-call.ets')]; + +const pluginTester = new PluginTester('test memo lambda', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +((arg: (()=> void)) => {})((() => {})); + +((arg: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)) => {})(@memo() (() => {})); + +((gensym%%_1?: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)) => { + let arg: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) = (((gensym%%_1) !== (undefined)) ? gensym%%_1 : (((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + (201676739)), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }) as @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void))); +})(@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + (209782503)), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } +})); + +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, gensym%%_?: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void => { + let arg: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) = (((gensym%%_) !== (undefined)) ? gensym%%_ : (((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }) as @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void))); + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })(__memo_context, ((__memo_id) + ()), @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + { + __memo_scope.recache(); + return; + } +}); + +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + let goo = @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, gensym%%_?: string): void => { + let name: string = (((gensym%%_) !== (undefined)) ? gensym%%_ : (\"old\" as string)); + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_name = __memo_scope.param(0, name); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }); + goo(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } +}); + +(() => { + let foo = ((gensym%%_?: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)) => { + let arg: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) = (((gensym%%_) !== (undefined)) ? gensym%%_ : (((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }) as @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void))); + }); + foo(@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); +}); +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform argument calls in lambdas', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/lambda-literals/function-with-receiver.test.ts b/ets1.2/tests_memo/lambda-literals/function-with-receiver.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..be488294a6ca913309fa32ba707384b588cf1857 --- /dev/null +++ b/ets1.2/tests_memo/lambda-literals/function-with-receiver.test.ts @@ -0,0 +1,97 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; +import { Plugins } from '../../../../common/plugin-context'; +import { uiTransform } from '../../../../ui-plugins'; + +const LAMBDA_DIR_PATH: string = 'memo/lambdas'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, LAMBDA_DIR_PATH, 'function-with-receiver.ets'), +]; + +const parsedTransform: Plugins = { + name: 'state-complex-type', + parsed: uiTransform().parsed +}; + +const pluginTester = new PluginTester('test memo lambda', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "@ohos.arkui.stateManagement"; + +function main() {} + +function foo1(this: B, __memo_context: __memo_context_type, __memo_id: __memo_id_type, str: string): void { + const __memo_scope = __memo_context.scope(((__memo_id) + (38567515)), 2); + const __memo_parameter_this = __memo_scope.param(0, this), __memo_parameter_str = __memo_scope.param(1, str); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + console.log("Good", __memo_parameter_str.value); + { + __memo_scope.recache(); + return; + } +} + +function foo2(this: B, __memo_context: __memo_context_type, __memo_id: __memo_id_type, str: string): B { + const __memo_scope = __memo_context.scope(((__memo_id) + (167482260)), 2); + const __memo_parameter_this = __memo_scope.param(0, this), __memo_parameter_str = __memo_scope.param(1, str); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + console.log("Good", __memo_parameter_str.value); + return __memo_scope.recache(this); +} + +class B { + public internal_call(__memo_context: __memo_context_type, __memo_id: __memo_id_type): B { + const __memo_scope = __memo_context.scope(((__memo_id) + (146437675)), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + foo1(this, __memo_context, ((__memo_id) + (119664703)), "morning"); + return __memo_scope.recache(foo2(this, __memo_context, ((__memo_id) + (181969214)), "afternoon")); + } + + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform lambdas about function with receiver feature', + [parsedTransform, memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/lambda-literals/trailing-lambdas.test.ts b/ets1.2/tests_memo/lambda-literals/trailing-lambdas.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..f023fef13b9f4a87a60269817fc05e53bd411580 --- /dev/null +++ b/ets1.2/tests_memo/lambda-literals/trailing-lambdas.test.ts @@ -0,0 +1,169 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const LAMBDA_DIR_PATH: string = 'memo/lambdas'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, LAMBDA_DIR_PATH, 'trailing-lambdas.ets'), +]; + +const pluginTester = new PluginTester('test memo lambda', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + let a = new A(); + a.foo(__memo_context, ((__memo_id) + ()), (() => { + console.log(); + })); + a.goo(((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + console.log(); + { + __memo_scope.recache(); + return; + } + })); + a.koo(__memo_context, ((__memo_id) + ()), ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + console.log(); + { + __memo_scope.recache(); + return; + } + })); + bar(__memo_context, ((__memo_id) + ()), (() => { + console.log(); + })); + par(((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + console.log(); + { + __memo_scope.recache(); + return; + } + })); + kar(__memo_context, ((__memo_id) + ()), ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + console.log(); + { + __memo_scope.recache(); + return; + } + })); + { + __memo_scope.recache(); + return; + } +}); +@functions.OptionalParametersAnnotation({minArgCount:0}) function bar(__memo_context: __memo_context_type, __memo_id: __memo_id_type, f?: (()=> void)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_f = __memo_scope.param(0, f); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } +} +@functions.OptionalParametersAnnotation({minArgCount:0}) function par(f?: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void {} +@functions.OptionalParametersAnnotation({minArgCount:0}) function kar(__memo_context: __memo_context_type, __memo_id: __memo_id_type, @memo() f?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_f = __memo_scope.param(0, f); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } +} +class A { + @functions.OptionalParametersAnnotation({minArgCount:0}) public foo(__memo_context: __memo_context_type, __memo_id: __memo_id_type, p?: (()=> void)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_p = __memo_scope.param(0, p); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + @functions.OptionalParametersAnnotation({minArgCount:0}) public goo(@memo() p?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void {} + @functions.OptionalParametersAnnotation({minArgCount:0}) public koo(__memo_context: __memo_context_type, __memo_id: __memo_id_type, @memo() p?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_p = __memo_scope.param(0, p); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform trailing lambdas', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/lambda-literals/void-lambda.test.ts b/ets1.2/tests_memo/lambda-literals/void-lambda.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..59b48a02458e04db484aca46c70396f2fca00a2d --- /dev/null +++ b/ets1.2/tests_memo/lambda-literals/void-lambda.test.ts @@ -0,0 +1,73 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const LAMBDA_DIR_PATH: string = 'memo/lambdas'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, LAMBDA_DIR_PATH, 'void-lambda.ets'), +]; + +const pluginTester = new PluginTester('test memo lambda', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } +}); +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg?: (()=> string)): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } +}); +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform lambdas with void return type', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/lambda-literals/with-receiver.test.ts b/ets1.2/tests_memo/lambda-literals/with-receiver.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..4f6e3fa92a6c7d7c4056ab836055e662fa0aa522 --- /dev/null +++ b/ets1.2/tests_memo/lambda-literals/with-receiver.test.ts @@ -0,0 +1,125 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const LAMBDA_DIR_PATH: string = 'memo/lambdas'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, LAMBDA_DIR_PATH, 'with-receiver.ets'), +]; + +const pluginTester = new PluginTester('test memo lambda', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + let x = new Person(); + fullName(x, ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + let f1: F1 = foo; + f1 = goo; + let f2: F2 = goo; + f2 = foo; + f1 = f2; + let a = new A(); + f1(a, ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + f1(a, ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + f2(a, ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + { + __memo_scope.recache(); + return; + } +}); +@functions.OptionalParametersAnnotation({minArgCount:1}) function fullName(this: Person, @memo() arg?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void { + return; +} +@functions.OptionalParametersAnnotation({minArgCount:1}) function foo(this: A, @memo() arg?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void {} +@functions.OptionalParametersAnnotation({minArgCount:1}) function goo(a: A, @memo() arg?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void {} +class Person { + public constructor() {} +} +class A { + public constructor() {} +} +type F1 = ((this: A, @memo() arg?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void))=> void); +type F2 = ((a: A, @memo() arg?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void))=> void); +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform lambdas with receiver', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/method-declarations/argument-call.test.ts b/ets1.2/tests_memo/method-declarations/argument-call.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..de72519e74bbc1669122263ac6f136e10b4ce9fa --- /dev/null +++ b/ets1.2/tests_memo/method-declarations/argument-call.test.ts @@ -0,0 +1,145 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const METHOD_DIR_PATH: string = 'memo/methods'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, METHOD_DIR_PATH, 'argument-call.ets')]; + +const pluginTester = new PluginTester('test memo method', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +class Test { + public lambda_arg(__memo_context: __memo_context_type, __memo_id: __memo_id_type, @memo() arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public lambda_arg_with_arg(__memo_context: __memo_context_type, __memo_id: __memo_id_type, @memo() arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, value: string)=> string)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public memo_content(__memo_context: __memo_context_type, __memo_id: __memo_id_type, @memo() content: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_content = __memo_scope.param(0, content); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + __memo_parameter_content.value(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } + } + public compute_test(__memo_context: __memo_context_type, __memo_id: __memo_id_type, @memo() arg1: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined, arg2: (()=> void) | undefined, content: (()=> void) | undefined): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 3); + const __memo_parameter_arg1 = __memo_scope.param(0, arg1), __memo_parameter_arg2 = __memo_scope.param(1, arg2), __memo_parameter_content = __memo_scope.param(2, content); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +class Use { + public test(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + const test = new Test(); + test.lambda_arg(__memo_context, ((__memo_id) + ()), ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + test.lambda_arg_with_arg(__memo_context, ((__memo_id) + ()), ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, value: string): string => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_value = __memo_scope.param(0, value); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(__memo_parameter_value.value); + })); + test.compute_test(__memo_context, ((__memo_id) + ()), ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }), (() => {}), (() => {})); + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform argument calls in methods', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/method-declarations/callable.test.ts b/ets1.2/tests_memo/method-declarations/callable.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..7657e1dd0ce878e17e8df46d82fec626e2754e57 --- /dev/null +++ b/ets1.2/tests_memo/method-declarations/callable.test.ts @@ -0,0 +1,112 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const METHOD_DIR_PATH: string = 'memo/methods'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, METHOD_DIR_PATH, 'callable.ets')]; + +const pluginTester = new PluginTester('test memo method', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + A.$_invoke(__memo_context, ((__memo_id) + ())); + B.$_invoke(((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + let x: C | D = C.$_instantiate(__memo_context, ((__memo_id) + ()), (() => { + return new C(); + })); + x = D.$_instantiate((() => { + return new D(); + })); + { + __memo_scope.recache(); + return; + } +}); +class A { + public static $_invoke(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +class B { + @functions.OptionalParametersAnnotation({minArgCount:0}) public static $_invoke(@memo() p?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void {} + public constructor() {} +} +class C { + public static $_instantiate(__memo_context: __memo_context_type, __memo_id: __memo_id_type, factory: (()=> C)): C { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_factory = __memo_scope.param(0, factory); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(__memo_parameter_factory.value()); + } + public constructor() {} +} +class D { + @functions.OptionalParametersAnnotation({minArgCount:1}) public static $_instantiate(factory: (()=> D), @memo() content?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): D { + return factory(); + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform callable class', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/method-declarations/declare-and-call.test.ts b/ets1.2/tests_memo/method-declarations/declare-and-call.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..0a669b4c085c2bf7abfc2c0cbd8e52c6bbaaf7b1 --- /dev/null +++ b/ets1.2/tests_memo/method-declarations/declare-and-call.test.ts @@ -0,0 +1,83 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const METHOD_DIR_PATH: string = 'memo/methods'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, METHOD_DIR_PATH, 'declare-and-call.ets'), +]; + +const pluginTester = new PluginTester('test memo method', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + new AA().x(__memo_context, ((__memo_id) + ())); + const a: A = new AA(); + a.x(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } +}); +declare abstract class A { + @memo() public x(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void + public test_signature(@memo() arg1: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void), @memo() arg2: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined, @memo() arg3: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined | ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> int) | undefined, @memo() x: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, y: ((z: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void))=> void))=> void)): @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) + public constructor() {} +} +class AA extends A { + public x(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform declare methods and calls', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/method-declarations/internal-calls.test.ts b/ets1.2/tests_memo/method-declarations/internal-calls.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..11dae0f7ed8a30c405812e53110d00d47ec5dd09 --- /dev/null +++ b/ets1.2/tests_memo/method-declarations/internal-calls.test.ts @@ -0,0 +1,186 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const METHOD_DIR_PATH: string = 'memo/methods'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, METHOD_DIR_PATH, 'internal-calls.ets')]; + +const pluginTester = new PluginTester('test memo method', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +function __context(): __memo_context_type +function __id(): __memo_id_type +type MemoType = @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void); +class Test { + public void_method(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public internal_call(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + this.void_method(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } + } + public method_with_internals(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + __context(); + __id(); + { + __memo_scope.recache(); + return; + } + } + public memo_lambda() { + @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }); + } + public memo_variables(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + @memo() const f = ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): number => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(123); + }), g = ((__memo_context: __memo_context_type, __memo_id: __memo_id_type, x: number): number => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_x = __memo_scope.param(0, x); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(((123) + (__memo_parameter_x.value))); + }); + const h = @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): number => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(1); + }); + f(__memo_context, ((__memo_id) + ())); + g(__memo_context, ((__memo_id) + ()), 1); + h(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } + } + @functions.OptionalParametersAnnotation({minArgCount:0}) public args_with_default_values(__memo_context: __memo_context_type, __memo_id: __memo_id_type, gensym%%_1?: int, gensym%%_2?: (()=> int), gensym%%_3?: int, arg4?: int): void { + let arg1: int = (((gensym%%_1) !== (undefined)) ? gensym%%_1 : (10 as int)); + let arg2: (()=> int) = (((gensym%%_2) !== (undefined)) ? gensym%%_2 : ((() => { + return 20; + }) as (()=> int))); + let arg3: int = (((gensym%%_3) !== (undefined)) ? gensym%%_3 : (arg1 as int)); + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 4); + const __memo_parameter_arg1 = __memo_scope.param(0, arg1), __memo_parameter_arg2 = __memo_scope.param(1, arg2), __memo_parameter_arg3 = __memo_scope.param(2, arg3), __memo_parameter_arg4 = __memo_scope.param(3, arg4); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + console.log(__memo_parameter_arg1.value, __memo_parameter_arg2.value, __memo_parameter_arg3.value, __memo_parameter_arg4.value); + console.log(__memo_parameter_arg2.value()); + { + __memo_scope.recache(); + return; + } + } + @functions.OptionalParametersAnnotation({minArgCount:0}) public optional_args(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg1?: int, arg2?: (()=> int)): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 2); + const __memo_parameter_arg1 = __memo_scope.param(0, arg1), __memo_parameter_arg2 = __memo_scope.param(1, arg2); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + console.log(__memo_parameter_arg1.value); + console.log(__memo_parameter_arg2.value); + console.log(({let gensym%%_166 = __memo_parameter_arg2.value; + (((gensym%%_166) == (null)) ? undefined : gensym%%_166())})); + { + __memo_scope.recache(); + return; + } + } + public type_alias(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg: MemoType): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + __memo_parameter_arg.value(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform inner calls in methods', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/method-declarations/non-void-method.test.ts b/ets1.2/tests_memo/method-declarations/non-void-method.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..a8ddef791a1367d4cb3575135fcfa52205e29514 --- /dev/null +++ b/ets1.2/tests_memo/method-declarations/non-void-method.test.ts @@ -0,0 +1,119 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const METHOD_DIR_PATH: string = 'memo/methods'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, METHOD_DIR_PATH, 'non-void-method.ets')]; + +const pluginTester = new PluginTester('test memo method', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +function __context(): __memo_context_type +function __id(): __memo_id_type +@Retention({policy:"SOURCE"}) @interface memo_intrinsic {} +@Retention({policy:"SOURCE"}) @interface memo_entry {} +class Test { + public void_method(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public string_method_with_return(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg: string): string { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(__memo_parameter_arg.value); + } + public method_with_type_parameter(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg: T): T { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + return __memo_scope.cached; + } + return __memo_scope.recache(__memo_parameter_arg.value); + } + public intrinsic_method(): int { + return 0; + } + public intrinsic_method_with_this(): int { + this.void_method(__memo_context, ((__memo_id) + ())); + return 0; + } + public memoEntry(__memo_context: __memo_context_type, __memo_id: __memo_id_type, @memo() entry: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> R)): R { + const getContext = (() => { + return __context(); + }); + const getId = (() => { + return __id(); + }); + { + const __memo_context = getContext(); + const __memo_id = getId(); + return entry(__memo_context, ((__memo_id) + ())); + } + } + public constructor() {} +} +class Use { + public test(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + const test = new Test(); + test.string_method_with_return(__memo_context, ((__memo_id) + ()), "a string"); + test.method_with_type_parameter(__memo_context, ((__memo_id) + ()), "I'm string"); + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform methods with non-void return type', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/method-declarations/void-method.test.ts b/ets1.2/tests_memo/method-declarations/void-method.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..953742b8a28ebc4248b410680ccd4f4971dd75cb --- /dev/null +++ b/ets1.2/tests_memo/method-declarations/void-method.test.ts @@ -0,0 +1,151 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const METHOD_DIR_PATH: string = 'memo/methods'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, METHOD_DIR_PATH, 'void-method.ets'), +]; + +const pluginTester = new PluginTester('test memo method', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +class A { + public x: int; + public y: int; + public constructor() {} +} +class Test { + public void_method(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public a_method_with_implicit_return_type(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public void_method_with_arg(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg: string): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public void_method_with_return(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg: string): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public static static_method_with_type_parameter(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg: T): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public obj_arg(__memo_context: __memo_context_type, __memo_id: __memo_id_type, arg: A): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 1); + const __memo_parameter_arg = __memo_scope.param(0, arg); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +class Use { + public test(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + const test = new Test(); + test.void_method(__memo_context, ((__memo_id) + ())); + test.void_method_with_arg(__memo_context, ((__memo_id) + ()), "an arg"); + test.void_method_with_return(__memo_context, ((__memo_id) + ()), "a value"); + Test.static_method_with_type_parameter(__memo_context, ((__memo_id) + ()), "I'm static"); + test.obj_arg(__memo_context, ((__memo_id) + ()), { + x: 1, + y: 2, + }); + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform methods with void return type', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/property-declarations/class-constructor.test.ts b/ets1.2/tests_memo/property-declarations/class-constructor.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..28671e70099f78415a094cd6548f1f8b48adfdb6 --- /dev/null +++ b/ets1.2/tests_memo/property-declarations/class-constructor.test.ts @@ -0,0 +1,101 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const PROPERTY_DIR_PATH: string = 'memo/properties'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, PROPERTY_DIR_PATH, 'class-constructor.ets'), +]; + +const pluginTester = new PluginTester('test memo property', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + let a = new AA({ + a: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }), + }); + { + __memo_scope.recache(); + return; + } +}); +interface A { + @memo() set a(a: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void + @memo() get a(): ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) +} +class AA { + @memo() public a: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined; + constructor() { + this(undefined); + } + public constructor(arg: A | undefined) { + this.a = ({let gensym%%_ = arg; + (((gensym%%_) == (null)) ? undefined : gensym%%_.a)}); + } + public build(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + ({let gensym%%_ = this.a; + (((gensym%%_) == (null)) ? undefined : gensym%%_(__memo_context, ((__memo_id) + ())))}); + { + __memo_scope.recache(); + return; + } + } +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform properties in class constructor', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/property-declarations/class-properties.test.ts b/ets1.2/tests_memo/property-declarations/class-properties.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..c987200392947b7ce38ffd1d31dd1d034326a613 --- /dev/null +++ b/ets1.2/tests_memo/property-declarations/class-properties.test.ts @@ -0,0 +1,106 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const PROPERTY_DIR_PATH: string = 'memo/properties'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, PROPERTY_DIR_PATH, 'class-properties.ets'), +]; + +const pluginTester = new PluginTester('test memo property', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from "@ohos.arkui.stateManagement"; +function main() {} +class A { + public arg: (()=> void); + @memo() public memo_arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void); + @memo() public memo_optional_arg?: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined; + @memo() public memo_union_arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined = ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }); + public arg_memo_type: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void); + public constructor() { + this.arg = (() => {}); + this.memo_arg = ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }); + this.arg_memo_type = ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }); + } + public build(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + this.arg(); + this.memo_arg(__memo_context, ((__memo_id) + ())); + this.arg_memo_type(__memo_context, ((__memo_id) + ())); + { + __memo_scope.recache(); + return; + } + } +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform properties in class', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_memo/property-declarations/interfaces.test.ts b/ets1.2/tests_memo/property-declarations/interfaces.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..99053d0efc1ff8c0704aae5ef3e8a5bb7f94ba85 --- /dev/null +++ b/ets1.2/tests_memo/property-declarations/interfaces.test.ts @@ -0,0 +1,107 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { memoNoRecheck } from '../../../utils/plugins'; + +const PROPERTY_DIR_PATH: string = 'memo/properties'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, PROPERTY_DIR_PATH, 'interfaces.ets')]; + +const pluginTester = new PluginTester('test memo property', buildConfig); + +const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +function main() {} +@memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + let a: A = { + arg: (() => {}), + memo_arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }), + memo_union_arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }), + arg_memo_type: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + ()), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + }), + }; + { + __memo_scope.recache(); + return; + } +}); +interface A { + set arg(arg: (()=> void)) + get arg(): (()=> void) + @memo() set memo_arg(memo_arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)): void + @memo() get memo_arg(): ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) + @memo() set memo_optional_arg(memo_optional_arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined): void + @memo() get memo_optional_arg(): ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined + @memo() set memo_union_arg(memo_union_arg: ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined): void + @memo() get memo_union_arg(): ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) | undefined + set arg_memo_type(arg_memo_type: @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void)) + get arg_memo_type(): @memo() ((__memo_context: __memo_context_type, __memo_id: __memo_id_type)=> void) +} +`; + +function testMemoTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform interface properties', + [memoNoRecheck], + { + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/animation/animation-basic.test.ts b/ets1.2/tests_ui/animation/animation-basic.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..dd4678db61622b3ddf437dbce6fec4d19a40b103 --- /dev/null +++ b/ets1.2/tests_ui/animation/animation-basic.test.ts @@ -0,0 +1,121 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { uiNoRecheck } from '../../../utils/plugins'; +import { uiTransform } from '../../../../ui-plugins'; +import { Plugins } from '../../../../common/plugin-context'; + +const ANIMATION_DIR_PATH: string = 'animation'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, ANIMATION_DIR_PATH, 'animation-basic.ets'), +]; + +const animationTransform: Plugins = { + name: 'animation', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test basic animation transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; + +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Text as Text, Column as Column, Component as Component, Color as Color, Curve as Curve } from "@ohos.arkui.component"; + +import { Entry as Entry } from "@ohos.arkui.component"; + +function main() {} + + + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class AnimatablePropertyExample extends CustomComponent { + public __initializeStruct(initializers: __Options_AnimatablePropertyExample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_AnimatablePropertyExample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: AnimatablePropertyExample)=> AnimatablePropertyExample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_AnimatablePropertyExample | undefined): void { + Column(undefined, undefined, (() => { + Text(@memo() ((instance: UITextAttribute): void => { + instance.animationStart({ + duration: 2000, + curve: Curve.Ease, + }).backgroundColor(Color.Red).animationStop({ + duration: 2000, + curve: Curve.Ease, + }).animationStart({ + duration: 2000, + curve: Curve.Ease, + }).fontSize(20).animationStop({ + duration: 2000, + curve: Curve.Ease, + }).width("100%"); + return; + }), "AnimatableProperty", undefined, undefined); + })); + } + + public constructor() {} + +} + +interface __Options_AnimatablePropertyExample { + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + AnimatablePropertyExample._instantiateImpl(undefined, (() => { + return new AnimatablePropertyExample(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} +`; + +function testAnimationTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test basic animation transform', + [animationTransform, uiNoRecheck], + { + checked: [testAnimationTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/builder-lambda/custom-component/custom-component-call.test.ts b/ets1.2/tests_ui/builder-lambda/custom-component/custom-component-call.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..b9a0d5943b3976263962533eb7f9fc86253eb8a2 --- /dev/null +++ b/ets1.2/tests_ui/builder-lambda/custom-component/custom-component-call.test.ts @@ -0,0 +1,166 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { recheck, uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'builder-lambda'; +const CUSTOM_COMPONENT_DIR_PATH: string = 'custom-component'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, CUSTOM_COMPONENT_DIR_PATH, 'custom-component-call.ets'), +]; + +const pluginTester = new PluginTester('test custom component call transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'custom-component-call', + parsed: uiTransform().parsed +}; + +const expectedParsedScript: string = ` +import { __memo_id_type as __memo_id_type } from "@ohos.arkui.stateManagement"; +import { __memo_context_type as __memo_context_type } from "@ohos.arkui.stateManagement"; +import { memo as memo } from "@ohos.arkui.stateManagement"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "@ohos.arkui.component"; +import { Text as Text, Column as Column, Component as Component, Builder as Builder, BuilderParam as BuilderParam } from "@ohos.arkui.component"; + +@Component() final class CustomContainer extends CustomComponent { + @Builder() public closerBuilder() {} + @BuilderParam() public closer: (()=> void) = (this).closerBuilder; + public build() {} + public constructor() {} +} + +@Component() final class CustomContainerUser extends CustomComponent { + public build() { + Column(undefined){ + CustomContainer(undefined){ + Column(undefined){ + Text("hello", undefined); + }; + }; + CustomContainer(({} as __Options_CustomContainer)){ + Column(undefined){}; + }; + CustomContainer(undefined){}; + CustomContainer(); + }; + } + public constructor() {} +} + +interface __Options_CustomContainer { + closer?: @memo() (()=> void); +} + +interface __Options_CustomContainerUser { +} +`; + +function testParedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedParsedScript)); +} + +const expectedBuilderLambdaScript: string = ` +import { __memo_id_type as __memo_id_type } from "@ohos.arkui.stateManagement"; +import { __memo_context_type as __memo_context_type } from "@ohos.arkui.stateManagement"; +import { memo as memo } from "@ohos.arkui.stateManagement"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "@ohos.arkui.component"; +import { Text as Text, Column as Column, Component as Component, Builder as Builder, BuilderParam as BuilderParam } from "@ohos.arkui.component"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class CustomContainer extends CustomComponent { + public __initializeStruct(initializers: __Options_CustomContainer | undefined, @memo() content: (()=> void) | undefined): void { + (this).__backing_closer = ((((({let gensym___38813563 = initializers; + (((gensym___38813563) == (null)) ? undefined : gensym___38813563.closer)})) ?? (content))) ?? ((this).closerBuilder)) + } + public __updateStruct(initializers: __Options_CustomContainer | undefined): void {} + private __backing_closer?: @memo() (()=> void); + public get closer(): @memo() (()=> void) { + return (this).__backing_closer!; + } + public set closer(@memo() value: (()=> void)) { + (this).__backing_closer = value; + } + @memo() public closerBuilder() {} + @memo() public _build(@memo() style: ((instance: CustomContainer)=> CustomContainer) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_CustomContainer | undefined): void {} + public constructor() {} +} + +@Component({freezeWhenInactive:false}) final class CustomContainerUser extends CustomComponent { + public __initializeStruct(initializers: __Options_CustomContainerUser | undefined, @memo() content: (()=> void) | undefined): void {} + public __updateStruct(initializers: __Options_CustomContainerUser | undefined): void {} + @memo() public _build(@memo() style: ((instance: CustomContainerUser)=> CustomContainerUser) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_CustomContainerUser | undefined): void { + Column(undefined, undefined, (() => { + CustomContainer._instantiateImpl(undefined, (() => { + return new CustomContainer(); + }), undefined, (() => { + Column(undefined, undefined, (() => { + Text(undefined, "hello", undefined, undefined); + })); + }), undefined); + CustomContainer._instantiateImpl(undefined, (() => { + return new CustomContainer(); + }), ({} as __Options_CustomContainer), (() => { + Column(undefined, undefined, (() => {})); + }), undefined); + CustomContainer._instantiateImpl(undefined, (() => { + return new CustomContainer(); + }), undefined, (() => {}), undefined); + CustomContainer._instantiateImpl(undefined, (() => { + return new CustomContainer(); + }), undefined, undefined, undefined); + })); + } + public constructor() {} +} + +interface __Options_CustomContainer { + set closer(closer: @memo() (()=> void) | undefined) + get closer(): @memo() (()=> void) | undefined +} + +interface __Options_CustomContainerUser { +} +`; + +function testCustomComponentTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedBuilderLambdaScript)); +} + +pluginTester.run( + 'test custom component call transformation', + [parsedTransform, recheck, uiNoRecheck], + { + parsed: [testParedTransformer], + 'checked:builder-lambda-no-recheck': [testCustomComponentTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/builder-lambda/simple-component.test.ts b/ets1.2/tests_ui/builder-lambda/simple-component.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..37b4605ad3ed31255840b0017cae248b3f3258fb --- /dev/null +++ b/ets1.2/tests_ui/builder-lambda/simple-component.test.ts @@ -0,0 +1,91 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { builderLambdaNoRecheck, memoNoRecheck, recheck } from '../../../utils/plugins'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'builder-lambda'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'simple-component.ets'), +]; + +const pluginTester = new PluginTester('test builder-lambda simple component', buildConfig); + +function testBuilderLambdaTransformer(this: PluginTestContext): void { + const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +import { Column as Column, UIColumnAttribute as UIColumnAttribute } from \"arkui.component.column\"; +function main() {} +class MyStateSample { + @memo() public build() { + Column(undefined, undefined, (() => {})); + } + public constructor() {} +} +`; + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +function testMemoTransformer(this: PluginTestContext): void { + const expectedScript: string = ` +import { memo as memo, __memo_context_type as __memo_context_type, __memo_id_type as __memo_id_type } from \"@ohos.arkui.stateManagement\"; +import { Column as Column, UIColumnAttribute as UIColumnAttribute } from \"arkui.component.column\"; +function main() {} +class MyStateSample { + public build(__memo_context: __memo_context_type, __memo_id: __memo_id_type): void { + const __memo_scope = __memo_context.scope(((__memo_id) + (263357132)), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + Column(__memo_context, ((__memo_id) + (65509320)), undefined, undefined, ((__memo_context: __memo_context_type, __memo_id: __memo_id_type): void => { + const __memo_scope = __memo_context.scope(((__memo_id) + (147296800)), 0); + if (__memo_scope.unchanged) { + __memo_scope.cached; + return; + } + { + __memo_scope.recache(); + return; + } + })); + { + __memo_scope.recache(); + return; + } + } + public constructor() {} +} +`; + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'transform simple component', + [builderLambdaNoRecheck, recheck, memoNoRecheck], + { + 'checked:builder-lambda-no-recheck': [testBuilderLambdaTransformer], + 'checked:memo-no-recheck': [testMemoTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/builder-lambda/style-with-receiver.test.ts b/ets1.2/tests_ui/builder-lambda/style-with-receiver.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..1c64f1cdb615ab39691453a1af0eea3b08742de5 --- /dev/null +++ b/ets1.2/tests_ui/builder-lambda/style-with-receiver.test.ts @@ -0,0 +1,102 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { builderLambdaNoRecheck, structNoRecheck, uiNoRecheck } from '../../../utils/plugins'; +import { uiTransform } from '../../../../ui-plugins'; +import { Plugins } from '../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'builder-lambda'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'style-with-receiver.ets'), +]; + +const pluginTester = new PluginTester('test function with receiver style transformstion', buildConfig); + +const parsedTransform: Plugins = { + name: 'style-with-receiver', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { memo as memo } from "@ohos.arkui.stateManagement"; +import { Text as Text, UITextAttribute as UITextAttribute, Column as Column, Component as Component } from "@ohos.arkui.component"; +import hilog from "@ohos.hilog"; + +function main() {} + +@memo() function cardStyle(this: UITextAttribute, num: number, str: string): UITextAttribute { + this.fontSize(num); + this.backgroundColor(num); + return this; +} + +@memo() function style22(this: UITextAttribute): UITextAttribute { + this.fontWeight(700); + return this; +} + +@Component({freezeWhenInactive:false}) final class MM extends CustomComponent { + public __initializeStruct(initializers: __Options_MM | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MM | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MM)=> MM) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MM | undefined): void { + Column(undefined, undefined, (() => { + Text(@memo() ((instance: UITextAttribute): void => { + style22(cardStyle(instance.height(200).fontColor("#000000"), 600, "#eeeeee").fontSize(60).fontWeight(400)).width(900); + return; + }), "hello world", undefined, undefined); + Text(@memo() ((instance: UITextAttribute): void => { + cardStyle(instance, 600, "#eeeeee"); + return; + }), "hello world", undefined, undefined); + })); + } + + public constructor() {} + +} + +interface __Options_MM { + +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test function with receiver style transformstion', + [parsedTransform, uiNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/builder-param/builder-param-passing.test.ts b/ets1.2/tests_ui/decorators/builder-param/builder-param-passing.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..ba63b9e2d3f79a811fb07922b3c14d811a15a9d8 --- /dev/null +++ b/ets1.2/tests_ui/decorators/builder-param/builder-param-passing.test.ts @@ -0,0 +1,133 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const FUNCTION_DIR_PATH: string = 'decorators/builder-param'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'builder-param-passing.ets'), +]; + +const pluginTester = new PluginTester('test builder param variable passing', buildConfig); + +const parsedTransform: Plugins = { + name: 'builder-param-passing', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "@ohos.arkui.stateManagement"; +import { __memo_context_type as __memo_context_type } from "@ohos.arkui.stateManagement"; +import { memo as memo } from "@ohos.arkui.stateManagement"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "@ohos.arkui.component"; +import { Component as Component, Entry as Entry, Builder as Builder, BuilderParam as BuilderParam, Column as Column, Text as Text } from "@ohos.arkui.component"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class Child extends CustomComponent { + public __initializeStruct(initializers: __Options_Child | undefined, @memo() content: (()=> void) | undefined): void { + (this).__backing_customBuilderParam = ((((({let gensym___169376706 = initializers; + (((gensym___169376706) == (null)) ? undefined : gensym___169376706.customBuilderParam)})) ?? (content))) ?? ((this).customBuilder)) + } + + public __updateStruct(initializers: __Options_Child | undefined): void {} + + private __backing_customBuilderParam?: @memo() (()=> void); + + public get customBuilderParam(): @memo() (()=> void) { + return (this).__backing_customBuilderParam!; + } + + public set customBuilderParam(@memo() value: (()=> void)) { + (this).__backing_customBuilderParam = value; + } + + @memo() public customBuilder() {} + + @memo() public _build(@memo() style: ((instance: Child)=> Child) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Child | undefined): void { + (this).customBuilderParam(); + } + + public constructor() {} + +} + +@Component({freezeWhenInactive:false}) final class Parent extends CustomComponent { + public __initializeStruct(initializers: __Options_Parent | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_Parent | undefined): void {} + + @memo() public componentBuilder() { + Text(undefined, "Parent builder", undefined, undefined); + } + + @memo() public _build(@memo() style: ((instance: Parent)=> Parent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Parent | undefined): void { + Column(undefined, undefined, (() => { + Child._instantiateImpl(undefined, (() => { + return new Child(); + }), ({ + customBuilderParam: (this).componentBuilder, + } as __Options_Child), undefined, undefined); + Child._instantiateImpl(undefined, (() => { + return new Child(); + }), ({ + customBuilderParam: @memo() (() => { + (this).componentBuilder(); + }), + } as __Options_Child), undefined, undefined); + Child._instantiateImpl(undefined, (() => { + return new Child(); + }), undefined, (() => { + Text(undefined, "Parent builder", undefined, undefined); + }), undefined); + })); + } + public constructor() {} +} + +interface __Options_Child { + set customBuilderParam(customBuilderParam: @memo() (()=> void) | undefined) + get customBuilderParam(): @memo() (()=> void) | undefined +} + +interface __Options_Parent { +} +`; + +function testCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test builder param variable passing', + [parsedTransform, uiNoRecheck], + { + 'checked:ui-no-recheck': [testCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/builder-param/init-with-local-builder.test.ts b/ets1.2/tests_ui/decorators/builder-param/init-with-local-builder.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..21e7f2bb4fa8bba3df65ba934b73b5ace27df3c1 --- /dev/null +++ b/ets1.2/tests_ui/decorators/builder-param/init-with-local-builder.test.ts @@ -0,0 +1,100 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const FUNCTION_DIR_PATH: string = 'decorators/builder-param'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'init-with-local-builder.ets'), +]; + +const pluginTester = new PluginTester('test builder param init with local builder', buildConfig); + +const parsedTransform: Plugins = { + name: 'init-with-local-builder', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, Builder as Builder, BuilderParam as BuilderParam } from "@ohos.arkui.component"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class Child extends CustomComponent { + public __initializeStruct(initializers: __Options_Child | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_customBuilderParam = ((((({let gensym___169376706 = initializers; + (((gensym___169376706) == (null)) ? undefined : gensym___169376706.customBuilderParam)})) ?? (content))) ?? (this.doNothingBuilder)) + this.__backing_customBuilderParam2 = ((((({let gensym___14041256 = initializers; + (((gensym___14041256) == (null)) ? undefined : gensym___14041256.customBuilderParam2)})) ?? (content))) ?? (this.doNothingBuilder2)) + } + public __updateStruct(initializers: __Options_Child | undefined): void {} + private __backing_customBuilderParam?: @memo() (()=> void); + public get customBuilderParam(): @memo() (()=> void) { + return this.__backing_customBuilderParam!; + } + public set customBuilderParam(@memo() value: (()=> void)) { + this.__backing_customBuilderParam = value; + } + private __backing_customBuilderParam2?: @memo() ((str: string)=> void); + public get customBuilderParam2(): @memo() ((str: string)=> void) { + return this.__backing_customBuilderParam2!; + } + public set customBuilderParam2(@memo() value: ((str: string)=> void)) { + this.__backing_customBuilderParam2 = value; + } + @memo() public doNothingBuilder() {} + @memo() public doNothingBuilder2(str: string) {} + @memo() public _build(@memo() style: ((instance: Child)=> Child) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Child | undefined): void { + this.customBuilderParam(); + this.customBuilderParam2("hello"); + } + public constructor() {} +} + +interface __Options_Child { + set customBuilderParam(customBuilderParam: @memo() (()=> void) | undefined) + get customBuilderParam(): @memo() (()=> void) | undefined + set customBuilderParam2(customBuilderParam2: @memo() ((str: string)=> void) | undefined) + get customBuilderParam2(): @memo() ((str: string)=> void) | undefined +} +`; + +function testCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test builder param init with local builder', + [parsedTransform, uiNoRecheck], + { + 'checked:ui-no-recheck': [testCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/builder/global-builder.test.ts b/ets1.2/tests_ui/decorators/builder/global-builder.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..95740a1d5123337008002dcf8760639e48454ce0 --- /dev/null +++ b/ets1.2/tests_ui/decorators/builder/global-builder.test.ts @@ -0,0 +1,97 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const FUNCTION_DIR_PATH: string = 'decorators/builder'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'global-builder.ets'), +]; + +const pluginTester = new PluginTester('test global builder', buildConfig); + +const parsedTransform: Plugins = { + name: 'global-builder', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { UIRowAttribute as UIRowAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, Row as Row, Builder as Builder, Text as Text } from "@ohos.arkui.component"; + +function main() {} + +@memo() function showTextBuilder() { + Text(undefined, "Hello World", undefined, undefined); +} + +@memo() function overBuilder(params: Tmp) { + Row(undefined, undefined, (() => { + Text(undefined, (("UseStateVarByReference: ") + (params.paramA1)), undefined, undefined); + })); +} + +class Tmp { + public paramA1: string = ""; + public constructor() {} +} + +@Component({freezeWhenInactive:false}) final class BuilderDemo extends CustomComponent { + public __initializeStruct(initializers: __Options_BuilderDemo | undefined, @memo() content: (()=> void) | undefined): void {} + public __updateStruct(initializers: __Options_BuilderDemo | undefined): void {} + @memo() public _build(@memo() style: ((instance: BuilderDemo)=> BuilderDemo) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_BuilderDemo | undefined): void { + Row(undefined, undefined, @memo() (() => { + showTextBuilder(); + overBuilder({ + paramA1: "Hello", + }); + })); + } + public constructor() {} +} + +interface __Options_BuilderDemo { + +} +`; + +function testCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'global builder', + [parsedTransform, uiNoRecheck], + { + 'checked:ui-no-recheck': [testCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/builder/local-builder.test.ts b/ets1.2/tests_ui/decorators/builder/local-builder.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..9769285c5dff301ccb5500da9ed6655cd95f1c4d --- /dev/null +++ b/ets1.2/tests_ui/decorators/builder/local-builder.test.ts @@ -0,0 +1,92 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const FUNCTION_DIR_PATH: string = 'decorators/builder'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, FUNCTION_DIR_PATH, 'local-builder.ets'), +]; + +const pluginTester = new PluginTester('test local builder', buildConfig); + +const parsedTransform: Plugins = { + name: 'local-builder', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, Column as Column, Builder as Builder, Text as Text } from "@ohos.arkui.component"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class BuilderDemo extends CustomComponent { + public __initializeStruct(initializers: __Options_BuilderDemo | undefined, @memo() content: (()=> void) | undefined): void {} + public __updateStruct(initializers: __Options_BuilderDemo | undefined): void {} + @memo() public showTextBuilder() { + Text(@memo() ((instance: UITextAttribute): void => { + instance.fontSize(30); + return; + }), "Hello World", undefined, undefined); + } + @memo() public showTextValueBuilder(param: string) { + Text(@memo() ((instance: UITextAttribute): void => { + instance.fontSize(30); + return; + }), param, undefined, undefined); + } + @memo() public _build(@memo() style: ((instance: BuilderDemo)=> BuilderDemo) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_BuilderDemo | undefined): void { + Column(undefined, undefined, @memo() (() => { + this.showTextBuilder(); + this.showTextValueBuilder("Hello @Builder"); + })); + } + public constructor() {} +} + +interface __Options_BuilderDemo { + +} +`; + +function testCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'local builder', + [parsedTransform, uiNoRecheck], + { + 'checked:ui-no-recheck': [testCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/link/link-basic-type.test.ts b/ets1.2/tests_ui/decorators/link/link-basic-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..340db6a9eacac05ec71919e9af39810b6c26c7fc --- /dev/null +++ b/ets1.2/tests_ui/decorators/link/link-basic-type.test.ts @@ -0,0 +1,151 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/link'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'link-basic-type.ets'), +]; + +const pluginTester = new PluginTester('test basic type @Link decorated variables transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'link-basic-type', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { DecoratedV1VariableBase as DecoratedV1VariableBase } from "@ohos.arkui.stateManagement"; +import { LinkDecoratedVariable as LinkDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { Link as Link } from "@ohos.arkui.stateManagement"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class LinkParent extends CustomComponent { + public __initializeStruct(initializers: __Options_LinkParent | undefined, @memo() content: (()=> void) | undefined): void { + if (({let gensym___11910109 = initializers; + (((gensym___11910109) == (null)) ? undefined : gensym___11910109.__backing_linkVar1)})) { + this.__backing_linkVar1 = new LinkDecoratedVariable("linkVar1", initializers!.__backing_linkVar1!); + }; + if (({let gensym___181684045 = initializers; + (((gensym___181684045) == (null)) ? undefined : gensym___181684045.__backing_linkVar2)})) { + this.__backing_linkVar2 = new LinkDecoratedVariable("linkVar2", initializers!.__backing_linkVar2!); + }; + if (({let gensym___24446313 = initializers; + (((gensym___24446313) == (null)) ? undefined : gensym___24446313.__backing_linkVar3)})) { + this.__backing_linkVar3 = new LinkDecoratedVariable("linkVar3", initializers!.__backing_linkVar3!); + }; + if (({let gensym___167989826 = initializers; + (((gensym___167989826) == (null)) ? undefined : gensym___167989826.__backing_linkVar4)})) { + this.__backing_linkVar4 = new LinkDecoratedVariable("linkVar4", initializers!.__backing_linkVar4!); + }; + if (({let gensym___157566097 = initializers; + (((gensym___157566097) == (null)) ? undefined : gensym___157566097.__backing_linkVar5)})) { + this.__backing_linkVar5 = new LinkDecoratedVariable("linkVar5", initializers!.__backing_linkVar5!); + }; + } + public __updateStruct(initializers: __Options_LinkParent | undefined): void {} + private __backing_linkVar1?: LinkDecoratedVariable; + public get linkVar1(): string { + return this.__backing_linkVar1!.get(); + } + public set linkVar1(value: string) { + this.__backing_linkVar1!.set(value); + } + private __backing_linkVar2?: LinkDecoratedVariable; + public get linkVar2(): number { + return this.__backing_linkVar2!.get(); + } + public set linkVar2(value: number) { + this.__backing_linkVar2!.set(value); + } + private __backing_linkVar3?: LinkDecoratedVariable; + public get linkVar3(): boolean { + return this.__backing_linkVar3!.get(); + } + public set linkVar3(value: boolean) { + this.__backing_linkVar3!.set(value); + } + private __backing_linkVar4?: LinkDecoratedVariable; + public get linkVar4(): undefined { + return this.__backing_linkVar4!.get(); + } + public set linkVar4(value: undefined) { + this.__backing_linkVar4!.set(value); + } + private __backing_linkVar5?: LinkDecoratedVariable; + public get linkVar5(): null { + return this.__backing_linkVar5!.get(); + } + public set linkVar5(value: null) { + this.__backing_linkVar5!.set(value); + } + @memo() public _build(@memo() style: ((instance: LinkParent)=> LinkParent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_LinkParent | undefined): void {} + public constructor() {} +} + +interface __Options_LinkParent { + set linkVar1(linkVar1: string | undefined) + get linkVar1(): string | undefined + set __backing_linkVar1(__backing_linkVar1: DecoratedV1VariableBase | undefined) + get __backing_linkVar1(): DecoratedV1VariableBase | undefined + set linkVar2(linkVar2: number | undefined) + get linkVar2(): number | undefined + set __backing_linkVar2(__backing_linkVar2: DecoratedV1VariableBase | undefined) + get __backing_linkVar2(): DecoratedV1VariableBase | undefined + set linkVar3(linkVar3: boolean | undefined) + get linkVar3(): boolean | undefined + set __backing_linkVar3(__backing_linkVar3: DecoratedV1VariableBase | undefined) + get __backing_linkVar3(): DecoratedV1VariableBase | undefined + set linkVar4(linkVar4: undefined | undefined) + get linkVar4(): undefined | undefined + set __backing_linkVar4(__backing_linkVar4: DecoratedV1VariableBase | undefined) + get __backing_linkVar4(): DecoratedV1VariableBase | undefined + set linkVar5(linkVar5: null | undefined) + get linkVar5(): null | undefined + set __backing_linkVar5(__backing_linkVar5: DecoratedV1VariableBase | undefined) + get __backing_linkVar5(): DecoratedV1VariableBase | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test basic type @Link decorated variables transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/link/link-complex-type.test.ts b/ets1.2/tests_ui/decorators/link/link-complex-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..486097a84761d4f03315d22735a709bfe1b4e7be --- /dev/null +++ b/ets1.2/tests_ui/decorators/link/link-complex-type.test.ts @@ -0,0 +1,314 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/link'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'link-complex-type.ets'), +]; + +const pluginTester = new PluginTester('test complex type @Link decorated variables transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'link-complex-type', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { DecoratedV1VariableBase as DecoratedV1VariableBase } from "@ohos.arkui.stateManagement"; +import { LinkDecoratedVariable as LinkDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { Link as Link } from "@ohos.arkui.stateManagement"; + +function main() {} + +class Per { + public num: number; + public constructor(num: number) { + this.num = num; + } +} + +final class LinkType extends BaseEnum { + private readonly #ordinal: int; + private static () {} + public constructor(ordinal: int, value: int) { + super(value); + this.#ordinal = ordinal; + } + public static readonly TYPE1: LinkType = new LinkType(0, 0); + public static readonly TYPE2: LinkType = new LinkType(1, 1); + public static readonly TYPE3: LinkType = new LinkType(2, 3); + private static readonly #NamesArray: String[] = ["TYPE1", "TYPE2", "TYPE3"]; + private static readonly #ValuesArray: int[] = [0, 1, 3]; + private static readonly #StringValuesArray: String[] = ["0", "1", "3"]; + private static readonly #ItemsArray: LinkType[] = [LinkType.TYPE1, LinkType.TYPE2, LinkType.TYPE3]; + public getName(): String { + return LinkType.#NamesArray[this.#ordinal]; + } + public static getValueOf(name: String): LinkType { + for (let i = 0;((i) < (LinkType.#NamesArray.length));(++i)) { + if (((name) == (LinkType.#NamesArray[i]))) { + return LinkType.#ItemsArray[i]; + } + } + throw new Error((("No enum constant LinkType.") + (name))); + } + + public static fromValue(value: int): LinkType { + for (let i = 0;((i) < (LinkType.#ValuesArray.length));(++i)) { + if (((value) == (LinkType.#ValuesArray[i]))) { + return LinkType.#ItemsArray[i]; + } + } + throw new Error((("No enum LinkType with value ") + (value))); + } + public valueOf(): int { + return LinkType.#ValuesArray[this.#ordinal]; + } + public toString(): String { + return LinkType.#StringValuesArray[this.#ordinal]; + } + public static values(): LinkType[] { + return LinkType.#ItemsArray; + } + public getOrdinal(): int { + return this.#ordinal; + } + public static $_get(e: LinkType): String { + return e.getName(); + } +} + +@Component({freezeWhenInactive:false}) final class Parent extends CustomComponent { + public __initializeStruct(initializers: __Options_Parent | undefined, @memo() content: (()=> void) | undefined): void { + if (({let gensym___11910109 = initializers; + (((gensym___11910109) == (null)) ? undefined : gensym___11910109.__backing_linkVar1)})) { + this.__backing_linkVar1 = new LinkDecoratedVariable("linkVar1", initializers!.__backing_linkVar1!); + }; + if (({let gensym___181684045 = initializers; + (((gensym___181684045) == (null)) ? undefined : gensym___181684045.__backing_linkVar2)})) { + this.__backing_linkVar2 = new LinkDecoratedVariable>("linkVar2", initializers!.__backing_linkVar2!); + }; + if (({let gensym___24446313 = initializers; + (((gensym___24446313) == (null)) ? undefined : gensym___24446313.__backing_linkVar3)})) { + this.__backing_linkVar3 = new LinkDecoratedVariable("linkVar3", initializers!.__backing_linkVar3!); + }; + if (({let gensym___167989826 = initializers; + (((gensym___167989826) == (null)) ? undefined : gensym___167989826.__backing_linkVar4)})) { + this.__backing_linkVar4 = new LinkDecoratedVariable>("linkVar4", initializers!.__backing_linkVar4!); + }; + if (({let gensym___157566097 = initializers; + (((gensym___157566097) == (null)) ? undefined : gensym___157566097.__backing_linkVar5)})) { + this.__backing_linkVar5 = new LinkDecoratedVariable>("linkVar5", initializers!.__backing_linkVar5!); + }; + if (({let gensym___60105491 = initializers; + (((gensym___60105491) == (null)) ? undefined : gensym___60105491.__backing_linkVar6)})) { + this.__backing_linkVar6 = new LinkDecoratedVariable>("linkVar6", initializers!.__backing_linkVar6!); + }; + if (({let gensym___3429048 = initializers; + (((gensym___3429048) == (null)) ? undefined : gensym___3429048.__backing_linkVar7)})) { + this.__backing_linkVar7 = new LinkDecoratedVariable>("linkVar7", initializers!.__backing_linkVar7!); + }; + if (({let gensym___139916435 = initializers; + (((gensym___139916435) == (null)) ? undefined : gensym___139916435.__backing_linkVar8)})) { + this.__backing_linkVar8 = new LinkDecoratedVariable<((sr: string)=> void)>("linkVar8", initializers!.__backing_linkVar8!); + }; + if (({let gensym___145003260 = initializers; + (((gensym___145003260) == (null)) ? undefined : gensym___145003260.__backing_linkVar9)})) { + this.__backing_linkVar9 = new LinkDecoratedVariable("linkVar9", initializers!.__backing_linkVar9!); + }; + if (({let gensym___122643185 = initializers; + (((gensym___122643185) == (null)) ? undefined : gensym___122643185.__backing_linkVar10)})) { + this.__backing_linkVar10 = new LinkDecoratedVariable>("linkVar10", initializers!.__backing_linkVar10!); + }; + if (({let gensym___222468503 = initializers; + (((gensym___222468503) == (null)) ? undefined : gensym___222468503.__backing_linkVar11)})) { + this.__backing_linkVar11 = new LinkDecoratedVariable("linkVar11", initializers!.__backing_linkVar11!); + }; + if (({let gensym___243301539 = initializers; + (((gensym___243301539) == (null)) ? undefined : gensym___243301539.__backing_linkVar12)})) { + this.__backing_linkVar12 = new LinkDecoratedVariable | Per>("linkVar12", initializers!.__backing_linkVar12!); + }; + } + public __updateStruct(initializers: __Options_Parent | undefined): void {} + private __backing_linkVar1?: LinkDecoratedVariable; + public get linkVar1(): Per { + return this.__backing_linkVar1!.get(); + } + public set linkVar1(value: Per) { + this.__backing_linkVar1!.set(value); + } + private __backing_linkVar2?: LinkDecoratedVariable>; + public get linkVar2(): Array { + return this.__backing_linkVar2!.get(); + } + public set linkVar2(value: Array) { + this.__backing_linkVar2!.set(value); + } + private __backing_linkVar3?: LinkDecoratedVariable; + public get linkVar3(): LinkType { + return this.__backing_linkVar3!.get(); + } + public set linkVar3(value: LinkType) { + this.__backing_linkVar3!.set(value); + } + private __backing_linkVar4?: LinkDecoratedVariable>; + public get linkVar4(): Set { + return this.__backing_linkVar4!.get(); + } + public set linkVar4(value: Set) { + this.__backing_linkVar4!.set(value); + } + private __backing_linkVar5?: LinkDecoratedVariable>; + public get linkVar5(): Array { + return this.__backing_linkVar5!.get(); + } + public set linkVar5(value: Array) { + this.__backing_linkVar5!.set(value); + } + private __backing_linkVar6?: LinkDecoratedVariable>; + public get linkVar6(): Array { + return this.__backing_linkVar6!.get(); + } + public set linkVar6(value: Array) { + this.__backing_linkVar6!.set(value); + } + private __backing_linkVar7?: LinkDecoratedVariable>; + public get linkVar7(): Array { + return this.__backing_linkVar7!.get(); + } + public set linkVar7(value: Array) { + this.__backing_linkVar7!.set(value); + } + private __backing_linkVar8?: LinkDecoratedVariable<((sr: string)=> void)>; + public get linkVar8(): ((sr: string)=> void) { + return this.__backing_linkVar8!.get(); + } + public set linkVar8(value: ((sr: string)=> void)) { + this.__backing_linkVar8!.set(value); + } + private __backing_linkVar9?: LinkDecoratedVariable; + public get linkVar9(): Date { + return this.__backing_linkVar9!.get(); + } + public set linkVar9(value: Date) { + this.__backing_linkVar9!.set(value); + } + private __backing_linkVar10?: LinkDecoratedVariable>; + public get linkVar10(): Map { + return this.__backing_linkVar10!.get(); + } + public set linkVar10(value: Map) { + this.__backing_linkVar10!.set(value); + } + private __backing_linkVar11?: LinkDecoratedVariable; + public get linkVar11(): string | number { + return this.__backing_linkVar11!.get(); + } + public set linkVar11(value: string | number) { + this.__backing_linkVar11!.set(value); + } + private __backing_linkVar12?: LinkDecoratedVariable | Per>; + public get linkVar12(): Set | Per { + return this.__backing_linkVar12!.get(); + } + public set linkVar12(value: Set | Per) { + this.__backing_linkVar12!.set(value); + } + @memo() public _build(@memo() style: ((instance: Parent)=> Parent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Parent | undefined): void {} + public constructor() {} +} + +interface __Options_Parent { + set linkVar1(linkVar1: Per | undefined) + get linkVar1(): Per | undefined + set __backing_linkVar1(__backing_linkVar1: DecoratedV1VariableBase | undefined) + get __backing_linkVar1(): DecoratedV1VariableBase | undefined + set linkVar2(linkVar2: Array | undefined) + get linkVar2(): Array | undefined + set __backing_linkVar2(__backing_linkVar2: DecoratedV1VariableBase> | undefined) + get __backing_linkVar2(): DecoratedV1VariableBase> | undefined + set linkVar3(linkVar3: LinkType | undefined) + get linkVar3(): LinkType | undefined + set __backing_linkVar3(__backing_linkVar3: DecoratedV1VariableBase | undefined) + get __backing_linkVar3(): DecoratedV1VariableBase | undefined + set linkVar4(linkVar4: Set | undefined) + get linkVar4(): Set | undefined + set __backing_linkVar4(__backing_linkVar4: DecoratedV1VariableBase> | undefined) + get __backing_linkVar4(): DecoratedV1VariableBase> | undefined + set linkVar5(linkVar5: Array | undefined) + get linkVar5(): Array | undefined + set __backing_linkVar5(__backing_linkVar5: DecoratedV1VariableBase> | undefined) + get __backing_linkVar5(): DecoratedV1VariableBase> | undefined + set linkVar6(linkVar6: Array | undefined) + get linkVar6(): Array | undefined + set __backing_linkVar6(__backing_linkVar6: DecoratedV1VariableBase> | undefined) + get __backing_linkVar6(): DecoratedV1VariableBase> | undefined + set linkVar7(linkVar7: Array | undefined) + get linkVar7(): Array | undefined + set __backing_linkVar7(__backing_linkVar7: DecoratedV1VariableBase> | undefined) + get __backing_linkVar7(): DecoratedV1VariableBase> | undefined + set linkVar8(linkVar8: ((sr: string)=> void) | undefined) + get linkVar8(): ((sr: string)=> void) | undefined + set __backing_linkVar8(__backing_linkVar8: DecoratedV1VariableBase<((sr: string)=> void)> | undefined) + get __backing_linkVar8(): DecoratedV1VariableBase<((sr: string)=> void)> | undefined + set linkVar9(linkVar9: Date | undefined) + get linkVar9(): Date | undefined + set __backing_linkVar9(__backing_linkVar9: DecoratedV1VariableBase | undefined) + get __backing_linkVar9(): DecoratedV1VariableBase | undefined + set linkVar10(linkVar10: Map | undefined) + get linkVar10(): Map | undefined + set __backing_linkVar10(__backing_linkVar10: DecoratedV1VariableBase> | undefined) + get __backing_linkVar10(): DecoratedV1VariableBase> | undefined + set linkVar11(linkVar11: string | number | undefined) + get linkVar11(): string | number | undefined + set __backing_linkVar11(__backing_linkVar11: DecoratedV1VariableBase | undefined) + get __backing_linkVar11(): DecoratedV1VariableBase | undefined + set linkVar12(linkVar12: Set | Per | undefined) + get linkVar12(): Set | Per | undefined + set __backing_linkVar12(__backing_linkVar12: DecoratedV1VariableBase | Per> | undefined) + get __backing_linkVar12(): DecoratedV1VariableBase | Per> | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test complex type @Link decorated variables transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/link/link-to-link-prop-state.test.ts b/ets1.2/tests_ui/decorators/link/link-to-link-prop-state.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..01a8275f91b30ba6ba4f45a333f48b0424eae2d6 --- /dev/null +++ b/ets1.2/tests_ui/decorators/link/link-to-link-prop-state.test.ts @@ -0,0 +1,186 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/link'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'link-to-link-prop-state.ets'), +]; + +const pluginTester = new PluginTester('test @Link decorated variables passing to other variables', buildConfig); + +const parsedTransform: Plugins = { + name: 'link-to-link-prop-state', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { PropDecoratedVariable as PropDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { DecoratedV1VariableBase as DecoratedV1VariableBase } from "@ohos.arkui.stateManagement"; +import { LinkDecoratedVariable as LinkDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { UITextInputAttribute as UITextInputAttribute } from "@ohos.arkui.component"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, Column as Column, TextInput as TextInput } from "@ohos.arkui.component"; +import { Link as Link, State as State, Prop as Prop } from "@ohos.arkui.stateManagement"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class Parant extends CustomComponent { + public __initializeStruct(initializers: __Options_Parant | undefined, @memo() content: (()=> void) | undefined): void { + if (({let gensym___10127521 = initializers; + (((gensym___10127521) == (null)) ? undefined : gensym___10127521.__backing_text1)})) { + this.__backing_text1 = new LinkDecoratedVariable("text1", initializers!.__backing_text1!); + }; + } + public __updateStruct(initializers: __Options_Parant | undefined): void {} + private __backing_text1?: LinkDecoratedVariable; + public get text1(): string { + return this.__backing_text1!.get(); + } + public set text1(value: string) { + this.__backing_text1!.set(value); + } + @memo() public _build(@memo() style: ((instance: Parant)=> Parant) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Parant | undefined): void { + Column(undefined, undefined, (() => { + TextInput(undefined, { + text: this.text1, + }, undefined); + Child._instantiateImpl(undefined, (() => { + return new Child(); + }), ({ + __backing_childText: this.__backing_text1, + childText2: this.text1, + childText3: this.text1, + childText4: this.text1, + } as __Options_Child), undefined, undefined); + })); + } + public constructor() {} +} + +@Component({freezeWhenInactive:false}) final class Child extends CustomComponent { + public __initializeStruct(initializers: __Options_Child | undefined, @memo() content: (()=> void) | undefined): void { + if (({let gensym___161337494 = initializers; + (((gensym___161337494) == (null)) ? undefined : gensym___161337494.__backing_childText)})) { + this.__backing_childText = new LinkDecoratedVariable("childText", initializers!.__backing_childText!); + }; + this.__backing_childText2 = new StateDecoratedVariable("childText2", ((({let gensym___95513066 = initializers; + (((gensym___95513066) == (null)) ? undefined : gensym___95513066.childText2)})) ?? ("sss"))); + this.__backing_childText3 = new PropDecoratedVariable("childText3", (initializers!.childText3 as string)); + this.__backing_childText4 = new PropDecoratedVariable("childText4", ((({let gensym___162028107 = initializers; + (((gensym___162028107) == (null)) ? undefined : gensym___162028107.childText4)})) ?? ("cc"))); + } + public __updateStruct(initializers: __Options_Child | undefined): void { + if (((({let gensym___77632518 = initializers; + (((gensym___77632518) == (null)) ? undefined : gensym___77632518.childText3)})) !== (undefined))) { + this.__backing_childText3!.update((initializers!.childText3 as string)); + } + if (((({let gensym___250510741 = initializers; + (((gensym___250510741) == (null)) ? undefined : gensym___250510741.childText4)})) !== (undefined))) { + this.__backing_childText4!.update((initializers!.childText4 as string)); + } + } + private __backing_childText?: LinkDecoratedVariable; + public get childText(): string { + return this.__backing_childText!.get(); + } + public set childText(value: string) { + this.__backing_childText!.set(value); + } + private __backing_childText2?: StateDecoratedVariable; + public get childText2(): string { + return this.__backing_childText2!.get(); + } + public set childText2(value: string) { + this.__backing_childText2!.set(value); + } + private __backing_childText3?: PropDecoratedVariable; + public get childText3(): string { + return this.__backing_childText3!.get(); + } + public set childText3(value: string) { + this.__backing_childText3!.set(value); + } + private __backing_childText4?: PropDecoratedVariable; + public get childText4(): string { + return this.__backing_childText4!.get(); + } + public set childText4(value: string) { + this.__backing_childText4!.set(value); + } + @memo() public _build(@memo() style: ((instance: Child)=> Child) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Child | undefined): void { + TextInput(undefined, { + text: this.childText, + }, undefined); + } + public constructor() {} +} + +interface __Options_Parant { + set text1(text1: string | undefined) + get text1(): string | undefined + set __backing_text1(__backing_text1: DecoratedV1VariableBase | undefined) + get __backing_text1(): DecoratedV1VariableBase | undefined +} + +interface __Options_Child { + set childText(childText: string | undefined) + get childText(): string | undefined + set __backing_childText(__backing_childText: DecoratedV1VariableBase | undefined) + get __backing_childText(): DecoratedV1VariableBase | undefined + set childText2(childText2: string | undefined) + get childText2(): string | undefined + set __backing_childText2(__backing_childText2: StateDecoratedVariable | undefined) + get __backing_childText2(): StateDecoratedVariable | undefined + set childText3(childText3: string | undefined) + get childText3(): string | undefined + set __backing_childText3(__backing_childText3: PropDecoratedVariable | undefined) + get __backing_childText3(): PropDecoratedVariable | undefined + set childText4(childText4: string | undefined) + get childText4(): string | undefined + set __backing_childText4(__backing_childText4: PropDecoratedVariable | undefined) + get __backing_childText4(): PropDecoratedVariable | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test @Link decorated variables passing to other variables', + [parsedTransform, uiNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/link/state-to-link.test.ts b/ets1.2/tests_ui/decorators/link/state-to-link.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..cd9424e90a9b9d10cfb84261831bc31b0f48db4b --- /dev/null +++ b/ets1.2/tests_ui/decorators/link/state-to-link.test.ts @@ -0,0 +1,175 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/link'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'state-to-link.ets'), +]; + +const pluginTester = new PluginTester('test @Link decorated variables passing', buildConfig); + +const parsedTransform: Plugins = { + name: 'state-to-link', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { DecoratedV1VariableBase as DecoratedV1VariableBase } from "@ohos.arkui.stateManagement"; +import { LinkDecoratedVariable as LinkDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { UIDatePickerAttribute as UIDatePickerAttribute } from "@ohos.arkui.component"; +import { UIButtonAttribute as UIButtonAttribute } from "@ohos.arkui.component"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { EntryPoint as EntryPoint } from "arkui.UserView"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, Entry as Entry, Column as Column, Button as Button, DatePicker as DatePicker, ClickEvent as ClickEvent } from "@ohos.arkui.component"; +import { Link as Link, State as State } from "@ohos.arkui.stateManagement"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class DateComponent extends CustomComponent { + public __initializeStruct(initializers: __Options_DateComponent | undefined, @memo() content: (()=> void) | undefined): void { + if (({let gensym___164314175 = initializers; + (((gensym___164314175) == (null)) ? undefined : gensym___164314175.__backing_selectedDate)})) { + this.__backing_selectedDate = new LinkDecoratedVariable("selectedDate", initializers!.__backing_selectedDate!); + }; + } + public __updateStruct(initializers: __Options_DateComponent | undefined): void {} + private __backing_selectedDate?: LinkDecoratedVariable; + public get selectedDate(): Date { + return this.__backing_selectedDate!.get(); + } + public set selectedDate(value: Date) { + this.__backing_selectedDate!.set(value); + } + @memo() public _build(@memo() style: ((instance: DateComponent)=> DateComponent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_DateComponent | undefined): void { + Column(undefined, undefined, (() => { + Button(@memo() ((instance: UIButtonAttribute): void => { + instance.onClick(((e: ClickEvent) => { + this.selectedDate.setFullYear(((this.selectedDate.getFullYear()) + (1))); + })); + return; + }), "child increase the year by 1", undefined, undefined); + Button(@memo() ((instance: UIButtonAttribute): void => { + instance.margin(10).onClick(((e: ClickEvent) => { + this.selectedDate = new Date("2023-09-09"); + })); + return; + }), "child update the new date", undefined, undefined); + DatePicker(undefined, { + start: new Date("1970-1-1"), + end: new Date("2100-1-1"), + selected: this.selectedDate, + }, undefined); + })); + } + public constructor() {} + +} + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class ParentComponent extends CustomComponent { + public __initializeStruct(initializers: __Options_ParentComponent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_parentSelectedDate = new StateDecoratedVariable("parentSelectedDate", ((({let gensym___80922148 = initializers; + (((gensym___80922148) == (null)) ? undefined : gensym___80922148.parentSelectedDate)})) ?? (new Date("2021-08-08")))); + } + public __updateStruct(initializers: __Options_ParentComponent | undefined): void {} + private __backing_parentSelectedDate?: StateDecoratedVariable; + public get parentSelectedDate(): Date { + return this.__backing_parentSelectedDate!.get(); + } + public set parentSelectedDate(value: Date) { + this.__backing_parentSelectedDate!.set(value); + } + @memo() public _build(@memo() style: ((instance: ParentComponent)=> ParentComponent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_ParentComponent | undefined): void { + Column(undefined, undefined, (() => { + Button(@memo() ((instance: UIButtonAttribute): void => { + instance.margin(10).onClick(((e: ClickEvent) => { + this.parentSelectedDate.setMonth(((this.parentSelectedDate.getMonth()) + (1))); + })); + return; + }), "parent increase the month by 1", undefined, undefined); + Button(@memo() ((instance: UIButtonAttribute): void => { + instance.margin(10).onClick(((e: ClickEvent) => { + this.parentSelectedDate = new Date("2023-07-07"); + })); + return; + }), "parent update the new date", undefined, undefined); + DatePicker(undefined, { + start: new Date("1970-1-1"), + end: new Date("2100-1-1"), + selected: this.parentSelectedDate, + }, undefined); + DateComponent._instantiateImpl(undefined, (() => { + return new DateComponent(); + }), ({ + __backing_selectedDate: this.__backing_parentSelectedDate, + } as __Options_DateComponent), undefined, undefined); + })); + } + public constructor() {} +} + +interface __Options_DateComponent { + set selectedDate(selectedDate: Date | undefined) + get selectedDate(): Date | undefined + set __backing_selectedDate(__backing_selectedDate: DecoratedV1VariableBase | undefined) + get __backing_selectedDate(): DecoratedV1VariableBase | undefined +} + +interface __Options_ParentComponent { + set parentSelectedDate(parentSelectedDate: Date | undefined) + get parentSelectedDate(): Date | undefined + set __backing_parentSelectedDate(__backing_parentSelectedDate: StateDecoratedVariable | undefined) + get __backing_parentSelectedDate(): StateDecoratedVariable | undefined +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + ParentComponent._instantiateImpl(undefined, (() => { + return new ParentComponent(); + }), undefined, undefined, undefined); + } + public constructor() {} +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test @Link decorated variables passing', + [parsedTransform, uiNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/observed-track/observed-only.test.ts b/ets1.2/tests_ui/decorators/observed-track/observed-only.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..08e0ec65b6f512f4a15e88aadad83489868eacf0 --- /dev/null +++ b/ets1.2/tests_ui/decorators/observed-track/observed-only.test.ts @@ -0,0 +1,157 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const OBSERVED_DIR_PATH: string = 'decorators/observed-track'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, OBSERVED_DIR_PATH, 'observed-only.ets'), +]; + +const observedTrackTransform: Plugins = { + name: 'observedTrack', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test observed only transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { SubscribedWatches as SubscribedWatches } from "@ohos.arkui.stateManagement"; + +import { WatchIdType as WatchIdType } from "@ohos.arkui.stateManagement"; + +import { int32 as int32 } from "@ohos.arkui.stateManagement"; + +import { IObservedObject as IObservedObject } from "@ohos.arkui.stateManagement"; + +import { setObservationDepth as setObservationDepth } from "@ohos.arkui.stateManagement"; + +import { BackingValue as BackingValue } from "@ohos.arkui.stateManagement"; + +import { MutableStateMeta as MutableStateMeta } from "@ohos.arkui.stateManagement"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component } from "@ohos.arkui.component"; + +import { Observed as Observed } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +@Observed() class A implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + private __meta: MutableStateMeta = new MutableStateMeta("@Observe properties (no @Track)"); + + private __backing_propA: number = 1; + + private __backing_trackA: number = 2; + + public constructor() {} + + public get propA(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_propA; + } + + public set propA(newValue: number) { + if (((this.__backing_propA) !== (newValue))) { + this.__backing_propA = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("propA"); + } + } + + public get trackA(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_trackA; + } + + public set trackA(newValue: number) { + if (((this.__backing_trackA) !== (newValue))) { + this.__backing_trackA = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("trackA"); + } + } + +} + +@Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + +`; + +function testObservedOnlyTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test observed only transform', + [observedTrackTransform, uiNoRecheck], + { + checked: [testObservedOnlyTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/observed-track/observed-track-class-property.test.ts b/ets1.2/tests_ui/decorators/observed-track/observed-track-class-property.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..5bd7f75517d71041264a000359ffd6c6319532c8 --- /dev/null +++ b/ets1.2/tests_ui/decorators/observed-track/observed-track-class-property.test.ts @@ -0,0 +1,206 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const OBSERVED_DIR_PATH: string = 'decorators/observed-track'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, OBSERVED_DIR_PATH, 'observed-track-class-property.ets'), +]; + +const observedTrackTransform: Plugins = { + name: 'observedTrack', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test observed track transform with class property', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { SubscribedWatches as SubscribedWatches } from "@ohos.arkui.stateManagement"; + +import { WatchIdType as WatchIdType } from "@ohos.arkui.stateManagement"; + +import { int32 as int32 } from "@ohos.arkui.stateManagement"; + +import { IObservedObject as IObservedObject } from "@ohos.arkui.stateManagement"; + +import { setObservationDepth as setObservationDepth } from "@ohos.arkui.stateManagement"; + +import { BackingValue as BackingValue } from "@ohos.arkui.stateManagement"; + +import { MutableStateMeta as MutableStateMeta } from "@ohos.arkui.stateManagement"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component } from "@ohos.arkui.component"; + +import { Observed as Observed, Track as Track } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +class Info { + public constructor() {} + +} + +class E implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + public propE: Info = new Info(); + + private __backing_trackE: BackingValue = new BackingValue(new Info()); + + private __meta_trackE: MutableStateMeta = new MutableStateMeta("@Track"); + + public constructor() {} + + public get trackE(): Info { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_trackE.addRef(); + } + setObservationDepth(this.__backing_trackE.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_trackE.value; + } + + public set trackE(newValue: Info) { + if (((this.__backing_trackE.value) !== (newValue))) { + this.__backing_trackE.value = newValue; + this.__meta_trackE.fireChange(); + this.executeOnSubscribingWatches("trackE"); + } + } + +} + +@Observed() class E1 implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + private __meta: MutableStateMeta = new MutableStateMeta("@Observe properties (no @Track)"); + + private __backing_propE1: BackingValue = new BackingValue(new Info()); + + private __backing_trackE1: BackingValue = new BackingValue(new Info()); + + public constructor() {} + + public get propE1(): Info { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_propE1.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_propE1.value; + } + + public set propE1(newValue: Info) { + if (((this.__backing_propE1.value) !== (newValue))) { + this.__backing_propE1.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("propE1"); + } + } + + public get trackE1(): Info { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_trackE1.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_trackE1.value; + } + + public set trackE1(newValue: Info) { + if (((this.__backing_trackE1.value) !== (newValue))) { + this.__backing_trackE1.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("trackE1"); + } + } + +} + +@Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} +`; + +function testObservedOnlyTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test observed track transform with class property', + [observedTrackTransform, uiNoRecheck], + { + checked: [testObservedOnlyTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/observed-track/observed-track-complex-type.test.ts b/ets1.2/tests_ui/decorators/observed-track/observed-track-complex-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..371c48a6cdcc181bc867a0a93f514b67615c6bc7 --- /dev/null +++ b/ets1.2/tests_ui/decorators/observed-track/observed-track-complex-type.test.ts @@ -0,0 +1,898 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const OBSERVED_DIR_PATH: string = 'decorators/observed-track'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, OBSERVED_DIR_PATH, 'observed-track-complex-type.ets'), +]; + +const observedTrackTransform: Plugins = { + name: 'observedTrack', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test observed track transform with complex type', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { SubscribedWatches as SubscribedWatches } from "@ohos.arkui.stateManagement"; + +import { WatchIdType as WatchIdType } from "@ohos.arkui.stateManagement"; + +import { int32 as int32 } from "@ohos.arkui.stateManagement"; + +import { IObservedObject as IObservedObject } from "@ohos.arkui.stateManagement"; + +import { setObservationDepth as setObservationDepth } from "@ohos.arkui.stateManagement"; + +import { BackingValue as BackingValue } from "@ohos.arkui.stateManagement"; + +import { MutableStateMeta as MutableStateMeta } from "@ohos.arkui.stateManagement"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry } from "@ohos.arkui.component"; + +import { Observed as Observed, Track as Track } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +class Person { + public constructor() {} + +} + +final class Status extends BaseEnum { + private readonly #ordinal: int; + + private static () {} + + public constructor(ordinal: int, value: int) { + super(value); + this.#ordinal = ordinal; + } + + public static readonly Success: Status = new Status(0, 200); + + public static readonly NotFound: Status = new Status(1, 404); + + public static readonly ServerError: Status = new Status(2, 500); + + private static readonly #NamesArray: String[] = ["Success", "NotFound", "ServerError"]; + + private static readonly #ValuesArray: int[] = [200, 404, 500]; + + private static readonly #StringValuesArray: String[] = ["200", "404", "500"]; + + private static readonly #ItemsArray: Status[] = [Status.Success, Status.NotFound, Status.ServerError]; + + public getName(): String { + return Status.#NamesArray[this.#ordinal]; + } + + public static getValueOf(name: String): Status { + for (let i = 0;((i) < (Status.#NamesArray.length));(++i)) { + if (((name) == (Status.#NamesArray[i]))) { + return Status.#ItemsArray[i]; + } + } + throw new Error((("No enum constant Status.") + (name))); + } + + public static fromValue(value: int): Status { + for (let i = 0;((i) < (Status.#ValuesArray.length));(++i)) { + if (((value) == (Status.#ValuesArray[i]))) { + return Status.#ItemsArray[i]; + } + } + throw new Error((("No enum Status with value ") + (value))); + } + + public valueOf(): int { + return Status.#ValuesArray[this.#ordinal]; + } + + public toString(): String { + return Status.#StringValuesArray[this.#ordinal]; + } + + public static values(): Status[] { + return Status.#ItemsArray; + } + + public getOrdinal(): int { + return this.#ordinal; + } + + public static $_get(e: Status): String { + return e.getName(); + } + +} + +@Observed() class mixed1 implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + private __backing_numA: number = 33; + + private __meta_numA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_stringA: string = "AA"; + + private __meta_stringA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_booleanA: boolean = true; + + private __meta_booleanA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_arrayA: BackingValue> = new BackingValue>([1, 2, 3]); + + private __meta_arrayA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_objectA: BackingValue = new BackingValue({}); + + private __meta_objectA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_dateA: BackingValue = new BackingValue(new Date("2021-08-08")); + + private __meta_dateA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_setA: BackingValue> = new BackingValue>(new Set()); + + private __meta_setA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_mapA: BackingValue> = new BackingValue>(new Map()); + + private __meta_mapA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_unionA: string | undefined = ""; + + private __meta_unionA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_classA: BackingValue = new BackingValue(new Person()); + + private __meta_classA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_enumA: BackingValue = new BackingValue(Status.NotFound); + + private __meta_enumA: MutableStateMeta = new MutableStateMeta("@Track"); + + public numB: number = 33; + + public stringB: string = "AA"; + + public booleanB: boolean = true; + + public arrayB: Array = [1, 2, 3]; + + public objectB: Object = {}; + + public dateB: Date = new Date("2021-08-08"); + + public setB: Set = new Set(); + + public mapB: Map = new Map(); + + public unionB: string | undefined = ""; + + public classB: Person = new Person(); + + public enumB: Status = Status.NotFound; + + public constructor() {} + + public get numA(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_numA.addRef(); + } + return this.__backing_numA; + } + + public set numA(newValue: number) { + if (((this.__backing_numA) !== (newValue))) { + this.__backing_numA = newValue; + this.__meta_numA.fireChange(); + this.executeOnSubscribingWatches("numA"); + } + } + + public get stringA(): string { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_stringA.addRef(); + } + return this.__backing_stringA; + } + + public set stringA(newValue: string) { + if (((this.__backing_stringA) !== (newValue))) { + this.__backing_stringA = newValue; + this.__meta_stringA.fireChange(); + this.executeOnSubscribingWatches("stringA"); + } + } + + public get booleanA(): boolean { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_booleanA.addRef(); + } + return this.__backing_booleanA; + } + + public set booleanA(newValue: boolean) { + if (((this.__backing_booleanA) !== (newValue))) { + this.__backing_booleanA = newValue; + this.__meta_booleanA.fireChange(); + this.executeOnSubscribingWatches("booleanA"); + } + } + + public get arrayA(): Array { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_arrayA.addRef(); + } + setObservationDepth(this.__backing_arrayA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_arrayA.value; + } + + public set arrayA(newValue: Array) { + if (((this.__backing_arrayA.value) !== (newValue))) { + this.__backing_arrayA.value = newValue; + this.__meta_arrayA.fireChange(); + this.executeOnSubscribingWatches("arrayA"); + } + } + + public get objectA(): Object { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_objectA.addRef(); + } + setObservationDepth(this.__backing_objectA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_objectA.value; + } + + public set objectA(newValue: Object) { + if (((this.__backing_objectA.value) !== (newValue))) { + this.__backing_objectA.value = newValue; + this.__meta_objectA.fireChange(); + this.executeOnSubscribingWatches("objectA"); + } + } + + public get dateA(): Date { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_dateA.addRef(); + } + setObservationDepth(this.__backing_dateA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_dateA.value; + } + + public set dateA(newValue: Date) { + if (((this.__backing_dateA.value) !== (newValue))) { + this.__backing_dateA.value = newValue; + this.__meta_dateA.fireChange(); + this.executeOnSubscribingWatches("dateA"); + } + } + + public get setA(): Set { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_setA.addRef(); + } + setObservationDepth(this.__backing_setA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_setA.value; + } + + public set setA(newValue: Set) { + if (((this.__backing_setA.value) !== (newValue))) { + this.__backing_setA.value = newValue; + this.__meta_setA.fireChange(); + this.executeOnSubscribingWatches("setA"); + } + } + + public get mapA(): Map { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_mapA.addRef(); + } + setObservationDepth(this.__backing_mapA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_mapA.value; + } + + public set mapA(newValue: Map) { + if (((this.__backing_mapA.value) !== (newValue))) { + this.__backing_mapA.value = newValue; + this.__meta_mapA.fireChange(); + this.executeOnSubscribingWatches("mapA"); + } + } + + public get unionA(): string | undefined { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_unionA.addRef(); + } + return this.__backing_unionA; + } + + public set unionA(newValue: string | undefined) { + if (((this.__backing_unionA) !== (newValue))) { + this.__backing_unionA = newValue; + this.__meta_unionA.fireChange(); + this.executeOnSubscribingWatches("unionA"); + } + } + + public get classA(): Person { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_classA.addRef(); + } + setObservationDepth(this.__backing_classA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_classA.value; + } + + public set classA(newValue: Person) { + if (((this.__backing_classA.value) !== (newValue))) { + this.__backing_classA.value = newValue; + this.__meta_classA.fireChange(); + this.executeOnSubscribingWatches("classA"); + } + } + + public get enumA(): Status { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_enumA.addRef(); + } + setObservationDepth(this.__backing_enumA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_enumA.value; + } + + public set enumA(newValue: Status) { + if (((this.__backing_enumA.value) !== (newValue))) { + this.__backing_enumA.value = newValue; + this.__meta_enumA.fireChange(); + this.executeOnSubscribingWatches("enumA"); + } + } + +} + +@Observed() class mixed2 implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + private __meta: MutableStateMeta = new MutableStateMeta("@Observe properties (no @Track)"); + + private __backing_numA: number = 33; + + private __backing_stringA: string = "AA"; + + private __backing_booleanA: boolean = true; + + private __backing_arrayA: BackingValue> = new BackingValue>([1, 2, 3]); + + private __backing_objectA: BackingValue = new BackingValue({}); + + private __backing_dateA: BackingValue = new BackingValue(new Date("2021-08-08")); + + private __backing_setA: BackingValue> = new BackingValue>(new Set()); + + private __backing_mapA: BackingValue> = new BackingValue>(new Map()); + + private __backing_unionA: string | undefined = ""; + + private __backing_classA: BackingValue = new BackingValue(new Person()); + + private __backing_enumA: BackingValue = new BackingValue(Status.NotFound); + + public constructor() {} + + public get numA(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_numA; + } + + public set numA(newValue: number) { + if (((this.__backing_numA) !== (newValue))) { + this.__backing_numA = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("numA"); + } + } + + public get stringA(): string { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_stringA; + } + + public set stringA(newValue: string) { + if (((this.__backing_stringA) !== (newValue))) { + this.__backing_stringA = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("stringA"); + } + } + + public get booleanA(): boolean { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_booleanA; + } + + public set booleanA(newValue: boolean) { + if (((this.__backing_booleanA) !== (newValue))) { + this.__backing_booleanA = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("booleanA"); + } + } + + public get arrayA(): Array { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_arrayA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_arrayA.value; + } + + public set arrayA(newValue: Array) { + if (((this.__backing_arrayA.value) !== (newValue))) { + this.__backing_arrayA.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("arrayA"); + } + } + + public get objectA(): Object { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_objectA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_objectA.value; + } + + public set objectA(newValue: Object) { + if (((this.__backing_objectA.value) !== (newValue))) { + this.__backing_objectA.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("objectA"); + } + } + + public get dateA(): Date { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_dateA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_dateA.value; + } + + public set dateA(newValue: Date) { + if (((this.__backing_dateA.value) !== (newValue))) { + this.__backing_dateA.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("dateA"); + } + } + + public get setA(): Set { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_setA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_setA.value; + } + + public set setA(newValue: Set) { + if (((this.__backing_setA.value) !== (newValue))) { + this.__backing_setA.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("setA"); + } + } + + public get mapA(): Map { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_mapA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_mapA.value; + } + + public set mapA(newValue: Map) { + if (((this.__backing_mapA.value) !== (newValue))) { + this.__backing_mapA.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("mapA"); + } + } + + public get unionA(): string | undefined { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_unionA; + } + + public set unionA(newValue: string | undefined) { + if (((this.__backing_unionA) !== (newValue))) { + this.__backing_unionA = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("unionA"); + } + } + + public get classA(): Person { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_classA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_classA.value; + } + + public set classA(newValue: Person) { + if (((this.__backing_classA.value) !== (newValue))) { + this.__backing_classA.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("classA"); + } + } + + public get enumA(): Status { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + setObservationDepth(this.__backing_enumA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_enumA.value; + } + + public set enumA(newValue: Status) { + if (((this.__backing_enumA.value) !== (newValue))) { + this.__backing_enumA.value = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("enumA"); + } + } + +} + +class mixed3 implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + private __backing_numA: number = 33; + + private __meta_numA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_stringA: string = "AA"; + + private __meta_stringA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_booleanA: boolean = true; + + private __meta_booleanA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_arrayA: BackingValue> = new BackingValue>([1, 2, 3]); + + private __meta_arrayA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_objectA: BackingValue = new BackingValue({}); + + private __meta_objectA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_dateA: BackingValue = new BackingValue(new Date("2021-08-08")); + + private __meta_dateA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_setA: BackingValue> = new BackingValue>(new Set()); + + private __meta_setA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_mapA: BackingValue> = new BackingValue>(new Map()); + + private __meta_mapA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_unionA: string | undefined = ""; + + private __meta_unionA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_classA: BackingValue = new BackingValue(new Person()); + + private __meta_classA: MutableStateMeta = new MutableStateMeta("@Track"); + + private __backing_enumA: BackingValue = new BackingValue(Status.NotFound); + + private __meta_enumA: MutableStateMeta = new MutableStateMeta("@Track"); + + public constructor() {} + + public get numA(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_numA.addRef(); + } + return this.__backing_numA; + } + + public set numA(newValue: number) { + if (((this.__backing_numA) !== (newValue))) { + this.__backing_numA = newValue; + this.__meta_numA.fireChange(); + this.executeOnSubscribingWatches("numA"); + } + } + + public get stringA(): string { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_stringA.addRef(); + } + return this.__backing_stringA; + } + + public set stringA(newValue: string) { + if (((this.__backing_stringA) !== (newValue))) { + this.__backing_stringA = newValue; + this.__meta_stringA.fireChange(); + this.executeOnSubscribingWatches("stringA"); + } + } + + public get booleanA(): boolean { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_booleanA.addRef(); + } + return this.__backing_booleanA; + } + + public set booleanA(newValue: boolean) { + if (((this.__backing_booleanA) !== (newValue))) { + this.__backing_booleanA = newValue; + this.__meta_booleanA.fireChange(); + this.executeOnSubscribingWatches("booleanA"); + } + } + + public get arrayA(): Array { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_arrayA.addRef(); + } + setObservationDepth(this.__backing_arrayA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_arrayA.value; + } + + public set arrayA(newValue: Array) { + if (((this.__backing_arrayA.value) !== (newValue))) { + this.__backing_arrayA.value = newValue; + this.__meta_arrayA.fireChange(); + this.executeOnSubscribingWatches("arrayA"); + } + } + + public get objectA(): Object { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_objectA.addRef(); + } + setObservationDepth(this.__backing_objectA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_objectA.value; + } + + public set objectA(newValue: Object) { + if (((this.__backing_objectA.value) !== (newValue))) { + this.__backing_objectA.value = newValue; + this.__meta_objectA.fireChange(); + this.executeOnSubscribingWatches("objectA"); + } + } + + public get dateA(): Date { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_dateA.addRef(); + } + setObservationDepth(this.__backing_dateA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_dateA.value; + } + + public set dateA(newValue: Date) { + if (((this.__backing_dateA.value) !== (newValue))) { + this.__backing_dateA.value = newValue; + this.__meta_dateA.fireChange(); + this.executeOnSubscribingWatches("dateA"); + } + } + + public get setA(): Set { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_setA.addRef(); + } + setObservationDepth(this.__backing_setA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_setA.value; + } + + public set setA(newValue: Set) { + if (((this.__backing_setA.value) !== (newValue))) { + this.__backing_setA.value = newValue; + this.__meta_setA.fireChange(); + this.executeOnSubscribingWatches("setA"); + } + } + + public get mapA(): Map { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_mapA.addRef(); + } + setObservationDepth(this.__backing_mapA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_mapA.value; + } + + public set mapA(newValue: Map) { + if (((this.__backing_mapA.value) !== (newValue))) { + this.__backing_mapA.value = newValue; + this.__meta_mapA.fireChange(); + this.executeOnSubscribingWatches("mapA"); + } + } + + public get unionA(): string | undefined { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_unionA.addRef(); + } + return this.__backing_unionA; + } + + public set unionA(newValue: string | undefined) { + if (((this.__backing_unionA) !== (newValue))) { + this.__backing_unionA = newValue; + this.__meta_unionA.fireChange(); + this.executeOnSubscribingWatches("unionA"); + } + } + + public get classA(): Person { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_classA.addRef(); + } + setObservationDepth(this.__backing_classA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_classA.value; + } + + public set classA(newValue: Person) { + if (((this.__backing_classA.value) !== (newValue))) { + this.__backing_classA.value = newValue; + this.__meta_classA.fireChange(); + this.executeOnSubscribingWatches("classA"); + } + } + + public get enumA(): Status { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_enumA.addRef(); + } + setObservationDepth(this.__backing_enumA.value, ((this._permissibleAddRefDepth) - (1))); + return this.__backing_enumA.value; + } + + public set enumA(newValue: Status) { + if (((this.__backing_enumA.value) !== (newValue))) { + this.__backing_enumA.value = newValue; + this.__meta_enumA.fireChange(); + this.executeOnSubscribingWatches("enumA"); + } + } + +} + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + MyStateSample._instantiateImpl(undefined, (() => { + return new MyStateSample(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} +`; + +function testObservedOnlyTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test observed track transform with complex type', + [observedTrackTransform, uiNoRecheck], + { + checked: [testObservedOnlyTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/observed-track/observed-track-extends.test.ts b/ets1.2/tests_ui/decorators/observed-track/observed-track-extends.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..f3f3a001e2c591788fd4d8553b3d78cdbcf1a73e --- /dev/null +++ b/ets1.2/tests_ui/decorators/observed-track/observed-track-extends.test.ts @@ -0,0 +1,204 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const OBSERVED_DIR_PATH: string = 'decorators/observed-track'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, OBSERVED_DIR_PATH, 'observed-track-extends.ets'), +]; + +const observedTrackTransform: Plugins = { + name: 'observedTrack', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test observed track transform with extends', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { SubscribedWatches as SubscribedWatches } from "@ohos.arkui.stateManagement"; + +import { WatchIdType as WatchIdType } from "@ohos.arkui.stateManagement"; + +import { int32 as int32 } from "@ohos.arkui.stateManagement"; + +import { IObservedObject as IObservedObject } from "@ohos.arkui.stateManagement"; + +import { setObservationDepth as setObservationDepth } from "@ohos.arkui.stateManagement"; + +import { BackingValue as BackingValue } from "@ohos.arkui.stateManagement"; + +import { MutableStateMeta as MutableStateMeta } from "@ohos.arkui.stateManagement"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component } from "@ohos.arkui.component"; + +import { Observed as Observed, Track as Track } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +@Observed() class A implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + private __meta: MutableStateMeta = new MutableStateMeta("@Observe properties (no @Track)"); + + private __backing_propA: number = 1; + + private __backing_trackA: number = 2; + + public constructor() {} + + public get propA(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_propA; + } + + public set propA(newValue: number) { + if (((this.__backing_propA) !== (newValue))) { + this.__backing_propA = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("propA"); + } + } + + public get trackA(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_trackA; + } + + public set trackA(newValue: number) { + if (((this.__backing_trackA) !== (newValue))) { + this.__backing_trackA = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("trackA"); + } + } + +} + +class G extends A { + public propG: number = 1; + + public constructor() {} + +} + +@Observed() class H extends G implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + private __backing_propG: number = 1; + + private __meta_propG: MutableStateMeta = new MutableStateMeta("@Track"); + + public constructor() {} + + public get propG(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_propG.addRef(); + } + return this.__backing_propG; + } + + public set propG(newValue: number) { + if (((this.__backing_propG) !== (newValue))) { + this.__backing_propG = newValue; + this.__meta_propG.fireChange(); + this.executeOnSubscribingWatches("propG"); + } + } + +} + +@Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + +`; + +function testObservedOnlyTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test observed track transform with extends', + [observedTrackTransform, uiNoRecheck], + { + checked: [testObservedOnlyTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/observed-track/observed-track-implements.test.ts b/ets1.2/tests_ui/decorators/observed-track/observed-track-implements.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..f71a5e9220baae369451ae7da09f53299cf542b0 --- /dev/null +++ b/ets1.2/tests_ui/decorators/observed-track/observed-track-implements.test.ts @@ -0,0 +1,171 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const OBSERVED_DIR_PATH: string = 'decorators/observed-track'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, OBSERVED_DIR_PATH, 'observed-track-implements.ets'), +]; + +const observedTrackTransform: Plugins = { + name: 'observedTrack', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test observed track transform with implements', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { SubscribedWatches as SubscribedWatches } from "@ohos.arkui.stateManagement"; + +import { WatchIdType as WatchIdType } from "@ohos.arkui.stateManagement"; + +import { int32 as int32 } from "@ohos.arkui.stateManagement"; + +import { IObservedObject as IObservedObject } from "@ohos.arkui.stateManagement"; + +import { setObservationDepth as setObservationDepth } from "@ohos.arkui.stateManagement"; + +import { BackingValue as BackingValue } from "@ohos.arkui.stateManagement"; + +import { MutableStateMeta as MutableStateMeta } from "@ohos.arkui.stateManagement"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component } from "@ohos.arkui.component"; + +import { Observed as Observed } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +interface PropInterface { + set propF(propF: number) + + get propF(): number + +} + +interface trackInterface { + set trackF(trackF: number) + + get trackF(): number + +} + +@Observed() class F implements PropInterface, trackInterface, IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + private __meta: MutableStateMeta = new MutableStateMeta("@Observe properties (no @Track)"); + + private __backing_propF: number = 1; + + private __backing_trackF: number = 2; + + public constructor() {} + + public set propF(newValue: number) { + if (((this.__backing_propF) !== (newValue))) { + this.__backing_propF = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("propF"); + } + } + + public get propF(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_propF; + } + + public set trackF(newValue: number) { + if (((this.__backing_trackF) !== (newValue))) { + this.__backing_trackF = newValue; + this.__meta.fireChange(); + this.executeOnSubscribingWatches("trackF"); + } + } + + public get trackF(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta.addRef(); + } + return this.__backing_trackF; + } + +} + +@Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + +`; + +function testObservedOnlyTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test observed track transform with implements', + [observedTrackTransform, uiNoRecheck], + { + checked: [testObservedOnlyTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/observed-track/observed-track.test.ts b/ets1.2/tests_ui/decorators/observed-track/observed-track.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..9f28609dcd64f3b519634444a4aefb6cda4ade5f --- /dev/null +++ b/ets1.2/tests_ui/decorators/observed-track/observed-track.test.ts @@ -0,0 +1,142 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const OBSERVED_DIR_PATH: string = 'decorators/observed-track'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, OBSERVED_DIR_PATH, 'observed-track.ets'), +]; + +const observedTrackTransform: Plugins = { + name: 'observedTrack', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test observed with track transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { SubscribedWatches as SubscribedWatches } from "@ohos.arkui.stateManagement"; + +import { WatchIdType as WatchIdType } from "@ohos.arkui.stateManagement"; + +import { int32 as int32 } from "@ohos.arkui.stateManagement"; + +import { IObservedObject as IObservedObject } from "@ohos.arkui.stateManagement"; + +import { setObservationDepth as setObservationDepth } from "@ohos.arkui.stateManagement"; + +import { BackingValue as BackingValue } from "@ohos.arkui.stateManagement"; + +import { MutableStateMeta as MutableStateMeta } from "@ohos.arkui.stateManagement"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component } from "@ohos.arkui.component"; + +import { Observed as Observed, Track as Track } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +@Observed() class B implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + public propB: number = 1; + + private __backing_trackB: number = 2; + + private __meta_trackB: MutableStateMeta = new MutableStateMeta("@Track"); + + public constructor() {} + + public get trackB(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_trackB.addRef(); + } + return this.__backing_trackB; + } + + public set trackB(newValue: number) { + if (((this.__backing_trackB) !== (newValue))) { + this.__backing_trackB = newValue; + this.__meta_trackB.fireChange(); + this.executeOnSubscribingWatches("trackB"); + } + } + +} + +@Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + +`; + +function testObservedOnlyTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test observed with track transform', + [observedTrackTransform, uiNoRecheck], + { + checked: [testObservedOnlyTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/observed-track/track-only.test.ts b/ets1.2/tests_ui/decorators/observed-track/track-only.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..a1e60b0fac2f4c912322eaa339453d70a5a0e624 --- /dev/null +++ b/ets1.2/tests_ui/decorators/observed-track/track-only.test.ts @@ -0,0 +1,142 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const OBSERVED_DIR_PATH: string = 'decorators/observed-track'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, OBSERVED_DIR_PATH, 'track-only.ets'), +]; + +const observedTrackTransform: Plugins = { + name: 'observedTrack', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test track only transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { SubscribedWatches as SubscribedWatches } from "@ohos.arkui.stateManagement"; + +import { WatchIdType as WatchIdType } from "@ohos.arkui.stateManagement"; + +import { int32 as int32 } from "@ohos.arkui.stateManagement"; + +import { IObservedObject as IObservedObject } from "@ohos.arkui.stateManagement"; + +import { setObservationDepth as setObservationDepth } from "@ohos.arkui.stateManagement"; + +import { BackingValue as BackingValue } from "@ohos.arkui.stateManagement"; + +import { MutableStateMeta as MutableStateMeta } from "@ohos.arkui.stateManagement"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component } from "@ohos.arkui.component"; + +import { Track as Track } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +class C implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + public propC: number = 1; + + private __backing_trackC: number = 2; + + private __meta_trackC: MutableStateMeta = new MutableStateMeta("@Track"); + + public constructor() {} + + public get trackC(): number { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_trackC.addRef(); + } + return this.__backing_trackC; + } + + public set trackC(newValue: number) { + if (((this.__backing_trackC) !== (newValue))) { + this.__backing_trackC = newValue; + this.__meta_trackC.fireChange(); + this.executeOnSubscribingWatches("trackC"); + } + } + +} + +@Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + +`; + +function testObservedOnlyTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test track only transform', + [observedTrackTransform, uiNoRecheck], + { + checked: [testObservedOnlyTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/prop/prop-basic-type.test.ts b/ets1.2/tests_ui/decorators/prop/prop-basic-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..9ed1637237c1bb9de9903aebfa230cc77d88d070 --- /dev/null +++ b/ets1.2/tests_ui/decorators/prop/prop-basic-type.test.ts @@ -0,0 +1,161 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/prop'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'prop-basic-type.ets'), +]; + +const pluginTester = new PluginTester('test basic type @Prop decorated variables transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'prop-basic-type', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { PropDecoratedVariable as PropDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { Prop as Prop } from "@ohos.arkui.stateManagement"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class PropParent extends CustomComponent { + public __initializeStruct(initializers: __Options_PropParent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_propVar1 = new PropDecoratedVariable("propVar1", ((({let gensym___95172135 = initializers; + (((gensym___95172135) == (null)) ? undefined : gensym___95172135.propVar1)})) ?? ("propVar1"))); + this.__backing_propVar2 = new PropDecoratedVariable("propVar2", ((({let gensym___222490386 = initializers; + (((gensym___222490386) == (null)) ? undefined : gensym___222490386.propVar2)})) ?? (50))); + this.__backing_propVar3 = new PropDecoratedVariable("propVar3", ((({let gensym___201781257 = initializers; + (((gensym___201781257) == (null)) ? undefined : gensym___201781257.propVar3)})) ?? (true))); + this.__backing_propVar4 = new PropDecoratedVariable("propVar4", ((({let gensym___22028950 = initializers; + (((gensym___22028950) == (null)) ? undefined : gensym___22028950.propVar4)})) ?? (undefined))); + this.__backing_propVar5 = new PropDecoratedVariable("propVar5", ((({let gensym___54872258 = initializers; + (((gensym___54872258) == (null)) ? undefined : gensym___54872258.propVar5)})) ?? (null))); + } + public __updateStruct(initializers: __Options_PropParent | undefined): void { + if (((({let gensym___67969738 = initializers; + (((gensym___67969738) == (null)) ? undefined : gensym___67969738.propVar1)})) !== (undefined))) { + this.__backing_propVar1!.update((initializers!.propVar1 as string)); + } + if (((({let gensym___52350476 = initializers; + (((gensym___52350476) == (null)) ? undefined : gensym___52350476.propVar2)})) !== (undefined))) { + this.__backing_propVar2!.update((initializers!.propVar2 as number)); + } + if (((({let gensym___103864283 = initializers; + (((gensym___103864283) == (null)) ? undefined : gensym___103864283.propVar3)})) !== (undefined))) { + this.__backing_propVar3!.update((initializers!.propVar3 as boolean)); + } + if (((({let gensym___175155715 = initializers; + (((gensym___175155715) == (null)) ? undefined : gensym___175155715.propVar4)})) !== (undefined))) { + this.__backing_propVar4!.update((initializers!.propVar4 as undefined)); + } + if (((({let gensym___134530703 = initializers; + (((gensym___134530703) == (null)) ? undefined : gensym___134530703.propVar5)})) !== (undefined))) { + this.__backing_propVar5!.update((initializers!.propVar5 as null)); + } + } + private __backing_propVar1?: PropDecoratedVariable; + public get propVar1(): string { + return this.__backing_propVar1!.get(); + } + public set propVar1(value: string) { + this.__backing_propVar1!.set(value); + } + private __backing_propVar2?: PropDecoratedVariable; + public get propVar2(): number { + return this.__backing_propVar2!.get(); + } + public set propVar2(value: number) { + this.__backing_propVar2!.set(value); + } + private __backing_propVar3?: PropDecoratedVariable; + public get propVar3(): boolean { + return this.__backing_propVar3!.get(); + } + public set propVar3(value: boolean) { + this.__backing_propVar3!.set(value); + } + private __backing_propVar4?: PropDecoratedVariable; + public get propVar4(): undefined { + return this.__backing_propVar4!.get(); + } + public set propVar4(value: undefined) { + this.__backing_propVar4!.set(value); + } + private __backing_propVar5?: PropDecoratedVariable; + public get propVar5(): null { + return this.__backing_propVar5!.get(); + } + public set propVar5(value: null) { + this.__backing_propVar5!.set(value); + } + @memo() public _build(@memo() style: ((instance: PropParent)=> PropParent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_PropParent | undefined): void {} + public constructor() {} +} + +interface __Options_PropParent { + set propVar1(propVar1: string | undefined) + get propVar1(): string | undefined + set __backing_propVar1(__backing_propVar1: PropDecoratedVariable | undefined) + get __backing_propVar1(): PropDecoratedVariable | undefined + set propVar2(propVar2: number | undefined) + get propVar2(): number | undefined + set __backing_propVar2(__backing_propVar2: PropDecoratedVariable | undefined) + get __backing_propVar2(): PropDecoratedVariable | undefined + set propVar3(propVar3: boolean | undefined) + get propVar3(): boolean | undefined + set __backing_propVar3(__backing_propVar3: PropDecoratedVariable | undefined) + get __backing_propVar3(): PropDecoratedVariable | undefined + set propVar4(propVar4: undefined | undefined) + get propVar4(): undefined | undefined + set __backing_propVar4(__backing_propVar4: PropDecoratedVariable | undefined) + get __backing_propVar4(): PropDecoratedVariable | undefined + set propVar5(propVar5: null | undefined) + get propVar5(): null | undefined + set __backing_propVar5(__backing_propVar5: PropDecoratedVariable | undefined) + get __backing_propVar5(): PropDecoratedVariable | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test basic type @Prop decorated variables transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/prop/prop-complex-type.test.ts b/ets1.2/tests_ui/decorators/prop/prop-complex-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..7db4457811022389e20f8b2b1ab1b2d0067444d1 --- /dev/null +++ b/ets1.2/tests_ui/decorators/prop/prop-complex-type.test.ts @@ -0,0 +1,337 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/prop'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'prop-complex-type.ets'), +]; + +const pluginTester = new PluginTester('test complex type @Prop decorated variables transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'prop-complex-type', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { PropDecoratedVariable as PropDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { Prop as Prop } from "@ohos.arkui.stateManagement"; + +function main() {} + +class Per { + public num: number; + public constructor(num: number) { + this.num = num; + } +} + +final class PropType extends BaseEnum { + private readonly #ordinal: int; + private static () {} + public constructor(ordinal: int, value: int) { + super(value); + this.#ordinal = ordinal; + } + public static readonly TYPE1: PropType = new PropType(0, 0); + public static readonly TYPE2: PropType = new PropType(1, 1); + public static readonly TYPE3: PropType = new PropType(2, 3); + private static readonly #NamesArray: String[] = ["TYPE1", "TYPE2", "TYPE3"]; + private static readonly #ValuesArray: int[] = [0, 1, 3]; + private static readonly #StringValuesArray: String[] = ["0", "1", "3"]; + private static readonly #ItemsArray: PropType[] = [PropType.TYPE1, PropType.TYPE2, PropType.TYPE3]; + public getName(): String { + return PropType.#NamesArray[this.#ordinal]; + } + public static getValueOf(name: String): PropType { + for (let i = 0;((i) < (PropType.#NamesArray.length));(++i)) { + if (((name) == (PropType.#NamesArray[i]))) { + return PropType.#ItemsArray[i]; + } + } + throw new Error((("No enum constant PropType.") + (name))); + } + public static fromValue(value: int): PropType { + for (let i = 0;((i) < (PropType.#ValuesArray.length));(++i)) { + if (((value) == (PropType.#ValuesArray[i]))) { + return PropType.#ItemsArray[i]; + } + } + throw new Error((("No enum PropType with value ") + (value))); + } + public valueOf(): int { + return PropType.#ValuesArray[this.#ordinal]; + } + public toString(): String { + return PropType.#StringValuesArray[this.#ordinal]; + } + public static values(): PropType[] { + return PropType.#ItemsArray; + } + public getOrdinal(): int { + return this.#ordinal; + } + public static $_get(e: PropType): String { + return e.getName(); + } +} + +@Component({freezeWhenInactive:false}) final class Parent extends CustomComponent { + public __initializeStruct(initializers: __Options_Parent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_propVar1 = new PropDecoratedVariable("propVar1", ((({let gensym___95172135 = initializers; + (((gensym___95172135) == (null)) ? undefined : gensym___95172135.propVar1)})) ?? (new Per(6)))); + this.__backing_propVar2 = new PropDecoratedVariable>("propVar2", ((({let gensym___222490386 = initializers; + (((gensym___222490386) == (null)) ? undefined : gensym___222490386.propVar2)})) ?? (new Array(3, 6, 8)))); + this.__backing_propVar3 = new PropDecoratedVariable("propVar3", ((({let gensym___201781257 = initializers; + (((gensym___201781257) == (null)) ? undefined : gensym___201781257.propVar3)})) ?? (PropType.TYPE3))); + this.__backing_propVar4 = new PropDecoratedVariable>("propVar4", ((({let gensym___22028950 = initializers; + (((gensym___22028950) == (null)) ? undefined : gensym___22028950.propVar4)})) ?? (new Set(new Array("aa", "bb"))))); + this.__backing_propVar5 = new PropDecoratedVariable>("propVar5", ((({let gensym___54872258 = initializers; + (((gensym___54872258) == (null)) ? undefined : gensym___54872258.propVar5)})) ?? ([true, false]))); + this.__backing_propVar6 = new PropDecoratedVariable>("propVar6", ((({let gensym___128760941 = initializers; + (((gensym___128760941) == (null)) ? undefined : gensym___128760941.propVar6)})) ?? (new Array(new Per(7), new Per(11))))); + this.__backing_propVar7 = new PropDecoratedVariable>("propVar7", ((({let gensym___30534085 = initializers; + (((gensym___30534085) == (null)) ? undefined : gensym___30534085.propVar7)})) ?? ([new Per(7), new Per(11)]))); + this.__backing_propVar8 = new PropDecoratedVariable<((sr: string)=> void)>("propVar8", ((({let gensym___12471776 = initializers; + (((gensym___12471776) == (null)) ? undefined : gensym___12471776.propVar8)})) ?? (((sr: string) => {})))); + this.__backing_propVar9 = new PropDecoratedVariable("propVar9", ((({let gensym___123472108 = initializers; + (((gensym___123472108) == (null)) ? undefined : gensym___123472108.propVar9)})) ?? (new Date("2025-4-23")))); + this.__backing_propVar10 = new PropDecoratedVariable>("propVar10", ((({let gensym___147847012 = initializers; + (((gensym___147847012) == (null)) ? undefined : gensym___147847012.propVar10)})) ?? (new Map([[0, new Per(7)], [1, new Per(10)]])))); + this.__backing_propVar11 = new PropDecoratedVariable("propVar11", ((({let gensym___117026760 = initializers; + (((gensym___117026760) == (null)) ? undefined : gensym___117026760.propVar11)})) ?? (0.0))); + this.__backing_propVar12 = new PropDecoratedVariable | Per>("propVar12", ((({let gensym___220245132 = initializers; + (((gensym___220245132) == (null)) ? undefined : gensym___220245132.propVar12)})) ?? (new Per(6)))); + } + public __updateStruct(initializers: __Options_Parent | undefined): void { + if (((({let gensym___67969738 = initializers; + (((gensym___67969738) == (null)) ? undefined : gensym___67969738.propVar1)})) !== (undefined))) { + this.__backing_propVar1!.update((initializers!.propVar1 as Per)); + } + if (((({let gensym___52350476 = initializers; + (((gensym___52350476) == (null)) ? undefined : gensym___52350476.propVar2)})) !== (undefined))) { + this.__backing_propVar2!.update((initializers!.propVar2 as Array)); + } + if (((({let gensym___103864283 = initializers; + (((gensym___103864283) == (null)) ? undefined : gensym___103864283.propVar3)})) !== (undefined))) { + this.__backing_propVar3!.update((initializers!.propVar3 as PropType)); + } + if (((({let gensym___175155715 = initializers; + (((gensym___175155715) == (null)) ? undefined : gensym___175155715.propVar4)})) !== (undefined))) { + this.__backing_propVar4!.update((initializers!.propVar4 as Set)); + } + if (((({let gensym___134530703 = initializers; + (((gensym___134530703) == (null)) ? undefined : gensym___134530703.propVar5)})) !== (undefined))) { + this.__backing_propVar5!.update((initializers!.propVar5 as Array)); + } + if (((({let gensym___211600890 = initializers; + (((gensym___211600890) == (null)) ? undefined : gensym___211600890.propVar6)})) !== (undefined))) { + this.__backing_propVar6!.update((initializers!.propVar6 as Array)); + } + if (((({let gensym___124229427 = initializers; + (((gensym___124229427) == (null)) ? undefined : gensym___124229427.propVar7)})) !== (undefined))) { + this.__backing_propVar7!.update((initializers!.propVar7 as Array)); + } + if (((({let gensym___248056380 = initializers; + (((gensym___248056380) == (null)) ? undefined : gensym___248056380.propVar8)})) !== (undefined))) { + this.__backing_propVar8!.update((initializers!.propVar8 as ((sr: string)=> void))); + } + if (((({let gensym___55399278 = initializers; + (((gensym___55399278) == (null)) ? undefined : gensym___55399278.propVar9)})) !== (undefined))) { + this.__backing_propVar9!.update((initializers!.propVar9 as Date)); + } + if (((({let gensym___125042885 = initializers; + (((gensym___125042885) == (null)) ? undefined : gensym___125042885.propVar10)})) !== (undefined))) { + this.__backing_propVar10!.update((initializers!.propVar10 as Map)); + } + if (((({let gensym___2015283 = initializers; + (((gensym___2015283) == (null)) ? undefined : gensym___2015283.propVar11)})) !== (undefined))) { + this.__backing_propVar11!.update((initializers!.propVar11 as string | number)); + } + if (((({let gensym___39009414 = initializers; + (((gensym___39009414) == (null)) ? undefined : gensym___39009414.propVar12)})) !== (undefined))) { + this.__backing_propVar12!.update((initializers!.propVar12 as Set | Per)); + } + } + private __backing_propVar1?: PropDecoratedVariable; + public get propVar1(): Per { + return this.__backing_propVar1!.get(); + } + public set propVar1(value: Per) { + this.__backing_propVar1!.set(value); + } + private __backing_propVar2?: PropDecoratedVariable>; + public get propVar2(): Array { + return this.__backing_propVar2!.get(); + } + public set propVar2(value: Array) { + this.__backing_propVar2!.set(value); + } + private __backing_propVar3?: PropDecoratedVariable; + public get propVar3(): PropType { + return this.__backing_propVar3!.get(); + } + public set propVar3(value: PropType) { + this.__backing_propVar3!.set(value); + } + private __backing_propVar4?: PropDecoratedVariable>; + public get propVar4(): Set { + return this.__backing_propVar4!.get(); + } + public set propVar4(value: Set) { + this.__backing_propVar4!.set(value); + } + private __backing_propVar5?: PropDecoratedVariable>; + public get propVar5(): Array { + return this.__backing_propVar5!.get(); + } + public set propVar5(value: Array) { + this.__backing_propVar5!.set(value); + } + private __backing_propVar6?: PropDecoratedVariable>; + public get propVar6(): Array { + return this.__backing_propVar6!.get(); + } + public set propVar6(value: Array) { + this.__backing_propVar6!.set(value); + } + private __backing_propVar7?: PropDecoratedVariable>; + public get propVar7(): Array { + return this.__backing_propVar7!.get(); + } + public set propVar7(value: Array) { + this.__backing_propVar7!.set(value); + } + private __backing_propVar8?: PropDecoratedVariable<((sr: string)=> void)>; + public get propVar8(): ((sr: string)=> void) { + return this.__backing_propVar8!.get(); + } + public set propVar8(value: ((sr: string)=> void)) { + this.__backing_propVar8!.set(value); + } + private __backing_propVar9?: PropDecoratedVariable; + public get propVar9(): Date { + return this.__backing_propVar9!.get(); + } + public set propVar9(value: Date) { + this.__backing_propVar9!.set(value); + } + private __backing_propVar10?: PropDecoratedVariable>; + public get propVar10(): Map { + return this.__backing_propVar10!.get(); + } + public set propVar10(value: Map) { + this.__backing_propVar10!.set(value); + } + private __backing_propVar11?: PropDecoratedVariable; + public get propVar11(): string | number { + return this.__backing_propVar11!.get(); + } + public set propVar11(value: string | number) { + this.__backing_propVar11!.set(value); + } + private __backing_propVar12?: PropDecoratedVariable | Per>; + public get propVar12(): Set | Per { + return this.__backing_propVar12!.get(); + } + public set propVar12(value: Set | Per) { + this.__backing_propVar12!.set(value); + } + @memo() public _build(@memo() style: ((instance: Parent)=> Parent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Parent | undefined): void {} + public constructor() {} +} + +interface __Options_Parent { + set propVar1(propVar1: Per | undefined) + get propVar1(): Per | undefined + set __backing_propVar1(__backing_propVar1: PropDecoratedVariable | undefined) + get __backing_propVar1(): PropDecoratedVariable | undefined + set propVar2(propVar2: Array | undefined) + get propVar2(): Array | undefined + set __backing_propVar2(__backing_propVar2: PropDecoratedVariable> | undefined) + get __backing_propVar2(): PropDecoratedVariable> | undefined + set propVar3(propVar3: PropType | undefined) + get propVar3(): PropType | undefined + set __backing_propVar3(__backing_propVar3: PropDecoratedVariable | undefined) + get __backing_propVar3(): PropDecoratedVariable | undefined + set propVar4(propVar4: Set | undefined) + get propVar4(): Set | undefined + set __backing_propVar4(__backing_propVar4: PropDecoratedVariable> | undefined) + get __backing_propVar4(): PropDecoratedVariable> | undefined + set propVar5(propVar5: Array | undefined) + get propVar5(): Array | undefined + set __backing_propVar5(__backing_propVar5: PropDecoratedVariable> | undefined) + get __backing_propVar5(): PropDecoratedVariable> | undefined + set propVar6(propVar6: Array | undefined) + get propVar6(): Array | undefined + set __backing_propVar6(__backing_propVar6: PropDecoratedVariable> | undefined) + get __backing_propVar6(): PropDecoratedVariable> | undefined + set propVar7(propVar7: Array | undefined) + get propVar7(): Array | undefined + set __backing_propVar7(__backing_propVar7: PropDecoratedVariable> | undefined) + get __backing_propVar7(): PropDecoratedVariable> | undefined + set propVar8(propVar8: ((sr: string)=> void) | undefined) + get propVar8(): ((sr: string)=> void) | undefined + set __backing_propVar8(__backing_propVar8: PropDecoratedVariable<((sr: string)=> void)> | undefined) + get __backing_propVar8(): PropDecoratedVariable<((sr: string)=> void)> | undefined + set propVar9(propVar9: Date | undefined) + get propVar9(): Date | undefined + set __backing_propVar9(__backing_propVar9: PropDecoratedVariable | undefined) + get __backing_propVar9(): PropDecoratedVariable | undefined + set propVar10(propVar10: Map | undefined) + get propVar10(): Map | undefined + set __backing_propVar10(__backing_propVar10: PropDecoratedVariable> | undefined) + get __backing_propVar10(): PropDecoratedVariable> | undefined + set propVar11(propVar11: string | number | undefined) + get propVar11(): string | number | undefined + set __backing_propVar11(__backing_propVar11: PropDecoratedVariable | undefined) + get __backing_propVar11(): PropDecoratedVariable | undefined + set propVar12(propVar12: Set | Per | undefined) + get propVar12(): Set | Per | undefined + set __backing_propVar12(__backing_propVar12: PropDecoratedVariable | Per> | undefined) + get __backing_propVar12(): PropDecoratedVariable | Per> | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test complex type @Prop decorated variables transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/prop/state-to-prop.test.ts b/ets1.2/tests_ui/decorators/prop/state-to-prop.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..0809c2d4618d31b1122ddb9aa96913a92229c623 --- /dev/null +++ b/ets1.2/tests_ui/decorators/prop/state-to-prop.test.ts @@ -0,0 +1,169 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/prop'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'state-to-prop.ets'), +]; + +const pluginTester = new PluginTester('test @Prop decorated variables passing', buildConfig); + +const parsedTransform: Plugins = { + name: 'state-to-prop', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { PropDecoratedVariable as PropDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { UIButtonAttribute as UIButtonAttribute } from "@ohos.arkui.component"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, Text as Text, Button as Button, Column as Column, ClickEvent as ClickEvent } from "@ohos.arkui.component"; +import { Prop as Prop, State as State } from "@ohos.arkui.stateManagement"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class CountDownComponent extends CustomComponent { + public __initializeStruct(initializers: __Options_CountDownComponent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_count = new PropDecoratedVariable("count", ((({let gensym___58710805 = initializers; + (((gensym___58710805) == (null)) ? undefined : gensym___58710805.count)})) ?? (0))); + this.__backing_costOfOneAttempt = ((({let gensym___88948111 = initializers; + (((gensym___88948111) == (null)) ? undefined : gensym___88948111.costOfOneAttempt)})) ?? (1)); + } + public __updateStruct(initializers: __Options_CountDownComponent | undefined): void { + if (((({let gensym___188547633 = initializers; + (((gensym___188547633) == (null)) ? undefined : gensym___188547633.count)})) !== (undefined))) { + this.__backing_count!.update((initializers!.count as number)); + } + } + private __backing_count?: PropDecoratedVariable; + public get count(): number { + return this.__backing_count!.get(); + } + public set count(value: number) { + this.__backing_count!.set(value); + } + private __backing_costOfOneAttempt?: number; + public get costOfOneAttempt(): number { + return (this.__backing_costOfOneAttempt as number); + } + public set costOfOneAttempt(value: number) { + this.__backing_costOfOneAttempt = value; + } + + @memo() public _build(@memo() style: ((instance: CountDownComponent)=> CountDownComponent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_CountDownComponent | undefined): void { + Column(undefined, undefined, (() => { + if (((this.count) > (0))) { + Text(undefined, (((("You have") + (this.count))) + ("Nuggets left")), undefined, undefined); + } else { + Text(undefined, "Game over!", undefined, undefined); + } + Button(@memo() ((instance: UIButtonAttribute): void => { + instance.onClick(((e: ClickEvent) => { + this.count -= this.costOfOneAttempt; + })); + return; + }), "Try again", undefined, undefined); + })); + } + public constructor() {} +} + +@Component({freezeWhenInactive:false}) final class ParentComponent extends CustomComponent { + public __initializeStruct(initializers: __Options_ParentComponent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_countDownStartValue = new StateDecoratedVariable("countDownStartValue", ((({let gensym___249912438 = initializers; + (((gensym___249912438) == (null)) ? undefined : gensym___249912438.countDownStartValue)})) ?? (10))); + } + public __updateStruct(initializers: __Options_ParentComponent | undefined): void {} + private __backing_countDownStartValue?: StateDecoratedVariable; + public get countDownStartValue(): number { + return this.__backing_countDownStartValue!.get(); + } + public set countDownStartValue(value: number) { + this.__backing_countDownStartValue!.set(value); + } + @memo() public _build(@memo() style: ((instance: ParentComponent)=> ParentComponent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_ParentComponent | undefined): void { + Column(undefined, undefined, (() => { + Text(undefined, (((("Grant") + (this.countDownStartValue))) + ("nuggets to play.")), undefined, undefined); + Button(@memo() ((instance: UIButtonAttribute): void => { + instance.onClick(((e: ClickEvent) => { + this.countDownStartValue += 1; + })); + return; + }), "+1 - Nuggets in New Game", undefined, undefined); + Button(@memo() ((instance: UIButtonAttribute): void => { + instance.onClick(((e: ClickEvent) => { + this.countDownStartValue -= 1; + })); + return; + }), "-1 - Nuggets in New Game", undefined, undefined); + CountDownComponent._instantiateImpl(undefined, (() => { + return new CountDownComponent(); + }), ({ + count: this.countDownStartValue, + costOfOneAttempt: 2, + } as __Options_CountDownComponent), undefined, undefined); + })); + } + public constructor() {} +} + +interface __Options_CountDownComponent { + set count(count: number | undefined) + get count(): number | undefined + set __backing_count(__backing_count: PropDecoratedVariable | undefined) + get __backing_count(): PropDecoratedVariable | undefined + set costOfOneAttempt(costOfOneAttempt: number | undefined) + get costOfOneAttempt(): number | undefined +} + +interface __Options_ParentComponent { + set countDownStartValue(countDownStartValue: number | undefined) + get countDownStartValue(): number | undefined + set __backing_countDownStartValue(__backing_countDownStartValue: StateDecoratedVariable | undefined) + get __backing_countDownStartValue(): StateDecoratedVariable | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test @Prop decorated variables passing', + [parsedTransform, uiNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/provide-and-consume/provide-annotation-usage.test.ts b/ets1.2/tests_ui/decorators/provide-and-consume/provide-annotation-usage.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..9f57877626b1b3aa3a18de0419f718f1971bf41d --- /dev/null +++ b/ets1.2/tests_ui/decorators/provide-and-consume/provide-annotation-usage.test.ts @@ -0,0 +1,179 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/provide-and-consume'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'provide-annotation-usage.ets'), +]; + +const pluginTester = new PluginTester('test different @Provide annotation usage transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'provide-annotation-usage', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { ProvideDecoratedVariable as ProvideDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { Provide as Provide } from "@ohos.arkui.stateManagement"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class Ancestors extends CustomComponent { + public __initializeStruct(initializers: __Options_Ancestors | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_count = this.addProvidedVar("count", "count", ((({let gensym___58710805 = initializers; + (((gensym___58710805) == (null)) ? undefined : gensym___58710805.count)})) ?? ("Child0")), false); + this.__backing_count1 = this.addProvidedVar("count1", "prov1", ((({let gensym___84874570 = initializers; + (((gensym___84874570) == (null)) ? undefined : gensym___84874570.count1)})) ?? ("Child1")), false); + this.__backing_count2 = this.addProvidedVar("count2", "prov2", ((({let gensym___124037738 = initializers; + (((gensym___124037738) == (null)) ? undefined : gensym___124037738.count2)})) ?? ("Child2")), false); + this.__backing_count3 = this.addProvidedVar("count3", "prov3", ((({let gensym___199202238 = initializers; + (((gensym___199202238) == (null)) ? undefined : gensym___199202238.count3)})) ?? ("Child3")), true); + this.__backing_count4 = this.addProvidedVar("count4", "count4", ((({let gensym___4359740 = initializers; + (((gensym___4359740) == (null)) ? undefined : gensym___4359740.count4)})) ?? ("Child4")), false); + this.__backing_count5 = this.addProvidedVar("count5", "count5", ((({let gensym___208755050 = initializers; + (((gensym___208755050) == (null)) ? undefined : gensym___208755050.count5)})) ?? ("Child5")), true); + this.__backing_count6 = this.addProvidedVar("count6", "", ((({let gensym___37571585 = initializers; + (((gensym___37571585) == (null)) ? undefined : gensym___37571585.count6)})) ?? ("Child6")), true); + this.__backing_count7 = this.addProvidedVar("count7", "", ((({let gensym___2162781 = initializers; + (((gensym___2162781) == (null)) ? undefined : gensym___2162781.count7)})) ?? ("Child7")), false); + } + public __updateStruct(initializers: __Options_Ancestors | undefined): void {} + private __backing_count?: ProvideDecoratedVariable; + public get count(): string | undefined { + return this.__backing_count!.get(); + } + public set count(value: string | undefined) { + this.__backing_count!.set(value); + } + private __backing_count1?: ProvideDecoratedVariable; + public get count1(): string | undefined { + return this.__backing_count1!.get(); + } + public set count1(value: string | undefined) { + this.__backing_count1!.set(value); + } + private __backing_count2?: ProvideDecoratedVariable; + public get count2(): string | undefined { + return this.__backing_count2!.get(); + } + public set count2(value: string | undefined) { + this.__backing_count2!.set(value); + } + private __backing_count3?: ProvideDecoratedVariable; + public get count3(): string | undefined { + return this.__backing_count3!.get(); + } + public set count3(value: string | undefined) { + this.__backing_count3!.set(value); + } + private __backing_count4?: ProvideDecoratedVariable; + public get count4(): string | undefined { + return this.__backing_count4!.get(); + } + public set count4(value: string | undefined) { + this.__backing_count4!.set(value); + } + private __backing_count5?: ProvideDecoratedVariable; + public get count5(): string | undefined { + return this.__backing_count5!.get(); + } + public set count5(value: string | undefined) { + this.__backing_count5!.set(value); + } + private __backing_count6?: ProvideDecoratedVariable; + public get count6(): string | undefined { + return this.__backing_count6!.get(); + } + public set count6(value: string | undefined) { + this.__backing_count6!.set(value); + } + private __backing_count7?: ProvideDecoratedVariable; + public get count7(): string | undefined { + return this.__backing_count7!.get(); + } + public set count7(value: string | undefined) { + this.__backing_count7!.set(value); + } + @memo() public _build(@memo() style: ((instance: Ancestors)=> Ancestors) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Ancestors | undefined): void {} + public constructor() {} +} + +interface __Options_Ancestors { + set count(count: string | undefined | undefined) + get count(): string | undefined | undefined + set __backing_count(__backing_count: ProvideDecoratedVariable | undefined) + get __backing_count(): ProvideDecoratedVariable | undefined + set count1(count1: string | undefined | undefined) + get count1(): string | undefined | undefined + set __backing_count1(__backing_count1: ProvideDecoratedVariable | undefined) + get __backing_count1(): ProvideDecoratedVariable | undefined + set count2(count2: string | undefined | undefined) + get count2(): string | undefined | undefined + set __backing_count2(__backing_count2: ProvideDecoratedVariable | undefined) + get __backing_count2(): ProvideDecoratedVariable | undefined + set count3(count3: string | undefined | undefined) + get count3(): string | undefined | undefined + set __backing_count3(__backing_count3: ProvideDecoratedVariable | undefined) + get __backing_count3(): ProvideDecoratedVariable | undefined + set count4(count4: string | undefined | undefined) + get count4(): string | undefined | undefined + set __backing_count4(__backing_count4: ProvideDecoratedVariable | undefined) + get __backing_count4(): ProvideDecoratedVariable | undefined + set count5(count5: string | undefined | undefined) + get count5(): string | undefined | undefined + set __backing_count5(__backing_count5: ProvideDecoratedVariable | undefined) + get __backing_count5(): ProvideDecoratedVariable | undefined + set count6(count6: string | undefined | undefined) + get count6(): string | undefined | undefined + set __backing_count6(__backing_count6: ProvideDecoratedVariable | undefined) + get __backing_count6(): ProvideDecoratedVariable | undefined + set count7(count7: string | undefined | undefined) + get count7(): string | undefined | undefined + set __backing_count7(__backing_count7: ProvideDecoratedVariable | undefined) + get __backing_count7(): ProvideDecoratedVariable | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test different @Provide annotation usage transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/provide-and-consume/provide-basic-type.test.ts b/ets1.2/tests_ui/decorators/provide-and-consume/provide-basic-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..dffbb429f3593481a71463a651ede773270191d5 --- /dev/null +++ b/ets1.2/tests_ui/decorators/provide-and-consume/provide-basic-type.test.ts @@ -0,0 +1,140 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/provide-and-consume'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'provide-basic-type.ets'), +]; + +const pluginTester = new PluginTester('test basic type @Provide decorated variables transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'provide-basic-type', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { ProvideDecoratedVariable as ProvideDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { Provide as Provide } from "@ohos.arkui.stateManagement"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class PropParent extends CustomComponent { + public __initializeStruct(initializers: __Options_PropParent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_provideVar1 = this.addProvidedVar("provideVar1", "provideVar1", ((({let gensym___181030638 = initializers; + (((gensym___181030638) == (null)) ? undefined : gensym___181030638.provideVar1)})) ?? ("propVar1")), false); + this.__backing_provideVar2 = this.addProvidedVar("provideVar2", "provideVar2", ((({let gensym___143944235 = initializers; + (((gensym___143944235) == (null)) ? undefined : gensym___143944235.provideVar2)})) ?? (50)), false); + this.__backing_provideVar3 = this.addProvidedVar("provideVar3", "provideVar3", ((({let gensym___262195977 = initializers; + (((gensym___262195977) == (null)) ? undefined : gensym___262195977.provideVar3)})) ?? (true)), false); + this.__backing_provideVar4 = this.addProvidedVar("provideVar4", "provideVar4", ((({let gensym___85711435 = initializers; + (((gensym___85711435) == (null)) ? undefined : gensym___85711435.provideVar4)})) ?? (undefined)), false); + this.__backing_provideVar5 = this.addProvidedVar("provideVar5", "provideVar5", ((({let gensym___139253630 = initializers; + (((gensym___139253630) == (null)) ? undefined : gensym___139253630.provideVar5)})) ?? (null)), false); + } + public __updateStruct(initializers: __Options_PropParent | undefined): void {} + private __backing_provideVar1?: ProvideDecoratedVariable; + public get provideVar1(): string { + return this.__backing_provideVar1!.get(); + } + public set provideVar1(value: string) { + this.__backing_provideVar1!.set(value); + } + private __backing_provideVar2?: ProvideDecoratedVariable; + public get provideVar2(): number { + return this.__backing_provideVar2!.get(); + } + public set provideVar2(value: number) { + this.__backing_provideVar2!.set(value); + } + private __backing_provideVar3?: ProvideDecoratedVariable; + public get provideVar3(): boolean { + return this.__backing_provideVar3!.get(); + } + public set provideVar3(value: boolean) { + this.__backing_provideVar3!.set(value); + } + private __backing_provideVar4?: ProvideDecoratedVariable; + public get provideVar4(): undefined { + return this.__backing_provideVar4!.get(); + } + public set provideVar4(value: undefined) { + this.__backing_provideVar4!.set(value); + } + private __backing_provideVar5?: ProvideDecoratedVariable; + public get provideVar5(): null { + return this.__backing_provideVar5!.get(); + } + public set provideVar5(value: null) { + this.__backing_provideVar5!.set(value); + } + @memo() public _build(@memo() style: ((instance: PropParent)=> PropParent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_PropParent | undefined): void {} + public constructor() {} +} + +interface __Options_PropParent { + set provideVar1(provideVar1: string | undefined) + get provideVar1(): string | undefined + set __backing_provideVar1(__backing_provideVar1: ProvideDecoratedVariable | undefined) + get __backing_provideVar1(): ProvideDecoratedVariable | undefined + set provideVar2(provideVar2: number | undefined) + get provideVar2(): number | undefined + set __backing_provideVar2(__backing_provideVar2: ProvideDecoratedVariable | undefined) + get __backing_provideVar2(): ProvideDecoratedVariable | undefined + set provideVar3(provideVar3: boolean | undefined) + get provideVar3(): boolean | undefined + set __backing_provideVar3(__backing_provideVar3: ProvideDecoratedVariable | undefined) + get __backing_provideVar3(): ProvideDecoratedVariable | undefined + set provideVar4(provideVar4: undefined | undefined) + get provideVar4(): undefined | undefined + set __backing_provideVar4(__backing_provideVar4: ProvideDecoratedVariable | undefined) + get __backing_provideVar4(): ProvideDecoratedVariable | undefined + set provideVar5(provideVar5: null | undefined) + get provideVar5(): null | undefined + set __backing_provideVar5(__backing_provideVar5: ProvideDecoratedVariable | undefined) + get __backing_provideVar5(): ProvideDecoratedVariable | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test basic type @Provide decorated variables transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/provide-and-consume/provide-complex-type.test.ts b/ets1.2/tests_ui/decorators/provide-and-consume/provide-complex-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..6684a83fe1e9ce59451fe32b83243e045150e5c3 --- /dev/null +++ b/ets1.2/tests_ui/decorators/provide-and-consume/provide-complex-type.test.ts @@ -0,0 +1,288 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/provide-and-consume'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'provide-complex-type.ets'), +]; + +const pluginTester = new PluginTester('test complex type @Provide decorated variables transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'provide-complex-type', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { ProvideDecoratedVariable as ProvideDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { Provide as Provide } from "@ohos.arkui.stateManagement"; + +function main() {} + +class Per { + public num: number; + public constructor(num: number) { + this.num = num; + } +} + +final class PropType extends BaseEnum { + private readonly #ordinal: int; + private static () {} + public constructor(ordinal: int, value: int) { + super(value); + this.#ordinal = ordinal; + } + public static readonly TYPE1: PropType = new PropType(0, 0); + public static readonly TYPE2: PropType = new PropType(1, 1); + public static readonly TYPE3: PropType = new PropType(2, 3); + private static readonly #NamesArray: String[] = ["TYPE1", "TYPE2", "TYPE3"]; + private static readonly #ValuesArray: int[] = [0, 1, 3]; + private static readonly #StringValuesArray: String[] = ["0", "1", "3"]; + private static readonly #ItemsArray: PropType[] = [PropType.TYPE1, PropType.TYPE2, PropType.TYPE3]; + public getName(): String { + return PropType.#NamesArray[this.#ordinal]; + } + public static getValueOf(name: String): PropType { + for (let i = 0;((i) < (PropType.#NamesArray.length));(++i)) { + if (((name) == (PropType.#NamesArray[i]))) { + return PropType.#ItemsArray[i]; + } + } + throw new Error((("No enum constant PropType.") + (name))); + } + public static fromValue(value: int): PropType { + for (let i = 0;((i) < (PropType.#ValuesArray.length));(++i)) { + if (((value) == (PropType.#ValuesArray[i]))) { + return PropType.#ItemsArray[i]; + } + } + throw new Error((("No enum PropType with value ") + (value))); + } + public valueOf(): int { + return PropType.#ValuesArray[this.#ordinal]; + } + public toString(): String { + return PropType.#StringValuesArray[this.#ordinal]; + } + public static values(): PropType[] { + return PropType.#ItemsArray; + } + public getOrdinal(): int { + return this.#ordinal; + } + public static $_get(e: PropType): String { + return e.getName(); + } +} + +@Component({freezeWhenInactive:false}) final class Parent extends CustomComponent { + public __initializeStruct(initializers: __Options_Parent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_provideVar1 = this.addProvidedVar("provideVar1", "provideVar1", ((({let gensym___181030638 = initializers; + (((gensym___181030638) == (null)) ? undefined : gensym___181030638.provideVar1)})) ?? (new Per(6))), false); + this.__backing_provideVar2 = this.addProvidedVar>("provideVar2", "provideVar2", ((({let gensym___143944235 = initializers; + (((gensym___143944235) == (null)) ? undefined : gensym___143944235.provideVar2)})) ?? (new Array(3, 6, 8))), false); + this.__backing_provideVar3 = this.addProvidedVar("provideVar3", "provideVar3", ((({let gensym___262195977 = initializers; + (((gensym___262195977) == (null)) ? undefined : gensym___262195977.provideVar3)})) ?? (PropType.TYPE3)), false); + this.__backing_provideVar4 = this.addProvidedVar>("provideVar4", "provideVar4", ((({let gensym___85711435 = initializers; + (((gensym___85711435) == (null)) ? undefined : gensym___85711435.provideVar4)})) ?? (new Set(new Array("aa", "bb")))), false); + this.__backing_provideVar5 = this.addProvidedVar>("provideVar5", "provideVar5", ((({let gensym___139253630 = initializers; + (((gensym___139253630) == (null)) ? undefined : gensym___139253630.provideVar5)})) ?? ([true, false])), false); + this.__backing_provideVar6 = this.addProvidedVar>("provideVar6", "provideVar6", ((({let gensym___146872112 = initializers; + (((gensym___146872112) == (null)) ? undefined : gensym___146872112.provideVar6)})) ?? (new Array(new Per(7), new Per(11)))), false); + this.__backing_provideVar7 = this.addProvidedVar>("provideVar7", "provideVar7", ((({let gensym___174412117 = initializers; + (((gensym___174412117) == (null)) ? undefined : gensym___174412117.provideVar7)})) ?? ([new Per(7), new Per(11)])), false); + this.__backing_provideVar8 = this.addProvidedVar<((sr: string)=> void)>("provideVar8", "provideVar8", ((({let gensym___253467853 = initializers; + (((gensym___253467853) == (null)) ? undefined : gensym___253467853.provideVar8)})) ?? (((sr: string) => {}))), false); + this.__backing_provideVar9 = this.addProvidedVar("provideVar9", "provideVar9", ((({let gensym___179115605 = initializers; + (((gensym___179115605) == (null)) ? undefined : gensym___179115605.provideVar9)})) ?? (new Date("2025-4-23"))), false); + this.__backing_provideVar10 = this.addProvidedVar>("provideVar10", "provideVar10", ((({let gensym___209671248 = initializers; + (((gensym___209671248) == (null)) ? undefined : gensym___209671248.provideVar10)})) ?? (new Map([[0, new Per(7)], [1, new Per(10)]]))), false); + this.__backing_provideVar11 = this.addProvidedVar("provideVar11", "provideVar11", ((({let gensym___150211849 = initializers; + (((gensym___150211849) == (null)) ? undefined : gensym___150211849.provideVar11)})) ?? (0.0)), false); + this.__backing_provideVar12 = this.addProvidedVar | Per>("provideVar12", "provideVar12", ((({let gensym___256025818 = initializers; + (((gensym___256025818) == (null)) ? undefined : gensym___256025818.provideVar12)})) ?? (new Per(6))), false); + } + public __updateStruct(initializers: __Options_Parent | undefined): void {} + private __backing_provideVar1?: ProvideDecoratedVariable; + public get provideVar1(): Per { + return this.__backing_provideVar1!.get(); + } + public set provideVar1(value: Per) { + this.__backing_provideVar1!.set(value); + } + private __backing_provideVar2?: ProvideDecoratedVariable>; + public get provideVar2(): Array { + return this.__backing_provideVar2!.get(); + } + public set provideVar2(value: Array) { + this.__backing_provideVar2!.set(value); + } + private __backing_provideVar3?: ProvideDecoratedVariable; + public get provideVar3(): PropType { + return this.__backing_provideVar3!.get(); + } + public set provideVar3(value: PropType) { + this.__backing_provideVar3!.set(value); + } + private __backing_provideVar4?: ProvideDecoratedVariable>; + public get provideVar4(): Set { + return this.__backing_provideVar4!.get(); + } + public set provideVar4(value: Set) { + this.__backing_provideVar4!.set(value); + } + private __backing_provideVar5?: ProvideDecoratedVariable>; + public get provideVar5(): Array { + return this.__backing_provideVar5!.get(); + } + public set provideVar5(value: Array) { + this.__backing_provideVar5!.set(value); + } + private __backing_provideVar6?: ProvideDecoratedVariable>; + public get provideVar6(): Array { + return this.__backing_provideVar6!.get(); + } + public set provideVar6(value: Array) { + this.__backing_provideVar6!.set(value); + } + private __backing_provideVar7?: ProvideDecoratedVariable>; + public get provideVar7(): Array { + return this.__backing_provideVar7!.get(); + } + public set provideVar7(value: Array) { + this.__backing_provideVar7!.set(value); + } + private __backing_provideVar8?: ProvideDecoratedVariable<((sr: string)=> void)>; + public get provideVar8(): ((sr: string)=> void) { + return this.__backing_provideVar8!.get(); + } + public set provideVar8(value: ((sr: string)=> void)) { + this.__backing_provideVar8!.set(value); + } + private __backing_provideVar9?: ProvideDecoratedVariable; + public get provideVar9(): Date { + return this.__backing_provideVar9!.get(); + } + public set provideVar9(value: Date) { + this.__backing_provideVar9!.set(value); + } + private __backing_provideVar10?: ProvideDecoratedVariable>; + public get provideVar10(): Map { + return this.__backing_provideVar10!.get(); + } + public set provideVar10(value: Map) { + this.__backing_provideVar10!.set(value); + } + private __backing_provideVar11?: ProvideDecoratedVariable; + public get provideVar11(): string | number { + return this.__backing_provideVar11!.get(); + } + public set provideVar11(value: string | number) { + this.__backing_provideVar11!.set(value); + } + private __backing_provideVar12?: ProvideDecoratedVariable | Per>; + public get provideVar12(): Set | Per { + return this.__backing_provideVar12!.get(); + } + public set provideVar12(value: Set | Per) { + this.__backing_provideVar12!.set(value); + } + @memo() public _build(@memo() style: ((instance: Parent)=> Parent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Parent | undefined): void {} + public constructor() {} +} + +interface __Options_Parent { + set provideVar1(provideVar1: Per | undefined) + get provideVar1(): Per | undefined + set __backing_provideVar1(__backing_provideVar1: ProvideDecoratedVariable | undefined) + get __backing_provideVar1(): ProvideDecoratedVariable | undefined + set provideVar2(provideVar2: Array | undefined) + get provideVar2(): Array | undefined + set __backing_provideVar2(__backing_provideVar2: ProvideDecoratedVariable> | undefined) + get __backing_provideVar2(): ProvideDecoratedVariable> | undefined + set provideVar3(provideVar3: PropType | undefined) + get provideVar3(): PropType | undefined + set __backing_provideVar3(__backing_provideVar3: ProvideDecoratedVariable | undefined) + get __backing_provideVar3(): ProvideDecoratedVariable | undefined + set provideVar4(provideVar4: Set | undefined) + get provideVar4(): Set | undefined + set __backing_provideVar4(__backing_provideVar4: ProvideDecoratedVariable> | undefined) + get __backing_provideVar4(): ProvideDecoratedVariable> | undefined + set provideVar5(provideVar5: Array | undefined) + get provideVar5(): Array | undefined + set __backing_provideVar5(__backing_provideVar5: ProvideDecoratedVariable> | undefined) + get __backing_provideVar5(): ProvideDecoratedVariable> | undefined + set provideVar6(provideVar6: Array | undefined) + get provideVar6(): Array | undefined + set __backing_provideVar6(__backing_provideVar6: ProvideDecoratedVariable> | undefined) + get __backing_provideVar6(): ProvideDecoratedVariable> | undefined + set provideVar7(provideVar7: Array | undefined) + get provideVar7(): Array | undefined + set __backing_provideVar7(__backing_provideVar7: ProvideDecoratedVariable> | undefined) + get __backing_provideVar7(): ProvideDecoratedVariable> | undefined + set provideVar8(provideVar8: ((sr: string)=> void) | undefined) + get provideVar8(): ((sr: string)=> void) | undefined + set __backing_provideVar8(__backing_provideVar8: ProvideDecoratedVariable<((sr: string)=> void)> | undefined) + get __backing_provideVar8(): ProvideDecoratedVariable<((sr: string)=> void)> | undefined + set provideVar9(provideVar9: Date | undefined) + get provideVar9(): Date | undefined + set __backing_provideVar9(__backing_provideVar9: ProvideDecoratedVariable | undefined) + get __backing_provideVar9(): ProvideDecoratedVariable | undefined + set provideVar10(provideVar10: Map | undefined) + get provideVar10(): Map | undefined + set __backing_provideVar10(__backing_provideVar10: ProvideDecoratedVariable> | undefined) + get __backing_provideVar10(): ProvideDecoratedVariable> | undefined + set provideVar11(provideVar11: string | number | undefined) + get provideVar11(): string | number | undefined + set __backing_provideVar11(__backing_provideVar11: ProvideDecoratedVariable | undefined) + get __backing_provideVar11(): ProvideDecoratedVariable | undefined + set provideVar12(provideVar12: Set | Per | undefined) + get provideVar12(): Set | Per | undefined + set __backing_provideVar12(__backing_provideVar12: ProvideDecoratedVariable | Per> | undefined) + get __backing_provideVar12(): ProvideDecoratedVariable | Per> | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test complex type @Provide decorated variables transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/resource/resource-in-build.test.ts b/ets1.2/tests_ui/decorators/resource/resource-in-build.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..ad9e6798bfc7ccefd79c5de649aa8965ae5e6969 --- /dev/null +++ b/ets1.2/tests_ui/decorators/resource/resource-in-build.test.ts @@ -0,0 +1,142 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/resource'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'resource-in-build.ets'), +]; + +const pluginTester = new PluginTester('test resource transform in build method', buildConfig); + +const parsedTransform: Plugins = { + name: 'resource-in-build', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { UIImageAnimatorAttribute as UIImageAnimatorAttribute } from "@ohos.arkui.component"; +import { UISelectAttribute as UISelectAttribute } from "@ohos.arkui.component"; +import { UITextInputAttribute as UITextInputAttribute } from "@ohos.arkui.component"; +import { UIImageAttribute as UIImageAttribute } from "@ohos.arkui.component"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { _rawfile as _rawfile } from "@ohos.arkui.component"; +import { _r as _r } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, $r as $r, $rawfile as $rawfile, Column as Column, Text as Text, Image as Image, TextInput as TextInput, Select as Select, SelectOption as SelectOption, Margin as Margin, ImageAnimator as ImageAnimator } from "@ohos.arkui.component"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class ResourceComponent extends CustomComponent { + public __initializeStruct(initializers: __Options_ResourceComponent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_str1 = ((({let gensym___147578113 = initializers; + (((gensym___147578113) == (null)) ? undefined : gensym___147578113.str1)})) ?? ("app.media.ri")); + this.__backing_str2 = ((({let gensym___220149772 = initializers; + (((gensym___220149772) == (null)) ? undefined : gensym___220149772.str2)})) ?? ("app.photo2.png")); + } + public __updateStruct(initializers: __Options_ResourceComponent | undefined): void {} + private __backing_str1?: string; + public get str1(): string { + return (this.__backing_str1 as string); + } + public set str1(value: string) { + this.__backing_str1 = value; + } + private __backing_str2?: string; + public get str2(): string { + return (this.__backing_str2 as string); + } + public set str2(value: string) { + this.__backing_str2 = value; + } + + @memo() public _build(@memo() style: ((instance: ResourceComponent)=> ResourceComponent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_ResourceComponent | undefined): void { + Column(undefined, undefined, (() => { + Text(undefined, _r("", "", "app.string.app_name"), undefined, undefined); + Image(undefined, _rawfile("", "", "app.photo.png"), undefined, undefined); + TextInput(undefined, { + text: _r("", "", "app.string.input_content"), + }, undefined); + Text(undefined, _r("", "", this.str1), undefined, undefined); + Text(undefined, _r("", "", this.str2), undefined, undefined); + Select(undefined, new Array({ + value: "aaa", + icon: _r("", "", "app.media.selection"), + }, { + value: "bbb", + icon: _r("", "", "app.media.selection"), + }, { + value: "ccc", + icon: _r("", "", "app.media.selection"), + }, { + value: "ddd", + icon: _r("", "", "app.media.selection"), + }), undefined); + Image(@memo() ((instance: UIImageAttribute): void => { + instance.margin(({ + top: _r("", "", "app.float.elements_margin_horizontal_m"), + bottom: _r("", "", "app.float.elements_margin_horizontal_l"), + } as Margin)); + return; + }), _r("", "", "app.media.app_icon"), undefined, undefined); + ImageAnimator(@memo() ((instance: UIImageAnimatorAttribute): void => { + instance.images([{ + src: _r("", "", "app.media.aaa"), + }, { + src: _r("", "", "app.media.bbb"), + }]); + return; + }), undefined); + })); + } + public constructor() {} +} + +interface __Options_ResourceComponent { + set str1(str1: string | undefined) + get str1(): string | undefined + set str2(str2: string | undefined) + get str2(): string | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test resource transform in build method', + [parsedTransform, uiNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/resource/resource-in-property.test.ts b/ets1.2/tests_ui/decorators/resource/resource-in-property.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..741751b9f990049cc0999c3afe3bfdbb0fb74d61 --- /dev/null +++ b/ets1.2/tests_ui/decorators/resource/resource-in-property.test.ts @@ -0,0 +1,108 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/resource'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'resource-in-property.ets'), +]; + +const pluginTester = new PluginTester('test resource transform in property', buildConfig); + +const parsedTransform: Plugins = { + name: 'resource-in-property', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { UIImageAttribute as UIImageAttribute } from "@ohos.arkui.component"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { _rawfile as _rawfile } from "@ohos.arkui.component"; +import { _r as _r } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, $r as $r, $rawfile as $rawfile, Column as Column, Text as Text, Image as Image, Resource as Resource } from "@ohos.arkui.component"; + +let i: Resource; +function main() {} +i = _r("", "", "app.string.app_name"); + +@Component({freezeWhenInactive:false}) final class ResourceComponent extends CustomComponent { + public __initializeStruct(initializers: __Options_ResourceComponent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_str = ((({let gensym___42103502 = initializers; + (((gensym___42103502) == (null)) ? undefined : gensym___42103502.str)})) ?? (_r("", "", "app.string.app_name"))); + this.__backing_icon = ((({let gensym___38135554 = initializers; + (((gensym___38135554) == (null)) ? undefined : gensym___38135554.icon)})) ?? (_rawfile("", "", "app.photo.png"))); + } + public __updateStruct(initializers: __Options_ResourceComponent | undefined): void {} + private __backing_str?: Resource; + public get str(): Resource { + return (this.__backing_str as Resource); + } + public set str(value: Resource) { + this.__backing_str = value; + } + private __backing_icon?: Resource; + public get icon(): Resource { + return (this.__backing_icon as Resource); + } + public set icon(value: Resource) { + this.__backing_icon = value; + } + @memo() public _build(@memo() style: ((instance: ResourceComponent)=> ResourceComponent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_ResourceComponent | undefined): void { + Column(undefined, undefined, (() => { + Text(undefined, this.str, undefined, undefined); + Text(undefined, i, undefined, undefined); + Image(undefined, this.icon, undefined, undefined); + })); + } + public constructor() {} +} + +interface __Options_ResourceComponent { + set str(str: Resource | undefined) + get str(): Resource | undefined + set icon(icon: Resource | undefined) + get icon(): Resource | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test resource transform in property', + [parsedTransform, uiNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/reusable/reusable-basic.test.ts b/ets1.2/tests_ui/decorators/reusable/reusable-basic.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..0589b25abf0770ba560c8f64696ec51e428e9836 --- /dev/null +++ b/ets1.2/tests_ui/decorators/reusable/reusable-basic.test.ts @@ -0,0 +1,159 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const REUSABLE_DIR_PATH: string = 'decorators/reusable'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, REUSABLE_DIR_PATH, 'reusable-basic.ets'), +]; + +const reusableTransform: Plugins = { + name: 'reusable', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test basic reusable', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { DecoratedV1VariableBase as DecoratedV1VariableBase } from "@ohos.arkui.stateManagement"; + +import { LinkDecoratedVariable as LinkDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Reusable as Reusable } from "@ohos.arkui.component"; + +import { State as State, Link as Link } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +@Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void { + Child._instantiateImpl(undefined, (() => { + return new Child(); + }), ({ + num: 5, + } as __Options_Child), undefined, "Child"); + } + + public constructor() {} + +} + +@Component({freezeWhenInactive:false}) @Reusable() final class Child extends CustomComponent { + public __initializeStruct(initializers: __Options_Child | undefined, @memo() content: (()=> void) | undefined): void { + if (({let gensym___98468840 = initializers; + (((gensym___98468840) == (null)) ? undefined : gensym___98468840.__backing_num)})) { + this.__backing_num = new LinkDecoratedVariable("num", initializers!.__backing_num!); + }; + this.__backing_num1 = new StateDecoratedVariable("num1", ((({let gensym___33833641 = initializers; + (((gensym___33833641) == (null)) ? undefined : gensym___33833641.num1)})) ?? (2))); + } + + public __updateStruct(initializers: __Options_Child | undefined): void {} + + public override __toRecord(params: Object): Record { + const paramsCasted = (params as __Options_Child); + return { + "num": ((paramsCasted.num) ?? (new Object())), + "num1": ((paramsCasted.num1) ?? (new Object())), + }; + } + + private __backing_num?: LinkDecoratedVariable; + + public get num(): number { + return this.__backing_num!.get(); + } + + public set num(value: number) { + this.__backing_num!.set(value); + } + + private __backing_num1?: StateDecoratedVariable; + + public get num1(): number { + return this.__backing_num1!.get(); + } + + public set num1(value: number) { + this.__backing_num1!.set(value); + } + + @memo() public _build(@memo() style: ((instance: Child)=> Child) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Child | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + +} + +interface __Options_Child { + set num(num: number | undefined) + + get num(): number | undefined + set __backing_num(__backing_num: DecoratedV1VariableBase | undefined) + + get __backing_num(): DecoratedV1VariableBase | undefined + set num1(num1: number | undefined) + + get num1(): number | undefined + set __backing_num1(__backing_num1: StateDecoratedVariable | undefined) + + get __backing_num1(): StateDecoratedVariable | undefined + +} +`; + +function testReusableTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test basic reusable', + [reusableTransform, uiNoRecheck], + { + checked: [testReusableTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/reusable/reusable-complex.test.ts b/ets1.2/tests_ui/decorators/reusable/reusable-complex.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..873738ced9f080079d9a4a5cb4e461ebb57f6f94 --- /dev/null +++ b/ets1.2/tests_ui/decorators/reusable/reusable-complex.test.ts @@ -0,0 +1,209 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const REUSABLE_DIR_PATH: string = 'decorators/reusable'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, REUSABLE_DIR_PATH, 'reusable-complex.ets'), +]; + +const reusableTransform: Plugins = { + name: 'reusable', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test complex reusable', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { UIButtonAttribute as UIButtonAttribute } from "@ohos.arkui.component"; + +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; + +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry, Reusable as Reusable, Column as Column, Text as Text, Button as Button, ClickEvent as ClickEvent, FontWeight as FontWeight } from "@ohos.arkui.component"; + +import { State as State } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +class Message { + public value: string | undefined; + + public constructor(value: string) { + this.value = value; + } + +} + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class Index extends CustomComponent { + public __initializeStruct(initializers: __Options_Index | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_display = new StateDecoratedVariable("display", ((({let gensym___83835842 = initializers; + (((gensym___83835842) == (null)) ? undefined : gensym___83835842.display)})) ?? (true))); + } + + public __updateStruct(initializers: __Options_Index | undefined): void {} + + private __backing_display?: StateDecoratedVariable; + + public get display(): boolean { + return this.__backing_display!.get(); + } + + public set display(value: boolean) { + this.__backing_display!.set(value); + } + + @memo() public _build(@memo() style: ((instance: Index)=> Index) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Index | undefined): void { + Column(@memo() ((instance: UIColumnAttribute): void => { + instance.height("100%").width("100%"); + return; + }), undefined, (() => { + Button(@memo() ((instance: UIButtonAttribute): void => { + instance.fontSize(30).fontWeight(FontWeight.Bold).onClick(((e: ClickEvent) => { + this.display = !(this.display); + })); + return; + }), "Hello", undefined, undefined); + if (this.display) { + Child._instantiateImpl(undefined, (() => { + return new Child(); + }), ({ + message: new Message("Child"), + } as __Options_Child), undefined, "Child"); + } + })); + } + + public constructor() {} + +} + +@Reusable() @Component({freezeWhenInactive:false}) final class Child extends CustomComponent { + public __initializeStruct(initializers: __Options_Child | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_message = new StateDecoratedVariable("message", ((({let gensym___91869411 = initializers; + (((gensym___91869411) == (null)) ? undefined : gensym___91869411.message)})) ?? (new Message("AboutToReuse")))); + } + + public __updateStruct(initializers: __Options_Child | undefined): void {} + + public override __toRecord(params: Object): Record { + const paramsCasted = (params as __Options_Child); + return { + "message": ((paramsCasted.message) ?? (new Object())), + }; + } + + private __backing_message?: StateDecoratedVariable; + + public get message(): Message { + return this.__backing_message!.get(); + } + + public set message(value: Message) { + this.__backing_message!.set(value); + } + + public aboutToReuse(params: Record) { + console.info("Recycle ====Child=="); + } + + @memo() public _build(@memo() style: ((instance: Child)=> Child) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Child | undefined): void { + Column(@memo() ((instance: UIColumnAttribute): void => { + instance.borderWidth(1).height(100); + return; + }), undefined, (() => { + Text(@memo() ((instance: UITextAttribute): void => { + instance.fontSize(30); + return; + }), this.message.value, undefined, undefined); + })); + } + + public constructor() {} + +} + +interface __Options_Index { + set display(display: boolean | undefined) + + get display(): boolean | undefined + set __backing_display(__backing_display: StateDecoratedVariable | undefined) + + get __backing_display(): StateDecoratedVariable | undefined + +} + +interface __Options_Child { + set message(message: Message | undefined) + + get message(): Message | undefined + set __backing_message(__backing_message: StateDecoratedVariable | undefined) + + get __backing_message(): StateDecoratedVariable | undefined + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + Index._instantiateImpl(undefined, (() => { + return new Index(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} + +`; + +function testReusableTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test complex reusable', + [reusableTransform, uiNoRecheck], + { + checked: [testReusableTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/state/state-basic-type.test.ts b/ets1.2/tests_ui/decorators/state/state-basic-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..96d03ea4bf7ee85d2432a1a0864d36e4d7268084 --- /dev/null +++ b/ets1.2/tests_ui/decorators/state/state-basic-type.test.ts @@ -0,0 +1,140 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/state'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'state-basic-type.ets'), +]; + +const pluginTester = new PluginTester('test basic type @State decorated variables transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'state-basic-type', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { State as State } from "@ohos.arkui.stateManagement"; + +function main() {} + +@Component({freezeWhenInactive:false}) final class Parent extends CustomComponent { + public __initializeStruct(initializers: __Options_Parent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_stateVar1 = new StateDecoratedVariable("stateVar1", ((({let gensym___213853607 = initializers; + (((gensym___213853607) == (null)) ? undefined : gensym___213853607.stateVar1)})) ?? ("stateVar1"))); + this.__backing_stateVar2 = new StateDecoratedVariable("stateVar2", ((({let gensym___113574154 = initializers; + (((gensym___113574154) == (null)) ? undefined : gensym___113574154.stateVar2)})) ?? (50))); + this.__backing_stateVar3 = new StateDecoratedVariable("stateVar3", ((({let gensym___166994972 = initializers; + (((gensym___166994972) == (null)) ? undefined : gensym___166994972.stateVar3)})) ?? (true))); + this.__backing_stateVar4 = new StateDecoratedVariable("stateVar4", ((({let gensym___148024261 = initializers; + (((gensym___148024261) == (null)) ? undefined : gensym___148024261.stateVar4)})) ?? (undefined))); + this.__backing_stateVar5 = new StateDecoratedVariable("stateVar5", ((({let gensym___99384342 = initializers; + (((gensym___99384342) == (null)) ? undefined : gensym___99384342.stateVar5)})) ?? (null))); + } + public __updateStruct(initializers: __Options_Parent | undefined): void {} + private __backing_stateVar1?: StateDecoratedVariable; + public get stateVar1(): string { + return this.__backing_stateVar1!.get(); + } + public set stateVar1(value: string) { + this.__backing_stateVar1!.set(value); + } + private __backing_stateVar2?: StateDecoratedVariable; + public get stateVar2(): number { + return this.__backing_stateVar2!.get(); + } + public set stateVar2(value: number) { + this.__backing_stateVar2!.set(value); + } + private __backing_stateVar3?: StateDecoratedVariable; + public get stateVar3(): boolean { + return this.__backing_stateVar3!.get(); + } + public set stateVar3(value: boolean) { + this.__backing_stateVar3!.set(value); + } + private __backing_stateVar4?: StateDecoratedVariable; + public get stateVar4(): undefined { + return this.__backing_stateVar4!.get(); + } + public set stateVar4(value: undefined) { + this.__backing_stateVar4!.set(value); + } + private __backing_stateVar5?: StateDecoratedVariable; + public get stateVar5(): null { + return this.__backing_stateVar5!.get(); + } + public set stateVar5(value: null) { + this.__backing_stateVar5!.set(value); + } + @memo() public _build(@memo() style: ((instance: Parent)=> Parent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Parent | undefined): void {} + public constructor() {} +} + +interface __Options_Parent { + set stateVar1(stateVar1: string | undefined) + get stateVar1(): string | undefined + set __backing_stateVar1(__backing_stateVar1: StateDecoratedVariable | undefined) + get __backing_stateVar1(): StateDecoratedVariable | undefined + set stateVar2(stateVar2: number | undefined) + get stateVar2(): number | undefined + set __backing_stateVar2(__backing_stateVar2: StateDecoratedVariable | undefined) + get __backing_stateVar2(): StateDecoratedVariable | undefined + set stateVar3(stateVar3: boolean | undefined) + get stateVar3(): boolean | undefined + set __backing_stateVar3(__backing_stateVar3: StateDecoratedVariable | undefined) + get __backing_stateVar3(): StateDecoratedVariable | undefined + set stateVar4(stateVar4: undefined | undefined) + get stateVar4(): undefined | undefined + set __backing_stateVar4(__backing_stateVar4: StateDecoratedVariable | undefined) + get __backing_stateVar4(): StateDecoratedVariable | undefined + set stateVar5(stateVar5: null | undefined) + get stateVar5(): null | undefined + set __backing_stateVar5(__backing_stateVar5: StateDecoratedVariable | undefined) + get __backing_stateVar5(): StateDecoratedVariable | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test basic type @State decorated variables transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/state/state-complex-type.test.ts b/ets1.2/tests_ui/decorators/state/state-complex-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..e42e3400622c079e69f6b69147b05dad2c0483d6 --- /dev/null +++ b/ets1.2/tests_ui/decorators/state/state-complex-type.test.ts @@ -0,0 +1,288 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { structNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/state'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'state-complex-type.ets'), +]; + +const pluginTester = new PluginTester('test complex type @State decorated variables transformation', buildConfig); + +const parsedTransform: Plugins = { + name: 'state-complex-type', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component } from "@ohos.arkui.component"; +import { State as State } from "@ohos.arkui.stateManagement"; + +function main() {} + +class Per { + public num: number; + public constructor(num: number) { + this.num = num; + } +} + +final class StateType extends BaseEnum { + private readonly #ordinal: int; + private static () {} + public constructor(ordinal: int, value: int) { + super(value); + this.#ordinal = ordinal; + } + public static readonly TYPE1: StateType = new StateType(0, 0); + public static readonly TYPE2: StateType = new StateType(1, 1); + public static readonly TYPE3: StateType = new StateType(2, 3); + private static readonly #NamesArray: String[] = ["TYPE1", "TYPE2", "TYPE3"]; + private static readonly #ValuesArray: int[] = [0, 1, 3]; + private static readonly #StringValuesArray: String[] = ["0", "1", "3"]; + private static readonly #ItemsArray: StateType[] = [StateType.TYPE1, StateType.TYPE2, StateType.TYPE3]; + public getName(): String { + return StateType.#NamesArray[this.#ordinal]; + } + public static getValueOf(name: String): StateType { + for (let i = 0;((i) < (StateType.#NamesArray.length));(++i)) { + if (((name) == (StateType.#NamesArray[i]))) { + return StateType.#ItemsArray[i]; + } + } + throw new Error((("No enum constant StateType.") + (name))); + } + public static fromValue(value: int): StateType { + for (let i = 0;((i) < (StateType.#ValuesArray.length));(++i)) { + if (((value) == (StateType.#ValuesArray[i]))) { + return StateType.#ItemsArray[i]; + } + } + throw new Error((("No enum StateType with value ") + (value))); + } + public valueOf(): int { + return StateType.#ValuesArray[this.#ordinal]; + } + public toString(): String { + return StateType.#StringValuesArray[this.#ordinal]; + } + public static values(): StateType[] { + return StateType.#ItemsArray; + } + public getOrdinal(): int { + return this.#ordinal; + } + public static $_get(e: StateType): String { + return e.getName(); + } +} + +@Component({freezeWhenInactive:false}) final class Parent extends CustomComponent { + public __initializeStruct(initializers: __Options_Parent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_stateVar1 = new StateDecoratedVariable("stateVar1", ((({let gensym___213853607 = initializers; + (((gensym___213853607) == (null)) ? undefined : gensym___213853607.stateVar1)})) ?? (new Per(6)))); + this.__backing_stateVar2 = new StateDecoratedVariable>("stateVar2", ((({let gensym___113574154 = initializers; + (((gensym___113574154) == (null)) ? undefined : gensym___113574154.stateVar2)})) ?? (new Array(3, 6, 8)))); + this.__backing_stateVar3 = new StateDecoratedVariable("stateVar3", ((({let gensym___166994972 = initializers; + (((gensym___166994972) == (null)) ? undefined : gensym___166994972.stateVar3)})) ?? (StateType.TYPE3))); + this.__backing_stateVar4 = new StateDecoratedVariable>("stateVar4", ((({let gensym___148024261 = initializers; + (((gensym___148024261) == (null)) ? undefined : gensym___148024261.stateVar4)})) ?? (new Set(new Array("aa", "bb"))))); + this.__backing_stateVar5 = new StateDecoratedVariable>("stateVar5", ((({let gensym___99384342 = initializers; + (((gensym___99384342) == (null)) ? undefined : gensym___99384342.stateVar5)})) ?? ([true, false]))); + this.__backing_stateVar6 = new StateDecoratedVariable>("stateVar6", ((({let gensym___133364871 = initializers; + (((gensym___133364871) == (null)) ? undefined : gensym___133364871.stateVar6)})) ?? (new Array(new Per(7), new Per(11))))); + this.__backing_stateVar7 = new StateDecoratedVariable>("stateVar7", ((({let gensym___69403028 = initializers; + (((gensym___69403028) == (null)) ? undefined : gensym___69403028.stateVar7)})) ?? ([new Per(7), new Per(11)]))); + this.__backing_stateVar8 = new StateDecoratedVariable<((sr: string)=> void)>("stateVar8", ((({let gensym___219403122 = initializers; + (((gensym___219403122) == (null)) ? undefined : gensym___219403122.stateVar8)})) ?? (((sr: string) => {})))); + this.__backing_stateVar9 = new StateDecoratedVariable("stateVar9", ((({let gensym___171171899 = initializers; + (((gensym___171171899) == (null)) ? undefined : gensym___171171899.stateVar9)})) ?? (new Date("2025-4-23")))); + this.__backing_stateVar10 = new StateDecoratedVariable>("stateVar10", ((({let gensym___91651348 = initializers; + (((gensym___91651348) == (null)) ? undefined : gensym___91651348.stateVar10)})) ?? (new Map([[0, new Per(7)], [1, new Per(10)]])))); + this.__backing_stateVar11 = new StateDecoratedVariable("stateVar11", ((({let gensym___56045278 = initializers; + (((gensym___56045278) == (null)) ? undefined : gensym___56045278.stateVar11)})) ?? (0.0))); + this.__backing_stateVar12 = new StateDecoratedVariable | Per>("stateVar12", ((({let gensym___164759887 = initializers; + (((gensym___164759887) == (null)) ? undefined : gensym___164759887.stateVar12)})) ?? (new Per(6)))); + } + public __updateStruct(initializers: __Options_Parent | undefined): void {} + private __backing_stateVar1?: StateDecoratedVariable; + public get stateVar1(): Per { + return this.__backing_stateVar1!.get(); + } + public set stateVar1(value: Per) { + this.__backing_stateVar1!.set(value); + } + private __backing_stateVar2?: StateDecoratedVariable>; + public get stateVar2(): Array { + return this.__backing_stateVar2!.get(); + } + public set stateVar2(value: Array) { + this.__backing_stateVar2!.set(value); + } + private __backing_stateVar3?: StateDecoratedVariable; + public get stateVar3(): StateType { + return this.__backing_stateVar3!.get(); + } + public set stateVar3(value: StateType) { + this.__backing_stateVar3!.set(value); + } + private __backing_stateVar4?: StateDecoratedVariable>; + public get stateVar4(): Set { + return this.__backing_stateVar4!.get(); + } + public set stateVar4(value: Set) { + this.__backing_stateVar4!.set(value); + } + private __backing_stateVar5?: StateDecoratedVariable>; + public get stateVar5(): Array { + return this.__backing_stateVar5!.get(); + } + public set stateVar5(value: Array) { + this.__backing_stateVar5!.set(value); + } + private __backing_stateVar6?: StateDecoratedVariable>; + public get stateVar6(): Array { + return this.__backing_stateVar6!.get(); + } + public set stateVar6(value: Array) { + this.__backing_stateVar6!.set(value); + } + private __backing_stateVar7?: StateDecoratedVariable>; + public get stateVar7(): Array { + return this.__backing_stateVar7!.get(); + } + public set stateVar7(value: Array) { + this.__backing_stateVar7!.set(value); + } + private __backing_stateVar8?: StateDecoratedVariable<((sr: string)=> void)>; + public get stateVar8(): ((sr: string)=> void) { + return this.__backing_stateVar8!.get(); + } + public set stateVar8(value: ((sr: string)=> void)) { + this.__backing_stateVar8!.set(value); + } + private __backing_stateVar9?: StateDecoratedVariable; + public get stateVar9(): Date { + return this.__backing_stateVar9!.get(); + } + public set stateVar9(value: Date) { + this.__backing_stateVar9!.set(value); + } + private __backing_stateVar10?: StateDecoratedVariable>; + public get stateVar10(): Map { + return this.__backing_stateVar10!.get(); + } + public set stateVar10(value: Map) { + this.__backing_stateVar10!.set(value); + } + private __backing_stateVar11?: StateDecoratedVariable; + public get stateVar11(): string | number { + return this.__backing_stateVar11!.get(); + } + public set stateVar11(value: string | number) { + this.__backing_stateVar11!.set(value); + } + private __backing_stateVar12?: StateDecoratedVariable | Per>; + public get stateVar12(): Set | Per { + return this.__backing_stateVar12!.get(); + } + public set stateVar12(value: Set | Per) { + this.__backing_stateVar12!.set(value); + } + @memo() public _build(@memo() style: ((instance: Parent)=> Parent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Parent | undefined): void {} + public constructor() {} +} + +interface __Options_Parent { + set stateVar1(stateVar1: Per | undefined) + get stateVar1(): Per | undefined + set __backing_stateVar1(__backing_stateVar1: StateDecoratedVariable | undefined) + get __backing_stateVar1(): StateDecoratedVariable | undefined + set stateVar2(stateVar2: Array | undefined) + get stateVar2(): Array | undefined + set __backing_stateVar2(__backing_stateVar2: StateDecoratedVariable> | undefined) + get __backing_stateVar2(): StateDecoratedVariable> | undefined + set stateVar3(stateVar3: StateType | undefined) + get stateVar3(): StateType | undefined + set __backing_stateVar3(__backing_stateVar3: StateDecoratedVariable | undefined) + get __backing_stateVar3(): StateDecoratedVariable | undefined + set stateVar4(stateVar4: Set | undefined) + get stateVar4(): Set | undefined + set __backing_stateVar4(__backing_stateVar4: StateDecoratedVariable> | undefined) + get __backing_stateVar4(): StateDecoratedVariable> | undefined + set stateVar5(stateVar5: Array | undefined) + get stateVar5(): Array | undefined + set __backing_stateVar5(__backing_stateVar5: StateDecoratedVariable> | undefined) + get __backing_stateVar5(): StateDecoratedVariable> | undefined + set stateVar6(stateVar6: Array | undefined) + get stateVar6(): Array | undefined + set __backing_stateVar6(__backing_stateVar6: StateDecoratedVariable> | undefined) + get __backing_stateVar6(): StateDecoratedVariable> | undefined + set stateVar7(stateVar7: Array | undefined) + get stateVar7(): Array | undefined + set __backing_stateVar7(__backing_stateVar7: StateDecoratedVariable> | undefined) + get __backing_stateVar7(): StateDecoratedVariable> | undefined + set stateVar8(stateVar8: ((sr: string)=> void) | undefined) + get stateVar8(): ((sr: string)=> void) | undefined + set __backing_stateVar8(__backing_stateVar8: StateDecoratedVariable<((sr: string)=> void)> | undefined) + get __backing_stateVar8(): StateDecoratedVariable<((sr: string)=> void)> | undefined + set stateVar9(stateVar9: Date | undefined) + get stateVar9(): Date | undefined + set __backing_stateVar9(__backing_stateVar9: StateDecoratedVariable | undefined) + get __backing_stateVar9(): StateDecoratedVariable | undefined + set stateVar10(stateVar10: Map | undefined) + get stateVar10(): Map | undefined + set __backing_stateVar10(__backing_stateVar10: StateDecoratedVariable> | undefined) + get __backing_stateVar10(): StateDecoratedVariable> | undefined + set stateVar11(stateVar11: string | number | undefined) + get stateVar11(): string | number | undefined + set __backing_stateVar11(__backing_stateVar11: StateDecoratedVariable | undefined) + get __backing_stateVar11(): StateDecoratedVariable | undefined + set stateVar12(stateVar12: Set | Per | undefined) + get stateVar12(): Set | Per | undefined + set __backing_stateVar12(__backing_stateVar12: StateDecoratedVariable | Per> | undefined) + get __backing_stateVar12(): StateDecoratedVariable | Per> | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test complex type @State decorated variables transformation', + [parsedTransform, structNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/state/state-to-state.test.ts b/ets1.2/tests_ui/decorators/state/state-to-state.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..52a438991ebe2faf37081d983e01c4e88afff32c --- /dev/null +++ b/ets1.2/tests_ui/decorators/state/state-to-state.test.ts @@ -0,0 +1,132 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const BUILDER_LAMBDA_DIR_PATH: string = 'decorators/state'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, BUILDER_LAMBDA_DIR_PATH, 'state-to-state.ets'), +]; + +const pluginTester = new PluginTester('test @State decorated variables passing', buildConfig); + +const parsedTransform: Plugins = { + name: 'state-to-state', + parsed: uiTransform().parsed +}; + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; +import { memo as memo } from "arkui.stateManagement.runtime"; +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; +import { Component as Component, Column as Column, Text as Text } from "@ohos.arkui.component"; +import { State as State } from "@ohos.arkui.stateManagement"; + +function main() {} + +class Per { + public str: string; + public constructor(str: string) { + this.str = str; + } +} + +@Component({freezeWhenInactive:false}) final class Parent extends CustomComponent { + public __initializeStruct(initializers: __Options_Parent | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_parentVar1 = new StateDecoratedVariable("parentVar1", ((({let gensym___247315634 = initializers; + (((gensym___247315634) == (null)) ? undefined : gensym___247315634.parentVar1)})) ?? (new Per("hello")))); + } + public __updateStruct(initializers: __Options_Parent | undefined): void {} + private __backing_parentVar1?: StateDecoratedVariable; + public get parentVar1(): Per { + return this.__backing_parentVar1!.get(); + } + public set parentVar1(value: Per) { + this.__backing_parentVar1!.set(value); + } + @memo() public _build(@memo() style: ((instance: Parent)=> Parent) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Parent | undefined): void { + Column(undefined, undefined, (() => { + Child._instantiateImpl(undefined, (() => { + return new Child(); + }), ({ + childVar1: this.parentVar1, + } as __Options_Child), undefined, undefined); + })); + } + public constructor() {} +} + +@Component({freezeWhenInactive:false}) final class Child extends CustomComponent { + public __initializeStruct(initializers: __Options_Child | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_childVar1 = new StateDecoratedVariable("childVar1", ((({let gensym___218939886 = initializers; + (((gensym___218939886) == (null)) ? undefined : gensym___218939886.childVar1)})) ?? (new Per("ccc")))); + } + public __updateStruct(initializers: __Options_Child | undefined): void {} + private __backing_childVar1?: StateDecoratedVariable; + public get childVar1(): Per { + return this.__backing_childVar1!.get(); + } + public set childVar1(value: Per) { + this.__backing_childVar1!.set(value); + } + @memo() public _build(@memo() style: ((instance: Child)=> Child) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Child | undefined): void { + Text(undefined, this.childVar1.str, undefined, undefined); + } + public constructor() {} + +} + +interface __Options_Parent { + set parentVar1(parentVar1: Per | undefined) + get parentVar1(): Per | undefined + set __backing_parentVar1(__backing_parentVar1: StateDecoratedVariable | undefined) + get __backing_parentVar1(): StateDecoratedVariable | undefined +} + +interface __Options_Child { + set childVar1(childVar1: Per | undefined) + get childVar1(): Per | undefined + set __backing_childVar1(__backing_childVar1: StateDecoratedVariable | undefined) + get __backing_childVar1(): StateDecoratedVariable | undefined +} +`; + +function testParsedAndCheckedTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test @State decorated variables passing', + [parsedTransform, uiNoRecheck], + { + checked: [testParsedAndCheckedTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/storagelink/storagelink-appstorage.test.ts b/ets1.2/tests_ui/decorators/storagelink/storagelink-appstorage.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..7f4460286083061c950d56618195e60c28aeac00 --- /dev/null +++ b/ets1.2/tests_ui/decorators/storagelink/storagelink-appstorage.test.ts @@ -0,0 +1,164 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const STORAGELINK_DIR_PATH: string = 'decorators/storagelink'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, STORAGELINK_DIR_PATH, 'storagelink-appstorage.ets'), +]; + +const storageLinkTransform: Plugins = { + name: 'storageLink', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test storagelink with appstorage', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { StorageLinkDecoratedVariable as StorageLinkDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; + +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry, Column as Column, Text as Text, ClickEvent as ClickEvent } from "@ohos.arkui.component"; + +import { StorageLink as StorageLink, AppStorage as AppStorage } from "@ohos.arkui.stateManagement"; + +function main() {} + +AppStorage.setOrCreate("PropA", 47); +AppStorage.setOrCreate("PropB", new Data(50)); + +class Data { + public code: number; + + public constructor(code: number) { + this.code = code; + } + +} + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class Index extends CustomComponent { + public __initializeStruct(initializers: __Options_Index | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_storageLink = new StorageLinkDecoratedVariable("PropA", "storageLink", 1) + this.__backing_storageLinkObject = new StorageLinkDecoratedVariable("PropB", "storageLinkObject", new Data(1)) + } + + public __updateStruct(initializers: __Options_Index | undefined): void {} + + private __backing_storageLink?: StorageLinkDecoratedVariable; + + public get storageLink(): number { + return this.__backing_storageLink!.get(); + } + + public set storageLink(value: number) { + this.__backing_storageLink!.set(value); + } + + private __backing_storageLinkObject?: StorageLinkDecoratedVariable; + + public get storageLinkObject(): Data { + return this.__backing_storageLinkObject!.get(); + } + + public set storageLinkObject(value: Data) { + this.__backing_storageLinkObject!.set(value); + } + + @memo() public _build(@memo() style: ((instance: Index)=> Index) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Index | undefined): void { + Column(undefined, undefined, (() => { + Text(@memo() ((instance: UITextAttribute): void => { + instance.onClick(((e: ClickEvent) => { + this.storageLink += 1; + })); + return; + }), \`From AppStorage \${this.storageLink}\`, undefined, undefined); + Text(@memo() ((instance: UITextAttribute): void => { + instance.onClick(((e: ClickEvent) => { + this.storageLinkObject.code += 1; + })); + return; + }), \`From AppStorage \${this.storageLinkObject.code}\`, undefined, undefined); + })); + } + + public constructor() {} + +} + +interface __Options_Index { + set storageLink(storageLink: number | undefined) + + get storageLink(): number | undefined + set __backing_storageLink(__backing_storageLink: StorageLinkDecoratedVariable | undefined) + + get __backing_storageLink(): StorageLinkDecoratedVariable | undefined + set storageLinkObject(storageLinkObject: Data | undefined) + + get storageLinkObject(): Data | undefined + set __backing_storageLinkObject(__backing_storageLinkObject: StorageLinkDecoratedVariable | undefined) + + get __backing_storageLinkObject(): StorageLinkDecoratedVariable | undefined + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + Index._instantiateImpl(undefined, (() => { + return new Index(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} +`; + +function testStorageLinkTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test storagelink with appstorage', + [storageLinkTransform, uiNoRecheck], + { + checked: [testStorageLinkTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/storagelink/storagelink-complex-type.test.ts b/ets1.2/tests_ui/decorators/storagelink/storagelink-complex-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..dba913594e47878ab3d517d21adb6da488833a00 --- /dev/null +++ b/ets1.2/tests_ui/decorators/storagelink/storagelink-complex-type.test.ts @@ -0,0 +1,313 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const STORAGELINK_DIR_PATH: string = 'decorators/storagelink'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, STORAGELINK_DIR_PATH, 'storagelink-complex-type.ets'), +]; + +const storageLinkTransform: Plugins = { + name: 'storageLink', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test storagelink complex type transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { StorageLinkDecoratedVariable as StorageLinkDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry } from "@ohos.arkui.component"; + +import { StorageLink as StorageLink } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +class Person { + public name: string = ""; + + public constructor(name: string) {} + +} + +final class Status extends BaseEnum { + private readonly #ordinal: int; + + private static () {} + + public constructor(ordinal: int, value: int) { + super(value); + this.#ordinal = ordinal; + } + + public static readonly Success: Status = new Status(0, 200); + + public static readonly NotFound: Status = new Status(1, 404); + + public static readonly ServerError: Status = new Status(2, 500); + + private static readonly #NamesArray: String[] = ["Success", "NotFound", "ServerError"]; + + private static readonly #ValuesArray: int[] = [200, 404, 500]; + + private static readonly #StringValuesArray: String[] = ["200", "404", "500"]; + + private static readonly #ItemsArray: Status[] = [Status.Success, Status.NotFound, Status.ServerError]; + + public getName(): String { + return Status.#NamesArray[this.#ordinal]; + } + + public static getValueOf(name: String): Status { + for (let i = 0;((i) < (Status.#NamesArray.length));(++i)) { + if (((name) == (Status.#NamesArray[i]))) { + return Status.#ItemsArray[i]; + } + } + throw new Error((("No enum constant Status.") + (name))); + } + + public static fromValue(value: int): Status { + for (let i = 0;((i) < (Status.#ValuesArray.length));(++i)) { + if (((value) == (Status.#ValuesArray[i]))) { + return Status.#ItemsArray[i]; + } + } + throw new Error((("No enum Status with value ") + (value))); + } + + public valueOf(): int { + return Status.#ValuesArray[this.#ordinal]; + } + + public toString(): String { + return Status.#StringValuesArray[this.#ordinal]; + } + + public static values(): Status[] { + return Status.#ItemsArray; + } + + public getOrdinal(): int { + return this.#ordinal; + } + + public static $_get(e: Status): String { + return e.getName(); + } + +} + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_arrayA = new StorageLinkDecoratedVariable>("Prop1", "arrayA", [1, 2, 3]) + this.__backing_objectA = new StorageLinkDecoratedVariable("Prop2", "objectA", {}) + this.__backing_dateA = new StorageLinkDecoratedVariable("Prop3", "dateA", new Date("2021-08-08")) + this.__backing_setA = new StorageLinkDecoratedVariable>("Prop4", "setA", new Set()) + this.__backing_mapA = new StorageLinkDecoratedVariable>("Prop5", "mapA", new Map()) + this.__backing_unionA = new StorageLinkDecoratedVariable("Prop6", "unionA", "") + this.__backing_classA = new StorageLinkDecoratedVariable("Prop7", "classA", new Person("John")) + this.__backing_enumA = new StorageLinkDecoratedVariable("Prop8", "enumA", Status.NotFound) + } + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + private __backing_arrayA?: StorageLinkDecoratedVariable>; + + public get arrayA(): Array { + return this.__backing_arrayA!.get(); + } + + public set arrayA(value: Array) { + this.__backing_arrayA!.set(value); + } + + private __backing_objectA?: StorageLinkDecoratedVariable; + + public get objectA(): Object { + return this.__backing_objectA!.get(); + } + + public set objectA(value: Object) { + this.__backing_objectA!.set(value); + } + + private __backing_dateA?: StorageLinkDecoratedVariable; + + public get dateA(): Date { + return this.__backing_dateA!.get(); + } + + public set dateA(value: Date) { + this.__backing_dateA!.set(value); + } + + private __backing_setA?: StorageLinkDecoratedVariable>; + + public get setA(): Set { + return this.__backing_setA!.get(); + } + + public set setA(value: Set) { + this.__backing_setA!.set(value); + } + + private __backing_mapA?: StorageLinkDecoratedVariable>; + + public get mapA(): Map { + return this.__backing_mapA!.get(); + } + + public set mapA(value: Map) { + this.__backing_mapA!.set(value); + } + + private __backing_unionA?: StorageLinkDecoratedVariable; + + public get unionA(): string | undefined { + return this.__backing_unionA!.get(); + } + + public set unionA(value: string | undefined) { + this.__backing_unionA!.set(value); + } + + private __backing_classA?: StorageLinkDecoratedVariable; + + public get classA(): Person { + return this.__backing_classA!.get(); + } + + public set classA(value: Person) { + this.__backing_classA!.set(value); + } + + private __backing_enumA?: StorageLinkDecoratedVariable; + + public get enumA(): Status { + return this.__backing_enumA!.get(); + } + + public set enumA(value: Status) { + this.__backing_enumA!.set(value); + } + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + set arrayA(arrayA: Array | undefined) + + get arrayA(): Array | undefined + set __backing_arrayA(__backing_arrayA: StorageLinkDecoratedVariable> | undefined) + + get __backing_arrayA(): StorageLinkDecoratedVariable> | undefined + set objectA(objectA: Object | undefined) + + get objectA(): Object | undefined + set __backing_objectA(__backing_objectA: StorageLinkDecoratedVariable | undefined) + + get __backing_objectA(): StorageLinkDecoratedVariable | undefined + set dateA(dateA: Date | undefined) + + get dateA(): Date | undefined + set __backing_dateA(__backing_dateA: StorageLinkDecoratedVariable | undefined) + + get __backing_dateA(): StorageLinkDecoratedVariable | undefined + set setA(setA: Set | undefined) + + get setA(): Set | undefined + set __backing_setA(__backing_setA: StorageLinkDecoratedVariable> | undefined) + + get __backing_setA(): StorageLinkDecoratedVariable> | undefined + set mapA(mapA: Map | undefined) + + get mapA(): Map | undefined + set __backing_mapA(__backing_mapA: StorageLinkDecoratedVariable> | undefined) + + get __backing_mapA(): StorageLinkDecoratedVariable> | undefined + set unionA(unionA: string | undefined | undefined) + + get unionA(): string | undefined | undefined + set __backing_unionA(__backing_unionA: StorageLinkDecoratedVariable | undefined) + + get __backing_unionA(): StorageLinkDecoratedVariable | undefined + set classA(classA: Person | undefined) + + get classA(): Person | undefined + set __backing_classA(__backing_classA: StorageLinkDecoratedVariable | undefined) + + get __backing_classA(): StorageLinkDecoratedVariable | undefined + set enumA(enumA: Status | undefined) + + get enumA(): Status | undefined + set __backing_enumA(__backing_enumA: StorageLinkDecoratedVariable | undefined) + + get __backing_enumA(): StorageLinkDecoratedVariable | undefined + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + MyStateSample._instantiateImpl(undefined, (() => { + return new MyStateSample(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} + +`; + +function testStorageLinkTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test storagelink complex type transform', + [storageLinkTransform, uiNoRecheck], + { + checked: [testStorageLinkTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/storagelink/storagelink-primitive-type.test.ts b/ets1.2/tests_ui/decorators/storagelink/storagelink-primitive-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..27a78307e6794b6a40d9087fb97ee33800cee8c1 --- /dev/null +++ b/ets1.2/tests_ui/decorators/storagelink/storagelink-primitive-type.test.ts @@ -0,0 +1,153 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const STORAGELINK_DIR_PATH: string = 'decorators/storagelink'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, STORAGELINK_DIR_PATH, 'storagelink-primitive-type.ets'), +]; + +const storageLinkTransform: Plugins = { + name: 'storageLink', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test storagelink primitive type transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { StorageLinkDecoratedVariable as StorageLinkDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry } from "@ohos.arkui.component"; + +import { StorageLink as StorageLink } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_numA = new StorageLinkDecoratedVariable("Prop1", "numA", 33) + this.__backing_stringA = new StorageLinkDecoratedVariable("Prop2", "stringA", "AA") + this.__backing_booleanA = new StorageLinkDecoratedVariable("Prop3", "booleanA", true) + } + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + private __backing_numA?: StorageLinkDecoratedVariable; + + public get numA(): number { + return this.__backing_numA!.get(); + } + + public set numA(value: number) { + this.__backing_numA!.set(value); + } + + private __backing_stringA?: StorageLinkDecoratedVariable; + + public get stringA(): string { + return this.__backing_stringA!.get(); + } + + public set stringA(value: string) { + this.__backing_stringA!.set(value); + } + + private __backing_booleanA?: StorageLinkDecoratedVariable; + + public get booleanA(): boolean { + return this.__backing_booleanA!.get(); + } + + public set booleanA(value: boolean) { + this.__backing_booleanA!.set(value); + } + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + set numA(numA: number | undefined) + + get numA(): number | undefined + set __backing_numA(__backing_numA: StorageLinkDecoratedVariable | undefined) + + get __backing_numA(): StorageLinkDecoratedVariable | undefined + set stringA(stringA: string | undefined) + + get stringA(): string | undefined + set __backing_stringA(__backing_stringA: StorageLinkDecoratedVariable | undefined) + + get __backing_stringA(): StorageLinkDecoratedVariable | undefined + set booleanA(booleanA: boolean | undefined) + + get booleanA(): boolean | undefined + set __backing_booleanA(__backing_booleanA: StorageLinkDecoratedVariable | undefined) + + get __backing_booleanA(): StorageLinkDecoratedVariable | undefined + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + MyStateSample._instantiateImpl(undefined, (() => { + return new MyStateSample(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} + +`; + +function testStorageLinkTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test storagelink primitive type transform', + [storageLinkTransform, uiNoRecheck], + { + checked: [testStorageLinkTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/storageprop/storageprop-appstorage.test.ts b/ets1.2/tests_ui/decorators/storageprop/storageprop-appstorage.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..e00d66d86c692d3cf2f4eee7eb9c4c44afc9ca5d --- /dev/null +++ b/ets1.2/tests_ui/decorators/storageprop/storageprop-appstorage.test.ts @@ -0,0 +1,165 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const STORAGEPROP_DIR_PATH: string = 'decorators/storageprop'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, STORAGEPROP_DIR_PATH, 'storageprop-appstorage.ets'), +]; + +const storagePropTransform: Plugins = { + name: 'storageprop', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test storageprop with appstorage', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { StoragePropDecoratedVariable as StoragePropDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { UITextAttribute as UITextAttribute } from "@ohos.arkui.component"; + +import { UIColumnAttribute as UIColumnAttribute } from "@ohos.arkui.component"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry, Column as Column, Text as Text, ClickEvent as ClickEvent } from "@ohos.arkui.component"; + +import { StorageProp as StorageProp, AppStorage as AppStorage } from "@ohos.arkui.stateManagement"; + +function main() {} + +AppStorage.setOrCreate("PropA", 47); +AppStorage.setOrCreate("PropB", new Data(50)); + +class Data { + public code: number; + + public constructor(code: number) { + this.code = code; + } + +} + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class Index extends CustomComponent { + public __initializeStruct(initializers: __Options_Index | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_storageProp = new StoragePropDecoratedVariable("PropA", "storageProp", 1) + this.__backing_storagePropObject = new StoragePropDecoratedVariable("PropB", "storagePropObject", new Data(1)) + } + + public __updateStruct(initializers: __Options_Index | undefined): void {} + + private __backing_storageProp?: StoragePropDecoratedVariable; + + public get storageProp(): number { + return this.__backing_storageProp!.get(); + } + + public set storageProp(value: number) { + this.__backing_storageProp!.set(value); + } + + private __backing_storagePropObject?: StoragePropDecoratedVariable; + + public get storagePropObject(): Data { + return this.__backing_storagePropObject!.get(); + } + + public set storagePropObject(value: Data) { + this.__backing_storagePropObject!.set(value); + } + + @memo() public _build(@memo() style: ((instance: Index)=> Index) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Index | undefined): void { + Column(undefined, undefined, (() => { + Text(@memo() ((instance: UITextAttribute): void => { + instance.onClick(((e: ClickEvent) => { + this.storageProp += 1; + })); + return; + }), \`From AppStorage \${this.storageProp}\`, undefined, undefined); + Text(@memo() ((instance: UITextAttribute): void => { + instance.onClick(((e: ClickEvent) => { + this.storagePropObject.code += 1; + })); + return; + }), \`From AppStorage \${this.storagePropObject.code}\`, undefined, undefined); + })); + } + + public constructor() {} + +} + +interface __Options_Index { + set storageProp(storageProp: number | undefined) + + get storageProp(): number | undefined + set __backing_storageProp(__backing_storageProp: StoragePropDecoratedVariable | undefined) + + get __backing_storageProp(): StoragePropDecoratedVariable | undefined + set storagePropObject(storagePropObject: Data | undefined) + + get storagePropObject(): Data | undefined + set __backing_storagePropObject(__backing_storagePropObject: StoragePropDecoratedVariable | undefined) + + get __backing_storagePropObject(): StoragePropDecoratedVariable | undefined + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + Index._instantiateImpl(undefined, (() => { + return new Index(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} + +`; + +function testStoragePropTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test storageprop with appstorage', + [storagePropTransform, uiNoRecheck], + { + checked: [testStoragePropTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/storageprop/storageprop-complex-type.test.ts b/ets1.2/tests_ui/decorators/storageprop/storageprop-complex-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..ca212c7caad25e27955d4136240a47414626b8f9 --- /dev/null +++ b/ets1.2/tests_ui/decorators/storageprop/storageprop-complex-type.test.ts @@ -0,0 +1,312 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const STORAGEPROP_DIR_PATH: string = 'decorators/storageprop'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, STORAGEPROP_DIR_PATH, 'storageprop-complex-type.ets'), +]; + +const storagePropTransform: Plugins = { + name: 'storageprop', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test storageprop complex type transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { StoragePropDecoratedVariable as StoragePropDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry } from "@ohos.arkui.component"; + +import { StorageProp as StorageProp } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +class Person { + public name: string = ""; + + public constructor(name: string) {} + +} + +final class Status extends BaseEnum { + private readonly #ordinal: int; + + private static () {} + + public constructor(ordinal: int, value: int) { + super(value); + this.#ordinal = ordinal; + } + + public static readonly Success: Status = new Status(0, 200); + + public static readonly NotFound: Status = new Status(1, 404); + + public static readonly ServerError: Status = new Status(2, 500); + + private static readonly #NamesArray: String[] = ["Success", "NotFound", "ServerError"]; + + private static readonly #ValuesArray: int[] = [200, 404, 500]; + + private static readonly #StringValuesArray: String[] = ["200", "404", "500"]; + + private static readonly #ItemsArray: Status[] = [Status.Success, Status.NotFound, Status.ServerError]; + + public getName(): String { + return Status.#NamesArray[this.#ordinal]; + } + + public static getValueOf(name: String): Status { + for (let i = 0;((i) < (Status.#NamesArray.length));(++i)) { + if (((name) == (Status.#NamesArray[i]))) { + return Status.#ItemsArray[i]; + } + } + throw new Error((("No enum constant Status.") + (name))); + } + + public static fromValue(value: int): Status { + for (let i = 0;((i) < (Status.#ValuesArray.length));(++i)) { + if (((value) == (Status.#ValuesArray[i]))) { + return Status.#ItemsArray[i]; + } + } + throw new Error((("No enum Status with value ") + (value))); + } + + public valueOf(): int { + return Status.#ValuesArray[this.#ordinal]; + } + + public toString(): String { + return Status.#StringValuesArray[this.#ordinal]; + } + + public static values(): Status[] { + return Status.#ItemsArray; + } + + public getOrdinal(): int { + return this.#ordinal; + } + + public static $_get(e: Status): String { + return e.getName(); + } + +} + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_arrayB = new StoragePropDecoratedVariable>("Prop1", "arrayB", [1, 2, 3]) + this.__backing_objectB = new StoragePropDecoratedVariable("Prop2", "objectB", {}) + this.__backing_dateB = new StoragePropDecoratedVariable("Prop3", "dateB", new Date("2021-09-09")) + this.__backing_setB = new StoragePropDecoratedVariable>("Prop4", "setB", new Set()) + this.__backing_mapB = new StoragePropDecoratedVariable>("Prop5", "mapB", new Map()) + this.__backing_unionB = new StoragePropDecoratedVariable("Prop6", "unionB", "") + this.__backing_classB = new StoragePropDecoratedVariable("Prop7", "classB", new Person("Kevin")) + this.__backing_enumB = new StoragePropDecoratedVariable("Prop8", "enumB", Status.NotFound) + } + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + private __backing_arrayB?: StoragePropDecoratedVariable>; + + public get arrayB(): Array { + return this.__backing_arrayB!.get(); + } + + public set arrayB(value: Array) { + this.__backing_arrayB!.set(value); + } + + private __backing_objectB?: StoragePropDecoratedVariable; + + public get objectB(): Object { + return this.__backing_objectB!.get(); + } + + public set objectB(value: Object) { + this.__backing_objectB!.set(value); + } + + private __backing_dateB?: StoragePropDecoratedVariable; + + public get dateB(): Date { + return this.__backing_dateB!.get(); + } + + public set dateB(value: Date) { + this.__backing_dateB!.set(value); + } + + private __backing_setB?: StoragePropDecoratedVariable>; + + public get setB(): Set { + return this.__backing_setB!.get(); + } + + public set setB(value: Set) { + this.__backing_setB!.set(value); + } + + private __backing_mapB?: StoragePropDecoratedVariable>; + + public get mapB(): Map { + return this.__backing_mapB!.get(); + } + + public set mapB(value: Map) { + this.__backing_mapB!.set(value); + } + + private __backing_unionB?: StoragePropDecoratedVariable; + + public get unionB(): string | undefined { + return this.__backing_unionB!.get(); + } + + public set unionB(value: string | undefined) { + this.__backing_unionB!.set(value); + } + + private __backing_classB?: StoragePropDecoratedVariable; + + public get classB(): Person { + return this.__backing_classB!.get(); + } + + public set classB(value: Person) { + this.__backing_classB!.set(value); + } + + private __backing_enumB?: StoragePropDecoratedVariable; + + public get enumB(): Status { + return this.__backing_enumB!.get(); + } + + public set enumB(value: Status) { + this.__backing_enumB!.set(value); + } + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + set arrayB(arrayB: Array | undefined) + + get arrayB(): Array | undefined + set __backing_arrayB(__backing_arrayB: StoragePropDecoratedVariable> | undefined) + + get __backing_arrayB(): StoragePropDecoratedVariable> | undefined + set objectB(objectB: Object | undefined) + + get objectB(): Object | undefined + set __backing_objectB(__backing_objectB: StoragePropDecoratedVariable | undefined) + + get __backing_objectB(): StoragePropDecoratedVariable | undefined + set dateB(dateB: Date | undefined) + + get dateB(): Date | undefined + set __backing_dateB(__backing_dateB: StoragePropDecoratedVariable | undefined) + + get __backing_dateB(): StoragePropDecoratedVariable | undefined + set setB(setB: Set | undefined) + + get setB(): Set | undefined + set __backing_setB(__backing_setB: StoragePropDecoratedVariable> | undefined) + + get __backing_setB(): StoragePropDecoratedVariable> | undefined + set mapB(mapB: Map | undefined) + + get mapB(): Map | undefined + set __backing_mapB(__backing_mapB: StoragePropDecoratedVariable> | undefined) + + get __backing_mapB(): StoragePropDecoratedVariable> | undefined + set unionB(unionB: string | undefined | undefined) + + get unionB(): string | undefined | undefined + set __backing_unionB(__backing_unionB: StoragePropDecoratedVariable | undefined) + + get __backing_unionB(): StoragePropDecoratedVariable | undefined + set classB(classB: Person | undefined) + + get classB(): Person | undefined + set __backing_classB(__backing_classB: StoragePropDecoratedVariable | undefined) + + get __backing_classB(): StoragePropDecoratedVariable | undefined + set enumB(enumB: Status | undefined) + + get enumB(): Status | undefined + set __backing_enumB(__backing_enumB: StoragePropDecoratedVariable | undefined) + + get __backing_enumB(): StoragePropDecoratedVariable | undefined + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + MyStateSample._instantiateImpl(undefined, (() => { + return new MyStateSample(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} +`; + +function testStoragePropTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test storageprop complex type transform', + [storagePropTransform, uiNoRecheck], + { + checked: [testStoragePropTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/storageprop/storageprop-primitive-type.test.ts b/ets1.2/tests_ui/decorators/storageprop/storageprop-primitive-type.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..d6247f205625a78926fd1b6e745ddbaca0b1fd2a --- /dev/null +++ b/ets1.2/tests_ui/decorators/storageprop/storageprop-primitive-type.test.ts @@ -0,0 +1,152 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const STORAGEPROP_DIR_PATH: string = 'decorators/storageprop'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, STORAGEPROP_DIR_PATH, 'storageprop-primitive-type.ets'), +]; + +const storagePropTransform: Plugins = { + name: 'storageprop', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test storageprop primitive type transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { StoragePropDecoratedVariable as StoragePropDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry } from "@ohos.arkui.component"; + +import { StorageProp as StorageProp } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_numB = new StoragePropDecoratedVariable("Prop1", "numB", 43) + this.__backing_stringB = new StoragePropDecoratedVariable("Prop2", "stringB", "BB") + this.__backing_booleanB = new StoragePropDecoratedVariable("Prop3", "booleanB", false) + } + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void {} + + private __backing_numB?: StoragePropDecoratedVariable; + + public get numB(): number { + return this.__backing_numB!.get(); + } + + public set numB(value: number) { + this.__backing_numB!.set(value); + } + + private __backing_stringB?: StoragePropDecoratedVariable; + + public get stringB(): string { + return this.__backing_stringB!.get(); + } + + public set stringB(value: string) { + this.__backing_stringB!.set(value); + } + + private __backing_booleanB?: StoragePropDecoratedVariable; + + public get booleanB(): boolean { + return this.__backing_booleanB!.get(); + } + + public set booleanB(value: boolean) { + this.__backing_booleanB!.set(value); + } + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + set numB(numB: number | undefined) + + get numB(): number | undefined + set __backing_numB(__backing_numB: StoragePropDecoratedVariable | undefined) + + get __backing_numB(): StoragePropDecoratedVariable | undefined + set stringB(stringB: string | undefined) + + get stringB(): string | undefined + set __backing_stringB(__backing_stringB: StoragePropDecoratedVariable | undefined) + + get __backing_stringB(): StoragePropDecoratedVariable | undefined + set booleanB(booleanB: boolean | undefined) + + get booleanB(): boolean | undefined + set __backing_booleanB(__backing_booleanB: StoragePropDecoratedVariable | undefined) + + get __backing_booleanB(): StoragePropDecoratedVariable | undefined + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + MyStateSample._instantiateImpl(undefined, (() => { + return new MyStateSample(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} +`; + +function testStoragePropTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test storageprop primitive type transform', + [storagePropTransform, uiNoRecheck], + { + checked: [testStoragePropTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/decorators/watch/watch-basic.test.ts b/ets1.2/tests_ui/decorators/watch/watch-basic.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..fbb612c70fa628e4852f9fdc505881799e5d71aa --- /dev/null +++ b/ets1.2/tests_ui/decorators/watch/watch-basic.test.ts @@ -0,0 +1,306 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../../utils/path-config'; +import { parseDumpSrc } from '../../../../utils/parse-string'; +import { uiNoRecheck } from '../../../../utils/plugins'; +import { uiTransform } from '../../../../../ui-plugins'; +import { Plugins } from '../../../../../common/plugin-context'; + +const WATCH_DIR_PATH: string = 'decorators/watch'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, WATCH_DIR_PATH, 'watch-basic.ets'), +]; + +const watchTransform: Plugins = { + name: 'watch', + parsed: uiTransform().parsed, +}; + +const pluginTester = new PluginTester('test basic watch transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { ConsumeDecoratedVariable as ConsumeDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { ProvideDecoratedVariable as ProvideDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { SubscribedWatches as SubscribedWatches } from "@ohos.arkui.stateManagement"; + +import { WatchIdType as WatchIdType } from "@ohos.arkui.stateManagement"; + +import { int32 as int32 } from "@ohos.arkui.stateManagement"; + +import { IObservedObject as IObservedObject } from "@ohos.arkui.stateManagement"; + +import { setObservationDepth as setObservationDepth } from "@ohos.arkui.stateManagement"; + +import { BackingValue as BackingValue } from "@ohos.arkui.stateManagement"; + +import { MutableStateMeta as MutableStateMeta } from "@ohos.arkui.stateManagement"; + +import { ObjectLinkDecoratedVariable as ObjectLinkDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { DecoratedV1VariableBase as DecoratedV1VariableBase } from "@ohos.arkui.stateManagement"; + +import { LinkDecoratedVariable as LinkDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { StoragePropDecoratedVariable as StoragePropDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { StorageLinkDecoratedVariable as StorageLinkDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { PropDecoratedVariable as PropDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { StateDecoratedVariable as StateDecoratedVariable } from "@ohos.arkui.stateManagement"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Entry as Entry } from "@ohos.arkui.component"; + +import { State as State, Prop as Prop, StorageLink as StorageLink, StorageProp as StorageProp, Link as Link, Watch as Watch, ObjectLink as ObjectLink, Observed as Observed, Track as Track, Provide as Provide, Consume as Consume } from "@ohos.arkui.stateManagement"; + +function main() {} + + + +@Observed() class A implements IObservedObject { + private subscribedWatches: SubscribedWatches = new SubscribedWatches(); + + public addWatchSubscriber(watchId: WatchIdType): void { + this.subscribedWatches.addWatchSubscriber(watchId); + } + + public removeWatchSubscriber(watchId: WatchIdType): boolean { + return this.subscribedWatches.removeWatchSubscriber(watchId); + } + + public executeOnSubscribingWatches(propertyName: string): void { + this.subscribedWatches.executeOnSubscribingWatches(propertyName); + } + + public _permissibleAddRefDepth: int32 = 0; + + public propA: string = "hello"; + + private __backing_trackA: string = "world"; + + private __meta_trackA: MutableStateMeta = new MutableStateMeta("@Track"); + + public constructor() {} + + public get trackA(): string { + if (((this._permissibleAddRefDepth) > (0))) { + this.__meta_trackA.addRef(); + } + return this.__backing_trackA; + } + + public set trackA(newValue: string) { + if (((this.__backing_trackA) !== (newValue))) { + this.__backing_trackA = newValue; + this.__meta_trackA.fireChange(); + this.executeOnSubscribingWatches("trackA"); + } + } + +} + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class MyStateSample extends CustomComponent { + public __initializeStruct(initializers: __Options_MyStateSample | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_statevar = new StateDecoratedVariable("statevar", ((({let gensym___76198660 = initializers; + (((gensym___76198660) == (null)) ? undefined : gensym___76198660.statevar)})) ?? ("Hello World")), ((_: string): void => { + this.stateOnChange(_); + })); + this.__backing_propvar = new PropDecoratedVariable("propvar", ((({let gensym___241486692 = initializers; + (((gensym___241486692) == (null)) ? undefined : gensym___241486692.propvar)})) ?? ("Hello World")), ((_: string): void => { + this.propOnChange(_); + })); + this.__backing_storagelinkvar = new StorageLinkDecoratedVariable("prop1", "storagelinkvar", "Hello World", ((_: string): void => { + this.storageLinkOnChange(_); + })) + this.__backing_storagepropvar = new StoragePropDecoratedVariable("prop2", "storagepropvar", "Hello World", ((_: string): void => { + this.storagePropOnChange(_); + })) + this.__backing_providevar = this.addProvidedVar("providevar", "providevar", ((({let gensym___194235814 = initializers; + (((gensym___194235814) == (null)) ? undefined : gensym___194235814.providevar)})) ?? ("Hello World")), false, ((_: string): void => { + this.ProvideOnChange(_); + })); + } + + public __updateStruct(initializers: __Options_MyStateSample | undefined): void { + if (((({let gensym___220608839 = initializers; + (((gensym___220608839) == (null)) ? undefined : gensym___220608839.propvar)})) !== (undefined))) { + this.__backing_propvar!.update((initializers!.propvar as string)); + } + } + + private __backing_statevar?: StateDecoratedVariable; + + public get statevar(): string { + return this.__backing_statevar!.get(); + } + + public set statevar(value: string) { + this.__backing_statevar!.set(value); + } + + private __backing_propvar?: PropDecoratedVariable; + + public get propvar(): string { + return this.__backing_propvar!.get(); + } + + public set propvar(value: string) { + this.__backing_propvar!.set(value); + } + + private __backing_storagelinkvar?: StorageLinkDecoratedVariable; + + public get storagelinkvar(): string { + return this.__backing_storagelinkvar!.get(); + } + + public set storagelinkvar(value: string) { + this.__backing_storagelinkvar!.set(value); + } + + private __backing_storagepropvar?: StoragePropDecoratedVariable; + + public get storagepropvar(): string { + return this.__backing_storagepropvar!.get(); + } + + public set storagepropvar(value: string) { + this.__backing_storagepropvar!.set(value); + } + + private __backing_providevar?: ProvideDecoratedVariable; + + public get providevar(): string { + return this.__backing_providevar!.get(); + } + + public set providevar(value: string) { + this.__backing_providevar!.set(value); + } + + public stateOnChange(propName: string) {} + + public propOnChange(propName: string) {} + + public storageLinkOnChange(propName: string) {} + + public storagePropOnChange(propName: string) {} + + public ProvideOnChange(propName: string) {} + + @memo() public _build(@memo() style: ((instance: MyStateSample)=> MyStateSample) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_MyStateSample | undefined): void { + Child._instantiateImpl(undefined, (() => { + return new Child(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} + +@Component({freezeWhenInactive:false}) final class Child extends CustomComponent { + public __initializeStruct(initializers: __Options_Child | undefined, @memo() content: (()=> void) | undefined): void {} + + public __updateStruct(initializers: __Options_Child | undefined): void {} + + @memo() public _build(@memo() style: ((instance: Child)=> Child) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Child | undefined): void {} + + public constructor() {} + +} + +interface __Options_MyStateSample { + set statevar(statevar: string | undefined) + + get statevar(): string | undefined + set __backing_statevar(__backing_statevar: StateDecoratedVariable | undefined) + + get __backing_statevar(): StateDecoratedVariable | undefined + set propvar(propvar: string | undefined) + + get propvar(): string | undefined + set __backing_propvar(__backing_propvar: PropDecoratedVariable | undefined) + + get __backing_propvar(): PropDecoratedVariable | undefined + set storagelinkvar(storagelinkvar: string | undefined) + + get storagelinkvar(): string | undefined + set __backing_storagelinkvar(__backing_storagelinkvar: StorageLinkDecoratedVariable | undefined) + + get __backing_storagelinkvar(): StorageLinkDecoratedVariable | undefined + set storagepropvar(storagepropvar: string | undefined) + + get storagepropvar(): string | undefined + set __backing_storagepropvar(__backing_storagepropvar: StoragePropDecoratedVariable | undefined) + + get __backing_storagepropvar(): StoragePropDecoratedVariable | undefined + set providevar(providevar: string | undefined) + + get providevar(): string | undefined + set __backing_providevar(__backing_providevar: ProvideDecoratedVariable | undefined) + + get __backing_providevar(): ProvideDecoratedVariable | undefined + +} + +interface __Options_Child { + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + MyStateSample._instantiateImpl(undefined, (() => { + return new MyStateSample(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} + +`; + +function testWatchTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test basic watch transform', + [watchTransform, uiNoRecheck], + { + checked: [testWatchTransformer], + }, + { + stopAfter: 'checked', + } +); diff --git a/ets1.2/tests_ui/xcomponent/xcomponent-basic.test.ts b/ets1.2/tests_ui/xcomponent/xcomponent-basic.test.ts new file mode 100644 index 0000000000000000000000000000000000000000..fc5ee09c61f539d5e2bd36eda2dff9a5221425c3 --- /dev/null +++ b/ets1.2/tests_ui/xcomponent/xcomponent-basic.test.ts @@ -0,0 +1,132 @@ +/* + * 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 * as path from 'path'; +import { PluginTestContext, PluginTester } from '../../../utils/plugin-tester'; +import { BuildConfig, mockBuildConfig } from '../../../utils/artkts-config'; +import { getRootPath, MOCK_ENTRY_DIR_PATH } from '../../../utils/path-config'; +import { parseDumpSrc } from '../../../utils/parse-string'; +import { uiNoRecheck } from '../../../utils/plugins'; +import { uiTransform } from '../../../../ui-plugins'; +import { Plugins } from '../../../../common/plugin-context'; + +const XCOMPONENT_DIR_PATH: string = 'xcomponent'; + +const buildConfig: BuildConfig = mockBuildConfig(); +buildConfig.compileFiles = [ + path.resolve(getRootPath(), MOCK_ENTRY_DIR_PATH, XCOMPONENT_DIR_PATH, 'xcomponent-basic.ets'), +]; + +const xcomponentTransform: Plugins = { + name: 'xcomponent', + parsed: uiTransform().parsed, +} + +const pluginTester = new PluginTester('test basic XComponent transform', buildConfig); + +const expectedScript: string = ` +import { __memo_id_type as __memo_id_type } from "arkui.stateManagement.runtime"; + +import { __memo_context_type as __memo_context_type } from "arkui.stateManagement.runtime"; + +import { memo as memo } from "arkui.stateManagement.runtime"; + +import { UIXComponentAttribute as UIXComponentAttribute } from "@ohos.arkui.component"; + +import { UIFlexAttribute as UIFlexAttribute } from "@ohos.arkui.component"; + +import { EntryPoint as EntryPoint } from "arkui.UserView"; + +import { CustomComponent as CustomComponent } from "arkui.component.customComponent"; + +import { Component as Component, Flex as Flex, XComponent as XComponent, FlexDirection as FlexDirection, XComponentType as XComponentType, Entry as Entry, XComponentController as XComponentController, ItemAlign as ItemAlign, FlexAlign as FlexAlign, XComponentParameter as XComponentParameter } from "@ohos.arkui.component"; + +function main() {} + + + +@Entry({useSharedStorage:false,storage:"",routeName:""}) @Component({freezeWhenInactive:false}) final class Index extends CustomComponent { + public __initializeStruct(initializers: __Options_Index | undefined, @memo() content: (()=> void) | undefined): void { + this.__backing_myXComponentController = ((({let gensym___221905990 = initializers; + (((gensym___221905990) == (null)) ? undefined : gensym___221905990.myXComponentController)})) ?? (new XComponentController())); + } + + public __updateStruct(initializers: __Options_Index | undefined): void {} + + private __backing_myXComponentController?: XComponentController; + + public get myXComponentController(): XComponentController { + return (this.__backing_myXComponentController as XComponentController); + } + + public set myXComponentController(value: XComponentController) { + this.__backing_myXComponentController = value; + } + + @memo() public _build(@memo() style: ((instance: Index)=> Index) | undefined, @memo() content: (()=> void) | undefined, initializers: __Options_Index | undefined): void { + Flex(@memo() ((instance: UIFlexAttribute): void => { + instance.width("100%").height("100%"); + return; + }), { + direction: FlexDirection.Column, + alignItems: ItemAlign.Center, + justifyContent: FlexAlign.Start, + }, (() => { + XComponent(undefined, ({ + id: "xComponentId", + type: XComponentType.TEXTURE, + libraryname: "nativerender", + controller: this.myXComponentController, + } as XComponentParameter), "", undefined); + })); + } + + public constructor() {} + +} + +interface __Options_Index { + set myXComponentController(myXComponentController: XComponentController | undefined) + + get myXComponentController(): XComponentController | undefined + +} + +class __EntryWrapper extends EntryPoint { + @memo() public entry(): void { + Index._instantiateImpl(undefined, (() => { + return new Index(); + }), undefined, undefined, undefined); + } + + public constructor() {} + +} +`; + +function testXComponentTransformer(this: PluginTestContext): void { + expect(parseDumpSrc(this.scriptSnapshot ?? '')).toBe(parseDumpSrc(expectedScript)); +} + +pluginTester.run( + 'test basic XComponent transform', + [xcomponentTransform, uiNoRecheck], + { + checked: [testXComponentTransformer], + }, + { + stopAfter: 'checked', + } +);