Diagnose -Wunused-value based on CFG reachability

[ychen]

Summary

While at it, add the diagnosis message "left operand of comma operator has no effect" (used by GCC) for comma operator.

This also makes Clang diagnose in the constant evaluation context which aligns with GCC/MSVC behavior. (https://godbolt.org/z/7zxb8Tx96)

[rsmith]

This will diagnose unused values in unreachable code in constant-evaluated contexts; that doesn't seem quite right. For example, in:

void f() {
  new double[false ? (1, 2) : 3][false ? (1, 2) : 3];
}

... we'll diagnose that the 1 is unused in only one of the two array bounds, because one of them is a constant-evaluated context and the other is not.

I'd suggest we start by adding a separate DiagIfReachable function that does the same thing as DiagRuntimeBehavior except without the context check, with the intent to eventually refine it to check for reachability even in expressions for which we don't build a CFG (eg, in the initializer of a global or in a constant expression).

[ychen]

• Add DiagIfReachable and use it in Sema::DiagnoseUnusedExprResult.
• Update tests.

[ychen]

In D103938#2806885, @rsmith wrote:

This will diagnose unused values in unreachable code in constant-evaluated contexts; that doesn't seem quite right. For example, in:

void f() {
  new double[false ? (1, 2) : 3][false ? (1, 2) : 3];
}

... we'll diagnose that the 1 is unused in only one of the two array bounds, because one of them is a constant-evaluated context and the other is not.

I'd suggest we start by adding a separate DiagIfReachable function that does the same thing as DiagRuntimeBehavior except without the context check, with the intent to eventually refine it to check for reachability even in expressions for which we don't build a CFG (eg, in the initializer of a global or in a constant expression).

@rsmith Thanks for the pointer! Comments addressed. For the reachability check in contexts without CFG, it seems that some delayed processing is needed since constant evaluation happens later, however, I'm not sure about that.

[ychen]

ping

[rsmith]

I've given this some more thought, and I think it's only the "constant evaluated" check that we want to bypass in this case. It's common to use sizeof or decltype with a comma operator in order to put an expression in a SFINAE context, and I don't think we should warn on those cases. So I think we should still do the context check for DiagIfReachable, but only bail out for unevaluated contexts, not for constant-evaluated contexts. Does that seem reasonable?

clang/test/SemaCXX/warn-unused-value.cpp

148

Please add a FIXME saying that we shouldn't diagnose the unreachable constant expression here.

[ychen]

• Add test case for 'constexpr if'

[ychen]

In D103938#2836470, @rsmith wrote:

I've given this some more thought, and I think it's only the "constant evaluated" check that we want to bypass in this case. It's common to use sizeof or decltype with a comma operator in order to put an expression in a SFINAE context, and I don't think we should warn on those cases. So I think we should still do the context check for DiagIfReachable, but only bail out for unevaluated contexts, not for constant-evaluated contexts. Does that seem reasonable?

Yeah, it is reasonable and seems already in place (https://reviews.llvm.org/rG78ecb8737d97a038770af9f6a1ad1d7925c87eb7).

[ychen]

ping..

[ychen]

ping

[aaron.ballman]

clang/include/clang/Sema/Sema.h

5121

clang/test/Sema/i-c-e.c

77–78

I think this diagnostic is kind of unfortunate because it increases my confusion -- the expression result is most assuredly *not* unused in these cases because it's used in the definition of the type.

clang/test/SemaCXX/warn-unused-value.cpp

145

This is another one that tripped me up due to the diagnostic wording.

[ychen]

• fix comment

clang/test/Sema/i-c-e.c

77–78

the expression result is most assuredly *not* unused in these cases because it's used in the definition of the type.

Do you mean "1" is used in the definition of the type? The warning is for "1" in this case. If I change 1 to any other number, the type of comma3 should not change, I think that means 1 is not used.

[aaron.ballman]

clang/test/Sema/i-c-e.c

77–78

Do you mean "1" is used in the definition of the type? The warning is for "1" in this case. If I change 1 to any other number, the type of comma3 should not change, I think that means 1 is not used.

I agree that the 1 is unused.

The trouble is that the diagnostic doesn't make that clear -- it just says the expression result is unused, which makes it sound like the entire comma expression result value is unused (which is not the case). I think the diagnostic should more clearly specify *what* is unused in this case, otherwise users may think the diagnostic is a false positive.

[ychen]

• Use more specific diagnoses "left operand of comma operator has no effect" when left operand of comma operator has no effect instead of "expression result is unused".

[ychen]

clang/test/Sema/i-c-e.c

77–78

Sounds good to me. I've used "left operand of comma operator has no effect" which is what GCC uses for this.

[ychen]

ping?

[aaron.ballman]

There were a few behavioral changes to tests that I had questions about. Also, can you add an additional test case that shows the behavior when the left operand of the comma expression is volatile (or do we already have that covered and I missed it)? e.g.,

int func() {
  volatile int *ip = (volatile int *)0xFEEDFACE;
  return (*ip, 1);
}

(In this case, we shouldn't diagnose that the left operand has no effect because reading a volatile variable is an operation with a side effect.)

clang/test/CodeCompletion/pragma-macro-token-caching.c

15

Why did we lose this diagnostic?

clang/test/Sema/exprs.c

19

Why did we lose this diagnostic (and the above comment about not changing the test)?

[ychen]

In D103938#3006540, @aaron.ballman wrote:

There were a few behavioral changes to tests that I had questions about. Also, can you add an additional test case that shows the behavior when the left operand of the comma expression is volatile (or do we already have that covered and I missed it)? e.g.,

int func() {
  volatile int *ip = (volatile int *)0xFEEDFACE;
  return (*ip, 1);
}

(In this case, we shouldn't diagnose that the left operand has no effect because reading a volatile variable is an operation with a side effect.)

It seems this is covered by svn157362.

clang/test/CodeCompletion/pragma-macro-token-caching.c

15

CFG analysis thinks it is unreachable, so it is not diagnosed.

clang/test/Sema/exprs.c

19

Because the behavior change here is that only reachable code is diagnosed. I should have kept the comment.

[ychen]

• Restore an useful comment.

[ychen]

Thanks for the review.

clang/test/Sema/exprs.c

19

I've put it back.

[aaron.ballman]

In D103938#3007708, @ychen wrote:

In D103938#3006540, @aaron.ballman wrote:

There were a few behavioral changes to tests that I had questions about. Also, can you add an additional test case that shows the behavior when the left operand of the comma expression is volatile (or do we already have that covered and I missed it)? e.g.,

int func() {
  volatile int *ip = (volatile int *)0xFEEDFACE;
  return (*ip, 1);
}

(In this case, we shouldn't diagnose that the left operand has no effect because reading a volatile variable is an operation with a side effect.)

It seems this is covered by svn157362.

Thanks, LGTM!

clang/test/CodeCompletion/pragma-macro-token-caching.c

15

Oh, I see now -- the CFG thinks this is unreachable because of the previous error.

[uabelho]

Hi @ychen,

A whole bunch of libcxx testcases fail for me when I run with this patch:

Failed Tests (90):
  libc++ :: libcxx/gdb/gdb_pretty_printer_test.sh.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_sseq.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/default.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/io.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_sseq.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/assign.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/copy.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/default.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/default.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/io.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/seed_result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/seed_sseq.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
  libc++ :: std/numerics/rand/rand.predef/mt19937_64.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.cons/default.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.hash/enabled_hash.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/all.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/any.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/count.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/flip_all.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/flip_one.out_of_range.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/flip_one.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/index.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/index_const.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/left_shift.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/none.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/not_all.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/reset_all.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/reset_one.out_of_range.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/reset_one.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/right_shift.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/set_all.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/set_one.out_of_range.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/set_one.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/size.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/test.out_of_range.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/test.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/to_string.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.operators/op_and.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.operators/op_not.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.operators/op_or.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.operators/stream_in.pass.cpp
  libc++ :: std/utilities/variant/variant.hash/hash.pass.cpp
  libc++ :: std/utilities/variant/variant.relops/relops.pass.cpp
  libc++ :: std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.status/index.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.status/valueless_by_exception.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
  libc++ :: std/utilities/variant/variant.visit/visit.pass.cpp
  libc++ :: std/utilities/variant/variant.visit/visit_return_type.pass.cpp

The first one fails like

In file included from /repo/uabelho/master-github/libcxx/test/libcxx/gdb/gdb_pretty_printer_test.sh.cpp:18:
/repo/uabelho/master-github/llvm/build-all-builtins/include/c++/v1/bitset:671:98: error: implicit conversion from 'unsigned long' to 'const unsigned int' changes value from 288230376151711744 to 0 [-Werror,-Wconstant-conversion]
    static const unsigned __n_words = _Size == 0 ? 0 : (_Size - 1) / (sizeof(size_t) * CHAR_BIT) + 1;
                          ~~~~~~~~~                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~
1 error generated.

error: command failed with exit status: 1

Can also be seen in build bots, e.g. here:
http://lab.llvm.org:8011/#/builders/119/builds/5612

[gulfem]

We also started seeing similar libc++ test failures in our Fuchsia builds:
https://logs.chromium.org/logs/fuchsia/buildbucket/cr-buildbucket/8835548361443044001/+/u/clang/test/stdout

Failed Tests (89):
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_sseq.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/default.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/io.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_sseq.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/assign.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/copy.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/default.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/default.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/io.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/seed_result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/seed_sseq.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
  libc++ :: std/numerics/rand/rand.predef/mt19937_64.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.cons/default.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.hash/enabled_hash.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/all.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/any.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/count.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/flip_all.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/flip_one.out_of_range.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/flip_one.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/index.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/index_const.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/left_shift.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/none.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/not_all.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/reset_all.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/reset_one.out_of_range.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/reset_one.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/right_shift.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/set_all.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/set_one.out_of_range.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/set_one.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/size.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/test.out_of_range.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/test.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/to_string.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.operators/op_and.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.operators/op_not.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.operators/op_or.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.operators/stream_in.pass.cpp
  libc++ :: std/utilities/variant/variant.hash/hash.pass.cpp
  libc++ :: std/utilities/variant/variant.relops/relops.pass.cpp
  libc++ :: std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.status/index.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.status/valueless_by_exception.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
  libc++ :: std/utilities/variant/variant.visit/visit.pass.cpp
  libc++ :: std/utilities/variant/variant.visit/visit_return_type.pass.cpp

Could you please revert it unless it could be fixed quickly?

[aaron.ballman]

In D103938#3012910, @gulfem wrote:

We also started seeing similar libc++ test failures in our Fuchsia builds:
https://logs.chromium.org/logs/fuchsia/buildbucket/cr-buildbucket/8835548361443044001/+/u/clang/test/stdout

Failed Tests (89):
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/assign.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/copy.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/ctor_sseq.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/default.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/discard.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/io.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/seed_sseq.pass.cpp
  libc++ :: std/numerics/rand/rand.adapt/rand.adapt.ibits/values.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.bern/rand.dist.bern.bin/eval_param.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.pconst/eval_param.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.samp/rand.dist.samp.plinear/eval_param.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.int/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.dis/rand.dist.uni/rand.dist.uni.real/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/assign.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/copy.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/ctor_result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/default.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.lcong/values.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/assign.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/copy.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/ctor_result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/default.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/discard.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/eval.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/io.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/seed_result_type.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/seed_sseq.pass.cpp
  libc++ :: std/numerics/rand/rand.eng/rand.eng.mers/values.pass.cpp
  libc++ :: std/numerics/rand/rand.predef/mt19937_64.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.cons/default.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.cons/string_ctor.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.cons/ull_ctor.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.hash/bitset.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.hash/enabled_hash.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/all.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/any.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/count.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/flip_all.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/flip_one.out_of_range.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/flip_one.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/index.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/index_const.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/left_shift.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/left_shift_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/none.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/not_all.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/op_and_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/op_eq_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/op_or_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/op_xor_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/reset_all.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/reset_one.out_of_range.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/reset_one.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/right_shift.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/right_shift_eq.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/set_all.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/set_one.out_of_range.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/set_one.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/size.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/test.out_of_range.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/test.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/to_string.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.members/to_ulong.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.operators/op_and.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.operators/op_not.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.operators/op_or.pass.cpp
  libc++ :: std/utilities/template.bitset/bitset.operators/stream_in.pass.cpp
  libc++ :: std/utilities/variant/variant.hash/hash.pass.cpp
  libc++ :: std/utilities/variant/variant.relops/relops.pass.cpp
  libc++ :: std/utilities/variant/variant.relops/relops_bool_conv.fail.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.assign/copy.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.assign/move.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.ctor/copy.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.ctor/move.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.status/index.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.status/valueless_by_exception.pass.cpp
  libc++ :: std/utilities/variant/variant.variant/variant.swap/swap.pass.cpp
  libc++ :: std/utilities/variant/variant.visit/visit.pass.cpp
  libc++ :: std/utilities/variant/variant.visit/visit_return_type.pass.cpp

Could you please revert it unless it could be fixed quickly?

I have reverted in 73a8bcd78921d38130fc42c90fd75d47b05b063d, thanks for letting us know about the test failures!

[ychen]

@uabelho @gulfem Thanks for the remainder. I could not reproduce the issue with my Ubuntu box. Could you please attach a reproducer?

[ychen]

In D103938#3012940, @ychen wrote:

@uabelho @gulfem Thanks for the remainder. I could not reproduce the issue with my Ubuntu box. Could you please attach a reproducer?

Never mind, I think I need "-Werror" to reproduce these.

[thakis]

This flags this code from absl:

template <typename ValueT, typename GenT,
          typename std::enable_if<std::is_integral<ValueT>::value, int>::type =
              (GenT{}, 0)>
constexpr FlagDefaultArg DefaultArg(int) {
  return {FlagDefaultSrc(GenT{}.value), FlagDefaultKind::kOneWord};
}

(https://source.chromium.org/chromium/chromium/src/+/main:third_party/abseil-cpp/absl/flags/internal/flag.h;l=293?q=third_party%2Fabseil-cpp%2Fabsl%2Fflags%2Finternal%2Fflag.h)

../../third_party/abseil-cpp/absl/flags/internal/flag.h:293:16: warning: left operand of comma operator has no effect [-Wunused-value]
              (GenT{}, 0)>
               ^   ~~
../../third_party/abseil-cpp/absl/flags/internal/flag.h:293:16: warning: left operand of comma operator has no effect [-Wunused-value]
              (GenT{}, 0)>
               ^   ~~

I guess it has a SFINAE effect there?

[ychen]

reopen to fix tests failure.

[ychen]

• Check the scope correctly: first line of DiagIfReachable should be getCurFunctionOrMethodDecl(). And the FunctionScopes should be kept to deal with requires expression where FunctionScopes could be empty.

[ychen]

• Remove accidentally included change.

[ychen]

This and 45c0ebe00efb should make -Werror build of libcxx tests pass.

[aaron.ballman]

The changes seem reasonable to me.

[thakis]

In D103938#3013503, @thakis wrote:

This flags this code from absl:

Did you see this comment? Looks like this relanded, but it still warns there even though it has an effect there I think (?)

[aaron.ballman]

In D103938#3013503, @thakis wrote:

This flags this code from absl:

template <typename ValueT, typename GenT,
          typename std::enable_if<std::is_integral<ValueT>::value, int>::type =
              (GenT{}, 0)>
constexpr FlagDefaultArg DefaultArg(int) {
  return {FlagDefaultSrc(GenT{}.value), FlagDefaultKind::kOneWord};
}

(https://source.chromium.org/chromium/chromium/src/+/main:third_party/abseil-cpp/absl/flags/internal/flag.h;l=293?q=third_party%2Fabseil-cpp%2Fabsl%2Fflags%2Finternal%2Fflag.h)

../../third_party/abseil-cpp/absl/flags/internal/flag.h:293:16: warning: left operand of comma operator has no effect [-Wunused-value]
              (GenT{}, 0)>
               ^   ~~
../../third_party/abseil-cpp/absl/flags/internal/flag.h:293:16: warning: left operand of comma operator has no effect [-Wunused-value]
              (GenT{}, 0)>
               ^   ~~

I guess it has a SFINAE effect there?

Sorry for having missed this comment before when reviewing the code @thakis, thanks for pinging on it! That does look like a false positive assuming it's being used for SFINAE. @ychen, can you take a look (and revert if it looks like it'll take a while to resolve)?

[ychen]

In D103938#3018588, @aaron.ballman wrote:

In D103938#3013503, @thakis wrote:

This flags this code from absl:

template <typename ValueT, typename GenT,
          typename std::enable_if<std::is_integral<ValueT>::value, int>::type =
              (GenT{}, 0)>
constexpr FlagDefaultArg DefaultArg(int) {
  return {FlagDefaultSrc(GenT{}.value), FlagDefaultKind::kOneWord};
}

(https://source.chromium.org/chromium/chromium/src/+/main:third_party/abseil-cpp/absl/flags/internal/flag.h;l=293?q=third_party%2Fabseil-cpp%2Fabsl%2Fflags%2Finternal%2Fflag.h)

../../third_party/abseil-cpp/absl/flags/internal/flag.h:293:16: warning: left operand of comma operator has no effect [-Wunused-value]
              (GenT{}, 0)>
               ^   ~~
../../third_party/abseil-cpp/absl/flags/internal/flag.h:293:16: warning: left operand of comma operator has no effect [-Wunused-value]
              (GenT{}, 0)>
               ^   ~~

I guess it has a SFINAE effect there?

Sorry for having missed this comment before when reviewing the code @thakis, thanks for pinging on it! That does look like a false positive assuming it's being used for SFINAE. @ychen, can you take a look (and revert if it looks like it'll take a while to resolve)?

@thakis sorry for missing that. Reverted. I'll take a look.

[ychen]

In D103938#3018918, @ychen wrote:

In D103938#3018588, @aaron.ballman wrote:

In D103938#3013503, @thakis wrote:

This flags this code from absl:

template <typename ValueT, typename GenT,
          typename std::enable_if<std::is_integral<ValueT>::value, int>::type =
              (GenT{}, 0)>
constexpr FlagDefaultArg DefaultArg(int) {
  return {FlagDefaultSrc(GenT{}.value), FlagDefaultKind::kOneWord};
}

(https://source.chromium.org/chromium/chromium/src/+/main:third_party/abseil-cpp/absl/flags/internal/flag.h;l=293?q=third_party%2Fabseil-cpp%2Fabsl%2Fflags%2Finternal%2Fflag.h)

../../third_party/abseil-cpp/absl/flags/internal/flag.h:293:16: warning: left operand of comma operator has no effect [-Wunused-value]
              (GenT{}, 0)>
               ^   ~~
../../third_party/abseil-cpp/absl/flags/internal/flag.h:293:16: warning: left operand of comma operator has no effect [-Wunused-value]
              (GenT{}, 0)>
               ^   ~~

I guess it has a SFINAE effect there?

Sorry for having missed this comment before when reviewing the code @thakis, thanks for pinging on it! That does look like a false positive assuming it's being used for SFINAE. @ychen, can you take a look (and revert if it looks like it'll take a while to resolve)?

@thakis sorry for missing that. Reverted. I'll take a look.

Diagnoses are suppressed in SFINAE context by default (https://github.com/llvm/llvm-project/blob/3dbf27e762008757c0de7034c778d941bfeb0388/clang/include/clang/Basic/Diagnostic.td#L83, related code is Sema::EmitCurrentDiagnostic). The test case triggered the warning because the substitution is successful for that overload candidate. When substitution failed, the warning is suppressed as expected. The test case I used is

#include<type_traits>

struct A {
  int value;
};

template <typename ValueT, typename GenT,
          typename std::enable_if<std::is_integral<ValueT>::value, int>::type =
               (GenT{},0)>
constexpr int DefaultArg(int) {
  return GenT{}.value;
}

template <typename ValueT, typename GenT>
constexpr int DefaultArg(double) {
  return 1;
}

int foo() {
    return DefaultArg<int,A>(0);
}
int bar() {
    return DefaultArg<double,A>(0);
}

So I think the behavior is expected and it seems absl already patch that code with (void). Is it ok with you to reland the patch @aaron.ballman @thakis ? Thanks

[aaron.ballman]

In D103938#3024938, @ychen wrote:

In D103938#3018918, @ychen wrote:

In D103938#3018588, @aaron.ballman wrote:

In D103938#3013503, @thakis wrote:

This flags this code from absl:

template <typename ValueT, typename GenT,
          typename std::enable_if<std::is_integral<ValueT>::value, int>::type =
              (GenT{}, 0)>
constexpr FlagDefaultArg DefaultArg(int) {
  return {FlagDefaultSrc(GenT{}.value), FlagDefaultKind::kOneWord};
}

(https://source.chromium.org/chromium/chromium/src/+/main:third_party/abseil-cpp/absl/flags/internal/flag.h;l=293?q=third_party%2Fabseil-cpp%2Fabsl%2Fflags%2Finternal%2Fflag.h)

../../third_party/abseil-cpp/absl/flags/internal/flag.h:293:16: warning: left operand of comma operator has no effect [-Wunused-value]
              (GenT{}, 0)>
               ^   ~~
../../third_party/abseil-cpp/absl/flags/internal/flag.h:293:16: warning: left operand of comma operator has no effect [-Wunused-value]
              (GenT{}, 0)>
               ^   ~~

I guess it has a SFINAE effect there?

Sorry for having missed this comment before when reviewing the code @thakis, thanks for pinging on it! That does look like a false positive assuming it's being used for SFINAE. @ychen, can you take a look (and revert if it looks like it'll take a while to resolve)?

@thakis sorry for missing that. Reverted. I'll take a look.

Diagnoses are suppressed in SFINAE context by default (https://github.com/llvm/llvm-project/blob/3dbf27e762008757c0de7034c778d941bfeb0388/clang/include/clang/Basic/Diagnostic.td#L83, related code is Sema::EmitCurrentDiagnostic). The test case triggered the warning because the substitution is successful for that overload candidate. When substitution failed, the warning is suppressed as expected. The test case I used is

#include<type_traits>

struct A {
  int value;
};

template <typename ValueT, typename GenT,
          typename std::enable_if<std::is_integral<ValueT>::value, int>::type =
               (GenT{},0)>
constexpr int DefaultArg(int) {
  return GenT{}.value;
}

template <typename ValueT, typename GenT>
constexpr int DefaultArg(double) {
  return 1;
}

int foo() {
    return DefaultArg<int,A>(0);
}
int bar() {
    return DefaultArg<double,A>(0);
}

So I think the behavior is expected and it seems absl already patch that code with (void). Is it ok with you to reland the patch @aaron.ballman @thakis ? Thanks

That will only help users who have newer versions of abseil. Also, I'm a bit worried this may be a code pattern used by more than just abseil.

The diagnostic text says that the comma operator has no effect, but this is a case where it does have a compile-time effect so the diagnostic sounds misleading. This suggests to me that we should silence the diagnostic in this case (because we want on-by-default diagnostics to be as close to free from false positives as possible). However, does silencing this cause significant issues with false negatives in other code examples?

[ychen]

In D103938#3025265, @aaron.ballman wrote:

In D103938#3024938, @ychen wrote:

In D103938#3018918, @ychen wrote:

In D103938#3018588, @aaron.ballman wrote:

In D103938#3013503, @thakis wrote:

This flags this code from absl:

template <typename ValueT, typename GenT,
          typename std::enable_if<std::is_integral<ValueT>::value, int>::type =
              (GenT{}, 0)>
constexpr FlagDefaultArg DefaultArg(int) {
  return {FlagDefaultSrc(GenT{}.value), FlagDefaultKind::kOneWord};
}

(https://source.chromium.org/chromium/chromium/src/+/main:third_party/abseil-cpp/absl/flags/internal/flag.h;l=293?q=third_party%2Fabseil-cpp%2Fabsl%2Fflags%2Finternal%2Fflag.h)

../../third_party/abseil-cpp/absl/flags/internal/flag.h:293:16: warning: left operand of comma operator has no effect [-Wunused-value]
              (GenT{}, 0)>
               ^   ~~
../../third_party/abseil-cpp/absl/flags/internal/flag.h:293:16: warning: left operand of comma operator has no effect [-Wunused-value]
              (GenT{}, 0)>
               ^   ~~

I guess it has a SFINAE effect there?

Sorry for having missed this comment before when reviewing the code @thakis, thanks for pinging on it! That does look like a false positive assuming it's being used for SFINAE. @ychen, can you take a look (and revert if it looks like it'll take a while to resolve)?

@thakis sorry for missing that. Reverted. I'll take a look.

Diagnoses are suppressed in SFINAE context by default (https://github.com/llvm/llvm-project/blob/3dbf27e762008757c0de7034c778d941bfeb0388/clang/include/clang/Basic/Diagnostic.td#L83, related code is Sema::EmitCurrentDiagnostic). The test case triggered the warning because the substitution is successful for that overload candidate. When substitution failed, the warning is suppressed as expected. The test case I used is

#include<type_traits>

struct A {
  int value;
};

template <typename ValueT, typename GenT,
          typename std::enable_if<std::is_integral<ValueT>::value, int>::type =
               (GenT{},0)>
constexpr int DefaultArg(int) {
  return GenT{}.value;
}

template <typename ValueT, typename GenT>
constexpr int DefaultArg(double) {
  return 1;
}

int foo() {
    return DefaultArg<int,A>(0);
}
int bar() {
    return DefaultArg<double,A>(0);
}

So I think the behavior is expected and it seems absl already patch that code with (void). Is it ok with you to reland the patch @aaron.ballman @thakis ? Thanks

That will only help users who have newer versions of abseil. Also, I'm a bit worried this may be a code pattern used by more than just abseil.

The diagnostic text says that the comma operator has no effect, but this is a case where it does have a compile-time effect so the diagnostic sounds misleading. This suggests to me that we should silence the diagnostic in this case (because we want on-by-default diagnostics to be as close to free from false positives as possible). However, does silencing this cause significant issues with false negatives in other code examples?

This makes great sense to me. IIUC, only constant-evaluation context could be in SFINAE context, so a check for this specific case should only affect the constant-evaluation context this patch is newly addressing. I'll update the patch and run some tests. Thanks for the quick reply.

[ychen]

• Disable comma operator diagnose in SFINAE context.

[ychen]

• Add a test case.

[aaron.ballman]

LGTM with some minor corrections in comments, thank you for the fix!

clang/lib/Sema/SemaStmt.cpp

381–383

clang/test/SemaCXX/warn-unused-value.cpp

154

[ychen]

• Address comments.

[thakis]

Thanks!

[xbolva00]

clang/include/clang/Sema/Sema.h

5124

Please adjust documentation, there is no "Statement" param.

[ychen]

clang/include/clang/Sema/Sema.h

5124

Fixed in a944f801cacdaa40. Thanks.

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def ext_typecheck_cond_pointer_integer_mismatch : ExtWarn<
   "pointer/integer type mismatch in conditional expression"
   "%diff{ ($ and $)|}0,1">,
   InGroup<DiagGroup<"conditional-type-mismatch">>;
 def err_typecheck_choose_expr_requires_constant : Error<
   "'__builtin_choose_expr' requires a constant expression">;
 def warn_unused_expr : Warning<"expression result unused">,
   InGroup<UnusedValue>;
+def warn_unused_comma_left_operand : Warning<
+  "left operand of comma operator has no effect">,
+  InGroup<UnusedValue>;
 def warn_unused_voidptr : Warning<
   "expression result unused; should this cast be to 'void'?">,
   InGroup<UnusedValue>;
 def warn_unused_property_expr : Warning<
  "property access result unused - getters should not be used for side effects">,
   InGroup<UnusedGetterReturnValue>;
 def warn_unused_container_subscript_expr : Warning<
  "container access result unused - container access should not be used for side effects">,

clang/include/clang/Sema/Sema.h

public:
   bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const;
 
   /// If it's a file scoped decl that must warn if not used, keep track
   /// of it.
   void MarkUnusedFileScopedDecl(const DeclaratorDecl *D);
 
   /// DiagnoseUnusedExprResult - If the statement passed in is an expression
   /// whose result is unused, warn.
-  void DiagnoseUnusedExprResult(const Stmt *S);
+  void DiagnoseUnusedExprResult(const Stmt *S, unsigned DiagID);
   void DiagnoseUnusedNestedTypedefs(const RecordDecl *D);
   void DiagnoseUnusedDecl(const NamedDecl *ND);
 
   /// If VD is set but not otherwise used, diagnose, for a parameter or a
   /// variable.
   void DiagnoseUnusedButSetDecl(const VarDecl *VD);
 
   /// Emit \p DiagID if statement located on \p StmtLoc has a suspicious null
public:
   /// Figure out if an expression could be turned into a call.
   bool tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
                      UnresolvedSetImpl &NonTemplateOverloads);
 
   /// Try to convert an expression \p E to type \p Ty. Returns the result of the
   /// conversion.
   ExprResult tryConvertExprToType(Expr *E, QualType Ty);
 
+  /// Conditionally issue a diagnostic based on the statement's reachability
+  /// analysis evaluation context.
+  ///
+  /// \param Statement If Statement is non-null, delay reporting the
+  /// diagnostic until the function body is parsed, and then do a basic
+  /// reachability analysis to determine if the statement is reachable.
+  /// If it is unreachable, the diagnostic will not be emitted.
+  bool DiagIfReachable(SourceLocation Loc, ArrayRef<const Stmt *> Stmts,
+                       const PartialDiagnostic &PD);
+
   /// Conditionally issue a diagnostic based on the current
   /// evaluation context.
   ///
   /// \param Statement If Statement is non-null, delay reporting the
   /// diagnostic until the function body is parsed, and then do a basic
   /// reachability analysis to determine if the statement is reachable.
   /// If it is unreachable, the diagnostic will not be emitted.
   bool DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,

clang/lib/Sema/SemaExpr.cpp

 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExprOpenMP.h"
 #include "clang/AST/OperationKinds.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/Builtins.h"
+#include "clang/Basic/DiagnosticSema.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/LiteralSupport.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/AnalysisBasedWarnings.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/DelayedDiagnostic.h"
static QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS,
   // C++'s comma does not do any conversions at all (C++ [expr.comma]p1).
 
   // So we treat the LHS as a ignored value, and in C++ we allow the
   // containing site to determine what should be done with the RHS.
   LHS = S.IgnoredValueConversions(LHS.get());
   if (LHS.isInvalid())
     return QualType();
 
-  S.DiagnoseUnusedExprResult(LHS.get());
+  S.DiagnoseUnusedExprResult(LHS.get(), diag::warn_unused_comma_left_operand);
 
   if (!S.getLangOpts().CPlusPlus) {
     RHS = S.DefaultFunctionArrayLvalueConversion(RHS.get());
     if (RHS.isInvalid())
       return QualType();
     if (!RHS.get()->getType()->isVoidType())
       S.RequireCompleteType(Loc, RHS.get()->getType(),
                             diag::err_incomplete_type);

 ///
 /// \param SkipLocalVariables If true, don't mark local variables as
 /// 'referenced'.
 void Sema::MarkDeclarationsReferencedInExpr(Expr *E,
                                             bool SkipLocalVariables) {
   EvaluatedExprMarker(*this, SkipLocalVariables).Visit(E);
 }
 
+/// Emit a diagnostic when statements are reachable.
+/// FIXME: check for reachability even in expressions for which we don't build a
+///        CFG (eg, in the initializer of a global or in a constant expression).
+///        For example,
+///        namespace { auto *p = new double[3][false ? (1, 2) : 3]; }
+bool Sema::DiagIfReachable(SourceLocation Loc, ArrayRef<const Stmt *> Stmts,
+                           const PartialDiagnostic &PD) {
+  if (!Stmts.empty() && getCurFunctionOrMethodDecl()) {
+    if (!FunctionScopes.empty())
+      FunctionScopes.back()->PossiblyUnreachableDiags.push_back(
+          sema::PossiblyUnreachableDiag(PD, Loc, Stmts));
+    return true;
+  }
+
+  // The initializer of a constexpr variable or of the first declaration of a
+  // static data member is not syntactically a constant evaluated constant,
+  // but nonetheless is always required to be a constant expression, so we
+  // can skip diagnosing.
+  // FIXME: Using the mangling context here is a hack.
+  if (auto *VD = dyn_cast_or_null<VarDecl>(
+          ExprEvalContexts.back().ManglingContextDecl)) {
+    if (VD->isConstexpr() ||
+        (VD->isStaticDataMember() && VD->isFirstDecl() && !VD->isInline()))
+      return false;
+    // FIXME: For any other kind of variable, we should build a CFG for its
+    // initializer and check whether the context in question is reachable.
+  }
+
+  Diag(Loc, PD);
+  return true;
+}
+
 /// Emit a diagnostic that describes an effect on the run-time behavior
 /// of the program being compiled.
 ///
 /// This routine emits the given diagnostic when the code currently being
 /// type-checked is "potentially evaluated", meaning that there is a
 /// possibility that the code will actually be executable. Code in sizeof()
 /// expressions, code used only during overload resolution, etc., are not
 /// potentially evaluated. This routine will suppress such diagnostics or,
case ExpressionEvaluationContext::DiscardedStatement:
     break;
 
   case ExpressionEvaluationContext::ConstantEvaluated:
     // Relevant diagnostics should be produced by constant evaluation.
     break;
 
   case ExpressionEvaluationContext::PotentiallyEvaluated:
   case ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed:
-    if (!Stmts.empty() && getCurFunctionOrMethodDecl()) {
-      FunctionScopes.back()->PossiblyUnreachableDiags.
-        push_back(sema::PossiblyUnreachableDiag(PD, Loc, Stmts));
-      return true;
-    }
-
-    // The initializer of a constexpr variable or of the first declaration of a
-    // static data member is not syntactically a constant evaluated constant,
-    // but nonetheless is always required to be a constant expression, so we
-    // can skip diagnosing.
-    // FIXME: Using the mangling context here is a hack.
-    if (auto *VD = dyn_cast_or_null<VarDecl>(
-            ExprEvalContexts.back().ManglingContextDecl)) {
-      if (VD->isConstexpr() ||
-          (VD->isStaticDataMember() && VD->isFirstDecl() && !VD->isInline()))
-        break;
-      // FIXME: For any other kind of variable, we should build a CFG for its
-      // initializer and check whether the context in question is reachable.
-    }
-
-    Diag(Loc, PD);
-    return true;
+    return DiagIfReachable(Loc, Stmts, PD);
   }
 
   return false;
 }
 
 bool Sema::DiagRuntimeBehavior(SourceLocation Loc, const Stmt *Statement,
                                const PartialDiagnostic &PD) {
   return DiagRuntimeBehavior(

clang/lib/Sema/SemaExprCXX.cpp

if (DiscardedValue) {
     FullExpr = CheckPlaceholderExpr(FullExpr.get());
     if (FullExpr.isInvalid())
       return ExprError();
 
     FullExpr = IgnoredValueConversions(FullExpr.get());
     if (FullExpr.isInvalid())
       return ExprError();
 
-    DiagnoseUnusedExprResult(FullExpr.get());
+    DiagnoseUnusedExprResult(FullExpr.get(), diag::warn_unused_expr);
   }
 
   FullExpr = CorrectDelayedTyposInExpr(FullExpr.get(), /*InitDecl=*/nullptr,
                                        /*RecoverUncorrectedTypos=*/true);
   if (FullExpr.isInvalid())
     return ExprError();
 
   CheckCompletedExpr(FullExpr.get(), CC, IsConstexpr);

clang/lib/Sema/SemaStmt.cpp

static bool DiagnoseNoDiscard(Sema &S, const WarnUnusedResultAttr *A,
   }
 
   if (IsCtor)
     return S.Diag(Loc, diag::warn_unused_constructor_msg) << A << Msg << R1
                                                           << R2;
   return S.Diag(Loc, diag::warn_unused_result_msg) << A << Msg << R1 << R2;
 }
 
-void Sema::DiagnoseUnusedExprResult(const Stmt *S) {
+void Sema::DiagnoseUnusedExprResult(const Stmt *S, unsigned DiagID) {
   if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
-    return DiagnoseUnusedExprResult(Label->getSubStmt());
+    return DiagnoseUnusedExprResult(Label->getSubStmt(), DiagID);
 
   const Expr *E = dyn_cast_or_null<Expr>(S);
   if (!E)
     return;
 
   // If we are in an unevaluated expression context, then there can be no unused
   // results because the results aren't expected to be used in the first place.
   if (isUnevaluatedContext())
if (isa<ParenExpr>(E->IgnoreImpCasts()) && Loc.isMacroID()) {
     SourceLocation SpellLoc = Loc;
     if (findMacroSpelling(SpellLoc, "UNREFERENCED_PARAMETER"))
       return;
   }
 
   // Okay, we have an unused result.  Depending on what the base expression is,
   // we might want to make a more specific diagnostic.  Check for one of these
   // cases now.
-  unsigned DiagID = diag::warn_unused_expr;
   if (const FullExpr *Temps = dyn_cast<FullExpr>(E))
     E = Temps->getSubExpr();
   if (const CXXBindTemporaryExpr *TempExpr = dyn_cast<CXXBindTemporaryExpr>(E))
     E = TempExpr->getSubExpr();
 
   if (DiagnoseUnusedComparison(*this, E))
     return;
 
if (MD) {
         return;
     }
   } else if (const PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(E)) {
     const Expr *Source = POE->getSyntacticForm();
     // Handle the actually selected call of an OpenMP specialized call.
     if (LangOpts.OpenMP && isa<CallExpr>(Source) &&
         POE->getNumSemanticExprs() == 1 &&
         isa<CallExpr>(POE->getSemanticExpr(0)))
-      return DiagnoseUnusedExprResult(POE->getSemanticExpr(0));
+      return DiagnoseUnusedExprResult(POE->getSemanticExpr(0), DiagID);
     if (isa<ObjCSubscriptRefExpr>(Source))
       DiagID = diag::warn_unused_container_subscript_expr;
     else
       DiagID = diag::warn_unused_property_expr;
   } else if (const CXXFunctionalCastExpr *FC
                                        = dyn_cast<CXXFunctionalCastExpr>(E)) {
     const Expr *E = FC->getSubExpr();
     if (const CXXBindTemporaryExpr *TE = dyn_cast<CXXBindTemporaryExpr>(E))
void Sema::DiagnoseUnusedExprResult(const Stmt *S, unsigned DiagID) {
   // Tell the user to assign it into a variable to force a volatile load if this
   // isn't an array.
   if (E->isGLValue() && E->getType().isVolatileQualified() &&
       !E->getType()->isArrayType()) {
     Diag(Loc, diag::warn_unused_volatile) << R1 << R2;
     return;
   }
 
-  DiagRuntimeBehavior(Loc, nullptr, PDiag(DiagID) << R1 << R2);
+  DiagIfReachable(Loc, S ? llvm::makeArrayRef(S) : llvm::None,
+                  PDiag(DiagID) << R1 << R2);
 }
 
 void Sema::ActOnStartOfCompoundStmt(bool IsStmtExpr) {
   PushCompoundScope(IsStmtExpr);
 }
 
 void Sema::ActOnAfterCompoundStatementLeadingPragmas() {
   if (getCurFPFeatures().isFPConstrained()) {
     FunctionScopeInfo *FSI = getCurFunction();

clang/test/Analysis/dead-stores.c

void f22() {
   case 6:
     1 ? ((void)y6, ({ return; })) : (void)x;
     (void)x;
     break;
   case 7:
     (void)(0 && x);
     (void)y7;
     (void)(0 || (y8, ({ return; }), 1));
-    // non-nested-warning@-1 {{expression result unused}}
+    // non-nested-warning@-1 {{left operand of comma operator has no effect}}
     (void)x;
     break;
   case 8:
     (void)(1 && (y9, ({ return; }), 1));
-    // non-nested-warning@-1 {{expression result unused}}
+    // non-nested-warning@-1 {{left operand of comma operator has no effect}}
     (void)x;
     break;
   case 9:
     (void)(1 || x);
     (void)y10;
     break;
   case 10:
     while (0) {

clang/test/CXX/basic/basic.link/p8.cpp

 extern Linkage1::Inner linkage1iv;
 extern Linkage2 linkage2v;
 extern Linkage2::Inner linkage2iv;
 extern Template<Linkage1> linkaget1v;
 extern Linkage1 linkage1f();
 void linkage2f(Linkage2);
 
 void use_linkage() {
-  &linkage1v, &linkage1iv, &linkage2v, &linkage2iv, &linkaget1v; // expected-warning 5{{unused}}
+  &linkage1v, &linkage1iv, &linkage2v, &linkage2iv, &linkaget1v; // expected-warning 4{{left operand of comma operator has no effect}} expected-warning {{unused}}
   linkage1f();
   linkage2f({});
 }
 
 extern NoLinkage1 no_linkage1(); // expected-error {{function 'no_linkage1' is used but not defined in this translation unit}}
 extern NoLinkage2 no_linkage2(); // expected-error {{function 'no_linkage2' is used but not defined in this translation unit}}
 extern NoLinkage3 no_linkage3(); // expected-error {{function 'no_linkage3' is used but not defined in this translation unit}}
 

clang/test/CXX/drs/dr14xx.cpp

template<typename T> struct A : T {
     static const int b;
     static void c();
     void d();
 
     void f() {
       Check<true ? 0 : A::unknown_spec>::type *var1; // expected-error {{undeclared identifier 'var1'}}
       Check<true ? 0 : a>::type *var2; // ok, variable declaration  expected-note 0+{{here}}
       Check<true ? 0 : b>::type *var3; // expected-error {{undeclared identifier 'var3'}}
-      Check<true ? 0 : (c, 0)>::type *var4; // expected-error {{undeclared identifier 'var4'}}
+      Check<true ? 0 : ((void)c, 0)>::type *var4; // expected-error {{undeclared identifier 'var4'}}
       // value-dependent because of the implied type-dependent 'this->', not because of 'd'
       Check<true ? 0 : (d(), 0)>::type *var5; // expected-error {{undeclared identifier 'var5'}}
       // value-dependent because of the value-dependent '&' operator, not because of 'A::d'
       Check<true ? 0 : (&A::d(), 0)>::type *var5; // expected-error {{undeclared identifier 'var5'}}
     }
   };
 }
 

clang/test/CXX/drs/dr20xx.cpp

void discarded_lval() {
     A a; // expected-note 1+{{here}}
     int &r = a.x; // expected-note {{here}}
     struct B {
       void f() {
         a.x; // expected-warning {{unused}}
         a.*&A::x; // expected-warning {{unused}}
         true ? a.x : a.y; // expected-warning {{unused}}
         (void)a.x;
-        a.x, discarded_lval(); // expected-warning {{unused}}
+        a.x, discarded_lval(); // expected-warning {{left operand of comma operator has no effect}}
 #if 1 // FIXME: These errors are all incorrect; the above code is valid.
       // expected-error@-6 {{enclosing function}}
       // expected-error@-6 {{enclosing function}}
       // expected-error@-6 2{{enclosing function}}
       // expected-error@-6 {{enclosing function}}
       // expected-error@-6 {{enclosing function}}
 #endif
 

clang/test/CXX/drs/dr7xx.cpp

namespace dr712 { // dr712: partial
   void use(int);
   void f() {
     const int a = 0; // expected-note 5{{here}}
     struct X {
       void g(bool cond) {
         use(a);
         use((a));
         use(cond ? a : a);
-        use((cond, a)); // expected-warning 2{{unused}} FIXME: should only warn once
+        use((cond, a)); // expected-warning 2{{left operand of comma operator has no effect}} FIXME: should only warn once
 
         (void)a; // FIXME: expected-error {{declared in enclosing}}
         (void)(a); // FIXME: expected-error {{declared in enclosing}}
         (void)(cond ? a : a); // FIXME: expected-error 2{{declared in enclosing}}
-        (void)(cond, a); // FIXME: expected-error {{declared in enclosing}} expected-warning {{unused}}
+        (void)(cond, a); // FIXME: expected-error {{declared in enclosing}} expected-warning {{left operand of comma operator has no effect}}
       }
     };
   }
 
 #if __cplusplus >= 201103L
   void g() {
     struct A { int n; };
     constexpr A a = {0}; // expected-note 2{{here}}

clang/test/CXX/temp/temp.constr/temp.constr.constr/partial-specializations.cpp

namespace class_templates
 
   template<typename T> requires A<T>::type // expected-note{{in instantiation of template class 'class_templates::A<int *>' requested here}}
                                            // expected-note@-1{{while substituting template arguments into constraint expression here}}
   struct B<T*> {};
 
   template<typename T> requires (T{}) // expected-error{{atomic constraint must be of type 'bool' (found 'int')}}
   struct B<T**> {};
 
-  static_assert((B<int**>{}, true)); // expected-note{{while checking constraint satisfaction for class template partial specialization 'B<int *>' required here}}
+  static_assert(((void)B<int**>{}, true)); // expected-note{{while checking constraint satisfaction for class template partial specialization 'B<int *>' required here}}
   // expected-note@-1{{while checking constraint satisfaction for class template partial specialization 'B<int>' required here}}
   // expected-note@-2{{during template argument deduction for class template partial specialization 'B<T *>' [with T = int *]}}
   // expected-note@-3{{during template argument deduction for class template partial specialization 'B<T **>' [with T = int]}}
   // expected-note@-4 2{{in instantiation of template class 'class_templates::B<int **>' requested here}}
 
   template<typename T, typename U = double>
   concept same_as = is_same<T, U>::value;
 
namespace variable_templates
 
   static_assert(v1<int**>); // expected-note{{while checking constraint satisfaction for variable template partial specialization 'v1<int *>' required here}}
   // expected-note@-1{{while checking constraint satisfaction for variable template partial specialization 'v1<int>' required here}}
   // expected-note@-2{{during template argument deduction for variable template partial specialization 'v1<T *>' [with T = int *]}}
   // expected-note@-3{{during template argument deduction for variable template partial specialization 'v1<T **>' [with T = int]}}
   // expected-error@-4{{static_assert failed due to requirement 'v1<int **>'}}
 
 }
 No newline at end of file

clang/test/CodeCompletion/pragma-macro-token-caching.c

 
 #define Outer(action) action
 
 void completeParam(int param) {
     ;
     Outer(__extension__({ _Pragma("clang diagnostic push") }));
     param;
 }
 
 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:7:1 %s | FileCheck %s
 // CHECK: param : [#int#]param
 
 void completeParamPragmaError(int param) {
     Outer(__extension__({ _Pragma(2) })); // expected-error {{_Pragma takes a parenthesized string literal}}
-    param; // expected-warning {{expression result unused}}
+    param;
 }
 
 // RUN: %clang_cc1 -fsyntax-only -verify -code-completion-at=%s:16:1 %s | FileCheck %s

clang/test/Frontend/fixed_point_crash.c

 // RUN: %clang_cc1 -verify -ffixed-point %s
 
 union a {
   _Accum x;
   int i;
 };
 
 int fn1() {
   union a m;
   m.x = 5.6k;
   return m.i;
 }
 
 int fn2() {
   union a m;
   m.x = 7, 5.6k; // expected-warning {{expression result unused}}
-  return m.x, m.i; // expected-warning {{expression result unused}}
+  return m.x, m.i; // expected-warning {{left operand of comma operator has no effect}}
 }
 
-_Accum acc = (0.5r, 6.9k); // expected-warning {{expression result unused}}
+_Accum acc = (0.5r, 6.9k); // expected-warning {{left operand of comma operator has no effect}}

clang/test/PCH/cxx-explicit-specifier.cpp

 // RUN: %clang_cc1 -std=c++2a -include %s %s -ast-print -verify | FileCheck %s
 //
 // RUN: %clang_cc1 -std=c++2a -emit-pch %s -o %t-cxx2a
 // RUN: %clang_cc1 -std=c++2a -include-pch %t-cxx2a %s -ast-print -verify | FileCheck %s
 
 // RUN: %clang_cc1 -std=c++2a -emit-pch -fpch-instantiate-templates %s -o %t-cxx2a
 // RUN: %clang_cc1 -std=c++2a -include-pch %t-cxx2a %s -ast-print -verify | FileCheck %s
 
 #ifndef USE_PCH
 namespace inheriting_constructor {
   struct S {};
 
   template<typename X, typename Y> struct T {
     template<typename A>
-    explicit((Y{}, true)) T(A &&a) {}
+    explicit(((void)Y{}, true)) T(A &&a) {}
   };
 
   template<typename X, typename Y> struct U : T<X, Y> {
     using T<X, Y>::T;
   };
 
   U<S, char> foo(char ch) {
     return U<S, char>(ch);
   }
 }
 #else
 namespace inheriting_constructor {
 U<S, char> a = foo('0');
 }
 
-//CHECK: explicit((char{} , true))
+//CHECK: explicit(((void)char{} , true))
 
 #endif
 
 namespace basic {
 #ifndef USE_PCH
 
 struct B {};
 

clang/test/Parser/cxx-ambig-decl-expr.cpp

 int f(unknown const x); // expected-error {{unknown type name 'unknown'}}
 
 // Disambiguating an array declarator from an array subscripting.
 void arr() {
   int x[] = {1}; // expected-note 2{{previous}}
 
   // This is array indexing not an array declarator because a comma expression
   // is not syntactically a constant-expression.
-  int(x[1,1]); // expected-warning 2{{unused}}
+  int(x[1,1]); // expected-warning {{left operand of comma operator has no effect}} expected-warning {{unused}}
 
   // This is array indexing not an array declaration because a braced-init-list
   // is not syntactically a constant-expression.
   int(x[{0}]); // expected-error {{array subscript is not an integer}}
   struct A {
     struct Q { int n; };
     int operator[](Q);
   } a;
   int(a[{0}]); // expected-warning {{unused}}
 
   // These are array declarations.
-  int(x[(1,1)]); // expected-error {{redefinition}}
-  int(x[true ? 1,1 : 1]); // expected-error {{redefinition}}
+  int(x[((void)1,1)]); // expected-error {{redefinition}}
+  int(x[true ? 1 : (1,1)]); // expected-error {{redefinition}} // expected-warning {{left operand of comma operator has no effect}}
 
   int (*_Atomic atomic_ptr_to_int);
   *atomic_ptr_to_int = 42;
 }

clang/test/Parser/cxx0x-ambig.cpp

void foo(int x, T ...t) {
     int *p0 = &x0;
     (void)p0;
 
     CtorSink x1(int(t) ..., int(x)); // ok, declares object x1
     CtorSink *p1 = &x1;
     (void)p1;
 
     UnsignedTmplArgSink<T(CtorSink(t ...)) ...> *t0; // ok
-    UnsignedTmplArgSink<((T *)0, 42u) ...> **t0p = &t0;
+    UnsignedTmplArgSink<((T *)0, 42u) ...> **t0p = &t0; // expected-warning 2{{left operand of comma operator has no effect}}
   }
 
   template void foo(int, int, int); // expected-note {{in instantiation of function template specialization 'ellipsis::foo<int, int>' requested here}}
 }
 
 namespace braced_init_list {
   struct X {
     void foo() {}

clang/test/Parser/cxx1z-init-statement.cpp

 // RUN: %clang_cc1 -std=c++1z -verify %s -Wno-vexing-parse
 
 int g, h;
 typedef int T;
 int f() {
   // init-statement declarations
   if (T n = 0; n != 0) {}
   if (T f(); f()) {}
   if (T(f()); f()) {}
   if (T(f()), g, h; f()) {}
   if (T f(); f()) {}
   if (T f(), g, h; f()) {}
   if (T(n) = 0; n) {}
 
   // init-statement expressions
   if (T{f()}; f()) {} // expected-warning {{expression result unused}}
-  if (T{f()}, g, h; f()) {} // expected-warning 2{{unused}} expected-warning {{expression result unused}}
-  if (T(f()), g, h + 1; f()) {} // expected-warning 2{{unused}} expected-warning {{expression result unused}}
+  if (T{f()}, g, h; f()) {} // expected-warning 2{{left operand of comma operator has no effect}} expected-warning {{expression result unused}}
+  if (T(f()), g, h + 1; f()) {} // expected-warning 2{{left operand of comma operator has no effect}} expected-warning {{expression result unused}}
 
   // condition declarations
   if (T(n){g}) {}
   if (T f()) {} // expected-error {{function type}}
   if (T f(), g, h) {} // expected-error {{function type}}
   if (T(n) = 0) {}
 
   // condition expressions
   if (T(f())) {}
   if (T{f()}) {}
-  if (T(f()), g, h) {} // expected-warning 2{{unused}}
-  if (T{f()}, g, h) {} // expected-warning 2{{unused}}
+  if (T(f()), g, h) {} // expected-warning 2{{left operand of comma operator has no effect}}
+  if (T{f()}, g, h) {} // expected-warning 2{{left operand of comma operator has no effect}}
 
   // none of the above, disambiguated as expression (can't be a declaration)
   if (T(n)(g)) {} // expected-error {{undeclared identifier 'n'}}
   if (T(n)(int())) {} // expected-error {{undeclared identifier 'n'}}
 
   // Likewise for 'switch'
   switch (int n; n) {}
   switch (g; int g = 5) {} // expected-warning {{expression result unused}}

clang/test/Parser/objc-messaging-1.m

 // RUN: %clang_cc1 %s -fsyntax-only -verify
 int main ()
 {
   int i,j;
   struct S *p;
         id a, b, c;
   [a ii]; // expected-warning{{not found}}
   [a if: 1 :2]; // expected-warning{{not found}}
   [a inout: 1 :2 another:(2,3,4)]; // expected-warning{{not found}} \
-           // expected-warning 2{{expression result unused}}
+           // expected-warning 2{{left operand of comma operator has no effect}}
   [a inout: 1 :2 another:(2,3,4), 6,6,8]; // expected-warning{{not found}} \
-           // expected-warning 2{{expression result unused}}
+           // expected-warning 2{{left operand of comma operator has no effect}}
   [a inout: 1 :2 another:(2,3,4), (6,4,5),6,8]; // expected-warning{{not found}} \
-           // expected-warning 4{{expression result unused}}
+           // expected-warning 4{{left operand of comma operator has no effect}}
   [a inout: 1 :2 another:(i+10), (i,j-1,5),6,8]; // expected-warning{{not found}} \
-           // expected-warning 2{{expression result unused}}
+           // expected-warning 2{{left operand of comma operator has no effect}}
   [a long: 1 :2 another:(i+10), (i,j-1,5),6,8]; // expected-warning{{not found}} \
-           // expected-warning 2{{expression result unused}}
+           // expected-warning 2{{left operand of comma operator has no effect}}
   [a : "Hello\n" :2 another:(i+10), (i,j-1,5),6,8]; // expected-warning{{not found}} \
-           // expected-warning 2{{expression result unused}}
+           // expected-warning 2{{left operand of comma operator has no effect}}
 
   // Comma expression as receiver (rdar://6222856)
   [a, b, c foo]; // expected-warning{{not found}} \
-           // expected-warning 2{{expression result unused}}
+           // expected-warning 2{{left operand of comma operator has no effect}}
 
 }

clang/test/Parser/objc-try-catch-1.m

@catch (Frob1* ex) {
     @throw proc();
   }
   @finally {
     @try {
       return proc();
     }
     @catch (Frob* ex) {
       @throw 1,2; // expected-error {{@throw requires an Objective-C object type ('int' invalid)}} \
-          // expected-warning {{expression result unused}}
+          // expected-warning {{left operand of comma operator has no effect}}
     }
     @catch (float x) {  // expected-error {{@catch parameter is not a pointer to an interface type}}
       
     }
     @catch(...) {
-      @throw (4,3,proc()); // expected-warning {{expression result unused}} \
-               // expected-warning {{expression result unused}}
+      @throw (4,3,proc()); // expected-warning 2{{left operand of comma operator has no effect}}
     }
   }
 
   @try {  // expected-error {{@try statement without a @catch and @finally clause}}
     return proc();
   }
 }
 

clang/test/Parser/objcxx11-attributes.mm

void f(X *noreturn) {
 
   int c[ [noreturn getSize] + 1 ];
 
   // An array size which is computed by a lambda is not OK.
   int d[ [noreturn] { return 3; } () ]; // expected-error {{expected ']'}} expected-error {{'noreturn' attribute only applies to functions}}
 
   // A message send which contains a message send is OK.
   [ [ X alloc ] init ];
-  [ [ int(), noreturn getSelf ] getSize ]; // expected-warning {{unused}}
+  [ [ int(), noreturn getSelf ] getSize ]; // expected-warning {{left operand of comma operator has no effect}}
 
   // A message send which contains a lambda is OK.
   [ [noreturn] { return noreturn; } () setSize: 4 ];
   [ [bitand] { return noreturn; } () setSize: 5 ];
   [[[[] { return [ X alloc ]; } () init] getSelf] getSize];
 
   // An attribute is OK.
   [[]];

clang/test/Sema/const-eval.c

 void foo(void) {}
 EVAL_EXPR(34, (foo == (void *)0) ? -1 : 1)
 
 // No PR. Mismatched bitwidths lead to a crash on second evaluation.
 const _Bool constbool = 0;
 EVAL_EXPR(35, constbool)
 EVAL_EXPR(36, constbool)
 
-EVAL_EXPR(37, (1,2.0) == 2.0 ? 1 : -1)
+EVAL_EXPR(37, ((void)1,2.0) == 2.0 ? 1 : -1)
 EVAL_EXPR(38, __builtin_expect(1,1) == 1 ? 1 : -1)
 
 // PR7884
 EVAL_EXPR(39, __real__(1.f) == 1 ? 1 : -1)
 EVAL_EXPR(40, __imag__(1.f) == 0 ? 1 : -1)
 
 // From gcc testsuite
 EVAL_EXPR(41, (int)(1+(_Complex unsigned)2))

clang/test/Sema/exprs.c

#define PR8876_pos(err_ptr) do {\
     if (!err_ptr) *(int*)(err_ptr) = 1;\
   } while (0)
 
 
 // Test that we don't report divide-by-zero errors in unreachable code.
 // This test should be left as is, as it also tests CFG functionality.
 void radar9171946() {
   if (0) {
-    0 / (0 ? 1 : 0); // expected-warning {{expression result unused}}
+    0 / (0 ? 1 : 0); // no-warning
   }
 }
 
 int test_pr8876() {
   PR8876(0); // no-warning
   PR8876_pos(0); // expected-warning{{indirection of non-volatile null pointer will be deleted, not trap}} expected-note{{consider using __builtin_trap() or qualifying pointer with 'volatile'}}
   return 0;
 }

clang/test/Sema/i-c-e.c

 
 
 // rdar://4213768
 int expr;
 char y[__builtin_constant_p(expr) ? -1 : 1];
 char z[__builtin_constant_p(4) ? 1 : -1];
 
 // Comma tests
-int comma1[0?1,2:3];
-int comma2[1||(1,2)]; // expected-warning {{use of logical '||' with constant operand}} \
-                      // expected-note {{use '|' for a bitwise operation}}
-int comma3[(1,2)]; // expected-warning {{variable length array folded to constant array as an extension}}
+int comma1[0?1,2:3]; // expected-warning {{left operand of comma operator has no effect}}
+int comma2[1 || (1, 2)]; // expected-warning {{use of logical '||' with constant operand}} \
+                      // expected-note {{use '|' for a bitwise operation}} \
+                      // expected-warning {{left operand of comma operator has no effect}}
+int comma3[(1, 2)];   // expected-warning {{variable length array folded to constant array as an extension}} \
+                      // expected-warning {{left operand of comma operator has no effect}}
 
 // Pointer + __builtin_constant_p
 char pbcp[__builtin_constant_p(4) ? (intptr_t)&expr : 0]; // expected-error {{variable length array declaration not allowed at file scope}}
 
 int illegaldiv1a[1 || 1/0];
 int illegaldiv1b[1 && 1/0];  //expected-error{{variable length array declaration not allowed at file scope}}
 
 int illegaldiv2[1/0]; // expected-error {{variable length array declaration not allowed at file scope}}

clang/test/Sema/sizeless-1.c

void func(int sel) {
   _Static_assert(__atomic_is_lock_free(1, &local_int8) == __atomic_is_lock_free(1, incomplete_ptr), "");
   _Static_assert(__atomic_is_lock_free(2, &local_int8) == __atomic_is_lock_free(2, incomplete_ptr), ""); // expected-error {{static_assert expression is not an integral constant expression}}
   _Static_assert(__atomic_always_lock_free(1, &local_int8) == __atomic_always_lock_free(1, incomplete_ptr), "");
 
   local_int8; // expected-warning {{expression result unused}}
 
   (void)local_int8;
 
-  local_int8, 0; // expected-warning + {{expression result unused}}
+  local_int8, 0; // expected-warning {{left operand of comma operator has no effect}}
 
-  0, local_int8; // expected-warning + {{expression result unused}}
+  0, local_int8; // expected-warning {{left operand of comma operator has no effect}} expected-warning {{expression result unused}}
 
   svint8_t init_int8 = local_int8;
   svint8_t bad_init_int8 = for; // expected-error {{expected expression}}
 
   int empty_brace_init_int = {}; // expected-error {{scalar initializer cannot be empty}}
   svint8_t empty_brace_init_int8 = {}; // expected-error {{initializer for sizeless type 'svint8_t' (aka '__SVInt8_t') cannot be empty}}
   svint8_t brace_init_int8 = {local_int8};
   svint8_t bad_brace_init_int8_1 = {local_int8, 0};    // expected-warning {{excess elements in initializer for indivisible sizeless type 'svint8_t'}}

clang/test/Sema/switch-1.c

#else
     // expected-error@-4 {{case value is not a constant expression}} \
     // expected-note@-4 {{value 8589934588 is outside the range of representable values of type 'int'}}
 #endif
       return 4;
     case 2147483647:
       return 0;
   }
   return (i, 65537) * 65537; // expected-warning {{overflow in expression; result is 131073 with type 'int'}} \
-           // expected-warning {{expression result unused}}
+           // expected-warning {{left operand of comma operator has no effect}}
 }
 
 // rdar://18405357
 unsigned long long l = 65536 * 65536; // expected-warning {{overflow in expression; result is 0 with type 'int'}}
 unsigned long long l2 = 65536 * (unsigned)65536;
 unsigned long long l3 = 65536 * 65536ULL;

clang/test/Sema/vla-2.c

 // RUN: %clang_cc1 %s -verify -fsyntax-only -pedantic
 // Check that we don't crash trying to emit warnings in a potentially-evaluated
 // sizeof or typeof.  (This test needs to be in a separate file because we use
 // a different codepath when we have already emitted an error.)
 
 int PotentiallyEvaluatedSizeofWarn(int n) {
-  return (int)sizeof *(0 << 32,(int(*)[n])0); // expected-warning {{expression result unused}} expected-warning {{shift count >= width of type}}
+  return (int)sizeof *(0 << 32,(int(*)[n])0); // expected-warning {{left operand of comma operator has no effect}} expected-warning {{shift count >= width of type}}
 }
 
 void PotentiallyEvaluatedTypeofWarn(int n) {
-  __typeof(*(0 << 32,(int(*)[n])0)) x; // expected-warning {{expression result unused}} expected-warning {{shift count >= width of type}}
+  __typeof(*(0 << 32,(int(*)[n])0)) x; // expected-warning {{left operand of comma operator has no effect}} expected-warning {{shift count >= width of type}}
   (void)x;
 }
 
 void PotentiallyEvaluatedArrayBoundWarn(int n) {
-  (void)*(int(*)[(0 << 32,n)])0; // FIXME: We should warn here.
+  (void)*(int(*)[(0 << 32,n)])0; // expected-warning {{left operand of comma operator has no effect}}
 }

clang/test/Sema/warn-type-safety.c

void test_argument_with_type_tag(struct flock *f)
 
   fcntl(0, F_SETLK, 10); // expected-warning {{argument type 'int' doesn't match specified 'fcntl' type tag that requires 'struct flock *'}}
   fcntl(0, F_DUPFD, f);  // expected-warning {{argument type 'struct flock *' doesn't match specified 'fcntl' type tag that requires 'int'}}
 }
 
 void test_tag_expresssion(int b) {
   fcntl(0, b ? F_DUPFD : F_SETLK, 10); // no-warning
   fcntl(0, b + F_DUPFD, 10); // no-warning
-  fcntl(0, (b, F_DUPFD), 10); // expected-warning {{expression result unused}}
+  fcntl(0, (b, F_DUPFD), 10); // expected-warning {{left operand of comma operator has no effect}}
 }
 
 // Check that using 64-bit magic values as tags works and tag values do not
 // overflow internally.
 void F_func(void *ptr, unsigned long long tag) __attribute__((pointer_with_type_tag(f,1,2) ));
 
 static const unsigned long long F_tag1 __attribute__(( type_tag_for_datatype(f,int) )) = 0xFFFFFFFFFFFFFFFFULL;
 static const unsigned long long F_tag2 __attribute__(( type_tag_for_datatype(f,float) )) = 0xFFFFFFFFULL;
 
 void test_64bit_magic(int *int_ptr, float *float_ptr)
 {
   F_func(int_ptr,   0xFFFFFFFFFFFFFFFFULL);
   F_func(int_ptr,   0xFFFFFFFFULL);         // expected-warning {{argument type 'int *' doesn't match specified 'f' type tag that requires 'float *'}}
   F_func(float_ptr, 0xFFFFFFFFFFFFFFFFULL); // expected-warning {{argument type 'float *' doesn't match specified 'f' type tag that requires 'int *'}}
   F_func(float_ptr, 0xFFFFFFFFULL);
 }

clang/test/Sema/warn-unused-value.c

 // RUN: %clang_cc1 -std=c11 -fsyntax-only -verify -Wunused-value -Wunused-label %s
 // RUN: %clang_cc1 -std=c11 -fsyntax-only -verify -Wunused %s
 // RUN: %clang_cc1 -std=c11 -fsyntax-only -verify -Wall %s
 
 int i = 0;
 int j = 0;
 
 void foo();
 
 // PR4806
 void pr4806() {
-  1,foo();          // expected-warning {{expression result unused}}
+  1,foo();          // expected-warning {{left operand of comma operator has no effect}}
 
   // other
   foo();
   i;                // expected-warning {{expression result unused}}
 
-  i,foo();          // expected-warning {{expression result unused}}
+  i,foo();          // expected-warning {{left operand of comma operator has no effect}}
   foo(),i;          // expected-warning {{expression result unused}}
 
-  i,j,foo();        // expected-warning {{expression result unused}} expected-warning {{expression result unused}}
-  i,foo(),j;        // expected-warning {{expression result unused}} expected-warning {{expression result unused}}
-  foo(),i,j;        // expected-warning {{expression result unused}} expected-warning {{expression result unused}}
+  i,j,foo();        // expected-warning 2{{left operand of comma operator has no effect}}
+  i,foo(),j;        // expected-warning {{left operand of comma operator has no effect}} expected-warning {{expression result unused}}
+  foo(),i,j;        // expected-warning {{expression result unused}} expected-warning {{left operand of comma operator has no effect}}
 
   i++;
 
   i++,foo();
   foo(),i++;
 
-  i++,j,foo();      // expected-warning {{expression result unused}}
+  i++,j,foo();      // expected-warning {{left operand of comma operator has no effect}}
   i++,foo(),j;      // expected-warning {{expression result unused}}
   foo(),i++,j;      // expected-warning {{expression result unused}}
 
-  i,j++,foo();      // expected-warning {{expression result unused}}
-  i,foo(),j++;      // expected-warning {{expression result unused}}
-  foo(),i,j++;      // expected-warning {{expression result unused}}
+  i,j++,foo();      // expected-warning {{left operand of comma operator has no effect}}
+  i,foo(),j++;      // expected-warning {{left operand of comma operator has no effect}}
+  foo(),i,j++;      // expected-warning {{left operand of comma operator has no effect}}
 
   i++,j++,foo();
   i++,foo(),j++;
   foo(),i++,j++;
 
   {};
   ({});
   ({}),foo();
void conditional_for_control_flow(int cond, int x, int y)
     cond? y : x; // expected-warning {{expression result unused}}
 }
 
 struct s0 { int f0; };
 
 void f0(int a);
 void f1(struct s0 *a) {
   // rdar://8139785
-  f0((int)(a->f0 + 1, 10)); // expected-warning {{expression result unused}}
+  f0((int)(a->f0 + 1, 10)); // expected-warning {{left operand of comma operator has no effect}}
 }
 
 void blah(int a);
 #define GenTest(x) _Generic(x, default : blah)(x)
 
 void unevaluated_operands(void) {
   int val = 0;
 

clang/test/SemaCXX/attr-annotate.cpp

namespace test0 {
   A<int, 9> a;
 // expected-note@-1 {{in instantiation of template class}}
   A<long, 7> a1;
 // expected-note@-1 {{in instantiation of template class}}
   A<unsigned long, 6> a2;
 
   template<typename T>
   struct B {
-    [[clang::annotate("test", (T{}, 9))]] void t() {}
+    [[clang::annotate("test", ((void)T{}, 9))]] void t() {}
     // expected-error@-1 {{illegal initializer type 'void'}}
   };
   B<int> b;
   B<void> b1;
 // expected-note@-1 {{in instantiation of template class}}
 }
 
 namespace test1 {
struct foo {
     // expected-note@-2 {{is not allowed in a constant expression}}
     [[clang::annotate("qdwqwd", cf, cb)]] void t() {}
     [[clang::annotate("qdwqwd", f, cb)]] void t1() {}
     // expected-error@-1 {{'annotate' attribute requires parameter 1 to be a constant expression}}
     // expected-note@-2 {{is not allowed in a constant expression}}
     [[clang::annotate("jui", b, cf)]] void t2() {}
     // expected-error@-1 {{'annotate' attribute requires parameter 1 to be a constant expression}}
     // expected-note@-2 {{is not allowed in a constant expression}}
-    [[clang::annotate("jui", (b, 0), cf)]] [[clang::annotate("jui", &b, cf, &foo::t2, str())]] void t3() {}
+    [[clang::annotate("jui", ((void)b, 0), cf)]] [[clang::annotate("jui", &b, cf, &foo::t2, str())]] void t3() {}
   };
 };
 
 static B<int long, -1>::foo<unsigned, 9> gf; // expected-note {{in instantiation of}}
 static B<int long, -2> gf1;
 
 } // namespace test1
 

clang/test/SemaCXX/builtin-constant-p.cpp

 
 #if __cplusplus >= 202002L
 namespace constexpr_dtor {
   struct A {
     int *p;
     constexpr ~A() { *p = 0; }
   };
   struct Q { int n; constexpr int *get() { return &n; } };
-  static_assert(!__builtin_constant_p((A{}, 123)));
+  static_assert(!__builtin_constant_p(((void)A{}, 123)));
   // FIXME: We should probably accept this. GCC does.
   // However, GCC appears to do so by running the destructors at the end of the
   // enclosing full-expression, which seems broken; running them at the end of
   // the evaluation of the __builtin_constant_p argument would be more
   // defensible.
-  static_assert(!__builtin_constant_p((A{Q().get()}, 123)));
+  static_assert(!__builtin_constant_p(((void)A{Q().get()}, 123)));
 }
 #endif

clang/test/SemaCXX/constant-expression-cxx2a.cpp

constexpr bool run_dtors_on_array_filler() {
     S s[3];
     return true;
   }
   static_assert(run_dtors_on_array_filler());
 
   // Ensure that we can handle temporary cleanups for array temporaries.
   struct ArrElem { constexpr ~ArrElem() {} };
   using Arr = ArrElem[3];
-  static_assert((Arr{}, true));
+  static_assert(((void)Arr{}, true));
 }
 
 namespace dynamic_alloc {
   constexpr int *p = // expected-error {{constant}} expected-note {{pointer to heap-allocated object is not a constant expression}}
     new int; // expected-note {{heap allocation performed here}}
 
   constexpr int f(int n) {
     int *p = new int[n];

clang/test/SemaCXX/constant-expression.cpp

 
 enum {
   a = sizeof(int) == 8,
   b = a? 8 : 4
 };
 
 void diags(int n) {
   switch (n) {
-    case (1/0, 1): // expected-error {{not an integral constant expression}} expected-note {{division by zero}}
-    case (int)(1/0, 2.0): // expected-error {{not an integral constant expression}} expected-note {{division by zero}}
+    case (1/0, 1): // expected-error {{not an integral constant expression}} expected-note {{division by zero}} expected-warning {{left operand of comma operator has no effect}}
+    case (int)(1/0, 2.0): // expected-error {{not an integral constant expression}} expected-note {{division by zero}} expected-warning {{left operand of comma operator has no effect}}
     case __imag(1/0): // expected-error {{not an integral constant expression}} expected-note {{division by zero}}
     case (int)__imag((double)(1/0)): // expected-error {{not an integral constant expression}} expected-note {{division by zero}}
       ;
   }
 }
 
 namespace IntOrEnum {
   const int k = 0;

clang/test/SemaCXX/expression-traits.cpp

 void expr_comma(int x)
 {
     // expr.comma: A pair of expressions separated by a comma is
     // evaluated left-to-right and the value of the left expression is
     // discarded... result is an lvalue if its right operand is.
 
     // Can't use the ASSERT_XXXX macros without adding parens around
     // the comma expression.
-    static_assert(__is_lvalue_expr(x,x), "expected an lvalue");
-    static_assert(__is_rvalue_expr(x,1), "expected an rvalue");
-    static_assert(__is_lvalue_expr(1,x), "expected an lvalue");
-    static_assert(__is_rvalue_expr(1,1), "expected an rvalue");
+    static_assert(__is_lvalue_expr((void)x,x), "expected an lvalue");
+    static_assert(__is_rvalue_expr((void)x,1), "expected an rvalue");
+    static_assert(__is_lvalue_expr((void)1,x), "expected an lvalue");
+    static_assert(__is_rvalue_expr((void)1,1), "expected an rvalue");
 }
 
 #if 0
 template<typename T> void f();
 
 // FIXME These currently fail
 void expr_fun_lvalue()
 {

clang/test/SemaCXX/matrix-type-operators.cpp

void insert(sx5x10_t a, float f) {
   get_matrix()[3] = 5.0;
   // expected-error@-1 {{single subscript expressions are not allowed for matrix values}}
 
   float &x = reinterpret_cast<float &>(a[3][3]);
   // expected-error@-1 {{reinterpret_cast of a matrix element to 'float &' needs its address, which is not allowed}}
 
   a[4, 5] = 5.0;
   // expected-error@-1 {{comma expressions are not allowed as indices in matrix subscript expressions}}
-  // expected-warning@-2 {{expression result unused}}
+  // expected-warning@-2 {{left operand of comma operator has no effect}}
 
   a[4, 5, 4] = 5.0;
   // expected-error@-1 {{comma expressions are not allowed as indices in matrix subscript expressions}}
-  // expected-warning@-2 {{expression result unused}}
-  // expected-warning@-3 {{expression result unused}}
+  // expected-warning@-2 {{left operand of comma operator has no effect}}
+  // expected-warning@-3 {{left operand of comma operator has no effect}}
 }
 
 void extract(sx5x10_t a, float f) {
   // Non integer indexes.
   float v1 = a[3][f];
   // expected-error@-1 {{matrix column index is not an integer}}
   float v2 = a[f][9];
   // expected-error@-1 {{matrix row index is not an integer}}

clang/test/SemaCXX/overloaded-operator.cpp

 void test_smartref(SmartRef r) {
   int* ip = &r;
 }
 
 bool& operator,(X, Y);
 
 void test_comma(X x, Y y) {
   bool& b1 = (x, y);
-  X& xr = (x, x); // expected-warning {{expression result unused}}
+  X& xr = (x, x); // expected-warning {{left operand of comma operator has no effect}}
 }
 
 struct Callable {
   int& operator()(int, double = 2.71828); // expected-note{{candidate function}}
   float& operator()(int, double, long, ...); // expected-note{{candidate function}}
 
   double& operator()(float); // expected-note{{candidate function}}
 };

clang/test/SemaCXX/sizeless-1.cpp

void func(int sel) {
   _Static_assert(__atomic_is_lock_free(1, &local_int8) == __atomic_is_lock_free(1, incomplete_ptr), "");
   _Static_assert(__atomic_is_lock_free(2, &local_int8) == __atomic_is_lock_free(2, incomplete_ptr), ""); // expected-error {{static_assert expression is not an integral constant expression}}
   _Static_assert(__atomic_always_lock_free(1, &local_int8) == __atomic_always_lock_free(1, incomplete_ptr), "");
 
   local_int8; // expected-warning {{expression result unused}}
 
   (void)local_int8;
 
-  local_int8, 0; // expected-warning + {{expression result unused}}
+  local_int8, 0; // expected-warning {{left operand of comma operator has no effect}}
 
-  0, local_int8; // expected-warning + {{expression result unused}}
+  0, local_int8; // expected-warning {{left operand of comma operator has no effect}} expected-warning {{expression result unused}}
 
   svint8_t init_int8 = local_int8;
   svint8_t bad_init_int8 = for; // expected-error {{expected expression}}
 
 #if __cplusplus >= 201103L
   int empty_brace_init_int = {};
   svint8_t empty_brace_init_int8 = {};
 #else

clang/test/SemaCXX/vector.cpp

void Init() {
   const PR15730<8, char>::type2 PR15730_2 = {};
 }
 
 } // namespace Templates
 
 typedef int inte2 __attribute__((__ext_vector_type__(2)));
 
 void test_vector_literal(inte4 res) {
-  inte2 a = (inte2)(1, 2); //expected-warning{{expression result unused}}
-  inte4 b = (inte4)(a, a); //expected-error{{C-style cast from vector 'inte2' (vector of 2 'int' values) to vector 'inte4' (vector of 4 'int' values) of different size}} //expected-warning{{expression result unused}}
+  inte2 a = (inte2)(1, 2); //expected-warning{{left operand of comma operator has no effect}}
+  inte4 b = (inte4)(a, a); //expected-error{{C-style cast from vector 'inte2' (vector of 2 'int' values) to vector 'inte4' (vector of 4 'int' values) of different size}} //expected-warning{{left operand of comma operator has no effect}}
 }
 
 typedef __attribute__((__ext_vector_type__(4))) float vector_float4;
 typedef __attribute__((__ext_vector_type__(4))) int vector_int4;
 
 namespace swizzle_template_confusion {
   template<typename T> struct xyzw {};
   vector_int4 foo123(vector_float4 &A, vector_float4 &B) {

clang/test/SemaCXX/warn-comma-operator.cpp

 typedef B<true> true_type;
 typedef B<false> false_type;
 
 template <bool...>
 struct bool_seq;
 
 template <typename... xs>
 class Foo {
-  typedef bool_seq<(xs::value, true)...> all_true;
-  typedef bool_seq<(xs::value, false)...> all_false;
+  typedef bool_seq<((void)xs::value, true)...> all_true;
+  typedef bool_seq<((void)xs::value, false)...> all_false;
   typedef bool_seq<xs::value...> seq;
 };
 
 const auto X = Foo<true_type>();
 }
 
 namespace test_mutex {
 class Mutex {

clang/test/SemaCXX/warn-unused-value.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -Wunused-value %s
 // RUN: %clang_cc1 -fsyntax-only -verify -Wunused-value -std=c++98 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -Wunused-value -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -Wunused-value -std=c++17 %s
 
 // PR4806
 namespace test0 {
   class Box {
   public:
     int i;
     volatile int j;
   };
#endif
   // None of these result in volatile loads in any language mode, and it's not
   // really reasonable to assume that they would, since volatile array loads
   // don't really exist anywhere.
   (void)arr1;
   (void)arr2;
   (void)arr3;
   (void)arr4;
 }
+
+#if __cplusplus >= 201103L // C++11 or later
+namespace test5 {
+int v[(5, 6)]; // expected-warning {{left operand of comma operator has no effect}}
+void foo() {
+  new double[false ? (1, 2) : 3]
+            // FIXME: We shouldn't diagnose the unreachable constant expression
+            // here.
+            [false ? (1, 2) : 3]; // expected-warning {{left operand of comma operator has no effect}}
+}
+} // namespace test5
+#endif
+
+#if __cplusplus >= 201703L // C++17 or later
+namespace test6 {
+auto b() {
+  if constexpr (false)
+    return (1,0);
+  else
+    return (1.0,0.0); // expected-warning {{left operand of comma operator has no effect}}
+}
+} // namespace test6
+#endif

clang/test/SemaTemplate/derived.cpp

class Typ { // expected-note {{not complete}}
     Typ x; // expected-error {{incomplete type}}
   };
 
   template <unsigned  C> class B :  Typ {};
   typedef B<0> TFP;
 
   class A {
     TFP m_p;
-    void Enable() { 0, A(); } // expected-warning {{unused}}
+    void Enable() { 0, A(); } // expected-warning {{left operand of comma operator has no effect}}
   };
 }

clang/test/SemaTemplate/lambda-capture-pack.cpp

template<typename ...T> void f(T ...v) {
   static_assert(sizeof(l) >= (sizeof(T) + ...));
 }
 
 template void f(int, char, double);
 
 namespace PR41576 {
   template <class... Xs> constexpr int f(Xs ...xs) {
     return [&](auto ...ys) { // expected-note {{instantiation}}
-      return ((xs + ys), ...); // expected-warning {{unused}}
+      return ((xs + ys), ...); // expected-warning {{left operand of comma operator has no effect}}
     }(1, 2);
   }
   static_assert(f(3, 4) == 6); // expected-note {{instantiation}}
 }