| /arkcompiler/ets_runtime/test/typeinfer/automatedcases/ |
| D | enumLiteralsSubtypeReduction.ts | 21 enum E {
1054 AssertType([ E.E0, E.E1], "E[]");
1055 AssertType(E.E0, "E.E0");
1056 AssertType(E.E1, "E.E1");
1057 return [ E.E0, E.E1]
1062 AssertType([ E.E2, E.E3], "E[]");
1063 AssertType(E.E2, "E.E2");
1064 AssertType(E.E3, "E.E3");
1065 return [ E.E2, E.E3]
1070 AssertType([ E.E4, E.E5], "E[]");
[all …]
|
| D | arithmeticOperatorWithEnum.ts | 23 enum E {
34 let c: E;
35 AssertType(c, "E");
41 AssertType(c, "E");
47 AssertType(c, "E");
53 AssertType(c, "E");
54 AssertType(c, "E");
60 AssertType(c, "E");
66 AssertType(c, "E");
68 let ra6 = E.a * a;
[all …]
|
| D | intersectionOfUnionOfUnitTypes.ts | 23 const enum E { A, B, C, D, E, F }
31 let x2: ('a' | 'b' | 'c') & ('c' | 'd' | 'e'); // 'c'
34 let x3: ('a' | 'b' | 'c') & ('d' | 'e' | 'f'); // never
37 let x4: ('a' | 'b' | 'c') & ('b' | 'c' | 'd') & ('c' | 'd' | 'e'); // 'c'
40 let x5: ('a' | 'b' | 'c') & ('b' | 'c' | 'd') & ('c' | 'd' | 'e') & ('d' | 'e' | 'f'); // never
61 let z0: (E.A | E.B | E.C) & (E.A | E.B | E.C); // E.A | E.B | E.C
63 AssertType(E, "any");
64 AssertType(E, "any");
65 AssertType(E, "any");
66 AssertType(E, "any");
[all …]
|
| D | arithmeticOperatorWithEnumUnion.ts | 23 enum E {
38 let c: E | F;
72 let ra6 = E.a * a;
74 AssertType(E.a * a, "number");
75 AssertType(E.a, "E.a");
78 let ra7 = E.a * b;
80 AssertType(E.a * b, "number");
81 AssertType(E.a, "E.a");
84 let ra8 = E.a * E.b;
86 AssertType(E.a * E.b, "number");
[all …]
|
| D | comparisonOperatorWithSubtypeEnumAndNumber.ts | 21 enum E { a, b, c }
23 let a: E;
24 AssertType(a, "E");
33 AssertType(a, "E");
40 AssertType(a, "E");
42 let ra3 = E.a < b;
44 AssertType(E.a < b, "boolean");
45 AssertType(E.a, "E.a");
48 let ra4 = b < E.a;
50 AssertType(b < E.a, "boolean");
[all …]
|
| D | localTypes1.ts | 22 enum E {
23 AssertType(E, "E");
26 AssertType(A, "E.A");
27 AssertType(B, "E.B");
28 AssertType(C, "E.C");
31 x: E;
34 x: E;
35 AssertType(x, "E");
46 a[0].x = E.B;
47 AssertType(a[0].x = E.B, "E.B");
[all …]
|
| D | controlFlowAliasingCatchVariablesuseunknownincatchvariablesfalse.ts | 22 catch (e) {
23 const isString = typeof e === 'string';
25 AssertType(typeof e === 'string', "boolean");
26 AssertType(typeof e, "union");
27 AssertType(e, "any");
33 e.toUpperCase(); // e string
34 AssertType(e.toUpperCase(), "string");
35 AssertType(e.toUpperCase, "() => string");
38 if (typeof e === 'string') {
39 AssertType(typeof e === 'string', "boolean");
[all …]
|
| D | exponentiationOperatorWithEnum.ts | 23 enum E {
34 let c: E;
35 AssertType(c, "E");
41 AssertType(c, "E");
47 AssertType(c, "E");
53 AssertType(c, "E");
54 AssertType(c, "E");
60 AssertType(c, "E");
66 AssertType(c, "E");
68 let r6 = E.a ** a;
[all …]
|
| D | constEnums.ts | 31 E = A | 1, enumerator
39 M = E << B,
40 N = E << 1,
41 O = E >> B,
42 P = E >> 1,
43 PQ = E ** 2,
73 export const enum E { enum
75 V2 = A.B.C.E.V1 | 100
84 export const enum E { enum
85 V3 = A.B.C.E["V2"] & 200,
[all …]
|
| D | additionOperatorWithNumberAndEnum.ts | 21 enum E { a, b }
27 let b: E;
28 AssertType(b, "E");
30 let c: E | F;
43 AssertType(b, "E");
48 AssertType(b, "E");
54 AssertType(b, "E");
55 AssertType(b, "E");
63 let r6 = E.a + 0;
65 AssertType(E.a + 0, "number");
[all …]
|
| D | exponentiationOperatorWithEnumUnion.ts | 23 enum E {
38 let c: E | F;
72 let r6 = E.a ** a;
74 AssertType(E.a ** a, "number");
75 AssertType(E.a, "E.a");
78 let r7 = E.a ** b;
80 AssertType(E.a ** b, "number");
81 AssertType(E.a, "E.a");
84 let r8 = E.a ** E.b;
86 AssertType(E.a ** E.b, "number");
[all …]
|
| D | bestCommonTypeWithContextualTyping.ts | 31 let e: Ellement; variable
32 AssertType(e, "Ellement");
37 let arr: Contextual[] = [e]; // Ellement[]
39 AssertType([e], "Ellement[]");
40 AssertType(e, "Ellement");
42 let obj: { [s: string]: Contextual } = { s: e }; // { s: Ellement; [s: string]: Ellement
47 AssertType({ s: e }, "{ s: Ellement; }");
51 AssertType(e, "Ellement");
54 let conditional: Contextual = null ? e : e; // Ellement variable
56 AssertType(null ? e : e, "Ellement");
[all …]
|
| D | declarationEmitPromise.ts | 25 export async function runSampleWorks<A, B, C, D, E>(
26 a: bluebird<A>, b?: bluebird<B>, c?: bluebird<C>, d?: bluebird<D>, e?: bluebird<E>) {
27 let result = await (bluebird.all as any)([a, b, c, d, e].filter(el => !!el));
29 AssertType(await (bluebird.all as any)([a, b, c, d, e].filter(el => !!el)), "any");
30 AssertType((bluebird.all as any)([a, b, c, d, e].filter(el => !!el)), "any");
34 AssertType([a, b, c, d, e].filter(el => !!el), "bluebird<A>[]");
35 AssertType([a, b, c, d, e].filter, "{ <S extends bluebird<A>>((bluebird<A>, number, bluebird<A>[]) …
36 AssertType([a, b, c, d, e], "bluebird<A>[]");
41 AssertType(e, "bluebird<E>");
48 let func = <T>(f: (a: A, b?: B, c?: C, d?: D, e?: E) => T): T =>
[all …]
|
| D | numberAssignableToEnum.ts | 21 enum E { A }
25 let e: E; variable
26 AssertType(e, "E");
28 e = n;
29 AssertType(e = n, "number");
30 AssertType(e, "E");
33 n = e;
34 AssertType(n = e, "E");
36 AssertType(e, "E");
|
| D | validNumberAssignments.ts | 37 enum E { A };
38 let d: E = x;
39 AssertType(d, "E");
42 let e = E.A; variable
43 AssertType(e, "E");
44 AssertType(E.A, "E");
46 e = x;
47 AssertType(e = x, "number");
48 AssertType(e, "E");
|
| D | declFileTypeofInAnonymousType.ts | 24 export enum e {
55 …pe(d, "{ m: { mod: typeof m1; }; mc: { cl: typeof m1.c; }; me: { en: typeof m1.e; }; mh: m1.e; }");
56 …}, me: { en: m1.e }, mh: m1.e.holiday}, "{ m: { mod: typeof m1; }; mc: { cl: typeof m1.c; };…
70 me: { en: m1.e },
71 AssertType(me, "{ en: typeof m1.e; }");
72 AssertType({ en: m1.e }, "{ en: typeof m1.e; }");
73 AssertType(en, "typeof m1.e");
74 AssertType(m1.e, "typeof m1.e");
76 mh: m1.e.holiday
77 AssertType(mh, "m1.e");
[all …]
|
| D | genericMethodOverspecialization.ts | 57 let xxx = elements.filter(function (e) {
60 AssertType(function (e) { return !e.isDisabled;}, "(HTMLElement) => boolean");
61 AssertType(e, "HTMLElement");
62 AssertType(elements.filter(function (e) { return !e.isDisabled;}), "HTMLElement[]");
64 AssertType(!e.isDisabled, "boolean");
65 AssertType(e.isDisabled, "boolean");
66 return !e.isDisabled;
70 let widths:number[] = elements.map(function (e) { // should not error
73 AssertType(function (e) { // should not error return e.clientWidth;}, "(HTMLElement) => number");
74 AssertType(e, "HTMLElement");
[all …]
|
| D | additionOperatorWithStringAndEveryType.ts | 21 enum E { a, b, c }
35 let e: Object; variable
36 AssertType(e, "Object");
41 let g: E;
42 AssertType(g, "E");
73 let r5 = x + e;
75 AssertType(x + e, "string");
77 AssertType(e, "Object");
89 AssertType(g, "E");
116 let r12 = e + x;
[all …]
|
| D | privateNameComputedPropertyName1targetesnext.ts | 28 #e = '';
45 const data: Record<string, string> = { a: 'a', b: 'b', c: 'c', d: 'd', e: 'e' };
47 AssertType({ a: 'a', b: 'b', c: 'c', d: 'd', e: 'e' }, "{ a: string; b: string; c: string; d: strin…
56 AssertType(e, "string");
57 AssertType('e', "string");
80 [this.#e = 'e']: e,
81 AssertType(this.#e = 'e', "string");
82 AssertType(this.#e, "string");
84 AssertType('e', "string");
85 AssertType(e, "string");
[all …]
|
| /arkcompiler/ets_frontend/legacy_bin/api8/src/ |
| D | index.js | 2 …e=>{var t=Object.prototype.toString,r="undefined"!=typeof Buffer&&"function"==typeof Buffer.alloc&… class
|
| /arkcompiler/ets_runtime/tools/circuit_viewer/src/engine/ |
| D | GLFrame.js | 37 function touchStart(e) { argument
38 document.addEventListener('contextmenu', function (e) { argument
39 e.preventDefault();
41 e.preventDefault();
44 e.touches[0].clientX,
45 e.touches[0].clientY
48 function touchMove(e) { argument
49 e.preventDefault();
52 e.touches[0].clientX,
53 e.touches[0].clientY
[all …]
|
| D | RightMenu.js | 91 for (let e of grp) {
92 if (e.type != 2) {
103 for (let e of grp) {
104 e.rect = [x, y, w, 32];
105 if (e.on) {
112 if (e.type == 2) {
113 e.rect = [x, y, w, 0];
120 e.name,
131 if (e.type == 0) {
132 if (e.hk) {
[all …]
|
| /arkcompiler/ets_frontend/es2panda/test/compiler/ts/cases/conformance/enums/ |
| D | test-ts-enum-11.ts | 17 namespace E { namespace
18 export enum E { enum
20 E = 1, enumerator
22 B = (() => {enum E{
24 E = 3,
26 E_2 = E + 10,
29 } return E.C + 5;})(),
34 print(E.E.E);
35 print(E.E.E_2);
36 print(E.E.B);
[all …]
|
| /arkcompiler/ets_frontend/es2panda/test/compiler/js/ |
| D | cocos_worker_test.js | 6 991: function(t, e, i) { argument
13 Object.defineProperty(e, "__esModule", {
16 e.launchEngine = e.loadModule = void 0;
36 const e = r[t];
37 null == e || e();
39 e.loadModule = o;
48 e.launchEngine = function() {
49 return new Promise(((t, e) => {
68 System.import("cc").then((e => {
70 e.macro.CLEANUP_IMAGE_CACHE = !1;
[all …]
|
| /arkcompiler/runtime_core/libpandabase/utils/ |
| D | expected.h | 26 template <class E>
29 explicit Unexpected(E e) noexcept(std::is_nothrow_move_constructible_v<E>) : e_(std::move(e)) {} in Unexpected() argument
31 const E &Value() const &noexcept in Value()
35 E &Value() & noexcept in Value()
39 E &&Value() && noexcept in Value()
50 E e_;
64 // Expected with T or E for a reference type is ill-formed.
65 template <class T, class E>
76 …Expected(Unexpected<E> e) noexcept(std::is_nothrow_move_constructible_v<E>) : v_(std::move(e.Value… in noexcept() argument
87 const E &Error() const &noexcept(ExpectedConfig::RELEASE) in Error()
[all …]
|