Lines Matching defs:st
38 checker::Type *ETSAnalyzer::Check(ir::CatchClause *st) const
43 ir::Identifier *paramIdent = st->Param()->AsIdentifier();
48 exceptionType = checker->CheckExceptionOrErrorType(catchParamAnnotationType, st->Param()->Start());
53 st->Body()->Check(checker);
55 st->SetTsType(exceptionType);
74 checker::Type *ETSAnalyzer::Check(ir::ClassProperty *st) const
76 ASSERT(st->Id() != nullptr);
79 if (st->TsTypeOrError() != nullptr) {
80 return st->TsTypeOrError();
87 if (st->IsStatic()) {
91 st->SetTsType(checker->CheckVariableDeclaration(st->Id(), st->TypeAnnotation(), st->Value(), st->Modifiers()));
93 return st->TsTypeOrError();
96 checker::Type *ETSAnalyzer::Check(ir::ClassStaticBlock *st) const
101 checker->LogTypeError("Static initializer is not allowed in inner class.", st->Start());
102 st->SetTsType(checker->GlobalTypeError());
103 return st->TsTypeOrError();
106 auto *func = st->Function();
109 st->SetTsType(checker->GlobalTypeError());
110 return st->TsTypeOrError();
112 st->SetTsType(checker->BuildNamedFunctionType(func));
118 return st->TsType();
501 checker::Type *ETSAnalyzer::Check([[maybe_unused]] ir::ETSPackageDeclaration *st) const
997 checker::Type *ETSAnalyzer::Check(ir::BlockExpression *st) const
1000 checker::ScopeContext scopeCtx(checker, st->Scope());
1002 if (st->TsTypeOrError() == nullptr) {
1004 for (std::size_t idx = 0; idx < st->Statements().size(); idx++) {
1005 st->Statements()[idx]->Check(checker);
1008 auto lastStmt = st->Statements().back();
1010 st->SetTsType(lastStmt->AsExpressionStatement()->GetExpression()->TsType());
1013 return st->TsTypeOrError();
1879 checker::Type *ETSAnalyzer::Check(ir::NamespaceDeclaration *st) const
1882 st->Definition()->Check(checker);
1886 checker::Type *ETSAnalyzer::Check([[maybe_unused]] ir::NamespaceDefinition *st) const
1922 checker::Type *ETSAnalyzer::Check(ir::ImportDeclaration *st) const
1926 for (auto *spec : st->Specifiers()) {
1935 checker::Type *ETSAnalyzer::Check(ir::ImportNamespaceSpecifier *st) const
1938 if (st->Local()->Name().Empty()) {
1942 if (st->Local()->AsIdentifier()->TsTypeOrError() != nullptr) {
1943 return st->Local()->TsTypeOrError();
1946 auto *importDecl = st->Parent()->AsETSImportDeclaration();
1950 checker->SetrModuleObjectTsType(st->Local(), type);
1954 return checker->GetImportSpecifierObjectType(importDecl, st->Local()->AsIdentifier());
1958 checker::Type *ETSAnalyzer::Check(ir::AssertStatement *st) const
1961 if (!(st->Test()->Check(checker)->HasTypeFlag(TypeFlag::ETS_BOOLEAN | TypeFlag::BOOLEAN_LIKE) ||
1962 st->Test()->Check(checker)->ToString() == "Boolean")) {
1963 checker->LogTypeError("Bad operand type, the type of the operand must be boolean type.", st->Test()->Start());
1966 if (st->Second() != nullptr) {
1967 auto *msgType = st->second_->Check(checker);
1970 checker->LogTypeError("Assert message must be string", st->Second()->Start());
1977 checker::Type *ETSAnalyzer::Check(ir::BlockStatement *st) const
1980 checker::ScopeContext scopeCtx(checker, st->Scope());
1985 for (std::size_t idx = 0; idx < st->Statements().size(); ++idx) {
1986 auto *stmt = st->Statements()[idx];
1990 if (auto const tb = st->trailingBlocks_.find(stmt); tb != st->trailingBlocks_.end()) {
1993 st->Statements().emplace(std::next(st->Statements().begin() + idx), trailingBlock);
2000 checker->GetDebugInfoPlugin()->AddPrologueEpilogue(st);
2004 if (auto const *const scope = st->Scope();
2005 scope->IsFunctionScope() && st->Parent()->Parent()->Parent()->IsMethodDefinition()) {
2020 checker::Type *ETSAnalyzer::Check(ir::BreakStatement *st) const
2023 auto node = checker->FindJumpTarget(st);
2027 st->SetTarget(*node);
2029 checker->Context().OnBreakStatement(st);
2033 checker::Type *ETSAnalyzer::Check(ir::ClassDeclaration *st) const
2036 st->Definition()->Check(checker);
2040 checker::Type *ETSAnalyzer::Check(ir::ContinueStatement *st) const
2043 auto node = checker->FindJumpTarget(st);
2047 st->SetTarget(*node);
2053 checker::Type *ETSAnalyzer::Check(ir::DoWhileStatement *st) const
2056 checker::ScopeContext scopeCtx(checker, st->Scope());
2059 auto [smartCasts, clearFlag] = checker->Context().EnterLoop(*st);
2061 checker->CheckTruthinessOfType(st->Test());
2062 st->Body()->Check(checker);
2064 checker->Context().ExitLoop(smartCasts, clearFlag, st);
2068 checker::Type *ETSAnalyzer::Check([[maybe_unused]] ir::EmptyStatement *st) const
2073 checker::Type *ETSAnalyzer::Check(ir::ExpressionStatement *st) const
2076 return st->GetExpression()->Check(checker);
2079 static bool ValidateAndProcessIteratorType(ETSChecker *checker, Type *elemType, ir::ForOfStatement *const st)
2081 checker::Type *iterType = GetIteratorType(checker, elemType, st->Left());
2087 relation->SetNode(st->Left()->IsVariableDeclaration()
2088 ? st->Left()->AsVariableDeclaration()->Declarators().front()->Id()
2089 : st->Left()->AsIdentifier());
2095 checker->LogTypeError(ss.str(), st->Start());
2103 st->Left()->IsVariableDeclaration()) {
2104 for (auto &declarator : st->Left()->AsVariableDeclaration()->Declarators()) {
2117 checker::Type *ETSAnalyzer::Check(ir::ForOfStatement *const st) const
2120 checker::ScopeContext scopeCtx(checker, st->Scope());
2123 auto [smartCasts, clearFlag] = checker->Context().EnterLoop(*st);
2125 checker::Type *const exprType = st->Right()->Check(checker);
2127 checker->LogTypeError(MISSING_SOURCE_EXPR_TYPE, st->Right()->Start());
2142 elemType = st->CheckIteratorMethod(checker);
2146 checker->LogTypeError(INVALID_SOURCE_EXPR_TYPE, st->Right()->Start());
2150 st->Left()->Check(checker);
2152 if (!ValidateAndProcessIteratorType(checker, elemType, st)) {
2156 st->Body()->Check(checker);
2158 checker->Context().ExitLoop(smartCasts, clearFlag, st);
2162 checker::Type *ETSAnalyzer::Check(ir::ForUpdateStatement *st) const
2165 checker::ScopeContext scopeCtx(checker, st->Scope());
2168 auto [smartCasts, clearFlag] = checker->Context().EnterLoop(*st);
2170 if (st->Init() != nullptr) {
2171 st->Init()->Check(checker);
2174 if (st->Test() != nullptr) {
2175 checker->CheckTruthinessOfType(st->Test());
2178 if (st->Update() != nullptr) {
2179 st->Update()->Check(checker);
2182 st->Body()->Check(checker);
2184 checker->Context().ExitLoop(smartCasts, clearFlag, st);
2188 checker::Type *ETSAnalyzer::Check(ir::IfStatement *st) const
2193 checker->CheckTruthinessOfType(st->Test());
2202 st->Consequent()->Check(checker);
2215 if (st->Alternate() != nullptr) {
2217 st->Alternate()->Check(checker);
2241 checker::Type *ETSAnalyzer::Check(ir::LabelledStatement *st) const
2244 st->body_->Check(checker);
2248 bool ETSAnalyzer::CheckInferredFunctionReturnType(ir::ReturnStatement *st, ir::ScriptFunction *containingFunc,
2253 if (returnTypeAnnotation->IsTSThisType() && (st->Argument() == nullptr || !st->Argument()->IsThisExpression())) {
2255 st->Start());
2261 if (st->argument_ == nullptr) {
2264 checker->LogTypeError("Missing return value.", st->Start());
2270 if (!CheckArgumentVoidType(funcReturnType, checker, name, st)) {
2274 if (st->argument_->IsObjectExpression()) {
2275 st->argument_->AsObjectExpression()->SetPreferredType(funcReturnType);
2277 if (st->argument_->IsMemberExpression()) {
2278 checker->SetArrayPreferredTypeForNestedMemberExpressions(st->argument_->AsMemberExpression(),
2282 if (st->argument_->IsArrayExpression()) {
2283 st->argument_->AsArrayExpression()->SetPreferredType(funcReturnType);
2286 checker::Type *argumentType = st->argument_->Check(checker);
2287 return CheckReturnType(checker, funcReturnType, argumentType, st->argument_, containingFunc->IsAsyncFunc());
2292 checker::Type *ETSAnalyzer::GetFunctionReturnType(ir::ReturnStatement *st, ir::ScriptFunction *containingFunc) const
2300 if (!CheckInferredFunctionReturnType(st, containingFunc, funcReturnType, returnTypeAnnotation, checker)) {
2307 st->argument_); // This removes the NEED_RETURN_TYPE flag, so only the first return
2311 ProcessReturnStatements(checker, containingFunc, funcReturnType, st,
2312 st->argument_); // and the remaining return statements will get processed here.
2316 if ((st->argument_ != nullptr) && st->argument_->IsArrayExpression() && funcReturnType->IsArrayType()) {
2317 checker->ModifyPreferredType(st->argument_->AsArrayExpression(), funcReturnType);
2318 st->argument_->Check(checker);
2324 checker::Type *ETSAnalyzer::Check(ir::ReturnStatement *st) const
2328 ir::AstNode *ancestor = util::Helpers::FindAncestorGivenByType(st, ir::AstNodeType::SCRIPT_FUNCTION);
2335 if (st->argument_ != nullptr) {
2336 checker->LogTypeError("Return statement with expression isn't allowed in constructor.", st->Start());
2342 st->returnType_ = GetFunctionReturnType(st, containingFunc);
2345 containingFunc->AddReturnStatement(st);
2351 checker::Type *ETSAnalyzer::Check(ir::SwitchStatement *st) const
2354 checker::ScopeContext scopeCtx(checker, st->Scope());
2358 auto *comparedExprType = checker->CheckSwitchDiscriminant(st->Discriminant());
2359 auto unboxedDiscType = (st->Discriminant()->GetBoxingUnboxingFlags() & ir::BoxingUnboxingFlags::UNBOXING_FLAG) != 0U
2366 for (auto &it : st->Cases()) {
2368 it->CheckAndTestCase(checker, comparedExprType, unboxedDiscType, st->Discriminant(), hasDefaultCase);
2371 if (it != st->Cases().back()) {
2381 checker->Context().AddBreakSmartCasts(st, checker->Context().CloneSmartCasts());
2389 checker->Context().AddBreakSmartCasts(st, std::move(smartCasts));
2393 checker->Context().CombineBreakSmartCasts(st);
2395 checker->CheckForSameSwitchCases(st->Cases());
2399 checker::Type *ETSAnalyzer::Check(ir::ThrowStatement *st) const
2402 auto *argType = st->argument_->Check(checker);
2403 checker->CheckExceptionOrErrorType(argType, st->Start());
2406 checker->CheckThrowingStatements(st);
2413 checker::Type *ETSAnalyzer::Check(ir::TryStatement *st) const
2419 auto smartCasts = checker->Context().CheckTryBlock(*st->Block());
2420 st->Block()->Check(checker);
2423 for (auto *catchClause : st->CatchClauses()) {
2450 if (st->HasFinalizer()) {
2451 st->FinallyBlock()->Check(checker);
2457 checker::Type *ETSAnalyzer::Check(ir::VariableDeclarator *st) const
2459 if (st->TsTypeOrError() != nullptr) {
2460 return st->TsTypeOrError();
2464 ASSERT(st->Id()->IsIdentifier());
2465 auto *const ident = st->Id()->AsIdentifier();
2477 auto *const variableType = checker->CheckVariableDeclaration(ident, ident->TypeAnnotation(), st->Init(), flags);
2482 if (auto *const initType = st->Init() != nullptr ? st->Init()->TsTypeOrError() : nullptr; initType != nullptr) {
2492 st->SetTsType(smartType);
2496 checker::Type *ETSAnalyzer::Check(ir::VariableDeclaration *st) const
2499 for (auto *it : st->Declarators()) {
2506 checker::Type *ETSAnalyzer::Check(ir::WhileStatement *st) const
2509 checker::ScopeContext scopeCtx(checker, st->Scope());
2512 auto [smartCasts, clearFlag] = checker->Context().EnterLoop(*st);
2514 checker->CheckTruthinessOfType(st->Test());
2515 st->Body()->Check(checker);
2517 checker->Context().ExitLoop(smartCasts, clearFlag, st);
2601 checker::Type *ETSAnalyzer::Check(ir::TSEnumDeclaration *st) const
2604 varbinder::Variable *enumVar = st->Key()->Variable();
2609 Check(st->BoxedClass());
2610 if (auto *const itemInit = st->Members().front()->AsTSEnumMember()->Init(); itemInit->IsNumberLiteral()) {
2611 etsEnumType = checker->CreateEnumIntTypeFromEnumDeclaration(st);
2613 etsEnumType = checker->CreateEnumStringTypeFromEnumDeclaration(st);
2615 checker->LogTypeError("Invalid enumeration value type.", st->Start());
2616 st->SetTsType(checker->GlobalTypeError());
2617 return st->TsTypeOrError();
2619 st->SetTsType(etsEnumType);
2622 } else if (st->TsTypeOrError() == nullptr) {
2623 st->SetTsType(enumVar->TsTypeOrError());
2626 return st->TsTypeOrError();
2629 checker::Type *ETSAnalyzer::Check(ir::TSInterfaceDeclaration *st) const
2635 if (st->TsTypeOrError() != nullptr) {
2636 return st->TsTypeOrError();
2639 interfaceType = checker->BuildBasicInterfaceProperties(st);
2643 st->SetTsType(interfaceType);
2645 checker::ScopeContext scopeCtx(checker, st->Scope());
2648 for (auto *it : st->Body()->Body()) {
2716 checker::Type *ETSAnalyzer::Check(ir::TSTypeAliasDeclaration *st) const
2719 if (st->TypeParams() == nullptr) {
2723 if (st->TypeAnnotation()->TsTypeOrError() == nullptr) {
2724 st->TypeAnnotation()->Check(checker);
2730 if (st->TypeParameterTypes().empty()) {
2731 auto [typeParamTypes, ok] = checker->CreateUnconstrainedTypeParameters(st->TypeParams());
2732 st->SetTypeParameterTypes(std::move(typeParamTypes));
2734 checker->AssignTypeParameterConstraints(st->TypeParams());
2738 for (auto *const param : st->TypeParams()->Params()) {
2739 const auto *const res = st->TypeAnnotation()->FindChild([¶m](const ir::AstNode *const node) {
2758 if (st->TypeAnnotation()->TsTypeOrError() == nullptr) {
2759 st->TypeAnnotation()->Check(checker);