1 /**
2 * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "globalTypesHolder.h"
17
18 #include "checker/types/typeError.h"
19 #include "checker/types/ts/numberType.h"
20 #include "checker/types/ts/anyType.h"
21 #include "checker/types/ts/stringType.h"
22 #include "checker/types/ts/booleanType.h"
23 #include "checker/types/ts/voidType.h"
24 #include "checker/types/ts/nullType.h"
25 #include "checker/types/ts/undefinedType.h"
26 #include "checker/types/ts/unknownType.h"
27 #include "checker/types/ts/neverType.h"
28 #include "checker/types/ts/nonPrimitiveType.h"
29 #include "checker/types/ts/bigintType.h"
30 #include "checker/types/ts/booleanLiteralType.h"
31 #include "checker/types/ts/bigintLiteralType.h"
32 #include "checker/types/ts/numberLiteralType.h"
33 #include "checker/types/ts/stringLiteralType.h"
34 #include "checker/types/ts/tupleType.h"
35 #include "checker/types/ts/objectLiteralType.h"
36 #include "checker/types/ts/unionType.h"
37 #include "checker/types/ets/byteType.h"
38 #include "checker/types/ets/charType.h"
39 #include "checker/types/ets/doubleType.h"
40 #include "checker/types/ets/floatType.h"
41 #include "checker/types/ets/intType.h"
42 #include "checker/types/ets/longType.h"
43 #include "checker/types/ets/shortType.h"
44 #include "checker/types/ets/etsBooleanType.h"
45 #include "checker/types/ets/etsStringType.h"
46 #include "checker/types/ets/etsBigIntType.h"
47 #include "checker/types/ets/etsVoidType.h"
48 #include "checker/types/ets/etsNullishTypes.h"
49 #include "checker/types/ets/etsObjectType.h"
50 #include "checker/types/ets/wildcardType.h"
51 #include "checker/types/ets/etsNeverType.h"
52 #include "util/helpers.h"
53
54 namespace ark::es2panda::checker {
55
AddETSEscompatLayer()56 void GlobalTypesHolder::AddETSEscompatLayer()
57 {
58 // ETS escompat layer
59 builtinNameMappings_.emplace("Array", GlobalTypeId::ETS_ARRAY_BUILTIN);
60 builtinNameMappings_.emplace("Date", GlobalTypeId::ETS_DATE_BUILTIN);
61 builtinNameMappings_.emplace("Error", GlobalTypeId::ETS_ERROR_BUILTIN);
62 builtinNameMappings_.emplace("OutOfMemoryError", GlobalTypeId::ETS_OUT_OF_MEMORY_ERROR_BUILTIN);
63 builtinNameMappings_.emplace("NoSuchMethodError", GlobalTypeId::ETS_NO_SUCH_METHOD_ERROR_BUILTIN);
64 builtinNameMappings_.emplace("DivideByZeroError", GlobalTypeId::ETS_DIVIDE_BY_ZERO_ERROR_BUILTIN);
65 builtinNameMappings_.emplace("NullPointerError", GlobalTypeId::ETS_NULL_POINTER_ERROR_BUILTIN);
66 builtinNameMappings_.emplace("UncaughtExceptionError", GlobalTypeId::ETS_UNCAUGHT_EXCEPTION_ERROR_BUILTIN);
67 builtinNameMappings_.emplace("Map", GlobalTypeId::ETS_MAP_BUILTIN);
68 builtinNameMappings_.emplace("RegExp", GlobalTypeId::ETS_REGEXP_BUILTIN);
69 builtinNameMappings_.emplace("Set", GlobalTypeId::ETS_SET_BUILTIN);
70 }
71
AddFunctionTypes(ArenaAllocator * allocator)72 void GlobalTypesHolder::AddFunctionTypes(ArenaAllocator *allocator)
73 {
74 // ETS throwing functional types
75 for (size_t id = static_cast<size_t>(GlobalTypeId::ETS_THROWING_FUNCTION0_CLASS), nargs = 0;
76 id < static_cast<size_t>(GlobalTypeId::ETS_THROWING_FUNCTIONN_CLASS); id++, nargs++) {
77 builtinNameMappings_.emplace(util::UString("ThrowingFunction" + std::to_string(nargs), allocator).View(),
78 static_cast<GlobalTypeId>(id));
79 }
80
81 builtinNameMappings_.emplace("ThrowingFunctionN", GlobalTypeId::ETS_THROWING_FUNCTIONN_CLASS);
82
83 // ETS rethrowing functional types
84 for (size_t id = static_cast<size_t>(GlobalTypeId::ETS_RETHROWING_FUNCTION0_CLASS), nargs = 0;
85 id < static_cast<size_t>(GlobalTypeId::ETS_RETHROWING_FUNCTIONN_CLASS); id++, nargs++) {
86 builtinNameMappings_.emplace(util::UString("RethrowingFunction" + std::to_string(nargs), allocator).View(),
87 static_cast<GlobalTypeId>(id));
88 }
89
90 builtinNameMappings_.emplace("RethrowingFunctionN", GlobalTypeId::ETS_RETHROWING_FUNCTIONN_CLASS);
91
92 // ETS functional types
93 for (size_t id = static_cast<size_t>(GlobalTypeId::ETS_FUNCTION0_CLASS), nargs = 0;
94 id < static_cast<size_t>(GlobalTypeId::ETS_FUNCTIONN_CLASS); id++, nargs++) {
95 builtinNameMappings_.emplace(util::UString("Function" + std::to_string(nargs), allocator).View(),
96 static_cast<GlobalTypeId>(id));
97 }
98
99 builtinNameMappings_.emplace("FunctionN", GlobalTypeId::ETS_FUNCTIONN_CLASS);
100 }
101
AddTSSpecificTypes(ArenaAllocator * allocator)102 void GlobalTypesHolder::AddTSSpecificTypes(ArenaAllocator *allocator)
103 {
104 globalTypes_[static_cast<size_t>(GlobalTypeId::NUMBER)] = allocator->New<NumberType>();
105 globalTypes_[static_cast<size_t>(GlobalTypeId::ANY)] = allocator->New<AnyType>();
106 globalTypes_[static_cast<size_t>(GlobalTypeId::STRING)] = allocator->New<StringType>();
107 globalTypes_[static_cast<size_t>(GlobalTypeId::BOOLEAN)] = allocator->New<BooleanType>();
108 globalTypes_[static_cast<size_t>(GlobalTypeId::VOID)] = allocator->New<VoidType>();
109 globalTypes_[static_cast<size_t>(GlobalTypeId::NULL_ID)] = allocator->New<NullType>();
110 globalTypes_[static_cast<size_t>(GlobalTypeId::UNDEFINED)] = allocator->New<UndefinedType>();
111 globalTypes_[static_cast<size_t>(GlobalTypeId::UNKNOWN)] = allocator->New<UnknownType>();
112 globalTypes_[static_cast<size_t>(GlobalTypeId::NEVER)] = allocator->New<NeverType>();
113 globalTypes_[static_cast<size_t>(GlobalTypeId::NON_PRIMITIVE)] = allocator->New<NonPrimitiveType>();
114 globalTypes_[static_cast<size_t>(GlobalTypeId::BIGINT)] = allocator->New<BigintType>();
115 globalTypes_[static_cast<size_t>(GlobalTypeId::FALSE_ID)] = allocator->New<BooleanLiteralType>(false);
116 globalTypes_[static_cast<size_t>(GlobalTypeId::TRUE_ID)] = allocator->New<BooleanLiteralType>(true);
117 globalTypes_[static_cast<size_t>(GlobalTypeId::NUMBER_OR_BIGINT)] =
118 allocator->New<UnionType>(allocator, std::initializer_list<Type *> {GlobalNumberType(), GlobalBigintType()});
119 globalTypes_[static_cast<size_t>(GlobalTypeId::STRING_OR_NUMBER)] =
120 allocator->New<UnionType>(allocator, std::initializer_list<Type *> {GlobalStringType(), GlobalNumberType()});
121 globalTypes_[static_cast<size_t>(GlobalTypeId::ZERO)] = allocator->New<NumberLiteralType>(0);
122 globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_STRING)] = allocator->New<StringLiteralType>("");
123 globalTypes_[static_cast<size_t>(GlobalTypeId::ZERO_BIGINT)] = allocator->New<BigintLiteralType>("0n", false);
124 globalTypes_[static_cast<size_t>(GlobalTypeId::PRIMITIVE)] = allocator->New<UnionType>(
125 allocator,
126 std::initializer_list<Type *> {GlobalNumberType(), GlobalStringType(), GlobalBigintType(), GlobalBooleanType(),
127 GlobalVoidType(), GlobalUndefinedType(), GlobalNullType()});
128 globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_TUPLE)] = allocator->New<TupleType>(allocator);
129 globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_OBJECT)] = allocator->New<ObjectLiteralType>();
130 globalTypes_[static_cast<size_t>(GlobalTypeId::RESOLVING_RETURN_TYPE)] = allocator->New<AnyType>();
131 globalTypes_[static_cast<size_t>(GlobalTypeId::ERROR_TYPE)] = allocator->New<AnyType>();
132 }
133
AddEtsSpecificTypes(ArenaAllocator * allocator)134 void GlobalTypesHolder::AddEtsSpecificTypes(ArenaAllocator *allocator)
135 {
136 // ETS specific types
137 globalTypes_[static_cast<size_t>(GlobalTypeId::BYTE)] = allocator->New<ByteType>();
138 globalTypes_[static_cast<size_t>(GlobalTypeId::SHORT)] = allocator->New<ShortType>();
139 globalTypes_[static_cast<size_t>(GlobalTypeId::INT)] = allocator->New<IntType>();
140 globalTypes_[static_cast<size_t>(GlobalTypeId::LONG)] = allocator->New<LongType>();
141 globalTypes_[static_cast<size_t>(GlobalTypeId::FLOAT)] = allocator->New<FloatType>();
142 globalTypes_[static_cast<size_t>(GlobalTypeId::DOUBLE)] = allocator->New<DoubleType>();
143 globalTypes_[static_cast<size_t>(GlobalTypeId::CHAR)] = allocator->New<CharType>();
144 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_BOOLEAN)] = allocator->New<ETSBooleanType>();
145 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_VOID)] = allocator->New<ETSVoidType>();
146 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_NULL)] = allocator->New<ETSNullType>();
147 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_UNDEFINED)] = allocator->New<ETSUndefinedType>();
148 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_WILDCARD)] = allocator->New<WildcardType>();
149 globalTypes_[static_cast<size_t>(GlobalTypeId::TYPE_ERROR)] = allocator->New<TypeError>();
150 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_NEVER)] = allocator->New<ETSNeverType>();
151 }
152
AddEtsSpecificBuiltinTypes()153 void GlobalTypesHolder::AddEtsSpecificBuiltinTypes()
154 {
155 builtinNameMappings_.emplace("Boolean", GlobalTypeId::ETS_BOOLEAN_BUILTIN);
156 builtinNameMappings_.emplace("Byte", GlobalTypeId::ETS_BYTE_BUILTIN);
157 builtinNameMappings_.emplace("Char", GlobalTypeId::ETS_CHAR_BUILTIN);
158 builtinNameMappings_.emplace("Comparable", GlobalTypeId::ETS_COMPARABLE_BUILTIN);
159 builtinNameMappings_.emplace("Console", GlobalTypeId::ETS_CONSOLE_BUILTIN);
160 builtinNameMappings_.emplace("Double", GlobalTypeId::ETS_DOUBLE_BUILTIN);
161 builtinNameMappings_.emplace("Exception", GlobalTypeId::ETS_EXCEPTION_BUILTIN);
162 builtinNameMappings_.emplace("Float", GlobalTypeId::ETS_FLOAT_BUILTIN);
163 builtinNameMappings_.emplace("Floating", GlobalTypeId::ETS_FLOATING_BUILTIN);
164 builtinNameMappings_.emplace("Int", GlobalTypeId::ETS_INTEGER_BUILTIN);
165 builtinNameMappings_.emplace("Integral", GlobalTypeId::ETS_INTEGRAL_BUILTIN);
166 builtinNameMappings_.emplace("Long", GlobalTypeId::ETS_LONG_BUILTIN);
167 builtinNameMappings_.emplace("Object", GlobalTypeId::ETS_OBJECT_BUILTIN);
168 builtinNameMappings_.emplace("Runtime", GlobalTypeId::ETS_RUNTIME_BUILTIN);
169 builtinNameMappings_.emplace("RuntimeLinker", GlobalTypeId::ETS_RUNTIME_LINKER_BUILTIN);
170 builtinNameMappings_.emplace("Short", GlobalTypeId::ETS_SHORT_BUILTIN);
171 builtinNameMappings_.emplace("StackTraceElement", GlobalTypeId::ETS_STACK_TRACE_ELEMENT_BUILTIN);
172 builtinNameMappings_.emplace("StackTrace", GlobalTypeId::ETS_STACK_TRACE_BUILTIN);
173 builtinNameMappings_.emplace("NullPointerException", GlobalTypeId::ETS_NULL_POINTER_EXCEPTION_BUILTIN);
174 builtinNameMappings_.emplace("ArrayIndexOutOfBoundsError",
175 GlobalTypeId::ETS_ARRAY_INDEX_OUT_OF_BOUNDS_ERROR_BUILTIN);
176 builtinNameMappings_.emplace("ArithmeticError", GlobalTypeId::ETS_ARITHMETIC_ERROR_BUILTIN);
177 builtinNameMappings_.emplace("ClassNotFoundException", GlobalTypeId::ETS_CLASS_NOT_FOUND_EXCEPTION_BUILTIN);
178 builtinNameMappings_.emplace("ClassCastError", GlobalTypeId::ETS_CLASS_CAST_ERROR_BUILTIN);
179 builtinNameMappings_.emplace("String", GlobalTypeId::ETS_STRING_BUILTIN);
180 builtinNameMappings_.emplace("BigInt", GlobalTypeId::ETS_BIG_INT_BUILTIN);
181 builtinNameMappings_.emplace("StringBuilder", GlobalTypeId::ETS_STRING_BUILDER_BUILTIN);
182 builtinNameMappings_.emplace("Type", GlobalTypeId::ETS_TYPE_BUILTIN);
183 builtinNameMappings_.emplace("Types", GlobalTypeId::ETS_TYPES_BUILTIN);
184 builtinNameMappings_.emplace("Promise", GlobalTypeId::ETS_PROMISE_BUILTIN);
185 builtinNameMappings_.emplace("Box", GlobalTypeId::ETS_BOX_BUILTIN);
186 builtinNameMappings_.emplace("BooleanBox", GlobalTypeId::ETS_BOOLEAN_BOX_BUILTIN);
187 builtinNameMappings_.emplace("ByteBox", GlobalTypeId::ETS_BYTE_BOX_BUILTIN);
188 builtinNameMappings_.emplace("CharBox", GlobalTypeId::ETS_CHAR_BOX_BUILTIN);
189 builtinNameMappings_.emplace("ShortBox", GlobalTypeId::ETS_SHORT_BOX_BUILTIN);
190 builtinNameMappings_.emplace("IntBox", GlobalTypeId::ETS_INT_BOX_BUILTIN);
191 builtinNameMappings_.emplace("LongBox", GlobalTypeId::ETS_LONG_BOX_BUILTIN);
192 builtinNameMappings_.emplace("FloatBox", GlobalTypeId::ETS_FLOAT_BOX_BUILTIN);
193 builtinNameMappings_.emplace("DoubleBox", GlobalTypeId::ETS_DOUBLE_BOX_BUILTIN);
194 }
195
GlobalTypesHolder(ArenaAllocator * allocator)196 GlobalTypesHolder::GlobalTypesHolder(ArenaAllocator *allocator) : builtinNameMappings_(allocator->Adapter())
197 {
198 // TS specific types
199 AddTSSpecificTypes(allocator);
200
201 // ETS specific types
202 AddEtsSpecificTypes(allocator);
203
204 AddEtsSpecificBuiltinTypes();
205
206 // ETS escompat layer
207 AddETSEscompatLayer();
208
209 builtinNameMappings_.emplace("TYPE ERROR", GlobalTypeId::TYPE_ERROR);
210
211 // ETS functional types
212 for (size_t id = static_cast<size_t>(GlobalTypeId::ETS_FUNCTION0_CLASS), nargs = 0;
213 id < static_cast<size_t>(GlobalTypeId::ETS_FUNCTIONN_CLASS); id++, nargs++) {
214 builtinNameMappings_.emplace(util::UString("Function" + std::to_string(nargs), allocator).View(),
215 static_cast<GlobalTypeId>(id));
216 }
217
218 builtinNameMappings_.emplace("FunctionN", GlobalTypeId::ETS_FUNCTIONN_CLASS);
219
220 // Function types
221 AddFunctionTypes(allocator);
222
223 // ETS interop js specific types
224 builtinNameMappings_.emplace("JSRuntime", GlobalTypeId::ETS_INTEROP_JSRUNTIME_BUILTIN);
225 builtinNameMappings_.emplace("JSValue", GlobalTypeId::ETS_INTEROP_JSVALUE_BUILTIN);
226 }
227
GlobalNumberType()228 Type *GlobalTypesHolder::GlobalNumberType()
229 {
230 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NUMBER));
231 }
232
GlobalAnyType()233 Type *GlobalTypesHolder::GlobalAnyType()
234 {
235 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ANY));
236 }
237
GlobalStringType()238 Type *GlobalTypesHolder::GlobalStringType()
239 {
240 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::STRING));
241 }
242
GlobalBooleanType()243 Type *GlobalTypesHolder::GlobalBooleanType()
244 {
245 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::BOOLEAN));
246 }
247
GlobalVoidType()248 Type *GlobalTypesHolder::GlobalVoidType()
249 {
250 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::VOID));
251 }
252
GlobalNullType()253 Type *GlobalTypesHolder::GlobalNullType()
254 {
255 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NULL_ID));
256 }
257
GlobalUndefinedType()258 Type *GlobalTypesHolder::GlobalUndefinedType()
259 {
260 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::UNDEFINED));
261 }
262
GlobalUnknownType()263 Type *GlobalTypesHolder::GlobalUnknownType()
264 {
265 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::UNKNOWN));
266 }
267
GlobalNeverType()268 Type *GlobalTypesHolder::GlobalNeverType()
269 {
270 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NEVER));
271 }
272
GlobalNonPrimitiveType()273 Type *GlobalTypesHolder::GlobalNonPrimitiveType()
274 {
275 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NON_PRIMITIVE));
276 }
277
GlobalBigintType()278 Type *GlobalTypesHolder::GlobalBigintType()
279 {
280 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::BIGINT));
281 }
282
GlobalFalseType()283 Type *GlobalTypesHolder::GlobalFalseType()
284 {
285 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::FALSE_ID));
286 }
287
GlobalTrueType()288 Type *GlobalTypesHolder::GlobalTrueType()
289 {
290 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::TRUE_ID));
291 }
292
GlobalNumberOrBigintType()293 Type *GlobalTypesHolder::GlobalNumberOrBigintType()
294 {
295 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NUMBER_OR_BIGINT));
296 }
297
GlobalStringOrNumberType()298 Type *GlobalTypesHolder::GlobalStringOrNumberType()
299 {
300 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::STRING_OR_NUMBER));
301 }
302
GlobalZeroType()303 Type *GlobalTypesHolder::GlobalZeroType()
304 {
305 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ZERO));
306 }
307
GlobalEmptyStringType()308 Type *GlobalTypesHolder::GlobalEmptyStringType()
309 {
310 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_STRING));
311 }
312
GlobalZeroBigintType()313 Type *GlobalTypesHolder::GlobalZeroBigintType()
314 {
315 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ZERO_BIGINT));
316 }
317
GlobalPrimitiveType()318 Type *GlobalTypesHolder::GlobalPrimitiveType()
319 {
320 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::PRIMITIVE));
321 }
322
GlobalEmptyTupleType()323 Type *GlobalTypesHolder::GlobalEmptyTupleType()
324 {
325 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_TUPLE));
326 }
327
GlobalEmptyObjectType()328 Type *GlobalTypesHolder::GlobalEmptyObjectType()
329 {
330 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_OBJECT));
331 }
332
GlobalResolvingReturnType()333 Type *GlobalTypesHolder::GlobalResolvingReturnType()
334 {
335 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::RESOLVING_RETURN_TYPE));
336 }
337
GlobalErrorType()338 Type *GlobalTypesHolder::GlobalErrorType()
339 {
340 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ERROR_TYPE));
341 }
342
GlobalByteType()343 Type *GlobalTypesHolder::GlobalByteType()
344 {
345 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::BYTE));
346 }
347
GlobalShortType()348 Type *GlobalTypesHolder::GlobalShortType()
349 {
350 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::SHORT));
351 }
352
GlobalIntType()353 Type *GlobalTypesHolder::GlobalIntType()
354 {
355 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::INT));
356 }
357
GlobalLongType()358 Type *GlobalTypesHolder::GlobalLongType()
359 {
360 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::LONG));
361 }
362
GlobalFloatType()363 Type *GlobalTypesHolder::GlobalFloatType()
364 {
365 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::FLOAT));
366 }
367
GlobalDoubleType()368 Type *GlobalTypesHolder::GlobalDoubleType()
369 {
370 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::DOUBLE));
371 }
372
GlobalCharType()373 Type *GlobalTypesHolder::GlobalCharType()
374 {
375 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::CHAR));
376 }
377
GlobalETSBooleanType()378 Type *GlobalTypesHolder::GlobalETSBooleanType()
379 {
380 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BOOLEAN));
381 }
382
GlobalETSStringLiteralType()383 Type *GlobalTypesHolder::GlobalETSStringLiteralType()
384 {
385 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_STRING));
386 }
387
GlobalETSVoidType()388 Type *GlobalTypesHolder::GlobalETSVoidType()
389 {
390 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_VOID));
391 }
392
GlobalETSObjectType()393 Type *GlobalTypesHolder::GlobalETSObjectType()
394 {
395 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_OBJECT_BUILTIN));
396 }
397
GlobalETSNullType()398 Type *GlobalTypesHolder::GlobalETSNullType()
399 {
400 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_NULL));
401 }
402
GlobalETSUndefinedType()403 Type *GlobalTypesHolder::GlobalETSUndefinedType()
404 {
405 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_UNDEFINED));
406 }
407
GlobalETSNeverType()408 Type *GlobalTypesHolder::GlobalETSNeverType()
409 {
410 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_NEVER));
411 }
412
GlobalETSNullishObjectType()413 Type *GlobalTypesHolder::GlobalETSNullishObjectType()
414 {
415 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_NULLISH_OBJECT));
416 }
417
GlobalETSNullishType()418 Type *GlobalTypesHolder::GlobalETSNullishType()
419 {
420 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_NULLISH_TYPE));
421 }
422
GlobalWildcardType()423 Type *GlobalTypesHolder::GlobalWildcardType()
424 {
425 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_WILDCARD));
426 }
427
GlobalETSBooleanBuiltinType()428 Type *GlobalTypesHolder::GlobalETSBooleanBuiltinType()
429 {
430 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BOOLEAN_BUILTIN));
431 }
432
GlobalByteBuiltinType()433 Type *GlobalTypesHolder::GlobalByteBuiltinType()
434 {
435 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BYTE_BUILTIN));
436 }
437
GlobalCharBuiltinType()438 Type *GlobalTypesHolder::GlobalCharBuiltinType()
439 {
440 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_CHAR_BUILTIN));
441 }
442
GlobalComparableBuiltinType()443 Type *GlobalTypesHolder::GlobalComparableBuiltinType()
444 {
445 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_COMPARABLE_BUILTIN));
446 }
447
GlobalConsoleBuiltinType()448 Type *GlobalTypesHolder::GlobalConsoleBuiltinType()
449 {
450 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_CONSOLE_BUILTIN));
451 }
452
GlobalDoubleBuiltinType()453 Type *GlobalTypesHolder::GlobalDoubleBuiltinType()
454 {
455 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_DOUBLE_BUILTIN));
456 }
457
GlobalExceptionBuiltinType()458 Type *GlobalTypesHolder::GlobalExceptionBuiltinType()
459 {
460 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_EXCEPTION_BUILTIN));
461 }
462
GlobalFloatBuiltinType()463 Type *GlobalTypesHolder::GlobalFloatBuiltinType()
464 {
465 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_FLOAT_BUILTIN));
466 }
467
GlobalFloatingBuiltinType()468 Type *GlobalTypesHolder::GlobalFloatingBuiltinType()
469 {
470 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_FLOATING_BUILTIN));
471 }
472
GlobalIntegerBuiltinType()473 Type *GlobalTypesHolder::GlobalIntegerBuiltinType()
474 {
475 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_INTEGER_BUILTIN));
476 }
477
GlobalIntegralBuiltinType()478 Type *GlobalTypesHolder::GlobalIntegralBuiltinType()
479 {
480 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_INTEGRAL_BUILTIN));
481 }
482
GlobalLongBuiltinType()483 Type *GlobalTypesHolder::GlobalLongBuiltinType()
484 {
485 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_LONG_BUILTIN));
486 }
487
GlobalMapBuiltinType()488 Type *GlobalTypesHolder::GlobalMapBuiltinType()
489 {
490 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_MAP_BUILTIN));
491 }
492
GlobalErrorBuiltinType()493 Type *GlobalTypesHolder::GlobalErrorBuiltinType()
494 {
495 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_ERROR_BUILTIN));
496 }
497
GlobalRuntimeBuiltinType()498 Type *GlobalTypesHolder::GlobalRuntimeBuiltinType()
499 {
500 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_RUNTIME_BUILTIN));
501 }
502
GlobalSetBuiltinType()503 Type *GlobalTypesHolder::GlobalSetBuiltinType()
504 {
505 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_SET_BUILTIN));
506 }
507
GlobalShortBuiltinType()508 Type *GlobalTypesHolder::GlobalShortBuiltinType()
509 {
510 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_SHORT_BUILTIN));
511 }
512
GlobalStackTraceElementBuiltinType()513 Type *GlobalTypesHolder::GlobalStackTraceElementBuiltinType()
514 {
515 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_STACK_TRACE_ELEMENT_BUILTIN));
516 }
517
GlobalStackTraceBuiltinType()518 Type *GlobalTypesHolder::GlobalStackTraceBuiltinType()
519 {
520 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_STACK_TRACE_BUILTIN));
521 }
522
GlobalNullPointerExceptionBuiltinType()523 Type *GlobalTypesHolder::GlobalNullPointerExceptionBuiltinType()
524 {
525 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_NULL_POINTER_EXCEPTION_BUILTIN));
526 }
527
GlobalArrayIndexOutOfBoundsErrorBuiltinType()528 Type *GlobalTypesHolder::GlobalArrayIndexOutOfBoundsErrorBuiltinType()
529 {
530 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_ARRAY_INDEX_OUT_OF_BOUNDS_ERROR_BUILTIN));
531 }
532
GlobalArithmeticErrorBuiltinType()533 Type *GlobalTypesHolder::GlobalArithmeticErrorBuiltinType()
534 {
535 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_ARITHMETIC_ERROR_BUILTIN));
536 }
537
GlobalClassNotFoundExceptionBuiltinType()538 Type *GlobalTypesHolder::GlobalClassNotFoundExceptionBuiltinType()
539 {
540 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_CLASS_NOT_FOUND_EXCEPTION_BUILTIN));
541 }
542
GlobalClassCastErrorBuiltinType() const543 Type *GlobalTypesHolder::GlobalClassCastErrorBuiltinType() const noexcept
544 {
545 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_CLASS_CAST_ERROR_BUILTIN));
546 }
547
GlobalClassOutOfMemoryErrorBuiltinType()548 Type *GlobalTypesHolder::GlobalClassOutOfMemoryErrorBuiltinType()
549 {
550 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_OUT_OF_MEMORY_ERROR_BUILTIN));
551 }
552
GlobalNoSuchMethodErrorBuiltinType()553 Type *GlobalTypesHolder::GlobalNoSuchMethodErrorBuiltinType()
554 {
555 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_NO_SUCH_METHOD_ERROR_BUILTIN));
556 }
557
GlobalAssertionErrorBuiltinType()558 Type *GlobalTypesHolder::GlobalAssertionErrorBuiltinType()
559 {
560 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_ASSERTION_ERROR_BUILTIN));
561 }
562
GlobalDivideByZeroErrorBuiltinType()563 Type *GlobalTypesHolder::GlobalDivideByZeroErrorBuiltinType()
564 {
565 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_DIVIDE_BY_ZERO_ERROR_BUILTIN));
566 }
567
GlobalNullPointerErrorBuiltinType()568 Type *GlobalTypesHolder::GlobalNullPointerErrorBuiltinType()
569 {
570 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_NULL_POINTER_ERROR_BUILTIN));
571 }
572
GlobalUncaughtExceptionErrorBuiltinType()573 Type *GlobalTypesHolder::GlobalUncaughtExceptionErrorBuiltinType()
574 {
575 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_UNCAUGHT_EXCEPTION_ERROR_BUILTIN));
576 }
577
GlobalETSStringBuiltinType()578 Type *GlobalTypesHolder::GlobalETSStringBuiltinType()
579 {
580 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_STRING_BUILTIN));
581 }
582
GlobalETSBigIntBuiltinType()583 Type *GlobalTypesHolder::GlobalETSBigIntBuiltinType()
584 {
585 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BIG_INT_BUILTIN));
586 }
587
GlobalETSBigIntLiteralType()588 Type *GlobalTypesHolder::GlobalETSBigIntLiteralType()
589 {
590 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BIG_INT));
591 }
592
GlobalStringBuilderBuiltinType()593 Type *GlobalTypesHolder::GlobalStringBuilderBuiltinType()
594 {
595 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_STRING_BUILDER_BUILTIN));
596 }
597
GlobalTypeBuiltinType()598 Type *GlobalTypesHolder::GlobalTypeBuiltinType()
599 {
600 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_TYPE_BUILTIN));
601 }
602
GlobalTypesBuiltinType()603 Type *GlobalTypesHolder::GlobalTypesBuiltinType()
604 {
605 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_TYPES_BUILTIN));
606 }
607
GlobalPromiseBuiltinType()608 Type *GlobalTypesHolder::GlobalPromiseBuiltinType()
609 {
610 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_PROMISE_BUILTIN));
611 }
612
GlobalRegExpBuiltinType()613 Type *GlobalTypesHolder::GlobalRegExpBuiltinType()
614 {
615 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_REGEXP_BUILTIN));
616 }
617
GlobalArrayBuiltinType()618 Type *GlobalTypesHolder::GlobalArrayBuiltinType()
619 {
620 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_ARRAY_BUILTIN));
621 }
622
GlobalBoxBuiltinType()623 Type *GlobalTypesHolder::GlobalBoxBuiltinType()
624 {
625 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BOX_BUILTIN));
626 }
627
GlobalJSRuntimeBuiltinType()628 Type *GlobalTypesHolder::GlobalJSRuntimeBuiltinType()
629 {
630 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_INTEROP_JSRUNTIME_BUILTIN));
631 }
632
GlobalJSValueBuiltinType()633 Type *GlobalTypesHolder::GlobalJSValueBuiltinType()
634 {
635 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_INTEROP_JSVALUE_BUILTIN));
636 }
637
GlobalBooleanBoxBuiltinType()638 Type *GlobalTypesHolder::GlobalBooleanBoxBuiltinType()
639 {
640 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BOOLEAN_BOX_BUILTIN));
641 }
642
GlobalByteBoxBuiltinType()643 Type *GlobalTypesHolder::GlobalByteBoxBuiltinType()
644 {
645 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BYTE_BOX_BUILTIN));
646 }
647
GlobalCharBoxBuiltinType()648 Type *GlobalTypesHolder::GlobalCharBoxBuiltinType()
649 {
650 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_CHAR_BOX_BUILTIN));
651 }
652
GlobalShortBoxBuiltinType()653 Type *GlobalTypesHolder::GlobalShortBoxBuiltinType()
654 {
655 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_SHORT_BOX_BUILTIN));
656 }
657
GlobalIntBoxBuiltinType()658 Type *GlobalTypesHolder::GlobalIntBoxBuiltinType()
659 {
660 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_INT_BOX_BUILTIN));
661 }
662
GlobalLongBoxBuiltinType()663 Type *GlobalTypesHolder::GlobalLongBoxBuiltinType()
664 {
665 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_LONG_BOX_BUILTIN));
666 }
667
GlobalFloatBoxBuiltinType()668 Type *GlobalTypesHolder::GlobalFloatBoxBuiltinType()
669 {
670 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_FLOAT_BOX_BUILTIN));
671 }
672
GlobalDoubleBoxBuiltinType()673 Type *GlobalTypesHolder::GlobalDoubleBoxBuiltinType()
674 {
675 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_DOUBLE_BOX_BUILTIN));
676 }
677
VariadicFunctionTypeThreshold()678 size_t GlobalTypesHolder::VariadicFunctionTypeThreshold()
679 {
680 auto val =
681 static_cast<size_t>(GlobalTypeId::ETS_FUNCTIONN_CLASS) - static_cast<size_t>(GlobalTypeId::ETS_FUNCTION0_CLASS);
682 ASSERT(val == (static_cast<size_t>(GlobalTypeId::ETS_THROWING_FUNCTIONN_CLASS) -
683 static_cast<size_t>(GlobalTypeId::ETS_THROWING_FUNCTION0_CLASS)));
684 ASSERT(val == (static_cast<size_t>(GlobalTypeId::ETS_RETHROWING_FUNCTIONN_CLASS) -
685 static_cast<size_t>(GlobalTypeId::ETS_RETHROWING_FUNCTION0_CLASS)));
686 return val;
687 }
688
GlobalFunctionBuiltinType(size_t nargs,ir::ScriptFunctionFlags flags)689 Type *GlobalTypesHolder::GlobalFunctionBuiltinType(size_t nargs, ir::ScriptFunctionFlags flags)
690 {
691 Type *type = globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_FUNCTION0_CLASS) + nargs);
692
693 if (nargs >= VariadicFunctionTypeThreshold()) {
694 if ((flags & ir::ScriptFunctionFlags::THROWS) != 0U) {
695 type = globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_THROWING_FUNCTIONN_CLASS));
696 } else if ((flags & ir::ScriptFunctionFlags::RETHROWS) != 0U) {
697 type = globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_RETHROWING_FUNCTIONN_CLASS));
698 } else {
699 type = globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_FUNCTIONN_CLASS));
700 }
701 } else if ((flags & ir::ScriptFunctionFlags::THROWS) != 0U) {
702 type = globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_THROWING_FUNCTION0_CLASS) + nargs);
703 } else if ((flags & ir::ScriptFunctionFlags::RETHROWS) != 0U) {
704 type = globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_RETHROWING_FUNCTION0_CLASS) + nargs);
705 }
706
707 return type;
708 }
709
GlobalTypeError()710 Type *GlobalTypesHolder::GlobalTypeError()
711 {
712 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::TYPE_ERROR));
713 }
714
InitializeBuiltin(const util::StringView name,Type * type)715 void GlobalTypesHolder::InitializeBuiltin(const util::StringView name, Type *type)
716 {
717 const auto typeId = builtinNameMappings_.find(name);
718 if (typeId == builtinNameMappings_.end()) {
719 util::Helpers::LogDebug("Did not find '", name, "' builtin in GlobalTypesHolder, it should be added.");
720 return;
721 }
722 globalTypes_.at(static_cast<size_t>(typeId->second)) = type;
723 }
724 } // namespace ark::es2panda::checker
725