Compiler flag '-Warray-compare' not implemented

[stephenLucien]

clangd version

[li@ArchLinux-li cpp]$ clangd --version
clangd version 18.1.8
Features: linux
Platform: x86_64-pc-linux-gnu
[li@ArchLinux-li cpp]$ clang-tidy --version
LLVM (http://llvm.org/):
  LLVM version 18.1.8
  Optimized build.

my .clangd file:

Diagnostics:
    ClangTidy:
        Remove: 
            - modernize-use-trailing-return-type
            - modernize-use-nullptr
            - modernize-use-using
            - modernize-use-bool-literals
            - modernize-use-equals-default
            - modernize-avoid-c-arrays
            - modernize-redundant-void-arg
            - modernize-deprecated-headers
            - bugprone-easily-swappable-parameters
        Add: 
            - modernize*
            - bugprone-* 
            - performance-*
CompileFlags:
    Add: 
        - "-ferror-limit=0"
        - "-fdelete-null-pointer-checks"
        - "-Wall"
        - "-Wextra"
        - "-Wpedantic"
        - "-Wformat=2"
        - "-Wnull-dereference"
        - "-Wpointer-compare"
        - "-Wstring-compare"
        - "-Warray-compare"
        - "-Wno-unused-but-set-variable"
        - "-Wno-unused-but-set-parameter"
        - "-Wno-unused-variable"
        - "-Wno-unused-parameter"
        - "-Wno-unused-label"
        - "-Wno-unused-function"
        

my test code main.cpp:

#include <iostream>

typedef struct {
  char str[16];
  int id[16];
} MyObj;

bool myobj_equal(const MyObj &obj1, const MyObj &obj2) {
  if (obj1.str != obj2.str) // compare array here, expect warning !!!
    return false;
  if (obj1.id != obj2.id) // compare array here, expect warning !!!
    return false;
  return true;
}

int main(int argc, char *argv[]) {
  //
  char str1[16] = "hello";
  char str2[16] = "hello";
  if (str1 == str2) {
    std::cout << "same string";
  }
  //
  MyObj a1 = {.str = "hello"};
  MyObj a2 = {.str = "hello"};
  if (myobj_equal(a1, a2)) {
    std::cout << "same obj";
  }
  return 0;
}

only the following warnings pops up:

[AaronBallman]

Clang doesn't implement -Warray-compare, which is why you're seeing this: https://godbolt.org/z/dMPs5oE8s

I've changed the issue to be a feature request instead.

[AmrDeveloper]

If it is approved and has priority, I will be interested in implementing it :D

[AaronBallman]

If it is approved and has priority, I will be interested in implementing it :D

We'd love to see an implementation for it; I'll assign this to you.

[AmrDeveloper]

If it is approved and has priority, I will be interested in implementing it :D

We'd love to see an implementation for it; I'll assign this to you.

Thank you

[AmrDeveloper]

I found that Clang already has a flag that produce the same warning like GCC but it for some reason named with prefix deprecated -Wdeprecated-array-compare it's works only for C++20 or above

llvm-project/clang/lib/Sema/SemaExpr.cpp

Lines 11854 to 11865 in 9ba6672

	// C++2a [depr.array.comp]:
	// Equality and relational comparisons ([expr.eq], [expr.rel]) between two
	// operands of array type are deprecated.
	if (S.getLangOpts().CPlusPlus20 && LHSStripped->getType()->isArrayType() &&
	RHSStripped->getType()->isArrayType()) {
	S.Diag(Loc, diag::warn_depr_array_comparison)
	<< LHS->getSourceRange() << RHS->getSourceRange()
	<< LHSStripped->getType() << RHSStripped->getType();
	// Carry on to produce the tautological comparison warning, if this
	// expression is potentially-evaluated, we can resolve the array to a
	// non-weak declaration, and so on.
	}

https://godbolt.org/z/YT1GKEYor

typedef struct {
  char str[16];
  int id[16];
} MyObj;

bool myobj_equal(const MyObj &obj1, const MyObj &obj2) {
  if (obj1.str != obj2.str) // compare array here, expect warning !!!
    return false;
  if (obj1.id != obj2.id) // compare array here, expect warning !!!
    return false;
  return true;
}

I don't know why it's deprecated and supports only C++20 or above, also it's enabled by default for C++ 20 or above 🤔.

@AaronBallman

Edit: I think the prefix deprecated is because the comparison of arrays is deprecated from C++20

The comparison is deprecated if both lhs and rhs have array type prior to the application of these conversions.(since C++20)

https://en.cppreference.com/w/cpp/language/operator_comparison

Should we produce warning for older C++ versions (Below 20)?

[AmrDeveloper]

What GCC does is produce a warning for all versions, but for C++20 or above it mentions that this comparison is deprecated, i think we can implement the same in Clang @AaronBallman.

-Wall -std=c++23

warning: comparison between two arrays is deprecated in C++20 [-Warray-compare]

-Wall

warning: comparison between two arrays [-Warray-compare]

[AaronBallman]

Ah! Good investigation! Yes, I think we should do the same in Clang, but we have to figure out what to do about the warning group name.

Clang adds this under -Wdeprecated because it's a deprecation warning, GCC does not: https://godbolt.org/z/7E1W5d79M I prefer Clang's behavior in this case.

We could add -Warray-compare as an alias to -Wdeprecated-array-compare for compatibility with GCC, but should that spelling also be under -Wdeprecated?

Tagging @erichkeane @MaskRay @jansvoboda11 for additional opinions