Lines Matching refs:checker
17 #include "checker/types/ets/etsAsyncFuncReturnType.h"
19 namespace ark::es2panda::checker {
20 void CheckExtensionIsShadowedInCurrentClassOrInterface(checker::ETSChecker *checker, checker::ETSObjectType *objType,
21 ir::ScriptFunction *extensionFunc, checker::Signature *signature)
25 auto *const variable = objType->GetOwnProperty<checker::PropertyType::INSTANCE_METHOD>(methodName);
33 if (!checker->Relation()->IsCompatibleTo(signature, funcSignature)) {
37 checker->ReportWarning({"extension is shadowed by a instance member function '", funcType->Name(),
44 void CheckExtensionIsShadowedByMethod(checker::ETSChecker *checker, checker::ETSObjectType *objType,
45 ir::ScriptFunction *extensionFunc, checker::Signature *signature)
51 CheckExtensionIsShadowedInCurrentClassOrInterface(checker, objType, extensionFunc, signature);
54 CheckExtensionIsShadowedByMethod(checker, interface, extensionFunc, signature);
57 CheckExtensionIsShadowedByMethod(checker, objType->SuperType(), extensionFunc, signature);
60 static void ReplaceThisInExtensionMethod(checker::ETSChecker *checker, ir::ScriptFunction *extensionFunc)
69 auto *thisParam = checker->Allocator()->New<ir::Identifier>(
70 varbinder::TypedBinder::MANDATORY_PARAM_THIS, checker->Allocator());
80 void CheckExtensionMethod(checker::ETSChecker *checker, ir::ScriptFunction *extensionFunc, ir::MethodDefinition *node)
82 auto *const classType = checker->GetApparentType(extensionFunc->Signature()->Params()[0]->TsType());
84 (!classType->AsETSObjectType()->HasObjectFlag(checker::ETSObjectFlags::CLASS) &&
85 !classType->AsETSObjectType()->HasObjectFlag(checker::ETSObjectFlags::INTERFACE))) {
86 checker->LogTypeError("Extension function can only defined for class and interface type.", node->Start());
90 classType->Variable()->Declaration()->Node()->Check(checker);
94 ReplaceThisInExtensionMethod(checker, extensionFunc);
96 checker::SignatureInfo *originalExtensionSigInfo = checker->Allocator()->New<checker::SignatureInfo>(
97 extensionFunc->Signature()->GetSignatureInfo(), checker->Allocator());
100 checker::Signature *originalExtensionSigature =
101 checker->CreateSignature(originalExtensionSigInfo, extensionFunc->Signature()->ReturnType(), extensionFunc);
103 CheckExtensionIsShadowedByMethod(checker, classType->AsETSObjectType(), extensionFunc, originalExtensionSigature);
106 void DoBodyTypeChecking(ETSChecker *checker, ir::MethodDefinition *node, ir::ScriptFunction *scriptFunc)
109 checker->LogTypeError("Native, Abstract and Declare methods cannot have body.", scriptFunc->Body()->Start());
114 checker::ScopeContext scopeCtx(checker, scriptFunc->Scope());
115 checker::SavedCheckerContext savedContext(checker, checker->Context().Status(),
116 checker->Context().ContainingClass());
117 checker->Context().SetContainingSignature(checker->GetSignatureFromMethodDefinition(node));
120 !checker->Context().ContainingClass()->HasObjectFlag(checker::ETSObjectFlags::GLOBAL)) {
121 checker->AddStatus(checker::CheckerStatus::IN_STATIC_CONTEXT);
125 checker->AddStatus(checker::CheckerStatus::IN_CONSTRUCTOR);
129 CheckExtensionMethod(checker, scriptFunc, node);
132 scriptFunc->Body()->Check(checker);
136 ComposeAsyncImplFuncReturnType(checker, scriptFunc);
140 returnStatement->SetReturnType(checker, scriptFunc->Signature()->ReturnType());
144 checker->Context().SetContainingSignature(nullptr);
148 void ComposeAsyncImplFuncReturnType(ETSChecker *checker, ir::ScriptFunction *scriptFunc)
150 const auto &promiseGlobal = checker->GlobalBuiltinPromiseType()->AsETSObjectType();
152 promiseGlobal->Instantiate(checker->Allocator(), checker->Relation(), checker->GetGlobalTypesHolder())
154 promiseType->AddTypeFlag(checker::TypeFlag::GENERIC);
159 checker->AllocNode<ir::Identifier>(compiler::Signatures::BUILTIN_OBJECT_CLASS, checker->Allocator());
161 checker->VarBinder()->AsETSBinder()->LookupTypeReference(objectId, false);
162 auto *returnType = checker->AllocNode<ir::ETSTypeReference>(
163 checker->AllocNode<ir::ETSTypeReferencePart>(objectId, nullptr, nullptr));
167 checker->Allocator()->New<ETSAsyncFuncReturnType>(checker->Allocator(), checker->Relation(), promiseType));
168 returnType->Check(checker);
172 void ComposeAsyncImplMethod(ETSChecker *checker, ir::MethodDefinition *node)
174 auto *classDef = checker->FindAncestorGivenByType(node, ir::AstNodeType::CLASS_DEFINITION)->AsClassDefinition();
176 ir::MethodDefinition *implMethod = checker->CreateAsyncProxy(node, classDef);
178 implMethod->Check(checker);
196 void CheckPredefinedMethodReturnType(ETSChecker *checker, ir::ScriptFunction *scriptFunc)
200 if (scriptFunc->IsSetter() && (scriptFunc->Signature()->ReturnType() != checker->GlobalVoidType())) {
201 checker->LogTypeError("Setter must have void return type", position);
204 if (scriptFunc->IsGetter() && (scriptFunc->Signature()->ReturnType() == checker->GlobalVoidType())) {
205 checker->LogTypeError("Getter must return a value", position);
212 if (scriptFunc->Signature()->ReturnType() == checker->GlobalVoidType()) {
213 checker->LogTypeError(methodName + "' shouldn't have void return type.", position);
216 if (scriptFunc->Signature()->ReturnType() != checker->GlobalVoidType()) {
217 checker->LogTypeError(methodName + "' should have void return type.", position);
220 CheckIteratorMethodReturnType(checker, scriptFunc, position, methodName);
242 void CheckIteratorMethodReturnType(ETSChecker *checker, ir::ScriptFunction *scriptFunc,
248 checker->LogTypeError(methodName + "' doesn't have return type.", position);
252 returnType = checker->GetApparentType(returnType->AsETSTypeParameter()->GetConstraintType());
266 checker->LogTypeError(
271 checker::Type *InitAnonymousLambdaCallee(checker::ETSChecker *checker, ir::Expression *callee,
272 checker::Type *calleeType)
276 ArenaVector<ir::Expression *> params {checker->Allocator()->Adapter()};
277 checker->CopyParams(arrowFunc->Params(), params);
278 checker::Type *funcReturnType = nullptr;
282 typeAnnotation = typeAnnotation->Clone(checker->Allocator(), nullptr);
285 auto newTypeAnnotation = callee->AsArrowFunctionExpression()->CreateTypeAnnotation(checker);
287 funcReturnType = newTypeAnnotation->GetType(checker);
291 auto *funcType = checker->AllocNode<ir::ETSFunctionType>(std::move(signature), ir::ScriptFunctionFlags::NONE);
294 auto *const funcIface = typeAnnotation != nullptr ? funcType->Check(checker) : funcReturnType;
295 checker->Relation()->SetNode(callee);
296 checker->Relation()->IsAssignableTo(calleeType, funcIface);
300 checker::Signature *ResolveCallExtensionFunction(checker::ETSFunctionType *functionType, checker::ETSChecker *checker,
306 checker->ResolveCallExpressionAndTrailingLambda(functionType->CallSignatures(), expr, expr->Start());
311 checker->LogTypeError({"Property '", memberExpr->Property()->AsIdentifier()->Name(),
319 checker->HandleUpdatedCallExpressionNode(expr);
321 expr->Callee()->Check(checker);
325 checker::Signature *ResolveCallForETSExtensionFuncHelperType(checker::ETSExtensionFuncHelperType *type,
326 checker::ETSChecker *checker, ir::CallExpression *expr)
328 checker::Signature *signature = checker->ResolveCallExpressionAndTrailingLambda(
329 type->ClassMethodType()->CallSignatures(), expr, expr->Start(), checker::TypeRelationFlag::NO_THROW);
341 return ResolveCallExtensionFunction(type->ExtensionMethodType(), checker, expr);
344 ArenaVector<checker::Signature *> GetUnionTypeSignatures(ETSChecker *checker, checker::ETSUnionType *etsUnionType)
346 ArenaVector<checker::Signature *> callSignatures(checker->Allocator()->Adapter());
350 ArenaVector<checker::Signature *> tmpCallSignatures(checker->Allocator()->Adapter());
352 ->GetOwnProperty<checker::PropertyType::INSTANCE_METHOD>("invoke0")
359 ArenaVector<checker::Signature *> tmpCallSignatures(checker->Allocator()->Adapter());
364 ArenaVector<checker::Signature *> tmpCallSignatures(checker->Allocator()->Adapter());
365 tmpCallSignatures = GetUnionTypeSignatures(checker, constituentType->AsETSUnionType());
373 ArenaVector<checker::Signature *> &ChooseSignatures(ETSChecker *checker, checker::Type *calleeType,
377 static ArenaVector<checker::Signature *> unionSignatures(checker->Allocator()->Adapter());
384 ->GetOwnProperty<checker::PropertyType::INSTANCE_METHOD>(FUNCTIONAL_INTERFACE_INVOKE_METHOD_NAME)
390 unionSignatures = GetUnionTypeSignatures(checker, calleeType->AsETSUnionType());
396 checker::ETSObjectType *ChooseCalleeObj(ETSChecker *checker, ir::CallExpression *expr, checker::Type *calleeType,
403 return checker->Context().ContainingClass();
409 void ProcessExclamationMark(ETSChecker *checker, ir::UnaryExpression *expr, checker::Type *operandType)
411 if (checker->IsNullLikeOrVoidExpression(expr->Argument())) {
412 auto tsType = checker->CreateETSBooleanType(true);
413 tsType->AddTypeFlag(checker::TypeFlag::CONSTANT);
419 checker->LogTypeError("Bad operand type, the type of the operand must be boolean type.",
421 expr->SetTsType(checker->GlobalTypeError());
427 auto tsType = checker->CreateETSBooleanType(!std::get<1>(exprRes));
428 tsType->AddTypeFlag(checker::TypeFlag::CONSTANT);
433 expr->SetTsType(checker->GlobalETSBooleanType());
436 void SetTsTypeForUnaryExpression(ETSChecker *checker, ir::UnaryExpression *expr, checker::Type *operandType)
441 if (operandType == nullptr || !operandType->HasTypeFlag(checker::TypeFlag::ETS_CONVERTIBLE_TO_NUMERIC)) {
442 checker->LogTypeError("Bad operand type, the type of the operand must be numeric type.",
444 expr->SetTsType(checker->GlobalTypeError());
448 if (operandType->HasTypeFlag(checker::TypeFlag::CONSTANT) &&
450 expr->SetTsType(checker->NegateNumericType(operandType, expr));
458 if (operandType == nullptr || !operandType->HasTypeFlag(checker::TypeFlag::ETS_CONVERTIBLE_TO_NUMERIC)) {
459 checker->LogTypeError("Bad operand type, the type of the operand must be numeric type.",
461 expr->SetTsType(checker->GlobalTypeError());
465 if (operandType->HasTypeFlag(checker::TypeFlag::CONSTANT)) {
466 expr->SetTsType(checker->BitwiseNegateNumericType(operandType, expr));
470 expr->SetTsType(checker->SelectGlobalIntegerTypeForNumeric(operandType));
474 ProcessExclamationMark(checker, expr, operandType);
488 checker::ETSObjectType *CreateSyntheticType(ETSChecker *checker, util::StringView const &syntheticName,
489 checker::ETSObjectType *lastObjectType, ir::Identifier *id)
491 auto *syntheticObjType = checker->Allocator()->New<checker::ETSObjectType>(
492 checker->Allocator(), syntheticName, syntheticName,
493 std::make_tuple(id, checker::ETSObjectFlags::NO_OPTS, checker->Relation()));
495 auto *classDecl = checker->Allocator()->New<varbinder::ClassDecl>(syntheticName);
497 checker->Allocator()->New<varbinder::LocalVariable>(classDecl, varbinder::VariableFlags::CLASS);
499 lastObjectType->AddProperty<checker::PropertyType::STATIC_FIELD>(var);
510 checker::Type *GetIteratorType(ETSChecker *checker, checker::Type *elemType, ir::AstNode *left)
513 auto const getIterType = [checker, elemType](ir::VariableDeclarator *const declarator) -> checker::Type * {
515 if (auto *resolved = checker->FindVariableInFunctionScope(declarator->Id()->AsIdentifier()->Name(),
524 return checker->GlobalTypeError();
527 checker::Type *iterType = nullptr;
534 checker->LogTypeError({errorMsg, variable->Name()}, decl->Node()->Start());
545 checker->LogTypeError(ITERATOR_TYPE_ABSENT, left->Start());
546 return checker->GlobalTypeError();
551 bool CheckArgumentVoidType(checker::Type *&funcReturnType, ETSChecker *checker, const std::string &name,
556 checker->LogTypeError("Bad return type, main enable only void or int type.", st->Start());
562 bool CheckReturnType(ETSChecker *checker, checker::Type *funcReturnType, checker::Type *argumentType,
565 if (funcReturnType->IsETSVoidType() || funcReturnType == checker->GlobalVoidType()) {
566 if (argumentType != checker->GlobalVoidType()) {
567 checker->LogTypeError("Unexpected return value, enclosing method return type is void.",
571 if (!checker::AssignmentContext(checker->Relation(), stArgument, argumentType, funcReturnType,
573 checker::TypeRelationFlag::DIRECT_RETURN | checker::TypeRelationFlag::NO_THROW)
575 checker->LogTypeError({"Return statement type is not compatible with the enclosing method's return type."},
583 funcReturnType->AsETSObjectType()->GetOriginalBaseType() == checker->GlobalBuiltinPromiseType()) {
585 checker::AssignmentContext(checker->Relation(), stArgument, argumentType, promiseArg, stArgument->Start(), {},
586 checker::TypeRelationFlag::DIRECT_RETURN | checker::TypeRelationFlag::NO_THROW);
587 if (checker->Relation()->IsTrue()) {
592 const Type *targetType = checker->TryGettingFunctionTypeFromInvokeFunction(funcReturnType);
593 const Type *sourceType = checker->TryGettingFunctionTypeFromInvokeFunction(argumentType);
594 if (!checker::AssignmentContext(checker->Relation(), stArgument, argumentType, funcReturnType, stArgument->Start(),
595 {}, checker::TypeRelationFlag::DIRECT_RETURN | checker::TypeRelationFlag::NO_THROW)
597 checker->LogTypeError(
605 void InferReturnType(ETSChecker *checker, ir::ScriptFunction *containingFunc, checker::Type *&funcReturnType,
610 stArgument == nullptr ? checker->GlobalVoidType() : checker->GetNonConstantType(stArgument->Check(checker));
620 auto typeAnnotation = arrowFunc->CreateTypeAnnotation(checker);
623 funcReturnType = typeAnnotation->GetType(checker);
625 const Type *sourceType = checker->TryGettingFunctionTypeFromInvokeFunction(argumentType);
626 const Type *targetType = checker->TryGettingFunctionTypeFromInvokeFunction(funcReturnType);
628 if (!checker::AssignmentContext(checker->Relation(), arrowFunc, argumentType, funcReturnType,
630 checker::TypeRelationFlag::DIRECT_RETURN | checker::TypeRelationFlag::NO_THROW)
632 checker->LogTypeError({"Type '", sourceType,
635 funcReturnType = checker->GlobalTypeError();
641 containingFunc->Signature()->RemoveSignatureFlag(checker::SignatureFlags::NEED_RETURN_TYPE);
642 containingFunc->Signature()->AddSignatureFlag(checker::SignatureFlags::INFERRED_RETURN_TYPE);
643 checker->VarBinder()->AsETSBinder()->BuildFunctionName(containingFunc);
650 void ProcessReturnStatements(ETSChecker *checker, ir::ScriptFunction *containingFunc, checker::Type *&funcReturnType,
657 if (!funcReturnType->IsETSVoidType() && funcReturnType != checker->GlobalVoidType()) {
658 checker->LogTypeError("All return statements in the function should be empty or have a value.",
668 checker->SetArrayPreferredTypeForNestedMemberExpressions(stArgument->AsMemberExpression(), funcReturnType);
671 checker::Type *argumentType = checker->GetNonConstantType(stArgument->Check(checker));
675 checker->LogTypeError("All return statements in the function should be empty or have a value.",
681 if (!CheckArgumentVoidType(funcReturnType, checker, name, st)) {
685 auto *const relation = checker->Relation();
689 checker->ResolveReturnStatement(funcReturnType, argumentType, containingFunc, st);
693 relation->SetFlags(checker::TypeRelationFlag::NONE);
697 ETSObjectType *CreateOptionalSignaturesForFunctionalType(ETSChecker *checker, ir::ETSFunctionType *node,
702 auto returnType = node->ReturnType()->GetType(checker);
705 checker::ETSChecker::EmplaceSubstituted(
707 InstantiateBoxedPrimitiveType(checker, params[i],
708 params[i]->AsETSParameterExpression()->TypeAnnotation()->GetType(checker)));
712 checker::ETSChecker::EmplaceSubstituted(
714 CreateParamTypeWithDefaultParam(checker, params[i]));
717 checker::ETSChecker::EmplaceSubstituted(
722 InstantiateBoxedPrimitiveType(checker, node->ReturnType(), returnType));
724 return genericInterfaceType->Substitute(checker->Relation(), substitution)->AsETSObjectType();
727 ETSObjectType *CreateInterfaceTypeForETSFunctionType(ETSChecker *checker, ir::ETSFunctionType *node,
731 if (auto const ¶ms = node->Params(); params.size() < checker->GlobalBuiltinFunctionTypeVariadicThreshold()) {
733 checker::ETSChecker::EmplaceSubstituted(
736 checker, params[i], params[i]->AsETSParameterExpression()->TypeAnnotation()->GetType(checker)));
740 checker::ETSChecker::EmplaceSubstituted(
742 InstantiateBoxedPrimitiveType(checker, node->ReturnType(), node->ReturnType()->GetType(checker)));
743 return genericInterfaceType->Substitute(checker->Relation(), substitution)->AsETSObjectType();
746 Type *CreateParamTypeWithDefaultParam(ETSChecker *checker, ir::Expression *param)
749 checker->LogTypeError({"Expected initializer for ", param->AsETSParameterExpression()->Ident()->Name()},
753 ArenaVector<Type *> types(checker->Allocator()->Adapter());
755 checker, param, param->AsETSParameterExpression()->TypeAnnotation()->GetType(checker)));
758 types.push_back(checker->GlobalETSUndefinedType());
761 return checker->CreateETSUnionType(Span<Type *const>(types));
764 Type *InstantiateBoxedPrimitiveType(ETSChecker *checker, ir::Expression *param, Type *paramType)
766 if (paramType->HasTypeFlag(checker::TypeFlag::ETS_PRIMITIVE)) {
767 auto node = checker->Relation()->GetNode();
768 checker->Relation()->SetNode(param);
769 auto *const boxedTypeArg = checker->PrimitiveTypeAsETSBuiltinType(paramType);
772 boxedTypeArg->Instantiate(checker->Allocator(), checker->Relation(), checker->GetGlobalTypesHolder());
773 checker->Relation()->SetNode(node);
778 } // namespace ark::es2panda::checker