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 "etsPrimitiveType.h"
17
18 #include "checker/TSchecker.h"
19 #include "checker/ETSchecker.h"
20 #include "compiler/core/ETSGen.h"
21 #include "compiler/core/pandagen.h"
22
23 namespace ark::es2panda::ir {
TransformChildren(const NodeTransformer & cb,std::string_view const transformationName)24 void ETSPrimitiveType::TransformChildren([[maybe_unused]] const NodeTransformer &cb,
25 [[maybe_unused]] std::string_view const transformationName)
26 {
27 for (auto *&it : VectorIterationGuard(Annotations())) {
28 if (auto *transformedNode = cb(it); it != transformedNode) {
29 it->SetTransformedNode(transformationName, transformedNode);
30 it = transformedNode->AsAnnotationUsage();
31 }
32 }
33 }
34
Iterate(const NodeTraverser & cb) const35 void ETSPrimitiveType::Iterate([[maybe_unused]] const NodeTraverser &cb) const
36 {
37 for (auto *it : VectorIterationGuard(Annotations())) {
38 cb(it);
39 }
40 }
41
Dump(ir::AstDumper * dumper) const42 void ETSPrimitiveType::Dump(ir::AstDumper *dumper) const
43 {
44 dumper->Add({{"type", "ETSPrimitiveType"}, {"annotations", AstDumper::Optional(Annotations())}});
45 }
46
Dump(ir::SrcDumper * dumper) const47 void ETSPrimitiveType::Dump(ir::SrcDumper *dumper) const
48 {
49 for (auto *anno : Annotations()) {
50 anno->Dump(dumper);
51 }
52 switch (GetPrimitiveType()) {
53 case PrimitiveType::BYTE:
54 dumper->Add("byte");
55 break;
56 case PrimitiveType::INT:
57 dumper->Add("int");
58 break;
59 case PrimitiveType::LONG:
60 dumper->Add("long");
61 break;
62 case PrimitiveType::SHORT:
63 dumper->Add("short");
64 break;
65 case PrimitiveType::FLOAT:
66 dumper->Add("float");
67 break;
68 case PrimitiveType::DOUBLE:
69 dumper->Add("double");
70 break;
71 case PrimitiveType::BOOLEAN:
72 dumper->Add("boolean");
73 break;
74 case PrimitiveType::CHAR:
75 dumper->Add("char");
76 break;
77 case PrimitiveType::VOID:
78 dumper->Add("void");
79 break;
80 default:
81 ES2PANDA_UNREACHABLE();
82 }
83 }
84
Compile(compiler::PandaGen * pg) const85 void ETSPrimitiveType::Compile(compiler::PandaGen *pg) const
86 {
87 pg->GetAstCompiler()->Compile(this);
88 }
89
Compile(compiler::ETSGen * etsg) const90 void ETSPrimitiveType::Compile(compiler::ETSGen *etsg) const
91 {
92 etsg->GetAstCompiler()->Compile(this);
93 }
94
Check(checker::TSChecker * checker)95 checker::Type *ETSPrimitiveType::Check(checker::TSChecker *checker)
96 {
97 return checker->GetAnalyzer()->Check(this);
98 }
99
GetType(checker::TSChecker * checker)100 checker::Type *ETSPrimitiveType::GetType([[maybe_unused]] checker::TSChecker *checker)
101 {
102 return checker->GlobalAnyType();
103 }
104
Check(checker::ETSChecker * checker)105 checker::VerifiedType ETSPrimitiveType::Check(checker::ETSChecker *checker)
106 {
107 return {this, checker->GetAnalyzer()->Check(this)};
108 }
109
GetType(checker::ETSChecker * checker)110 checker::Type *ETSPrimitiveType::GetType([[maybe_unused]] checker::ETSChecker *checker)
111 {
112 switch (type_) {
113 case PrimitiveType::BYTE: {
114 SetTsType(checker->GlobalByteType());
115 return TsType();
116 }
117 case PrimitiveType::SHORT: {
118 SetTsType(checker->GlobalShortType());
119 return TsType();
120 }
121 case PrimitiveType::INT: {
122 SetTsType(checker->GlobalIntType());
123 return TsType();
124 }
125 case PrimitiveType::LONG: {
126 SetTsType(checker->GlobalLongType());
127 return TsType();
128 }
129 case PrimitiveType::FLOAT: {
130 SetTsType(checker->GlobalFloatType());
131 return TsType();
132 }
133 case PrimitiveType::DOUBLE: {
134 SetTsType(checker->GlobalDoubleType());
135 return TsType();
136 }
137 case PrimitiveType::BOOLEAN: {
138 SetTsType(checker->GlobalETSBooleanType());
139 return TsType();
140 }
141 case PrimitiveType::CHAR: {
142 SetTsType(checker->GlobalCharType());
143 return TsType();
144 }
145 case PrimitiveType::VOID: {
146 if (LIKELY(checker->CheckVoidAnnotation(this))) {
147 SetTsType(checker->GlobalVoidType());
148 return TsType();
149 }
150
151 return checker->InvalidateType(this);
152 }
153 default: {
154 ES2PANDA_UNREACHABLE();
155 }
156 }
157 }
158
Clone(ArenaAllocator * const allocator,AstNode * const parent)159 ETSPrimitiveType *ETSPrimitiveType::Clone(ArenaAllocator *const allocator, AstNode *const parent)
160 {
161 auto *const clone = allocator->New<ETSPrimitiveType>(type_, allocator);
162 ES2PANDA_ASSERT(clone != nullptr);
163
164 if (parent != nullptr) {
165 clone->SetParent(parent);
166 }
167
168 if (!Annotations().empty()) {
169 ArenaVector<AnnotationUsage *> annotationUsages {allocator->Adapter()};
170 for (auto *annotationUsage : Annotations()) {
171 auto *annotationClone = annotationUsage->Clone(allocator, clone);
172 ES2PANDA_ASSERT(annotationClone != nullptr);
173 annotationUsages.push_back(annotationClone->AsAnnotationUsage());
174 }
175 clone->SetAnnotations(std::move(annotationUsages));
176 }
177
178 clone->SetRange(Range());
179 return clone;
180 }
181 } // namespace ark::es2panda::ir
182