| //===--- SemaFixItUtils.cpp - Sema FixIts ---------------------------------===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // This file defines helper classes for generation of Sema FixItHints. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "clang/AST/ASTContext.h" | |
| #include "clang/AST/ExprCXX.h" | |
| #include "clang/AST/ExprObjC.h" | |
| #include "clang/Lex/Preprocessor.h" | |
| #include "clang/Sema/Sema.h" | |
| #include "clang/Sema/SemaFixItUtils.h" | |
| using namespace clang; | |
| bool ConversionFixItGenerator::compareTypesSimple(CanQualType From, | |
| CanQualType To, | |
| Sema &S, | |
| SourceLocation Loc, | |
| ExprValueKind FromVK) { | |
| if (!To.isAtLeastAsQualifiedAs(From, S.getASTContext())) | |
| return false; | |
| From = From.getNonReferenceType(); | |
| To = To.getNonReferenceType(); | |
| // If both are pointer types, work with the pointee types. | |
| if (isa<PointerType>(From) && isa<PointerType>(To)) { | |
| From = S.Context.getCanonicalType( | |
| (cast<PointerType>(From))->getPointeeType()); | |
| To = S.Context.getCanonicalType( | |
| (cast<PointerType>(To))->getPointeeType()); | |
| } | |
| const CanQualType FromUnq = From.getUnqualifiedType(); | |
| const CanQualType ToUnq = To.getUnqualifiedType(); | |
| if ((FromUnq == ToUnq || (S.IsDerivedFrom(Loc, FromUnq, ToUnq))) && | |
| To.isAtLeastAsQualifiedAs(From, S.getASTContext())) | |
| return true; | |
| return false; | |
| } | |
| bool ConversionFixItGenerator::tryToFixConversion(const Expr *FullExpr, | |
| const QualType FromTy, | |
| const QualType ToTy, | |
| Sema &S) { | |
| if (!FullExpr) | |
| return false; | |
| const CanQualType FromQTy = S.Context.getCanonicalType(FromTy); | |
| const CanQualType ToQTy = S.Context.getCanonicalType(ToTy); | |
| const SourceLocation Begin = FullExpr->getSourceRange().getBegin(); | |
| const SourceLocation End = S.getLocForEndOfToken(FullExpr->getSourceRange() | |
| .getEnd()); | |
| // Strip the implicit casts - those are implied by the compiler, not the | |
| // original source code. | |
| const Expr* Expr = FullExpr->IgnoreImpCasts(); | |
| bool NeedParen = true; | |
| if (isa<ArraySubscriptExpr>(Expr) || | |
| isa<CallExpr>(Expr) || | |
| isa<DeclRefExpr>(Expr) || | |
| isa<CastExpr>(Expr) || | |
| isa<CXXNewExpr>(Expr) || | |
| isa<CXXConstructExpr>(Expr) || | |
| isa<CXXDeleteExpr>(Expr) || | |
| isa<CXXNoexceptExpr>(Expr) || | |
| isa<CXXPseudoDestructorExpr>(Expr) || | |
| isa<CXXScalarValueInitExpr>(Expr) || | |
| isa<CXXThisExpr>(Expr) || | |
| isa<CXXTypeidExpr>(Expr) || | |
| isa<CXXUnresolvedConstructExpr>(Expr) || | |
| isa<ObjCMessageExpr>(Expr) || | |
| isa<ObjCPropertyRefExpr>(Expr) || | |
| isa<ObjCProtocolExpr>(Expr) || | |
| isa<MemberExpr>(Expr) || | |
| isa<ParenExpr>(FullExpr) || | |
| isa<ParenListExpr>(Expr) || | |
| isa<SizeOfPackExpr>(Expr) || | |
| isa<UnaryOperator>(Expr)) | |
| NeedParen = false; | |
| // Check if the argument needs to be dereferenced: | |
| // (type * -> type) or (type * -> type &). | |
| if (const PointerType *FromPtrTy = dyn_cast<PointerType>(FromQTy)) { | |
| OverloadFixItKind FixKind = OFIK_Dereference; | |
| bool CanConvert = CompareTypes( | |
| S.Context.getCanonicalType(FromPtrTy->getPointeeType()), ToQTy, | |
| S, Begin, VK_LValue); | |
| if (CanConvert) { | |
| // Do not suggest dereferencing a Null pointer. | |
| if (Expr->IgnoreParenCasts()-> | |
| isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull)) | |
| return false; | |
| if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(Expr)) { | |
| if (UO->getOpcode() == UO_AddrOf) { | |
| FixKind = OFIK_RemoveTakeAddress; | |
| Hints.push_back(FixItHint::CreateRemoval( | |
| CharSourceRange::getTokenRange(Begin, Begin))); | |
| } | |
| } else if (NeedParen) { | |
| Hints.push_back(FixItHint::CreateInsertion(Begin, "*(")); | |
| Hints.push_back(FixItHint::CreateInsertion(End, ")")); | |
| } else { | |
| Hints.push_back(FixItHint::CreateInsertion(Begin, "*")); | |
| } | |
| NumConversionsFixed++; | |
| if (NumConversionsFixed == 1) | |
| Kind = FixKind; | |
| return true; | |
| } | |
| } | |
| // Check if the pointer to the argument needs to be passed: | |
| // (type -> type *) or (type & -> type *). | |
| if (const auto *ToPtrTy = dyn_cast<PointerType>(ToQTy)) { | |
| bool CanConvert = false; | |
| OverloadFixItKind FixKind = OFIK_TakeAddress; | |
| // Only suggest taking address of L-values. | |
| if (!Expr->isLValue() || Expr->getObjectKind() != OK_Ordinary) | |
| return false; | |
| // Do no take address of const pointer to get void* | |
| if (isa<PointerType>(FromQTy) && ToPtrTy->isVoidPointerType()) | |
| return false; | |
| CanConvert = CompareTypes(S.Context.getPointerType(FromQTy), ToQTy, S, | |
| Begin, VK_PRValue); | |
| if (CanConvert) { | |
| if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(Expr)) { | |
| if (UO->getOpcode() == UO_Deref) { | |
| FixKind = OFIK_RemoveDereference; | |
| Hints.push_back(FixItHint::CreateRemoval( | |
| CharSourceRange::getTokenRange(Begin, Begin))); | |
| } | |
| } else if (NeedParen) { | |
| Hints.push_back(FixItHint::CreateInsertion(Begin, "&(")); | |
| Hints.push_back(FixItHint::CreateInsertion(End, ")")); | |
| } else { | |
| Hints.push_back(FixItHint::CreateInsertion(Begin, "&")); | |
| } | |
| NumConversionsFixed++; | |
| if (NumConversionsFixed == 1) | |
| Kind = FixKind; | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| static bool isMacroDefined(const Sema &S, SourceLocation Loc, StringRef Name) { | |
| return (bool)S.PP.getMacroDefinitionAtLoc(&S.getASTContext().Idents.get(Name), | |
| Loc); | |
| } | |
| static std::string getScalarZeroExpressionForType( | |
| const Type &T, SourceLocation Loc, const Sema &S) { | |
| assert(T.isScalarType() && "use scalar types only"); | |
| // Suggest "0" for non-enumeration scalar types, unless we can find a | |
| // better initializer. | |
| if (T.isEnumeralType()) | |
| return std::string(); | |
| if ((T.isObjCObjectPointerType() || T.isBlockPointerType()) && | |
| isMacroDefined(S, Loc, "nil")) | |
| return "nil"; | |
| if (T.isRealFloatingType()) | |
| return "0.0"; | |
| if (T.isBooleanType() && | |
| (S.LangOpts.CPlusPlus || isMacroDefined(S, Loc, "false"))) | |
| return "false"; | |
| if (T.isPointerType() || T.isMemberPointerType()) { | |
| if (S.LangOpts.CPlusPlus11) | |
| return "nullptr"; | |
| if (isMacroDefined(S, Loc, "NULL")) | |
| return "NULL"; | |
| } | |
| if (T.isCharType()) | |
| return "'\\0'"; | |
| if (T.isWideCharType()) | |
| return "L'\\0'"; | |
| if (T.isChar16Type()) | |
| return "u'\\0'"; | |
| if (T.isChar32Type()) | |
| return "U'\\0'"; | |
| return "0"; | |
| } | |
| std::string | |
| Sema::getFixItZeroInitializerForType(QualType T, SourceLocation Loc) const { | |
| if (T->isScalarType()) { | |
| std::string s = getScalarZeroExpressionForType(*T, Loc, *this); | |
| if (!s.empty()) | |
| s = " = " + s; | |
| return s; | |
| } | |
| const CXXRecordDecl *RD = T->getAsCXXRecordDecl(); | |
| if (!RD || !RD->hasDefinition()) | |
| return std::string(); | |
| if (LangOpts.CPlusPlus11 && !RD->hasUserProvidedDefaultConstructor()) | |
| return "{}"; | |
| if (RD->isAggregate()) | |
| return " = {}"; | |
| return std::string(); | |
| } | |
| std::string | |
| Sema::getFixItZeroLiteralForType(QualType T, SourceLocation Loc) const { | |
| return getScalarZeroExpressionForType(*T, Loc, *this); | |
| } |