[clang] AST: fix getAs canonicalization of leaf types

[mizvekov]

Before this patch, the application of getAs and castAs on a leaf type would always produce a canonical type, which is undesirable because some of these types can be sugared.

The user expectation is that getAs only removes top level sugar nodes, leaving all the type sugar on the returned node, but it had an optimization intended for type nodes with no sugar: for these, we can skip the expensive traversal of the top level sugar with a simple canonicalization followed by dyn_cast.

The problem is that the concept of leaf type does not map well to what is correct to apply this optimization to.

This patch replaces the concept of leaf types with 'always canonical' types, and only applies the canonicalization strategy on them.

In order to avoid the performance regression this would cause, as most current users do not care about type sugar, this patch also replaces all of these uses with alternative cast functions which operate through canonicalization.

• Introduces castAs variants to complement the getAsTagDecl and derived variants.
• Introduces getAsEnumDecl and castAsEnumDecl, complementing the current set, so that all TagDecls are covered.
• Introduces getAsCanonical and castAsCanonical, for faster casting when only the canonical type is desired.

The getAsTagDecl and related functions are not provided inline, because of the circular dependencies that would involve. So this patch causes a small overall performance regression:

This will be fixed in a later patch, bringing the whole thing back to a positive performance improvement overall:

These follow-up patches are:

• [clang] NFC: rename clang/include/clang/AST/Type.h to TypeBase.h #155049
• [clang] NFC: reintroduce clang/include/clang/AST/Type.h #155050
• [clang] NFC: Provide inline definitions for {get,cast}TagDecl and friends #155051

[erichkeane]

"Meat and Potatoes" patch looks fine to me. Rest of it is too large to look at beyond scrolling through. Would be nice to have a few other +1s on this, just because of the size.

[mizvekov]

@rjmccall done, I have offloaded all of the changes this PR did which didn't need the introduction of a new helper.

That halved the size of the patch.

The "meat and potatoes" commit still contains the important changes.

[mizvekov]

I did another offloading of NFC changes to another patch.

This PR is tiny now in comparison.

[rjmccall]

LGTM

[jyknight]

Heads up, this is breaking modules support in our buildsystem. I'm getting errors now like this:

libcxx/include/__atomic/memory_order.h:31:27: error: missing '#include <__atomic/memory_order.h>'; '__memory_order_underlying_t' must be declared before it is used
   31 | enum class memory_order : __memory_order_underlying_t {
      |                           ^
libcxx/include/__atomic/memory_order.h:27:7: note: declaration here is not visible
   27 | using __memory_order_underlying_t _LIBCPP_NODEBUG = __underlying_type_t<__legacy_memory_order>;

Note that the "not visible" decl is declared literally 4 lines before the usage.

I don't know how to repro this upstream (and, I'd note, we aren't using the upstream modulemap file). My suspicion is that this commit has broken module decl-merging, where multiple copies of the same header are imported.

I'll attempt to make a minimal example...

[jyknight]

Minimized test-case:

cat > test.h <<EOF
#ifndef TEST_H_
#define TEST_H_
template <class _Tp>
using __underlying_type_t = __underlying_type(_Tp);
enum __legacy_memory_order { __mo_relaxed };
using __memory_order_underlying_t = __underlying_type_t<__legacy_memory_order>;
enum class memory_order : __memory_order_underlying_t { relaxed = __mo_relaxed };
#endif
EOF

cat > test1.h <<EOF
#ifndef TEST1_H_
#define TEST1_H_
#include "test.h"
#endif
EOF

cat > test2.h <<EOF
#ifndef TEST2_H_
#define TEST2_H_
#include "test.h"
#endif
EOF

cat > test.cppmap <<EOF
module "test_module" {
  export *
  module "test1.h" {
    export *
    header "test1.h"
  }
  module "test2.h" {
    export *
    header "test2.h"
  }
  textual header "test.h"
}
EOF

$CLANG -xc++ -std=gnu++20 -fmodule-name=test_module -fmodule-map-file=test.cppmap -Xclang=-emit-module -fmodules -fno-implicit-modules -fno-implicit-module-maps -c test.cppmap -o /dev/null

With a debug build of Clang, this actually results in an assert fail

clang: clang/lib/Sema/SemaType.cpp:9881: QualType GetEnumUnderlyingType(Sema &, QualType, SourceLocation): Assertion `!Underlying.isNull()' failed.

[mizvekov]

@jyknight thanks, this will be fixed here: #155900