1 /**
2 * Copyright (c) 2021 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 "destructuringContext.h"
17
18 #include <util/helpers.h>
19 #include <binder/scope.h>
20 #include <ir/expressions/identifier.h>
21 #include <ir/expressions/objectExpression.h>
22 #include <ir/expressions/assignmentExpression.h>
23 #include <ir/expressions/arrayExpression.h>
24 #include <ir/base/spreadElement.h>
25 #include <ir/base/property.h>
26 #include <ir/typeNode.h>
27
28 namespace panda::es2panda::checker {
Prepare(const ir::Expression * typeAnnotation,const ir::Expression * initializer,const lexer::SourcePosition & loc)29 void DestructuringContext::Prepare(const ir::Expression *typeAnnotation, const ir::Expression *initializer,
30 const lexer::SourcePosition &loc)
31 {
32 if (typeAnnotation) {
33 typeAnnotation->Check(checker_);
34 Type *annotationType = typeAnnotation->AsTypeNode()->GetType(checker_);
35
36 if (initializer) {
37 checker_->ElaborateElementwise(annotationType, initializer, loc);
38 }
39
40 validateTypeAnnotation_ = true;
41 inferedType_ = annotationType;
42 return;
43 }
44
45 if (initializer) {
46 if (!initializer->IsObjectExpression()) {
47 validateObjectPatternInitializer_ = false;
48 }
49
50 inferedType_ = initializer->Check(checker_);
51 }
52 }
53
HandleDestructuringAssignment(const ir::Identifier * ident,Type * inferedType,Type * defaultType)54 void DestructuringContext::HandleDestructuringAssignment(const ir::Identifier *ident, Type *inferedType,
55 Type *defaultType)
56 {
57 if (!ident->Variable()) {
58 checker_->ThrowTypeError({"Cannot find name '", ident->Name(), "'."}, ident->Start());
59 }
60
61 binder::Variable *variable = ident->Variable();
62 ASSERT(variable->TsType());
63
64 if (defaultType && !checker_->IsTypeAssignableTo(defaultType, variable->TsType())) {
65 checker_->ThrowAssignmentError(defaultType, variable->TsType(), ident->Start());
66 }
67
68 if (inferedType && !checker_->IsTypeAssignableTo(inferedType, variable->TsType())) {
69 checker_->ThrowAssignmentError(inferedType, variable->TsType(), ident->Start());
70 }
71 }
72
SetInferedTypeForVariable(binder::Variable * var,Type * inferedType,const lexer::SourcePosition & loc)73 void DestructuringContext::SetInferedTypeForVariable(binder::Variable *var, Type *inferedType,
74 const lexer::SourcePosition &loc)
75 {
76 ASSERT(var);
77
78 if (!checker_->HasStatus(CheckerStatus::IN_CONST_CONTEXT)) {
79 inferedType = checker_->GetBaseTypeOfLiteralType(inferedType);
80 }
81
82 if (var->TsType()) {
83 checker_->IsTypeIdenticalTo(var->TsType(), inferedType,
84 {"Subsequent variable declaration must have the same type. Variable '", var->Name(),
85 "' must be of type '", var->TsType(), "', but here has type '", inferedType, "'."},
86 loc);
87 return;
88 }
89
90 if (signatureInfo_) {
91 signatureInfo_->params.push_back(var->AsLocalVariable());
92 signatureInfo_->minArgCount++;
93 }
94
95 var->SetTsType(inferedType);
96 }
97
ValidateObjectLiteralType(ObjectType * objType,const ir::ObjectExpression * objPattern)98 void DestructuringContext::ValidateObjectLiteralType(ObjectType *objType, const ir::ObjectExpression *objPattern)
99 {
100 for (const auto *sourceProp : objType->Properties()) {
101 const util::StringView &sourceName = sourceProp->Name();
102 bool found = false;
103
104 for (const auto *targetProp : objPattern->Properties()) {
105 if (targetProp->IsRestElement()) {
106 continue;
107 }
108
109 ASSERT(targetProp->IsProperty());
110 const util::StringView &targetName = targetProp->AsProperty()->Key()->AsIdentifier()->Name();
111
112 if (sourceName == targetName) {
113 found = true;
114 break;
115 }
116 }
117
118 if (!found) {
119 checker_->ThrowTypeError({"Object literal may only specify known properties, and property '", sourceName,
120 "' does not exist in the pattern."},
121 objPattern->Start());
122 }
123 }
124 }
125
HandleAssignmentPattern(const ir::AssignmentExpression * assignmentPattern,Type * inferedType,bool validateDefault)126 void DestructuringContext::HandleAssignmentPattern(const ir::AssignmentExpression *assignmentPattern, Type *inferedType,
127 bool validateDefault)
128 {
129 CHECK_NOT_NULL(assignmentPattern);
130 if (!assignmentPattern->Left()->IsArrayPattern()) {
131 checker_->RemoveStatus(CheckerStatus::FORCE_TUPLE);
132 }
133
134 Type *defaultType = assignmentPattern->Right()->Check(checker_);
135
136 if (!checker_->HasStatus(CheckerStatus::IN_CONST_CONTEXT)) {
137 defaultType = checker_->GetBaseTypeOfLiteralType(defaultType);
138 }
139
140 if (validateDefault && assignmentPattern->Right()->IsObjectExpression() &&
141 assignmentPattern->Left()->IsObjectPattern()) {
142 if (defaultType != nullptr && assignmentPattern != nullptr && assignmentPattern->Left() != nullptr) {
143 ValidateObjectLiteralType(defaultType->AsObjectType(), assignmentPattern->Left()->AsObjectPattern());
144 }
145 }
146
147 Type *initType = inferedType;
148 checker_->AddStatus(CheckerStatus::FORCE_TUPLE);
149
150 if (validateTypeAnnotation_) {
151 if (!inferedType) {
152 inferedType = checker_->GlobalUndefinedType();
153 }
154 } else {
155 if (!inferedType) {
156 inferedType = defaultType;
157 } else if (inferedType->IsUnionType()) {
158 inferedType->AsUnionType()->AddConstituentType(defaultType, checker_->Relation());
159 } else {
160 inferedType = checker_->CreateUnionType({inferedType, defaultType});
161 }
162 }
163
164 if (assignmentPattern->Left()->IsIdentifier()) {
165 HandleIdentifierPattern(assignmentPattern, initType, inferedType, defaultType);
166 return;
167 }
168
169 if (assignmentPattern->Left()->IsArrayPattern()) {
170 ArrayDestructuringContext nextContext = ArrayDestructuringContext(
171 checker_, assignmentPattern->Left(), inAssignment_, convertTupleToArray_, nullptr, nullptr);
172 nextContext.SetInferedType(inferedType);
173 nextContext.Start();
174 return;
175 }
176
177 ASSERT(assignmentPattern->Left()->IsObjectPattern());
178 ObjectDestructuringContext nextContext = ObjectDestructuringContext(
179 checker_, assignmentPattern->Left(), inAssignment_, convertTupleToArray_, nullptr, nullptr);
180 nextContext.SetInferedType(inferedType);
181 nextContext.Start();
182 }
183
HandleIdentifierPattern(const ir::AssignmentExpression * assignmentPattern,Type * initType,Type * inferedType,Type * defaultType)184 void DestructuringContext::HandleIdentifierPattern(const ir::AssignmentExpression *assignmentPattern, Type *initType,
185 Type *inferedType, Type *defaultType)
186 {
187 if (inAssignment_) {
188 HandleDestructuringAssignment(assignmentPattern->Left()->AsIdentifier(), initType, defaultType);
189 return;
190 }
191
192 if (validateTypeAnnotation_ && !checker_->IsTypeAssignableTo(defaultType, inferedType)) {
193 checker_->ThrowAssignmentError(defaultType, inferedType, assignmentPattern->Left()->Start());
194 }
195
196 SetInferedTypeForVariable(assignmentPattern->Left()->AsIdentifier()->Variable(), inferedType,
197 assignmentPattern->Start());
198 }
199
ValidateInferedType()200 void ArrayDestructuringContext::ValidateInferedType()
201 {
202 if (!inferedType_->IsArrayType() && !inferedType_->IsUnionType() &&
203 (!inferedType_->IsObjectType() || !inferedType_->AsObjectType()->IsTupleType())) {
204 checker_->ThrowTypeError(
205 {"Type ", inferedType_, " must have a '[Symbol.iterator]()' method that returns an iterator."},
206 id_->Start());
207 }
208
209 if (inferedType_->IsUnionType()) {
210 for (auto *it : inferedType_->AsUnionType()->ConstituentTypes()) {
211 if (!it->IsArrayType() && (!it->IsObjectType() || !it->AsObjectType()->IsTupleType())) {
212 checker_->ThrowTypeError(
213 {"Type ", inferedType_, " must have a '[Symbol.iterator]()' method that returns an iterator."},
214 id_->Start());
215 }
216 }
217 }
218 }
219
GetTypeFromTupleByIndex(TupleType * tuple)220 Type *ArrayDestructuringContext::GetTypeFromTupleByIndex(TupleType *tuple)
221 {
222 util::StringView memberIndex = util::Helpers::ToStringView(checker_->Allocator(), index_);
223 binder::Variable *memberVar = tuple->GetProperty(memberIndex, false);
224
225 if (!memberVar) {
226 return nullptr;
227 }
228
229 return memberVar->TsType();
230 }
231
NextInferedType(const util::StringView & searchName,bool throwError)232 Type *ArrayDestructuringContext::NextInferedType([[maybe_unused]] const util::StringView &searchName, bool throwError)
233 {
234 if (inferedType_->IsArrayType()) {
235 return inferedType_->AsArrayType()->ElementType();
236 }
237
238 if (inferedType_->IsObjectType()) {
239 ASSERT(inferedType_->AsObjectType()->IsTupleType());
240 Type *returnType = GetTypeFromTupleByIndex(inferedType_->AsObjectType()->AsTupleType());
241
242 if (!returnType && throwError) {
243 if (!validateTypeAnnotation_ && checker_->HasStatus(CheckerStatus::IN_PARAMETER)) {
244 return returnType;
245 }
246
247 checker_->ThrowTypeError({"Tuple type ", inferedType_, " of length ",
248 inferedType_->AsObjectType()->AsTupleType()->FixedLength(),
249 " has no element at index ", index_, "."},
250 id_->Start());
251 }
252
253 return returnType;
254 }
255
256 ASSERT(inferedType_->IsUnionType());
257
258 ArenaVector<Type *> unionTypes(checker_->Allocator()->Adapter());
259
260 for (auto *type : inferedType_->AsUnionType()->ConstituentTypes()) {
261 if (type->IsArrayType()) {
262 unionTypes.push_back(type->AsArrayType()->ElementType());
263 continue;
264 }
265
266 ASSERT(type->IsObjectType() && type->AsObjectType()->IsTupleType());
267 Type *elementType = GetTypeFromTupleByIndex(type->AsObjectType()->AsTupleType());
268
269 if (!elementType) {
270 continue;
271 }
272
273 unionTypes.push_back(elementType);
274 }
275
276 if (unionTypes.empty()) {
277 if (throwError) {
278 checker_->ThrowTypeError({"Property ", index_, " does not exist on type ", inferedType_, "."},
279 id_->Start());
280 }
281
282 return nullptr;
283 }
284
285 return checker_->CreateUnionType(std::move(unionTypes));
286 }
287
CreateArrayTypeForRest(UnionType * inferedType)288 Type *ArrayDestructuringContext::CreateArrayTypeForRest(UnionType *inferedType)
289 {
290 ArenaVector<Type *> unionTypes(checker_->Allocator()->Adapter());
291 uint32_t savedIdx = index_;
292
293 for (auto *it : inferedType->ConstituentTypes()) {
294 if (it->IsArrayType()) {
295 unionTypes.push_back(it->AsArrayType()->ElementType());
296 continue;
297 }
298
299 ASSERT(it->IsObjectType() && it->AsObjectType()->IsTupleType());
300 Type *tupleElementType = GetTypeFromTupleByIndex(it->AsObjectType()->AsTupleType());
301
302 while (tupleElementType) {
303 unionTypes.push_back(tupleElementType);
304 index_++;
305 tupleElementType = GetTypeFromTupleByIndex(it->AsObjectType()->AsTupleType());
306 }
307
308 index_ = savedIdx;
309 }
310
311 Type *restArrayElementType = checker_->CreateUnionType(std::move(unionTypes));
312 return checker_->Allocator()->New<ArrayType>(restArrayElementType);
313 }
314
CreateTupleTypeForRest(TupleType * tuple)315 Type *ArrayDestructuringContext::CreateTupleTypeForRest(TupleType *tuple)
316 {
317 ObjectDescriptor *desc = checker_->Allocator()->New<ObjectDescriptor>(checker_->Allocator());
318 CHECK_NOT_NULL(desc);
319 ArenaVector<ElementFlags> elementFlags(checker_->Allocator()->Adapter());
320 uint32_t savedIdx = index_;
321 uint32_t iterIndex = 0;
322
323 Type *tupleElementType = GetTypeFromTupleByIndex(tuple);
324
325 while (tupleElementType) {
326 ElementFlags memberFlag = ElementFlags::REQUIRED;
327 util::StringView memberIndex = util::Helpers::ToStringView(checker_->Allocator(), iterIndex);
328 auto *memberVar =
329 binder::Scope::CreateVar(checker_->Allocator(), memberIndex, binder::VariableFlags::PROPERTY, nullptr);
330 memberVar->SetTsType(tupleElementType);
331 elementFlags.push_back(memberFlag);
332 desc->properties.push_back(memberVar);
333
334 index_++;
335 iterIndex++;
336
337 tupleElementType = GetTypeFromTupleByIndex(tuple);
338 }
339
340 index_ = savedIdx;
341 return checker_->CreateTupleType(desc, std::move(elementFlags), ElementFlags::REQUIRED, iterIndex, iterIndex,
342 false);
343 }
344
GetRestType(const lexer::SourcePosition & loc)345 Type *ArrayDestructuringContext::GetRestType([[maybe_unused]] const lexer::SourcePosition &loc)
346 {
347 if (inferedType_->IsArrayType()) {
348 return inferedType_;
349 }
350
351 if (inferedType_->IsObjectType() && inferedType_->AsObjectType()->IsTupleType()) {
352 return CreateTupleTypeForRest(inferedType_->AsObjectType()->AsTupleType());
353 }
354
355 ASSERT(inferedType_->IsUnionType());
356 bool createArrayType = false;
357
358 for (auto *it : inferedType_->AsUnionType()->ConstituentTypes()) {
359 if (it->IsArrayType()) {
360 createArrayType = true;
361 break;
362 }
363 }
364
365 if (createArrayType) {
366 return CreateArrayTypeForRest(inferedType_->AsUnionType());
367 }
368
369 ArenaVector<Type *> tupleUnion(checker_->Allocator()->Adapter());
370
371 for (auto *it : inferedType_->AsUnionType()->ConstituentTypes()) {
372 ASSERT(it->IsObjectType() && it->AsObjectType()->IsTupleType());
373 Type *newTuple = CreateTupleTypeForRest(it->AsObjectType()->AsTupleType());
374 tupleUnion.push_back(newTuple);
375 }
376
377 return checker_->CreateUnionType(std::move(tupleUnion));
378 }
379
HandleRest(const ir::SpreadElement * rest)380 void ArrayDestructuringContext::HandleRest(const ir::SpreadElement *rest)
381 {
382 Type *inferedRestType = GetRestType(rest->Start());
383
384 if (rest->Argument()->IsIdentifier()) {
385 if (inAssignment_) {
386 HandleDestructuringAssignment(rest->Argument()->AsIdentifier(), inferedRestType, nullptr);
387 return;
388 }
389
390 SetInferedTypeForVariable(rest->Argument()->AsIdentifier()->Variable(), inferedRestType, rest->Start());
391 return;
392 }
393
394 if (rest->Argument()->IsArrayPattern()) {
395 ArrayDestructuringContext nextContext = ArrayDestructuringContext(checker_, rest->Argument(), inAssignment_,
396 convertTupleToArray_, nullptr, nullptr);
397 nextContext.SetInferedType(inferedRestType);
398 nextContext.Start();
399 return;
400 }
401
402 ASSERT(rest->Argument()->IsObjectPattern());
403 ObjectDestructuringContext nextContext =
404 ObjectDestructuringContext(checker_, rest->Argument(), inAssignment_, convertTupleToArray_, nullptr, nullptr);
405 nextContext.SetInferedType(inferedRestType);
406 nextContext.Start();
407 }
408
ConvertTupleTypeToArrayTypeIfNecessary(const ir::AstNode * node,Type * type)409 Type *ArrayDestructuringContext::ConvertTupleTypeToArrayTypeIfNecessary(const ir::AstNode *node, Type *type)
410 {
411 if (!convertTupleToArray_) {
412 return type;
413 }
414
415 if (!type) {
416 return type;
417 }
418
419 if (node->IsArrayPattern() ||
420 (node->IsAssignmentPattern() && node->AsAssignmentPattern()->Left()->IsArrayPattern())) {
421 return type;
422 }
423
424 if (type->IsObjectType() && type->AsObjectType()->IsTupleType()) {
425 return type->AsObjectType()->AsTupleType()->ConvertToArrayType(checker_);
426 }
427
428 return type;
429 }
430
SetParameterType(const ir::AstNode * parent,Type * type)431 static void SetParameterType(const ir::AstNode *parent, Type *type)
432 {
433 parent->Iterate([type](ir::AstNode *childNode) -> void {
434 if (childNode->IsIdentifier() && childNode->AsIdentifier()->Variable()) {
435 childNode->AsIdentifier()->Variable()->SetTsType(type);
436 return;
437 }
438
439 SetParameterType(childNode, type);
440 });
441 }
442
SetRemainingPatameterTypes()443 void ArrayDestructuringContext::SetRemainingPatameterTypes()
444 {
445 do {
446 const auto *it = id_->AsArrayPattern()->Elements()[index_];
447 ASSERT(it);
448 SetParameterType(it, checker_->GlobalAnyType());
449 } while (++index_ != id_->AsArrayPattern()->Elements().size());
450 }
451
Start()452 void ArrayDestructuringContext::Start()
453 {
454 ASSERT(id_->IsArrayPattern());
455
456 ValidateInferedType();
457
458 util::StringView name = util::Helpers::ToStringView(checker_->Allocator(), 0);
459
460 for (const auto *it : id_->AsArrayPattern()->Elements()) {
461 if (it->IsRestElement()) {
462 HandleRest(it->AsRestElement());
463 break;
464 }
465
466 Type *nextInferedType =
467 ConvertTupleTypeToArrayTypeIfNecessary(it, NextInferedType(name, !it->IsAssignmentPattern()));
468
469 if (!nextInferedType && checker_->HasStatus(CheckerStatus::IN_PARAMETER)) {
470 SetRemainingPatameterTypes();
471 return;
472 }
473
474 if (convertTupleToArray_ && nextInferedType && inferedType_->IsObjectType()) {
475 ASSERT(inferedType_->AsObjectType()->IsTupleType());
476
477 binder::Variable *currentTupleElement = inferedType_->AsObjectType()->Properties()[index_];
478
479 if (currentTupleElement) {
480 currentTupleElement->SetTsType(nextInferedType);
481 }
482 }
483
484 switch (it->Type()) {
485 case ir::AstNodeType::IDENTIFIER: {
486 if (inAssignment_) {
487 HandleDestructuringAssignment(it->AsIdentifier(), nextInferedType, nullptr);
488 break;
489 }
490
491 SetInferedTypeForVariable(it->AsIdentifier()->Variable(), nextInferedType, it->Start());
492 break;
493 }
494 case ir::AstNodeType::ARRAY_PATTERN: {
495 ArrayDestructuringContext nextContext =
496 ArrayDestructuringContext(checker_, it, inAssignment_, convertTupleToArray_, nullptr, nullptr);
497 nextContext.SetInferedType(nextInferedType);
498 nextContext.Start();
499 break;
500 }
501 case ir::AstNodeType::OBJECT_PATTERN: {
502 ObjectDestructuringContext nextContext =
503 ObjectDestructuringContext(checker_, it, inAssignment_, convertTupleToArray_, nullptr, nullptr);
504 nextContext.SetInferedType(nextInferedType);
505 nextContext.Start();
506 break;
507 }
508 case ir::AstNodeType::ASSIGNMENT_PATTERN: {
509 HandleAssignmentPattern(it->AsAssignmentPattern(), nextInferedType, false);
510 break;
511 }
512 case ir::AstNodeType::OMITTED_EXPRESSION: {
513 break;
514 }
515 default: {
516 UNREACHABLE();
517 }
518 }
519
520 index_++;
521 }
522 }
523
ValidateInferedType()524 void ObjectDestructuringContext::ValidateInferedType()
525 {
526 if (!inferedType_->IsObjectType()) {
527 return;
528 }
529
530 ValidateObjectLiteralType(inferedType_->AsObjectType(), id_->AsObjectPattern());
531 }
532
HandleRest(const ir::SpreadElement * rest)533 void ObjectDestructuringContext::HandleRest(const ir::SpreadElement *rest)
534 {
535 Type *inferedRestType = GetRestType(rest->Start());
536 ASSERT(rest->Argument()->IsIdentifier());
537
538 if (inAssignment_) {
539 HandleDestructuringAssignment(rest->Argument()->AsIdentifier(), inferedRestType, nullptr);
540 return;
541 }
542
543 SetInferedTypeForVariable(rest->Argument()->AsIdentifier()->Variable(), inferedRestType, rest->Start());
544 }
545
CreateObjectTypeForRest(ObjectType * objType)546 Type *ObjectDestructuringContext::CreateObjectTypeForRest(ObjectType *objType)
547 {
548 ObjectDescriptor *desc = checker_->Allocator()->New<ObjectDescriptor>(checker_->Allocator());
549 CHECK_NOT_NULL(desc);
550
551 for (auto *it : objType->AsObjectType()->Properties()) {
552 if (!it->HasFlag(binder::VariableFlags::INFERED_IN_PATTERN)) {
553 auto *memberVar =
554 binder::Scope::CreateVar(checker_->Allocator(), it->Name(), binder::VariableFlags::NONE, nullptr);
555 CHECK_NOT_NULL(memberVar);
556 memberVar->SetTsType(it->TsType());
557 memberVar->AddFlag(it->Flags());
558 desc->properties.push_back(memberVar);
559 }
560 }
561
562 Type *returnType = checker_->Allocator()->New<ObjectLiteralType>(desc);
563 CHECK_NOT_NULL(returnType);
564 returnType->AsObjectType()->AddObjectFlag(ObjectFlags::RESOLVED_MEMBERS);
565 return returnType;
566 }
567
GetRestType(const lexer::SourcePosition & loc)568 Type *ObjectDestructuringContext::GetRestType([[maybe_unused]] const lexer::SourcePosition &loc)
569 {
570 if (inferedType_->IsUnionType()) {
571 ArenaVector<Type *> unionTypes(checker_->Allocator()->Adapter());
572
573 for (auto *it : inferedType_->AsUnionType()->ConstituentTypes()) {
574 if (it->IsObjectType()) {
575 unionTypes.push_back(CreateObjectTypeForRest(it->AsObjectType()));
576 continue;
577 }
578
579 checker_->ThrowTypeError("Rest types may only be created from object types.", loc);
580 }
581
582 return checker_->CreateUnionType(std::move(unionTypes));
583 }
584
585 if (inferedType_->IsObjectType()) {
586 return CreateObjectTypeForRest(inferedType_->AsObjectType());
587 }
588
589 checker_->ThrowTypeError("Rest types may only be created from object types.", loc);
590 }
591
ConvertTupleTypeToArrayTypeIfNecessary(const ir::AstNode * node,Type * type)592 Type *ObjectDestructuringContext::ConvertTupleTypeToArrayTypeIfNecessary(const ir::AstNode *node, Type *type)
593 {
594 if (!convertTupleToArray_) {
595 return type;
596 }
597
598 if (!type) {
599 return type;
600 }
601
602 ASSERT(node->IsProperty());
603
604 const ir::Property *property = node->AsProperty();
605
606 if (property->Value()->IsArrayPattern()) {
607 return type;
608 }
609
610 if (property->Value()->IsAssignmentPattern() &&
611 property->Value()->AsAssignmentPattern()->Left()->IsArrayPattern()) {
612 return type;
613 }
614
615 if (type->IsObjectType() && type->AsObjectType()->IsTupleType()) {
616 return type->AsObjectType()->AsTupleType()->ConvertToArrayType(checker_);
617 }
618
619 return type;
620 }
621
NextInferedType(const util::StringView & searchName,bool throwError)622 Type *ObjectDestructuringContext::NextInferedType([[maybe_unused]] const util::StringView &searchName, bool throwError)
623 {
624 binder::Variable *prop =
625 checker_->GetPropertyOfType(inferedType_, searchName, !throwError, binder::VariableFlags::INFERED_IN_PATTERN);
626
627 if (prop) {
628 prop->AddFlag(binder::VariableFlags::INFERED_IN_PATTERN);
629 return prop->TsType();
630 }
631
632 if (inferedType_->IsObjectType()) {
633 checker::ObjectType *objType = inferedType_->AsObjectType();
634
635 if (objType->StringIndexInfo()) {
636 return objType->StringIndexInfo()->GetType();
637 }
638 }
639
640 if (throwError) {
641 checker_->ThrowTypeError({"Property ", searchName, " does not exist on type ", inferedType_, "."},
642 id_->Start());
643 }
644
645 return nullptr;
646 }
647
Start()648 void ObjectDestructuringContext::Start()
649 {
650 ASSERT(id_->IsObjectPattern());
651
652 if (!id_->AsObjectPattern()->Properties().back()->IsRestElement() && validateObjectPatternInitializer_) {
653 ValidateInferedType();
654 }
655
656 for (const auto *it : id_->AsObjectPattern()->Properties()) {
657 switch (it->Type()) {
658 case ir::AstNodeType::PROPERTY: {
659 const ir::Property *property = it->AsProperty();
660
661 if (property->IsComputed()) {
662 // TODO(aszilagyi)
663 return;
664 }
665
666 Type *nextInferedType = ConvertTupleTypeToArrayTypeIfNecessary(
667 it->AsProperty(),
668 NextInferedType(property->Key()->AsIdentifier()->Name(),
669 (!property->Value()->IsAssignmentPattern() || validateTypeAnnotation_)));
670
671 if (property->Value()->IsIdentifier()) {
672 if (inAssignment_) {
673 HandleDestructuringAssignment(property->Value()->AsIdentifier(), nextInferedType, nullptr);
674 break;
675 }
676
677 SetInferedTypeForVariable(property->Value()->AsIdentifier()->Variable(), nextInferedType,
678 it->Start());
679 break;
680 }
681
682 if (property->Value()->IsArrayPattern()) {
683 ArrayDestructuringContext nextContext =
684 ArrayDestructuringContext(checker_, property->Value()->AsArrayPattern(), inAssignment_,
685 convertTupleToArray_, nullptr, nullptr);
686 nextContext.SetInferedType(nextInferedType);
687 nextContext.Start();
688 break;
689 }
690
691 if (property->Value()->IsObjectPattern()) {
692 ObjectDestructuringContext nextContext =
693 ObjectDestructuringContext(checker_, property->Value()->AsObjectPattern(), inAssignment_,
694 convertTupleToArray_, nullptr, nullptr);
695 nextContext.SetInferedType(nextInferedType);
696 nextContext.Start();
697 break;
698 }
699
700 ASSERT(property->Value()->IsAssignmentPattern());
701 HandleAssignmentPattern(property->Value()->AsAssignmentPattern(), nextInferedType, true);
702 break;
703 }
704 case ir::AstNodeType::REST_ELEMENT: {
705 HandleRest(it->AsRestElement());
706 break;
707 }
708 default: {
709 UNREACHABLE();
710 }
711 }
712 }
713 }
714 } // namespace panda::es2panda::checker
715