1 /**
2 * Copyright (c) 2021-2025 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/etsAnyType.h"
52 #include "checker/types/ets/etsNeverType.h"
53 #include "util/helpers.h"
54
55 namespace ark::es2panda::checker {
56
AddETSEscompatLayer()57 void GlobalTypesHolder::AddETSEscompatLayer()
58 {
59 // ETS escompat layer
60 builtinNameMappings_.emplace("Array", GlobalTypeId::ETS_ARRAY_BUILTIN);
61 builtinNameMappings_.emplace("Date", GlobalTypeId::ETS_DATE_BUILTIN);
62 builtinNameMappings_.emplace("Error", GlobalTypeId::ETS_ERROR_BUILTIN);
63 builtinNameMappings_.emplace("DivideByZeroError", GlobalTypeId::ETS_DIVIDE_BY_ZERO_ERROR_BUILTIN);
64 builtinNameMappings_.emplace("NullPointerError", GlobalTypeId::ETS_NULL_POINTER_ERROR_BUILTIN);
65 builtinNameMappings_.emplace("UncaughtExceptionError", GlobalTypeId::ETS_UNCAUGHT_EXCEPTION_ERROR_BUILTIN);
66 builtinNameMappings_.emplace("Map", GlobalTypeId::ETS_MAP_BUILTIN);
67 builtinNameMappings_.emplace("Record", GlobalTypeId::ETS_RECORD_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 auto addTypes = [this, allocator](const std::string &name, GlobalTypeId from, GlobalTypeId to) {
75 for (size_t id = static_cast<size_t>(from), nargs = 0; id <= static_cast<size_t>(to); id++, nargs++) {
76 builtinNameMappings_.emplace(util::UString(name, allocator).Append(std::to_string(nargs)).View(),
77 static_cast<GlobalTypeId>(id));
78 }
79 };
80
81 addTypes("Function", GlobalTypeId::ETS_FUNCTION0_CLASS, GlobalTypeId::ETS_FUNCTION16_CLASS);
82 addTypes("Lambda", GlobalTypeId::ETS_LAMBDA0_CLASS, GlobalTypeId::ETS_LAMBDA16_CLASS);
83
84 addTypes("FunctionR", GlobalTypeId::ETS_FUNCTIONR0_CLASS, GlobalTypeId::ETS_FUNCTIONR16_CLASS);
85 addTypes("LambdaR", GlobalTypeId::ETS_LAMBDAR0_CLASS, GlobalTypeId::ETS_LAMBDAR16_CLASS);
86
87 builtinNameMappings_.emplace("FunctionN", GlobalTypeId::ETS_FUNCTIONN_CLASS);
88 builtinNameMappings_.emplace("LambdaN", GlobalTypeId::ETS_FUNCTIONN_CLASS);
89 }
90
AddTupleTypes(ArenaAllocator * allocator)91 void GlobalTypesHolder::AddTupleTypes(ArenaAllocator *allocator)
92 {
93 auto addTypes = [this, allocator](const std::string &name, GlobalTypeId from, GlobalTypeId to) {
94 for (size_t id = static_cast<size_t>(from), nargs = 0; id <= static_cast<size_t>(to); id++, nargs++) {
95 builtinNameMappings_.emplace(util::UString(name + std::to_string(nargs), allocator).View(),
96 static_cast<GlobalTypeId>(id));
97 }
98 };
99
100 addTypes("Tuple", GlobalTypeId::ETS_TUPLE0_CLASS, GlobalTypeId::ETS_TUPLE16_CLASS);
101 builtinNameMappings_.emplace("TupleN", GlobalTypeId::ETS_TUPLEN_CLASS);
102 }
103
AddTSSpecificTypes(ArenaAllocator * allocator)104 void GlobalTypesHolder::AddTSSpecificTypes(ArenaAllocator *allocator)
105 {
106 globalTypes_[static_cast<size_t>(GlobalTypeId::NUMBER)] = allocator->New<NumberType>();
107 globalTypes_[static_cast<size_t>(GlobalTypeId::ANY)] = allocator->New<AnyType>();
108 globalTypes_[static_cast<size_t>(GlobalTypeId::STRING)] = allocator->New<StringType>();
109 globalTypes_[static_cast<size_t>(GlobalTypeId::BOOLEAN)] = allocator->New<BooleanType>();
110 globalTypes_[static_cast<size_t>(GlobalTypeId::VOID)] = allocator->New<VoidType>();
111 globalTypes_[static_cast<size_t>(GlobalTypeId::NULL_ID)] = allocator->New<NullType>();
112 globalTypes_[static_cast<size_t>(GlobalTypeId::UNDEFINED)] = allocator->New<UndefinedType>();
113 globalTypes_[static_cast<size_t>(GlobalTypeId::UNKNOWN)] = allocator->New<UnknownType>();
114 globalTypes_[static_cast<size_t>(GlobalTypeId::NEVER)] = allocator->New<NeverType>();
115 globalTypes_[static_cast<size_t>(GlobalTypeId::NON_PRIMITIVE)] = allocator->New<NonPrimitiveType>();
116 globalTypes_[static_cast<size_t>(GlobalTypeId::BIGINT)] = allocator->New<BigintType>();
117 globalTypes_[static_cast<size_t>(GlobalTypeId::FALSE_ID)] = allocator->New<BooleanLiteralType>(false);
118 globalTypes_[static_cast<size_t>(GlobalTypeId::TRUE_ID)] = allocator->New<BooleanLiteralType>(true);
119 globalTypes_[static_cast<size_t>(GlobalTypeId::NUMBER_OR_BIGINT)] =
120 allocator->New<UnionType>(allocator, std::initializer_list<Type *> {GlobalNumberType(), GlobalBigintType()});
121 globalTypes_[static_cast<size_t>(GlobalTypeId::STRING_OR_NUMBER)] =
122 allocator->New<UnionType>(allocator, std::initializer_list<Type *> {GlobalStringType(), GlobalNumberType()});
123 globalTypes_[static_cast<size_t>(GlobalTypeId::ZERO)] = allocator->New<NumberLiteralType>(0);
124 globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_STRING)] = allocator->New<StringLiteralType>("");
125 globalTypes_[static_cast<size_t>(GlobalTypeId::ZERO_BIGINT)] = allocator->New<BigintLiteralType>("0n", false);
126 globalTypes_[static_cast<size_t>(GlobalTypeId::PRIMITIVE)] = allocator->New<UnionType>(
127 allocator,
128 std::initializer_list<Type *> {GlobalNumberType(), GlobalStringType(), GlobalBigintType(), GlobalBooleanType(),
129 GlobalVoidType(), GlobalUndefinedType(), GlobalNullType()});
130 globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_TUPLE)] = allocator->New<TupleType>(allocator);
131 globalTypes_[static_cast<size_t>(GlobalTypeId::EMPTY_OBJECT)] = allocator->New<ObjectLiteralType>();
132 globalTypes_[static_cast<size_t>(GlobalTypeId::RESOLVING_RETURN_TYPE)] = allocator->New<AnyType>();
133 globalTypes_[static_cast<size_t>(GlobalTypeId::ERROR_TYPE)] = allocator->New<AnyType>();
134 }
135
AddEtsSpecificTypes(ArenaAllocator * allocator)136 void GlobalTypesHolder::AddEtsSpecificTypes(ArenaAllocator *allocator)
137 {
138 // ETS specific types
139 globalTypes_[static_cast<size_t>(GlobalTypeId::BYTE)] = allocator->New<ByteType>();
140 globalTypes_[static_cast<size_t>(GlobalTypeId::SHORT)] = allocator->New<ShortType>();
141 globalTypes_[static_cast<size_t>(GlobalTypeId::INT)] = allocator->New<IntType>();
142 globalTypes_[static_cast<size_t>(GlobalTypeId::LONG)] = allocator->New<LongType>();
143 globalTypes_[static_cast<size_t>(GlobalTypeId::FLOAT)] = allocator->New<FloatType>();
144 globalTypes_[static_cast<size_t>(GlobalTypeId::DOUBLE)] = allocator->New<DoubleType>();
145 globalTypes_[static_cast<size_t>(GlobalTypeId::CHAR)] = allocator->New<CharType>();
146 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_BOOLEAN)] = allocator->New<ETSBooleanType>();
147 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_VOID)] = allocator->New<ETSVoidType>();
148 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_NULL)] = allocator->New<ETSNullType>();
149 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_UNDEFINED)] = allocator->New<ETSUndefinedType>();
150 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_WILDCARD)] = allocator->New<WildcardType>();
151 globalTypes_[static_cast<size_t>(GlobalTypeId::TYPE_ERROR)] = allocator->New<TypeError>();
152 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_ANY)] = allocator->New<ETSAnyType>();
153 globalTypes_[static_cast<size_t>(GlobalTypeId::ETS_NEVER)] = allocator->New<ETSNeverType>();
154 }
155
AddEtsSpecificBuiltinTypes()156 void GlobalTypesHolder::AddEtsSpecificBuiltinTypes()
157 {
158 builtinNameMappings_.emplace("Any", GlobalTypeId::ETS_ANY);
159 builtinNameMappings_.emplace("Boolean", GlobalTypeId::ETS_BOOLEAN_BUILTIN);
160 builtinNameMappings_.emplace("Byte", GlobalTypeId::ETS_BYTE_BUILTIN);
161 builtinNameMappings_.emplace("Char", GlobalTypeId::ETS_CHAR_BUILTIN);
162 builtinNameMappings_.emplace("Comparable", GlobalTypeId::ETS_COMPARABLE_BUILTIN);
163 builtinNameMappings_.emplace("Console", GlobalTypeId::ETS_CONSOLE_BUILTIN);
164 builtinNameMappings_.emplace("Double", GlobalTypeId::ETS_DOUBLE_BUILTIN);
165 builtinNameMappings_.emplace("Exception", GlobalTypeId::ETS_EXCEPTION_BUILTIN);
166 builtinNameMappings_.emplace("Float", GlobalTypeId::ETS_FLOAT_BUILTIN);
167 builtinNameMappings_.emplace("Floating", GlobalTypeId::ETS_FLOATING_BUILTIN);
168 builtinNameMappings_.emplace("Int", GlobalTypeId::ETS_INT_BUILTIN);
169 builtinNameMappings_.emplace("Integral", GlobalTypeId::ETS_INTEGRAL_BUILTIN);
170 builtinNameMappings_.emplace("Long", GlobalTypeId::ETS_LONG_BUILTIN);
171 builtinNameMappings_.emplace("Object", GlobalTypeId::ETS_OBJECT_BUILTIN);
172 builtinNameMappings_.emplace("Runtime", GlobalTypeId::ETS_RUNTIME_BUILTIN);
173 builtinNameMappings_.emplace("RuntimeLinker", GlobalTypeId::ETS_RUNTIME_LINKER_BUILTIN);
174 builtinNameMappings_.emplace("Short", GlobalTypeId::ETS_SHORT_BUILTIN);
175 builtinNameMappings_.emplace("StackTraceElement", GlobalTypeId::ETS_STACK_TRACE_ELEMENT_BUILTIN);
176 builtinNameMappings_.emplace("StackTrace", GlobalTypeId::ETS_STACK_TRACE_BUILTIN);
177 builtinNameMappings_.emplace("ArrayIndexOutOfBoundsError",
178 GlobalTypeId::ETS_ARRAY_INDEX_OUT_OF_BOUNDS_ERROR_BUILTIN);
179 builtinNameMappings_.emplace("ArithmeticError", GlobalTypeId::ETS_ARITHMETIC_ERROR_BUILTIN);
180 builtinNameMappings_.emplace("ClassCastError", GlobalTypeId::ETS_CLASS_CAST_ERROR_BUILTIN);
181 builtinNameMappings_.emplace("String", GlobalTypeId::ETS_STRING_BUILTIN);
182 builtinNameMappings_.emplace("BigInt", GlobalTypeId::ETS_BIG_INT_BUILTIN);
183 builtinNameMappings_.emplace("StringBuilder", GlobalTypeId::ETS_STRING_BUILDER_BUILTIN);
184 builtinNameMappings_.emplace("Type", GlobalTypeId::ETS_TYPE_BUILTIN);
185 builtinNameMappings_.emplace("Types", GlobalTypeId::ETS_TYPES_BUILTIN);
186 builtinNameMappings_.emplace("Promise", GlobalTypeId::ETS_PROMISE_BUILTIN);
187 builtinNameMappings_.emplace("Function", GlobalTypeId::ETS_FUNCTION_BUILTIN);
188 builtinNameMappings_.emplace("Box", GlobalTypeId::ETS_BOX_BUILTIN);
189 builtinNameMappings_.emplace("BooleanBox", GlobalTypeId::ETS_BOOLEAN_BOX_BUILTIN);
190 builtinNameMappings_.emplace("ByteBox", GlobalTypeId::ETS_BYTE_BOX_BUILTIN);
191 builtinNameMappings_.emplace("CharBox", GlobalTypeId::ETS_CHAR_BOX_BUILTIN);
192 builtinNameMappings_.emplace("ShortBox", GlobalTypeId::ETS_SHORT_BOX_BUILTIN);
193 builtinNameMappings_.emplace("IntBox", GlobalTypeId::ETS_INT_BOX_BUILTIN);
194 builtinNameMappings_.emplace("LongBox", GlobalTypeId::ETS_LONG_BOX_BUILTIN);
195 builtinNameMappings_.emplace("FloatBox", GlobalTypeId::ETS_FLOAT_BOX_BUILTIN);
196 builtinNameMappings_.emplace("DoubleBox", GlobalTypeId::ETS_DOUBLE_BOX_BUILTIN);
197 }
198
GlobalTypesHolder(ArenaAllocator * allocator)199 GlobalTypesHolder::GlobalTypesHolder(ArenaAllocator *allocator)
200 : allocator_(allocator),
201 builtinNameMappings_(allocator->Adapter()),
202 extensionGetterMaps_(allocator->Adapter()),
203 extensionSetterMaps_(allocator->Adapter())
204 {
205 // TS specific types
206 AddTSSpecificTypes(allocator);
207
208 // ETS specific types
209 AddEtsSpecificTypes(allocator);
210
211 AddEtsSpecificBuiltinTypes();
212
213 // ETS escompat layer
214 AddETSEscompatLayer();
215
216 builtinNameMappings_.emplace("TYPE ERROR", GlobalTypeId::TYPE_ERROR);
217
218 // Function types
219 AddFunctionTypes(allocator);
220
221 // Tuple types
222 AddTupleTypes(allocator);
223
224 // ETS interop js specific types
225 builtinNameMappings_.emplace("JSRuntime", GlobalTypeId::ETS_INTEROP_JSRUNTIME_BUILTIN);
226 builtinNameMappings_.emplace("JSValue", GlobalTypeId::ETS_INTEROP_JSVALUE_BUILTIN);
227 }
228
GlobalNumberType()229 Type *GlobalTypesHolder::GlobalNumberType()
230 {
231 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NUMBER));
232 }
233
GlobalAnyType()234 Type *GlobalTypesHolder::GlobalAnyType()
235 {
236 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ANY));
237 }
238
GlobalStringType()239 Type *GlobalTypesHolder::GlobalStringType()
240 {
241 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::STRING));
242 }
243
GlobalBooleanType()244 Type *GlobalTypesHolder::GlobalBooleanType()
245 {
246 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::BOOLEAN));
247 }
248
GlobalVoidType()249 Type *GlobalTypesHolder::GlobalVoidType()
250 {
251 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::VOID));
252 }
253
GlobalNullType()254 Type *GlobalTypesHolder::GlobalNullType()
255 {
256 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NULL_ID));
257 }
258
GlobalUndefinedType()259 Type *GlobalTypesHolder::GlobalUndefinedType()
260 {
261 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::UNDEFINED));
262 }
263
GlobalUnknownType()264 Type *GlobalTypesHolder::GlobalUnknownType()
265 {
266 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::UNKNOWN));
267 }
268
GlobalNeverType()269 Type *GlobalTypesHolder::GlobalNeverType()
270 {
271 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NEVER));
272 }
273
GlobalNonPrimitiveType()274 Type *GlobalTypesHolder::GlobalNonPrimitiveType()
275 {
276 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NON_PRIMITIVE));
277 }
278
GlobalBigintType()279 Type *GlobalTypesHolder::GlobalBigintType()
280 {
281 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::BIGINT));
282 }
283
GlobalFalseType()284 Type *GlobalTypesHolder::GlobalFalseType()
285 {
286 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::FALSE_ID));
287 }
288
GlobalTrueType()289 Type *GlobalTypesHolder::GlobalTrueType()
290 {
291 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::TRUE_ID));
292 }
293
GlobalNumberOrBigintType()294 Type *GlobalTypesHolder::GlobalNumberOrBigintType()
295 {
296 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::NUMBER_OR_BIGINT));
297 }
298
GlobalStringOrNumberType()299 Type *GlobalTypesHolder::GlobalStringOrNumberType()
300 {
301 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::STRING_OR_NUMBER));
302 }
303
GlobalZeroType()304 Type *GlobalTypesHolder::GlobalZeroType()
305 {
306 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ZERO));
307 }
308
GlobalEmptyStringType()309 Type *GlobalTypesHolder::GlobalEmptyStringType()
310 {
311 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_STRING));
312 }
313
GlobalZeroBigintType()314 Type *GlobalTypesHolder::GlobalZeroBigintType()
315 {
316 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ZERO_BIGINT));
317 }
318
GlobalPrimitiveType()319 Type *GlobalTypesHolder::GlobalPrimitiveType()
320 {
321 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::PRIMITIVE));
322 }
323
GlobalEmptyTupleType()324 Type *GlobalTypesHolder::GlobalEmptyTupleType()
325 {
326 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_TUPLE));
327 }
328
GlobalEmptyObjectType()329 Type *GlobalTypesHolder::GlobalEmptyObjectType()
330 {
331 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::EMPTY_OBJECT));
332 }
333
GlobalResolvingReturnType()334 Type *GlobalTypesHolder::GlobalResolvingReturnType()
335 {
336 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::RESOLVING_RETURN_TYPE));
337 }
338
GlobalErrorType()339 Type *GlobalTypesHolder::GlobalErrorType()
340 {
341 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ERROR_TYPE));
342 }
343
GlobalByteType()344 Type *GlobalTypesHolder::GlobalByteType()
345 {
346 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::BYTE));
347 }
348
GlobalShortType()349 Type *GlobalTypesHolder::GlobalShortType()
350 {
351 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::SHORT));
352 }
353
GlobalIntType()354 Type *GlobalTypesHolder::GlobalIntType()
355 {
356 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::INT));
357 }
358
GlobalLongType()359 Type *GlobalTypesHolder::GlobalLongType()
360 {
361 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::LONG));
362 }
363
GlobalFloatType()364 Type *GlobalTypesHolder::GlobalFloatType()
365 {
366 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::FLOAT));
367 }
368
GlobalDoubleType()369 Type *GlobalTypesHolder::GlobalDoubleType()
370 {
371 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::DOUBLE));
372 }
373
GlobalCharType()374 Type *GlobalTypesHolder::GlobalCharType()
375 {
376 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::CHAR));
377 }
378
GlobalETSBooleanType()379 Type *GlobalTypesHolder::GlobalETSBooleanType()
380 {
381 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BOOLEAN));
382 }
383
GlobalETSStringLiteralType()384 Type *GlobalTypesHolder::GlobalETSStringLiteralType()
385 {
386 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_STRING));
387 }
388
GlobalETSVoidType()389 Type *GlobalTypesHolder::GlobalETSVoidType()
390 {
391 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_VOID));
392 }
393
GlobalETSObjectType()394 Type *GlobalTypesHolder::GlobalETSObjectType()
395 {
396 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_OBJECT_BUILTIN));
397 }
398
GlobalETSNullType()399 Type *GlobalTypesHolder::GlobalETSNullType()
400 {
401 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_NULL));
402 }
403
GlobalETSUndefinedType()404 Type *GlobalTypesHolder::GlobalETSUndefinedType()
405 {
406 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_UNDEFINED));
407 }
408
GlobalETSAnyType()409 Type *GlobalTypesHolder::GlobalETSAnyType()
410 {
411 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_ANY));
412 }
413
GlobalETSNeverType()414 Type *GlobalTypesHolder::GlobalETSNeverType()
415 {
416 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_NEVER));
417 }
418
GlobalETSUnionUndefinedNullObject()419 Type *GlobalTypesHolder::GlobalETSUnionUndefinedNullObject()
420 {
421 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_UNION_UNDEFINED_NULL_OBJECT));
422 }
423
GlobalETSUnionUndefinedNull()424 Type *GlobalTypesHolder::GlobalETSUnionUndefinedNull()
425 {
426 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_UNION_UNDEFINED_NULL));
427 }
428
GlobalWildcardType()429 Type *GlobalTypesHolder::GlobalWildcardType()
430 {
431 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_WILDCARD));
432 }
433
GlobalETSBooleanBuiltinType()434 Type *GlobalTypesHolder::GlobalETSBooleanBuiltinType()
435 {
436 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BOOLEAN_BUILTIN));
437 }
438
GlobalByteBuiltinType()439 Type *GlobalTypesHolder::GlobalByteBuiltinType()
440 {
441 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BYTE_BUILTIN));
442 }
443
GlobalCharBuiltinType()444 Type *GlobalTypesHolder::GlobalCharBuiltinType()
445 {
446 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_CHAR_BUILTIN));
447 }
448
GlobalComparableBuiltinType()449 Type *GlobalTypesHolder::GlobalComparableBuiltinType()
450 {
451 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_COMPARABLE_BUILTIN));
452 }
453
GlobalConsoleBuiltinType()454 Type *GlobalTypesHolder::GlobalConsoleBuiltinType()
455 {
456 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_CONSOLE_BUILTIN));
457 }
458
GlobalDoubleBuiltinType()459 Type *GlobalTypesHolder::GlobalDoubleBuiltinType()
460 {
461 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_DOUBLE_BUILTIN));
462 }
463
GlobalExceptionBuiltinType()464 Type *GlobalTypesHolder::GlobalExceptionBuiltinType()
465 {
466 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_EXCEPTION_BUILTIN));
467 }
468
GlobalFloatBuiltinType()469 Type *GlobalTypesHolder::GlobalFloatBuiltinType()
470 {
471 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_FLOAT_BUILTIN));
472 }
473
GlobalFloatingBuiltinType()474 Type *GlobalTypesHolder::GlobalFloatingBuiltinType()
475 {
476 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_FLOATING_BUILTIN));
477 }
478
GlobalIntegerBuiltinType()479 Type *GlobalTypesHolder::GlobalIntegerBuiltinType()
480 {
481 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_INT_BUILTIN));
482 }
483
GlobalIntegralBuiltinType()484 Type *GlobalTypesHolder::GlobalIntegralBuiltinType()
485 {
486 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_INTEGRAL_BUILTIN));
487 }
488
GlobalLongBuiltinType()489 Type *GlobalTypesHolder::GlobalLongBuiltinType()
490 {
491 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_LONG_BUILTIN));
492 }
493
GlobalMapBuiltinType()494 Type *GlobalTypesHolder::GlobalMapBuiltinType()
495 {
496 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_MAP_BUILTIN));
497 }
498
GlobalRecordBuiltinType()499 Type *GlobalTypesHolder::GlobalRecordBuiltinType()
500 {
501 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_RECORD_BUILTIN));
502 }
503
GlobalErrorBuiltinType()504 Type *GlobalTypesHolder::GlobalErrorBuiltinType()
505 {
506 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_ERROR_BUILTIN));
507 }
508
GlobalRuntimeBuiltinType()509 Type *GlobalTypesHolder::GlobalRuntimeBuiltinType()
510 {
511 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_RUNTIME_BUILTIN));
512 }
513
GlobalSetBuiltinType()514 Type *GlobalTypesHolder::GlobalSetBuiltinType()
515 {
516 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_SET_BUILTIN));
517 }
518
GlobalShortBuiltinType()519 Type *GlobalTypesHolder::GlobalShortBuiltinType()
520 {
521 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_SHORT_BUILTIN));
522 }
523
GlobalStackTraceElementBuiltinType()524 Type *GlobalTypesHolder::GlobalStackTraceElementBuiltinType()
525 {
526 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_STACK_TRACE_ELEMENT_BUILTIN));
527 }
528
GlobalStackTraceBuiltinType()529 Type *GlobalTypesHolder::GlobalStackTraceBuiltinType()
530 {
531 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_STACK_TRACE_BUILTIN));
532 }
533
GlobalArrayIndexOutOfBoundsErrorBuiltinType()534 Type *GlobalTypesHolder::GlobalArrayIndexOutOfBoundsErrorBuiltinType()
535 {
536 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_ARRAY_INDEX_OUT_OF_BOUNDS_ERROR_BUILTIN));
537 }
538
GlobalArithmeticErrorBuiltinType()539 Type *GlobalTypesHolder::GlobalArithmeticErrorBuiltinType()
540 {
541 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_ARITHMETIC_ERROR_BUILTIN));
542 }
543
GlobalClassCastErrorBuiltinType() const544 Type *GlobalTypesHolder::GlobalClassCastErrorBuiltinType() const noexcept
545 {
546 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_CLASS_CAST_ERROR_BUILTIN));
547 }
548
GlobalAssertionErrorBuiltinType()549 Type *GlobalTypesHolder::GlobalAssertionErrorBuiltinType()
550 {
551 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_ASSERTION_ERROR_BUILTIN));
552 }
553
GlobalDivideByZeroErrorBuiltinType()554 Type *GlobalTypesHolder::GlobalDivideByZeroErrorBuiltinType()
555 {
556 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_DIVIDE_BY_ZERO_ERROR_BUILTIN));
557 }
558
GlobalNullPointerErrorBuiltinType()559 Type *GlobalTypesHolder::GlobalNullPointerErrorBuiltinType()
560 {
561 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_NULL_POINTER_ERROR_BUILTIN));
562 }
563
GlobalUncaughtExceptionErrorBuiltinType()564 Type *GlobalTypesHolder::GlobalUncaughtExceptionErrorBuiltinType()
565 {
566 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_UNCAUGHT_EXCEPTION_ERROR_BUILTIN));
567 }
568
GlobalETSStringBuiltinType()569 Type *GlobalTypesHolder::GlobalETSStringBuiltinType()
570 {
571 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_STRING_BUILTIN));
572 }
573
GlobalETSBigIntBuiltinType()574 Type *GlobalTypesHolder::GlobalETSBigIntBuiltinType()
575 {
576 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BIG_INT_BUILTIN));
577 }
578
GlobalETSBigIntLiteralType()579 Type *GlobalTypesHolder::GlobalETSBigIntLiteralType()
580 {
581 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BIG_INT));
582 }
583
GlobalStringBuilderBuiltinType()584 Type *GlobalTypesHolder::GlobalStringBuilderBuiltinType()
585 {
586 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_STRING_BUILDER_BUILTIN));
587 }
588
GlobalTypeBuiltinType()589 Type *GlobalTypesHolder::GlobalTypeBuiltinType()
590 {
591 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_TYPE_BUILTIN));
592 }
593
GlobalTypesBuiltinType()594 Type *GlobalTypesHolder::GlobalTypesBuiltinType()
595 {
596 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_TYPES_BUILTIN));
597 }
598
GlobalPromiseBuiltinType()599 Type *GlobalTypesHolder::GlobalPromiseBuiltinType()
600 {
601 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_PROMISE_BUILTIN));
602 }
603
GlobalFunctionBuiltinType()604 Type *GlobalTypesHolder::GlobalFunctionBuiltinType()
605 {
606 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_FUNCTION_BUILTIN));
607 }
608
GlobalRegExpBuiltinType()609 Type *GlobalTypesHolder::GlobalRegExpBuiltinType()
610 {
611 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_REGEXP_BUILTIN));
612 }
613
GlobalArrayBuiltinType()614 Type *GlobalTypesHolder::GlobalArrayBuiltinType()
615 {
616 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_ARRAY_BUILTIN));
617 }
618
GlobalBoxBuiltinType()619 Type *GlobalTypesHolder::GlobalBoxBuiltinType()
620 {
621 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BOX_BUILTIN));
622 }
623
GlobalJSRuntimeBuiltinType()624 Type *GlobalTypesHolder::GlobalJSRuntimeBuiltinType()
625 {
626 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_INTEROP_JSRUNTIME_BUILTIN));
627 }
628
GlobalJSValueBuiltinType()629 Type *GlobalTypesHolder::GlobalJSValueBuiltinType()
630 {
631 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_INTEROP_JSVALUE_BUILTIN));
632 }
633
GlobalBooleanBoxBuiltinType()634 Type *GlobalTypesHolder::GlobalBooleanBoxBuiltinType()
635 {
636 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BOOLEAN_BOX_BUILTIN));
637 }
638
GlobalByteBoxBuiltinType()639 Type *GlobalTypesHolder::GlobalByteBoxBuiltinType()
640 {
641 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_BYTE_BOX_BUILTIN));
642 }
643
GlobalCharBoxBuiltinType()644 Type *GlobalTypesHolder::GlobalCharBoxBuiltinType()
645 {
646 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_CHAR_BOX_BUILTIN));
647 }
648
GlobalShortBoxBuiltinType()649 Type *GlobalTypesHolder::GlobalShortBoxBuiltinType()
650 {
651 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_SHORT_BOX_BUILTIN));
652 }
653
GlobalIntBoxBuiltinType()654 Type *GlobalTypesHolder::GlobalIntBoxBuiltinType()
655 {
656 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_INT_BOX_BUILTIN));
657 }
658
GlobalLongBoxBuiltinType()659 Type *GlobalTypesHolder::GlobalLongBoxBuiltinType()
660 {
661 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_LONG_BOX_BUILTIN));
662 }
663
GlobalFloatBoxBuiltinType()664 Type *GlobalTypesHolder::GlobalFloatBoxBuiltinType()
665 {
666 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_FLOAT_BOX_BUILTIN));
667 }
668
GlobalDoubleBoxBuiltinType()669 Type *GlobalTypesHolder::GlobalDoubleBoxBuiltinType()
670 {
671 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_DOUBLE_BOX_BUILTIN));
672 }
673
VariadicFunctionTypeThreshold()674 size_t GlobalTypesHolder::VariadicFunctionTypeThreshold()
675 {
676 return static_cast<size_t>(GlobalTypeId::ETS_FUNCTIONN_CLASS) -
677 static_cast<size_t>(GlobalTypeId::ETS_FUNCTION0_CLASS);
678 }
679
GlobalFunctionBuiltinType(size_t nargs,bool hasRest)680 Type *GlobalTypesHolder::GlobalFunctionBuiltinType(size_t nargs, bool hasRest)
681 {
682 if (nargs < VariadicFunctionTypeThreshold()) {
683 auto base = hasRest ? GlobalTypeId::ETS_FUNCTIONR0_CLASS : GlobalTypeId::ETS_FUNCTION0_CLASS;
684 return globalTypes_.at(static_cast<size_t>(base) + nargs);
685 }
686 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_FUNCTIONN_CLASS));
687 }
688
GlobalLambdaBuiltinType(size_t nargs,bool hasRest)689 Type *GlobalTypesHolder::GlobalLambdaBuiltinType(size_t nargs, bool hasRest)
690 {
691 if (nargs < VariadicFunctionTypeThreshold()) {
692 auto base = hasRest ? GlobalTypeId::ETS_LAMBDAR0_CLASS : GlobalTypeId::ETS_LAMBDA0_CLASS;
693 return globalTypes_.at(static_cast<size_t>(base) + nargs);
694 }
695 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::ETS_LAMBDAN_CLASS));
696 }
697
VariadicTupleTypeThreshold()698 size_t GlobalTypesHolder::VariadicTupleTypeThreshold()
699 {
700 return static_cast<size_t>(GlobalTypeId::ETS_TUPLEN_CLASS) - static_cast<size_t>(GlobalTypeId::ETS_TUPLE0_CLASS);
701 }
702
GlobalTupleBuiltinType(size_t nargs)703 Type *GlobalTypesHolder::GlobalTupleBuiltinType(size_t nargs)
704 {
705 const auto tupleClassIdPos = nargs < VariadicTupleTypeThreshold()
706 ? static_cast<size_t>(GlobalTypeId::ETS_TUPLE0_CLASS) + nargs
707 : static_cast<size_t>(GlobalTypeId::ETS_TUPLEN_CLASS);
708 return globalTypes_.at(tupleClassIdPos);
709 }
710
GlobalTypeError()711 Type *GlobalTypesHolder::GlobalTypeError()
712 {
713 return globalTypes_.at(static_cast<size_t>(GlobalTypeId::TYPE_ERROR));
714 }
715
InitializeBuiltin(const util::StringView name,Type * type)716 void GlobalTypesHolder::InitializeBuiltin(const util::StringView name, Type *type)
717 {
718 const auto typeId = builtinNameMappings_.find(name);
719 if (typeId == builtinNameMappings_.end()) {
720 LOG(DEBUG, ES2PANDA) << "Did not find '" << name << "' builtin in GlobalTypesHolder, it should be added.";
721 return;
722 }
723 globalTypes_.at(static_cast<size_t>(typeId->second)) = type;
724 }
725
FindExtensionAccessorInMap(util::StringView name,ETSObjectType * type,ExtensionAccessorMap & maps) const726 Signature *GlobalTypesHolder::FindExtensionAccessorInMap(util::StringView name, ETSObjectType *type,
727 ExtensionAccessorMap &maps) const
728 {
729 auto it = maps.find(name);
730 if (it == maps.end()) {
731 return nullptr;
732 }
733
734 auto targetSig = it->second.find(type);
735 if (targetSig != it->second.end()) {
736 return targetSig->second;
737 }
738
739 return nullptr;
740 }
741
InsertExtensionAccessorToMap(util::StringView name,ETSObjectType * type,Signature * sig,ExtensionAccessorMap & maps)742 void GlobalTypesHolder::InsertExtensionAccessorToMap(util::StringView name, ETSObjectType *type, Signature *sig,
743 ExtensionAccessorMap &maps)
744 {
745 auto it = maps.find(name);
746 if (it == maps.end()) {
747 ArenaUnorderedMap<ETSObjectType *, Signature *> newSigMap(allocator_->Adapter());
748 newSigMap.emplace(type, sig);
749 maps.emplace(name, newSigMap);
750 return;
751 }
752
753 auto targetMap = it->second;
754 targetMap.emplace(type, sig);
755 }
756 } // namespace ark::es2panda::checker
757