[clang] 4c37671 - [Clang][Sema] Enabled implicit conversion warning for CompoundAssignment operator.
Fahad Nayyar via cfe-commits
cfe-commits at lists.llvm.org
Fri Jan 13 08:05:17 PST 2023
Author: Fahad Nayyar
Date: 2023-01-13T16:04:42Z
New Revision: 4c37671a7c946ac246b52fa44a6a649b89d6310b
URL: https://github.com/llvm/llvm-project/commit/4c37671a7c946ac246b52fa44a6a649b89d6310b
DIFF: https://github.com/llvm/llvm-project/commit/4c37671a7c946ac246b52fa44a6a649b89d6310b.diff
LOG: [Clang][Sema] Enabled implicit conversion warning for CompoundAssignment operator.
This change enables implicit conversion warnings (like Wshorten-64-to-32) for compound assignment operator with integral operands.
rdar://10466193
Differential Revision: https://reviews.llvm.org/D139114
Added:
Modified:
clang/docs/ReleaseNotes.rst
clang/lib/Sema/SemaChecking.cpp
clang/test/Sema/conversion-64-32.c
Removed:
################################################################################
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 92de83bae01cd..e8b61db26a860 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -351,6 +351,9 @@ Bug Fixes
Improvements to Clang's diagnostics
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+- Clang now supports implicit conversion warnings (``-Wsign-conversion``,
+ ``Wshorten-64-to-32``, etc) for compound assignment operators (like +=, -=, <<=, >>= etc)
+ with integral operands.
- Clang will now check compile-time determinable string literals as format strings.
Fixes `Issue 55805: <https://github.com/llvm/llvm-project/issues/55805>`_.
- ``-Wformat`` now recognizes ``%b`` for the ``printf``/``scanf`` family of
diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
index 1d956fadcf670..b3834c830d7b7 100644
--- a/clang/lib/Sema/SemaChecking.cpp
+++ b/clang/lib/Sema/SemaChecking.cpp
@@ -13508,8 +13508,13 @@ static void DiagnoseFloatingImpCast(Sema &S, Expr *E, QualType T,
}
}
+static void CheckImplicitConversion(Sema &S, Expr *E, QualType T,
+ SourceLocation CC,
+ bool *ICContext = nullptr,
+ bool IsListInit = false);
+
/// Analyze the given compound assignment for the possible losing of
-/// floating-point precision.
+/// floating-point precision and for implicit conversions for integral operands.
static void AnalyzeCompoundAssignment(Sema &S, BinaryOperator *E) {
assert(isa<CompoundAssignOperator>(E) &&
"Must be compound assignment operation");
@@ -13526,8 +13531,17 @@ static void AnalyzeCompoundAssignment(Sema &S, BinaryOperator *E) {
->getComputationResultType()
->getAs<BuiltinType>();
+ // Check for implicit conversions for compound assignment statements with
+ // intergral operands.
+ // FIXME: should this handle floating-point as well?
+ if (E->getLHS()->getType()->isIntegerType() &&
+ E->getRHS()->getType()->isIntegerType() && !E->isShiftAssignOp())
+ CheckImplicitConversion(S, E->getRHS(), E->getType(),
+ E->getRHS()->getExprLoc());
+
// The below checks assume source is floating point.
- if (!ResultBT || !RBT || !RBT->isFloatingPoint()) return;
+ if (!ResultBT || !RBT || !RBT->isFloatingPoint())
+ return;
// If source is floating point but target is an integer.
if (ResultBT->isInteger())
@@ -13816,9 +13830,8 @@ static void DiagnoseIntInBoolContext(Sema &S, Expr *E) {
}
static void CheckImplicitConversion(Sema &S, Expr *E, QualType T,
- SourceLocation CC,
- bool *ICContext = nullptr,
- bool IsListInit = false) {
+ SourceLocation CC, bool *ICContext,
+ bool IsListInit) {
if (E->isTypeDependent() || E->isValueDependent()) return;
const Type *Source = S.Context.getCanonicalType(E->getType()).getTypePtr();
diff --git a/clang/test/Sema/conversion-64-32.c b/clang/test/Sema/conversion-64-32.c
index 3de20cb0fda3a..6b9d2e2ff35ae 100644
--- a/clang/test/Sema/conversion-64-32.c
+++ b/clang/test/Sema/conversion-64-32.c
@@ -17,3 +17,36 @@ int4 test1(long2 a) {
int test2(long v) {
return v / 2; // expected-warning {{implicit conversion loses integer precision: 'long' to 'int'}}
}
+
+// rdar://10466193
+void test3(int i, long long ll) {
+ i += ll; // expected-warning {{implicit conversion loses integer precision}}
+ i -= ll; // expected-warning {{implicit conversion loses integer precision}}
+ i *= ll; // expected-warning {{implicit conversion loses integer precision}}
+ i /= ll; // expected-warning {{implicit conversion loses integer precision}}
+}
+
+void test4(int i, long long ll) {
+ i += i-ll; // expected-warning {{implicit conversion loses integer precision}}
+ i += i+ll; // expected-warning {{implicit conversion loses integer precision}}
+ i -= i-ll; // expected-warning {{implicit conversion loses integer precision}}
+ i -= i+ll; // expected-warning {{implicit conversion loses integer precision}}
+}
+
+void test5(int i, int j, long long ll) {
+ i += (i-j)*ll; // expected-warning {{implicit conversion loses integer precision}}
+ i += (i+j)*ll; // expected-warning {{implicit conversion loses integer precision}}
+ i -= ll/(i-j); // expected-warning {{implicit conversion loses integer precision}}
+ i -= ll/(i-j); // expected-warning {{implicit conversion loses integer precision}}
+}
+
+void test6(char c) {
+ c <<= 999999; // expected-warning {{shift count >= width of type}} \
+ // cxx17-warning {{shift count >= width of type}} \
+ // ref-warning {{shift count >= width of type}} \
+ // ref-cxx17-warning {{shift count >= width of type}}
+ c >>= 999999; // expected-warning {{shift count >= width of type}} \
+ // cxx17-warning {{shift count >= width of type}} \
+ // ref-warning {{shift count >= width of type}} \
+ // ref-cxx17-warning {{shift count >= width of type}}
+}
More information about the cfe-commits
mailing list