From cbe9be3db0805deebe1521d4ccec54d2781d2b1e Mon Sep 17 00:00:00 2001 From: igorlegalov Date: Fri, 20 Jun 2025 19:25:30 +0300 Subject: [PATCH] Remove NullishType alias Issue: https://gitee.com/open_harmony/dashboard?issue_id=ICH95I Testing: all pre-merge tests passed Co-authored-by: Ivan Tyulyandin Signed-off-by: igorlegalov --- .../doc/concurrency/02_concurrency_stdlib.rst | 6 +- .../plugins/ets/doc/spec/16_concurrency.rst | 6 +- .../ets/sdk/api/@ohos.util.ArrayList.ets | 4 +- .../plugins/ets/sdk/api/@ohos.util.Deque.ets | 4 +- .../plugins/ets/sdk/api/@ohos.util.ets | 52 ++++---- .../plugins/ets/sdk/api/@ohos.util.json.ets | 10 +- static_core/plugins/ets/sdk/api/@ohos.xml.ets | 16 +-- .../plugins/ets/stdlib/escompat/Array.ets | 48 +++---- .../plugins/ets/stdlib/escompat/BigInt.ets | 2 +- .../plugins/ets/stdlib/escompat/Global.ets | 8 +- .../plugins/ets/stdlib/escompat/Map.ets | 2 +- .../plugins/ets/stdlib/escompat/Reflect.ets | 26 ++-- .../plugins/ets/stdlib/escompat/RegExp.ets | 2 +- .../plugins/ets/stdlib/escompat/deepcopy.ets | 6 +- .../plugins/ets/stdlib/escompat/json.ets | 65 +++++----- .../plugins/ets/stdlib/escompat/taskpool.ets | 122 +++++++++--------- .../ets/stdlib/std/concurrency/AsyncLock.ets | 2 +- .../ets/stdlib/std/concurrency/Launch.ets | 16 +-- .../std/containers/ConcurrentHashMap.ets | 2 +- .../plugins/ets/stdlib/std/core/Boolean.ets | 4 +- .../ets/stdlib/std/core/BuiltinArray.ets | 16 +-- .../std/core/BuiltinArrayAlgorithms.ets | 6 +- .../plugins/ets/stdlib/std/core/Byte.ets | 2 +- .../plugins/ets/stdlib/std/core/Char.ets | 2 +- .../plugins/ets/stdlib/std/core/Console.ets | 72 +++++------ .../ets/stdlib/std/core/ConsoleHelper.ets | 58 ++++----- .../plugins/ets/stdlib/std/core/Double.ets | 2 +- .../plugins/ets/stdlib/std/core/EAWorker.ets | 24 ++-- .../plugins/ets/stdlib/std/core/Field.ets | 10 +- .../plugins/ets/stdlib/std/core/Float.ets | 2 +- .../plugins/ets/stdlib/std/core/Int.ets | 2 +- .../plugins/ets/stdlib/std/core/Job.ets | 2 +- .../plugins/ets/stdlib/std/core/Long.ets | 2 +- .../plugins/ets/stdlib/std/core/Method.ets | 10 +- .../plugins/ets/stdlib/std/core/Null.ets | 2 +- .../plugins/ets/stdlib/std/core/Object.ets | 41 +++--- .../plugins/ets/stdlib/std/core/Parameter.ets | 2 +- .../plugins/ets/stdlib/std/core/Promise.ets | 2 +- .../plugins/ets/stdlib/std/core/Proxy.ets | 94 +++++++------- .../stdlib/std/core/ReadonlyArrayProxy.ets | 4 +- .../plugins/ets/stdlib/std/core/Runtime.ets | 5 - .../plugins/ets/stdlib/std/core/Short.ets | 2 +- .../plugins/ets/stdlib/std/core/String.ets | 6 +- .../plugins/ets/stdlib/std/core/Type.ets | 54 ++++---- .../ets/stdlib/std/core/TypeCreator.ets | 4 +- .../plugins/ets/stdlib/std/core/Value.ets | 56 ++++---- .../std/interop/js/InteropTransferHelper.ets | 26 ++-- .../stdlib/std/interop/js/PromiseInterop.ets | 4 +- .../ets/templates/stdlib/Array_builtin.erb | 6 +- .../stdlib/Array_builtin_algorithms.ets.j2 | 4 +- .../ets/templates/stdlib/Array_common.erb | 2 +- .../ets/templates/stdlib/Array_escompat.erb | 40 +++--- .../stdlib/InteropTransferHelper.ets.j2 | 6 +- .../ets/tests/checked/escompat_array_from.ets | 8 +- .../tests/ets-common-tests/stubs/typeof.ets | 2 +- .../taskpool/common_tasks.ets | 18 +-- .../ets-common-tests/taskpool/group_tasks.ets | 10 +- .../ets-common-tests/taskpool/long_task.ets | 8 +- .../taskpool/seqrunner_tasks.ets | 10 +- .../escompat/ArrayProxyTest.ets | 6 +- .../escompat/ArrayTest_disabled.ets | 8 +- .../escompat/JsonAnnotationTest.ets | 6 +- .../ets_func_tests/escompat/JsonParseTest.ets | 22 ++-- .../escompat/JsonReplacerTest.ets | 24 ++-- .../escompat/JsonStringifyArrayTest.ets | 2 +- .../escompat/JsonStringifyTest.ets | 32 ++--- .../ets_func_tests/escompat/JsonTest.ets | 4 +- .../escompat/ObjectLiteralTest.ets | 2 +- .../ets_func_tests/escompat/ProxyTest.ets | 12 +- .../10.Interfaces/method_overiding_0001.ets | 6 +- .../BlockingQueue/AddAndPollStress.ets | 2 +- .../std/core/ConsoleDirTest.ets | 2 +- .../std/core/ConsoleTableTest.ets | 8 +- .../tests/ets_func_tests/std/core/Object.ets | 28 ++-- .../std/core/TypeClassTypeTest.ets | 6 +- .../std/core/TypeCreateErasedBodyTest.ets | 4 +- .../std/core/TypeMethodInvoke.ets | 4 +- .../std/core/TypeMethodInvokeConstructor.ets | 2 +- .../std/core/TypeMethodInvokeVirt.ets | 2 +- .../std/core/TypeMethodResolveConstructor.ets | 14 +- .../core/TypeMethodResolveConstructorFew.ets | 6 +- .../core/dateformat/DateTimeFormatTest.ets | 2 +- .../ets_sdk/api/@ohos/util/json/Parse.ets | 2 +- .../ets_sdk/api/@ohos/util/json/Stringify.ets | 2 +- .../coroutines/allhandled_rejection.ets | 4 +- .../constructor/ts_to_sts/constructor.ets | 2 +- .../not_nullish_operator.ets | 2 +- .../tests/promise/promise_tests.ets | 6 +- .../js_to_ets/test_class_methods.ets | 8 +- .../test_intrins/frontend_test_intrins.ets | 2 +- .../tests/test_intrins/test_intrins.ets | 4 +- .../test_return_this/test_return_this.ets | 4 +- .../tests/test_undefined/test_undefined.ets | 10 +- .../generate-es-checked/src/types.rb | 2 +- .../templates/template.sts.erb | 22 ++-- .../tools/generate-es-checked/src/types.rb | 2 +- .../templates/template.ets.erb | 22 ++-- 97 files changed, 658 insertions(+), 669 deletions(-) diff --git a/static_core/plugins/ets/doc/concurrency/02_concurrency_stdlib.rst b/static_core/plugins/ets/doc/concurrency/02_concurrency_stdlib.rst index 9a9246543b..e193f621ae 100644 --- a/static_core/plugins/ets/doc/concurrency/02_concurrency_stdlib.rst +++ b/static_core/plugins/ets/doc/concurrency/02_concurrency_stdlib.rst @@ -141,12 +141,12 @@ The following methods are used as follows: method .. - Promise::then(onFulfilled: ((value: T) => U|PromiseLike throws)|undefined, onRejected: ((error: NullishType) => E|PromiseLike throws)|undefined): Promise + Promise::then(onFulfilled: ((value: T) => U|PromiseLike throws)|undefined, onRejected: ((error: Any) => E|PromiseLike throws)|undefined): Promise .. code-block:: typescript :donotcompile: - Promise::then(onFulfilled: ((value: T) => U|PromiseLike throws)|undefined, onRejected: ((error: NullishType) => E|PromiseLike throws)|undefined): Promise + Promise::then(onFulfilled: ((value: T) => U|PromiseLike throws)|undefined, onRejected: ((error: Any) => E|PromiseLike throws)|undefined): Promise - ``catch`` takes one argument(the callback called after promise is rejected) and returns ``Promise`` @@ -155,7 +155,7 @@ The following methods are used as follows: .. code-block:: typescript :donotcompile: - Promise::catch(onRejected?: (error: NullishType) => U|PromiseLike throws): Promise + Promise::catch(onRejected?: (error: Any) => U|PromiseLike throws): Promise - ``finally`` takes one argument (the callback called after ``promise`` is either fulfilled or rejected) and returns ``Promise``. diff --git a/static_core/plugins/ets/doc/spec/16_concurrency.rst b/static_core/plugins/ets/doc/spec/16_concurrency.rst index 3a72dcde2d..7c3353dfb6 100644 --- a/static_core/plugins/ets/doc/spec/16_concurrency.rst +++ b/static_core/plugins/ets/doc/spec/16_concurrency.rst @@ -253,11 +253,11 @@ The methods are used as follows: method .. - Promise::then(onFulfilled: ((value: T) => U|PromiseLike throws)|undefined, onRejected: ((error: NullishType) => E|PromiseLike throws)|undefined): Promise + Promise::then(onFulfilled: ((value: T) => U|PromiseLike throws)|undefined, onRejected: ((error: Any) => E|PromiseLike throws)|undefined): Promise .. code-block:: typescript - Promise::then(onFulfilled: ((value: T) => U|PromiseLike throws)|undefined, onRejected: ((error: NullishType) => E|PromiseLike throws)|undefined): Promise> + Promise::then(onFulfilled: ((value: T) => U|PromiseLike throws)|undefined, onRejected: ((error: Any) => E|PromiseLike throws)|undefined): Promise> - ``catch`` takes one argument(the callback called after promise is rejected) and returns ``Promise>`` @@ -265,7 +265,7 @@ The methods are used as follows: .. code-block:: typescript - Promise::catch(onRejected?: (error: NullishType) => U|PromiseLike throws): Promise> + Promise::catch(onRejected?: (error: Any) => U|PromiseLike throws): Promise> - ``finally`` takes one argument (the callback called after ``promise`` is either fulfilled or rejected) and returns ``Promise>``. diff --git a/static_core/plugins/ets/sdk/api/@ohos.util.ArrayList.ets b/static_core/plugins/ets/sdk/api/@ohos.util.ArrayList.ets index d15427e09d..50a305b471 100644 --- a/static_core/plugins/ets/sdk/api/@ohos.util.ArrayList.ets +++ b/static_core/plugins/ets/sdk/api/@ohos.util.ArrayList.ets @@ -38,10 +38,10 @@ export class ArrayList implements Iterable, JsonReplacer { private capacity: int = this.DEFAULT_CAPACITY; private buffer: Array; - public jsonReplacer(): Record { + public jsonReplacer(): Record { const buf = this.buffer; const len = buf.length; - let arrayObj: Record = {}; + let arrayObj: Record = {}; for (let i = 0; i < len; i++) { arrayObj[String(i)] = buf[i]; } diff --git a/static_core/plugins/ets/sdk/api/@ohos.util.Deque.ets b/static_core/plugins/ets/sdk/api/@ohos.util.Deque.ets index 42b8a2ec94..519ce28174 100644 --- a/static_core/plugins/ets/sdk/api/@ohos.util.Deque.ets +++ b/static_core/plugins/ets/sdk/api/@ohos.util.Deque.ets @@ -35,10 +35,10 @@ export default class Deque implements Iterable, JsonReplacer { internal front: int = 0; internal rear: int = 0; - public jsonReplacer(): Record { + public jsonReplacer(): Record { const buf = this.buffer; const len = buf.length; - let arrayObj: Record = {}; + let arrayObj: Record = {}; for (let i = 0; i < len; i++) { arrayObj[String(i)] = buf[i]; } diff --git a/static_core/plugins/ets/sdk/api/@ohos.util.ets b/static_core/plugins/ets/sdk/api/@ohos.util.ets index c5bc68c875..45563cbc72 100644 --- a/static_core/plugins/ets/sdk/api/@ohos.util.ets +++ b/static_core/plugins/ets/sdk/api/@ohos.util.ets @@ -464,7 +464,7 @@ export namespace util { */ export function format(s: string, ...args: Object[]): string { // arrays are invariant, need to copy Objects to NullishTypes - let a = new Array(args.length) + let a = new Array(args.length) for (let i = 0; i < args.length; ++i) { a[i] = args[i] } @@ -1113,7 +1113,7 @@ export namespace util { return (new UtilHelper).stringifyObject(obj, '\n', 1, full) } - private static isNullObject(obj: NullishType): boolean { + private static isNullObject(obj: Any): boolean { return (obj == undefined) || (obj == null) } @@ -1133,25 +1133,25 @@ export namespace util { return obj instanceof Array } - private stringifySubObject(delimiter: string, subObj: NullishType, subObjName: string, depth: number, full: boolean = false): string { + private stringifySubObject(delimiter: string, subObj: Any, subObjName: string, depth: number, full: boolean = false): string { if (UtilHelper.isNullObject(subObj)) { return UtilHelper.nullObjectDescription(subObjName) + ',' + delimiter } let strB = new StringBuilder - subObj = __narrowAny(subObj) - - if (UtilHelper.isArray(subObj!)) { - strB.append(subObjName + ':' + delimiter + UtilHelper.arrayToString(delimiter + ' ', subObj! as Array, depth, full)) - } else if (UtilHelper.isObject(subObj!)) { - strB.append(this.subObjectDescription(subObj!, subObjName, this.isCircular(subObj!), delimiter, depth)) - } else if (UtilHelper.isFunction(subObj!)) { - strB.append(UtilHelper.functionDescription(subObj!, delimiter, true, full)) + subObj = subObj as object + + if (UtilHelper.isArray(subObj)) { + strB.append(subObjName + ':' + delimiter + UtilHelper.arrayToString(delimiter + ' ', subObj as Array, depth, full)) + } else if (UtilHelper.isObject(subObj)) { + strB.append(this.subObjectDescription(subObj, subObjName, this.isCircular(subObj), delimiter, depth)) + } else if (UtilHelper.isFunction(subObj)) { + strB.append(UtilHelper.functionDescription(subObj, delimiter, true, full)) } else { - strB.append(UtilHelper.simpleObjectDescription(subObj!, subObjName, true)) + strB.append(UtilHelper.simpleObjectDescription(subObj, subObjName, true)) } - this.objects.add(subObj!) + this.objects.add(subObj) strB.append(',' + delimiter) return strB.toString() @@ -1186,12 +1186,12 @@ export namespace util { private objects = new Set - private isCircular(obj: NullishType): boolean { + private isCircular(obj: Any): boolean { if (obj == null) { return false } - return this.objects.has(__narrowAny(obj)) + return this.objects.has(obj as object) } private static nullObjectDescription(objName: string = ''): string { @@ -1203,25 +1203,25 @@ export namespace util { return (isSub ? objName + ': ' : '') + quotesStr + obj + quotesStr } - private stringifyObject(obj: NullishType, delimiter: string = '\n', depth: number = 1, full: boolean = false): string { + private stringifyObject(obj: Any, delimiter: string = '\n', depth: number = 1, full: boolean = false): string { if (UtilHelper.isNullObject(obj)) { return UtilHelper.nullObjectDescription() } - obj = __narrowAny(obj) - this.objects.add(obj!) + obj = obj as object + this.objects.add(obj) let strB = new StringBuilder - if (UtilHelper.isArray(obj!)) { - strB.append(UtilHelper.arrayToString(delimiter, obj! as Array, depth, full)) - } else if (UtilHelper.isFunction(obj!)) { - strB.append(UtilHelper.functionDescription(obj!, delimiter, false, full)) + if (UtilHelper.isArray(obj)) { + strB.append(UtilHelper.arrayToString(delimiter, obj as Array, depth, full)) + } else if (UtilHelper.isFunction(obj)) { + strB.append(UtilHelper.functionDescription(obj, delimiter, false, full)) if (!full) { strB = (new StringBuilder).append('{ ').append(strB.toString()).append(' }') } - } else if (UtilHelper.isObject(obj!)) { - strB.append(this.objectDescription(obj!, delimiter, depth, full)) + } else if (UtilHelper.isObject(obj)) { + strB.append(this.objectDescription(obj, delimiter, depth, full)) } else { - strB.append(UtilHelper.simpleObjectDescription(obj!, '')) + strB.append(UtilHelper.simpleObjectDescription(obj, '')) } return strB.toString() } @@ -1290,7 +1290,7 @@ export namespace util { return subObj ? subObj! as int : 0 } - private static getValue(key: string, obj: Object): NullishType { + private static getValue(key: string, obj: Object): Any { if (!obj) { return null } diff --git a/static_core/plugins/ets/sdk/api/@ohos.util.json.ets b/static_core/plugins/ets/sdk/api/@ohos.util.json.ets index fb642f65e1..e1bec15b72 100644 --- a/static_core/plugins/ets/sdk/api/@ohos.util.json.ets +++ b/static_core/plugins/ets/sdk/api/@ohos.util.json.ets @@ -15,7 +15,7 @@ export namespace json { - export type Transformer = (key: string, value: NullishType) => NullishType + export type Transformer = (key: string, value: Any) => Any export enum BigIntMode { DEFAULT = 0, @@ -43,9 +43,9 @@ /** * Converts an object to a JavaScript Object Notation (JSON) string. * - * @param obj: NullishType An object to be converted. + * @param obj: Any An object to be converted. * - * @param replacer An array with elements indicating names of the properties in the object + * @param replacer An array with elements indicating names of the properties in the object * or Transformer function changing field values * that should be included in the resulting JSON string * @@ -54,7 +54,7 @@ * * @returns String - JSON representation of Object */ - export function stringify(value: NullishType, replacer?: Transformer | ((double | string)[]) | null, space?: string | int): string { + export function stringify(value: Any, replacer?: Transformer | ((double | string)[]) | null, space?: string | int): string { if ((replacer === null) || (replacer === undefined)) { return JSON.stringify(value, undefined, space) } else if (replacer! instanceof Transformer) { @@ -82,4 +82,4 @@ return JSON.parse(text, reviver, type, opt) } - } \ No newline at end of file + } diff --git a/static_core/plugins/ets/sdk/api/@ohos.xml.ets b/static_core/plugins/ets/sdk/api/@ohos.xml.ets index 047a800f9b..d90182446b 100644 --- a/static_core/plugins/ets/sdk/api/@ohos.xml.ets +++ b/static_core/plugins/ets/sdk/api/@ohos.xml.ets @@ -622,7 +622,7 @@ export namespace xml { } public calcPosition(str: string, node: XmlNode) { - let lineEndMatch: NullishType + let lineEndMatch: Any let pos: int = 1 let end: int = str.length > 1 ? str.length.toInt() + 1 : 1 let lineChanged: boolean = false @@ -661,7 +661,7 @@ export namespace xml { private startDocumentFound: boolean = false private documentEntities = new Map() private processServiceTag(regexp: RegExp, type: EventType) { - let m : NullishType + let m : Any let pos: int = 0 while (m = regexp.exec(this.strXml_.substr(pos))) { pos = m!.index.toInt() + 1 @@ -704,7 +704,7 @@ export namespace xml { private processAllStartTags() { let pos: int = 0 - let m : NullishType + let m: Any while (m = XmlParseHelper.startTagRegExp.exec(this.strXml_.substr(pos))) { pos += m!.index let item = m!.result[0] @@ -738,7 +738,7 @@ export namespace xml { private processAllEndTags() { let pos: int = 0 - let m : NullishType + let m: Any while (m = XmlParseHelper.closeTagRegExp.exec(this.strXml_.substr(pos))) { pos += m!.index let item = m!.result[0] @@ -762,7 +762,7 @@ export namespace xml { } private processAllSelfCloseTags() { - let m : NullishType + let m: Any let pos: int = 0 while (m = XmlParseHelper.selfCloseTagRegExp.exec(this.strXml_.substr(pos))) { pos += m!.index @@ -799,7 +799,7 @@ export namespace xml { } private processAllTextTags() { - let m : NullishType + let m: Any let pos:int = 0 while (m = XmlParseHelper.textTagRegExp.exec(this.strXml_.substr(pos))) { pos += m!.index @@ -861,13 +861,13 @@ export namespace xml { this.processNode(endNode) } - private isNullish(obj: NullishType): boolean { + private isNullish(obj: Any): boolean { return (obj == undefined) } private getAttributes(str: string, node: XmlNode): Map { let attributes = new Map() - let keyValueMatch : NullishType + let keyValueMatch : Any while (!this.isNullish(keyValueMatch = str.match(XmlParseHelper.attributeRegExp))) { if (node.attributes) { attributes = node.attributes! diff --git a/static_core/plugins/ets/stdlib/escompat/Array.ets b/static_core/plugins/ets/stdlib/escompat/Array.ets index 38179098f2..b2daa323f4 100644 --- a/static_core/plugins/ets/stdlib/escompat/Array.ets +++ b/static_core/plugins/ets/stdlib/escompat/Array.ets @@ -67,7 +67,7 @@ const FROM_BUFFER: FromBuffer; * Represents JS API-compatible Array */ export class Array implements ReadonlyArray, Iterable { - private buffer: FixedArray + private buffer: FixedArray internal actualLength: int override get length(): number { @@ -108,7 +108,7 @@ export class Array implements ReadonlyArray, Iterable { * Creates a new instance of Array */ public constructor(arrayLen: int) { - this.buffer = new NullishType[arrayLen] + this.buffer = new Any[arrayLen] this.actualLength = arrayLen } @@ -116,13 +116,13 @@ export class Array implements ReadonlyArray, Iterable { this(arrayLen.toInt()) } - internal constructor(_tag: FromBuffer, buf: FixedArray) { + internal constructor(_tag: FromBuffer, buf: FixedArray) { this.buffer = buf this.actualLength = buf.length } internal constructor() { - this.buffer = new NullishType[4] + this.buffer = new Any[4] this.actualLength = 0 } @@ -132,7 +132,7 @@ export class Array implements ReadonlyArray, Iterable { * @param d Array initializer */ public constructor(first: T, ...d: T[]) { - this.buffer = new NullishType[d.length + 1] + this.buffer = new Any[d.length + 1] this.actualLength = d.length.toInt() + 1 this.buffer[0] = first @@ -312,9 +312,9 @@ export class Array implements ReadonlyArray, Iterable { */ public static from(arr: FixedArray): Array { const len = arr.length - const ret : FixedArray = new NullishType[len.toInt()] + const ret : FixedArray = new Any[len.toInt()] for (let i: int = 0; i < len; i++) { - ret[i] = arr[i] as NullishType + ret[i] = arr[i] as Any } return new Array(FROM_BUFFER, ret) } @@ -636,7 +636,7 @@ export class Array implements ReadonlyArray, Iterable { * * @returns Returns one of values -1, 0, 1 (_less_, _equal_, _greater_ respectively). */ - private static defaultComparator(a: NullishType, b: NullishType): number { + private static defaultComparator(a: Any, b: Any): number { if (a instanceof Number && b instanceof Number) { const x = a const y = b @@ -694,9 +694,9 @@ export class Array implements ReadonlyArray, Iterable { * * @returns Copy of an `Array`'s primitive array data. */ - private copyArray(): FixedArray { + private copyArray(): FixedArray { let len: int = this.actualLength - let res : FixedArray = new NullishType[len] + let res : FixedArray = new Any[len] for (let i = 0; i < len; i++) { res[i] = this.$_get_unsafe(i) } @@ -726,7 +726,7 @@ export class Array implements ReadonlyArray, Iterable { this.$_set_unsafe(i, undefined as T) } - sort_default(this.buffer, strArr, 0, sortTo) + sort_default(this.buffer, strArr, 0, sortTo) } catch (e) { if (e instanceof OutOfMemoryError) { @@ -739,7 +739,7 @@ export class Array implements ReadonlyArray, Iterable { private slow_default_sort(): void { let idxNonUndef = 0 - const cmp: (l: NullishType, r: NullishType) => number = (l: NullishType, r: NullishType): number => { + const cmp: (l: Any, r: Any) => number = (l: Any, r: Any): number => { return Array.defaultComparator(l, r) } for (let i = 0; i < this.actualLength; i++) { @@ -753,7 +753,7 @@ export class Array implements ReadonlyArray, Iterable { for (let i = idxNonUndef; i < this.actualLength; i++) { this.$_set_unsafe(i, undefined as T) } - sort_stable(this.buffer, 0, sortTo, cmp) + sort_stable(this.buffer, 0, sortTo, cmp) } private move_undefined_end(): int { @@ -796,10 +796,10 @@ export class Array implements ReadonlyArray, Iterable { } const compareTo: int = this.move_undefined_end() - let cmp: (l: NullishType, r: NullishType) => number = (l: NullishType, r: NullishType): number => { + let cmp: (l: Any, r: Any) => number = (l: Any, r: Any): number => { return comparator!(l as T, r as T) } - sort_stable(this.buffer, 0, compareTo, cmp) + sort_stable(this.buffer, 0, compareTo, cmp) return this } @@ -883,7 +883,7 @@ export class Array implements ReadonlyArray, Iterable { private ensureUnusedCapacity(cap: int): void { if (this.actualLength + cap > this.buffer.length) { - const copy : FixedArray = new NullishType[this.buffer.length * 2 + cap] + const copy : FixedArray = new Any[this.buffer.length * 2 + cap] for (let i = 0; i < this.actualLength; i++) { copy[i] = this.buffer[i] } @@ -985,7 +985,7 @@ export class Array implements ReadonlyArray, Iterable { * * @returns true is arr is a non-nullish array, false otherwise */ - public static isArray(o: NullishType): boolean { + public static isArray(o: Any): boolean { if (o instanceof Array) { return true } @@ -1020,7 +1020,7 @@ export class Array implements ReadonlyArray, Iterable { public unshift(...values: T[]): number { let buffer = this.buffer if (this.buffer.length <= values.length + this.actualLength) { - buffer = new NullishType[this.buffer.length * 2 + values.length] + buffer = new Any[this.buffer.length * 2 + values.length] } for (let i = 0; i < this.actualLength; i++) { buffer[this.actualLength + values.length.toInt() - i - 1] = this.buffer[this.actualLength - 1 - i] @@ -1152,7 +1152,7 @@ export class Array implements ReadonlyArray, Iterable { totalAdd += items[i].length.toInt() } - const buf : FixedArray = new NullishType[totalAdd]; + const buf : FixedArray = new Any[totalAdd]; for (let i = 0; i < this.actualLength; i++) { buf[i] = this.$_get_unsafe(i); @@ -1518,7 +1518,7 @@ export class Array implements ReadonlyArray, Iterable { if (count < 0) { count = 0; } - let res : FixedArray = new NullishType[count] + let res : FixedArray = new Any[count] for (let i = 0; i < count; i++) { res[i] = this.$_get_unsafe(relStart + i); } @@ -1702,7 +1702,7 @@ export class Array implements ReadonlyArray, Iterable { if (i != 0) { sb.append(",") } - let x = this.$_get_unsafe(i) as NullishType; + let x = this.$_get_unsafe(i) as Any; if ((null !== x) && (undefined !== x)) { sb.append((x! as object).toLocaleString()) // #26217 } @@ -1758,7 +1758,7 @@ export class Array implements ReadonlyArray, Iterable { if (start > len - delete) { delete = len - start } - const res : FixedArray = new NullishType[len - delete + items.length]; + const res : FixedArray = new Any[len - delete + items.length]; for (let i = 0; i < start; i++) { res[i] = this.$_get_unsafe(i) } @@ -1892,7 +1892,7 @@ export class Array implements ReadonlyArray, Iterable { * @returns reversed copy of the current Array */ public toReversed(): Array { - let arr : FixedArray = new NullishType[this.actualLength] + let arr : FixedArray = new Any[this.actualLength] for (let i = 0; i < this.actualLength; i++) { arr[this.actualLength - 1 - i] = this.$_get_unsafe(i) } @@ -1958,7 +1958,7 @@ export class Array implements ReadonlyArray, Iterable { */ public override map(callbackfn: (value: T, index: number, array: Array) => U): Array { const len = this.actualLength; - let res : FixedArray = new NullishType[len]; + let res : FixedArray = new Any[len]; for (let i = 0; i < this.actualLength; i++) { res[i] = callbackfn(this.$_get_unsafe(i), i.toDouble(), this); } diff --git a/static_core/plugins/ets/stdlib/escompat/BigInt.ets b/static_core/plugins/ets/stdlib/escompat/BigInt.ets index 78d5c9f05c..2eac3520f4 100644 --- a/static_core/plugins/ets/stdlib/escompat/BigInt.ets +++ b/static_core/plugins/ets/stdlib/escompat/BigInt.ets @@ -161,7 +161,7 @@ export final class BigInt { return true } - equals(other: NullishType): boolean { + equals(other: Any): boolean { if (Runtime.isSameReference(this, other)) { return true } diff --git a/static_core/plugins/ets/stdlib/escompat/Global.ets b/static_core/plugins/ets/stdlib/escompat/Global.ets index a67e093aa9..4f217ee129 100644 --- a/static_core/plugins/ets/stdlib/escompat/Global.ets +++ b/static_core/plugins/ets/stdlib/escompat/Global.ets @@ -304,10 +304,10 @@ export function setTimeout(func: Function): int { * * @param { Function } func - the function to be executed after the timer expires. * @param { int } delayMs - timeout in milliseconds. - * @param { ...NullishType } args - parameters passed to func. + * @param { ...Any } args - parameters passed to func. * @returns { int } timer id */ -export function setTimeout(func: Function, delayMs: int, ...args: FixedArray): int { +export function setTimeout(func: Function, delayMs: int, ...args: FixedArray): int { return startTimer((): void => { func.unsafeCall(...args) }, delayMs, false); } @@ -360,10 +360,10 @@ export function setInterval(func: Function): int { * * @param { Function } func - the function to be executed. * @param { int } delayMs - timeout in milliseconds. - * @param { ...NullishType } args - parameters passed to func. + * @param { ...Any } args - parameters passed to func. * @returns { int } - timer id */ -export function setInterval(func: Function, delayMs: int, ...args: FixedArray): int { +export function setInterval(func: Function, delayMs: int, ...args: FixedArray): int { return startTimer((): void => { func.unsafeCall(...args) }, delayMs, true); } diff --git a/static_core/plugins/ets/stdlib/escompat/Map.ets b/static_core/plugins/ets/stdlib/escompat/Map.ets index 4808e2d23d..3145ca0671 100644 --- a/static_core/plugins/ets/stdlib/escompat/Map.ets +++ b/static_core/plugins/ets/stdlib/escompat/Map.ets @@ -136,7 +136,7 @@ export class Map implements ReadonlyMap { private static readonly MIN_BUCKETS_COUNT = 8 - private getBucketIndex(k: NullishType): int { + private getBucketIndex(k: Any): int { if (__runtimeIsSameReference(k, null)) { return 0; } diff --git a/static_core/plugins/ets/stdlib/escompat/Reflect.ets b/static_core/plugins/ets/stdlib/escompat/Reflect.ets index 56b41afb46..51366a8239 100644 --- a/static_core/plugins/ets/stdlib/escompat/Reflect.ets +++ b/static_core/plugins/ets/stdlib/escompat/Reflect.ets @@ -32,7 +32,7 @@ export class Reflect { * * @returns the value of the field */ - public static get(target: Object, key: PropertyKey): NullishType { + public static get(target: Object, key: PropertyKey): Any { if (target instanceof Char || target instanceof Boolean || target instanceof Byte || @@ -92,7 +92,7 @@ export class Reflect { * * @returns property value */ - public static get(target: Record, key: string): NullishType { + public static get(target: Record, key: string): Any { return target[key] } @@ -123,7 +123,7 @@ export class Reflect { let t = Type.of(target) if (t instanceof ArrayType) { let av = reflect.Value.of(target) as ArrayValue - return __narrowAny(av.getElement(index.toLong()).getData()) + return av.getElement(index.toLong()).getData() as (object | undefined) } else if (t instanceof EnumType) { // NOTE(shumilov-petr): Not implemented throw new Error("Not implemented") @@ -140,7 +140,7 @@ export class Reflect { // same as Double.numberFromString private static native numberFromString(s: String): double; - private static toNumberInt(value: NullishType): double { + private static toNumberInt(value: Any): double { if (value instanceof double || value instanceof int) { return value as double; } @@ -162,7 +162,7 @@ export class Reflect { return NaN; } - private static toNumberDouble(value: NullishType): double { + private static toNumberDouble(value: Any): double { if (value instanceof double || value instanceof int) { return value as double; } @@ -345,7 +345,7 @@ export class Reflect { return result; } - private static toBigInt(value: NullishType): long|bigint|double { + private static toBigInt(value: Any): long|bigint|double { if (value instanceof long || value instanceof bigint) { return value; } @@ -390,7 +390,7 @@ export class Reflect { return index; } - private static setIntTypedArray(target: ArrayLike, key: PropertyKey, value: NullishType): boolean { + private static setIntTypedArray(target: ArrayLike, key: PropertyKey, value: Any): boolean { let index: int = Reflect.getIndexForTypedArray(target, key); if (index < 0) { return true; @@ -416,7 +416,7 @@ export class Reflect { return true; } - private static setBigIntTypedArray(target: ArrayLike, key: PropertyKey, value: NullishType): boolean { + private static setBigIntTypedArray(target: ArrayLike, key: PropertyKey, value: Any): boolean { let index: int = Reflect.getIndexForTypedArray(target, key); if (index < 0) { return true; @@ -439,7 +439,7 @@ export class Reflect { return true; } - private static setFloatTypedArray(target: ArrayLike, key: PropertyKey, value: NullishType): boolean { + private static setFloatTypedArray(target: ArrayLike, key: PropertyKey, value: Any): boolean { let index: int = Reflect.getIndexForTypedArray(target, key); if (index < 0) { return true; @@ -487,7 +487,7 @@ export class Reflect { * * @returns a Boolean indicating whether or not setting the field was successful */ - public static set(target: Object, key: PropertyKey, value: NullishType): boolean { + public static set(target: Object, key: PropertyKey, value: Any): boolean { let typedArrayFlag: boolean = Reflect.checkIntTypedArray(target); if (typedArrayFlag) { return Reflect.setIntTypedArray(target as ArrayLike, key, value); @@ -550,7 +550,7 @@ export class Reflect { * * @returns a Boolean indicating whether or not setting the property was successful */ - public static set(target: Record, key: string, value: Object): Boolean { + public static set(target: Record, key: string, value: Object): Boolean { target[key] = value return true } @@ -602,7 +602,7 @@ export class Reflect { * * @returns as array of the target Record property names */ - public static ownKeys(target: Record): string[] { + public static ownKeys(target: Record): string[] { return Object.getOwnPropertyNames(target) } @@ -664,7 +664,7 @@ export class Reflect { * * @returns a boolean indicating whether or not the record has the specified property */ - public static has(target: Record, key: string): boolean { + public static has(target: Record, key: string): boolean { return target.has(key) } diff --git a/static_core/plugins/ets/stdlib/escompat/RegExp.ets b/static_core/plugins/ets/stdlib/escompat/RegExp.ets index 3562e75105..0ffa3d42e0 100644 --- a/static_core/plugins/ets/stdlib/escompat/RegExp.ets +++ b/static_core/plugins/ets/stdlib/escompat/RegExp.ets @@ -896,7 +896,7 @@ export class RegExp extends Object { let capN = result.$_get(n); args.pushBack(capN) } - let namedCaptures: NullishType = /*result.groups*/ undefined; + let namedCaptures: Any = /*result.groups*/ undefined; args.pushBack(position.toDouble()); args.pushBack(str) if (namedCaptures != undefined) { diff --git a/static_core/plugins/ets/stdlib/escompat/deepcopy.ets b/static_core/plugins/ets/stdlib/escompat/deepcopy.ets index d27dd702a9..3775f3f05a 100644 --- a/static_core/plugins/ets/stdlib/escompat/deepcopy.ets +++ b/static_core/plugins/ets/stdlib/escompat/deepcopy.ets @@ -147,7 +147,7 @@ class DeepCloner { const fieldName = objEntry![DeepCloner.OBJ_ENTRY_NAME] const field = objType.getFieldByName(fieldName as String) - const objFieldValueCopy = this.clone(__narrowAny(objEntry![DeepCloner.OBJ_ENTRY_VALUE])) + const objFieldValueCopy = this.clone(objEntry![DeepCloner.OBJ_ENTRY_VALUE] as (Object | undefined)) if (field.getType().assignableFrom(Type.of(objFieldValueCopy))) { objCopyValue.setFieldByName(fieldName as string, reflect.Value.of(objFieldValueCopy) as reflect.Value) } @@ -174,8 +174,8 @@ class DeepCloner { for (let i = 0; i < arrayLength; i++) { const arrayElementValue = arrayValue.getElement(i) - const arrayElementCopy = this.clone(__narrowAny(arrayElementValue.getData())) - arrayCopyValue.setElement(i, reflect.Value.of(__narrowAny(arrayElementCopy))) + const arrayElementCopy = this.clone(arrayElementValue.getData() as (Object | undefined)) + arrayCopyValue.setElement(i, reflect.Value.of(arrayElementCopy as (Object | undefined))) } this.currentDepth-- diff --git a/static_core/plugins/ets/stdlib/escompat/json.ets b/static_core/plugins/ets/stdlib/escompat/json.ets index 36994645ac..497b82ef0d 100644 --- a/static_core/plugins/ets/stdlib/escompat/json.ets +++ b/static_core/plugins/ets/stdlib/escompat/json.ets @@ -21,13 +21,13 @@ import { jsonx } from "std/core" const BigIntType: Type; export interface JsonReplacer { - jsonReplacer(): Record + jsonReplacer(): Record } // NOTE (chengzhihao): $Partial is not generated for exported interfaces.issue #26111 // now use this class to throw the error. export class JsonReplacerTemp implements JsonReplacer { - jsonReplacer(): Record { + jsonReplacer(): Record { throw new Error("frontend bug"); } } @@ -244,7 +244,7 @@ export class JSON { * * @returns String - JSON representation of Object */ - public static stringify(obj: NullishType): String { + public static stringify(obj: Any): String { if (obj === undefined) { return "undefined" } @@ -255,7 +255,7 @@ export class JSON { return new JSONWriter().write(obj) } - private static native stringifyFast(obj: NullishType): String; + private static native stringifyFast(obj: Any): String; public static stringify(obj: JsonReplacer): String { const record = obj.jsonReplacer(); @@ -275,10 +275,10 @@ export class JSON { * @returns String - JSON representation of Object */ public static stringify( - obj: NullishType, - replacer: ((key: string, value: NullishType) => NullishType) | undefined | null, + obj: Any, + replacer: ((key: string, value: Any) => Any) | undefined | null, space?: string | int): string { - const replacerOpt: ((key: string, value: NullishType) => NullishType) | undefined = (replacer === null) ? undefined : replacer + const replacerOpt: ((key: string, value: Any) => Any) | undefined = (replacer === null) ? undefined : replacer if (space instanceof String || space === undefined) { return new JSONWriter(replacerOpt, space).write(obj) @@ -300,7 +300,7 @@ export class JSON { * * @returns String - JSON representation of Object */ - public static stringify(obj: NullishType, replacer: FixedArray, space?: int | string): string { + public static stringify(obj: Any, replacer: FixedArray, space?: int | string): string { const filter : FixedArray = new string[replacer.length] for (let i = 0; i < replacer.length; i++) { filter[i] = `${replacer[i]}` @@ -313,7 +313,7 @@ export class JSON { } } - public static stringify(obj: NullishType, replacer: Array, space?: int | string): string { + public static stringify(obj: Any, replacer: Array, space?: int | string): string { const filter : FixedArray = new string[replacer.length] for (let i = 0; i < replacer.length; i++) { filter[i] = `${replacer[i]}` @@ -623,7 +623,7 @@ export class JSON { return JSON.parse(text, undefined, type) } - public static parse(text: string, reviver: ((key: string, value: NullishType) => NullishType) | undefined, type: Type, bigIntMode?: int): Nullish { + public static parse(text: string, reviver: ((key: string, value: Any) => Any) | undefined, type: Type, bigIntMode?: int): Nullish { if (!JSON.checkType(type, new Array())) { throw new Error("Incorrect type: " + type.toString()) } @@ -682,7 +682,7 @@ class JSONWriter { private static readonly ESCOMPAT_MAP_TYPE = Type.of(new Map()) private static readonly STD_CORE_PROMISE_TYPE = Type.of(new Promise((res) => {})) - private readonly replacer: ((key: String, value: NullishType) => NullishType) | undefined + private readonly replacer: ((key: String, value: Any) => Any) | undefined private readonly fieldsFilter: FixedArray private readonly space: String | undefined @@ -695,7 +695,7 @@ class JSONWriter { private readonly path = new Set() private buffer = new StringBuilder() - constructor(replacer?: (key: String, value: NullishType) => NullishType, space?: String) { + constructor(replacer?: (key: String, value: Any) => Any, space?: String) { this.replacer = replacer this.fieldsFilter = [] this.space = space @@ -715,7 +715,7 @@ class JSONWriter { this.useIndent = !(this.space == undefined || this.space == "") } - write(obj: NullishType): String { + write(obj: Any): String { if (this.useReplacer) { this.writeObject(this.replacer!("", obj)) } else { @@ -725,8 +725,7 @@ class JSONWriter { return this.buffer.toString() } - private writeObject(obj: NullishType): void { - obj = __narrowAny(obj) + private writeObject(obj: Any): void { if (obj === null) { this.buffer.append("null") } else if (obj === undefined) { @@ -740,13 +739,13 @@ class JSONWriter { } else if (obj instanceof Record) { this.writeESCompatRecord(obj) } else if (obj instanceof JsonReplacer) { - let temp: Record = obj.jsonReplacer() + let temp: Record = obj.jsonReplacer() this.writeESCompatRecord(temp) } else if (obj instanceof ESValue) { this.writeInteropESValue(obj) } else if (obj instanceof JsonElementDeserializable) { this.buffer.append(JSON.stringifyJsonElement((obj as JsonElementDeserializable).toJSON())) - } else if (this.writeValueTypeWrapper(obj)) { + } else if (this.writeValueTypeWrapper(obj as Object)) { // nothing to do - write completed successfully } else { const objType = Type.of(obj) @@ -765,7 +764,7 @@ class JSONWriter { objType.getName() == JSONWriter.ESCOMPAT_MAP_TYPE.getName()) { this.buffer.append(JSONObject.EMPTY) } else if (objType instanceof ClassType) { - this.writeClassValue(obj, objType as ClassType) + this.writeClassValue(obj as Object, objType as ClassType) } else if (objType instanceof LambdaType) { this.buffer.append("undefined") } else { @@ -973,7 +972,7 @@ class JSONWriter { this.buffer = currentBuffer } - private writeField(fieldName: string, fieldVal: NullishType, fieldDumped: boolean): boolean { + private writeField(fieldName: string, fieldVal: Any, fieldDumped: boolean): boolean { if (fieldVal === undefined) { return fieldDumped } @@ -1115,7 +1114,7 @@ class JSONWriter { const arrayLength = arrayValue.getLength().toInt() if (arrayLength > 0) { - const array: Object = __narrowAny(arrayValue.getData())! + const array: Object = arrayValue.getData() as Object this.path.add(array) @@ -1219,7 +1218,7 @@ class JSONWriter { this.buffer.append("]") } - private writeObjectsArrayElement(arrayElement: NullishType, elementIndex: int): void { + private writeObjectsArrayElement(arrayElement: Any, elementIndex: int): void { this.writePadding() const replacedArrayElement = this.useReplacer ? this.replacer!("" + elementIndex, arrayElement) : arrayElement @@ -1233,12 +1232,12 @@ class JSONWriter { } } - private checkReferencesCycle(obj: NullishType): void { + private checkReferencesCycle(obj: Any): void { if (obj == null) { return } - const cycleDetected = this.path.has(__narrowAny(obj)) + const cycleDetected = this.path.has(obj as Object) if (cycleDetected) { throw new TypeError("cyclic object value") } @@ -1679,15 +1678,15 @@ export class JSONParser { } class JSONValueParser { - private reviver: ((key: string, value: NullishType) => NullishType) | undefined + private reviver: ((key: string, value: Any) => Any) | undefined private bigIntMode: int - constructor(reviver: ((key: string, value: NullishType) => NullishType) | undefined, bigIntMode: int) { + constructor(reviver: ((key: string, value: Any) => Any) | undefined, bigIntMode: int) { this.reviver = reviver this.bigIntMode = bigIntMode } - private createNumber(value: JSONNumber, typ: Type): NullishType { + private createNumber(value: JSONNumber, typ: Type): Any { if (typ.equals(BigIntType) && (this.bigIntMode === 2 || (!Double.isSafeInteger(value.value) && this.bigIntMode === 1))) { return new BigInt(value.bigintValue) } else if (typ instanceof DoubleType && (this.bigIntMode === 0 || (Double.isSafeInteger(value.value) && this.bigIntMode === 1))) { @@ -1707,7 +1706,7 @@ class JSONValueParser { } } - parse(value: JSONValue, typ: Type): NullishType { + parse(value: JSONValue, typ: Type): Any { if (value instanceof JSONObject && typ instanceof ClassType) { return this.parseObject(value as JSONObject, typ as ClassType) } else if (value instanceof JSONObject && typ instanceof UnionType) { @@ -1730,15 +1729,15 @@ class JSONValueParser { } } - private classFieldSetter(classVal: ClassValue, fieldName: string, fieldVal: NullishType): void { + private classFieldSetter(classVal: ClassValue, fieldName: string, fieldVal: Any): void { classVal.setFieldByName(fieldName, reflect.Value.of(fieldVal)) } private parseObject(jsonObj: JSONObject, classType: ClassType): Object { - let setClassFieldFn = (cv: ClassValue, fn: string, fv: NullishType) => { cv.setFieldByName(fn, reflect.Value.of(fv)) } + let setClassFieldFn = (cv: ClassValue, fn: string, fv: Any) => { cv.setFieldByName(fn, reflect.Value.of(fv)) } if (this.reviver != undefined) { - setClassFieldFn = (classVal: ClassValue, fieldName: string, fieldVal: NullishType): void => { + setClassFieldFn = (classVal: ClassValue, fieldName: string, fieldVal: Any): void => { const revivedVal = this.reviver!(fieldName, fieldVal) // setFieldByName doesn't allow null/undefined values @@ -1785,12 +1784,12 @@ class JSONValueParser { private parseArray(jVal: JSONArray, aType: ArrayType): Object | null { let len = jVal.values.length - let arr = aType.make(len.toInt()) as FixedArray + let arr = aType.make(len.toInt()) as FixedArray - let setArrayElementFn = (a: FixedArray, i: int, v: NullishType) => { a[i] = v } + let setArrayElementFn = (a: FixedArray, i: int, v: Any) => { a[i] = v } if (this.reviver !== undefined) { - setArrayElementFn = (array: FixedArray, index: int, elemVal: NullishType): void => { + setArrayElementFn = (array: FixedArray, index: int, elemVal: Any): void => { const revivedVal = this.reviver!(`${index}`, elemVal) array[index] = revivedVal !== undefined ? revivedVal : null } diff --git a/static_core/plugins/ets/stdlib/escompat/taskpool.ets b/static_core/plugins/ets/stdlib/escompat/taskpool.ets index 93a77533fb..f88670370c 100644 --- a/static_core/plugins/ets/stdlib/escompat/taskpool.ets +++ b/static_core/plugins/ets/stdlib/escompat/taskpool.ets @@ -76,16 +76,16 @@ export namespace taskpool { } workerPendingTasksCount.set(this.workerId, workerPendingTasksCount.get(this.workerId)! + 1); this.currentPriority = task.priority; - let job = this.run((): NullishType => { + let job = this.run((): Any => { let res = task?.execute(); return res; }); - const taskRunner = (value: NullishType): NullishType => { + const taskRunner = (value: Any): Any => { let res = job.Await(); return res; } - let p = Promise.resolve(new Object()).then(taskRunner, taskRunner); - p.then((res: NullishType) => { + let p = Promise.resolve(new Object()).then(taskRunner, taskRunner); + p.then((res: Any) => { task?.resolve(res); this.notifyTaskFinished(task); }).catch((e) => { @@ -167,19 +167,19 @@ export namespace taskpool { * * @param { string } name The name of task * @param { Function } func Concurrent function to execute in the taskpool - * @param { ...NullishType } args arguments for function to execute with + * @param { ...Any } args arguments for function to execute with */ - constructor(name: string, func: Function, ...args: FixedArray) { + constructor(name: string, func: Function, ...args: FixedArray) { this.name = name; this.arguments = Array.from(args); if (isSupportingInterop()) { let serializeHelper = new InteropSerializeHelper(args); - this.taskFunction = (): NullishType => { + this.taskFunction = (): Any => { let deserializedArgs = serializeHelper.deserialize(); return func.unsafeCall(...deserializedArgs); }; } else { - this.taskFunction = (): NullishType => { + this.taskFunction = (): Any => { return func.unsafeCall(...args); }; } @@ -197,9 +197,9 @@ export namespace taskpool { * Create a Task instance * * @param { Function } func Concurrent function to execute in the taskpool - * @param { ...NullishType } args arguments for function to execute with + * @param { ...Any } args arguments for function to execute with */ - constructor(func: Function, ...args: FixedArray) { + constructor(func: Function, ...args: FixedArray) { this(func.name, func, ...args); } @@ -342,11 +342,11 @@ export namespace taskpool { /** * Send data to host side and trigger the registered callback - * @param { ...NullishType } args arguments for the registered callback + * @param { ...Any } args arguments for the registered callback * @throws Error if the function is not called from a taskpool task * @throws Error if the callback is not registered */ - static sendData(...args: FixedArray): void { + static sendData(...args: FixedArray): void { const item: Task | undefined = getCurrentTask(); if (item === undefined) { throw new Error(TASKPOOL_ERROR_NOT_IN_TASKPOOL, "taskpool:: The function is not called in the TaskPool thread"); @@ -368,10 +368,10 @@ export namespace taskpool { } /// Concurrent function to execute in taskpool - taskFunction: () => NullishType; + taskFunction: () => Any; /// The concurrent function arguments - arguments?: NullishType[]; + arguments?: Any[]; /// Task name name: string; @@ -478,7 +478,7 @@ export namespace taskpool { return ((Chrono.nanoNow() - this.startTime) / Chrono.NS_PER_MS).toInt(); } - internal execute(): NullishType { + internal execute(): Any { initWorkerPool(); this.waitForDependencies(); if (!taskStarted(this)) { @@ -486,7 +486,7 @@ export namespace taskpool { this.throwCancelTaskError(); } this.callUserCallback(this.onStartCallback); - let result: NullishType = null; + let result: Any = null; this.startTime = Chrono.nanoNow(); const startCpuTime: long = Chrono.getCpuTime(); try { @@ -556,13 +556,13 @@ export namespace taskpool { * @see taskpool.execute * @see taskpool.SequenceRunner.execute */ - internal getOnReceivePromise(p: Promise): Promise { + internal getOnReceivePromise(p: Promise): Promise { if (this.onReceiveCallback === undefined) { return p; } - return p.then((value: NullishType): NullishType => { - const argsArray: Array> = this.extractDataArgs(); - argsArray.forEach((args: FixedArray) => { + return p.then((value: Any): Any => { + const argsArray: Array> = this.extractDataArgs(); + argsArray.forEach((args: FixedArray) => { try { this.onReceiveCallback!.unsafeCall(...args); } catch(e: Error) {} @@ -593,10 +593,10 @@ export namespace taskpool { } /// @see taskpool.Task.getOnReceivePromise - internal extractDataArgs(): Array> { + internal extractDataArgs(): Array> { ConcurrencyHelpers.mutexLock(this.dataMutex); - const argsArray: Array> = this.argsArray; - this.argsArray = new Array>(); + const argsArray: Array> = this.argsArray; + this.argsArray = new Array>(); ConcurrencyHelpers.mutexUnlock(this.dataMutex); return argsArray; } @@ -641,7 +641,7 @@ export namespace taskpool { internal taskMutex: Object; internal condVar: Object; - internal resolve: (value: NullishType) => void; + internal resolve: (value: Any) => void; internal reject: (e: Error) => void; internal priority: Priority; @@ -650,7 +650,7 @@ export namespace taskpool { private onReceiveCallback?: Function; private dataMutex: Object = ConcurrencyHelpers.mutexCreate(); - private argsArray: Array> = new Array>(); + private argsArray: Array> = new Array>(); private onEnqueueCallback?: CallbackFunction; private onStartCallback?: CallbackFunction; @@ -669,16 +669,16 @@ export namespace taskpool { * @param { string } name The name of long task * @param { Function } func Concurrent function to execute in the taskpool */ - constructor(name: string, func: Function, ...args: FixedArray) { + constructor(name: string, func: Function, ...args: FixedArray) { super(name, func, ...args); } /** * Create a LongTask instance * @param { Function } func Concurrent function to execute in the taskpool - * @param { ...NullishType } args arguments for func to execute with + * @param { ...Any } args arguments for func to execute with */ - constructor(func: Function, ...args: FixedArray) { + constructor(func: Function, ...args: FixedArray) { super("", func, ...args); } @@ -722,9 +722,9 @@ export namespace taskpool { * Add a concurrent function into task group * * @param { Function } func the concurrent function to add to the task group - * @param { ...NullishType } args arguments for func to execute with + * @param { ...Any } args arguments for func to execute with */ - addTask(func: Function, ...args: FixedArray): void { + addTask(func: Function, ...args: FixedArray): void { this.addTask(new Task(func, ...args)); } @@ -778,10 +778,10 @@ export namespace taskpool { class SeqRunnerImpl { constructor(id: int) { this.id = id; - this.seqPromise = Promise.resolve(new Object()); + this.seqPromise = Promise.resolve(new Object()); } readonly id: int; - seqPromise: Promise; + seqPromise: Promise; } /** @@ -801,7 +801,7 @@ export namespace taskpool { this.tasks = new Array(); } - execute(task: Task): Promise { + execute(task: Task): Promise { initWorkerPool(); this.checkExecution(task); task.seqId = this.impl.id; @@ -810,17 +810,17 @@ export namespace taskpool { task.isSubmitted = true; if (isTaskPoolUseLaunch) { task.enqueue(this.priority); - const taskRunner = (value: NullishType): NullishType => { + const taskRunner = (value: Any): Any => { return task.execute(); }; - this.impl.seqPromise = task.getOnReceivePromise(this.impl.seqPromise.then(taskRunner, (error) => { + this.impl.seqPromise = task.getOnReceivePromise(this.impl.seqPromise.then(taskRunner, (error) => { taskRunner(undefined); return new Promise((resolve, reject) => {}); } )); return this.impl.seqPromise; } - const promise = new Promise((resolve, reject) => { + const promise = new Promise((resolve, reject) => { task.resolve = resolve; task.reject = reject; }); @@ -920,10 +920,10 @@ export namespace taskpool { * Create task and execute * * @param { Function } func a concurrent function to create task from - * @param { ...NullishType } args arguments for func to execute with - * @returns { Promise } Promise for result of executed task + * @param { ...Any } args arguments for func to execute with + * @returns { Promise } Promise for result of executed task */ - export function execute(func: Function, ...args: FixedArray): Promise { + export function execute(func: Function, ...args: FixedArray): Promise { initWorkerPool(); if (isTaskPoolUseLaunch) { return launchPromise(func, ...args); @@ -937,9 +937,9 @@ export namespace taskpool { * * @param task The task to execute * @param { Priority } [priority] priority for the task - * @returns { Promise } Promise for result of executed task + * @returns { Promise } Promise for result of executed task */ - export function execute(task: Task, priority?: Priority): Promise { + export function execute(task: Task, priority?: Priority): Promise { initWorkerPool(); task.checkExecution(); taskSubmitted(task); @@ -950,7 +950,7 @@ export namespace taskpool { return task.getOnReceivePromise(launchPromise(task.execute)); } - const promise = new Promise((resolve, reject) => { + const promise = new Promise((resolve, reject) => { task.resolve = resolve; task.reject = reject; }); @@ -963,17 +963,17 @@ export namespace taskpool { * * @param { TaskGroup } group The task group for execution * @param { Priority } [priority] priority for tasks in the group - * @returns { Promise> } Promise for array of results of executed tasks from the group + * @returns { Promise> } Promise for array of results of executed tasks from the group */ - export function execute(group: TaskGroup, priority?: Priority): Promise> { + export function execute(group: TaskGroup, priority?: Priority): Promise> { initWorkerPool(); const tasksCount = group.tasks.length.toInt(); if (tasksCount == 0) { - return Promise.resolve>(new Array()); + return Promise.resolve>(new Array()); } taskGroupSubmitted(group.id, tasksCount); group.isTaskAlreadySubmitted = true; - const promises: Array> = new Array>(); + const promises: Array> = new Array>(); group.tasks.forEach((task: Task) => { taskSubmitted(task); task.isSubmitted = true; @@ -981,7 +981,7 @@ export namespace taskpool { if (isTaskPoolUseLaunch) { promises.push(task.getOnReceivePromise(launchPromise(task.execute))); } else { - const promise = new Promise((resolve, reject) => { + const promise = new Promise((resolve, reject) => { task.resolve = resolve; task.reject = reject; }); @@ -989,7 +989,7 @@ export namespace taskpool { promises.push(task.getOnReceivePromise(promise)); } }); - return Promise.all(promises); + return Promise.all(promises); } /** @@ -998,16 +998,16 @@ export namespace taskpool { * @param { int } delayTime timeout in ms to execute task after * @param { Task } task The task to execute * @param { Priority } [priority] priority for task - * @returns { Promise } Promise for result of executed task + * @returns { Promise } Promise for result of executed task */ - export function executeDelayed(delayTime: int, task: Task, priority?: Priority): Promise { + export function executeDelayed(delayTime: int, task: Task, priority?: Priority): Promise { initWorkerPool(); task.checkExecutionForDelayedTask(delayTime); task.isSubmitted = true; ConcurrencyHelpers.lockGuard(mutex, () => { pendingDelayed.add(task); }); - return new Promise((resolve, reject) => { + return new Promise((resolve, reject) => { task.timerId = setTimeout(() => { ConcurrencyHelpers.lockGuard(mutex, () => { pendingDelayed.delete(task); @@ -1021,18 +1021,18 @@ export namespace taskpool { taskSubmitted(task); task.enqueue(priority); if (isTaskPoolUseLaunch) { - launchImpl(task, priority).then((res: NullishType) => { + launchImpl(task, priority).then((res: Any) => { resolve(res); }).catch((e) => { reject(e); }) } else { - const p = new Promise((resolve, reject) => { + const p = new Promise((resolve, reject) => { task.resolve = resolve; task.reject = reject; }) notifyExecuteTask(); - task.getOnReceivePromise(p).then((res: NullishType) => { + task.getOnReceivePromise(p).then((res: Any) => { resolve(res); }).catch((e) => { reject(e); @@ -1063,7 +1063,7 @@ export namespace taskpool { if (isTaskPoolUseLaunch) { launchImpl(task, priority); } else { - const p = new Promise((resolve, reject) => { + const p = new Promise((resolve, reject) => { task.resolve = resolve; task.reject = reject; }) @@ -1585,11 +1585,11 @@ export namespace taskpool { * @param task submitting task * @param priority task execution priority */ - function launchImpl(task: Task, priority?: Priority): Promise { - const job: Job = launch NullishType>( + function launchImpl(task: Task, priority?: Priority): Promise { + const job: Job = launch Any>( task.execute ); - let promise = new Promise((resolve, reject) => { + let promise = new Promise((resolve, reject) => { try { let res = job.Await(); resolve(res); @@ -1645,10 +1645,10 @@ export namespace taskpool { const continuousExecutionCount: int = 5; } -function launchPromise(f: Function, ...args: FixedArray): Promise { - let resolver: (((v: NullishType | PromiseLike) => void) | undefined) = undefined; +function launchPromise(f: Function, ...args: FixedArray): Promise { + let resolver: (((v: Any | PromiseLike) => void) | undefined) = undefined; let rejecter: (((error: Error) => void) | undefined) = undefined; - let p = new Promise((res, rej) => { + let p = new Promise((res, rej) => { resolver = res rejecter = rej; }) diff --git a/static_core/plugins/ets/stdlib/std/concurrency/AsyncLock.ets b/static_core/plugins/ets/stdlib/std/concurrency/AsyncLock.ets index 5237d99989..2aa24b1286 100644 --- a/static_core/plugins/ets/stdlib/std/concurrency/AsyncLock.ets +++ b/static_core/plugins/ets/stdlib/std/concurrency/AsyncLock.ets @@ -133,7 +133,7 @@ export final class AsyncLock { this.unlock(asyncLockInfo); }); } - private static launchPromise(f: Function, ...args: FixedArray): Promise { + private static launchPromise(f: Function, ...args: FixedArray): Promise { let resolver: (((v: T | PromiseLike) => void) | undefined) = undefined; let rejecter: (((error: Error) => void) | undefined) = undefined; let p = new Promise((res, rej) => { diff --git a/static_core/plugins/ets/stdlib/std/concurrency/Launch.ets b/static_core/plugins/ets/stdlib/std/concurrency/Launch.ets index 90126e2ade..8ac8420b38 100644 --- a/static_core/plugins/ets/stdlib/std/concurrency/Launch.ets +++ b/static_core/plugins/ets/stdlib/std/concurrency/Launch.ets @@ -42,8 +42,8 @@ type CoroFunT = ( * * @returns instance of the Job class that represents newly launched coroutine. */ -export function launch>(coroFun: F, ...args: FixedArray): Job { - return launchInternal(coroFun, args as FixedArray); +export function launch>(coroFun: F, ...args: FixedArray): Job { + return launchInternal(coroFun, args as FixedArray); } /** @@ -117,16 +117,16 @@ export interface LaunchParams { * * @returns instance of the Job class that represents newly launched coroutine. */ -export function launch>(coroFun: F, launchParams: LaunchParams, ...args: FixedArray): Job { - return launchInternal(coroFun, args as FixedArray, launchParams); +export function launch>(coroFun: F, launchParams: LaunchParams, ...args: FixedArray): Job { + return launchInternal(coroFun, args as FixedArray, launchParams); } -function launchInternal>(coroFun: F, args: FixedArray, launchParams?: LaunchParams): Job { +function launchInternal>(coroFun: F, args: FixedArray, launchParams?: LaunchParams): Job { const paddedArgs = padArrayToMaxArgs(args); if (launchParams) { - return launchInternalJobNative(coroFun, args as FixedArray, launchParams.abortFlag, launchParams.workerGroupId); + return launchInternalJobNative(coroFun, args as FixedArray, launchParams.abortFlag, launchParams.workerGroupId); } - return launchInternalJobNative(coroFun, args as FixedArray, false, WorkerGroup.ANY_ID); + return launchInternalJobNative(coroFun, args as FixedArray, false, WorkerGroup.ANY_ID); } function padArrayToMaxArgs(arr: FixedArray): FixedArray<(T | undefined)> { @@ -141,4 +141,4 @@ function padArrayToMaxArgs(arr: FixedArray): FixedArray<(T | undefined)> { return res; } -native function launchInternalJobNative(coroFun: F, args: FixedArray, abortFlag: boolean, gid: WorkerGroupId): Job; +native function launchInternalJobNative(coroFun: F, args: FixedArray, abortFlag: boolean, gid: WorkerGroupId): Job; diff --git a/static_core/plugins/ets/stdlib/std/containers/ConcurrentHashMap.ets b/static_core/plugins/ets/stdlib/std/containers/ConcurrentHashMap.ets index c210c4b69d..fb24539082 100644 --- a/static_core/plugins/ets/stdlib/std/containers/ConcurrentHashMap.ets +++ b/static_core/plugins/ets/stdlib/std/containers/ConcurrentHashMap.ets @@ -143,7 +143,7 @@ export namespace containers { private static readonly MIN_BUCKETS_COUNT = 8; - private getBucketIndex(k: NullishType): int { + private getBucketIndex(k: Any): int { if (k === null) { return 0; } diff --git a/static_core/plugins/ets/stdlib/std/core/Boolean.ets b/static_core/plugins/ets/stdlib/std/core/Boolean.ets index 6e2c68a30a..81e47ec8bf 100644 --- a/static_core/plugins/ets/stdlib/std/core/Boolean.ets +++ b/static_core/plugins/ets/stdlib/std/core/Boolean.ets @@ -117,7 +117,7 @@ export final class Boolean extends Object implements Comparable { * * @param value value to construct class instance with */ - public constructor(value: NullishType = undefined) { + public constructor(value: Any = undefined) { if (value == null || value == undefined) { this.value = false; } else if (value instanceof Boolean) { @@ -237,7 +237,7 @@ export final class Boolean extends Object implements Comparable { * @returns true if provided object and this instance have same value, false otherwise * Returns false if type of provided object is not the same as this type */ - public equals(other: NullishType): boolean { + public equals(other: Any): boolean { if (this === other) { return true } diff --git a/static_core/plugins/ets/stdlib/std/core/BuiltinArray.ets b/static_core/plugins/ets/stdlib/std/core/BuiltinArray.ets index 89e7d6e3dc..ce44269e89 100644 --- a/static_core/plugins/ets/stdlib/std/core/BuiltinArray.ets +++ b/static_core/plugins/ets/stdlib/std/core/BuiltinArray.ets @@ -620,7 +620,7 @@ export function toLocaleString(self: FixedArray): string { if (i != 0) { sb.append(",") } - let x = self[i] as NullishType; + let x = self[i] as Any; if ((null !== x) && (undefined !== x)) { sb.append((x! as object).toLocaleString()) // #26217 } @@ -1583,7 +1583,7 @@ export function toLocaleString(self: FixedArray): string { if (i != 0) { sb.append(",") } - let x = self[i] as NullishType; + let x = self[i] as Any; if ((null !== x) && (undefined !== x)) { sb.append((x! as object).toLocaleString()) // #26217 } @@ -2546,7 +2546,7 @@ export function toLocaleString(self: FixedArray): string { if (i != 0) { sb.append(",") } - let x = self[i] as NullishType; + let x = self[i] as Any; if ((null !== x) && (undefined !== x)) { sb.append((x! as object).toLocaleString()) // #26217 } @@ -3509,7 +3509,7 @@ export function toLocaleString(self: FixedArray): string { if (i != 0) { sb.append(",") } - let x = self[i] as NullishType; + let x = self[i] as Any; if ((null !== x) && (undefined !== x)) { sb.append((x! as object).toLocaleString()) // #26217 } @@ -4472,7 +4472,7 @@ export function toLocaleString(self: FixedArray): string { if (i != 0) { sb.append(",") } - let x = self[i] as NullishType; + let x = self[i] as Any; if ((null !== x) && (undefined !== x)) { sb.append((x! as object).toLocaleString()) // #26217 } @@ -5435,7 +5435,7 @@ export function toLocaleString(self: FixedArray): string { if (i != 0) { sb.append(",") } - let x = self[i] as NullishType; + let x = self[i] as Any; if ((null !== x) && (undefined !== x)) { sb.append((x! as object).toLocaleString()) // #26217 } @@ -6406,7 +6406,7 @@ export function toLocaleString(self: FixedArray): string { if (i != 0) { sb.append(",") } - let x = self[i] as NullishType; + let x = self[i] as Any; if ((null !== x) && (undefined !== x)) { sb.append((x! as object).toLocaleString()) // #26217 } @@ -7377,7 +7377,7 @@ export function toLocaleString(self: FixedArray): string { if (i != 0) { sb.append(",") } - let x = self[i] as NullishType; + let x = self[i] as Any; if ((null !== x) && (undefined !== x)) { sb.append((x! as object).toLocaleString()) // #26217 } diff --git a/static_core/plugins/ets/stdlib/std/core/BuiltinArrayAlgorithms.ets b/static_core/plugins/ets/stdlib/std/core/BuiltinArrayAlgorithms.ets index 318f3b0ed7..ef8693bc92 100644 --- a/static_core/plugins/ets/stdlib/std/core/BuiltinArrayAlgorithms.ets +++ b/static_core/plugins/ets/stdlib/std/core/BuiltinArrayAlgorithms.ets @@ -1353,8 +1353,8 @@ export function copyTo(src: FixedArray, dst: FixedArray, dstStart: i * @param src source array to be copied * @returns copy of `src` */ -export function copyOf(src: FixedArray): FixedArray { - const r : FixedArray = new NullishType[src.length]; +export function copyOf(src: FixedArray): FixedArray { + const r : FixedArray = new Any[src.length]; try { copyTo(src, r, 0, 0, src.length); } catch (e) { @@ -1382,7 +1382,7 @@ export function copyOf(src: FixedArray): FixedArray { * copyTo(src, dst, 0, 0, src.length) * ``` */ -export function copyTo(src: FixedArray, dst: FixedArray, dstStart: int, srcStart: int, srcEnd: int): void { +export function copyTo(src: FixedArray, dst: FixedArray, dstStart: int, srcStart: int, srcEnd: int): void { if (!checkRange(src.length, srcStart, srcEnd)) { throw new ArrayIndexOutOfBoundsError("copyTo: src bounds verification failed") } diff --git a/static_core/plugins/ets/stdlib/std/core/Byte.ets b/static_core/plugins/ets/stdlib/std/core/Byte.ets index 8818030cff..c62e0cecf3 100644 --- a/static_core/plugins/ets/stdlib/std/core/Byte.ets +++ b/static_core/plugins/ets/stdlib/std/core/Byte.ets @@ -347,7 +347,7 @@ export final class Byte extends Integral implements Comparable { * @returns true if provided object and this instance have same value, false otherwise * Returns false if type of provided object is not the same as this type */ - public equals(other: NullishType): boolean { + public equals(other: Any): boolean { if (this === other) { return true } diff --git a/static_core/plugins/ets/stdlib/std/core/Char.ets b/static_core/plugins/ets/stdlib/std/core/Char.ets index b0aa579b3e..3974ffd224 100644 --- a/static_core/plugins/ets/stdlib/std/core/Char.ets +++ b/static_core/plugins/ets/stdlib/std/core/Char.ets @@ -70,7 +70,7 @@ export final class Char extends Object implements Comparable { * @returns comparison result of underlying primitive chars. * Returns false if the argument is not an instance of Char. */ - public equals(other: NullishType): boolean { + public equals(other: Any): boolean { if (this === other) { return true } diff --git a/static_core/plugins/ets/stdlib/std/core/Console.ets b/static_core/plugins/ets/stdlib/std/core/Console.ets index ec61d1c4f6..2df6a91716 100644 --- a/static_core/plugins/ets/stdlib/std/core/Console.ets +++ b/static_core/plugins/ets/stdlib/std/core/Console.ets @@ -110,13 +110,13 @@ export final class Console { return Console.INDENT_MARGIN.repeat(this.indentationLevel) } - private static NullishTypeToPrint(o: NullishType): String { + private static NullishTypeToPrint(o: Any): String { return reflect.Value.of(o).toPrint(MAX_CONSOLE_PRINT_DEPTH) } /** * Implementations for printing primitive types - * @param {string | boolean | byte | short | char | int | long | float | double | NullishType} i - The value to print + * @param {string | boolean | byte | short | char | int | long | float | double | Any} i - The value to print * @returns {void} * @public * @deprecated Will be removed in future. Please use log instead @@ -148,7 +148,7 @@ export final class Console { public print(i: double): void { this.addToBuffer(new Double(i).toString(), LogLevel.PRINTLN) } - public print(o: NullishType): void { + public print(o: Any): void { this.print(Console.NullishTypeToPrint(o)) } @@ -168,12 +168,12 @@ export final class Console { /** * Prints an object followed by a newline to stdout - * @param {NullishType | string | boolean | byte | short | char | int | long | float | double} i - The value to print + * @param {Any | string | boolean | byte | short | char | int | long | float | double} i - The value to print * @returns {void} * @public * @deprecated Will be removed in future. Please use log instead */ - public println(i: NullishType): void { + public println(i: Any): void { this.print(i) this.println() } @@ -220,7 +220,7 @@ export final class Console { /** * Implementations for log primitive types to stdout - * @param {string | boolean | byte | short | char | int | long | NullishType} i - The value to print to stdout + * @param {string | boolean | byte | short | char | int | long | Any} i - The value to print to stdout * @returns {void} * @public */ @@ -261,7 +261,7 @@ export final class Console { * @section Variadics */ - private printRest(level: LogLevel, ...vals: NullishType[]) { + private printRest(level: LogLevel, ...vals: Any[]) { let sb = new StringBuilder() if (vals.length != 0) { @@ -286,66 +286,66 @@ export final class Console { /** * Prints log-level messages * If first argument is a string it is treated as a format string - * @param {...NullishType[]} vals - Variable number of values to be logged + * @param {...Any[]} vals - Variable number of values to be logged * @returns {void} * @public */ - public log(...vals: NullishType[]): void { + public log(...vals: Any[]): void { this.printRest(LogLevel.LOG, ...vals) } /** * Prints debug-level messages * If first argument is a string it is treated as a format string - * @param {...NullishType[]} vals - Variable number of values to be logged + * @param {...Any[]} vals - Variable number of values to be logged * @returns {void} * @public */ - public debug(...vals: NullishType[]): void { + public debug(...vals: Any[]): void { this.printRest(LogLevel.DEBUG, ...vals) } /** * Prints info-level messages * If first argument is a string it is treated as a format string - * @param {...NullishType[]} vals - Variable number of values to be logged + * @param {...Any[]} vals - Variable number of values to be logged * @returns {void} * @public */ - public info(...vals: NullishType[]): void { + public info(...vals: Any[]): void { this.printRest(LogLevel.INFO, ...vals) } /** * Prints warn-level messages * If first argument is a string it is treated as a format string - * @param {...NullishType[]} vals - Variable number of values to be logged + * @param {...Any[]} vals - Variable number of values to be logged * @returns {void} * @public */ - public warn(...vals: NullishType[]): void { + public warn(...vals: Any[]): void { this.printRest(LogLevel.WARN, ...vals) } /** * Prints error-level messages * If first argument is a string it is treated as a format string - * @param {...NullishType[]} vals - Variable number of values to be logged + * @param {...Any[]} vals - Variable number of values to be logged * @returns {void} * @public */ - public error(...vals: NullishType[]): void { + public error(...vals: Any[]): void { this.printRest(LogLevel.ERROR, ...vals) } /** * Conditionally prints an error message if the assertion condition is false - * @param {...NullishType[]} vals - Values to be logged if condition is false. + * @param {...Any[]} vals - Values to be logged if condition is false. * Condition is the first value in vals (if exist) * @returns {void} * @public */ - public assert(...vals: NullishType[]): void { + public assert(...vals: Any[]): void { if (vals.length == 0) { return } @@ -397,10 +397,10 @@ export final class Console { /** * Prints a formatted representation of an object to stdout * Filters out properties containing 'field#' in their keys - * @param {NullishType} obj - The object to inspect + * @param {Any} obj - The object to inspect * @returns {void} */ - public dir(obj?: NullishType): void { + public dir(obj?: Any): void { if (obj == null || obj == undefined) { return } @@ -418,7 +418,7 @@ export final class Console { // "age": 25, // "field#m": 25 // Internal field // } - const filterer = (key: String, value: NullishType): NullishType => { + const filterer = (key: String, value: Any): Any => { if (key.includes("field#")) { return undefined; } @@ -431,10 +431,10 @@ export final class Console { /** * Prints an XML representation of an object to stdout * Currently outputs the object as-is - * @param {NullishType} obj - The object to display as XML + * @param {Any} obj - The object to display as XML * @returns {void} */ - public dirxml(obj: NullishType): void { + public dirxml(obj: Any): void { this.log(obj) } @@ -450,7 +450,7 @@ export final class Console { * @param {string} [objs] - Data to be printed without additional indent * @returns {void} */ - public group(...objs: NullishType[]): void { + public group(...objs: Any[]): void { if (objs.length != 0) { this.log(objs) } @@ -475,7 +475,7 @@ export final class Console { * @returns {void} * @see group */ - public groupCollapsed(...objs: NullishType[]): void { + public groupCollapsed(...objs: Any[]): void { this.group(...objs); } @@ -486,10 +486,10 @@ export final class Console { /** * Displays an array of objects in tabular format * Converts the data to a DataFrame and renders it - * @param {NullishType[]} data - Array of objects to display as a table + * @param {Any[]} data - Array of objects to display as a table * @returns {void} */ - public table(...data: NullishType[]): void { + public table(...data: Any[]): void { if (data.length == 0) { return } @@ -499,7 +499,7 @@ export final class Console { let dat = data[0]! const isSimple = (dat == undefined) || (dat == null) - || (dat instanceof String) || (Object.keys(__narrowAny(dat)!).length == 0) + || (dat instanceof String) || (Object.keys(dat as Object).length == 0) if (isSimple) { this.log(dat) return @@ -507,8 +507,8 @@ export final class Console { let df: DataFrame | undefined = undefined if (dat instanceof ArrayLike) { - dat = dat as ArrayLike - let d = new Array(dat.length) + dat = dat as ArrayLike + let d = new Array(dat.length) for (let i = 0; i < d.length; ++i) { d[i] = dat[i] } @@ -577,10 +577,10 @@ export final class Console { /** * Prints the current stack trace with an optional label * Skips the first stack frame (the trace call itself) - * @param {NullishType[]} ...data - args to prints + * @param {Any[]} ...data - args to prints * @returns {void} */ - public trace(...data: NullishType[]): void { + public trace(...data: Any[]): void { this.log("Trace:", data) const stackT = StackTrace.provisionStackTrace(); for (let i = 1; i < stackT.length; ++i) { @@ -778,7 +778,7 @@ class DataFrame { * @param obj - The object to be converted into table info * @returns A Map containing string representations of object properties */ - private static getObjectInfoForTable(obj: NullishType): Map { + private static getObjectInfoForTable(obj: Any): Map { const mapping = new Map(); const objType = Type.of(obj); const objValue = reflect.Value.of(obj); @@ -845,11 +845,11 @@ class DataFrame { /** * Creates a DataFrame from an array of objects - * @param {NullishType[]} data - Array of objects to convert + * @param {Any[]} data - Array of objects to convert * @returns {DataFrame} New DataFrame instance * @static */ - public static fromObjects(...data: NullishType[]): DataFrame { + public static fromObjects(...data: Any[]): DataFrame { if (data.length == 0) { return new DataFrame(new Array()); } diff --git a/static_core/plugins/ets/stdlib/std/core/ConsoleHelper.ets b/static_core/plugins/ets/stdlib/std/core/ConsoleHelper.ets index 1a6dbfbed8..13362bac22 100644 --- a/static_core/plugins/ets/stdlib/std/core/ConsoleHelper.ets +++ b/static_core/plugins/ets/stdlib/std/core/ConsoleHelper.ets @@ -20,7 +20,7 @@ export class Formatter { return (new Formatter).stringifyObject(obj, '\n', 1, full) } - private static isNullObject(obj: NullishType): boolean { + private static isNullObject(obj: Any): boolean { return (obj == undefined) || (obj == null) } @@ -40,25 +40,25 @@ export class Formatter { return obj instanceof Array } - private stringifySubObject(delimiter: string, subObj: NullishType, subObjName: string, depth: number, full: boolean = false): string { + private stringifySubObject(delimiter: string, subObj: Any, subObjName: string, depth: number, full: boolean = false): string { if (Formatter.isNullObject(subObj)) { return Formatter.nullObjectDescription(subObjName) + ',' + delimiter } let strB = new StringBuilder - subObj = __narrowAny(subObj) - - if (Formatter.isArray(subObj!)) { - strB.append(subObjName + ':' + delimiter + Formatter.arrayToString(delimiter + ' ', subObj! as Array, depth, full)) - } else if (Formatter.isObject(subObj!)) { - strB.append(this.subObjectDescription(subObj!, subObjName, this.isCircular(subObj!), delimiter, depth)) - } else if (Formatter.isFunction(subObj!)) { - strB.append(Formatter.functionDescription(subObj!, delimiter, true, full)) + subObj = subObj as object + + if (Formatter.isArray(subObj)) { + strB.append(subObjName + ':' + delimiter + Formatter.arrayToString(delimiter + ' ', subObj as Array, depth, full)) + } else if (Formatter.isObject(subObj)) { + strB.append(this.subObjectDescription(subObj, subObjName, this.isCircular(subObj), delimiter, depth)) + } else if (Formatter.isFunction(subObj)) { + strB.append(Formatter.functionDescription(subObj, delimiter, true, full)) } else { - strB.append(Formatter.simpleObjectDescription(subObj!, subObjName, true)) + strB.append(Formatter.simpleObjectDescription(subObj, subObjName, true)) } - this.objects.add(subObj!) + this.objects.add(subObj) strB.append(',' + delimiter) return strB.toString() @@ -93,12 +93,12 @@ export class Formatter { private objects = new Set - private isCircular(obj: NullishType): boolean { + private isCircular(obj: Any): boolean { if (obj == null) { return false } - return this.objects.has(__narrowAny(obj)) + return this.objects.has(obj as object) } private static nullObjectDescription(objName: string = ''): string { @@ -110,26 +110,26 @@ export class Formatter { return (isSub ? objName + ': ' : '') + quotesStr + obj + quotesStr } - private stringifyObject(obj: NullishType, delimiter: string = '\n', depth: number = 1, full: boolean = false): string { + private stringifyObject(obj: Any, delimiter: string = '\n', depth: number = 1, full: boolean = false): string { if (Formatter.isNullObject(obj)) { return Formatter.nullObjectDescription() } - obj = __narrowAny(obj) - this.objects.add(obj!) + obj = obj as object + this.objects.add(obj) let strB = new StringBuilder - if (Formatter.isArray(obj!)) { - strB.append(Formatter.arrayToString(delimiter, obj! as Array, depth, full)) - } else if (Formatter.isFunction(obj!)) { - strB.append(Formatter.functionDescription(obj!, delimiter, false, full)) + if (Formatter.isArray(obj)) { + strB.append(Formatter.arrayToString(delimiter, obj as Array, depth, full)) + } else if (Formatter.isFunction(obj)) { + strB.append(Formatter.functionDescription(obj, delimiter, false, full)) if (!full) { strB = (new StringBuilder).append('{ ').append(strB.toString()).append(' }') } - } else if (Formatter.isObject(obj!)) { - strB.append(this.objectDescription(obj!, delimiter, depth, full)) + } else if (Formatter.isObject(obj)) { + strB.append(this.objectDescription(obj, delimiter, depth, full)) } else { - strB.append(Formatter.simpleObjectDescription(obj!, '')) + strB.append(Formatter.simpleObjectDescription(obj, '')) } return strB.toString() } @@ -198,7 +198,7 @@ export class Formatter { return subObj ? subObj! as int : 0 } - private static getValue(key: string, obj: Object): NullishType { + private static getValue(key: string, obj: Object): Any { if (!obj) { return null } @@ -273,18 +273,18 @@ export class Formatter { return "%" + flag } - private static joinLastArgs(index: int, args: Array): string { + private static joinLastArgs(index: int, args: Array): string { let sb = new StringBuilder for (let i = index; i < args.length; ++i) { sb.append(" ") // behavior for null and undefined expected to be the same as for empty string - sb.append(args[i] != undefined && args[i] != null ? __narrowAny(args[i])!.toString() : "") + sb.append(args[i] != undefined && args[i] != null ? (args[i] as object).toString() : "") } return sb.toString() } // NOTE(ivan-tyulyandin): some modifiers work wrongly, see #25046 - public format(s: string, args: Array): string { + public format(s: string, args: Array): string { let preI: int = 0 let i: int = 0 let argCounter = 0 @@ -302,7 +302,7 @@ export class Formatter { if (flags.includes(flag)) { let d = args[argCounter] if (d != undefined && d != null) { - res.append(Formatter.processArg(flag, __narrowAny(d))) + res.append(Formatter.processArg(flag, d as object)) } else { // behavior for null and undefined expected to be the same as for empty string res.append(Formatter.processArg(flag, "")) diff --git a/static_core/plugins/ets/stdlib/std/core/Double.ets b/static_core/plugins/ets/stdlib/std/core/Double.ets index fc93a47852..9c7dbfb7be 100644 --- a/static_core/plugins/ets/stdlib/std/core/Double.ets +++ b/static_core/plugins/ets/stdlib/std/core/Double.ets @@ -476,7 +476,7 @@ export final class Double extends Floating implements Comparable { * Returns false if type of provided object is not the same as this type * @tag arkts */ - public equals(other: NullishType): boolean { + public equals(other: Any): boolean { if (this === other) { return true } diff --git a/static_core/plugins/ets/stdlib/std/core/EAWorker.ets b/static_core/plugins/ets/stdlib/std/core/EAWorker.ets index 9029c06a53..2a2da16e8f 100644 --- a/static_core/plugins/ets/stdlib/std/core/EAWorker.ets +++ b/static_core/plugins/ets/stdlib/std/core/EAWorker.ets @@ -381,10 +381,10 @@ export class EAWorker { * Note: it has no effect if EAWorker was stoped * * @param { Function } task function to execute - * @param { ...NullishType } args argumnents for task to execute with + * @param { ...Any } args argumnents for task to execute with * @returns { Job } Job that represents the task */ - public run (task: Function, ...args: FixedArray): Job { + public run (task: Function, ...args: FixedArray): Job { if (this.isMain) { return EAWorker.postToMain(task, ...args); } @@ -396,17 +396,17 @@ export class EAWorker { public static postToMain( coroFun: Function, - ...args: FixedArray + ...args: FixedArray ) : Job { - return EAWorker.postTaskToMain(coroFun, args as FixedArray, false); + return EAWorker.postTaskToMain(coroFun, args as FixedArray, false); } public static postToMain( coroFun: Function, launchParams: LaunchParams, - ...args: FixedArray + ...args: FixedArray ) : Job { - return EAWorker.postTaskToMain(coroFun, args as FixedArray, launchParams.abortFlag); + return EAWorker.postTaskToMain(coroFun, args as FixedArray, launchParams.abortFlag); } /** @@ -415,7 +415,7 @@ export class EAWorker { */ private native static postTaskToMain( coroFun: Object, - args: FixedArray, + args: FixedArray, abortFlag: boolean ) : Job; @@ -478,7 +478,7 @@ export class EAWorker { }; interface InternalWorker { - run(task:Function, ...args:FixedArray): Job; + run(task:Function, ...args:FixedArray): Job; start(initialTask?: Task); @@ -565,7 +565,7 @@ class InteropWorker implements InternalWorker { return this?.workerId; } - public run(task:Function, ...args:FixedArray):Job { + public run(task:Function, ...args:FixedArray):Job { let job = new CompletableJob(); this.initEvent.wait(); let serializeHelper = new InteropSerializeHelper(args); @@ -584,7 +584,7 @@ class InteropWorker implements InternalWorker { break; } } - + // handle message cancellation if (currentMessage !== undefined) { if (this.messages.get(currentMessage) === MessageStatus.CANCELLED) { @@ -702,7 +702,7 @@ class StaticWorker implements InternalWorker { return this?.workerId; } - public run(task: Function, ...args:FixedArray): Job { + public run(task: Function, ...args:FixedArray): Job { let job = new CompletableJob(); let wrapperTask = ():T => { return task.unsafeCall(...args) as T; @@ -786,7 +786,7 @@ class StaticWorker implements InternalWorker { } if (shouldExecute) { - task(); + task(); } } } diff --git a/static_core/plugins/ets/stdlib/std/core/Field.ets b/static_core/plugins/ets/stdlib/std/core/Field.ets index 1069cffa3b..a22e88edd5 100644 --- a/static_core/plugins/ets/stdlib/std/core/Field.ets +++ b/static_core/plugins/ets/stdlib/std/core/Field.ets @@ -15,8 +15,8 @@ package std.core; -native function TypeAPIGetStaticFieldValue(ownerType: Type, name: string): NullishType -native function TypeAPISetStaticFieldValue(ownerType: Type, name: string, val: NullishType): void +native function TypeAPIGetStaticFieldValue(ownerType: Type, name: string): Any +native function TypeAPISetStaticFieldValue(ownerType: Type, name: string, val: Any): void /** * Represents field of class or interface @@ -56,14 +56,14 @@ export final class Field extends Object { return this.accessMod } - public getStaticValue(): NullishType { + public getStaticValue(): Any { if (!this.isStatic()) { throw new AssertionError("Field value is not static!") } return TypeAPIGetStaticFieldValue(this.ownerType!, this.name) } - public setStaticValue(v: NullishType): void { + public setStaticValue(v: Any): void { if (!this.isStatic()) { throw new AssertionError("Field value is not static!") } @@ -90,7 +90,7 @@ export final class Field extends Object { return this.getName() + ": " + this.getType().toString() } - public equals(oth: NullishType): boolean { + public equals(oth: Any): boolean { return oth instanceof Field && this.fieldType!.equals((oth as Field).fieldType!) && this.name == (oth as Field).name && diff --git a/static_core/plugins/ets/stdlib/std/core/Float.ets b/static_core/plugins/ets/stdlib/std/core/Float.ets index 5e611b2a43..f419c0431f 100644 --- a/static_core/plugins/ets/stdlib/std/core/Float.ets +++ b/static_core/plugins/ets/stdlib/std/core/Float.ets @@ -375,7 +375,7 @@ export final class Float extends Floating implements Comparable { * @returns true if provided object and this instance have same value, false otherwise * Returns false if type of provided object is not the same as this type */ - public equals(other: NullishType): boolean { + public equals(other: Any): boolean { if (this === other) { return true } diff --git a/static_core/plugins/ets/stdlib/std/core/Int.ets b/static_core/plugins/ets/stdlib/std/core/Int.ets index dd69f2853c..47448192c2 100644 --- a/static_core/plugins/ets/stdlib/std/core/Int.ets +++ b/static_core/plugins/ets/stdlib/std/core/Int.ets @@ -313,7 +313,7 @@ export final class Int extends Integral implements Comparable { return this.value; } - equals(other: NullishType): boolean { + equals(other: Any): boolean { if (this === other) { return true } diff --git a/static_core/plugins/ets/stdlib/std/core/Job.ets b/static_core/plugins/ets/stdlib/std/core/Job.ets index 430114a284..e1c1cdbfe0 100644 --- a/static_core/plugins/ets/stdlib/std/core/Job.ets +++ b/static_core/plugins/ets/stdlib/std/core/Job.ets @@ -94,5 +94,5 @@ export final class CompletableJob extends Job } private native finishImpl(value: U): void - private native failImpl(error: NullishType): void + private native failImpl(error: Any): void } diff --git a/static_core/plugins/ets/stdlib/std/core/Long.ets b/static_core/plugins/ets/stdlib/std/core/Long.ets index ec3854e131..1cd847a86a 100644 --- a/static_core/plugins/ets/stdlib/std/core/Long.ets +++ b/static_core/plugins/ets/stdlib/std/core/Long.ets @@ -348,7 +348,7 @@ export final class Long extends Integral implements Comparable { * @returns true if provided object and this instance have same value, false otherwise * Returns false if type of provided object is not the same as this type */ - public equals(other: NullishType): boolean { + public equals(other: Any): boolean { if (this === other) { return true } diff --git a/static_core/plugins/ets/stdlib/std/core/Method.ets b/static_core/plugins/ets/stdlib/std/core/Method.ets index 22921d01cb..536f2e2d62 100644 --- a/static_core/plugins/ets/stdlib/std/core/Method.ets +++ b/static_core/plugins/ets/stdlib/std/core/Method.ets @@ -15,8 +15,8 @@ package std.core; -native function TypeAPIMethodInvoke(methodType: MethodType, recv: NullishType, args: FixedArray): NullishType -native function TypeAPIMethodInvokeConstructor(methodType: MethodType, args: FixedArray): Object +native function TypeAPIMethodInvoke(methodType: MethodType, recv: Any, args: FixedArray): Any +native function TypeAPIMethodInvokeConstructor(methodType: MethodType, args: FixedArray): Object /** * Represents method of class or interface @@ -75,7 +75,7 @@ export final class Method extends Object { return this.getName() + ": " + this.getType().toString() } - public invoke(recv: NullishType, args: FixedArray): NullishType { + public invoke(recv: Any, args: FixedArray): Any { const isCtor = this.isConstructor() const isStatic = this.isStatic() if ((isStatic || isCtor) != (recv == null)) { @@ -85,7 +85,7 @@ export final class Method extends Object { if (thisType.getParametersNum() != args.length) { throw new Error("arguments length mismatch " + thisType.getParametersNum() + " != " + args.length) } - let convertedArgs: FixedArray = new NullishType[args.length] + let convertedArgs: FixedArray = new Any[args.length] for (let i = 0; i < convertedArgs.length; i++) { convertedArgs[i] = thisType.getParameter(i).getType().convertObject(args[i]) } @@ -107,7 +107,7 @@ export final class Method extends Object { return this.accessMod } - public equals(oth: NullishType): boolean { + public equals(oth: Any): boolean { return oth instanceof Method && this.methodType!.equals((oth as Method).methodType!) && this.name == (oth as Method).name && diff --git a/static_core/plugins/ets/stdlib/std/core/Null.ets b/static_core/plugins/ets/stdlib/std/core/Null.ets index fe4b5b9134..a4a3fde28e 100644 --- a/static_core/plugins/ets/stdlib/std/core/Null.ets +++ b/static_core/plugins/ets/stdlib/std/core/Null.ets @@ -20,7 +20,7 @@ final class Null { public override toString(): String { return "null"; } - public equals(to: NullishType): boolean { + public equals(to: Any): boolean { throw new Error("Internal error: null.equals was called!") } } diff --git a/static_core/plugins/ets/stdlib/std/core/Object.ets b/static_core/plugins/ets/stdlib/std/core/Object.ets index 1d48504ec6..210fc6fe97 100644 --- a/static_core/plugins/ets/stdlib/std/core/Object.ets +++ b/static_core/plugins/ets/stdlib/std/core/Object.ets @@ -15,11 +15,6 @@ package std.core; -/** - * @deprecated -*/ -export type NullishType = Any - /** * @deprecated */ @@ -40,7 +35,7 @@ export const OBJECT_TO_STRING_MEMBER_NAME: string = "toString" export const OBJECT_TO_LOCALE_STRING_MEMBER_NAME: string = "toLocaleString" export const OBJECT_HAS_OWN_PROPERTY_MEMBER_NAME: string = "hasOwnProperty" -type EntryType = [PropertyKey, NullishType] +type EntryType = [PropertyKey, Any] type NullishEntryType = EntryType | null | undefined /** @@ -91,7 +86,7 @@ export class Object { * * @returns an array of strings representing the given record's property names */ - public static keys(rec: Record): string[] { + public static keys(rec: Record): string[] { const keys: string[] = new string[rec.size.toInt()] let i = 0 @@ -182,8 +177,8 @@ export class Object { throw new AssertionError("Invalid object type"); } - public static values(rec: Record): NullishType[] { - const vals: NullishType[] = new NullishType[rec.size.toInt()] + public static values(rec: Record): Any[] { + const vals: Any[] = new Any[rec.size.toInt()] let i = 0 for (let val of rec.values()) { @@ -201,7 +196,7 @@ export class Object { * * @returns an array containing the given object's own string-keyed field values */ - public static values(o: Object): NullishType[] { + public static values(o: Object): Any[] { if (o instanceof Char || o instanceof Boolean || o instanceof Byte || @@ -210,15 +205,15 @@ export class Object { o instanceof Long || o instanceof Float || o instanceof Double) { - return new NullishType[0] + return new Any[0] } if (o instanceof String) { const sv = o as string const len = sv.getLength() if (len == 0) { - return new NullishType[0] + return new Any[0] } - let res: NullishType[] = new NullishType[len] + let res: Any[] = new Any[len] for (let i = 0; i < len; i++) { // NOTE(shumilov-petr): must be replaced by `sv.charAt(i) as string` when #15731 will be fixed res[i] = new Char(sv.charAt(i)).toString() @@ -229,11 +224,11 @@ export class Object { if (t instanceof ClassType) { const cv = reflect.Value.of(o) as ClassValue if (cv.getFieldsNum() == 0) { - return new NullishType[0] + return new Any[0] } const keys = Object.keys(o) const len = keys.length - let res: NullishType[] = new NullishType[len] + let res: Any[] = new Any[len] for (let i = 0; i < len; i++) { res[i] = cv.getFieldByName(keys[i]).getData() } @@ -242,15 +237,15 @@ export class Object { const av = reflect.Value.of(o) as ArrayValue const len = av.getLength() if (len == 0) { - return new NullishType[0] + return new Any[0] } - let res: NullishType[] = new NullishType[len.toInt()] + let res: Any[] = new Any[len.toInt()] for (let i = 0; i < len; i++) { res[i] = av.getElement(i).getData() } return res } else if (t instanceof LambdaType) { - return new NullishType[0] + return new Any[0] } else if (t instanceof EnumType) { // NOTE(shumilov-petr): Not implemented throw new Error("Not implemented") @@ -272,7 +267,7 @@ export class Object { * * @returns array representation of key/value */ - public static entries(rec: Record): NullishEntryType[] { + public static entries(rec: Record): NullishEntryType[] { const entries: NullishEntryType[] = new NullishEntryType[rec.size.toInt()] let i = 0 @@ -354,7 +349,7 @@ export class Object { throw new AssertionError("Invalid object type") } - public static getOwnPropertyNames(rec: Record): string[] { + public static getOwnPropertyNames(rec: Record): string[] { return Object.keys(rec) } @@ -489,7 +484,7 @@ export class Object { * * @returns new Record whose properties are given by the elements of the Iterable */ - public static fromEntries(entries: Iterable<[PropertyKey, T]>): Record { + public static fromEntries(entries: Iterable<[PropertyKey, T]>): Record { const result = new Record() const entriesIter = entries.$_iterator() @@ -516,11 +511,11 @@ export class Object { * * @returns the modified target Record */ - public static assign(target: Record, ...source: FixedArray): Record { + public static assign(target: Record, ...source: FixedArray): Record { for (const s of source) { const entries = Object.entries(s) for (const e of entries) { - target.set(e![0] as PropertyKey, e![1] as NullishType) + target.set(e![0] as PropertyKey, e![1] as Any) } } return target diff --git a/static_core/plugins/ets/stdlib/std/core/Parameter.ets b/static_core/plugins/ets/stdlib/std/core/Parameter.ets index 8d2be89902..b71a035d7c 100644 --- a/static_core/plugins/ets/stdlib/std/core/Parameter.ets +++ b/static_core/plugins/ets/stdlib/std/core/Parameter.ets @@ -49,7 +49,7 @@ export final class Parameter extends Object { return this.getName() + ": " + this.getType().toString() } - public equals(oth: NullishType): boolean { + public equals(oth: Any): boolean { return oth instanceof Parameter && this.paramType!.equals((oth as Parameter).paramType!) && this.name == (oth as Parameter).name && diff --git a/static_core/plugins/ets/stdlib/std/core/Promise.ets b/static_core/plugins/ets/stdlib/std/core/Promise.ets index 651507a290..409eeb9d3b 100644 --- a/static_core/plugins/ets/stdlib/std/core/Promise.ets +++ b/static_core/plugins/ets/stdlib/std/core/Promise.ets @@ -498,7 +498,7 @@ export final class Promise implements PromiseLike { // 1. Reference fields // 2. Primitive fields in mostly size decreasing order // filling alignment holes - private value: NullishType = undefined; + private value: Any = undefined; private mutex = new Mutex(); private event = new Event(); private callbackQueue?: Object[]; diff --git a/static_core/plugins/ets/stdlib/std/core/Proxy.ets b/static_core/plugins/ets/stdlib/std/core/Proxy.ets index 84d28c3651..9c96bb9426 100644 --- a/static_core/plugins/ets/stdlib/std/core/Proxy.ets +++ b/static_core/plugins/ets/stdlib/std/core/Proxy.ets @@ -35,11 +35,11 @@ export final class Proxy { private static readonly SETTER_METHOD_PREFIX = "" private static readonly SETTER_METHOD_PREFIX_LENGTH = Proxy.SETTER_METHOD_PREFIX.getLength() - static tryGetTarget(obj: Object): NullishType { + static tryGetTarget(obj: Object): Any { return Reflect.get(obj, Proxy.PROXY_INSTANCE_TARGET_FIELD) } - static tryGetHandler(obj: Object): NullishType { + static tryGetHandler(obj: Object): Any { return Reflect.get(obj, Proxy.PROXY_INSTANCE_HANDLER_FIELD) } @@ -229,7 +229,7 @@ export final class Proxy { } } - private handlerGet(target: T, handler: ProxyHandler, propName: string): NullishType { + private handlerGet(target: T, handler: ProxyHandler, propName: string): Any { return handler.get(target, propName) } @@ -250,7 +250,7 @@ export final class Proxy { if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - return (this.handlerGet(__narrowAny(target), __narrowAny>(handler), propertyName) as Numeric).toInt() + return (this.handlerGet(target as object, handler as ProxyHandler, propertyName) as Numeric).toInt() } throw new TypeError("unexpected proxy handler type: " + Type.of(handler).getName()) @@ -261,7 +261,7 @@ export final class Proxy { if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - return (this.handlerGet(__narrowAny(target), __narrowAny>(handler), propertyName) as Numeric).toDouble() + return (this.handlerGet(target as object, handler as ProxyHandler, propertyName) as Numeric).toDouble() } throw new TypeError("unexpected proxy handler type: " + Type.of(handler).getName()) @@ -272,7 +272,7 @@ export final class Proxy { if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - return (this.handlerGet(__narrowAny(target), __narrowAny>(handler), propertyName) as Numeric).toShort() + return (this.handlerGet(target as object, handler as ProxyHandler, propertyName) as Numeric).toShort() } throw new TypeError("unexpected proxy handler type: " + Type.of(handler).getName()) @@ -283,7 +283,7 @@ export final class Proxy { if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - return (this.handlerGet(__narrowAny(target), __narrowAny>(handler), propertyName) as Numeric).toFloat() + return (this.handlerGet(target as object, handler as ProxyHandler, propertyName) as Numeric).toFloat() } throw new TypeError("unexpected proxy handler type: " + Type.of(handler).getName()) @@ -294,7 +294,7 @@ export final class Proxy { if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - return (this.handlerGet(__narrowAny(target), __narrowAny>(handler), propertyName) as Numeric).toByte() + return (this.handlerGet(target as object, handler as ProxyHandler, propertyName) as Numeric).toByte() } throw new TypeError("unexpected proxy handler type: " + Type.of(handler).getName()) @@ -305,7 +305,7 @@ export final class Proxy { if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - return this.handlerGet(__narrowAny(target), __narrowAny>(handler), propertyName) as Char + return this.handlerGet(target as object, handler as ProxyHandler, propertyName) as Char } throw new TypeError("unexpected proxy handler type: " + Type.of(handler).getName()) @@ -316,30 +316,30 @@ export final class Proxy { if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - return (this.handlerGet(__narrowAny(target), __narrowAny>(handler), propertyName) as Numeric).toLong() + return (this.handlerGet(target as object, handler as ProxyHandler, propertyName) as Numeric).toLong() } throw new TypeError("unexpected proxy handler type: " + Type.of(handler).getName()) })) } else { - getterCreator.addBody(new CallableBodyFunction((proxy: Object): NullishType => { + getterCreator.addBody(new CallableBodyFunction((proxy: Object): Any => { const handler = Reflect.get(proxy, Proxy.PROXY_INSTANCE_HANDLER_FIELD) if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - return this.handlerGet(__narrowAny(target), __narrowAny>(handler), propertyName) + return this.handlerGet(target as object, handler as ProxyHandler, propertyName) } throw new TypeError("unexpected proxy handler type: " + Type.of(handler).getName()) })) } } else { - getterCreator.addBody(new CallableBodyFunction((proxy: Object): NullishType => { + getterCreator.addBody(new CallableBodyFunction((proxy: Object): Any => { const handler = Reflect.get(proxy, Proxy.PROXY_INSTANCE_HANDLER_FIELD) if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - return this.handlerGet(__narrowAny(target), __narrowAny>(handler), propertyName) + return this.handlerGet(target as object, handler as ProxyHandler, propertyName) } throw new TypeError("unexpected proxy handler type: " + Type.of(handler).getName()) @@ -348,7 +348,7 @@ export final class Proxy { proxyTypeCreator.addMethod(getterCreator) } - private handlerSet(target: T, handler: ProxyHandler, propName: string, propVal: NullishType): boolean { + private handlerSet(target: T, handler: ProxyHandler, propName: string, propVal: Any): boolean { return handler.set(target, propName, propVal) } @@ -371,7 +371,7 @@ export final class Proxy { if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - const success = this.handlerSet(__narrowAny(target), __narrowAny>(handler), propertyName, value as object) + const success = this.handlerSet(target as object, handler as ProxyHandler, propertyName, value as object) if (!success) { throw new TypeError(`proxy set handler returned false for propety '"${propertyName}"'`) } @@ -385,7 +385,7 @@ export final class Proxy { if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - const success = this.handlerSet(__narrowAny(target), __narrowAny>(handler), propertyName, value as object) + const success = this.handlerSet(target as object, handler as ProxyHandler, propertyName, value as object) if (!success) { throw new TypeError(`proxy set handler returned false for propety '"${propertyName}"'`) } @@ -399,7 +399,7 @@ export final class Proxy { if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - const success = this.handlerSet(__narrowAny(target), __narrowAny>(handler), propertyName, value as object) + const success = this.handlerSet(target as object, handler as ProxyHandler, propertyName, value as object) if (!success) { throw new TypeError(`proxy set handler returned false for propety '"${propertyName}"'`) } @@ -413,7 +413,7 @@ export final class Proxy { if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - const success = this.handlerSet(__narrowAny(target), __narrowAny>(handler), propertyName, value as object) + const success = this.handlerSet(target as object, handler as ProxyHandler, propertyName, value as object) if (!success) { throw new TypeError(`proxy set handler returned false for propety '"${propertyName}"'`) } @@ -427,7 +427,7 @@ export final class Proxy { if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - const success = this.handlerSet(__narrowAny(target), __narrowAny>(handler), propertyName, value as object) + const success = this.handlerSet(target as object, handler as ProxyHandler, propertyName, value as object) if (!success) { throw new TypeError(`proxy set handler returned false for propety '"${propertyName}"'`) } @@ -441,7 +441,7 @@ export final class Proxy { if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - const success = this.handlerSet(__narrowAny(target), __narrowAny>(handler), propertyName, value as object) + const success = this.handlerSet(target as object, handler as ProxyHandler, propertyName, value as object) if (!success) { throw new TypeError(`proxy set handler returned false for propety '"${propertyName}"'`) } @@ -455,7 +455,7 @@ export final class Proxy { if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - const success = this.handlerSet(__narrowAny(target), __narrowAny>(handler), propertyName, value as object) + const success = this.handlerSet(target as object, handler as ProxyHandler, propertyName, value as object) if (!success) { throw new TypeError(`proxy set handler returned false for propety '"${propertyName}"'`) } @@ -464,12 +464,12 @@ export final class Proxy { } })) } else { - setterCreator.addBody(new CallableBodyFunction((proxy: Object, value: NullishType): void => { + setterCreator.addBody(new CallableBodyFunction((proxy: Object, value: Any): void => { const handler = Reflect.get(proxy, Proxy.PROXY_INSTANCE_HANDLER_FIELD) if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - const success = this.handlerSet(__narrowAny(target), __narrowAny>(handler), propertyName, value as object) + const success = this.handlerSet(target as object, handler as ProxyHandler, propertyName, value as object) if (!success) { throw new TypeError(`proxy set handler returned false for propety '"${propertyName}"'`) } @@ -479,12 +479,12 @@ export final class Proxy { })) } } else { - setterCreator.addBody(new CallableBodyFunction((proxy: Object, value: NullishType): void => { + setterCreator.addBody(new CallableBodyFunction((proxy: Object, value: Any): void => { const handler = Reflect.get(proxy, Proxy.PROXY_INSTANCE_HANDLER_FIELD) if (handler instanceof ProxyHandler) { const target = Reflect.get(proxy, Proxy.PROXY_INSTANCE_TARGET_FIELD) // using "wrapper" method to "capture" after smartcast - const success = this.handlerSet(__narrowAny(target), __narrowAny>(handler), propertyName, value as object) + const success = this.handlerSet(target as object, handler as ProxyHandler, propertyName, value as object) if (!success) { throw new TypeError(`proxy set handler returned false for propety '"${propertyName}"'`) } @@ -497,7 +497,7 @@ export final class Proxy { proxyTypeCreator.addMethod(setterCreator) } - private handlerInvoke(target: T, handler: ProxyHandler, method: Method, args: FixedArray): NullishType { + private handlerInvoke(target: T, handler: ProxyHandler, method: Method, args: FixedArray): Any { return handler.invoke(target, method, args) } @@ -511,12 +511,12 @@ export final class Proxy { methodProxyCreator .addResult(methodType.getResultType()) - .addBody(new CallableBodyErasedFunction((proxy: NullishType, args: FixedArray): NullishType => { + .addBody(new CallableBodyErasedFunction((proxy: Any, args: FixedArray): Any => { const proxyInstance = proxy as Object const handler = Reflect.get(proxyInstance, Proxy.PROXY_INSTANCE_HANDLER_FIELD) if (handler instanceof ProxyHandler) { const target = Reflect.get(proxyInstance, Proxy.PROXY_INSTANCE_TARGET_FIELD) - return this.handlerInvoke(__narrowAny(target), __narrowAny>(handler), method, args) + return this.handlerInvoke(target as object, handler as ProxyHandler, method, args) } throw new TypeError("unexpected proxy handler type: " + Type.of(handler).getName()) @@ -562,8 +562,8 @@ export final class Proxy { return (p1: P1, p2: P2, p3: P3, p4: P4): R => fn.invoke4(p1, p2, p3, p4) } - private arrayHandlerInvoke(arrayProxy: ArrayProxy, method: Method, args: FixedArray): NullishType { - const methodArgs: FixedArray = new NullishType[args.length] + private arrayHandlerInvoke(arrayProxy: ArrayProxy, method: Method, args: FixedArray): Any { + const methodArgs: FixedArray = new Any[args.length] for (let argIdx = 0; argIdx < args.length; argIdx++) { const arg = args[argIdx] @@ -589,7 +589,7 @@ export final class Proxy { methodProxyCreator .addResult(methodType.getResultType()) - .addBody(new CallableBodyErasedFunction((arrayProxy: NullishType, args: FixedArray): NullishType => { + .addBody(new CallableBodyErasedFunction((arrayProxy: Any, args: FixedArray): Any => { if (arrayProxy instanceof ArrayProxy) { return this.arrayHandlerInvoke(arrayProxy, method, args) } @@ -602,23 +602,23 @@ export final class Proxy { } export interface ProxyHandler { - get(target: T, name: string): NullishType + get(target: T, name: string): Any - set(target: T, name: string, value: NullishType): boolean + set(target: T, name: string, value: Any): boolean - invoke(target: T, method: Method, args: FixedArray): NullishType + invoke(target: T, method: Method, args: FixedArray): Any } export abstract class DefaultProxyHandler implements ProxyHandler { - override get(target: T, name: string): NullishType { + override get(target: T, name: string): Any { return Reflect.get(target, name) } - override set(target: T, name: string, value: NullishType): boolean { + override set(target: T, name: string, value: Any): boolean { return Reflect.set(target, name, value) } - override invoke(target: T, method: Method, args: FixedArray): NullishType { + override invoke(target: T, method: Method, args: FixedArray): Any { return method.invoke(target, args) } } @@ -630,7 +630,7 @@ export interface ArrayProxyHandler extends ProxyHandler> { } export abstract class DefaultArrayProxyHandler extends DefaultProxyHandler> implements ArrayProxyHandler { - override get(target: Array, name: string): NullishType { + override get(target: Array, name: string): Any { if (name == ArrayProxy.LENGTH_PROP_NAME) { return target.length } @@ -638,7 +638,7 @@ export abstract class DefaultArrayProxyHandler extends DefaultProxyHandler, name: string, value: NullishType): boolean { + override set(target: Array, name: string, value: Any): boolean { if (name == ArrayProxy.LENGTH_PROP_NAME) { if (value instanceof Number) { target.length = value @@ -649,7 +649,7 @@ export abstract class DefaultArrayProxyHandler extends DefaultProxyHandler, method: Method, args: FixedArray): NullishType { + override invoke(target: Array, method: Method, args: FixedArray): Any { return super.invoke(target, method, args) } @@ -772,7 +772,7 @@ abstract class ArrayProxy extends Array { } // this "wrapper" method is a workaround for #20860 - private handlerGet(target: Array, handler: ProxyHandler>, name: string): NullishType { + private handlerGet(target: Array, handler: ProxyHandler>, name: string): Any { return handler.get(target, name) } @@ -785,7 +785,7 @@ abstract class ArrayProxy extends Array { throw new TypeError("unexpected Array.length value type: " + Type.of(length)) } - private handlerSet(target: Array, handler: ProxyHandler>, name: string, value: NullishType): void { + private handlerSet(target: Array, handler: ProxyHandler>, name: string, value: Any): void { const success = handler.set(target, name, value) if (!success) { throw new TypeError(`proxy set handler returned false for propety '"${name}"'`) @@ -849,7 +849,7 @@ abstract class ArrayProxy extends Array { const handler = this.handler const result = handler.invoke(this.target, ArrayProxy.SPLICE_METHOD_NUM_OBJ_ARR, [start, deleteCount, items]) if (result instanceof Array) { - return __narrowAny>(result) + return result as Array } throw new AssertionError("Array.splice(int, int, T[]) unexpected result type: " + Type.of(result)) @@ -859,7 +859,7 @@ abstract class ArrayProxy extends Array { const handler = this.handler const result = handler.invoke(this.target, ArrayProxy.SPLICE_METHOD_INT_INT_ARR, [start, deleteCount, items]) if (result instanceof Array) { - return __narrowAny>(result) + return result as Array } throw new AssertionError("Array.splice(int, int, T[]) unexpected result type: " + Type.of(result)) @@ -868,7 +868,7 @@ abstract class ArrayProxy extends Array { override splice(start: number): Array { const result = this.handler.invoke(this.target, ArrayProxy.SPLICE_METHOD_NUM, [start]) if (result instanceof Array) { - return __narrowAny>(result) + return result as Array } throw new AssertionError("Array.splice(number) unexpected result type: " + Type.of(result)) @@ -877,7 +877,7 @@ abstract class ArrayProxy extends Array { override splice(start: int): Array { const result = this.handler.invoke(this.target, ArrayProxy.SPLICE_METHOD_INT, [start]) if (result instanceof Array) { - return __narrowAny>(result) + return result as Array } throw new AssertionError("Array.splice(int) unexpected result type: " + Type.of(result)) diff --git a/static_core/plugins/ets/stdlib/std/core/ReadonlyArrayProxy.ets b/static_core/plugins/ets/stdlib/std/core/ReadonlyArrayProxy.ets index e72527fa01..b94700857c 100644 --- a/static_core/plugins/ets/stdlib/std/core/ReadonlyArrayProxy.ets +++ b/static_core/plugins/ets/stdlib/std/core/ReadonlyArrayProxy.ets @@ -18,13 +18,13 @@ package std.core; export namespace proxy { export interface ReadonlyArrayProxyHandler { - get(target: ReadonlyArray, name: string): NullishType + get(target: ReadonlyArray, name: string): Any get(target: ReadonlyArray, index: int): T } export abstract class DefaultReadonlyArrayProxyHandler implements ReadonlyArrayProxyHandler { - override get(target: ReadonlyArray, name: string): NullishType { + override get(target: ReadonlyArray, name: string): Any { if (name == "length") { return target.length } diff --git a/static_core/plugins/ets/stdlib/std/core/Runtime.ets b/static_core/plugins/ets/stdlib/std/core/Runtime.ets index f587aca6b4..78b2fd4019 100644 --- a/static_core/plugins/ets/stdlib/std/core/Runtime.ets +++ b/static_core/plugins/ets/stdlib/std/core/Runtime.ets @@ -191,11 +191,6 @@ export final class Runtime { } } -// Deprecated. Narrow the value to type T or to default (object | null | undefined). -export function __narrowAny(v: Any): T { - return v as T -} - export function __runtimeEquals(o1: Any, o2: Any): boolean { return Runtime.equals(o1, o2) } diff --git a/static_core/plugins/ets/stdlib/std/core/Short.ets b/static_core/plugins/ets/stdlib/std/core/Short.ets index 394342ee9d..5b06cb22f0 100644 --- a/static_core/plugins/ets/stdlib/std/core/Short.ets +++ b/static_core/plugins/ets/stdlib/std/core/Short.ets @@ -321,7 +321,7 @@ export final class Short extends Integral implements Comparable { * @returns true if provided object and this instance have same value, false otherwise * Returns false if type of provided object is not the same as this type */ - public equals(other: NullishType): boolean { + public equals(other: Any): boolean { if (this === other) { return true } diff --git a/static_core/plugins/ets/stdlib/std/core/String.ets b/static_core/plugins/ets/stdlib/std/core/String.ets index 55340b82ca..f504ad01c2 100644 --- a/static_core/plugins/ets/stdlib/std/core/String.ets +++ b/static_core/plugins/ets/stdlib/std/core/String.ets @@ -60,11 +60,11 @@ export final class String extends Object implements Comparable, Iterable public native constructor(otherStr: String) /** - * Constructs String from NullishType + * Constructs String from Any * * @param object initializer */ - public native constructor(object: NullishType) + public native constructor(object: Any) /** * Creates a new instance of a String @@ -118,7 +118,7 @@ export final class String extends Object implements Comparable, Iterable * @remarks * Implemented as native function, @see `equals()` intrinsic [declaration](https://gitee.com/openharmony-sig/arkcompiler_runtime_core/blob/master/plugins/ets/runtime/ets_libbase_runtime.yaml#L596). */ - public native equals(to: NullishType): boolean; + public native equals(to: Any): boolean; /** * Length of this string diff --git a/static_core/plugins/ets/stdlib/std/core/Type.ets b/static_core/plugins/ets/stdlib/std/core/Type.ets index 927b3a6c26..d654dd1ad0 100644 --- a/static_core/plugins/ets/stdlib/std/core/Type.ets +++ b/static_core/plugins/ets/stdlib/std/core/Type.ets @@ -93,11 +93,11 @@ class TypeAPI { private static NullTypeDescriptor: RuntimeTypeDescriptor = TypeAPI.getNullTypeDescriptor() private static UndefinedTypeDescriptor: RuntimeTypeDescriptor = TypeAPI.getUndefinedTypeDescriptor() - static getTypeDescriptor(o: NullishType): RuntimeTypeDescriptor { + static getTypeDescriptor(o: Any): RuntimeTypeDescriptor { if (o === null) { return TypeAPI.NullTypeDescriptor } - return (o === undefined) ? TypeAPI.UndefinedTypeDescriptor : TypeAPI.getClassDescriptor(Class.of(__narrowAny(o))) + return (o === undefined) ? TypeAPI.UndefinedTypeDescriptor : TypeAPI.getClassDescriptor(Class.of(o as object)) } static getTypeName(cls: Class): string { @@ -368,9 +368,9 @@ export abstract class Type extends Object { // ----- - public static of(o: NullishType): Type { + public static of(o: Any): Type { const td = TypeAPI.getTypeDescriptor(o) - const contextClass = o == undefined ? Class.ofCaller() : Class.of(__narrowAny(o)) + const contextClass = o == undefined ? Class.ofCaller() : Class.of(o as object) const contextLinker = contextClass == undefined ? getBootRuntimeLinker() : contextClass.getLinker() return Type.resolve(td, contextLinker)! } @@ -538,7 +538,7 @@ export abstract class Type extends Object { return false } - internal abstract convertObject(obj: NullishType): NullishType; + internal abstract convertObject(obj: Any): Any; private isNumericType(): boolean { return (this) instanceof ByteType @@ -675,7 +675,7 @@ export final class NullType extends Type { return other instanceof NullType } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { if (obj != null) { throw new Error("invalid conversion") } @@ -746,7 +746,7 @@ export final class UndefinedType extends Type { return other instanceof UndefinedType } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { throw new Error("todo(kprokopenko): add when undefined becomes available") } } @@ -821,7 +821,7 @@ export final class VoidType extends Type { return other instanceof VoidType } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { if (!this.assignableFrom(Type.of(obj))) { throw new Error("invalid conversion") } @@ -905,7 +905,7 @@ export final class CharType extends Type { return other instanceof CharType && this.isValue != (other as CharType).isReference() } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { const objType = Type.of(obj) if (!this.equals(objType)) { throw new Error("invalid type for conversion") @@ -989,7 +989,7 @@ export final class BooleanType extends Type { return other instanceof BooleanType && this.isValue != (other as BooleanType).isReference() } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { const objType = Type.of(obj) if (!this.equals(objType)) { throw new Error("invalid type for conversion") @@ -1073,7 +1073,7 @@ export final class ByteType extends Type { return other instanceof ByteType && this.isValue != (other as ByteType).isReference() } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { const objType = Type.of(obj) if (this.equals(objType)) { return obj @@ -1168,7 +1168,7 @@ export final class ShortType extends Type { return other instanceof ShortType && this.isValue != (other as ShortType).isReference() } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { const objType = Type.of(obj) if (this.equals(objType)) { return obj @@ -1263,7 +1263,7 @@ export final class IntType extends Type { return other instanceof IntType && this.isValue != (other as IntType).isReference() } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { const objType = Type.of(obj) if (this.equals(objType)) { return obj @@ -1358,7 +1358,7 @@ export final class LongType extends Type { return other instanceof LongType && this.isValue != (other as LongType).isReference() } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { const objType = Type.of(obj) if (this.equals(objType)) { return obj @@ -1453,7 +1453,7 @@ export final class FloatType extends Type { return other instanceof FloatType && this.isValue != (other as FloatType).isReference() } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { const objType = Type.of(obj) if (this.equals(objType)) { return obj @@ -1548,7 +1548,7 @@ export final class DoubleType extends Type { return other instanceof DoubleType && this.isValue != (other as DoubleType).isReference() } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { const objType = Type.of(obj) if (this.equals(objType)) { return obj @@ -1882,7 +1882,7 @@ export final class ClassType extends Type { } // todo(kprokopenko): make varargs - public make(args: FixedArray): Object { + public make(args: FixedArray): Object { const argTypes = new Array(args.length) for (let i = 0; i < args.length; i++) { argTypes[i] = Type.of(args[i]) @@ -1934,7 +1934,7 @@ export final class ClassType extends Type { if (ctors.length != 1) { throw new Error("can't select consturctor: " + ctors.length + " left") } - return __narrowAny(ctors.at(0)!.invoke(undefined, args))! + return ctors.at(0)!.invoke(undefined, args) as Object } // class.subTypeOf(U) means that `class extends U` or `class implements U` @@ -1970,7 +1970,7 @@ export final class ClassType extends Type { return false } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { const objType = Type.of(obj) if (!this.assignableFrom(objType)) { throw new Error("invalid conversion") @@ -2152,7 +2152,7 @@ export final class InterfaceType extends Type { return TypeAPI.isInheritedFrom(this.cls, expected.cls) } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { const objType = Type.of(obj) if (!this.assignableFrom(objType)) { throw new Error("invalid conversion") @@ -2318,7 +2318,7 @@ export final class ArrayType extends Type { return TypeAPI.makeArrayInstance(this.elemTD, this.getContextLinker(), length) } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { const objType = Type.of(obj) if (this.equals(objType)) { return obj @@ -2359,7 +2359,7 @@ export final class TupleType extends Type { throw new Error("Not implemented") } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { throw new Error("todo(kprokopenko): add when tuple becomes available") } } @@ -2601,7 +2601,7 @@ export final class LambdaType extends FunctionType { } } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { const objType = Type.of(obj) if (this.equals(objType)) { return obj @@ -2664,7 +2664,7 @@ export final class MethodType extends FunctionType { return this.getReceiverTypeDescriptor() !== undefined } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { throw new Error("Only LambdaType can be converted") } @@ -2739,7 +2739,7 @@ export final class StringType extends Type { return other instanceof StringType } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { const objType = Type.of(obj) if (!this.equals(objType)) { throw new Error("invalid conversion") @@ -2851,7 +2851,7 @@ export final class EnumType extends Type { throw new Error("not implemented") } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { throw new Error("todo(kprokopenko): enum conversion") } } @@ -2967,7 +2967,7 @@ export final class UnionType extends Type { throw new Error("not implemented") } - internal override convertObject(obj: NullishType): NullishType { + internal override convertObject(obj: Any): Any { const objType = Type.of(obj) if (this.equals(objType)) { return obj diff --git a/static_core/plugins/ets/stdlib/std/core/TypeCreator.ets b/static_core/plugins/ets/stdlib/std/core/TypeCreator.ets index 307a10ab4e..d0c2ea09d2 100644 --- a/static_core/plugins/ets/stdlib/std/core/TypeCreator.ets +++ b/static_core/plugins/ets/stdlib/std/core/TypeCreator.ets @@ -1235,8 +1235,8 @@ export final class CallableBodyFunction extends CallableBody { * Represents call to lambda with boxing all arguments */ export final class CallableBodyErasedFunction extends CallableBody { - internal /* readonly */ body: (recv: NullishType, args: FixedArray) => NullishType - public constructor(m: (recv: NullishType, args: FixedArray) => NullishType) { + internal /* readonly */ body: (recv: Any, args: FixedArray) => Any + public constructor(m: (recv: Any, args: FixedArray) => Any) { super() this.body = m } diff --git a/static_core/plugins/ets/stdlib/std/core/Value.ets b/static_core/plugins/ets/stdlib/std/core/Value.ets index 2aa65c6aa8..1f419f6033 100644 --- a/static_core/plugins/ets/stdlib/std/core/Value.ets +++ b/static_core/plugins/ets/stdlib/std/core/Value.ets @@ -179,7 +179,7 @@ export abstract class Value extends Object { * * @returns {@link Value} of this object */ - public static of(o: NullishType): Value { + public static of(o: Any): Value { if (o instanceof Value) { return o as Value } else if (o instanceof Boolean) { @@ -208,13 +208,13 @@ export abstract class Value extends Object { } else if (t instanceof VoidType) { return VoidValue.INSTANCE } else if (t instanceof ClassType) { - return new ClassValue(t as ClassType, __narrowAny(o)!) + return new ClassValue(t as ClassType, o as object) } else if (t instanceof ArrayType) { - return new ArrayValue(t as ArrayType, __narrowAny(o)!) + return new ArrayValue(t as ArrayType, o as object) } else if (t instanceof StringType) { return new StringValue(t as StringType, o! as string) } else if (t instanceof LambdaType) { - return new LambdaValue(t as LambdaType, __narrowAny(o)!) + return new LambdaValue(t as LambdaType, o as object) } else if (t instanceof MethodType) { throw new Error("The MethodType cannot be instantiated") } else if (t instanceof EnumType) { @@ -263,7 +263,7 @@ export abstract class Value extends Object { public abstract getType(): Type - public abstract getData(): NullishType + public abstract getData(): Any public abstract toPrint(depth: int): string } @@ -282,7 +282,7 @@ export final class ClassValue extends reflect.Value { return this.typ as Type } - public override getData(): NullishType { + public override getData(): Any { return this.data } @@ -412,11 +412,11 @@ export final class ClassValue extends reflect.Value { } else if (ft.assignableFrom(StringType.REF) && val instanceof StringValue) { ValueAPISetFieldByNameObject(this.data, name, (val as StringValue).getData()! as string) } else if (ft instanceof ArrayType && val instanceof ArrayValue) { - ValueAPISetFieldByNameObject(this.data, name, __narrowAny((val as ArrayValue).getData())!) + ValueAPISetFieldByNameObject(this.data, name, (val as ArrayValue).getData() as object) } else if (ft instanceof ClassType && this.isAssignableToObject(val)) { - ValueAPISetFieldByNameObject(this.data, name, __narrowAny(val.getData())!) + ValueAPISetFieldByNameObject(this.data, name, val.getData() as object) } else if (ft instanceof LambdaType && val instanceof LambdaValue) { - ValueAPISetFieldByNameObject(this.data, name, __narrowAny((val as LambdaValue).getData())!) + ValueAPISetFieldByNameObject(this.data, name, (val as LambdaValue).getData() as object) } else if (ft instanceof DoubleType && val instanceof ByteValue) { ValueAPISetFieldByNameDouble(this.data, name, val.getValueData()) } else if (ft instanceof DoubleType && val instanceof ShortValue) { @@ -502,11 +502,11 @@ export final class ClassValue extends reflect.Value { } else if (ft instanceof StringType && val instanceof StringValue) { ValueAPISetFieldObject(this.data, i, (val as StringValue).getData()! as string) } else if (ft instanceof ArrayType && val instanceof ArrayValue) { - ValueAPISetFieldObject(this.data, i, __narrowAny((val as ArrayValue).getData())!) + ValueAPISetFieldObject(this.data, i, (val as ArrayValue).getData() as object) } else if (ft instanceof ClassType && this.isAssignableToObject(val)) { - ValueAPISetFieldObject(this.data, i, __narrowAny((val as ClassValue).getData())!) + ValueAPISetFieldObject(this.data, i, (val as ClassValue).getData() as object) } else if (ft instanceof LambdaType && val instanceof LambdaValue) { - ValueAPISetFieldObject(this.data, i, __narrowAny(val.getData())!) + ValueAPISetFieldObject(this.data, i, val.getData() as object) } else { throw new Error("Cannot assign field of type " + ft + " with value of type " + vt) } @@ -568,7 +568,7 @@ export final class ArrayValue extends reflect.Value { return this.typ as Type } - public override getData(): NullishType { + public override getData(): Any { return this.data } @@ -640,9 +640,9 @@ export final class ArrayValue extends reflect.Value { } else if (et instanceof StringType && val instanceof StringValue) { ValueAPISetElementObject(this.data, i, (val as StringValue).getData()! as string) } else if (et instanceof ArrayType && val instanceof ArrayValue) { - ValueAPISetElementObject(this.data, i, __narrowAny((val as ArrayValue).getData())!) + ValueAPISetElementObject(this.data, i, (val as ArrayValue).getData() as object) } else if (et instanceof ClassType && val instanceof ClassValue) { - ValueAPISetElementObject(this.data, i, __narrowAny((val as ClassValue).getData())!) + ValueAPISetElementObject(this.data, i, (val as ClassValue).getData() as object) } else { throw new Error("Cannot assign array of type " + et + " with value of type " + vt) } @@ -706,7 +706,7 @@ export final class LambdaValue extends reflect.Value { return this.typ as Type } - public override getData(): NullishType { + public override getData(): Any { return this.data } @@ -744,7 +744,7 @@ export final class BooleanValue extends reflect.Value { return this.typ as Type } - public override getData(): NullishType { + public override getData(): Any { return new Boolean(this.data) } @@ -781,7 +781,7 @@ export final class ByteValue extends reflect.Value { return this.typ as Type } - public override getData(): NullishType { + public override getData(): Any { return new Byte(this.data) } @@ -818,7 +818,7 @@ export final class ShortValue extends reflect.Value { return this.typ as Type } - public override getData(): NullishType { + public override getData(): Any { return new Short(this.data) } @@ -855,7 +855,7 @@ export final class CharValue extends reflect.Value { return this.typ as Type } - public override getData(): NullishType { + public override getData(): Any { return new Char(this.data) } @@ -892,7 +892,7 @@ export final class IntValue extends reflect.Value { return this.typ as Type } - public override getData(): NullishType { + public override getData(): Any { return new Int(this.data) } @@ -929,7 +929,7 @@ export final class FloatValue extends reflect.Value { return this.typ as Type } - public override getData(): NullishType { + public override getData(): Any { return new Float(this.data) } @@ -966,7 +966,7 @@ export final class DoubleValue extends reflect.Value { return this.typ as Type } - public override getData(): NullishType { + public override getData(): Any { return this.data } @@ -1003,7 +1003,7 @@ export final class LongValue extends reflect.Value { return this.typ as Type } - public override getData(): NullishType { + public override getData(): Any { return new Long(this.data) } @@ -1040,7 +1040,7 @@ export final class StringValue extends reflect.Value { return this.typ as Type } - public override getData(): NullishType { + public override getData(): Any { return this.data } @@ -1072,7 +1072,7 @@ export final class NullValue extends reflect.Value { return NullType.REF as Type } - public override getData(): NullishType { + public override getData(): Any { return null } @@ -1101,7 +1101,7 @@ export final class UndefinedValue extends reflect.Value { return UndefinedType.REF as Type } - public override getData(): NullishType { + public override getData(): Any { return undefined } @@ -1130,7 +1130,7 @@ export final class VoidValue extends reflect.Value { return VoidType.REF as Type } - public override getData(): NullishType { + public override getData(): Any { return Void.void_instance } diff --git a/static_core/plugins/ets/stdlib/std/interop/js/InteropTransferHelper.ets b/static_core/plugins/ets/stdlib/std/interop/js/InteropTransferHelper.ets index e714a51c3a..01a2e77dec 100644 --- a/static_core/plugins/ets/stdlib/std/interop/js/InteropTransferHelper.ets +++ b/static_core/plugins/ets/stdlib/std/interop/js/InteropTransferHelper.ets @@ -26,7 +26,7 @@ export final class InteropTransferHelper { if (dynamicObject == null || dynamicObject == undefined) { throw new Error("dynamicObject is null or undefined"); } - let dynamicESValue = ESValue.wrap(__narrowAny(dynamicObject)); + let dynamicESValue = ESValue.wrap(dynamicObject as object); return InteropTransferHelper.transferArrayBufferToStaticImpl(dynamicESValue) as Object; } @@ -46,7 +46,7 @@ export final class InteropTransferHelper { throw new Error("dynamicObject is null or undefined"); } - let dynamicESValue = ESValue.wrap(__narrowAny(dynamicObject)); + let dynamicESValue = ESValue.wrap(dynamicObject as object); let dynamicBuffer = dynamicESValue.getProperty("buffer"); let byteOffset = dynamicESValue.getProperty("byteOffset").toNumber(); let length = dynamicESValue.getProperty("length").toNumber(); @@ -80,7 +80,7 @@ export final class InteropTransferHelper { throw new Error("dynamicObject is null or undefined"); } - let dynamicESValue = ESValue.wrap(__narrowAny(dynamicObject)); + let dynamicESValue = ESValue.wrap(dynamicObject as object); let dynamicBuffer = dynamicESValue.getProperty("buffer"); let byteOffset = dynamicESValue.getProperty("byteOffset").toNumber(); let length = dynamicESValue.getProperty("length").toNumber(); @@ -114,7 +114,7 @@ export final class InteropTransferHelper { throw new Error("dynamicObject is null or undefined"); } - let dynamicESValue = ESValue.wrap(__narrowAny(dynamicObject)); + let dynamicESValue = ESValue.wrap(dynamicObject as object); let dynamicBuffer = dynamicESValue.getProperty("buffer"); let byteOffset = dynamicESValue.getProperty("byteOffset").toNumber(); let length = dynamicESValue.getProperty("length").toNumber(); @@ -148,7 +148,7 @@ export final class InteropTransferHelper { throw new Error("dynamicObject is null or undefined"); } - let dynamicESValue = ESValue.wrap(__narrowAny(dynamicObject)); + let dynamicESValue = ESValue.wrap(dynamicObject as object); let dynamicBuffer = dynamicESValue.getProperty("buffer"); let byteOffset = dynamicESValue.getProperty("byteOffset").toNumber(); let length = dynamicESValue.getProperty("length").toNumber(); @@ -182,7 +182,7 @@ export final class InteropTransferHelper { throw new Error("dynamicObject is null or undefined"); } - let dynamicESValue = ESValue.wrap(__narrowAny(dynamicObject)); + let dynamicESValue = ESValue.wrap(dynamicObject as object); let dynamicBuffer = dynamicESValue.getProperty("buffer"); let byteOffset = dynamicESValue.getProperty("byteOffset").toNumber(); let length = dynamicESValue.getProperty("length").toNumber(); @@ -216,7 +216,7 @@ export final class InteropTransferHelper { throw new Error("dynamicObject is null or undefined"); } - let dynamicESValue = ESValue.wrap(__narrowAny(dynamicObject)); + let dynamicESValue = ESValue.wrap(dynamicObject as object); let dynamicBuffer = dynamicESValue.getProperty("buffer"); let byteOffset = dynamicESValue.getProperty("byteOffset").toNumber(); let length = dynamicESValue.getProperty("length").toNumber(); @@ -250,7 +250,7 @@ export final class InteropTransferHelper { throw new Error("dynamicObject is null or undefined"); } - let dynamicESValue = ESValue.wrap(__narrowAny(dynamicObject)); + let dynamicESValue = ESValue.wrap(dynamicObject as object); let dynamicBuffer = dynamicESValue.getProperty("buffer"); let byteOffset = dynamicESValue.getProperty("byteOffset").toNumber(); let length = dynamicESValue.getProperty("length").toNumber(); @@ -284,7 +284,7 @@ export final class InteropTransferHelper { throw new Error("dynamicObject is null or undefined"); } - let dynamicESValue = ESValue.wrap(__narrowAny(dynamicObject)); + let dynamicESValue = ESValue.wrap(dynamicObject as object); let dynamicBuffer = dynamicESValue.getProperty("buffer"); let byteOffset = dynamicESValue.getProperty("byteOffset").toNumber(); let length = dynamicESValue.getProperty("length").toNumber(); @@ -318,7 +318,7 @@ export final class InteropTransferHelper { throw new Error("dynamicObject is null or undefined"); } - let dynamicESValue = ESValue.wrap(__narrowAny(dynamicObject)); + let dynamicESValue = ESValue.wrap(dynamicObject as object); let dynamicBuffer = dynamicESValue.getProperty("buffer"); let byteOffset = dynamicESValue.getProperty("byteOffset").toNumber(); let length = dynamicESValue.getProperty("length").toNumber(); @@ -352,7 +352,7 @@ export final class InteropTransferHelper { throw new Error("dynamicObject is null or undefined"); } - let dynamicESValue = ESValue.wrap(__narrowAny(dynamicObject)); + let dynamicESValue = ESValue.wrap(dynamicObject as object); let dynamicBuffer = dynamicESValue.getProperty("buffer"); let byteOffset = dynamicESValue.getProperty("byteOffset").toNumber(); let length = dynamicESValue.getProperty("length").toNumber(); @@ -386,7 +386,7 @@ export final class InteropTransferHelper { throw new Error("dynamicObject is null or undefined"); } - let dynamicESValue = ESValue.wrap(__narrowAny(dynamicObject)); + let dynamicESValue = ESValue.wrap(dynamicObject as object); let dynamicBuffer = dynamicESValue.getProperty("buffer"); let byteOffset = dynamicESValue.getProperty("byteOffset").toNumber(); let length = dynamicESValue.getProperty("length").toNumber(); @@ -420,7 +420,7 @@ export final class InteropTransferHelper { throw new Error("dynamicObject is null or undefined"); } - let dynamicESValue = ESValue.wrap(__narrowAny(dynamicObject)); + let dynamicESValue = ESValue.wrap(dynamicObject as object); let dynamicBuffer = dynamicESValue.getProperty("buffer"); let byteOffset = dynamicESValue.getProperty("byteOffset").toNumber().toInt(); let byteLength = dynamicESValue.getProperty("byteLength").toNumber().toInt(); diff --git a/static_core/plugins/ets/stdlib/std/interop/js/PromiseInterop.ets b/static_core/plugins/ets/stdlib/std/interop/js/PromiseInterop.ets index 2b39172086..f41f8df1fd 100644 --- a/static_core/plugins/ets/stdlib/std/interop/js/PromiseInterop.ets +++ b/static_core/plugins/ets/stdlib/std/interop/js/PromiseInterop.ets @@ -19,12 +19,12 @@ final class PromiseInterop { static connectPromise(p: Promise, deferred: long): void { p.then((value: T): void => { PromiseInterop.resolve(value, deferred); - }, (error: NullishType): void => { + }, (error: Any): void => { PromiseInterop.reject(error, deferred); }); } private static native resolve(value: T, deferred: long): void; - private static native reject(error: NullishType, deferred: long): void; + private static native reject(error: Any, deferred: long): void; } diff --git a/static_core/plugins/ets/templates/stdlib/Array_builtin.erb b/static_core/plugins/ets/templates/stdlib/Array_builtin.erb index d2dead95d6..a19f104e2b 100644 --- a/static_core/plugins/ets/templates/stdlib/Array_builtin.erb +++ b/static_core/plugins/ets/templates/stdlib/Array_builtin.erb @@ -177,9 +177,9 @@ export function concat<%= ctx.this_generic %>(self: <%= ctx.this_type %>, fst: < * @note Mutating method */ export function sort<%= ctx.this_generic %>(<%= ctx.this_arg %>comparator: (a: <%= ctx.el_type %>, b: <%= ctx.el_type %>) => number, start?: int, end?: int): <%= ctx.this_return_type %> { -% sort_elem_type = ctx.el_type == 'T' ? 'NullishType' : ctx.el_type +% sort_elem_type = ctx.el_type == 'T' ? 'Any' : ctx.el_type % from_sort_elem_type = ctx.el_type == 'T' ? ' as T' : '' - sort_subarray(self<%= ctx.el_type == 'T' ? ' as FixedArray' : '' %>, (start == undefined) ? 0 : start!, (end == undefined) ? self.length : end!, (l: <%= sort_elem_type %>, r: <%= sort_elem_type %>): boolean => { + sort_subarray(self<%= ctx.el_type == 'T' ? ' as FixedArray' : '' %>, (start == undefined) ? 0 : start!, (end == undefined) ? self.length : end!, (l: <%= sort_elem_type %>, r: <%= sort_elem_type %>): boolean => { return comparator(l<%= from_sort_elem_type %>, r <%= from_sort_elem_type %>) < 0; }); return self; @@ -194,7 +194,7 @@ export function sort<%= ctx.this_generic %>(<%= ctx.this_arg %>comparator: (a: < */ export function sort<%= ctx.this_generic %>(<%= ctx.this_arg.chomp(', ') %>): <%= ctx.this_return_type %> { % if !primitive_types.include?(ctx.el_type) - sort_subarray(self<%= ctx.el_type == 'T' ? ' as FixedArray' : '' %>, 0, self.length, (l: <%= sort_elem_type %>, r: <%= sort_elem_type %>): boolean => { + sort_subarray(self<%= ctx.el_type == 'T' ? ' as FixedArray' : '' %>, 0, self.length, (l: <%= sort_elem_type %>, r: <%= sort_elem_type %>): boolean => { return new String(l).compareTo(new String(r)) < 0; }); % else diff --git a/static_core/plugins/ets/templates/stdlib/Array_builtin_algorithms.ets.j2 b/static_core/plugins/ets/templates/stdlib/Array_builtin_algorithms.ets.j2 index d8a52a0489..af15a4b8c2 100644 --- a/static_core/plugins/ets/templates/stdlib/Array_builtin_algorithms.ets.j2 +++ b/static_core/plugins/ets/templates/stdlib/Array_builtin_algorithms.ets.j2 @@ -19,9 +19,9 @@ package std.core; export const KEY_NOT_FOUND = -1; -{% for T in ['boolean', 'byte', 'short', 'int', 'long', 'float', 'double', 'char', 'NullishType'] %} +{% for T in ['boolean', 'byte', 'short', 'int', 'long', 'float', 'double', 'char', 'Any'] %} -{% if T != "NullishType" -%} +{% if T != "Any" -%} // C++ semantics // (lower|upper)BoundSearch([1, 1, 2, 2, 2, 3, 3], 2, 0, 7) // ^ ^ diff --git a/static_core/plugins/ets/templates/stdlib/Array_common.erb b/static_core/plugins/ets/templates/stdlib/Array_common.erb index 51aa050706..4fc7c94244 100644 --- a/static_core/plugins/ets/templates/stdlib/Array_common.erb +++ b/static_core/plugins/ets/templates/stdlib/Array_common.erb @@ -678,7 +678,7 @@ private joinObject(sep?: String): string { if (i != 0) { sb.append(",") } - let x = <%= get_unsafe.(this, 'i') %> as NullishType; + let x = <%= get_unsafe.(this, 'i') %> as Any; if ((null !== x) && (undefined !== x)) { sb.append((x! as object).toLocaleString()) // #26217 } diff --git a/static_core/plugins/ets/templates/stdlib/Array_escompat.erb b/static_core/plugins/ets/templates/stdlib/Array_escompat.erb index ef3cbe5d7b..60c1a5e1fe 100644 --- a/static_core/plugins/ets/templates/stdlib/Array_escompat.erb +++ b/static_core/plugins/ets/templates/stdlib/Array_escompat.erb @@ -50,7 +50,7 @@ const FROM_BUFFER: FromBuffer; * Represents JS API-compatible Array */ export class Array implements ReadonlyArray, Iterable { - private buffer: FixedArray + private buffer: FixedArray internal actualLength: int override get length(): number { @@ -91,7 +91,7 @@ export class Array implements ReadonlyArray, Iterable { * Creates a new instance of Array */ public constructor(arrayLen: int) { - this.buffer = new NullishType[arrayLen] + this.buffer = new Any[arrayLen] this.actualLength = arrayLen } @@ -99,13 +99,13 @@ export class Array implements ReadonlyArray, Iterable { this(arrayLen.toInt()) } - internal constructor(_tag: FromBuffer, buf: FixedArray) { + internal constructor(_tag: FromBuffer, buf: FixedArray) { this.buffer = buf this.actualLength = buf.length } internal constructor() { - this.buffer = new NullishType[4] + this.buffer = new Any[4] this.actualLength = 0 } @@ -115,7 +115,7 @@ export class Array implements ReadonlyArray, Iterable { * @param d Array initializer */ public constructor(first: T, ...d: T[]) { - this.buffer = new NullishType[d.length + 1] + this.buffer = new Any[d.length + 1] this.actualLength = d.length.toInt() + 1 this.buffer[0] = first @@ -295,9 +295,9 @@ export class Array implements ReadonlyArray, Iterable { */ public static from(arr: FixedArray): Array { const len = arr.length - const ret : FixedArray = new NullishType[len.toInt()] + const ret : FixedArray = new Any[len.toInt()] for (let i: int = 0; i < len; i++) { - ret[i] = arr[i] as NullishType + ret[i] = arr[i] as Any } return new Array(FROM_BUFFER, ret) } @@ -619,7 +619,7 @@ export class Array implements ReadonlyArray, Iterable { * * @returns Returns one of values -1, 0, 1 (_less_, _equal_, _greater_ respectively). */ - private static defaultComparator(a: NullishType, b: NullishType): number { + private static defaultComparator(a: Any, b: Any): number { if (a instanceof Number && b instanceof Number) { const x = a const y = b @@ -677,9 +677,9 @@ export class Array implements ReadonlyArray, Iterable { * * @returns Copy of an `Array`'s primitive array data. */ - private copyArray(): FixedArray { + private copyArray(): FixedArray { let len: int = this.actualLength - let res : FixedArray = new NullishType[len] + let res : FixedArray = new Any[len] for (let i = 0; i < len; i++) { res[i] = this.$_get_unsafe(i) } @@ -709,7 +709,7 @@ export class Array implements ReadonlyArray, Iterable { this.$_set_unsafe(i, undefined as T) } - sort_default(this.buffer, strArr, 0, sortTo) + sort_default(this.buffer, strArr, 0, sortTo) } catch (e) { if (e instanceof OutOfMemoryError) { @@ -722,7 +722,7 @@ export class Array implements ReadonlyArray, Iterable { private slow_default_sort(): void { let idxNonUndef = 0 - const cmp: (l: NullishType, r: NullishType) => number = (l: NullishType, r: NullishType): number => { + const cmp: (l: Any, r: Any) => number = (l: Any, r: Any): number => { return Array.defaultComparator(l, r) } for (let i = 0; i < this.actualLength; i++) { @@ -736,7 +736,7 @@ export class Array implements ReadonlyArray, Iterable { for (let i = idxNonUndef; i < this.actualLength; i++) { this.$_set_unsafe(i, undefined as T) } - sort_stable(this.buffer, 0, sortTo, cmp) + sort_stable(this.buffer, 0, sortTo, cmp) } private move_undefined_end(): int { @@ -779,10 +779,10 @@ export class Array implements ReadonlyArray, Iterable { } const compareTo: int = this.move_undefined_end() - let cmp: (l: NullishType, r: NullishType) => number = (l: NullishType, r: NullishType): number => { + let cmp: (l: Any, r: Any) => number = (l: Any, r: Any): number => { return comparator!(l as T, r as T) } - sort_stable(this.buffer, 0, compareTo, cmp) + sort_stable(this.buffer, 0, compareTo, cmp) return this } @@ -866,7 +866,7 @@ export class Array implements ReadonlyArray, Iterable { private ensureUnusedCapacity(cap: int): void { if (this.actualLength + cap > this.buffer.length) { - const copy : FixedArray = new NullishType[this.buffer.length * 2 + cap] + const copy : FixedArray = new Any[this.buffer.length * 2 + cap] for (let i = 0; i < this.actualLength; i++) { copy[i] = this.buffer[i] } @@ -968,7 +968,7 @@ export class Array implements ReadonlyArray, Iterable { * * @returns true is arr is a non-nullish array, false otherwise */ - public static isArray(o: NullishType): boolean { + public static isArray(o: Any): boolean { if (o instanceof Array) { return true } @@ -1003,7 +1003,7 @@ export class Array implements ReadonlyArray, Iterable { public unshift(...values: T[]): number { let buffer = this.buffer if (this.buffer.length <= values.length + this.actualLength) { - buffer = new NullishType[this.buffer.length * 2 + values.length] + buffer = new Any[this.buffer.length * 2 + values.length] } for (let i = 0; i < this.actualLength; i++) { buffer[this.actualLength + values.length.toInt() - i - 1] = this.buffer[this.actualLength - 1 - i] @@ -1123,9 +1123,9 @@ export class Array implements ReadonlyArray, Iterable { % ctx.this_return_type = 'this' % ctx.clone_this = 'new Array(FROM_BUFFER, this.copyArray())' % ctx.make_buffer = Proc.new { |l, elt| -% "new NullishType[#{l}]" +% "new Any[#{l}]" % } -% ctx.make_fixed_array = 'FixedArray' +% ctx.make_fixed_array = 'FixedArray' % ctx.from_buffer = Proc.new { |b, elt| % elt ||= ctx.el_type % "new Array<#{elt}>(FROM_BUFFER, #{b})" diff --git a/static_core/plugins/ets/templates/stdlib/InteropTransferHelper.ets.j2 b/static_core/plugins/ets/templates/stdlib/InteropTransferHelper.ets.j2 index 5ba2fe9056..6f8e511dc3 100644 --- a/static_core/plugins/ets/templates/stdlib/InteropTransferHelper.ets.j2 +++ b/static_core/plugins/ets/templates/stdlib/InteropTransferHelper.ets.j2 @@ -26,7 +26,7 @@ export final class InteropTransferHelper { if (dynamicObject == null || dynamicObject == undefined) { throw new Error("dynamicObject is null or undefined"); } - let dynamicESValue = ESValue.wrap(__narrowAny(dynamicObject)); + let dynamicESValue = ESValue.wrap(dynamicObject as object); return InteropTransferHelper.transferArrayBufferToStaticImpl(dynamicESValue) as Object; } @@ -60,7 +60,7 @@ export final class InteropTransferHelper { throw new Error("dynamicObject is null or undefined"); } - let dynamicESValue = ESValue.wrap(__narrowAny(dynamicObject)); + let dynamicESValue = ESValue.wrap(dynamicObject as object); let dynamicBuffer = dynamicESValue.getProperty("buffer"); let byteOffset = dynamicESValue.getProperty("byteOffset").toNumber(); let length = dynamicESValue.getProperty("length").toNumber(); @@ -95,7 +95,7 @@ export final class InteropTransferHelper { throw new Error("dynamicObject is null or undefined"); } - let dynamicESValue = ESValue.wrap(__narrowAny(dynamicObject)); + let dynamicESValue = ESValue.wrap(dynamicObject as object); let dynamicBuffer = dynamicESValue.getProperty("buffer"); let byteOffset = dynamicESValue.getProperty("byteOffset").toNumber().toInt(); let byteLength = dynamicESValue.getProperty("byteLength").toNumber().toInt(); diff --git a/static_core/plugins/ets/tests/checked/escompat_array_from.ets b/static_core/plugins/ets/tests/checked/escompat_array_from.ets index b5883d5d25..ffb1bd0b2a 100644 --- a/static_core/plugins/ets/tests/checked/escompat_array_from.ets +++ b/static_core/plugins/ets/tests/checked/escompat_array_from.ets @@ -43,7 +43,7 @@ let smallFromUint8ClampedArray: Uint8ClampedArray = new Uint8ClampedArray(shortS let bigFromUint8ClampedArray: Uint8ClampedArray = new Uint8ClampedArray(longSize); class ArrayLikeImplTest implements ArrayLike { - private buffer: NullishType[] + private buffer: Any[] internal actualLength: int override $_get(index: number): T { @@ -60,14 +60,14 @@ class ArrayLikeImplTest implements ArrayLike { public push(val: T): number { this.ensureUnusedCapacity(1); - this.buffer[this.actualLength] = val as NullishType; + this.buffer[this.actualLength] = val as Any; this.actualLength += 1; return this.actualLength; } private ensureUnusedCapacity(cap: int): void { if (this.actualLength + cap > this.buffer.length) { - const copy = new NullishType[this.buffer.length * 2 + cap]; + const copy = new Any[this.buffer.length * 2 + cap]; for (let i = 0; i < this.actualLength; i++) { copy[i] = this.buffer[i]; } @@ -76,7 +76,7 @@ class ArrayLikeImplTest implements ArrayLike { } public constructor() { - this.buffer = new NullishType[4] + this.buffer = new Any[4] this.actualLength = 0 } } diff --git a/static_core/plugins/ets/tests/ets-common-tests/stubs/typeof.ets b/static_core/plugins/ets/tests/ets-common-tests/stubs/typeof.ets index 78adab6364..b80fc2c886 100644 --- a/static_core/plugins/ets/tests/ets-common-tests/stubs/typeof.ets +++ b/static_core/plugins/ets/tests/ets-common-tests/stubs/typeof.ets @@ -159,7 +159,7 @@ function testUnion() { } class A implements Function { - unsafeCall(...r: FixedArray): NullishType { return null } + unsafeCall(...r: FixedArray): Any { return null } get name() { return "A"; } diff --git a/static_core/plugins/ets/tests/ets-common-tests/taskpool/common_tasks.ets b/static_core/plugins/ets/tests/ets-common-tests/taskpool/common_tasks.ets index eb01f9688f..aeaa2d03a6 100644 --- a/static_core/plugins/ets/tests/ets-common-tests/taskpool/common_tasks.ets +++ b/static_core/plugins/ets/tests/ets-common-tests/taskpool/common_tasks.ets @@ -67,11 +67,11 @@ function delayWithYield(duration: int): void { Coroutine.Schedule(); } -function launchImpl(func: () => NullishType): Promise { - const job: Job = launch NullishType>( +function launchImpl(func: () => Any): Promise { + const job: Job = launch Any>( func ); - return new Promise((resolve, reject) => { + return new Promise((resolve, reject) => { try { let res = job.Await(); resolve(res); @@ -100,11 +100,11 @@ class Event { private resolveFn: ((val: boolean) => void) | null = null; } -function testDelayFunc(): NullishType { +function testDelayFunc(): Any { let task1 = new taskpool.Task(returnFailAbc); let res: string = ''; let isTask1Finished = new Event(); - taskpool.executeDelayed(100, task1).catch((e: NullishType) => { + taskpool.executeDelayed(100, task1).catch((e: Any) => { res = (e as Error).message; isTask1Finished.fire(); }) @@ -181,7 +181,7 @@ function verifySendDataRes(a:int):void{ verifyCount++; } -function verifySendDataResWithRestParameter(...args:FixedArray) { +function verifySendDataResWithRestParameter(...args:FixedArray) { let arg1 = args[0] as Array; let arg2 = args[1] as Array; arktest.assertEQ(arg1[0], 1); @@ -545,10 +545,10 @@ function cancelExecutingTaskTest() { let task2 = new taskpool.Task(testCancelFunc, 300); let val: int = 0; let isExecuted = new Event(); - taskpool.execute(task2).then((value: NullishType): void => { + taskpool.execute(task2).then((value: Any): void => { val = 1; isExecuted.fire(); - }).catch((e: NullishType): void => { + }).catch((e: Any): void => { val = 2; isExecuted.fire(); }); @@ -897,7 +897,7 @@ function tasksExecutionTest() { } let allExecuted = new Event(); for (let i: int = 0; i < count; ++i) { - taskpool.execute(taskArray[i]).then((value: NullishType): void => { + taskpool.execute(taskArray[i]).then((value: Any): void => { num++; if (num == count) { allExecuted.fire(); diff --git a/static_core/plugins/ets/tests/ets-common-tests/taskpool/group_tasks.ets b/static_core/plugins/ets/tests/ets-common-tests/taskpool/group_tasks.ets index 0bb093e2b7..51a5de13d6 100644 --- a/static_core/plugins/ets/tests/ets-common-tests/taskpool/group_tasks.ets +++ b/static_core/plugins/ets/tests/ets-common-tests/taskpool/group_tasks.ets @@ -35,11 +35,11 @@ function delayWithYield(duration: int): void { Coroutine.Schedule(); } -function launchImpl(func: () => NullishType): Promise { - const job: Job = launch NullishType>( +function launchImpl(func: () => Any): Promise { + const job: Job = launch Any>( func ); - return new Promise((resolve, reject) => { + return new Promise((resolve, reject) => { try { let res = job.Await(); resolve(res); @@ -49,7 +49,7 @@ function launchImpl(func: () => NullishType): Promise { }); } -function testDelayFunc(): NullishType { +function testDelayFunc(): Any { let task = new taskpool.Task(sum, 100, 300); let value = await taskpool.executeDelayed(100, task); let g = new taskpool.TaskGroup(); @@ -75,7 +75,7 @@ function executeDelayedTest(): void { }, new Error('taskpool:: groupTask cannot executeDelayed outside')); } -function testPeriodFunc(): NullishType { +function testPeriodFunc(): Any { let task = new taskpool.Task(sum, 100, 300); taskpool.executePeriodically(200, task); let isTaskCanceled: AtomicFlag = new AtomicFlag(false); diff --git a/static_core/plugins/ets/tests/ets-common-tests/taskpool/long_task.ets b/static_core/plugins/ets/tests/ets-common-tests/taskpool/long_task.ets index 6654bf06e0..9f8e2bba24 100644 --- a/static_core/plugins/ets/tests/ets-common-tests/taskpool/long_task.ets +++ b/static_core/plugins/ets/tests/ets-common-tests/taskpool/long_task.ets @@ -32,11 +32,11 @@ function delayWithYield(duration: int): void { Coroutine.Schedule(); } -function launchImpl(func: () => NullishType): Promise { - const job: Job = launch NullishType>( +function launchImpl(func: () => Any): Promise { + const job: Job = launch Any>( func ); - return new Promise((resolve, reject) => { + return new Promise((resolve, reject) => { try { let res = job.Await(); resolve(res); @@ -46,7 +46,7 @@ function launchImpl(func: () => NullishType): Promise { }); } -function testDelayFunc(): NullishType { +function testDelayFunc(): Any { let task = new taskpool.LongTask(sumFunc); let res = await taskpool.executeDelayed(10, task); arktest.expectError(() => { diff --git a/static_core/plugins/ets/tests/ets-common-tests/taskpool/seqrunner_tasks.ets b/static_core/plugins/ets/tests/ets-common-tests/taskpool/seqrunner_tasks.ets index 118e649ff4..b39bb0eee5 100644 --- a/static_core/plugins/ets/tests/ets-common-tests/taskpool/seqrunner_tasks.ets +++ b/static_core/plugins/ets/tests/ets-common-tests/taskpool/seqrunner_tasks.ets @@ -31,11 +31,11 @@ function delayWithYield(duration: int): void { Coroutine.Schedule(); } -function launchImpl(func: () => NullishType): Promise { - const job: Job = launch NullishType>( +function launchImpl(func: () => Any): Promise { + const job: Job = launch Any>( func ); - return new Promise((resolve, reject) => { + return new Promise((resolve, reject) => { try { let res = job.Await(); resolve(res); @@ -45,7 +45,7 @@ function launchImpl(func: () => NullishType): Promise { }); } -function testDelayFunc(): NullishType { +function testDelayFunc(): Any { let task = new taskpool.Task(max, 80, 90); let res = await taskpool.executeDelayed(50, task); let runner = new taskpool.SequenceRunner(); @@ -91,7 +91,7 @@ function executePeriodicallyTest(): void { CoroutineExtras.setSchedulingPolicy(CoroutineExtras.POLICY_ANY); } -function testPeriodFunc(): NullishType { +function testPeriodFunc(): Any { let task = new taskpool.Task(sum, 80, 90); taskpool.executePeriodically(200, task); let isTaskCanceled: AtomicFlag = new AtomicFlag(false); diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/ArrayProxyTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/ArrayProxyTest.ets index b4608a1926..5d916e36ec 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/escompat/ArrayProxyTest.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/ArrayProxyTest.ets @@ -40,11 +40,11 @@ class StringArrayProxyHandler extends proxy.DefaultArrayProxyHandler { return super.set(target, index, value) } - override get(target: Array, name: string): NullishType { + override get(target: Array, name: string): Any { return super.get(target, name) } - override set(target: Array, name: string, value: NullishType): boolean { + override set(target: Array, name: string, value: Any): boolean { if (name == "length") { this.setLengthTrapped = true // ignore set new length request @@ -54,7 +54,7 @@ class StringArrayProxyHandler extends proxy.DefaultArrayProxyHandler { return super.set(target, name, value) } - override invoke(target: Array, method: Method, args: FixedArray): NullishType { + override invoke(target: Array, method: Method, args: FixedArray): Any { const methodName = method.getName() if (methodName == "pop") { this.popTrapped = true diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/ArrayTest_disabled.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/ArrayTest_disabled.ets index f66572dfcb..d4dcaee3f8 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/escompat/ArrayTest_disabled.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/ArrayTest_disabled.ets @@ -171,7 +171,7 @@ function everyFuncArg3ReadonlyArray(): int { // NOTE (ikorobkov): uncomment when Array will have implementation of from(arr: ArrayLike|Iterable, fn: (v: T, k: number) => U) // // class ArrayLikeImplTest implements ArrayLike { -// private buffer: NullishType[] +// private buffer: Any[] // internal actualLength: int // // public at(index: number): T | undefined { @@ -201,14 +201,14 @@ function everyFuncArg3ReadonlyArray(): int { // // public push(val: T): number { // this.ensureUnusedCapacity(1); -// this.buffer[this.actualLength] = val as NullishType; +// this.buffer[this.actualLength] = val as Any; // this.actualLength += 1; // return this.actualLength; // } // // private ensureUnusedCapacity(cap: int): void { // if (this.actualLength + cap > this.buffer.length) { -// const copy = new NullishType[this.buffer.length * 2 + cap]; +// const copy = new Any[this.buffer.length * 2 + cap]; // for (let i = 0; i < this.actualLength; i++) { // copy[i] = this.buffer[i]; // } @@ -217,7 +217,7 @@ function everyFuncArg3ReadonlyArray(): int { // } // // public constructor() { -// this.buffer = new NullishType[4] +// this.buffer = new Any[4] // this.actualLength = 0 // } // } diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonAnnotationTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonAnnotationTest.ets index dc15622db7..b80ccbbdbb 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonAnnotationTest.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonAnnotationTest.ets @@ -119,11 +119,11 @@ class TestClass14 extends TestClass13 { class TestClass15 { @JSONRename("record15") - record: Record = new Record() + record: Record = new Record() @JSONRename("map15") map: Map = new Map() @JSONRename("nestedRecord15") - nestedRecord: Record = new Record() + nestedRecord: Record = new Record() @JSONStringifyIgnore i8Array: Int8Array = Int8Array.of(INT8_MAX, INT8_MIN, 100, INT8_MIN + 1) @JSONRename("fixArray15") @@ -247,7 +247,7 @@ function jsonTestWithTypes() { obj.record["version"] = 1 obj.map.set("key1", "value1") obj.nestedRecord = { "name": "arkts", "version": 1} - const nest: Record = { "desc": "nested" } + const nest: Record = { "desc": "nested" } obj.nestedRecord["nested"] = nest let json = JSON.stringify(obj) const targetOutput = '{"record15":{"name":"arkts","version":1},"map15":{},' + diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonParseTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonParseTest.ets index 2bb6617b86..9e5230d2b1 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonParseTest.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonParseTest.ets @@ -48,16 +48,16 @@ class Trash { } } -function newUndefiningReviver(...keys: FixedArray): (k: string, v: NullishType) => NullishType { - return (key: string, val: NullishType) => Array.from(keys).indexOf(key) != -1 ? undefined : val +function newUndefiningReviver(...keys: FixedArray): (k: string, v: Any) => Any { + return (key: string, val: Any) => Array.from(keys).indexOf(key) != -1 ? undefined : val } -function newNullingReviver(...keys: FixedArray): (k: string, v: NullishType) => NullishType { - return (key: string, val: NullishType) => Array.from(keys).indexOf(key) != -1 ? null : val +function newNullingReviver(...keys: FixedArray): (k: string, v: Any) => Any { + return (key: string, val: Any) => Array.from(keys).indexOf(key) != -1 ? null : val } -function newReplacingReviver(replacements: Map): (k: string, v: NullishType) => NullishType { - return (key: string, val: NullishType) => { +function newReplacingReviver(replacements: Map): (k: string, v: Any) => Any { + return (key: string, val: Any) => { if (replacements.has(key)) { return replacements.get(key) } @@ -66,7 +66,7 @@ function newReplacingReviver(replacements: Map): (k: string } } -function replacingReviver(key: string, val: NullishType): NullishType { +function replacingReviver(key: string, val: Any): Any { if (key == "x") { return 10.0 } else { @@ -83,7 +83,7 @@ function jsonParseUsingUndefinedReviver(): int { arktest.assertEQ(point.x, parsedPoint.x) arktest.assertEQ(point.y, parsedPoint.y) - + return RESULT_SUCCESS } @@ -109,7 +109,7 @@ function jsonParseArrayUsingReviverWhichReturnsUndefined(): int { function jsonParseUsingReplacingReviver(): int { const NEW_X = 10.0 - const replacements = new Map() + const replacements = new Map() replacements.set("x", NEW_X) const point = new Point(3, 4) @@ -139,7 +139,7 @@ function jsonParseUsingReplacingReviver(): int { function jsonParseArrayWithReplacingReviver(): int { const romans: FixedArray> = ["I", "II"] - const replacements = new Map() + const replacements = new Map() const replacedRomans: FixedArray> = ["I"] replacements.set("", replacedRomans) @@ -152,7 +152,7 @@ function jsonParseArrayWithReplacingReviver(): int { enum Color { Black = 0, - Red = 1, + Red = 1, Green = 2 } diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonReplacerTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonReplacerTest.ets index f092cbb4ab..d004f2e01b 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonReplacerTest.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonReplacerTest.ets @@ -12,11 +12,11 @@ * limitations under the License. */ -function dummyReplacer(key: string, value: NullishType): NullishType { +function dummyReplacer(key: string, value: Any): Any { return value } -function toStringReplacer(key: string, value: NullishType): NullishType { +function toStringReplacer(key: string, value: Any): Any { if (key == "") { return value } @@ -24,7 +24,7 @@ function toStringReplacer(key: string, value: NullishType): NullishType { return "" + value } -function toFnReplacer(key: string, value: NullishType): NullishType { +function toFnReplacer(key: string, value: Any): Any { return key == "id" ? () => {} : value } @@ -71,10 +71,10 @@ class O implements JsonReplacer { this.buffer.push(val) } - jsonReplacer(): Record { + jsonReplacer(): Record { const buf = this.buffer const len = buf.length - let arrayObj: Record = {} + let arrayObj: Record = {} for (let i = 0; i < len; i++) { arrayObj[String(i)] = buf[i] } @@ -106,13 +106,13 @@ function jsonStringifyObjectWithFunctionReplacer(): void { } function jsonStringifyRecordWithFunctionReplacer(): void { - const record: Record = { "id": 1, "name": "R" } + const record: Record = { "id": 1, "name": "R" } arktest.assertEQ(JSON.stringify(record, dummyReplacer), `{"id":1,"name":"R"}`) arktest.assertEQ(JSON.stringify(record, toFnReplacer), `{"name":"R"}`) } function jsonStringifyArrayWithFunctionReplacer(): void { - const replacer = (key: string, value: NullishType): NullishType => { + const replacer = (key: string, value: Any): Any => { if (key == "" || key == "0") { return value } else { @@ -134,7 +134,7 @@ function jsonStringifyArrayWithFunctionReplacer(): void { arktest.assertEQ(JSON.stringify(ar, toStringReplacer, 1), '[\n "A(1)",\n "A(1)"\n]') arktest.assertEQ(JSON.stringify(ar, replacer), '[{},null]') - const reverser = (key: string, value: NullishType): NullishType => + const reverser = (key: string, value: Any): Any => Array.isArray(value) ? Array.from(value as FixedArray).reverse() : value arktest.assertEQ(JSON.stringify([new A(1), new A(2)] as FixedArray, reverser), '[{"id":2,"name":"A"},{"id":1,"name":"A"}]') @@ -149,7 +149,7 @@ function jsonStringifyArrayWithFunctionReplacer(): void { const EMPTY_ARRAY: FixedArray = [] function jsonStringifyWithArrayReplacer(): void { - const rec: Record = { 'id': 1, 'name': 'R' } + const rec: Record = { 'id': 1, 'name': 'R' } arktest.assertEQ(JSON.stringify(new A(), EMPTY_ARRAY), '{}') arktest.assertEQ(JSON.stringify(rec, EMPTY_ARRAY), '{}') arktest.assertEQ(JSON.stringify(new A(), ['id']), '{"id":1}') @@ -174,16 +174,16 @@ function jsonStringifyWithArrayReplacer(): void { function jsonStringifyWithNullReplacer(): void { arktest.assertEQ(JSON.stringify(new A(), null), '{"id":1,"name":"A"}') - const rec: Record = { 'id': 1, 'name': 'R' } + const rec: Record = { 'id': 1, 'name': 'R' } arktest.assertEQ(JSON.stringify(rec, null), '{"id":1,"name":"R"}') arktest.assertEQ(JSON.stringify(new E(), null, ' '), '{}') - const emptyRec: Record = {} + const emptyRec: Record = {} arktest.assertEQ(JSON.stringify(emptyRec, null, ' '), '{}') } function jsonStringifyWithUndefinedReplacer(): void { arktest.assertEQ(JSON.stringify(new A(), undefined), '{"id":1,"name":"A"}') - const rec: Record = { 'id': 1, 'name': 'R' } + const rec: Record = { 'id': 1, 'name': 'R' } arktest.assertEQ(JSON.stringify(rec, undefined), '{"id":1,"name":"R"}') } diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonStringifyArrayTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonStringifyArrayTest.ets index 96fca914e5..f496691b28 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonStringifyArrayTest.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonStringifyArrayTest.ets @@ -120,7 +120,7 @@ function jsonStringifyArrayReplacer3() { arktest.assertEQ(ret, expect); } -function replaceNumber(key: string, value: NullishType): NullishType { +function replaceNumber(key: string, value: Any): Any { if (key == '1' || key == '4') { return key + '_' + value; } else { diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonStringifyTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonStringifyTest.ets index ef72e984d6..74c1810668 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonStringifyTest.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonStringifyTest.ets @@ -117,7 +117,7 @@ function jsonStringifyMapWithEntries(): void { } function jsonStringifyRecord(): void { - let record: Record = {} + let record: Record = {} record["name"] = "arkts"; record["version"] = 1; @@ -134,13 +134,13 @@ function jsonStringifyRecord(): void { } function jsonStringifyRecordWithSpace(): void { - const rec: Record = { 'name': 'Rec', 'version': 2 } + const rec: Record = { 'name': 'Rec', 'version': 2 } const recJson = JSON.stringify(rec, undefined, ' ') arktest.assertEQ(recJson, '{\n "name": "Rec",\n "version": 2\n}') } function jsonStringifyRecordWithUndefinedValue(): void { - let record: Record = new Record(); + let record: Record = new Record(); record["name"] = "arkts"; record["version"] = 1.0; record["ignore"] = undefined; @@ -155,17 +155,17 @@ function jsonStringifyRecordWithUndefinedValue(): void { } function jsonStringifyRecordWithUndefinedValueWithSpace(): void { - const record: Record = { 'name': 'arkts', 'version': 1, 'ignore': undefined } + const record: Record = { 'name': 'arkts', 'version': 1, 'ignore': undefined } const recordJson = JSON.stringify(record, undefined, ' ') arktest.assertEQ(recordJson, '{\n "name": "arkts",\n "version": 1\n}') } function jsonStringifyNestedRecord(): void { - let record: Record = new Record(); + let record: Record = new Record(); record["name"] = "arkts"; record["version"] = 1.0; - const nestedRecord: Record = new Record(); + const nestedRecord: Record = new Record(); nestedRecord["inner"] = record; nestedRecord["desc"] = new String("nested"); @@ -182,8 +182,8 @@ function jsonStringifyNestedRecord(): void { } function jsonStringifyNestedRecordWithSpace(): void { - const record: Record = { 'name': 'arkts', 'version': 1} - const nestedRecord: Record = { 'desc': 'nested' } + const record: Record = { 'name': 'arkts', 'version': 1} + const nestedRecord: Record = { 'desc': 'nested' } record['nested'] = nestedRecord const recordJson = JSON.stringify(record, undefined, ' ') @@ -191,7 +191,7 @@ function jsonStringifyNestedRecordWithSpace(): void { } function jsonStringifyRecordWithClassInstance(): void { - let record: Record = new Record(); + let record: Record = new Record(); record["TestClass"] = new TestClass('Test'); let jsonStr = JSON.stringify(record); @@ -206,13 +206,13 @@ function jsonStringifyRecordWithClassInstance(): void { function jsonStringifyRecordWithClassInstanceWithSpace(): void { // CC-OFFNXT(G.NAM.03) implementation feature - const record: Record = { 'TestClass': new TestClass('Test') } + const record: Record = { 'TestClass': new TestClass('Test') } const recordJson = JSON.stringify(record, undefined, ' ') arktest.assertEQ(recordJson, '{\n "TestClass": {\n "value": "Test"\n }\n}') } function jsonStringifyRecordWithArray(): void { - let record: Record = new Record(); + let record: Record = new Record(); record['list'] = new Array(1, 2, 3); let jsonStr = JSON.stringify(record); @@ -229,12 +229,12 @@ function jsonStringifyRecordWithArray(): void { } function jsonStringifyRecordWithArrayWithSpace(): void { - const record: Record = { 'list': [1, 2, 3] } + const record: Record = { 'list': [1, 2, 3] } arktest.assertEQ(JSON.stringify(record, undefined, ' '), '{\n "list": [\n 1,\n 2,\n 3\n ]\n}') } function jsonStringifyRecordWithNull(): void { - let record: Record = new Record(); + let record: Record = new Record(); record['nullable'] = null; let jsonStr = JSON.stringify(record); @@ -246,7 +246,7 @@ function jsonStringifyRecordWithNull(): void { } function jsonStringifyRecordWithNullWithSpace(): void { - const record: Record = { 'nullable': null } + const record: Record = { 'nullable': null } arktest.assertEQ(JSON.stringify(record, undefined, ' '), '{\n "nullable": null\n}') } @@ -273,7 +273,7 @@ function jsonStringifyRecordWithSameValue(): void { function jsonStringifyNestedMap(): void { const map = new Map(); - let record: Record = new Record(); + let record: Record = new Record(); record["name"] = "arkts"; map.set("nested", record); @@ -281,7 +281,7 @@ function jsonStringifyNestedMap(): void { } function jsonStringifyCyclicRecord(): void { - const cycleRecord = new Record(); + const cycleRecord = new Record(); cycleRecord["self"] = cycleRecord; try { JSON.stringify(cycleRecord); diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonTest.ets index 0fc952ba52..eb1962869d 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonTest.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/JsonTest.ets @@ -287,9 +287,9 @@ function testStringifyObjectOfDerivedClass(): int { class TestNode { value: string - next: NullishType + next: Any - constructor(value: string, next: NullishType = null) { + constructor(value: string, next: Any = null) { this.value = value this.next = next } diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/ObjectLiteralTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/ObjectLiteralTest.ets index e9cf336e8a..8e5f2fb5ca 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/escompat/ObjectLiteralTest.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/ObjectLiteralTest.ets @@ -37,7 +37,7 @@ function testObjectAssignKeys(): void { } } -function objEntriesComparator(l: [String, NullishType], r: [String, NullishType]): number { +function objEntriesComparator(l: [String, Any], r: [String, Any]): number { const lname = l[0] const rname = r[0] diff --git a/static_core/plugins/ets/tests/ets_func_tests/escompat/ProxyTest.ets b/static_core/plugins/ets/tests/ets_func_tests/escompat/ProxyTest.ets index e9462b4f55..f810bd4669 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/escompat/ProxyTest.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/escompat/ProxyTest.ets @@ -54,7 +54,7 @@ class ObjProxyHandler extends proxy.DefaultProxyHandler { setTrapped: boolean = false getIdTrapped: boolean = false - get(target: ObjWithProps, name: string): NullishType { + get(target: ObjWithProps, name: string): Any { this.getTrapped = true const value = super.get(target, name) @@ -65,12 +65,12 @@ class ObjProxyHandler extends proxy.DefaultProxyHandler { } } - set(target: ObjWithProps, name: string, value: NullishType): boolean { + set(target: ObjWithProps, name: string, value: Any): boolean { this.setTrapped = true return super.set(target, name, value) } - invoke(target: ObjWithProps, method: Method, args: FixedArray): NullishType { + invoke(target: ObjWithProps, method: Method, args: FixedArray): Any { const methodName = method.getName() if (methodName == "isNameSet") { return false @@ -95,12 +95,12 @@ interface ProxyTest { } class interfaceProxyHandler implements proxy.ProxyHandler{ - public get(target:T, name:string):NullishType { + public get(target:T, name:string):Any { const value = Reflect.get(target, name) as Any return value } - public set(target:T, name:string, newValue:NullishType):boolean { + public set(target:T, name:string, newValue:Any):boolean { if (Reflect.get(target, name) !== newValue) { const result = Reflect.set(target, name, newValue) return result @@ -108,7 +108,7 @@ class interfaceProxyHandler implements proxy.ProxyHandler{ return true } - public invoke(target:T, method:Method, args:FixedArray):NullishType { + public invoke(target:T, method:Method, args:FixedArray):Any { return method.invoke(target, args) } } diff --git a/static_core/plugins/ets/tests/ets_func_tests/spec/10.Interfaces/method_overiding_0001.ets b/static_core/plugins/ets/tests/ets_func_tests/spec/10.Interfaces/method_overiding_0001.ets index faeb404e53..5f378883db 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/spec/10.Interfaces/method_overiding_0001.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/spec/10.Interfaces/method_overiding_0001.ets @@ -18,9 +18,9 @@ desc: 10.6.2 Inheritance and Overriding tags: [compile-only] ---*/ -type EntryType = [PropertyKey, NullishType] +type EntryType = [PropertyKey, Any] type __Record = Map -type RecordForObject = Map +type RecordForObject = Map interface I { keys(o: Object): string[] @@ -28,7 +28,7 @@ interface I { getOwnPropertyNames(o: Object): string[] hasOwn(target: Object, key: string): boolean hasOwn(target: Object, index: number): boolean - values__(o: Object): NullishType[] + values__(o: Object): Any[] fromEntries(entries: Map): __Record assign(target: RecordForObject, ...source: Object[]): RecordForObject } diff --git a/static_core/plugins/ets/tests/ets_func_tests/std/containers/BlockingQueue/AddAndPollStress.ets b/static_core/plugins/ets/tests/ets_func_tests/std/containers/BlockingQueue/AddAndPollStress.ets index 2e832a2262..e2349023f8 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/std/containers/BlockingQueue/AddAndPollStress.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/std/containers/BlockingQueue/AddAndPollStress.ets @@ -42,7 +42,7 @@ function addAndPoll() { // Test body let addAndPollStressTest = (testBQ: containers.BlockingQueue) => { - let arrPromise = new Array>(20) + let arrPromise = new Array>(20) for (let i = 0; i < 10; i++) { arrPromise[i] = taskpool.execute(addSome, testBQ, i * 1000) } diff --git a/static_core/plugins/ets/tests/ets_func_tests/std/core/ConsoleDirTest.ets b/static_core/plugins/ets/tests/ets_func_tests/std/core/ConsoleDirTest.ets index 038294d174..4081ac540a 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/std/core/ConsoleDirTest.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/std/core/ConsoleDirTest.ets @@ -94,7 +94,7 @@ function main() { console.dir(calculator); // Array with mixed types - const mixedArray: NullishType[] = [ + const mixedArray: Any[] = [ 1, "string", [1, 2, 3], diff --git a/static_core/plugins/ets/tests/ets_func_tests/std/core/ConsoleTableTest.ets b/static_core/plugins/ets/tests/ets_func_tests/std/core/ConsoleTableTest.ets index 28c63ab519..4718d8ade7 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/std/core/ConsoleTableTest.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/std/core/ConsoleTableTest.ets @@ -88,7 +88,7 @@ class NestedData { // Data display utility class class DataDisplay { static displayUsers(): void { - const users : Array = [ + const users : Array = [ new User(1, "John", 30), new User(2, "Alice", 25), new User(3, "Bob", 35) @@ -102,11 +102,11 @@ class DataDisplay { ["A2", "B2", "C2"], ["A3", "B3", "C3"] ]; - console.table(matrix as Object as Array); + console.table(matrix as Object as Array); } static displayProducts(): void { - const products : Array = [ + const products : Array = [ new Product(1, "Phone", 699, 50), new Product(2, "Laptop", 999, 30), new Product(3, "Tablet", 399, 75) @@ -115,7 +115,7 @@ class DataDisplay { } static displayMixedData(): void { - const mixedData : Array = [ + const mixedData : Array = [ new MixedData(1, "string"), new MixedData(2, 42), new MixedData(3, true) diff --git a/static_core/plugins/ets/tests/ets_func_tests/std/core/Object.ets b/static_core/plugins/ets/tests/ets_func_tests/std/core/Object.ets index 2dbc13e702..75c7fca7e2 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/std/core/Object.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/std/core/Object.ets @@ -39,7 +39,7 @@ function main(): int { return test(failures, "All tests run"); } -type TupleT = [string, NullishType] +type TupleT = [string, Any] type NullishTuple = TupleT | null | undefined class Point2D { @@ -74,7 +74,7 @@ function strArraysAreEqual(a: string[], b: string[]): boolean { return true } -function objArraysAreEqual(a: NullishType[], b: NullishType[]): boolean { +function objArraysAreEqual(a: Any[], b: Any[]): boolean { let alen = a.length if (alen != b.length) { return false @@ -100,13 +100,13 @@ function tupleAreEqual(a: NullishTuple[], b: NullishTuple[]): boolean { return true } -function mapAreEqual(a: Map, b: Map): boolean { +function mapAreEqual(a: Map, b: Map): boolean { let alen = a.size if (alen != b.size) { return false } let areEqual: boolean = true - a.forEach((av: NullishType, k: PropertyKey) => { + a.forEach((av: Any, k: PropertyKey) => { const bv = b.get(k) if (bv == undefined || !__runtimeEquals(av, bv)) { areEqual = false @@ -186,7 +186,7 @@ function objectValues(): int { return a + 1 } - let emptyArr: NullishType[] = [] + let emptyArr: Any[] = [] result += objArraysAreEqual(Object.values(c), emptyArr) ? 0 : 1 result += objArraysAreEqual(Object.values(bo), emptyArr) ? 0 : 1 @@ -197,13 +197,13 @@ function objectValues(): int { result += objArraysAreEqual(Object.values(fl), emptyArr) ? 0 : 1 result += objArraysAreEqual(Object.values(dou), emptyArr) ? 0 : 1 - let arrVal: NullishType[] = [new Number(10), new Number(20), new Number(30)] + let arrVal: Any[] = [new Number(10), new Number(20), new Number(30)] result += objArraysAreEqual(Object.values(arr), arrVal) ? 0 : 1 - let strVal: NullishType[] = ["a" as string, "b" as string, "c" as string] + let strVal: Any[] = ["a" as string, "b" as string, "c" as string] result += objArraysAreEqual(Object.values(str), strVal) ? 0 : 1 - let clVal: NullishType[] = [new Number(10), new Number(20), undefined] + let clVal: Any[] = [new Number(10), new Number(20), undefined] result += objArraysAreEqual(Object.values(cl), clVal) ? 0 : 1 result += objArraysAreEqual(Object.values(lambda), emptyArr) ? 0 : 1 @@ -366,7 +366,7 @@ function objectHasOwn(): int { return result } -type Rec = Record +type Rec = Record function objectFromEntries(): int { let result: int = 0 @@ -383,15 +383,15 @@ function objectFromEntries(): int { "z": new Number(30) } - result += mapAreEqual(Object.fromEntries(entries), expected) ? 0 : 1 + result += mapAreEqual(Object.fromEntries(entries), expected) ? 0 : 1 - const entriesIterable: Iterable<[PropertyKey, NullishType]> = entries - result += mapAreEqual(Object.fromEntries(entriesIterable), expected) ? 0 : 1 + const entriesIterable: Iterable<[PropertyKey, Any]> = entries + result += mapAreEqual(Object.fromEntries(entriesIterable), expected) ? 0 : 1 const emptyObj: Rec = {} - const emptyEntries = new Array<[PropertyKey, NullishType]>() - result += mapAreEqual(Object.fromEntries(emptyEntries), emptyObj) ? 0 : 1 + const emptyEntries = new Array<[PropertyKey, Any]>() + result += mapAreEqual(Object.fromEntries(emptyEntries), emptyObj) ? 0 : 1 return result } diff --git a/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeClassTypeTest.ets b/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeClassTypeTest.ets index a1ef2f6e76..38970c3ee0 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeClassTypeTest.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeClassTypeTest.ets @@ -306,9 +306,9 @@ function testMake(): int { let pt = Type.of(new Point()) as ClassType let wt = Type.of(new HTMLWriter(0)) as ClassType let p3t = Type.of(new Point3D(10)) as ClassType - let point = pt.make([new Double(1.0), new Double(2.0)] as FixedArray) as Point - let point3D = p3t.make([new Double(1.0), new Double(2.0), new Double(3.0)] as FixedArray) as Point3D - let writer = wt.make([new Int(10)] as FixedArray) as HTMLWriter + let point = pt.make([new Double(1.0), new Double(2.0)] as FixedArray) as Point + let point3D = p3t.make([new Double(1.0), new Double(2.0), new Double(3.0)] as FixedArray) as Point3D + let writer = wt.make([new Int(10)] as FixedArray) as HTMLWriter failures += test(point.serialize() == "{1,2}", "Point") failures += test(point3D.serialize() == "{1,2}" && point3D.z == 3, "Point3D") failures += test(writer.getState() == 10, "HTMLWriter" ) diff --git a/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeCreateErasedBodyTest.ets b/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeCreateErasedBodyTest.ets index 817842d538..6ea2d69a31 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeCreateErasedBodyTest.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeCreateErasedBodyTest.ets @@ -25,12 +25,12 @@ class C { } -function erasedM(recv: NullishType, args: FixedArray): NullishType { +function erasedM(recv: Any, args: FixedArray): Any { arktest.assertEQ( args.length, 1) return (args[0]?.toString()) + "123" + (recv as C).dat } -function erased(recv: NullishType, args: FixedArray): NullishType { +function erased(recv: Any, args: FixedArray): Any { arktest.assertEQ( args.length, 3) const a1: int = args[0] as int const a2: long = args[1] as long diff --git a/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodInvoke.ets b/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodInvoke.ets index c86166670b..c9cec0f6ba 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodInvoke.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodInvoke.ets @@ -26,7 +26,7 @@ class C { } function testSum(sum: Method): void { - const args : FixedArray = new NullishType[2] + const args : FixedArray = new Any[2] args[0] = Int.MAX_VALUE args[1] = 30 const res = sum.invoke(null, args) @@ -36,7 +36,7 @@ function testSum(sum: Method): void { function testGetIsEvenPlusX(getIsEvenPlusX: Method): void { const c = new C() c.a = 15 - const args : FixedArray = new NullishType[1] + const args : FixedArray = new Any[1] args[0] = 13 arktest.assertEQ( getIsEvenPlusX.invoke(c, args), true) diff --git a/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodInvokeConstructor.ets b/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodInvokeConstructor.ets index 8e631670b6..84b2c4c301 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodInvokeConstructor.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodInvokeConstructor.ets @@ -26,7 +26,7 @@ function main(): void { const cType = Type.of(c) as ClassType arktest.assertEQ( cType.getConstructorsNum(), 1) const m = cType.getConstructor(0) - const args : FixedArray = new NullishType[1]; + const args : FixedArray = new Any[1]; args[0] = 10 let res = m.invoke(null, args) as C arktest.assertEQ( res.a, 10) diff --git a/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodInvokeVirt.ets b/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodInvokeVirt.ets index 44ef16d6cd..35d5cd15bf 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodInvokeVirt.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodInvokeVirt.ets @@ -32,7 +32,7 @@ function main(): void { continue } got++ - arktest.assertEQ( m.invoke(new C(), new NullishType[0]) as Int, 30) + arktest.assertEQ( m.invoke(new C(), new Any[0]) as Int, 30) } arktest.assertEQ( got, 1) } diff --git a/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodResolveConstructor.ets b/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodResolveConstructor.ets index 57cf541796..b63eb74066 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodResolveConstructor.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodResolveConstructor.ets @@ -44,7 +44,7 @@ class C { } } -function test(args: FixedArray, exp: int): int { +function test(args: FixedArray, exp: int): int { called = -1 CType.make(args) if (called != exp) { @@ -57,24 +57,24 @@ function test(args: FixedArray, exp: int): int { return 0 } -function mk(num: int, fn: (idx: int) => NullishType): FixedArray { - const arr : FixedArray = new NullishType[num] +function mk(num: int, fn: (idx: int) => Any): FixedArray { + const arr : FixedArray = new Any[num] for (let i = 0; i < num; i++) { arr[i] = fn(i) } return arr; } -function from(x: NullishType): FixedArray { - const ret :FixedArray = new NullishType[1] +function from(x: Any): FixedArray { + const ret :FixedArray = new Any[1] ret[0] = x return ret } function main(): int { let f = 0 - f += test(new NullishType[0], 0) - f += test(mk(2, (idx: int): NullishType => { return idx as Int }), 2) + f += test(new Any[0], 0) + f += test(mk(2, (idx: int): Any => { return idx as Int }), 2) f += test(from(new B()), 12) f += test(from(new D()), 11) diff --git a/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodResolveConstructorFew.ets b/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodResolveConstructorFew.ets index 9d11768123..d7474732f4 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodResolveConstructorFew.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/std/core/TypeMethodResolveConstructorFew.ets @@ -35,7 +35,7 @@ class Test { } } -function test(args: FixedArray, exp: int): int { +function test(args: FixedArray, exp: int): int { called = -1 try { TestType.make(args) @@ -53,8 +53,8 @@ function test(args: FixedArray, exp: int): int { return 0 } -function from(x: NullishType): FixedArray { - const ret : FixedArray = new NullishType[1] +function from(x: Any): FixedArray { + const ret : FixedArray = new Any[1] ret[0] = x return ret } diff --git a/static_core/plugins/ets/tests/ets_func_tests/std/core/dateformat/DateTimeFormatTest.ets b/static_core/plugins/ets/tests/ets_func_tests/std/core/dateformat/DateTimeFormatTest.ets index 1a7772c8db..3e0792b1cd 100644 --- a/static_core/plugins/ets/tests/ets_func_tests/std/core/dateformat/DateTimeFormatTest.ets +++ b/static_core/plugins/ets/tests/ets_func_tests/std/core/dateformat/DateTimeFormatTest.ets @@ -94,7 +94,7 @@ function testConsoleLogNegativeDate() { let d = new Date(-271822) const MAX_CONSOLE_PRINT_DEPTH: int = 10 // console.log stub - let res = reflect.Value.of(d as NullishType).toPrint(MAX_CONSOLE_PRINT_DEPTH) + let res = reflect.Value.of(d as Any).toPrint(MAX_CONSOLE_PRINT_DEPTH) arktest.assertEQ(res, "Date: \"1969-12-31T23:55:28.178Z\"") } diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/json/Parse.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/json/Parse.ets index 48a31fba87..cf67ff1951 100644 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/json/Parse.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/json/Parse.ets @@ -61,7 +61,7 @@ function testStringifyParseOptZero(): void { function testStringifyParseBigIntWithReviver(): void { let classType = Type.of(new SuperUser() as Object) - let reviver = (k: string, v: NullishType) => { + let reviver = (k: string, v: Any) => { if (k === "id") { return new BigInt(1) } diff --git a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/json/Stringify.ets b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/json/Stringify.ets index b38e08e602..704144f1ad 100644 --- a/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/json/Stringify.ets +++ b/static_core/plugins/ets/tests/ets_sdk/api/@ohos/util/json/Stringify.ets @@ -50,7 +50,7 @@ function testStringifyObjWithArrayReplacer() { } function testStringifyObjWithFuncReplacer() { - let f = (k: string, value: NullishType): NullishType => { + let f = (k: string, value: Any): Any => { if (k === "a") { return 77777 } else if (k === "not existing") { diff --git a/static_core/plugins/ets/tests/ets_test_suite/coroutines/allhandled_rejection.ets b/static_core/plugins/ets/tests/ets_test_suite/coroutines/allhandled_rejection.ets index fa03d32140..208ccead67 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/coroutines/allhandled_rejection.ets +++ b/static_core/plugins/ets/tests/ets_test_suite/coroutines/allhandled_rejection.ets @@ -55,7 +55,7 @@ function testAllhandledRejection(): void { } catch(e) { } - AsyncFailing().catch((e: NullishType) => {}); + AsyncFailing().catch((e: Any) => {}); let p = Promise.reject(new Error('promise1')); let q = p.then(() => { @@ -63,7 +63,7 @@ function testAllhandledRejection(): void { let procManager = new StdProcess.ProcessManager(); procManager.exit(1); }); - q.catch((e: NullishType) => {}); + q.catch((e: Any) => {}); let f = async (): Promise => { try { diff --git a/static_core/plugins/ets/tests/interop_js/tests/constructor/ts_to_sts/constructor.ets b/static_core/plugins/ets/tests/interop_js/tests/constructor/ts_to_sts/constructor.ets index 827f86c043..fc5f7c6334 100644 --- a/static_core/plugins/ets/tests/interop_js/tests/constructor/ts_to_sts/constructor.ets +++ b/static_core/plugins/ets/tests/interop_js/tests/constructor/ts_to_sts/constructor.ets @@ -133,7 +133,7 @@ function checkIIFEConstructor(): boolean { function checkIIFEConstructorUndefined(): boolean { const TSClass = IIFEConstructor(tsInt); - return TSClass as NullishType == undefined; + return TSClass as Any == undefined; } function checkCreateIIFEConstructorFromTs(): boolean { diff --git a/static_core/plugins/ets/tests/interop_js/tests/dot_operator/ts_to_sts/not_nullish_operator/not_nullish_operator.ets b/static_core/plugins/ets/tests/interop_js/tests/dot_operator/ts_to_sts/not_nullish_operator/not_nullish_operator.ets index 2676e5077e..5b0c07295f 100644 --- a/static_core/plugins/ets/tests/interop_js/tests/dot_operator/ts_to_sts/not_nullish_operator/not_nullish_operator.ets +++ b/static_core/plugins/ets/tests/interop_js/tests/dot_operator/ts_to_sts/not_nullish_operator/not_nullish_operator.ets @@ -21,7 +21,7 @@ import { class PublicGetterClass { _value = tsString; - test: null | undefined//NullishType + test: null | undefined//Any get value(): string { return this._value; } diff --git a/static_core/plugins/ets/tests/interop_js/tests/promise/promise_tests.ets b/static_core/plugins/ets/tests/interop_js/tests/promise/promise_tests.ets index 54c025f8fd..22bbdc25f8 100644 --- a/static_core/plugins/ets/tests/interop_js/tests/promise/promise_tests.ets +++ b/static_core/plugins/ets/tests/interop_js/tests/promise/promise_tests.ets @@ -100,7 +100,7 @@ function testPendingPromise(): int { p.then((): void => { globalTest!.fail(); }); - p.catch((error: NullishType): void => { + p.catch((error: Any): void => { globalTest!.fail(); }); // Check callback are not called inside 'then' and 'catch' @@ -122,7 +122,7 @@ function testResolvedPromise(): int { } return null; }); - p.catch((err: NullishType): Object | null => { + p.catch((err: Any): Object | null => { globalTest!.fail(); return null; }); @@ -279,7 +279,7 @@ function testResolvePromiseThenFinally(): int { } else { globalTest!.fail(); } - }, (error: NullishType): void => { + }, (error: Any): void => { globalTest!.fail(); }); p1.finally((): void => { diff --git a/static_core/plugins/ets/tests/interop_js/tests/test_class_methods_returning_values/js_to_ets/test_class_methods.ets b/static_core/plugins/ets/tests/interop_js/tests/test_class_methods_returning_values/js_to_ets/test_class_methods.ets index 22174884e9..803ddb919e 100644 --- a/static_core/plugins/ets/tests/interop_js/tests/test_class_methods_returning_values/js_to_ets/test_class_methods.ets +++ b/static_core/plugins/ets/tests/interop_js/tests/test_class_methods_returning_values/js_to_ets/test_class_methods.ets @@ -95,10 +95,10 @@ function TestReturnBooleanAsAny(): boolean { return testVal == TEST_BOOLEAN } -// Note: Using NullishType is a workaround until #17745 is not resolved +// Note: Using Any is a workaround until #17745 is not resolved function TestReturnNullAsAny(): boolean { const TestFunc: TReturnsAny = returnNullAsAny - const testVal = TestFunc() as NullishType + const testVal = TestFunc() as Any return testVal == null } @@ -231,10 +231,10 @@ function TestReturnBoolSubsetByValue(): boolean { ) } -// Note: Using NullishType is a workaround until #17745 is not resolved +// Note: Using Any is a workaround until #17745 is not resolved function TestReturnNullSubsetByValue(): boolean { const TestFunc = returnNullSubsetByValue - const testVal = TestFunc() as NullishType + const testVal = TestFunc() as Any return ( testVal == null && typeof testVal == 'object' diff --git a/static_core/plugins/ets/tests/interop_js/tests/test_intrins/frontend_test_intrins.ets b/static_core/plugins/ets/tests/interop_js/tests/test_intrins/frontend_test_intrins.ets index 79b5b8c006..4f5a34d148 100644 --- a/static_core/plugins/ets/tests/interop_js/tests/test_intrins/frontend_test_intrins.ets +++ b/static_core/plugins/ets/tests/interop_js/tests/test_intrins/frontend_test_intrins.ets @@ -52,7 +52,7 @@ function jsSumWrapperNumStr(a: double, b: String): String { function testUndefined(): boolean { let v = JSRuntime.getUndefined(); let r = "undefined:undefined"; - if (identity(v) as NullishType !== undefined) { + if (identity(v) as Any !== undefined) { return false; } return r == vstringify(v); diff --git a/static_core/plugins/ets/tests/interop_js/tests/test_intrins/test_intrins.ets b/static_core/plugins/ets/tests/interop_js/tests/test_intrins/test_intrins.ets index 4d4ba14eac..67435904a5 100644 --- a/static_core/plugins/ets/tests/interop_js/tests/test_intrins/test_intrins.ets +++ b/static_core/plugins/ets/tests/interop_js/tests/test_intrins/test_intrins.ets @@ -50,7 +50,7 @@ class jscall { native static bigint$a(top: JSValue, qname: String, v0: JSValue): BigInt; native static any$a(top: JSValue, qname: String, v0: JSValue): JSValue; - native static any$a$obj(top: JSValue, qname: String, v0: JSValue): NullishType; + native static any$a$obj(top: JSValue, qname: String, v0: JSValue): Any; native static any$b(top: JSValue, qname: String, v0: boolean): JSValue; native static any$n(top: JSValue, qname: String, v0: double): JSValue; native static any$s(top: JSValue, qname: String, v0: String): JSValue; @@ -124,7 +124,7 @@ function testUndefined(): boolean { function testNull(): boolean { let v = JSRuntime.getNull(); let r = "object:null"; - if (jscall.any$a(jsvars.m, ".identity", v) as NullishType !== null) { + if (jscall.any$a(jsvars.m, ".identity", v) as Any !== null) { return false; } return r == vstringify(v); diff --git a/static_core/plugins/ets/tests/interop_js/tests/test_return_this/test_return_this.ets b/static_core/plugins/ets/tests/interop_js/tests/test_return_this/test_return_this.ets index 97c7c4ea49..12f6c683f9 100644 --- a/static_core/plugins/ets/tests/interop_js/tests/test_return_this/test_return_this.ets +++ b/static_core/plugins/ets/tests/interop_js/tests/test_return_this/test_return_this.ets @@ -51,7 +51,7 @@ function testReturnThisAsString(): boolean { } function testReturnThisAsNull(): boolean { - return getThis.call(TEST_NULL) as NullishType == TEST_NULL + return getThis.call(TEST_NULL) as Any == TEST_NULL } function testReturnThisAsMap(): boolean { @@ -92,7 +92,7 @@ function testReturnThisAsAsyncFunc(): boolean { testVal = value; return null; }); - p.catch((err: NullishType): string | null => { + p.catch((err: Any): string | null => { return null; }); return testVal == TEST_STRING; diff --git a/static_core/plugins/ets/tests/interop_js/tests/test_undefined/test_undefined.ets b/static_core/plugins/ets/tests/interop_js/tests/test_undefined/test_undefined.ets index c713dbca67..d44c74c532 100644 --- a/static_core/plugins/ets/tests/interop_js/tests/test_undefined/test_undefined.ets +++ b/static_core/plugins/ets/tests/interop_js/tests/test_undefined/test_undefined.ets @@ -16,7 +16,7 @@ import { etsUndefinedProduce, etsUndefinedConsume, etsNullProduce, etsNullConsume } from "js_code" function TestPassUndefinedToEts(): boolean { - let a: NullishType = etsUndefinedProduce() + let a: Any = etsUndefinedProduce() if (a as JSValue !== JSRuntime.getUndefined()) { return false; } @@ -27,21 +27,21 @@ function TestPassUndefinedToEts(): boolean { } function TestPassUndefinedFromEts(): boolean { - let mUndefined: NullishType = undefined; + let mUndefined: Any = undefined; return etsUndefinedConsume(mUndefined) as boolean; } function TestPassNullToEts(): boolean { - if (etsNullProduce() as NullishType !== null) { + if (etsNullProduce() as Any !== null) { return false; } - if (etsNullProduce() as NullishType === undefined) { + if (etsNullProduce() as Any === undefined) { return false; } return true; } function TestPassNullFromEts(): boolean { - let mNull: NullishType = null; + let mNull: Any = null; return etsNullConsume(mNull) as boolean; } diff --git a/static_core/tests/tests-u-runner-2/runner/extensions/generators/ets_es_checked/generate-es-checked/src/types.rb b/static_core/tests/tests-u-runner-2/runner/extensions/generators/ets_es_checked/generate-es-checked/src/types.rb index acd806cdd0..bc6556f34f 100644 --- a/static_core/tests/tests-u-runner-2/runner/extensions/generators/ets_es_checked/generate-es-checked/src/types.rb +++ b/static_core/tests/tests-u-runner-2/runner/extensions/generators/ets_es_checked/generate-es-checked/src/types.rb @@ -75,7 +75,7 @@ module ESChecker end end if rb_obj == "#__undefined" || rb_obj == "#__null" - return { :kind => :trivial, :str => "NullishType" } + return { :kind => :trivial, :str => "Any" } end raise "can't detect type for #{rb_obj}" end diff --git a/static_core/tests/tests-u-runner-2/runner/extensions/generators/ets_es_checked/generate-es-checked/templates/template.sts.erb b/static_core/tests/tests-u-runner-2/runner/extensions/generators/ets_es_checked/generate-es-checked/templates/template.sts.erb index d597dfb155..72dcdb0be5 100644 --- a/static_core/tests/tests-u-runner-2/runner/extensions/generators/ets_es_checked/generate-es-checked/templates/template.sts.erb +++ b/static_core/tests/tests-u-runner-2/runner/extensions/generators/ets_es_checked/generate-es-checked/templates/template.sts.erb @@ -32,7 +32,7 @@ function __fail(): void { __fail_count += 1; } -class ArrayValueIterator implements IterableIterator { +class ArrayValueIterator implements IterableIterator { private idx: int private val: ArrayValue @@ -41,19 +41,19 @@ class ArrayValueIterator implements IterableIterator { this.val = val } - override $_iterator(): IterableIterator { + override $_iterator(): IterableIterator { return this; } - override next(): IteratorResult { + override next(): IteratorResult { if (this.idx >= this.val.getLength()) { - return new IteratorResult() + return new IteratorResult() } - return new IteratorResult(this.val.getElement(this.idx++).getData()); + return new IteratorResult(this.val.getElement(this.idx++).getData()); } } -function __value_rewrap_builtin_array(a: NullishType): NullishType { +function __value_rewrap_builtin_array(a: Any): Any { if (!(Type.of(a) instanceof ArrayType)) { return a; } @@ -70,7 +70,7 @@ class IterableData { } const KNOWN_ITERABLES = new Array() -function getIteratorFromIterable(a: NullishType, aTypeUncasted: Type): Iterator | undefined { +function getIteratorFromIterable(a: Any, aTypeUncasted: Type): Iterator | undefined { if (!(aTypeUncasted instanceof ClassType)) { return undefined } @@ -80,7 +80,7 @@ function getIteratorFromIterable(a: NullishType, aTypeUncasted: Type): Iterator< for (let i = 0; i < KNOWN_ITERABLES.length; i++) { const ki = KNOWN_ITERABLES[i]; if (ki.cls.equals(aType)) { - return ki.meth.invoke(a, [])! as Iterator + return ki.meth.invoke(a, [])! as Iterator } } const mNum = aType.getMethodsNum(); @@ -88,13 +88,13 @@ function getIteratorFromIterable(a: NullishType, aTypeUncasted: Type): Iterator< const m = aType.getMethod(i); if (m.getName() == "$_iterator" && !m.isStatic() && m.getType().getParametersNum() == 0) { KNOWN_ITERABLES.push(new IterableData(aType, m)); - return m.invoke(a, [])! as Iterator + return m.invoke(a, [])! as Iterator } } return undefined; } -function __value_is_same(a: NullishType, b: NullishType): boolean { +function __value_is_same(a: Any, b: Any): boolean { if (Runtime.sameValue(a, b)) { return true; } @@ -166,7 +166,7 @@ function __value_is_same(a: NullishType, b: NullishType): boolean { return false } -function __check_value(a: NullishType, b: NullishType): void { +function __check_value(a: Any, b: Any): void { if (__value_is_same(a, b)) { return } diff --git a/static_core/tests/tests-u-runner/tools/generate-es-checked/src/types.rb b/static_core/tests/tests-u-runner/tools/generate-es-checked/src/types.rb index a9561ebdd5..89c63716bc 100644 --- a/static_core/tests/tests-u-runner/tools/generate-es-checked/src/types.rb +++ b/static_core/tests/tests-u-runner/tools/generate-es-checked/src/types.rb @@ -75,7 +75,7 @@ module ESChecker end end if rb_obj == "#__undefined" || rb_obj == "#__null" - return { :kind => :trivial, :str => "NullishType" } + return { :kind => :trivial, :str => "Any" } end raise "can't detect type for #{rb_obj}" end diff --git a/static_core/tests/tests-u-runner/tools/generate-es-checked/templates/template.ets.erb b/static_core/tests/tests-u-runner/tools/generate-es-checked/templates/template.ets.erb index 6c400fb0ae..58ecae6ecf 100644 --- a/static_core/tests/tests-u-runner/tools/generate-es-checked/templates/template.ets.erb +++ b/static_core/tests/tests-u-runner/tools/generate-es-checked/templates/template.ets.erb @@ -32,7 +32,7 @@ function __fail(): void { __fail_count += 1; } -class ArrayValueIterator implements IterableIterator { +class ArrayValueIterator implements IterableIterator { private idx: int private val: ArrayValue @@ -41,19 +41,19 @@ class ArrayValueIterator implements IterableIterator { this.val = val } - override $_iterator(): IterableIterator { + override $_iterator(): IterableIterator { return this; } - override next(): IteratorResult { + override next(): IteratorResult { if (this.idx >= this.val.getLength()) { - return new IteratorResult() + return new IteratorResult() } - return new IteratorResult(this.val.getElement(this.idx++).getData()); + return new IteratorResult(this.val.getElement(this.idx++).getData()); } } -function __value_rewrap_builtin_array(a: NullishType): NullishType { +function __value_rewrap_builtin_array(a: Any): Any { if (!(Type.of(a) instanceof ArrayType)) { return a; } @@ -70,7 +70,7 @@ class IterableData { } const KNOWN_ITERABLES = new Array() -function getIteratorFromIterable(a: NullishType, aTypeUncasted: Type): Iterator | undefined { +function getIteratorFromIterable(a: Any, aTypeUncasted: Type): Iterator | undefined { if (!(aTypeUncasted instanceof ClassType)) { return undefined } @@ -80,7 +80,7 @@ function getIteratorFromIterable(a: NullishType, aTypeUncasted: Type): Iterator< for (let i = 0; i < KNOWN_ITERABLES.length; i++) { const ki = KNOWN_ITERABLES[i]; if (ki.cls.equals(aType)) { - return ki.meth.invoke(a, [])! as Iterator + return ki.meth.invoke(a, [])! as Iterator } } const mNum = aType.getMethodsNum(); @@ -88,13 +88,13 @@ function getIteratorFromIterable(a: NullishType, aTypeUncasted: Type): Iterator< const m = aType.getMethod(i); if (m.getName() == "$_iterator" && !m.isStatic() && m.getType().getParametersNum() == 0) { KNOWN_ITERABLES.push(new IterableData(aType, m)); - return m.invoke(a, [])! as Iterator + return m.invoke(a, [])! as Iterator } } return undefined; } -function __value_is_same(a: NullishType, b: NullishType): boolean { +function __value_is_same(a: Any, b: Any): boolean { if (Runtime.sameValue(a, b)) { return true; } @@ -166,7 +166,7 @@ function __value_is_same(a: NullishType, b: NullishType): boolean { return false } -function __check_value(a: NullishType, b: NullishType): void { +function __check_value(a: Any, b: Any): void { if (__value_is_same(a, b)) { return } -- Gitee