Merge from 'main' to 'sycl-web' (intel#30)

Author: abhinavgaba

clang-tools-extra/clang-tidy/abseil/DurationRewriter.cpp

@@ -208,7 +208,7 @@ stripFloatLiteralFraction(const MatchFinder::MatchResult &Result,
   if (const auto *LitFloat = llvm::dyn_cast<FloatingLiteral>(&Node))
     // Attempt to simplify a `Duration` factory call with a literal argument.
     if (llvm::Optional<llvm::APSInt> IntValue = truncateIfIntegral(*LitFloat))
-      return IntValue->toString(/*radix=*/10);
+      return toString(*IntValue, /*radix=*/10);
 
   return llvm::None;
 }

clang-tools-extra/clang-tidy/cppcoreguidelines/NarrowingConversionsCheck.cpp

@@ -71,8 +71,9 @@ void NarrowingConversionsCheck::registerMatchers(MatchFinder *Finder) {
       hasType(namedDecl(hasAnyListedName(IgnoreConversionFromTypes)));
 
   // `IsConversionFromIgnoredType` will ignore narrowing calls from those types,
-  // but not expressions that are promoted to `int64` due to a binary expression
-  // with one of those types. For example, it will continue to reject:
+  // but not expressions that are promoted to an ignored type as a result of a
+  // binary expression with one of those types.
+  // For example, it will continue to reject:
   // `int narrowed = int_value + container.size()`.
   // We attempt to address common incidents of compound expressions with
   // `IsIgnoredTypeTwoLevelsDeep`, allowing binary expressions that have one
@@ -221,6 +222,22 @@ static bool isWideEnoughToHold(const ASTContext &Context,
   return ToIntegerRange.contains(IntegerConstant);
 }
 
+// Returns true iff the floating point constant can be losslessly represented
+// by an integer in the given destination type. eg. 2.0 can be accurately
+// represented by an int32_t, but neither 2^33 nor 2.001 can.
+static bool isFloatExactlyRepresentable(const ASTContext &Context,
+                                        const llvm::APFloat &FloatConstant,
+                                        const QualType &DestType) {
+  unsigned DestWidth = Context.getIntWidth(DestType);
+  bool DestSigned = DestType->isSignedIntegerOrEnumerationType();
+  llvm::APSInt Result = llvm::APSInt(DestWidth, !DestSigned);
+  bool IsExact = false;
+  bool Overflows = FloatConstant.convertToInteger(
+                       Result, llvm::APFloat::rmTowardZero, &IsExact) &
+                   llvm::APFloat::opInvalidOp;
+  return !Overflows && IsExact;
+}
+
 static llvm::SmallString<64> getValueAsString(const llvm::APSInt &Value,
                                               uint64_t HexBits) {
   llvm::SmallString<64> Str;
@@ -237,6 +254,21 @@ static llvm::SmallString<64> getValueAsString(const llvm::APSInt &Value,
   return Str;
 }
 
+bool NarrowingConversionsCheck::isWarningInhibitedByEquivalentSize(
+    const ASTContext &Context, const BuiltinType &FromType,
+    const BuiltinType &ToType) const {
+  // With this option, we don't warn on conversions that have equivalent width
+  // in bits. eg. uint32 <-> int32.
+  if (!WarnOnEquivalentBitWidth) {
+    uint64_t FromTypeSize = Context.getTypeSize(&FromType);
+    uint64_t ToTypeSize = Context.getTypeSize(&ToType);
+    if (FromTypeSize == ToTypeSize) {
+      return true;
+    }
+  }
+  return false;
+}
+
 void NarrowingConversionsCheck::diagNarrowType(SourceLocation SourceLoc,
                                                const Expr &Lhs,
                                                const Expr &Rhs) {
@@ -351,7 +383,10 @@ void NarrowingConversionsCheck::handleIntegralToFloating(
       diagNarrowIntegerConstant(SourceLoc, Lhs, Rhs, IntegerConstant);
     return;
   }
+
   const BuiltinType *FromType = getBuiltinType(Rhs);
+  if (isWarningInhibitedByEquivalentSize(Context, *FromType, *ToType))
+    return;
   if (!isWideEnoughToHold(Context, *FromType, *ToType))
     diagNarrowType(SourceLoc, Lhs, Rhs);
 }
@@ -360,25 +395,21 @@ void NarrowingConversionsCheck::handleFloatingToIntegral(
     const ASTContext &Context, SourceLocation SourceLoc, const Expr &Lhs,
     const Expr &Rhs) {
   llvm::APFloat FloatConstant(0.0);
+  if (getFloatingConstantExprValue(Context, Rhs, FloatConstant)) {
+    if (!isFloatExactlyRepresentable(Context, FloatConstant, Lhs.getType()))
+      return diagNarrowConstant(SourceLoc, Lhs, Rhs);
 
-  // We always warn when Rhs is non-constexpr.
-  if (!getFloatingConstantExprValue(Context, Rhs, FloatConstant))
-    return diagNarrowType(SourceLoc, Lhs, Rhs);
+    if (PedanticMode)
+      return diagConstantCast(SourceLoc, Lhs, Rhs);
 
-  QualType DestType = Lhs.getType();
-  unsigned DestWidth = Context.getIntWidth(DestType);
-  bool DestSigned = DestType->isSignedIntegerOrEnumerationType();
-  llvm::APSInt Result = llvm::APSInt(DestWidth, !DestSigned);
-  bool IsExact = false;
-  bool Overflows = FloatConstant.convertToInteger(
-                       Result, llvm::APFloat::rmTowardZero, &IsExact) &
-                   llvm::APFloat::opInvalidOp;
-  // We warn iff the constant floating point value is not exactly representable.
-  if (Overflows || !IsExact)
-    return diagNarrowConstant(SourceLoc, Lhs, Rhs);
+    return;
+  }
 
-  if (PedanticMode)
-    return diagConstantCast(SourceLoc, Lhs, Rhs);
+  const BuiltinType *FromType = getBuiltinType(Rhs);
+  const BuiltinType *ToType = getBuiltinType(Lhs);
+  if (isWarningInhibitedByEquivalentSize(Context, *FromType, *ToType))
+    return;
+  diagNarrowType(SourceLoc, Lhs, Rhs); // Assumed always lossy.
 }
 
 void NarrowingConversionsCheck::handleFloatingToBoolean(

clang-tools-extra/clang-tidy/cppcoreguidelines/NarrowingConversionsCheck.h

@@ -93,6 +93,10 @@ class NarrowingConversionsCheck : public ClangTidyCheck {
   void handleBinaryOperator(const ASTContext &Context,
                             const BinaryOperator &Op);
 
+  bool isWarningInhibitedByEquivalentSize(const ASTContext &Context,
+                                          const BuiltinType &FromType,
+                                          const BuiltinType &ToType) const;
+
   const bool WarnOnIntegerNarrowingConversion;
   const bool WarnOnFloatingPointNarrowingConversion;
   const bool WarnWithinTemplateInstantiation;

clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp

@@ -99,7 +99,7 @@ void ProBoundsConstantArrayIndexCheck::check(
 
   if (Index->isSigned() && Index->isNegative()) {
     diag(Matched->getExprLoc(), "std::array<> index %0 is negative")
-        << Index->toString(10);
+        << toString(*Index, 10);
     return;
   }
 
@@ -118,7 +118,7 @@ void ProBoundsConstantArrayIndexCheck::check(
     diag(Matched->getExprLoc(),
          "std::array<> index %0 is past the end of the array "
          "(which contains %1 elements)")
-        << Index->toString(10) << ArraySize.toString(10, false);
+        << toString(*Index, 10) << toString(ArraySize, 10, false);
   }
 }
 

clang-tools-extra/clangd/DumpAST.cpp

@@ -290,7 +290,7 @@ class DumpVisitor : public RecursiveASTVisitor<DumpVisitor> {
   }
   std::string getDetail(const TemplateArgumentLoc &TAL) {
     if (TAL.getArgument().getKind() == TemplateArgument::Integral)
-      return TAL.getArgument().getAsIntegral().toString(10);
+      return toString(TAL.getArgument().getAsIntegral(), 10);
     return "";
   }
   std::string getDetail(const TemplateName &TN) {

clang-tools-extra/clangd/Hover.cpp

@@ -587,7 +587,7 @@ HoverInfo getHoverContents(const NamedDecl *D, const PrintingPolicy &PP,
   } else if (const auto *ECD = dyn_cast<EnumConstantDecl>(D)) {
     // Dependent enums (e.g. nested in template classes) don't have values yet.
     if (!ECD->getType()->isDependentType())
-      HI.Value = ECD->getInitVal().toString(10);
+      HI.Value = toString(ECD->getInitVal(), 10);
   }
 
   HI.Definition = printDefinition(D, PP);

clang-tools-extra/clangd/refactor/Rename.cpp

@@ -751,6 +751,26 @@ llvm::Expected<RenameResult> rename(const RenameInputs &RInputs) {
   auto MainFileRenameEdit = renameWithinFile(AST, RenameDecl, RInputs.NewName);
   if (!MainFileRenameEdit)
     return MainFileRenameEdit.takeError();
+
+  // Check the rename-triggering location is actually being renamed.
+  // This is a robustness check to avoid surprising rename results -- if the
+  // the triggering location is not actually the name of the node we identified
+  // (e.g. for broken code), then rename is likely not what users expect, so we
+  // reject this kind of rename.
+  auto StartOffset = positionToOffset(MainFileCode, CurrentIdentifier.start);
+  auto EndOffset = positionToOffset(MainFileCode, CurrentIdentifier.end);
+  if (!StartOffset)
+    return StartOffset.takeError();
+  if (!EndOffset)
+    return EndOffset.takeError();
+  if (llvm::find_if(
+          *MainFileRenameEdit,
+          [&StartOffset, &EndOffset](const clang::tooling::Replacement &R) {
+            return R.getOffset() == *StartOffset &&
+                   R.getLength() == *EndOffset - *StartOffset;
+          }) == MainFileRenameEdit->end()) {
+    return makeError(ReasonToReject::NoSymbolFound);
+  }
   RenameResult Result;
   Result.Target = CurrentIdentifier;
   Edit MainFileEdits = Edit(MainFileCode, std::move(*MainFileRenameEdit));

clang-tools-extra/clangd/unittests/RenameTests.cpp

@@ -1071,6 +1071,13 @@ TEST(RenameTest, Renameable) {
         struct B : priv^ate A {};
       )cpp",
        "Cannot rename symbol: there is no symbol at the given location", false},
+      {R"cpp(// Ensure it doesn't associate base specifier with base name.
+        /*error-ok*/
+        struct A {
+          A() : inva^lid(0) {}
+        };
+      )cpp",
+       "no symbol", false},
   };
 
   for (const auto& Case : Cases) {

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-narrowing-conversions-equivalentbitwidth-option.cpp

@@ -11,16 +11,35 @@
 
 void narrowing_equivalent_bitwidth() {
   int i;
-  unsigned int j;
-  i = j;
+  unsigned int ui;
+  i = ui;
   // CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:7: warning: narrowing conversion from 'unsigned int' to signed type 'int' is implementation-defined [cppcoreguidelines-narrowing-conversions]
   // DISABLED: Warning disabled with WarnOnEquivalentBitWidth=0.
+
+  float f;
+  i = f;
+  // CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:7: warning: narrowing conversion from 'float' to 'int' [cppcoreguidelines-narrowing-conversions]
+  // DISABLED: Warning disabled with WarnOnEquivalentBitWidth=0.
+
+  f = i;
+  // CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:7: warning: narrowing conversion from 'int' to 'float' [cppcoreguidelines-narrowing-conversions]
+  // DISABLED: Warning disabled with WarnOnEquivalentBitWidth=0.
+
+  long long ll;
+  double d;
+  ll = d;
+  // CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:8: warning: narrowing conversion from 'double' to 'long long' [cppcoreguidelines-narrowing-conversions]
+  // DISABLED: Warning disabled with WarnOnEquivalentBitWidth=0.
+
+  d = ll;
+  // CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:7: warning: narrowing conversion from 'long long' to 'double' [cppcoreguidelines-narrowing-conversions]
+  // DISABLED: Warning disabled with WarnOnEquivalentBitWidth=0.
 }
 
 void most_narrowing_is_not_ok() {
   int i;
-  long long j;
-  i = j;
+  long long ui;
+  i = ui;
   // CHECK-MESSAGES-DEFAULT: :[[@LINE-1]]:7: warning: narrowing conversion from 'long long' to signed type 'int' is implementation-defined [cppcoreguidelines-narrowing-conversions]
   // CHECK-MESSAGES-DISABLED: :[[@LINE-2]]:7: warning: narrowing conversion from 'long long' to signed type 'int' is implementation-defined [cppcoreguidelines-narrowing-conversions]
 }

clang/include/clang/ASTMatchers/ASTMatchers.h

@@ -1213,7 +1213,7 @@ AST_MATCHER_P(TemplateArgument, equalsIntegralValue,
               std::string, Value) {
   if (Node.getKind() != TemplateArgument::Integral)
     return false;
-  return Node.getAsIntegral().toString(10) == Value;
+  return toString(Node.getAsIntegral(), 10) == Value;
 }
 
 /// Matches an Objective-C autorelease pool statement.