@davidbolvansky

No, compilers don't have to diagnose it, it is not required by C/C++ standard.

And that is one of the reason for flex not to adopt __attribute__((fallthrough)) for now. Like I said in the first comment, it would be better to wait for clang to support the /* fallthrough */ comment, than to change flex code just to workaround that problem specific to clang (and it's only the development versions of clang).

FWIW, we have recently reconfirmed our decision not to support comments as a mechanism to suppress diagnostics in Clang. Also, I think it's incorrect to claim this is a problem specific to Clang (see below).

@davidbolvansky __attribute__ is a gcc-invented syntax. Although gcc is popular and almost the default C/C++ compiler in Linux systems, it's not a technically "universal" syntax. Did you test on Microsoft's Visual C++ compilers or Intel C compilers? Those are most unlikely to support GNU C syntaxes, at least not until recently. By the way, you should not take clang's support for GNU syntaxes for granted, and that's why I disagree with your claim that __attribute__ is universal enough.

[[]] is a standardized syntax in both C++ (since C++11) and C (starting in C2x). __attribute__ is not standardized, but it is supported by GCC, Clang, ICC, ICX, TCC, cproc, as well as other compilers. It's not ubiquitous, but it's also not uncommon to support.

Specific to the compilers you asked about: ICC supports many GNU extensions, as does ICX, including __attribute__((fallthrough)), but ICC does not have a flag to diagnose implicit fallthrough despite supporting the attribute. MSVC also doesn't diagnose implicit fallthrough except as part of their C++ Core Guideline static analysis checks, which comments do not suppress (at least no comments I've found will do it).

IMO, comments are the least portable way to silence this diagnostic (out of the list of compilers you've asked about, only GCC supports that). The most portable way is to use the utilities compilers have provided to query for support and then fall back to comments as a last resort. Something along these lines works significantly better than hoping comments are parsed for semantic effects:

// Boilerplate for compiler compatibility.
#ifndef __has_cpp_attribute
#define __has_cpp_attribute(x) 0
#endif

#ifndef __has_c_attribute
#define __has_c_attribute(x) 0
#endif

#ifndef __has_attribute
#define __has_attribute(x) 0
#endif

// Actually interesting bit to define the FALLTHROUGH macro.
#if __has_cpp_attribute(fallthrough) || __has_c_attribute(fallthrough)
#define FALLTHROUGH [[fallthrough]]
#elif __has_attribute(fallthrough)
#define FALLTHROUGH __attribute__((fallthrough))
// Note, there could be more branches here, like using `[[gsl::suppress]]` for MSVC, or
// other vendor-specific attributes/spellings. This list is not intended to be exhaustive.
#else
#define FALLTHROUGH
#endif

// Silly example code
void func(int something) {
  extern void foo(void), bar(void);
  switch (something) {
  default: break;
  case 0:
    foo();
    // Note the use of the comment -- that's a good fallback for the compilers that you can't
    // write a FALLTHROUGH macro for but still parse comments for diagnostic suppression.
    FALLTHROUGH; /* fallthrough */
  case 12:
    bar();
    break;
  }
}

You might want to reopen this issue to reconsider your stance on this. GCC added implicit fallthrough warnings to -Wextra. Clang has not yet done so, but we have had requests to do it and I can imagine a future where that happens. (I would be very surprised if either GCC or Clang enabled implicit fallthrough warnings by default though.)

Flex should use '__attribute__((fallthrough))' instead of /*FALLTHROUGH*/ #427

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions

Flex should use 'attribute((fallthrough))' instead of /FALLTHROUGH/ #427