From 307fbfd8e78adaadd3ee83e6e44c2d6e68261387 Mon Sep 17 00:00:00 2001 From: yp9522 Date: Tue, 1 Jul 2025 14:34:23 +0800 Subject: [PATCH] fix check not null Issue: https://gitee.com/openharmony/arkcompiler_ets_frontend/issues/ICJ4E0 Signed-off-by: yp9522 --- ets2panda/checker/TSAnalyzer.cpp | 4 ++ ets2panda/checker/ts/helpers.cpp | 5 ++- ets2panda/checker/ts/object.cpp | 4 ++ ets2panda/checker/ts/typeCreation.cpp | 6 ++- .../checker/types/ets/etsFunctionType.cpp | 20 ++++++---- ets2panda/checker/types/ets/etsObjectType.cpp | 5 +++ .../types/ets/etsPartialTypeParameter.cpp | 9 ++++- ets2panda/checker/types/ets/etsTupleType.cpp | 1 + ets2panda/checker/types/ets/etsTupleType.h | 5 ++- .../checker/types/ets/etsTypeParameter.cpp | 1 + ets2panda/checker/types/ets/etsUnionType.cpp | 2 + ets2panda/checker/types/signature.cpp | 5 ++- ets2panda/checker/types/signature.h | 1 + ets2panda/checker/types/ts/interfaceType.cpp | 3 +- .../checker/types/ts/objectDescriptor.cpp | 4 +- ets2panda/checker/types/ts/unionType.cpp | 4 +- ets2panda/checker/types/typeRelation.cpp | 3 +- ets2panda/parser/TSparser.cpp | 7 ++++ ets2panda/parser/expressionParser.cpp | 25 ++++++++++++ ets2panda/parser/expressionTSParser.cpp | 8 ++++ ets2panda/parser/parserImpl.cpp | 18 ++++++++- ets2panda/parser/program/program.cpp | 3 +- ets2panda/parser/statementParser.cpp | 40 +++++++++++++++++++ ets2panda/parser/statementTSParser.cpp | 6 +++ 24 files changed, 169 insertions(+), 20 deletions(-) diff --git a/ets2panda/checker/TSAnalyzer.cpp b/ets2panda/checker/TSAnalyzer.cpp index cfaad3f534..84390e83d6 100644 --- a/ets2panda/checker/TSAnalyzer.cpp +++ b/ets2panda/checker/TSAnalyzer.cpp @@ -107,6 +107,7 @@ checker::Type *TSAnalyzer::Check(ir::TSMethodSignature *node) const } returnType->Check(checker); + CHECK_NOT_NULL(callSignature); callSignature->SetReturnType(returnType->GetType(checker)); return nullptr; @@ -787,6 +788,7 @@ void TSAnalyzer::CheckNonComputed(checker::ObjectDescriptor *desc, ir::Expressio auto *memberVar = varbinder::Scope::CreateVar(checker->Allocator(), propName, flags, it); + CHECK_NOT_NULL(memberVar); if (inConstContext) { memberVar->AddFlag(varbinder::VariableFlags::READONLY); } else { @@ -1342,6 +1344,7 @@ static void CheckSimpleVariableDeclaration(checker::TSChecker *checker, ir::Vari initializerType = checker->GetBaseTypeOfLiteralType(initializerType); } + CHECK_NOT_NULL(initializerType); if (initializerType->IsNullType()) { checker->ThrowTypeError( {"Cannot infer type for variable '", declarator->Id()->AsIdentifier()->Name(), "'."}, @@ -1729,6 +1732,7 @@ static void AddEnumValueDeclaration(checker::TSChecker *checker, double number, if (res == nullptr) { auto *decl = checker->Allocator()->New(memberStr); + CHECK_NOT_NULL(decl); decl->BindNode(variable->Declaration()->Node()); enumScope->AddDecl(checker->Allocator(), decl, ScriptExtension::TS); res = enumScope->FindLocal(memberStr, varbinder::ResolveBindingOptions::BINDINGS); diff --git a/ets2panda/checker/ts/helpers.cpp b/ets2panda/checker/ts/helpers.cpp index 9c2455f558..e8c2ae8248 100644 --- a/ets2panda/checker/ts/helpers.cpp +++ b/ets2panda/checker/ts/helpers.cpp @@ -59,7 +59,7 @@ Type *TSChecker::GetBaseTypeOfLiteralType(Type *type) if (HasStatus(CheckerStatus::KEEP_LITERAL_TYPE)) { return type; } - + CHECK_NOT_NULL(type); if (type->IsStringLiteralType()) { return GlobalStringType(); } @@ -370,6 +370,7 @@ void TSChecker::GetTypeVar(varbinder::Decl *decl) util::Helpers::FindAncestorGivenByType(decl->Node(), ir::AstNodeType::VARIABLE_DECLARATOR); ES2PANDA_ASSERT(declarator); + CHECK_NOT_NULL(declarator); if (declarator->AsVariableDeclarator()->Id()->IsIdentifier()) { InferSimpleVariableDeclaratorType(declarator->AsVariableDeclarator()); return; @@ -382,6 +383,7 @@ void TSChecker::GetTypeParam(varbinder::Variable *var, varbinder::Decl *decl) { ir::AstNode *declaration = FindAncestorUntilGivenType(decl->Node(), ir::AstNodeType::SCRIPT_FUNCTION); + CHECK_NOT_NULL(declaration); if (declaration->IsIdentifier()) { auto *ident = declaration->AsIdentifier(); if (ident->TypeAnnotation() != nullptr) { @@ -499,6 +501,7 @@ Type *TSChecker::GetTypeFromClassOrInterfaceReference([[maybe_unused]] ir::TSTyp if (resolvedType == nullptr) { ObjectDescriptor *desc = Allocator()->New(Allocator()); resolvedType = Allocator()->New(Allocator(), var->Name(), desc); + CHECK_NOT_NULL(resolvedType); resolvedType->SetVariable(var); var->SetTsType(resolvedType); } diff --git a/ets2panda/checker/ts/object.cpp b/ets2panda/checker/ts/object.cpp index d0b36c61dc..3d06163e96 100644 --- a/ets2panda/checker/ts/object.cpp +++ b/ets2panda/checker/ts/object.cpp @@ -139,6 +139,7 @@ void TSChecker::ResolveUnionTypeMembers(UnionType *type) } } + CHECK_NOT_NULL(desc); desc->callSignatures = callSignatures; desc->constructSignatures = constructSignatures; @@ -333,6 +334,7 @@ varbinder::Variable *TSChecker::GetPropertyOfUnionType(UnionType *type, const ut } varbinder::Variable *syntheticProp = varbinder::Scope::CreateVar(Allocator(), name, flags, nullptr); + CHECK_NOT_NULL(syntheticProp); syntheticProp->SetTsType(CreateUnionType(std::move(collectedTypes))); type->CachedSyntheticProperties().insert({name, syntheticProp}); return syntheticProp; @@ -390,6 +392,7 @@ Type *TSChecker::GetPropertyTypeForIndexType(Type *type, Type *indexType) return type->AsArrayType()->ElementType(); } + CHECK_NOT_NULL(indexType); if (indexType->HasTypeFlag(TypeFlag::STRING_LITERAL | TypeFlag::NUMBER_LITERAL)) { varbinder::Variable *prop = nullptr; @@ -453,6 +456,7 @@ ArenaVector TSChecker::GetBaseTypes(InterfaceType *type) for (auto *extends : declaration->Extends()) { Type *baseType = extends->Expr()->GetType(this); + CHECK_NOT_NULL(baseType); if (!baseType->HasTypeFlag(TypeFlag::OBJECT | TypeFlag::NON_PRIMITIVE | TypeFlag::ANY)) { ThrowTypeError( "An interface can only extend an object type or intersection of object types with statically " diff --git a/ets2panda/checker/ts/typeCreation.cpp b/ets2panda/checker/ts/typeCreation.cpp index c40b8b1ed7..144178af71 100644 --- a/ets2panda/checker/ts/typeCreation.cpp +++ b/ets2panda/checker/ts/typeCreation.cpp @@ -1,5 +1,5 @@ /** - * Copyright (c) 2021-2024 Huawei Device Co., Ltd. + * Copyright (c) 2021-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -125,6 +125,7 @@ Type *TSChecker::CreateUnionType(ArenaVector &&constituentTypes) Type *TSChecker::CreateObjectTypeWithCallSignature(Signature *callSignature) { auto *objType = Allocator()->New(Allocator()->New(Allocator())); + CHECK_NOT_NULL(objType); objType->AddCallSignature(callSignature); return objType; } @@ -132,6 +133,7 @@ Type *TSChecker::CreateObjectTypeWithCallSignature(Signature *callSignature) Type *TSChecker::CreateObjectTypeWithConstructSignature(Signature *constructSignature) { auto *objType = Allocator()->New(Allocator()->New(Allocator())); + CHECK_NOT_NULL(objType); objType->AddConstructSignature(constructSignature); return objType; } @@ -139,6 +141,7 @@ Type *TSChecker::CreateObjectTypeWithConstructSignature(Signature *constructSign Type *TSChecker::CreateFunctionTypeWithSignature(Signature *callSignature) { auto *funcObjType = Allocator()->New(Allocator()->New(Allocator())); + CHECK_NOT_NULL(funcObjType); funcObjType->AddCallSignature(callSignature); return funcObjType; } @@ -146,6 +149,7 @@ Type *TSChecker::CreateFunctionTypeWithSignature(Signature *callSignature) Type *TSChecker::CreateConstructorTypeWithSignature(Signature *constructSignature) { auto *constructObjType = Allocator()->New(Allocator()->New(Allocator())); + CHECK_NOT_NULL(constructObjType); constructObjType->AddConstructSignature(constructSignature); return constructObjType; } diff --git a/ets2panda/checker/types/ets/etsFunctionType.cpp b/ets2panda/checker/types/ets/etsFunctionType.cpp index 0ec3b4ecac..ad6d385a2a 100644 --- a/ets2panda/checker/types/ets/etsFunctionType.cpp +++ b/ets2panda/checker/types/ets/etsFunctionType.cpp @@ -46,9 +46,12 @@ ETSFunctionType::ETSFunctionType(ETSChecker *checker, Signature *signature) extensionFunctionSigs_(ArenaVector(checker->ProgramAllocator()->Adapter())), extensionAccessorSigs_(ArenaVector(checker->ProgramAllocator()->Adapter())), name_(""), - assemblerName_(checker->GlobalBuiltinFunctionType(signature->MinArgCount(), signature->HasRestParameter()) - ->AsETSObjectType() - ->AssemblerName()) + assemblerName_(checker->GlobalBuiltinFunctionType(signature->MinArgCount(), signature->HasRestParameter()) != + nullptr + ? checker->GlobalBuiltinFunctionType(signature->MinArgCount(), signature->HasRestParameter()) + ->AsETSObjectType() + ->AssemblerName() + : "") { } @@ -56,11 +59,12 @@ ETSFunctionType::ETSFunctionType(ETSChecker *checker, Signature *signature) static void HackThisParameterInExtensionFunctionInvoke(ETSObjectType *interface, size_t arity) { auto invokeName = FunctionalInterfaceInvokeName(arity, false); - auto &callSigsOfInvoke0 = interface->AsETSObjectType() - ->GetOwnProperty(util::StringView(invokeName)) - ->TsType() - ->AsETSFunctionType() - ->CallSignatures(); + auto *property = interface->AsETSObjectType()->GetOwnProperty( + util::StringView(invokeName)); + CHECK_NOT_NULL(property); + auto *tsType = property->TsType(); + CHECK_NOT_NULL(tsType); + auto &callSigsOfInvoke0 = tsType->AsETSFunctionType()->CallSignatures(); for (auto sig : callSigsOfInvoke0) { sig->AddSignatureFlag(SignatureFlags::THIS_RETURN_TYPE); } diff --git a/ets2panda/checker/types/ets/etsObjectType.cpp b/ets2panda/checker/types/ets/etsObjectType.cpp index e7d2fb4229..d83a2c49a5 100644 --- a/ets2panda/checker/types/ets/etsObjectType.cpp +++ b/ets2panda/checker/types/ets/etsObjectType.cpp @@ -238,6 +238,7 @@ varbinder::LocalVariable *ETSObjectType::CreateSyntheticVarFromEverySignature(co for (auto &s : signatures) { funcType->AddCallSignature(s); } + CHECK_NOT_NULL(res); res->SetTsType(funcType); funcType->SetVariable(res); @@ -1069,6 +1070,7 @@ varbinder::LocalVariable *ETSObjectType::CopyProperty(varbinder::LocalVariable * if (copiedPropType->Variable() == prop) { copiedPropType->SetVariable(copiedProp); } + CHECK_NOT_NULL(copiedProp); copiedProp->SetTsType(copiedPropType); return copiedProp; } @@ -1089,6 +1091,7 @@ Type *ETSObjectType::Instantiate(ArenaAllocator *const allocator, TypeRelation * auto *const copiedType = checker->CreateETSObjectType(declNode_, flags_); ES2PANDA_ASSERT(copiedType->internalName_ == internalName_); ES2PANDA_ASSERT(copiedType->name_ == name_); + CHECK_NOT_NULL(copiedType); copiedType->typeFlags_ = typeFlags_; copiedType->RemoveObjectFlag(ETSObjectFlags::INCOMPLETE_INSTANTIATION | ETSObjectFlags::CHECKED_INVOKE_LEGITIMACY); copiedType->SetVariable(variable_); @@ -1136,6 +1139,7 @@ static varbinder::LocalVariable *CopyPropertyWithTypeArguments(varbinder::LocalV if (copiedPropType->Variable() == prop || copiedPropType->Variable() == nullptr) { copiedPropType->SetVariable(copiedProp); } + CHECK_NOT_NULL(copiedProp); copiedProp->SetTsType(copiedPropType); return copiedProp; } @@ -1186,6 +1190,7 @@ static ArenaSubstitution *ComputeEffectiveSubstitution(TypeRelation *const relat void ETSObjectType::SetCopiedTypeProperties(TypeRelation *const relation, ETSObjectType *const copiedType, ArenaVector &&newTypeArgs, ETSObjectType *base) { + CHECK_NOT_NULL(copiedType); copiedType->typeFlags_ = typeFlags_; copiedType->RemoveObjectFlag(ETSObjectFlags::INCOMPLETE_INSTANTIATION | ETSObjectFlags::CHECKED_INVOKE_LEGITIMACY); copiedType->SetVariable(variable_); diff --git a/ets2panda/checker/types/ets/etsPartialTypeParameter.cpp b/ets2panda/checker/types/ets/etsPartialTypeParameter.cpp index 14b5577976..5b9c8be9e7 100644 --- a/ets2panda/checker/types/ets/etsPartialTypeParameter.cpp +++ b/ets2panda/checker/types/ets/etsPartialTypeParameter.cpp @@ -82,8 +82,13 @@ void ETSPartialTypeParameter::IsSubtypeOf(TypeRelation *relation, Type *target) ETSPartialTypeParameter *ETSPartialTypeParameter::Instantiate(ArenaAllocator *allocator, TypeRelation *relation, GlobalTypesHolder *globalTypes) { - return allocator->New( - GetUnderlying()->Instantiate(allocator, relation, globalTypes)->AsETSTypeParameter(), checker_); + auto *underlying = GetUnderlying(); + CHECK_NOT_NULL(underlying); + auto *instantiated = underlying->Instantiate(allocator, relation, globalTypes); + CHECK_NOT_NULL(instantiated); + auto *typeParam = instantiated->AsETSTypeParameter(); + CHECK_NOT_NULL(typeParam); + return allocator->New(typeParam, checker_); } Type *ETSPartialTypeParameter::Substitute(TypeRelation *relation, const Substitution *substitution) diff --git a/ets2panda/checker/types/ets/etsTupleType.cpp b/ets2panda/checker/types/ets/etsTupleType.cpp index d0eb6e7034..c0d8000560 100644 --- a/ets2panda/checker/types/ets/etsTupleType.cpp +++ b/ets2panda/checker/types/ets/etsTupleType.cpp @@ -198,6 +198,7 @@ Type *ETSTupleType::Instantiate([[maybe_unused]] ArenaAllocator *allocator, [[ma { auto *const checker = relation->GetChecker()->AsETSChecker(); auto *const tupleType = allocator->New(checker, GetTupleTypesList()); + CHECK_NOT_NULL(tupleType); tupleType->typeFlags_ = typeFlags_; return tupleType; } diff --git a/ets2panda/checker/types/ets/etsTupleType.h b/ets2panda/checker/types/ets/etsTupleType.h index 2a326dedf9..f6a76125a9 100644 --- a/ets2panda/checker/types/ets/etsTupleType.h +++ b/ets2panda/checker/types/ets/etsTupleType.h @@ -28,7 +28,10 @@ public: explicit ETSTupleType(ETSChecker *checker, const ArenaVector &typeList) : Type(checker::TypeFlag::ETS_TUPLE), typeList_(typeList), - wrapperType_(checker->GlobalBuiltinTupleType(typeList_.size())->AsETSObjectType()) + // NOLINTNEXTLINE(readability-implicit-bool-conversion) + wrapperType_(checker->GlobalBuiltinTupleType(typeList_.size()) != nullptr + ? checker->GlobalBuiltinTupleType(typeList_.size())->AsETSObjectType() + : nullptr) { typeFlags_ |= TypeFlag::ETS_TUPLE; } diff --git a/ets2panda/checker/types/ets/etsTypeParameter.cpp b/ets2panda/checker/types/ets/etsTypeParameter.cpp index 518a42441b..c947d68e93 100644 --- a/ets2panda/checker/types/ets/etsTypeParameter.cpp +++ b/ets2panda/checker/types/ets/etsTypeParameter.cpp @@ -127,6 +127,7 @@ Type *ETSTypeParameter::Instantiate([[maybe_unused]] ArenaAllocator *allocator, auto *const checker = relation->GetChecker()->AsETSChecker(); auto *const copiedType = checker->CreateTypeParameter(); + CHECK_NOT_NULL(copiedType); copiedType->AddTypeFlag(TypeFlag::GENERIC); copiedType->SetDeclNode(GetDeclNode()); copiedType->SetDefaultType(GetDefaultType()); diff --git a/ets2panda/checker/types/ets/etsUnionType.cpp b/ets2panda/checker/types/ets/etsUnionType.cpp index 34f539ad85..d8fc972091 100644 --- a/ets2panda/checker/types/ets/etsUnionType.cpp +++ b/ets2panda/checker/types/ets/etsUnionType.cpp @@ -65,6 +65,7 @@ bool ETSUnionType::TypeRelatedToSomeType(TypeRelation *relation, Type *source, E Type *ETSUnionType::ComputeAssemblerLUB(ETSChecker *checker, ETSUnionType *un) { auto *const apparent = checker->GetApparentType(un); + CHECK_NOT_NULL(apparent); if (!apparent->IsETSUnionType()) { return apparent; } @@ -368,6 +369,7 @@ bool ETSUnionType::ExtractType(checker::ETSChecker *checker, checker::Type *sour constituentType = constituentType->AsETSTypeParameter()->GetConstraintType(); } else if (constituentType->HasTypeFlag(checker::TypeFlag::GENERIC)) { constituentType = constituentType->Clone(checker); + CHECK_NOT_NULL(constituentType); constituentType->RemoveTypeFlag(checker::TypeFlag::GENERIC); } diff --git a/ets2panda/checker/types/signature.cpp b/ets2panda/checker/types/signature.cpp index be45282d5f..fcf1642081 100644 --- a/ets2panda/checker/types/signature.cpp +++ b/ets2panda/checker/types/signature.cpp @@ -35,7 +35,7 @@ Signature *Signature::Substitute(TypeRelation *relation, const Substitution *sub auto *allocator = checker->ProgramAllocator(); bool anyChange = false; SignatureInfo *newSigInfo = allocator->New(allocator); - + CHECK_NOT_NULL(newSigInfo); if (!signatureInfo_->typeParams.empty()) { for (auto *tparam : signatureInfo_->typeParams) { auto *newTparam = tparam->Substitute(relation, substitution); @@ -82,6 +82,7 @@ Signature *Signature::Substitute(TypeRelation *relation, const Substitution *sub Signature *Signature::CreateSignatureForSubstitute(ArenaAllocator *allocator, SignatureInfo *sigInfo, Type *returnType) { auto *result = allocator->New(sigInfo, returnType, func_); + CHECK_NOT_NULL(result); result->flags_ = flags_; result->internalName_ = internalName_; result->ownerObj_ = ownerObj_; @@ -124,6 +125,7 @@ Signature *Signature::Copy(ArenaAllocator *allocator, TypeRelation *relation, Gl } auto *const copiedSignature = allocator->New(copiedInfo, returnType_, func_); + CHECK_NOT_NULL(copiedSignature); copiedSignature->flags_ = flags_; copiedSignature->internalName_ = internalName_; copiedSignature->ownerObj_ = ownerObj_; @@ -289,6 +291,7 @@ Signature *Signature::ToArrowSignature(ETSChecker *checker) { auto *allocator = checker->ProgramAllocator(); auto *sigInfo = allocator->New(signatureInfo_, allocator); + CHECK_NOT_NULL(sigInfo); for (auto param : sigInfo->params) { param->SetTsType(checker->MaybeBoxType(param->TsType())); } diff --git a/ets2panda/checker/types/signature.h b/ets2panda/checker/types/signature.h index 8515f6b0ca..c84d461c74 100644 --- a/ets2panda/checker/types/signature.h +++ b/ets2panda/checker/types/signature.h @@ -49,6 +49,7 @@ public: if (other->restVar != nullptr) { restVar = other->restVar->Copy(allocator, other->restVar->Declaration()); + CHECK_NOT_NULL(restVar); restVar->SetTsType(other->restVar->TsType()); } } diff --git a/ets2panda/checker/types/ts/interfaceType.cpp b/ets2panda/checker/types/ts/interfaceType.cpp index 724bee9caa..e592781109 100644 --- a/ets2panda/checker/types/ts/interfaceType.cpp +++ b/ets2panda/checker/types/ts/interfaceType.cpp @@ -1,5 +1,5 @@ /** - * Copyright (c) 2021-2024 Huawei Device Co., Ltd. + * Copyright (c) 2021-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -148,6 +148,7 @@ Type *InterfaceType::Instantiate(ArenaAllocator *allocator, TypeRelation *relati Type *newInterfaceType = allocator->New(allocator, name_, copiedDesc); + CHECK_NOT_NULL(newInterfaceType); for (auto *it : bases_) { newInterfaceType->AsObjectType()->AsInterfaceType()->AddBase( it->Instantiate(allocator, relation, globalTypes)->AsObjectType()); diff --git a/ets2panda/checker/types/ts/objectDescriptor.cpp b/ets2panda/checker/types/ts/objectDescriptor.cpp index a418e6815b..2b2b240263 100644 --- a/ets2panda/checker/types/ts/objectDescriptor.cpp +++ b/ets2panda/checker/types/ts/objectDescriptor.cpp @@ -1,5 +1,5 @@ /** - * Copyright (c) 2021-2024 Huawei Device Co., Ltd. + * Copyright (c) 2021-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -34,10 +34,12 @@ varbinder::LocalVariable *ObjectDescriptor::FindProperty(const util::StringView void ObjectDescriptor::Copy(ArenaAllocator *allocator, ObjectDescriptor *copiedDesc, TypeRelation *relation, GlobalTypesHolder *globalTypes) { + CHECK_NOT_NULL(copiedDesc); // copy by hand for (auto *it : properties) { auto *copiedProp = it->Copy(allocator, it->Declaration()); copiedProp->SetTsType(it->TsType()->Instantiate(allocator, relation, globalTypes)); + CHECK_NOT_NULL(copiedDesc); copiedDesc->properties.push_back(copiedProp); } diff --git a/ets2panda/checker/types/ts/unionType.cpp b/ets2panda/checker/types/ts/unionType.cpp index 8ba291ba7b..0a34cc3e9c 100644 --- a/ets2panda/checker/types/ts/unionType.cpp +++ b/ets2panda/checker/types/ts/unionType.cpp @@ -1,5 +1,5 @@ /** - * Copyright (c) 2021-2024 Huawei Device Co., Ltd. + * Copyright (c) 2021-2025 Huawei Device Co., Ltd. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at @@ -111,6 +111,7 @@ void UnionType::RemoveDuplicatedTypes(TypeRelation *relation, ArenaVectorHasConstituentFlag(TypeFlag::ANY)) { return globalTypesHolder->GlobalAnyType(); } @@ -184,6 +185,7 @@ Type *UnionType::Instantiate(ArenaAllocator *allocator, TypeRelation *relation, Type *newUnionType = allocator->New(allocator, std::move(copiedConstituents)); + CHECK_NOT_NULL(newUnionType); return HandleUnionType(newUnionType->AsUnionType(), globalTypes); } } // namespace ark::es2panda::checker diff --git a/ets2panda/checker/types/typeRelation.cpp b/ets2panda/checker/types/typeRelation.cpp index 130fa19dbb..cca16ef500 100644 --- a/ets2panda/checker/types/typeRelation.cpp +++ b/ets2panda/checker/types/typeRelation.cpp @@ -35,7 +35,6 @@ RelationResult TypeRelation::CacheLookup(const Type *source, const Type *target, ES2PANDA_ASSERT(source != nullptr); ES2PANDA_ASSERT(target != nullptr); - auto key = RelationHolder::MakeKey(source->Id(), target->Id()); auto res = holder.Find(key); if (res == nullptr) { @@ -125,6 +124,8 @@ bool TypeRelation::IsAssignableTo(Type *source, Type *target) if (result_ == RelationResult::CACHE_MISS) { // NOTE: we support assigning T to Readonly, but do not support assigning Readonly to T // more details in spec + CHECK_NOT_NULL(source); + CHECK_NOT_NULL(target); if (source->HasTypeFlag(TypeFlag::READONLY) && !target->HasTypeFlag(TypeFlag::READONLY)) { result_ = RelationResult::FALSE; } diff --git a/ets2panda/parser/TSparser.cpp b/ets2panda/parser/TSparser.cpp index 164f34c170..18e568d2da 100644 --- a/ets2panda/parser/TSparser.cpp +++ b/ets2panda/parser/TSparser.cpp @@ -199,6 +199,7 @@ ir::TSTypeAliasDeclaration *TSParser::ParseTypeAliasDeclaration() const util::StringView &ident = Lexer()->GetToken().Ident(); auto *id = AllocNode(ident, Allocator()); + CHECK_NOT_NULL(id); id->SetRange(Lexer()->GetToken().Loc()); Lexer()->NextToken(); @@ -544,6 +545,7 @@ ir::TypeNode *TSParser::ParseTypeOperatorOrTypeReference() auto *inferType = AllocNode(typeParam, Allocator()); + CHECK_NOT_NULL(inferType); inferType->SetRange({inferStart, Lexer()->GetToken().End()}); return inferType; @@ -1020,6 +1022,7 @@ ir::TSIntersectionType *TSParser::ParseIntersectionType(ir::Expression *type, bo auto *intersectionType = AllocNode(std::move(types), Allocator()); auto *typeVar = varbinder::Scope::CreateVar(Allocator(), "__type", varbinder::VariableFlags::TYPE, intersectionType); + CHECK_NOT_NULL(intersectionType); intersectionType->SetVariable(typeVar); intersectionType->SetRange({startLoc, endLoc}); @@ -1041,6 +1044,7 @@ private: return parser->AllocNode(bigintNode, parser->Allocator()); } auto *numberNode = parser->AllocNode(lexer->GetToken().GetNumber()); + CHECK_NOT_NULL(numberNode); numberNode->SetRange(lexer->GetToken().Loc()); return parser->AllocNode(numberNode, parser->Allocator()); @@ -1534,6 +1538,7 @@ ir::TSIndexSignature *TSParser::ParseIndexSignature(const lexer::SourcePosition ES2PANDA_ASSERT(Lexer()->GetToken().Type() == lexer::TokenType::LITERAL_IDENT); auto *key = AllocNode(Lexer()->GetToken().Ident(), Allocator()); + CHECK_NOT_NULL(key); key->SetRange(Lexer()->GetToken().Loc()); Lexer()->NextToken(); // eat key @@ -1905,6 +1910,7 @@ ir::MethodDefinition *TSParser::ParseClassMethod(ClassElementDescriptor *desc, ir::ScriptFunction *func = ParseFunction(desc->newStatus); + CHECK_NOT_NULL(func); if (func->IsOverload() && !desc->decorators.empty()) { ThrowSyntaxError("A decorator can only decorate a method implementation, not an overload.", desc->decorators.front()->Start()); @@ -2110,6 +2116,7 @@ ir::AstNode *TSParser::ParseImportDefaultSpecifier(ArenaVector *s } auto *specifier = AllocNode(local); + CHECK_NOT_NULL(specifier); specifier->SetRange(specifier->Local()->Range()); specifiers->push_back(specifier); diff --git a/ets2panda/parser/expressionParser.cpp b/ets2panda/parser/expressionParser.cpp index 67500b59ac..c825c539c4 100644 --- a/ets2panda/parser/expressionParser.cpp +++ b/ets2panda/parser/expressionParser.cpp @@ -208,6 +208,7 @@ ir::ArrayExpression *ParserImpl::ParseArrayExpression(ExpressionParseFlags flags auto nodeType = inPattern ? ir::AstNodeType::ARRAY_PATTERN : ir::AstNodeType::ARRAY_EXPRESSION; auto *arrayExpressionNode = AllocNode(nodeType, std::move(elements), Allocator(), trailingComma); + CHECK_NOT_NULL(arrayExpressionNode); arrayExpressionNode->SetRange({startLoc, endLoc}); if (inPattern) { @@ -581,6 +582,7 @@ ir::Expression *ParserImpl::CreateBinaryAssignmentExpression(ir::Expression *ass auto *binaryAssignmentExpression = AllocNode(lhsExpression, assignmentExpression, tokenType); + CHECK_NOT_NULL(binaryAssignmentExpression); binaryAssignmentExpression->SetRange({lhsExpression->Start(), assignmentExpression->End()}); return binaryAssignmentExpression; @@ -596,6 +598,7 @@ ir::Expression *ParserImpl::ParseAssignmentExpression(ir::Expression *lhsExpress ir::Expression *consequent = ParseAssignmentExpressionHelper(); ir::Expression *alternate = ParseExpression(); auto *conditionalExpr = AllocNode(lhsExpression, consequent, alternate); + CHECK_NOT_NULL(conditionalExpr); conditionalExpr->SetRange({lhsExpression->Start(), alternate->End()}); return conditionalExpr; } @@ -709,6 +712,7 @@ ir::Expression *ParserImpl::ParseAssignmentEqualExpression(const lexer::TokenTyp auto *binaryAssignmentExpression = AllocNode(lhsExpression, assignmentExpression, tokenType); + CHECK_NOT_NULL(binaryAssignmentExpression); binaryAssignmentExpression->SetRange({lhsExpression->Start(), assignmentExpression->End()}); return binaryAssignmentExpression; @@ -851,6 +855,7 @@ ir::MetaProperty *ParserImpl::ParsePotentialNewTarget() } auto *metaProperty = AllocNode(ir::MetaProperty::MetaPropertyKind::NEW_TARGET); + CHECK_NOT_NULL(metaProperty); metaProperty->SetRange(loc); lexer_->NextToken(); return metaProperty; @@ -863,6 +868,7 @@ ir::MetaProperty *ParserImpl::ParsePotentialNewTarget() ir::Identifier *ParserImpl::ParsePrimaryExpressionIdent([[maybe_unused]] ExpressionParseFlags flags) { auto *identNode = AllocNode(lexer_->GetToken().Ident(), Allocator()); + CHECK_NOT_NULL(identNode); identNode->SetRange(lexer_->GetToken().Loc()); lexer_->NextToken(); @@ -875,6 +881,7 @@ ir::BooleanLiteral *ParserImpl::ParseBooleanLiteral() lexer_->GetToken().Type() == lexer::TokenType::LITERAL_FALSE); auto *booleanNode = AllocNode(lexer_->GetToken().Type() == lexer::TokenType::LITERAL_TRUE); + CHECK_NOT_NULL(booleanNode); booleanNode->SetRange(lexer_->GetToken().Loc()); lexer_->NextToken(); @@ -885,6 +892,7 @@ ir::NullLiteral *ParserImpl::ParseNullLiteral() { ES2PANDA_ASSERT(lexer_->GetToken().Type() == lexer::TokenType::LITERAL_NULL); auto *nullNode = AllocNode(); + CHECK_NOT_NULL(nullNode); nullNode->SetRange(lexer_->GetToken().Loc()); lexer_->NextToken(); @@ -914,6 +922,7 @@ ir::CharLiteral *ParserImpl::ParseCharLiteral() ES2PANDA_ASSERT(lexer_->GetToken().Type() == lexer::TokenType::LITERAL_CHAR); auto *charNode = AllocNode(lexer_->GetToken().Utf16()); + CHECK_NOT_NULL(charNode); charNode->SetRange(lexer_->GetToken().Loc()); lexer_->NextToken(); @@ -925,6 +934,7 @@ ir::StringLiteral *ParserImpl::ParseStringLiteral() ES2PANDA_ASSERT(lexer_->GetToken().Type() == lexer::TokenType::LITERAL_STRING); auto *stringNode = AllocNode(lexer_->GetToken().String()); + CHECK_NOT_NULL(stringNode); stringNode->SetRange(lexer_->GetToken().Loc()); lexer_->NextToken(); @@ -935,6 +945,7 @@ ir::UndefinedLiteral *ParserImpl::ParseUndefinedLiteral() { ES2PANDA_ASSERT(lexer_->GetToken().Type() == lexer::TokenType::KEYW_UNDEFINED); auto *undefinedNode = AllocNode(); + CHECK_NOT_NULL(undefinedNode); undefinedNode->SetRange(lexer_->GetToken().Loc()); lexer_->NextToken(); @@ -946,6 +957,7 @@ ir::ThisExpression *ParserImpl::ParseThisExpression() ES2PANDA_ASSERT(lexer_->GetToken().Type() == lexer::TokenType::KEYW_THIS); auto *thisExprNode = AllocNode(); + CHECK_NOT_NULL(thisExprNode); thisExprNode->SetRange(lexer_->GetToken().Loc()); lexer_->NextToken(); @@ -965,6 +977,7 @@ ir::RegExpLiteral *ParserImpl::ParseRegularExpression() reParser.ParsePattern(); auto *regexpNode = AllocNode(regexp.patternStr, regexp.flags, regexp.flagsStr); + CHECK_NOT_NULL(regexpNode); regexpNode->SetRange(lexer_->GetToken().Loc()); lexer_->NextToken(); @@ -976,6 +989,7 @@ ir::SuperExpression *ParserImpl::ParseSuperExpression() ES2PANDA_ASSERT(lexer_->GetToken().Type() == lexer::TokenType::KEYW_SUPER); auto *superExprNode = AllocNode(); + CHECK_NOT_NULL(superExprNode); superExprNode->SetRange(lexer_->GetToken().Loc()); lexer_->NextToken(); // eat super @@ -1045,6 +1059,7 @@ ir::Expression *ParserImpl::ParseClassExpression() } auto *classExpr = AllocNode(classDefinition); + CHECK_NOT_NULL(classExpr); classExpr->SetRange({startLoc, classDefinition->End()}); return classExpr; @@ -1341,6 +1356,7 @@ ir::Expression *ParserImpl::ParseBinaryExpression(ir::Expression *left, const le } const lexer::SourcePosition &endPos = rightExpr->End(); rightExpr = AllocNode(left, rightExpr, operatorType); + CHECK_NOT_NULL(rightExpr); rightExpr->SetRange({left->Start(), endPos}); } @@ -1406,6 +1422,7 @@ ir::CallExpression *ParserImpl::ParseCallExpression(ir::Expression *callee, bool callExpr = AllocNode(callee, std::move(arguments), nullptr, isOptionalChain, trailingComma); } + CHECK_NOT_NULL(callExpr); callExpr->SetRange({callee->Start(), endLoc}); isOptionalChain = false; @@ -1482,6 +1499,7 @@ ir::ArrowFunctionExpression *ParserImpl::ParsePotentialArrowExpression(ir::Expre switch (lexer_->GetToken().Type()) { case lexer::TokenType::KEYW_FUNCTION: { *returnExpression = ParseFunctionExpression(ParserStatus::ASYNC_FUNCTION); + CHECK_NOT_NULL(returnExpression); (*returnExpression)->SetStart(startLoc); break; } @@ -1570,6 +1588,7 @@ ir::MemberExpression *ParserImpl::ParsePrivatePropertyAccess(ir::Expression *pri ValidatePrivateIdentifier(); auto *privateIdent = AllocNode(lexer_->GetToken().Ident(), Allocator()); + CHECK_NOT_NULL(privateIdent); privateIdent->SetRange({memberStart, lexer_->GetToken().End()}); privateIdent->SetPrivate(true); lexer_->NextToken(); @@ -1647,6 +1666,7 @@ ir::Expression *ParserImpl::ParsePostPrimaryExpressionBackTick(ir::Expression *r const lexer::SourcePosition startLoc) { ir::TemplateLiteral *propertyNode = ParseTemplateLiteral(); + CHECK_NOT_NULL(propertyNode); lexer::SourcePosition endLoc = propertyNode->End(); returnExpression = AllocNode(returnExpression, propertyNode, nullptr); @@ -1710,6 +1730,7 @@ ir::Expression *ParserImpl::SetupChainExpr(ir::Expression *const top, lexer::Sou lexer::SourcePosition endLoc = expr->End(); auto chain = AllocNode(expr); + CHECK_NOT_NULL(chain); chain->SetRange({startLoc, endLoc}); if (expr == top) { @@ -1808,6 +1829,7 @@ ir::Expression *ParserImpl::ParsePatternElement(ExpressionParseFlags flags, bool ir::Expression *rightNode = ParseExpression(); auto *assignmentExpression = AllocNode( ir::AstNodeType::ASSIGNMENT_PATTERN, returnNode, rightNode, lexer::TokenType::PUNCTUATOR_SUBSTITUTION); + CHECK_NOT_NULL(assignmentExpression); assignmentExpression->SetRange({returnNode->Start(), rightNode->End()}); return assignmentExpression; @@ -2093,6 +2115,7 @@ ir::Expression *ParserImpl::ParsePropertyValue(const ir::PropertyKind *propertyK size_t paramsSize = methodDefinitonNode->Params().size(); auto *value = AllocNode(methodDefinitonNode); + CHECK_NOT_NULL(value); value->SetRange(methodDefinitonNode->Range()); if (*propertyKind == ir::PropertyKind::SET && paramsSize != 1) { @@ -2142,6 +2165,7 @@ ir::Expression *ParserImpl::ParsePropertyDefinition([[maybe_unused]] ExpressionP } ir::Expression *value = ParsePropertyValue(&propertyKind, &methodStatus, flags); + CHECK_NOT_NULL(value); lexer::SourcePosition end = value->End(); auto *returnProperty = @@ -2267,6 +2291,7 @@ ir::SequenceExpression *ParserImpl::ParseSequenceExpression(ir::Expression *star lexer::SourcePosition end = sequence.back()->End(); auto *sequenceNode = AllocNode(std::move(sequence)); + CHECK_NOT_NULL(sequenceNode); sequenceNode->SetRange({start, end}); return sequenceNode; diff --git a/ets2panda/parser/expressionTSParser.cpp b/ets2panda/parser/expressionTSParser.cpp index 0820dc473a..9860aaf8f8 100644 --- a/ets2panda/parser/expressionTSParser.cpp +++ b/ets2panda/parser/expressionTSParser.cpp @@ -137,6 +137,7 @@ ir::Expression *TSParser::ParsePotentialAsExpression(ir::Expression *expr) lexer::SourcePosition startLoc = expr->Start(); auto *asExpr = AllocNode(expr, typeAnnotation, isConst); + CHECK_NOT_NULL(asExpr); asExpr->SetRange({startLoc, Lexer()->GetToken().End()}); if (Lexer()->GetToken().KeywordType() == lexer::TokenType::KEYW_AS) { @@ -169,6 +170,7 @@ ir::AnnotatedExpression *TSParser::ParsePatternElementGetReturnNode(ExpressionPa } case lexer::TokenType::LITERAL_IDENT: { ir::AnnotatedExpression *returnNode = AllocNode(Lexer()->GetToken().Ident(), Allocator()); + CHECK_NOT_NULL(returnNode); if (returnNode->AsIdentifier()->Decorators().empty()) { returnNode->SetRange(Lexer()->GetToken().Loc()); @@ -340,6 +342,7 @@ ir::Expression *TSParser::ParseModuleReference() Lexer()->NextToken(); // eat ')' } else { result = AllocNode(Lexer()->GetToken().Ident(), Allocator()); + CHECK_NOT_NULL(result); result->SetRange(Lexer()->GetToken().Loc()); Lexer()->NextToken(); @@ -357,6 +360,7 @@ ir::TSTypeReference *TSParser::ParseConstExpression() identRef->SetRange(Lexer()->GetToken().Loc()); auto *typeReference = AllocNode(identRef, nullptr, Allocator()); + CHECK_NOT_NULL(typeReference); typeReference->SetRange(Lexer()->GetToken().Loc()); Lexer()->NextToken(); @@ -379,6 +383,7 @@ bool TSParser::ParsePotentialNonNullExpression(ir::Expression **returnExpression } *returnExpression = AllocNode(*returnExpression); + CHECK_NOT_NULL(*returnExpression); // NOLINTNEXTLINE(clang-analyzer-core.CallAndMessage) (*returnExpression)->SetRange({startLoc, Lexer()->GetToken().End()}); Lexer()->NextToken(); @@ -436,6 +441,8 @@ private: } }; +// NOLINTNEXTLINE(readability-function-size) +// CC-OFFNXT(huge_method[C++], G.FUN.01-CPP) solid logic ir::ArrowFunctionExpression *TSParser::ParsePotentialArrowExpression(ir::Expression **returnExpression, const lexer::SourcePosition &startLoc) { @@ -444,6 +451,7 @@ ir::ArrowFunctionExpression *TSParser::ParsePotentialArrowExpression(ir::Express switch (Lexer()->GetToken().Type()) { case lexer::TokenType::KEYW_FUNCTION: { *returnExpression = ParseFunctionExpression(ParserStatus::ASYNC_FUNCTION); + CHECK_NOT_NULL(*returnExpression); (*returnExpression)->SetStart(startLoc); break; } diff --git a/ets2panda/parser/parserImpl.cpp b/ets2panda/parser/parserImpl.cpp index b5c33731a2..ac5d941aaf 100644 --- a/ets2panda/parser/parserImpl.cpp +++ b/ets2panda/parser/parserImpl.cpp @@ -82,6 +82,7 @@ void ParserImpl::ParseProgram(ScriptKind kind) auto statements = ParseStatementList(StatementParsingFlags::STMT_GLOBAL_LEXICAL); auto *blockStmt = AllocNode(Allocator(), std::move(statements)); + CHECK_NOT_NULL(blockStmt); blockStmt->SetRange({startLoc, lexer_->GetToken().End()}); program_->SetAst(blockStmt); @@ -337,6 +338,7 @@ std::tuple ParserImpl::ParseComputedClassFieldOrIndexSignature return {true, false, false}; } +// CC-OFFNXT(huge_method[C++], G.FUN.01-CPP) solid logic ir::Expression *ParserImpl::ParseClassKey(ClassElementDescriptor *desc) { ir::Expression *propName = nullptr; @@ -377,6 +379,7 @@ ir::Expression *ParserImpl::ParseClassKey(ClassElementDescriptor *desc) } else { propName = AllocNode(lexer_->GetToken().GetNumber()); } + CHECK_NOT_NULL(propName); propName->SetRange(lexer_->GetToken().Loc()); break; @@ -456,6 +459,7 @@ ir::MethodDefinition *ParserImpl::ParseClassMethod(ClassElementDescriptor *desc, ir::ScriptFunction *func = ParseFunction(desc->newStatus); auto *funcExpr = AllocNode(func); + CHECK_NOT_NULL(funcExpr); funcExpr->SetRange(func->Range()); if (desc->methodKind == ir::MethodDefinitionKind::SET) { @@ -481,6 +485,7 @@ ir::ClassElement *ParserImpl::ParseClassProperty(ClassElementDescriptor *desc, const ArenaVector &properties, ir::Expression *propName, ir::TypeNode *typeAnnotation) { + CHECK_NOT_NULL(propName); lexer::SourcePosition propEnd = propName->End(); ir::ClassElement *property = nullptr; @@ -588,6 +593,7 @@ ir::ClassElement *ParserImpl::ParseClassStaticBlock() auto *funcExpr = AllocNode(func); auto *staticBlock = AllocNode(funcExpr, Allocator()); + CHECK_NOT_NULL(staticBlock); staticBlock->SetRange({startPos, lexer_->GetToken().End()}); lexer_->NextToken(); // eat '}' @@ -684,6 +690,7 @@ ir::MethodDefinition *ParserImpl::BuildImplicitConstructor(ir::ClassDefinitionMo auto *ctor = AllocNode(ir::MethodDefinitionKind::CONSTRUCTOR, key, funcExpr, ir::ModifierFlags::CONSTRUCTOR, Allocator(), false); + CHECK_NOT_NULL(ctor); const auto rangeImplicitContstuctor = lexer::SourceRange(startLoc, startLoc); ctor->IterateRecursively( @@ -703,7 +710,9 @@ void ParserImpl::CreateImplicitConstructor(ir::MethodDefinition *&ctor, ctor = BuildImplicitConstructor(modifiers, startLoc); if ((flags & ir::ModifierFlags::DECLARE) != 0) { - ctor->Function()->AddFlag(ir::ScriptFunctionFlags::EXTERNAL); + auto *ctorFunc = ctor->Function(); + CHECK_NOT_NULL(ctorFunc); + ctorFunc->AddFlag(ir::ScriptFunctionFlags::EXTERNAL); } } @@ -789,6 +798,7 @@ ir::ClassDefinition *ParserImpl::ParseClassDefinition(ir::ClassDefinitionModifie auto *classDefinition = AllocNode(identNode, nullptr, superTypeParams, std::move(implements), ctor, superClass, std::move(properties), modifiers, flags, GetContext().GetLanguage()); + CHECK_NOT_NULL(classDefinition); classDefinition->SetInternalName(privateBinding.View()); classDefinition->SetRange(bodyRange); @@ -939,6 +949,7 @@ std::tuple ParserImpl:: } ir::BlockStatement *body = ParseBlockStatement(); + CHECK_NOT_NULL(body); return {true, body, body->End(), false}; } @@ -1004,6 +1015,7 @@ ir::ScriptFunction *ParserImpl::ParseFunction(ParserStatus newStatus) functionContext.Flags(), // CC-OFFNXT(G.FMT.02-CPP) project code style {}, // CC-OFFNXT(G.FMT.02-CPP) project code style context_.GetLanguage()}); // CC-OFF(G.FMT.02-CPP) project code style + CHECK_NOT_NULL(funcNode); funcNode->SetRange({startLoc, endLoc}); @@ -1033,6 +1045,7 @@ ir::SpreadElement *ParserImpl::ParseSpreadElement(ExpressionParseFlags flags) auto nodeType = inPattern ? ir::AstNodeType::REST_ELEMENT : ir::AstNodeType::SPREAD_ELEMENT; auto *spreadElementNode = AllocNode(nodeType, Allocator(), argument); + CHECK_NOT_NULL(spreadElementNode); spreadElementNode->SetRange({startLocation, argument->End()}); return spreadElementNode; } @@ -1278,6 +1291,7 @@ ir::Identifier *ParserImpl::ExpectIdentifier([[maybe_unused]] bool isReference, } auto *ident = AllocNode(tokenName, Allocator()); + CHECK_NOT_NULL(ident); // NOTE: here actual token can be changed! ident->SetRange({tokenStart, lexer_->GetToken().End()}); lexer_->NextToken(); @@ -1453,6 +1467,7 @@ ir::Identifier *ParserImpl::AllocBrokenExpression(const lexer::SourcePosition &p ir::Identifier *ParserImpl::AllocBrokenExpression(const lexer::SourceRange &range) { auto *node = AllocNode(Allocator()); + CHECK_NOT_NULL(node); node->SetRange(range); return node; } @@ -1465,6 +1480,7 @@ ir::TypeNode *ParserImpl::AllocBrokenType(const lexer::SourcePosition &pos) ir::TypeNode *ParserImpl::AllocBrokenType(const lexer::SourceRange &range) { auto node = AllocNode(Allocator()); + CHECK_NOT_NULL(node); node->SetRange(range); return node; } diff --git a/ets2panda/parser/program/program.cpp b/ets2panda/parser/program/program.cpp index 13cb454676..891bb19497 100644 --- a/ets2panda/parser/program/program.cpp +++ b/ets2panda/parser/program/program.cpp @@ -33,7 +33,7 @@ Program::Program(ArenaAllocator *allocator, varbinder::VarBinder *varbinder) : allocator_(allocator), externalSources_(allocator_->Adapter()), directExternalSources_(allocator_->Adapter()), - extension_(varbinder->Extension()), + extension_(varbinder != nullptr ? varbinder->Extension() : ScriptExtension::INVALID), etsnolintCollection_(allocator_->Adapter()), cfg_(allocator_->New(allocator_)), functionScopes_(allocator_->Adapter()), @@ -132,6 +132,7 @@ void Program::SetPackageInfo(const util::StringView &name, util::ModuleKind kind // NOTE(vpukhov): part of ongoing design void Program::MaybeTransformToDeclarationModule() { + CHECK_NOT_NULL(ast_); if (IsPackage() || ast_->Statements().empty()) { return; } diff --git a/ets2panda/parser/statementParser.cpp b/ets2panda/parser/statementParser.cpp index c4ff7e348a..741d5a5ce7 100644 --- a/ets2panda/parser/statementParser.cpp +++ b/ets2panda/parser/statementParser.cpp @@ -230,6 +230,7 @@ ir::Statement *ParserImpl::ParseLetStatement(StatementParsingFlags flags) } auto *variableDecl = ParseVariableDeclaration(VariableParsingFlags::LET); + CHECK_NOT_NULL(variableDecl); if (variableDecl->IsBrokenStatement()) { // Error processing. return variableDecl; } @@ -248,6 +249,7 @@ ir::Statement *ParserImpl::ParseConstStatement(StatementParsingFlags flags) lexer_->NextToken(); auto *variableDecl = ParseVariableDeclaration(VariableParsingFlags::CONST | VariableParsingFlags::NO_SKIP_VAR_KIND); + CHECK_NOT_NULL(variableDecl); if (variableDecl->IsBrokenStatement()) { // Error processing. return variableDecl; } @@ -261,6 +263,7 @@ ir::Statement *ParserImpl::ParseConstStatement(StatementParsingFlags flags) ir::EmptyStatement *ParserImpl::ParseEmptyStatement() { auto *empty = AllocNode(); + CHECK_NOT_NULL(empty); empty->SetRange(lexer_->GetToken().Loc()); lexer_->NextToken(); return empty; @@ -269,6 +272,7 @@ ir::EmptyStatement *ParserImpl::ParseEmptyStatement() ir::Statement *ParserImpl::ParseDebuggerStatement() { auto *debuggerNode = AllocNode(); + CHECK_NOT_NULL(debuggerNode); debuggerNode->SetRange(lexer_->GetToken().Loc()); lexer_->NextToken(); ConsumeSemicolon(debuggerNode); @@ -288,6 +292,7 @@ ir::Statement *ParserImpl::ParseFunctionStatement(StatementParsingFlags flags) stmts.push_back(funcDecl); auto *localBlockStmt = AllocNode(Allocator(), std::move(stmts)); + CHECK_NOT_NULL(localBlockStmt); localBlockStmt->SetRange(funcDecl->Range()); return funcDecl; @@ -333,6 +338,7 @@ ir::Statement *ParserImpl::ParseStructDeclaration(ir::ClassDefinitionModifiers m lexer::SourcePosition endLoc = classDefinition->End(); auto *structDecl = AllocNode(classDefinition, Allocator()); + CHECK_NOT_NULL(structDecl); structDecl->SetRange({startLoc, endLoc}); return structDecl; } @@ -353,6 +359,7 @@ ir::Statement *ParserImpl::ParseClassDeclaration(ir::ClassDefinitionModifiers mo lexer::SourcePosition endLoc = classDefinition->End(); auto *classDecl = AllocNode(classDefinition, Allocator()); + CHECK_NOT_NULL(classDecl); classDecl->SetRange({startLoc, endLoc}); return classDecl; } @@ -379,6 +386,7 @@ void ParserImpl::ConsumeSemicolon(ir::Statement *statement) auto const &token = lexer_->GetToken(); auto tokenType = token.Type(); if (tokenType == lexer::TokenType::PUNCTUATOR_SEMI_COLON) { + CHECK_NOT_NULL(statement); statement->SetEnd(token.End()); lexer_->NextToken(); return; @@ -434,6 +442,7 @@ bool ParserImpl::ParseDirective(ArenaVector *statements) bool isDirective = exprNode->IsStringLiteral(); auto *exprStatement = AllocNode(exprNode); + CHECK_NOT_NULL(exprStatement); exprStatement->SetRange(exprNode->Range()); ConsumeSemicolon(exprStatement); @@ -464,6 +473,7 @@ ir::BlockStatement *ParserImpl::ParseBlockStatement() auto statements = ParseStatementList(); auto *blockNode = AllocNode(Allocator(), std::move(statements)); + CHECK_NOT_NULL(blockNode); blockNode->SetRange({startLoc, lexer_->GetToken().End()}); ExpectToken(lexer::TokenType::PUNCTUATOR_RIGHT_BRACE); @@ -495,6 +505,7 @@ ir::Statement *ParserImpl::ParseBreakStatement() } auto *breakStatement = AllocNode(); + CHECK_NOT_NULL(breakStatement); breakStatement->SetRange({startLoc, lexer_->GetToken().End()}); if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) { @@ -570,6 +581,7 @@ ir::Statement *ParserImpl::ParseContinueStatement() identNode->SetRange(lexer_->GetToken().Loc()); auto *continueStatement = AllocNode(identNode); + CHECK_NOT_NULL(continueStatement); continueStatement->SetRange({startLoc, lexer_->GetToken().End()}); lexer_->NextToken(); @@ -618,6 +630,7 @@ ir::Statement *ParserImpl::ParseDoWhileStatement() ExpectToken(lexer::TokenType::PUNCTUATOR_RIGHT_PARENTHESIS); auto *doWhileStatement = AllocNode(body, condition); + CHECK_NOT_NULL(doWhileStatement); doWhileStatement->SetRange({startLoc, endLoc}); if (lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_SEMI_COLON) { @@ -664,6 +677,7 @@ ir::FunctionDeclaration *ParserImpl::ParseFunctionDeclaration(bool canBeAnonymou newStatus |= ParserStatus::FUNCTION_DECLARATION; ir::ScriptFunction *func = ParseFunction(newStatus | ParserStatus::NEED_RETURN_TYPE); + CHECK_NOT_NULL(func); func->SetIdent(identNode); func->SetStart(startLoc); @@ -726,6 +740,7 @@ ir::Statement *ParserImpl::ParseExpressionStatement(StatementParsingFlags flags) lexer::SourcePosition endPos = exprNode->End(); auto *exprStatementNode = AllocNode(exprNode); + CHECK_NOT_NULL(exprStatementNode); exprStatementNode->SetRange({startPos.GetToken().Start(), endPos}); ConsumeSemicolon(exprStatementNode); @@ -856,6 +871,7 @@ std::tuple ir::AstNode *initNode = lexer_->GetToken().Type() == lexer::TokenType::PUNCTUATOR_COMMA ? ParseSequenceExpression(expr) : expr; + CHECK_NOT_NULL(initNode); if (initNode->IsConditionalExpression()) { ir::ConditionalExpression *condExpr = initNode->AsConditionalExpression(); @@ -1008,6 +1024,7 @@ ir::Statement *ParserImpl::CreateForStatement(ForStatementNodes &&nodes, ForStat } } + CHECK_NOT_NULL(forStatement); forStatement->SetRange({startLoc, nodes.body->End()}); return forStatement; @@ -1085,6 +1102,7 @@ ir::Statement *ParserImpl::ParseIfStatement() } auto *ifStatement = AllocNode(test, consequent, alternate); + CHECK_NOT_NULL(ifStatement); ifStatement->SetRange({startLoc, endLoc}); return ifStatement; } @@ -1115,6 +1133,7 @@ ir::Statement *ParserImpl::ParseLabelledStatement(const lexer::LexerPosition &po ir::Statement *body = ParseStatement(StatementParsingFlags::LABELLED); auto *labeledStatement = AllocNode(identNode, body); + CHECK_NOT_NULL(labeledStatement); labeledStatement->SetRange({pos.GetToken().Start(), body->End()}); return labeledStatement; @@ -1154,6 +1173,7 @@ ir::Statement *ParserImpl::ParseReturnStatement() returnStatement = AllocNode(); } + CHECK_NOT_NULL(returnStatement); returnStatement->SetRange({startLoc, endLoc}); ConsumeSemicolon(returnStatement); @@ -1209,6 +1229,7 @@ ir::SwitchCaseStatement *ParserImpl::ParseSwitchCaseStatement(bool *seenDefault) } auto *caseNode = AllocNode(testExpr, std::move(consequents)); + CHECK_NOT_NULL(caseNode); caseNode->SetRange({caseStartLoc, caseEndLoc}); return caseNode; } @@ -1240,6 +1261,7 @@ ir::Statement *ParserImpl::ParseSwitchStatement() ExpectToken(lexer::TokenType::PUNCTUATOR_RIGHT_BRACE); auto *switchStatement = AllocNode(discriminant, std::move(cases)); + CHECK_NOT_NULL(switchStatement); switchStatement->SetRange({startLoc, endLoc}); return switchStatement; } @@ -1264,6 +1286,7 @@ ir::Statement *ParserImpl::ParseThrowStatement() lexer::SourcePosition endLoc = expression->End(); auto *throwStatement = AllocNode(expression); + CHECK_NOT_NULL(throwStatement); throwStatement->SetRange({startLoc, endLoc}); ConsumeSemicolon(throwStatement); @@ -1318,6 +1341,7 @@ ir::CatchClause *ParserImpl::ParseCatchClause() lexer::SourcePosition endLoc = catchBlock->End(); auto *catchClause = AllocNode(param, catchBlock); + CHECK_NOT_NULL(catchClause); catchClause->SetRange({catchStartLoc, endLoc}); return catchClause; @@ -1362,6 +1386,7 @@ ir::Statement *ParserImpl::ParseTryStatement() lexer_->NextToken(); // eat 'finally' keyword finallyClause = ParseBlockStatement(); + CHECK_NOT_NULL(finallyClause); endLoc = finallyClause->End(); } @@ -1532,6 +1557,7 @@ ir::Statement *ParserImpl::ParseVariableDeclaration(VariableParsingFlags flags) lexer::SourcePosition endLoc = declarators.back()->End(); auto *declaration = AllocNode(varKind, Allocator(), std::move(declarators)); + CHECK_NOT_NULL(declaration); declaration->SetRange({startLoc, endLoc}); return declaration; @@ -1559,6 +1585,7 @@ ir::Statement *ParserImpl::ParseWhileStatement() lexer::SourcePosition endLoc = body->End(); auto *whileStatement = AllocNode(condition, body); + CHECK_NOT_NULL(whileStatement); whileStatement->SetRange({startLoc, endLoc}); return whileStatement; @@ -1609,6 +1636,7 @@ ir::ExportDefaultDeclaration *ParserImpl::ParseExportDefaultDeclaration(const le ES2PANDA_ASSERT(declNode != nullptr); lexer::SourcePosition endLoc = declNode->End(); auto *exportDeclaration = AllocNode(declNode, isExportEquals); + CHECK_NOT_NULL(exportDeclaration); exportDeclaration->SetRange({startLoc, endLoc}); if (eatSemicolon) { @@ -1632,6 +1660,7 @@ ir::Identifier *ParserImpl::ParseNamedExport(lexer::Token *exportedToken) const util::StringView &exportedString = exportedToken->Ident(); auto *exported = AllocNode(exportedString, Allocator()); + CHECK_NOT_NULL(exported); exported->SetRange(exportedToken->Loc()); return exported; @@ -1649,9 +1678,11 @@ ir::ExportAllDeclaration *ParserImpl::ParseExportAllDeclaration(const lexer::Sou lexer_->NextToken(); // eat exported name } ir::StringLiteral *source = ParseFromClause(); + CHECK_NOT_NULL(source); lexer::SourcePosition endLoc = source->End(); auto *exportDeclaration = AllocNode(source, exported); + CHECK_NOT_NULL(exportDeclaration); exportDeclaration->SetRange({startLoc, endLoc}); ConsumeSemicolon(exportDeclaration); @@ -1706,6 +1737,7 @@ ir::ExportNamedDeclaration *ParserImpl::ParseExportNamedSpecifiers(const lexer:: } auto *exportDeclaration = AllocNode(Allocator(), source, std::move(specifiers)); + CHECK_NOT_NULL(exportDeclaration); exportDeclaration->SetRange({startLoc, endPos}); ConsumeSemicolon(exportDeclaration); @@ -1760,6 +1792,7 @@ ir::Statement *ParserImpl::ParseNamedExportDeclaration(const lexer::SourcePositi lexer::SourcePosition endLoc = decl->End(); ArenaVector specifiers(Allocator()->Adapter()); auto *exportDeclaration = AllocNode(Allocator(), decl, std::move(specifiers)); + CHECK_NOT_NULL(exportDeclaration); exportDeclaration->SetRange({startLoc, endLoc}); return exportDeclaration; @@ -1808,6 +1841,7 @@ void ParserImpl::ParseNameSpaceImport(ArenaVector *specifiers) ir::Identifier *local = ParseNamedImport(&lexer_->GetToken()); auto *specifier = AllocNode(local); + CHECK_NOT_NULL(specifier); specifier->SetRange({namespaceStart, lexer_->GetToken().End()}); specifiers->push_back(specifier); @@ -1825,6 +1859,7 @@ ir::Identifier *ParserImpl::ParseNamedImport(lexer::Token *importedToken) CheckRestrictedBinding(importedToken->KeywordType()); auto *local = AllocNode(importedToken->Ident(), Allocator()); + CHECK_NOT_NULL(local); local->SetRange(importedToken->Loc()); return local; @@ -1871,6 +1906,7 @@ ir::AstNode *ParserImpl::ParseImportDefaultSpecifier(ArenaVector lexer_->NextToken(); // eat local name auto *specifier = AllocNode(local); + CHECK_NOT_NULL(specifier); specifier->SetRange(specifier->Local()->Range()); specifiers->push_back(specifier); @@ -1903,6 +1939,7 @@ ir::StringLiteral *ParserImpl::ParseFromClause(bool requireFrom) } auto *source = AllocNode(lexer_->GetToken().String()); + CHECK_NOT_NULL(source); source->SetRange(lexer_->GetToken().Loc()); lexer_->NextToken(); @@ -1961,6 +1998,7 @@ ir::Statement *ParserImpl::ParseImportDeclaration(StatementParsingFlags flags) lexer::SourcePosition endLoc = source->End(); auto *importDeclaration = AllocNode(source, std::move(specifiers)); + CHECK_NOT_NULL(importDeclaration); importDeclaration->SetRange({startLoc, endLoc}); ConsumeSemicolon(importDeclaration); @@ -1976,6 +2014,7 @@ ir::Statement *ParserImpl::AllocBrokenStatement(const lexer::SourcePosition &pos ir::Statement *ParserImpl::AllocBrokenStatement(const lexer::SourceRange &range) { auto *broken = AllocNode(true); + CHECK_NOT_NULL(broken); broken->SetRange(range); return broken; } @@ -1991,6 +2030,7 @@ bool ParserImpl::IsBrokenStatement(ir::Statement *st) ir::Statement *ParserImpl::AllocEmptyStatement() { auto *empty = AllocNode(); + CHECK_NOT_NULL(empty); empty->SetRange(lexer_->GetToken().Loc()); return empty; } diff --git a/ets2panda/parser/statementTSParser.cpp b/ets2panda/parser/statementTSParser.cpp index 34dce05dc1..ce4f5ffe2b 100644 --- a/ets2panda/parser/statementTSParser.cpp +++ b/ets2panda/parser/statementTSParser.cpp @@ -131,6 +131,7 @@ ir::TSImportEqualsDeclaration *TSParser::ParseTsImportEqualsDeclaration(const le } auto *id = AllocNode(Lexer()->GetToken().Ident(), Allocator()); + CHECK_NOT_NULL(id); id->SetRange(Lexer()->GetToken().Loc()); Lexer()->NextToken(); // eat id name @@ -190,6 +191,7 @@ ir::ExportDefaultDeclaration *TSParser::ParseExportDefaultDeclaration(const lexe lexer::SourcePosition endLoc = declNode->End(); auto *exportDeclaration = AllocNode(declNode, isExportEquals); + CHECK_NOT_NULL(exportDeclaration); exportDeclaration->SetRange({startLoc, endLoc}); if (eatSemicolon) { @@ -265,6 +267,7 @@ ir::Statement *TSParser::ParseNamedExportDeclaration(const lexer::SourcePosition lexer::SourcePosition endLoc = decl->End(); ArenaVector specifiers(Allocator()->Adapter()); auto *exportDeclaration = AllocNode(Allocator(), decl, std::move(specifiers)); + CHECK_NOT_NULL(exportDeclaration); exportDeclaration->SetRange({startLoc, endLoc}); return exportDeclaration; @@ -293,6 +296,7 @@ ir::Statement *TSParser::ParseExportDeclaration(StatementParsingFlags flags) } default: { auto ret = ParseNamedExportDeclaration(startLoc); + CHECK_NOT_NULL(ret); if (ret->IsBrokenStatement()) { return ret; } @@ -322,6 +326,7 @@ ir::Statement *TSParser::ParseConstStatement(StatementParsingFlags flags) } auto *variableDecl = ParseVariableDeclaration(VariableParsingFlags::CONST | VariableParsingFlags::NO_SKIP_VAR_KIND); + CHECK_NOT_NULL(variableDecl); variableDecl->SetStart(constVarStar); ConsumeSemicolon(variableDecl); @@ -364,6 +369,7 @@ ir::Statement *TSParser::ParseImportDeclaration([[maybe_unused]] StatementParsin source = ParseFromClause(false); } + CHECK_NOT_NULL(source); lexer::SourcePosition endLoc = source->End(); auto *importDeclaration = AllocNode(source, std::move(specifiers)); importDeclaration->SetRange({startLoc, endLoc}); -- Gitee