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/ts/numberType.h"
19 #include "checker/types/ts/anyType.h"
20 #include "checker/types/ts/stringType.h"
21 #include "checker/types/ts/booleanType.h"
22 #include "checker/types/ts/voidType.h"
23 #include "checker/types/ts/nullType.h"
24 #include "checker/types/ts/undefinedType.h"
25 #include "checker/types/ts/unknownType.h"
26 #include "checker/types/ts/neverType.h"
27 #include "checker/types/ts/nonPrimitiveType.h"
28 #include "checker/types/ts/bigintType.h"
29 #include "checker/types/ts/booleanLiteralType.h"
30 #include "checker/types/ts/bigintLiteralType.h"
31 #include "checker/types/ts/numberLiteralType.h"
32 #include "checker/types/ts/stringLiteralType.h"
33 #include "checker/types/ts/tupleType.h"
34 #include "checker/types/ts/objectLiteralType.h"
35 #include "checker/types/ts/unionType.h"
36 #include "checker/types/ets/byteType.h"
37 #include "checker/types/ets/charType.h"
38 #include "checker/types/ets/doubleType.h"
39 #include "checker/types/ets/floatType.h"
40 #include "checker/types/ets/intType.h"
41 #include "checker/types/ets/longType.h"
42 #include "checker/types/ets/shortType.h"
43 #include "checker/types/ets/etsBooleanType.h"
44 #include "checker/types/ets/etsStringType.h"
45 #include "checker/types/ets/etsBigIntType.h"
46 #include "checker/types/ets/etsVoidType.h"
47 #include "checker/types/ets/etsObjectType.h"
48 #include "checker/types/ets/wildcardType.h"
49 #include "util/helpers.h"
50
51 namespace panda::es2panda::checker {
GlobalTypesHolder(ArenaAllocator * allocator)52 GlobalTypesHolder::GlobalTypesHolder(ArenaAllocator *allocator) : builtinNameMappings_(allocator->Adapter())
53 {
54 // TS specific types
55 globalTypes_[static_cast<size_t>(GlobalTypeId::NUMBER)] = allocator->New<NumberType>();
56 globalTypes_[static_cast<size_t>(GlobalTypeId::ANY)] = allocator->New<AnyType>();
57 globalTypes_[static_cast<size_t>(GlobalTypeId::STRING)] = allocator->New<StringType>();
58 globalTypes_[static_cast<size_t>(GlobalTypeId::BOOLEAN)] = allocator->New<BooleanType>();
59 globalTypes_[static_cast<size_t>(GlobalTypeId::VOID)] = allocator->New<VoidType>();
60 globalTypes_[static_cast<size_t>(GlobalTypeId::NULL_ID)] = allocator->New<NullType>();
61 globalTypes_[static_cast<size_t>(GlobalTypeId::UNDEFINED)] = allocator->New<UndefinedType>();
62 globalTypes_[static_cast<size_t>(GlobalTypeId::UNKNOWN)] = allocator->New<UnknownType>();
63 globalTypes_[static_cast<size_t>(GlobalTypeId::NEVER)] = allocator->New<NeverType>();
64 globalTypes_[static_cast<size_t>(GlobalTypeId::NON_PRIMITIVE)] = allocator->New<NonPrimitiveType>();
65 globalTypes_[static_cast<size_t>(GlobalTypeId::BIGINT)] = allocator->New<BigintType>();
66 globalTypes_[static_cast<size_t>(GlobalTypeId::FALSE_ID)] = allocator->New<BooleanLiteralType>(false);
67 globalTypes_[static_cast<size_t>(GlobalTypeId::TRUE_ID)] = allocator->New<BooleanLiteralType>(true);
68 globalTypes_[static_cast<size_t>(GlobalTypeId::NUMBER_OR_BIGINT)] =
69 allocator->New<UnionType>(allocator, std::initializer_list<Type *> {GlobalNumberType(), GlobalBigintType()});
70 globalTypes_[static_cast<size_t>(GlobalTypeId::STRING_OR_NUMBER)] =
71 allocator->New<UnionType>(allocator, std::initializer_list<Type *> {GlobalStringType(), GlobalNumberType()});
72 globalTypes_[static_cast<size_t>(GlobalTypeId::ZERO)] = allocator->New<NumberLiteralType>(0);
73 globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_STRING)] = allocator->New<StringLiteralType>("");
74 globalTypes_[static_cast<size_t>(GlobalTypeId::ZERO_BIGINT)] = allocator->New<BigintLiteralType>("0n", false);
75 globalTypes_[static_cast<size_t>(GlobalTypeId::PRIMITIVE)] = allocator->New<UnionType>(
76 allocator,
77 std::initializer_list<Type *> {GlobalNumberType(), GlobalStringType(), GlobalBigintType(), GlobalBooleanType(),
78 GlobalVoidType(), GlobalUndefinedType(), GlobalNullType()});
79 globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_TUPLE)] = allocator->New<TupleType>(allocator);
80 globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_OBJECT)] = allocator->New<ObjectLiteralType>();
81 globalTypes_[static_cast<size_t>(GlobalTypeId::RESOLVING_RETURN_TYPE)] = allocator->New<AnyType>();
82 globalTypes_[static_cast<size_t>(GlobalTypeId::ERROR_TYPE)] = allocator->New<AnyType>();
83
84 // ETS specific types
85 globalTypes_[static_cast<size_t>(GlobalTypeId::BYTE)] = allocator->New<ByteType>();
86 globalTypes_[static_cast<size_t>(GlobalTypeId::SHORT)] = allocator->New<ShortType>();
87 globalTypes_[static_cast<size_t>(GlobalTypeId::INT)] = allocator->New<IntType>();
88 globalTypes_[static_cast<size_t>(GlobalTypeId::LONG)] = allocator->New<LongType>();
89 globalTypes_[static_cast<size_t>(GlobalTypeId::FLOAT)] = allocator->New<FloatType>();
90 globalTypes_[static_cast<size_t>(GlobalTypeId::DOUBLE)] = allocator->New<DoubleType>();
91 globalTypes_[static_cast<size_t>(GlobalTypeId::CHAR)] = allocator->New<CharType>();
92 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_BOOLEAN)] = allocator->New<ETSBooleanType>();
93 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_VOID)] = allocator->New<ETSVoidType>();
94 auto *globalNullType = allocator->New<ETSObjectType>(allocator);
95 globalNullType->AsETSObjectType()->AddObjectFlag(ETSObjectFlags::NULL_TYPE);
96 globalNullType->AsETSObjectType()->SetName("null");
97 globalNullType->AsETSObjectType()->SetAssemblerName("null has no symbol!");
98 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_NULL)] = globalNullType;
99 auto *globalUndefinedType = allocator->New<ETSObjectType>(allocator);
100 globalUndefinedType->AsETSObjectType()->AddObjectFlag(ETSObjectFlags::UNDEFINED_TYPE);
101 globalUndefinedType->AsETSObjectType()->SetName("undefined");
102 globalUndefinedType->AsETSObjectType()->SetAssemblerName("undefined has no symbol!");
103 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_UNDEFINED)] = globalUndefinedType;
104 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_WILDCARD)] = allocator->New<WildcardType>();
105
106 builtinNameMappings_.emplace("Boolean", GlobalTypeId::ETS_BOOLEAN_BUILTIN);
107 builtinNameMappings_.emplace("Byte", GlobalTypeId::ETS_BYTE_BUILTIN);
108 builtinNameMappings_.emplace("Char", GlobalTypeId::ETS_CHAR_BUILTIN);
109 builtinNameMappings_.emplace("Comparable", GlobalTypeId::ETS_COMPARABLE_BUILTIN);
110 builtinNameMappings_.emplace("Console", GlobalTypeId::ETS_CONSOLE_BUILTIN);
111 builtinNameMappings_.emplace("Double", GlobalTypeId::ETS_DOUBLE_BUILTIN);
112 builtinNameMappings_.emplace("Exception", GlobalTypeId::ETS_EXCEPTION_BUILTIN);
113 builtinNameMappings_.emplace("Float", GlobalTypeId::ETS_FLOAT_BUILTIN);
114 builtinNameMappings_.emplace("Floating", GlobalTypeId::ETS_FLOATING_BUILTIN);
115 builtinNameMappings_.emplace("Int", GlobalTypeId::ETS_INTEGER_BUILTIN);
116 builtinNameMappings_.emplace("Integral", GlobalTypeId::ETS_INTEGRAL_BUILTIN);
117 builtinNameMappings_.emplace("Long", GlobalTypeId::ETS_LONG_BUILTIN);
118 builtinNameMappings_.emplace("Object", GlobalTypeId::ETS_OBJECT_BUILTIN);
119 builtinNameMappings_.emplace("Runtime", GlobalTypeId::ETS_RUNTIME_BUILTIN);
120 builtinNameMappings_.emplace("Short", GlobalTypeId::ETS_SHORT_BUILTIN);
121 builtinNameMappings_.emplace("StackTraceElement", GlobalTypeId::ETS_STACK_TRACE_ELEMENT_BUILTIN);
122 builtinNameMappings_.emplace("StackTrace", GlobalTypeId::ETS_STACK_TRACE_BUILTIN);
123 builtinNameMappings_.emplace("NullPointerException", GlobalTypeId::ETS_NULL_POINTER_EXCEPTION_BUILTIN);
124 builtinNameMappings_.emplace("ArrayIndexOutOfBoundsException",
125 GlobalTypeId::ETS_ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION_BUILTIN);
126 builtinNameMappings_.emplace("ArithmeticException", GlobalTypeId::ETS_ARITHMETIC_EXCEPTION_BUILTIN);
127 builtinNameMappings_.emplace("ClassNotFoundException", GlobalTypeId::ETS_CLASS_NOT_FOUND_EXCEPTION_BUILTIN);
128 builtinNameMappings_.emplace("ClassCastException", GlobalTypeId::ETS_CLASS_CAST_EXCEPTION_BUILTIN);
129 builtinNameMappings_.emplace("String", GlobalTypeId::ETS_STRING_BUILTIN);
130 builtinNameMappings_.emplace("BigInt", GlobalTypeId::ETS_BIG_INT_BUILTIN);
131 builtinNameMappings_.emplace("StringBuilder", GlobalTypeId::ETS_STRING_BUILDER_BUILTIN);
132 builtinNameMappings_.emplace("Type", GlobalTypeId::ETS_TYPE_BUILTIN);
133 builtinNameMappings_.emplace("Types", GlobalTypeId::ETS_TYPES_BUILTIN);
134 builtinNameMappings_.emplace("Promise", GlobalTypeId::ETS_PROMISE_BUILTIN);
135 builtinNameMappings_.emplace("Box", GlobalTypeId::ETS_BOX_BUILTIN);
136 builtinNameMappings_.emplace("BooleanBox", GlobalTypeId::ETS_BOOLEAN_BOX_BUILTIN);
137 builtinNameMappings_.emplace("ByteBox", GlobalTypeId::ETS_BYTE_BOX_BUILTIN);
138 builtinNameMappings_.emplace("CharBox", GlobalTypeId::ETS_CHAR_BOX_BUILTIN);
139 builtinNameMappings_.emplace("ShortBox", GlobalTypeId::ETS_SHORT_BOX_BUILTIN);
140 builtinNameMappings_.emplace("IntBox", GlobalTypeId::ETS_INT_BOX_BUILTIN);
141 builtinNameMappings_.emplace("LongBox", GlobalTypeId::ETS_LONG_BOX_BUILTIN);
142 builtinNameMappings_.emplace("FloatBox", GlobalTypeId::ETS_FLOAT_BOX_BUILTIN);
143 builtinNameMappings_.emplace("DoubleBox", GlobalTypeId::ETS_DOUBLE_BOX_BUILTIN);
144 builtinNameMappings_.emplace("void", GlobalTypeId::ETS_VOID_BUILTIN);
145 builtinNameMappings_.emplace("never", GlobalTypeId::ETS_NEVER_BUILTIN);
146
147 // ETS escompat layer
148 builtinNameMappings_.emplace("Array", GlobalTypeId::ETS_ARRAY_BUILTIN);
149 builtinNameMappings_.emplace("Date", GlobalTypeId::ETS_DATE_BUILTIN);
150 builtinNameMappings_.emplace("Error", GlobalTypeId::ETS_ERROR_BUILTIN);
151 builtinNameMappings_.emplace("OutOfMemoryError", GlobalTypeId::ETS_OUT_OF_MEMORY_ERROR_BUILTIN);
152 builtinNameMappings_.emplace("NoSuchMethodError", GlobalTypeId::ETS_NO_SUCH_METHOD_ERROR_BUILTIN);
153 builtinNameMappings_.emplace("AssertionError", GlobalTypeId::ETS_ASSERTION_ERROR_BUILTIN);
154 builtinNameMappings_.emplace("DivideByZeroError", GlobalTypeId::ETS_DIVIDE_BY_ZERO_ERROR_BUILTIN);
155 builtinNameMappings_.emplace("NullPointerError", GlobalTypeId::ETS_NULL_POINTER_ERROR_BUILTIN);
156 builtinNameMappings_.emplace("UncatchedExceptionError", GlobalTypeId::ETS_UNCATCHED_EXCEPTION_ERROR_BUILTIN);
157 builtinNameMappings_.emplace("Map", GlobalTypeId::ETS_MAP_BUILTIN);
158 builtinNameMappings_.emplace("RegExp", GlobalTypeId::ETS_REGEXP_BUILTIN);
159 builtinNameMappings_.emplace("Set", GlobalTypeId::ETS_SET_BUILTIN);
160
161 // ETS interop js specific types
162 builtinNameMappings_.emplace("JSRuntime", GlobalTypeId::ETS_INTEROP_JSRUNTIME_BUILTIN);
163 builtinNameMappings_.emplace("JSValue", GlobalTypeId::ETS_INTEROP_JSVALUE_BUILTIN);
164 }
165
GlobalNumberType()166 Type *GlobalTypesHolder::GlobalNumberType()
167 {
168 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NUMBER));
169 }
170
GlobalAnyType()171 Type *GlobalTypesHolder::GlobalAnyType()
172 {
173 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ANY));
174 }
175
GlobalStringType()176 Type *GlobalTypesHolder::GlobalStringType()
177 {
178 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::STRING));
179 }
180
GlobalBooleanType()181 Type *GlobalTypesHolder::GlobalBooleanType()
182 {
183 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::BOOLEAN));
184 }
185
GlobalVoidType()186 Type *GlobalTypesHolder::GlobalVoidType()
187 {
188 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::VOID));
189 }
190
GlobalNullType()191 Type *GlobalTypesHolder::GlobalNullType()
192 {
193 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NULL_ID));
194 }
195
GlobalUndefinedType()196 Type *GlobalTypesHolder::GlobalUndefinedType()
197 {
198 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::UNDEFINED));
199 }
200
GlobalUnknownType()201 Type *GlobalTypesHolder::GlobalUnknownType()
202 {
203 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::UNKNOWN));
204 }
205
GlobalNeverType()206 Type *GlobalTypesHolder::GlobalNeverType()
207 {
208 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NEVER));
209 }
210
GlobalNonPrimitiveType()211 Type *GlobalTypesHolder::GlobalNonPrimitiveType()
212 {
213 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NON_PRIMITIVE));
214 }
215
GlobalBigintType()216 Type *GlobalTypesHolder::GlobalBigintType()
217 {
218 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::BIGINT));
219 }
220
GlobalFalseType()221 Type *GlobalTypesHolder::GlobalFalseType()
222 {
223 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::FALSE_ID));
224 }
225
GlobalTrueType()226 Type *GlobalTypesHolder::GlobalTrueType()
227 {
228 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::TRUE_ID));
229 }
230
GlobalNumberOrBigintType()231 Type *GlobalTypesHolder::GlobalNumberOrBigintType()
232 {
233 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NUMBER_OR_BIGINT));
234 }
235
GlobalStringOrNumberType()236 Type *GlobalTypesHolder::GlobalStringOrNumberType()
237 {
238 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::STRING_OR_NUMBER));
239 }
240
GlobalZeroType()241 Type *GlobalTypesHolder::GlobalZeroType()
242 {
243 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ZERO));
244 }
245
GlobalEmptyStringType()246 Type *GlobalTypesHolder::GlobalEmptyStringType()
247 {
248 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_STRING));
249 }
250
GlobalZeroBigintType()251 Type *GlobalTypesHolder::GlobalZeroBigintType()
252 {
253 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ZERO_BIGINT));
254 }
255
GlobalPrimitiveType()256 Type *GlobalTypesHolder::GlobalPrimitiveType()
257 {
258 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::PRIMITIVE));
259 }
260
GlobalEmptyTupleType()261 Type *GlobalTypesHolder::GlobalEmptyTupleType()
262 {
263 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_TUPLE));
264 }
265
GlobalEmptyObjectType()266 Type *GlobalTypesHolder::GlobalEmptyObjectType()
267 {
268 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_OBJECT));
269 }
270
GlobalResolvingReturnType()271 Type *GlobalTypesHolder::GlobalResolvingReturnType()
272 {
273 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::RESOLVING_RETURN_TYPE));
274 }
275
GlobalErrorType()276 Type *GlobalTypesHolder::GlobalErrorType()
277 {
278 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ERROR_TYPE));
279 }
280
GlobalByteType()281 Type *GlobalTypesHolder::GlobalByteType()
282 {
283 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::BYTE));
284 }
285
GlobalShortType()286 Type *GlobalTypesHolder::GlobalShortType()
287 {
288 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::SHORT));
289 }
290
GlobalIntType()291 Type *GlobalTypesHolder::GlobalIntType()
292 {
293 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::INT));
294 }
295
GlobalLongType()296 Type *GlobalTypesHolder::GlobalLongType()
297 {
298 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::LONG));
299 }
300
GlobalFloatType()301 Type *GlobalTypesHolder::GlobalFloatType()
302 {
303 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::FLOAT));
304 }
305
GlobalDoubleType()306 Type *GlobalTypesHolder::GlobalDoubleType()
307 {
308 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::DOUBLE));
309 }
310
GlobalCharType()311 Type *GlobalTypesHolder::GlobalCharType()
312 {
313 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::CHAR));
314 }
315
GlobalETSBooleanType()316 Type *GlobalTypesHolder::GlobalETSBooleanType()
317 {
318 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BOOLEAN));
319 }
320
GlobalETSStringLiteralType()321 Type *GlobalTypesHolder::GlobalETSStringLiteralType()
322 {
323 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_STRING));
324 }
325
GlobalETSVoidType()326 Type *GlobalTypesHolder::GlobalETSVoidType()
327 {
328 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_VOID));
329 }
330
GlobalBuiltinVoidType()331 Type *GlobalTypesHolder::GlobalBuiltinVoidType()
332 {
333 return globalTypes_.at(static_cast<std::size_t>(GlobalTypeId::ETS_VOID_BUILTIN));
334 }
335
GlobalETSObjectType()336 Type *GlobalTypesHolder::GlobalETSObjectType()
337 {
338 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_OBJECT_BUILTIN));
339 }
340
GlobalETSNullType()341 Type *GlobalTypesHolder::GlobalETSNullType()
342 {
343 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_NULL));
344 }
345
GlobalETSUndefinedType()346 Type *GlobalTypesHolder::GlobalETSUndefinedType()
347 {
348 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_UNDEFINED));
349 }
350
GlobalETSNullishObjectType()351 Type *GlobalTypesHolder::GlobalETSNullishObjectType()
352 {
353 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_NULLISH_OBJECT));
354 }
355
GlobalWildcardType()356 Type *GlobalTypesHolder::GlobalWildcardType()
357 {
358 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_WILDCARD));
359 }
360
GlobalETSBooleanBuiltinType()361 Type *GlobalTypesHolder::GlobalETSBooleanBuiltinType()
362 {
363 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BOOLEAN_BUILTIN));
364 }
365
GlobalByteBuiltinType()366 Type *GlobalTypesHolder::GlobalByteBuiltinType()
367 {
368 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BYTE_BUILTIN));
369 }
370
GlobalCharBuiltinType()371 Type *GlobalTypesHolder::GlobalCharBuiltinType()
372 {
373 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_CHAR_BUILTIN));
374 }
375
GlobalComparableBuiltinType()376 Type *GlobalTypesHolder::GlobalComparableBuiltinType()
377 {
378 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_COMPARABLE_BUILTIN));
379 }
380
GlobalConsoleBuiltinType()381 Type *GlobalTypesHolder::GlobalConsoleBuiltinType()
382 {
383 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_CONSOLE_BUILTIN));
384 }
385
GlobalDoubleBuiltinType()386 Type *GlobalTypesHolder::GlobalDoubleBuiltinType()
387 {
388 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_DOUBLE_BUILTIN));
389 }
390
GlobalExceptionBuiltinType()391 Type *GlobalTypesHolder::GlobalExceptionBuiltinType()
392 {
393 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_EXCEPTION_BUILTIN));
394 }
395
GlobalFloatBuiltinType()396 Type *GlobalTypesHolder::GlobalFloatBuiltinType()
397 {
398 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_FLOAT_BUILTIN));
399 }
400
GlobalFloatingBuiltinType()401 Type *GlobalTypesHolder::GlobalFloatingBuiltinType()
402 {
403 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_FLOATING_BUILTIN));
404 }
405
GlobalIntegerBuiltinType()406 Type *GlobalTypesHolder::GlobalIntegerBuiltinType()
407 {
408 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_INTEGER_BUILTIN));
409 }
410
GlobalIntegralBuiltinType()411 Type *GlobalTypesHolder::GlobalIntegralBuiltinType()
412 {
413 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_INTEGRAL_BUILTIN));
414 }
415
GlobalLongBuiltinType()416 Type *GlobalTypesHolder::GlobalLongBuiltinType()
417 {
418 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_LONG_BUILTIN));
419 }
420
GlobalMapBuiltinType()421 Type *GlobalTypesHolder::GlobalMapBuiltinType()
422 {
423 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_MAP_BUILTIN));
424 }
425
GlobalErrorBuiltinType()426 Type *GlobalTypesHolder::GlobalErrorBuiltinType()
427 {
428 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_ERROR_BUILTIN));
429 }
430
GlobalRuntimeBuiltinType()431 Type *GlobalTypesHolder::GlobalRuntimeBuiltinType()
432 {
433 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_RUNTIME_BUILTIN));
434 }
435
GlobalSetBuiltinType()436 Type *GlobalTypesHolder::GlobalSetBuiltinType()
437 {
438 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_SET_BUILTIN));
439 }
440
GlobalShortBuiltinType()441 Type *GlobalTypesHolder::GlobalShortBuiltinType()
442 {
443 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_SHORT_BUILTIN));
444 }
445
GlobalStackTraceElementBuiltinType()446 Type *GlobalTypesHolder::GlobalStackTraceElementBuiltinType()
447 {
448 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_STACK_TRACE_ELEMENT_BUILTIN));
449 }
450
GlobalStackTraceBuiltinType()451 Type *GlobalTypesHolder::GlobalStackTraceBuiltinType()
452 {
453 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_STACK_TRACE_BUILTIN));
454 }
455
GlobalNullPointerExceptionBuiltinType()456 Type *GlobalTypesHolder::GlobalNullPointerExceptionBuiltinType()
457 {
458 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_NULL_POINTER_EXCEPTION_BUILTIN));
459 }
460
GlobalArrayIndexOutOfBoundsExceptionBuiltinType()461 Type *GlobalTypesHolder::GlobalArrayIndexOutOfBoundsExceptionBuiltinType()
462 {
463 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_ARRAY_INDEX_OUT_OF_BOUNDS_EXCEPTION_BUILTIN));
464 }
465
GlobalArithmeticExceptionBuiltinType()466 Type *GlobalTypesHolder::GlobalArithmeticExceptionBuiltinType()
467 {
468 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_ARITHMETIC_EXCEPTION_BUILTIN));
469 }
470
GlobalClassNotFoundExceptionBuiltinType()471 Type *GlobalTypesHolder::GlobalClassNotFoundExceptionBuiltinType()
472 {
473 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_CLASS_NOT_FOUND_EXCEPTION_BUILTIN));
474 }
475
GlobalClassCastExceptionBuiltinType() const476 Type *GlobalTypesHolder::GlobalClassCastExceptionBuiltinType() const noexcept
477 {
478 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_CLASS_CAST_EXCEPTION_BUILTIN));
479 }
480
GlobalClassOutOfMemoryErrorBuiltinType()481 Type *GlobalTypesHolder::GlobalClassOutOfMemoryErrorBuiltinType()
482 {
483 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_OUT_OF_MEMORY_ERROR_BUILTIN));
484 }
485
GlobalNoSuchMethodErrorBuiltinType()486 Type *GlobalTypesHolder::GlobalNoSuchMethodErrorBuiltinType()
487 {
488 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_NO_SUCH_METHOD_ERROR_BUILTIN));
489 }
490
GlobalAssertionErrorBuiltinType()491 Type *GlobalTypesHolder::GlobalAssertionErrorBuiltinType()
492 {
493 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_ASSERTION_ERROR_BUILTIN));
494 }
495
GlobalDivideByZeroErrorBuiltinType()496 Type *GlobalTypesHolder::GlobalDivideByZeroErrorBuiltinType()
497 {
498 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_DIVIDE_BY_ZERO_ERROR_BUILTIN));
499 }
500
GlobalNullPointerErrorBuiltinType()501 Type *GlobalTypesHolder::GlobalNullPointerErrorBuiltinType()
502 {
503 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_NULL_POINTER_ERROR_BUILTIN));
504 }
505
GlobalUncatchedExceptionErrorBuiltinType()506 Type *GlobalTypesHolder::GlobalUncatchedExceptionErrorBuiltinType()
507 {
508 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_UNCATCHED_EXCEPTION_ERROR_BUILTIN));
509 }
510
GlobalETSStringBuiltinType()511 Type *GlobalTypesHolder::GlobalETSStringBuiltinType()
512 {
513 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_STRING_BUILTIN));
514 }
515
GlobalETSBigIntBuiltinType()516 Type *GlobalTypesHolder::GlobalETSBigIntBuiltinType()
517 {
518 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BIG_INT_BUILTIN));
519 }
520
GlobalETSBigIntLiteralType()521 Type *GlobalTypesHolder::GlobalETSBigIntLiteralType()
522 {
523 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BIG_INT));
524 }
525
GlobalStringBuilderBuiltinType()526 Type *GlobalTypesHolder::GlobalStringBuilderBuiltinType()
527 {
528 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_STRING_BUILDER_BUILTIN));
529 }
530
GlobalTypeBuiltinType()531 Type *GlobalTypesHolder::GlobalTypeBuiltinType()
532 {
533 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_TYPE_BUILTIN));
534 }
535
GlobalTypesBuiltinType()536 Type *GlobalTypesHolder::GlobalTypesBuiltinType()
537 {
538 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_TYPES_BUILTIN));
539 }
540
GlobalPromiseBuiltinType()541 Type *GlobalTypesHolder::GlobalPromiseBuiltinType()
542 {
543 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_PROMISE_BUILTIN));
544 }
545
GlobalRegExpBuiltinType()546 Type *GlobalTypesHolder::GlobalRegExpBuiltinType()
547 {
548 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_REGEXP_BUILTIN));
549 }
550
GlobalArrayBuiltinType()551 Type *GlobalTypesHolder::GlobalArrayBuiltinType()
552 {
553 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_ARRAY_BUILTIN));
554 }
555
GlobalBoxBuiltinType()556 Type *GlobalTypesHolder::GlobalBoxBuiltinType()
557 {
558 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BOX_BUILTIN));
559 }
560
GlobalJSRuntimeBuiltinType()561 Type *GlobalTypesHolder::GlobalJSRuntimeBuiltinType()
562 {
563 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_INTEROP_JSRUNTIME_BUILTIN));
564 }
565
GlobalJSValueBuiltinType()566 Type *GlobalTypesHolder::GlobalJSValueBuiltinType()
567 {
568 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_INTEROP_JSVALUE_BUILTIN));
569 }
570
GlobalBooleanBoxBuiltinType()571 Type *GlobalTypesHolder::GlobalBooleanBoxBuiltinType()
572 {
573 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BOOLEAN_BOX_BUILTIN));
574 }
575
GlobalByteBoxBuiltinType()576 Type *GlobalTypesHolder::GlobalByteBoxBuiltinType()
577 {
578 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BYTE_BOX_BUILTIN));
579 }
580
GlobalCharBoxBuiltinType()581 Type *GlobalTypesHolder::GlobalCharBoxBuiltinType()
582 {
583 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_CHAR_BOX_BUILTIN));
584 }
585
GlobalShortBoxBuiltinType()586 Type *GlobalTypesHolder::GlobalShortBoxBuiltinType()
587 {
588 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_SHORT_BOX_BUILTIN));
589 }
590
GlobalIntBoxBuiltinType()591 Type *GlobalTypesHolder::GlobalIntBoxBuiltinType()
592 {
593 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_INT_BOX_BUILTIN));
594 }
595
GlobalLongBoxBuiltinType()596 Type *GlobalTypesHolder::GlobalLongBoxBuiltinType()
597 {
598 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_LONG_BOX_BUILTIN));
599 }
600
GlobalFloatBoxBuiltinType()601 Type *GlobalTypesHolder::GlobalFloatBoxBuiltinType()
602 {
603 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_FLOAT_BOX_BUILTIN));
604 }
605
GlobalDoubleBoxBuiltinType()606 Type *GlobalTypesHolder::GlobalDoubleBoxBuiltinType()
607 {
608 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_DOUBLE_BOX_BUILTIN));
609 }
610
GlobalBuiltinNeverType()611 Type *GlobalTypesHolder::GlobalBuiltinNeverType()
612 {
613 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_NEVER_BUILTIN));
614 }
615
InitializeBuiltin(const util::StringView name,Type * type)616 void GlobalTypesHolder::InitializeBuiltin(const util::StringView name, Type *type)
617 {
618 const auto typeId = builtinNameMappings_.find(name);
619 if (typeId == builtinNameMappings_.end()) {
620 util::Helpers::LogDebug("Did not find '", name, "' builtin in GlobalTypesHolder, it should be added.");
621 return;
622 }
623 globalTypes_.at(static_cast<size_t>(typeId->second)) = type;
624 }
625 } // namespace panda::es2panda::checker
626