davrec added a comment.
If I understand this correctly: whenever isDivergent() is true, `getDecl()` or
`getFoundDecl()` is an arbitrary choice between multiple candidate
(re)declarations of a typedef or using decl. In particular it will be the
first redeclaration, //even though each different redeclaration can contain
different sugar information//.
E.g. considering your examples:
using X1 = int;
using Y1 = int;
using RPB1 = X1*;
using RPX1 = RPB1;
using RPB1 = Y1*; // redeclared
using RPY1 = RPB1;
namespace A { using type1 = X1*; };
namespace C { using A::type1; };
using UPX1 = C::type1;
namespace A { using type1 = Y1*; }; // redeclared
namespace C { using A::type1; }; // redeclared
using UPY1 = C::type1;
So far so good: isDivergent() would be false for all the above TypedefTypes and
UsingTypes, since the UnderlyingTypes and Decls/FoundDecls are consistent. But
these types are a different matter:
auto t29 = 0 ? (RPX1){} : (RPY1){};
auto t32 = 0 ? (UPX1){} : (UPY1){};
In the process of unifying the sugar to get the deduced type of t29/t32, we
will compare their sugar, which has the same basic structure for each, but
different decls/found decls; so unifying these types will simply involve
unifying their decls; and getCommonDecl(X,Y) has been defined to will simply
get the older declaration between them. So, the TypedefType/UsingType sugar in
t29/t32 will reference the X1 decls and friends, *not* the Y1s, as its
Decls/FoundDecls. (Right?)
The UnderlyingType however will not be as arbitrary, as it will use
getCommonType to skip over everything the two don't have in common.
If I have this right, my question is: since the Decl/FoundDecl is an arbitrary
choice, should we solve this by either
1. constructing these with a null Decl/FoundDecl for such types, or if that is
problematic,
2. renaming `isDivergent` to `declIsArbitrary()` or something like that, to
suggest that not only do the underlying type and decl diverge, it is the
underlying type which is more meaningful, not the decl.
================
Comment at: clang/include/clang/AST/Type.h:4490
UsingShadowDecl *getFoundDecl() const { return Found; }
+ bool isDivergent() const { return UsingBits.isDivergent; }
QualType getUnderlyingType() const;
----------------
The name of this might be less important than just documenting it extremely
well here, with an example.
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D133468/new/
https://reviews.llvm.org/D133468
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
