1 //===- ComparisonCategories.cpp - Three Way Comparison Data -----*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 //  This file defines the Comparison Category enum and data types, which
11 //  store the types and expressions needed to support operator<=>
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/AST/ComparisonCategories.h"
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 
21 using namespace clang;
22 
23 bool ComparisonCategoryInfo::ValueInfo::hasValidIntValue() const {
24   assert(VD && "must have var decl");
25   if (!VD->checkInitIsICE())
26     return false;
27 
28   // Before we attempt to get the value of the first field, ensure that we
29   // actually have one (and only one) field.
30   auto *Record = VD->getType()->getAsCXXRecordDecl();
31   if (std::distance(Record->field_begin(), Record->field_end()) != 1 ||
32       !Record->field_begin()->getType()->isIntegralOrEnumerationType())
33     return false;
34 
35   return true;
36 }
37 
38 /// Attempt to determine the integer value used to represent the comparison
39 /// category result by evaluating the initializer for the specified VarDecl as
40 /// a constant expression and retreiving the value of the class's first
41 /// (and only) field.
42 ///
43 /// Note: The STL types are expected to have the form:
44 ///    struct X { T value; };
45 /// where T is an integral or enumeration type.
46 llvm::APSInt ComparisonCategoryInfo::ValueInfo::getIntValue() const {
47   assert(hasValidIntValue() && "must have a valid value");
48   return VD->evaluateValue()->getStructField(0).getInt();
49 }
50 
51 ComparisonCategoryInfo::ValueInfo *ComparisonCategoryInfo::lookupValueInfo(
52     ComparisonCategoryResult ValueKind) const {
53   // Check if we already have a cache entry for this value.
54   auto It = llvm::find_if(
55       Objects, [&](ValueInfo const &Info) { return Info.Kind == ValueKind; });
56   if (It != Objects.end())
57     return &(*It);
58 
59   // We don't have a cached result. Lookup the variable declaration and create
60   // a new entry representing it.
61   DeclContextLookupResult Lookup = Record->getCanonicalDecl()->lookup(
62       &Ctx.Idents.get(ComparisonCategories::getResultString(ValueKind)));
63   if (Lookup.size() != 1 || !isa<VarDecl>(Lookup.front()))
64     return nullptr;
65   Objects.emplace_back(ValueKind, cast<VarDecl>(Lookup.front()));
66   return &Objects.back();
67 }
68 
69 static const NamespaceDecl *lookupStdNamespace(const ASTContext &Ctx,
70                                                NamespaceDecl *&StdNS) {
71   if (!StdNS) {
72     DeclContextLookupResult Lookup =
73         Ctx.getTranslationUnitDecl()->lookup(&Ctx.Idents.get("std"));
74     if (Lookup.size() == 1)
75       StdNS = dyn_cast<NamespaceDecl>(Lookup.front());
76   }
77   return StdNS;
78 }
79 
80 static CXXRecordDecl *lookupCXXRecordDecl(const ASTContext &Ctx,
81                                           const NamespaceDecl *StdNS,
82                                           ComparisonCategoryType Kind) {
83   StringRef Name = ComparisonCategories::getCategoryString(Kind);
84   DeclContextLookupResult Lookup = StdNS->lookup(&Ctx.Idents.get(Name));
85   if (Lookup.size() == 1)
86     if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Lookup.front()))
87       return RD;
88   return nullptr;
89 }
90 
91 const ComparisonCategoryInfo *
92 ComparisonCategories::lookupInfo(ComparisonCategoryType Kind) const {
93   auto It = Data.find(static_cast<char>(Kind));
94   if (It != Data.end())
95     return &It->second;
96 
97   if (const NamespaceDecl *NS = lookupStdNamespace(Ctx, StdNS))
98     if (CXXRecordDecl *RD = lookupCXXRecordDecl(Ctx, NS, Kind))
99       return &Data.try_emplace((char)Kind, Ctx, RD, Kind).first->second;
100 
101   return nullptr;
102 }
103 
104 const ComparisonCategoryInfo *
105 ComparisonCategories::lookupInfoForType(QualType Ty) const {
106   assert(!Ty.isNull() && "type must be non-null");
107   using CCT = ComparisonCategoryType;
108   auto *RD = Ty->getAsCXXRecordDecl();
109   if (!RD)
110     return nullptr;
111 
112   // Check to see if we have information for the specified type cached.
113   const auto *CanonRD = RD->getCanonicalDecl();
114   for (auto &KV : Data) {
115     const ComparisonCategoryInfo &Info = KV.second;
116     if (CanonRD == Info.Record->getCanonicalDecl())
117       return &Info;
118   }
119 
120   if (!RD->getEnclosingNamespaceContext()->isStdNamespace())
121     return nullptr;
122 
123   // If not, check to see if the decl names a type in namespace std with a name
124   // matching one of the comparison category types.
125   for (unsigned I = static_cast<unsigned>(CCT::First),
126                 End = static_cast<unsigned>(CCT::Last);
127        I <= End; ++I) {
128     CCT Kind = static_cast<CCT>(I);
129 
130     // We've found the comparison category type. Build a new cache entry for
131     // it.
132     if (getCategoryString(Kind) == RD->getName())
133       return &Data.try_emplace((char)Kind, Ctx, RD, Kind).first->second;
134   }
135 
136   // We've found nothing. This isn't a comparison category type.
137   return nullptr;
138 }
139 
140 const ComparisonCategoryInfo &ComparisonCategories::getInfoForType(QualType Ty) const {
141   const ComparisonCategoryInfo *Info = lookupInfoForType(Ty);
142   assert(Info && "info for comparison category not found");
143   return *Info;
144 }
145 
146 QualType ComparisonCategoryInfo::getType() const {
147   assert(Record);
148   return QualType(Record->getTypeForDecl(), 0);
149 }
150 
151 StringRef ComparisonCategories::getCategoryString(ComparisonCategoryType Kind) {
152   using CCKT = ComparisonCategoryType;
153   switch (Kind) {
154   case CCKT::WeakEquality:
155     return "weak_equality";
156   case CCKT::StrongEquality:
157     return "strong_equality";
158   case CCKT::PartialOrdering:
159     return "partial_ordering";
160   case CCKT::WeakOrdering:
161     return "weak_ordering";
162   case CCKT::StrongOrdering:
163     return "strong_ordering";
164   }
165   llvm_unreachable("unhandled cases in switch");
166 }
167 
168 StringRef ComparisonCategories::getResultString(ComparisonCategoryResult Kind) {
169   using CCVT = ComparisonCategoryResult;
170   switch (Kind) {
171   case CCVT::Equal:
172     return "equal";
173   case CCVT::Nonequal:
174     return "nonequal";
175   case CCVT::Equivalent:
176     return "equivalent";
177   case CCVT::Nonequivalent:
178     return "nonequivalent";
179   case CCVT::Less:
180     return "less";
181   case CCVT::Greater:
182     return "greater";
183   case CCVT::Unordered:
184     return "unordered";
185   }
186   llvm_unreachable("unhandled case in switch");
187 }
188 
189 std::vector<ComparisonCategoryResult>
190 ComparisonCategories::getPossibleResultsForType(ComparisonCategoryType Type) {
191   using CCT = ComparisonCategoryType;
192   using CCR = ComparisonCategoryResult;
193   std::vector<CCR> Values;
194   Values.reserve(6);
195   Values.push_back(CCR::Equivalent);
196   bool IsStrong = (Type == CCT::StrongEquality || Type == CCT::StrongOrdering);
197   if (IsStrong)
198     Values.push_back(CCR::Equal);
199   if (Type == CCT::StrongOrdering || Type == CCT::WeakOrdering ||
200       Type == CCT::PartialOrdering) {
201     Values.push_back(CCR::Less);
202     Values.push_back(CCR::Greater);
203   } else {
204     Values.push_back(CCR::Nonequivalent);
205     if (IsStrong)
206       Values.push_back(CCR::Nonequal);
207   }
208   if (Type == CCT::PartialOrdering)
209     Values.push_back(CCR::Unordered);
210   return Values;
211 }
212