clang 19.0.0git
ComparisonCategories.cpp
Go to the documentation of this file.
1//===- ComparisonCategories.cpp - Three Way Comparison Data -----*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file defines the Comparison Category enum and data types, which
10// store the types and expressions needed to support operator<=>
11//
12//===----------------------------------------------------------------------===//
13
16#include "clang/AST/Decl.h"
17#include "clang/AST/DeclCXX.h"
18#include "clang/AST/Type.h"
19#include "llvm/ADT/SmallVector.h"
20#include <optional>
21
22using namespace clang;
23
24std::optional<ComparisonCategoryType>
26 using CCT = ComparisonCategoryType;
27
29 return CCT::StrongOrdering;
30
31 if (T->isRealFloatingType())
32 return CCT::PartialOrdering;
33
34 // C++2a [expr.spaceship]p8: If the composite pointer type is an object
35 // pointer type, p <=> q is of type std::strong_ordering.
36 // Note: this assumes neither operand is a null pointer constant.
38 return CCT::StrongOrdering;
39
40 // TODO: Extend support for operator<=> to ObjC types.
41 return std::nullopt;
42}
43
45 assert(VD && "must have var decl");
47 return false;
48
49 // Before we attempt to get the value of the first field, ensure that we
50 // actually have one (and only one) field.
51 const auto *Record = VD->getType()->getAsCXXRecordDecl();
52 if (std::distance(Record->field_begin(), Record->field_end()) != 1 ||
53 !Record->field_begin()->getType()->isIntegralOrEnumerationType())
54 return false;
55
56 return true;
57}
58
59/// Attempt to determine the integer value used to represent the comparison
60/// category result by evaluating the initializer for the specified VarDecl as
61/// a constant expression and retrieving the value of the class's first
62/// (and only) field.
63///
64/// Note: The STL types are expected to have the form:
65/// struct X { T value; };
66/// where T is an integral or enumeration type.
68 assert(hasValidIntValue() && "must have a valid value");
69 return VD->evaluateValue()->getStructField(0).getInt();
70}
71
72ComparisonCategoryInfo::ValueInfo *ComparisonCategoryInfo::lookupValueInfo(
73 ComparisonCategoryResult ValueKind) const {
74 // Check if we already have a cache entry for this value.
75 auto It = llvm::find_if(
76 Objects, [&](ValueInfo const &Info) { return Info.Kind == ValueKind; });
77 if (It != Objects.end())
78 return &(*It);
79
80 // We don't have a cached result. Lookup the variable declaration and create
81 // a new entry representing it.
82 DeclContextLookupResult Lookup = Record->getCanonicalDecl()->lookup(
84 if (Lookup.empty() || !isa<VarDecl>(Lookup.front()))
85 return nullptr;
86 Objects.emplace_back(ValueKind, cast<VarDecl>(Lookup.front()));
87 return &Objects.back();
88}
89
91 NamespaceDecl *&StdNS) {
92 if (!StdNS) {
94 Ctx.getTranslationUnitDecl()->lookup(&Ctx.Idents.get("std"));
95 if (!Lookup.empty())
96 StdNS = dyn_cast<NamespaceDecl>(Lookup.front());
97 }
98 return StdNS;
99}
100
102 const NamespaceDecl *StdNS,
105 DeclContextLookupResult Lookup = StdNS->lookup(&Ctx.Idents.get(Name));
106 if (!Lookup.empty())
107 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Lookup.front()))
108 return RD;
109 return nullptr;
110}
111
114 auto It = Data.find(static_cast<char>(Kind));
115 if (It != Data.end())
116 return &It->second;
117
118 if (const NamespaceDecl *NS = lookupStdNamespace(Ctx, StdNS))
119 if (const CXXRecordDecl *RD = lookupCXXRecordDecl(Ctx, NS, Kind))
120 return &Data.try_emplace((char)Kind, Ctx, RD, Kind).first->second;
121
122 return nullptr;
123}
124
127 assert(!Ty.isNull() && "type must be non-null");
128 using CCT = ComparisonCategoryType;
129 const auto *RD = Ty->getAsCXXRecordDecl();
130 if (!RD)
131 return nullptr;
132
133 // Check to see if we have information for the specified type cached.
134 const auto *CanonRD = RD->getCanonicalDecl();
135 for (const auto &KV : Data) {
136 const ComparisonCategoryInfo &Info = KV.second;
137 if (CanonRD == Info.Record->getCanonicalDecl())
138 return &Info;
139 }
140
141 if (!RD->getEnclosingNamespaceContext()->isStdNamespace())
142 return nullptr;
143
144 // If not, check to see if the decl names a type in namespace std with a name
145 // matching one of the comparison category types.
146 for (unsigned I = static_cast<unsigned>(CCT::First),
147 End = static_cast<unsigned>(CCT::Last);
148 I <= End; ++I) {
149 CCT Kind = static_cast<CCT>(I);
150
151 // We've found the comparison category type. Build a new cache entry for
152 // it.
153 if (getCategoryString(Kind) == RD->getName())
154 return &Data.try_emplace((char)Kind, Ctx, RD, Kind).first->second;
155 }
156
157 // We've found nothing. This isn't a comparison category type.
158 return nullptr;
159}
160
162 const ComparisonCategoryInfo *Info = lookupInfoForType(Ty);
163 assert(Info && "info for comparison category not found");
164 return *Info;
165}
166
168 assert(Record);
169 return QualType(Record->getTypeForDecl(), 0);
170}
171
173 using CCKT = ComparisonCategoryType;
174 switch (Kind) {
175 case CCKT::PartialOrdering:
176 return "partial_ordering";
177 case CCKT::WeakOrdering:
178 return "weak_ordering";
179 case CCKT::StrongOrdering:
180 return "strong_ordering";
181 }
182 llvm_unreachable("unhandled cases in switch");
183}
184
186 using CCVT = ComparisonCategoryResult;
187 switch (Kind) {
188 case CCVT::Equal:
189 return "equal";
190 case CCVT::Equivalent:
191 return "equivalent";
192 case CCVT::Less:
193 return "less";
194 case CCVT::Greater:
195 return "greater";
196 case CCVT::Unordered:
197 return "unordered";
198 }
199 llvm_unreachable("unhandled case in switch");
200}
201
202std::vector<ComparisonCategoryResult>
204 using CCT = ComparisonCategoryType;
205 using CCR = ComparisonCategoryResult;
206 std::vector<CCR> Values;
207 Values.reserve(4);
208 bool IsStrong = Type == CCT::StrongOrdering;
209 Values.push_back(IsStrong ? CCR::Equal : CCR::Equivalent);
210 Values.push_back(CCR::Less);
211 Values.push_back(CCR::Greater);
212 if (Type == CCT::PartialOrdering)
213 Values.push_back(CCR::Unordered);
214 return Values;
215}
Defines the clang::ASTContext interface.
static const NamespaceDecl * lookupStdNamespace(const ASTContext &Ctx, NamespaceDecl *&StdNS)
static const CXXRecordDecl * lookupCXXRecordDecl(const ASTContext &Ctx, const NamespaceDecl *StdNS, ComparisonCategoryType Kind)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
llvm::MachO::Record Record
Definition: MachO.h:31
C Language Family Type Representation.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:186
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1094
IdentifierTable & Idents
Definition: ASTContext.h:659
Represents a C++ struct/union/class.
Definition: DeclCXX.h:258
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:523
const ComparisonCategoryInfo * lookupInfoForType(QualType Ty) const
const ComparisonCategoryInfo & getInfoForType(QualType Ty) const
Return the comparison category information as specified by getCategoryForType(Ty).
const ComparisonCategoryInfo * lookupInfo(ComparisonCategoryType Kind) const
Return the cached comparison category information for the specified 'Kind'.
static StringRef getCategoryString(ComparisonCategoryType Kind)
static StringRef getResultString(ComparisonCategoryResult Kind)
static std::vector< ComparisonCategoryResult > getPossibleResultsForType(ComparisonCategoryType Type)
Return the list of results which are valid for the specified comparison category type.
const CXXRecordDecl * Record
The declaration for the comparison category type from the standard library.
ComparisonCategoryType Kind
The Kind of the comparison category type.
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1358
reference front() const
Definition: DeclBase.h:1381
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1828
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:523
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
Represent a C++ namespace.
Definition: Decl.h:547
A (possibly-)qualified type.
Definition: Type.h:941
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:1008
The base class of the type hierarchy.
Definition: Type.h:1829
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1882
bool isObjectPointerType() const
Definition: Type.h:8022
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition: Type.h:8410
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:2266
QualType getType() const
Definition: Decl.h:678
bool isUsableInConstantExpressions(const ASTContext &C) const
Determine whether this variable's value can be used in a constant expression, according to the releva...
Definition: Decl.cpp:2493
The JSON file list parser is used to communicate input to InstallAPI.
std::optional< ComparisonCategoryType > getComparisonCategoryForBuiltinCmp(QualType T)
Get the comparison category that should be used when comparing values of type T.
ComparisonCategoryResult
An enumeration representing the possible results of a three-way comparison.
ComparisonCategoryType
An enumeration representing the different comparison categories types.
const FunctionProtoType * T
bool hasValidIntValue() const
True iff we've successfully evaluated the variable as a constant expression and extracted its integer...
llvm::APSInt getIntValue() const
Get the constant integer value used by this variable to represent the comparison category result type...