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 "etsParameterExpression.h"
17
18 #include "checker/ETSchecker.h"
19 #include "checker/ets/typeRelationContext.h"
20 #include "checker/TSchecker.h"
21 #include "compiler/core/ETSGen.h"
22 #include "compiler/core/pandagen.h"
23 #include "ir/astDump.h"
24 #include "ir/srcDump.h"
25 #include "ir/typeNode.h"
26 #include "ir/expressions/identifier.h"
27 #include "ir/base/spreadElement.h"
28
29 namespace ark::es2panda::ir {
30
ETSParameterExpression(AnnotatedExpression *const identOrSpread, Expression *const initializer)31 ETSParameterExpression::ETSParameterExpression(AnnotatedExpression *const identOrSpread, Expression *const initializer)
32 : Expression(AstNodeType::ETS_PARAMETER_EXPRESSION), initializer_(initializer)
33 {
34 ASSERT(identOrSpread != nullptr);
35 identOrSpread->SetParent(this);
36
37 if (identOrSpread->IsIdentifier()) {
38 ident_ = identOrSpread->AsIdentifier();
39 } else if (identOrSpread->IsRestElement()) {
40 spread_ = identOrSpread->AsRestElement();
41 ASSERT(spread_->Argument()->IsIdentifier());
42 ident_ = spread_->Argument()->AsIdentifier();
43 ident_->SetParent(spread_);
44 initializer_ = nullptr; // Just in case!
45 } else {
46 UNREACHABLE();
47 }
48 }
49
50 const Identifier *ETSParameterExpression::Ident() const noexcept
51 {
52 return ident_;
53 }
54
55 Identifier *ETSParameterExpression::Ident() noexcept
56 {
57 return ident_;
58 }
59
60 const SpreadElement *ETSParameterExpression::RestParameter() const noexcept
61 {
62 return spread_;
63 }
64
65 SpreadElement *ETSParameterExpression::RestParameter() noexcept
66 {
67 return spread_;
68 }
69
70 const Expression *ETSParameterExpression::Initializer() const noexcept
71 {
72 return initializer_;
73 }
74
75 Expression *ETSParameterExpression::Initializer() noexcept
76 {
77 return initializer_;
78 }
79
80 varbinder::Variable *ETSParameterExpression::Variable() const noexcept
81 {
82 return ident_->Variable();
83 }
84
85 TypeNode const *ETSParameterExpression::TypeAnnotation() const noexcept
86 {
87 return !IsRestParameter() ? ident_->TypeAnnotation() : spread_->TypeAnnotation();
88 }
89
90 TypeNode *ETSParameterExpression::TypeAnnotation() noexcept
91 {
92 return !IsRestParameter() ? ident_->TypeAnnotation() : spread_->TypeAnnotation();
93 }
94
95 void ETSParameterExpression::SetVariable(varbinder::Variable *const variable) noexcept
96 {
97 ident_->SetVariable(variable);
98 }
99
100 void ETSParameterExpression::SetLexerSaved(util::StringView s) noexcept
101 {
102 savedLexer_ = s;
103 }
104
105 util::StringView ETSParameterExpression::LexerSaved() const noexcept
106 {
107 return savedLexer_;
108 }
109
TransformChildren(const NodeTransformer &cb, std::string_view const transformationName)110 void ETSParameterExpression::TransformChildren(const NodeTransformer &cb, std::string_view const transformationName)
111 {
112 if (IsRestParameter()) {
113 if (auto *transformedNode = cb(spread_); spread_ != transformedNode) {
114 spread_->SetTransformedNode(transformationName, transformedNode);
115 spread_ = transformedNode->AsRestElement();
116 }
117 ident_ = spread_->Argument()->AsIdentifier();
118 } else {
119 if (auto *transformedNode = cb(ident_); ident_ != transformedNode) {
120 ident_->SetTransformedNode(transformationName, transformedNode);
121 ident_ = transformedNode->AsIdentifier();
122 }
123 }
124
125 if (IsDefault()) {
126 if (auto *transformedNode = cb(initializer_); initializer_ != transformedNode) {
127 initializer_->SetTransformedNode(transformationName, transformedNode);
128 initializer_ = transformedNode->AsExpression();
129 }
130 }
131 }
132
Iterate(const NodeTraverser &cb) const133 void ETSParameterExpression::Iterate(const NodeTraverser &cb) const
134 {
135 if (IsRestParameter()) {
136 cb(spread_);
137 } else {
138 cb(ident_);
139 }
140
141 if (IsDefault()) {
142 cb(initializer_);
143 }
144 }
145
Dump(ir::AstDumper *const dumper) const146 void ETSParameterExpression::Dump(ir::AstDumper *const dumper) const
147 {
148 if (!IsRestParameter()) {
149 dumper->Add(
150 {{"type", "ETSParameterExpression"}, {"name", ident_}, {"initializer", AstDumper::Optional(initializer_)}});
151 } else {
152 dumper->Add({{"type", "ETSParameterExpression"}, {"rest parameter", spread_}});
153 }
154 }
155
Dump(ir::SrcDumper *const dumper) const156 void ETSParameterExpression::Dump(ir::SrcDumper *const dumper) const
157 {
158 if (IsRestParameter()) {
159 spread_->Dump(dumper);
160 } else {
161 if (ident_ != nullptr) {
162 ASSERT(ident_->IsAnnotatedExpression());
163 ident_->Dump(dumper);
164 if (initializer_ != nullptr && initializer_->IsUndefinedLiteral()) {
165 dumper->Add("?");
166 }
167 auto typeAnnotation = ident_->AsAnnotatedExpression()->TypeAnnotation();
168 if (typeAnnotation != nullptr) {
169 dumper->Add(": ");
170 typeAnnotation->Dump(dumper);
171 }
172 }
173 if (initializer_ != nullptr && !initializer_->IsUndefinedLiteral()) {
174 dumper->Add(" = ");
175 initializer_->Dump(dumper);
176 }
177 }
178 }
179
Compile(compiler::PandaGen *const pg) const180 void ETSParameterExpression::Compile(compiler::PandaGen *const pg) const
181 {
182 pg->GetAstCompiler()->Compile(this);
183 }
184
Compile(compiler::ETSGen *const etsg) const185 void ETSParameterExpression::Compile(compiler::ETSGen *const etsg) const
186 {
187 etsg->GetAstCompiler()->Compile(this);
188 }
189
Check(checker::TSChecker *const checker)190 checker::Type *ETSParameterExpression::Check(checker::TSChecker *const checker)
191 {
192 return checker->GetAnalyzer()->Check(this);
193 }
194
Check(checker::ETSChecker *const checker)195 checker::Type *ETSParameterExpression::Check(checker::ETSChecker *const checker)
196 {
197 return checker->GetAnalyzer()->Check(this);
198 }
199
Clone(ArenaAllocator *const allocator, AstNode *const parent)200 ETSParameterExpression *ETSParameterExpression::Clone(ArenaAllocator *const allocator, AstNode *const parent)
201 {
202 auto *const identOrSpread = spread_ != nullptr ? spread_->Clone(allocator, nullptr)->AsAnnotatedExpression()
203 : ident_->Clone(allocator, nullptr)->AsAnnotatedExpression();
204 auto *const initializer =
205 initializer_ != nullptr ? initializer_->Clone(allocator, nullptr)->AsExpression() : nullptr;
206
207 if (auto *const clone = allocator->New<ETSParameterExpression>(identOrSpread, initializer); clone != nullptr) {
208 identOrSpread->SetParent(clone);
209
210 if (initializer != nullptr) {
211 initializer->SetParent(clone);
212 }
213
214 if (parent != nullptr) {
215 clone->SetParent(parent);
216 }
217
218 clone->SetRequiredParams(extraValue_);
219 return clone;
220 }
221
222 throw Error(ErrorType::GENERIC, "", CLONE_ALLOCATION_ERROR);
223 }
224 } // namespace ark::es2panda::ir
225