1 //===--- SemaInternal.h - Internal Sema Interfaces --------------*- 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 provides common API and #includes for the internal
10 // implementation of Sema.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_SEMA_SEMAINTERNAL_H
15 #define LLVM_CLANG_SEMA_SEMAINTERNAL_H
16 
17 #include "clang/AST/ASTContext.h"
18 #include "clang/Sema/Lookup.h"
19 #include "clang/Sema/Sema.h"
20 #include "clang/Sema/SemaDiagnostic.h"
21 
22 namespace clang {
23 
24 inline PartialDiagnostic Sema::PDiag(unsigned DiagID) {
25   return PartialDiagnostic(DiagID, Context.getDiagAllocator());
26 }
27 
28 inline bool
29 FTIHasSingleVoidParameter(const DeclaratorChunk::FunctionTypeInfo &FTI) {
30   return FTI.NumParams == 1 && !FTI.isVariadic &&
31          FTI.Params[0].Ident == nullptr && FTI.Params[0].Param &&
32          cast<ParmVarDecl>(FTI.Params[0].Param)->getType()->isVoidType();
33 }
34 
35 inline bool
36 FTIHasNonVoidParameters(const DeclaratorChunk::FunctionTypeInfo &FTI) {
37   // Assume FTI is well-formed.
38   return FTI.NumParams && !FTIHasSingleVoidParameter(FTI);
39 }
40 
41 // Helper function to check whether D's attributes match current CUDA mode.
42 // Decls with mismatched attributes and related diagnostics may have to be
43 // ignored during this CUDA compilation pass.
44 inline bool DeclAttrsMatchCUDAMode(const LangOptions &LangOpts, Decl *D) {
45   if (!LangOpts.CUDA || !D)
46     return true;
47   bool isDeviceSideDecl = D->hasAttr<CUDADeviceAttr>() ||
48                           D->hasAttr<CUDASharedAttr>() ||
49                           D->hasAttr<CUDAGlobalAttr>();
50   return isDeviceSideDecl == LangOpts.CUDAIsDevice;
51 }
52 
53 /// Return a DLL attribute from the declaration.
54 inline InheritableAttr *getDLLAttr(Decl *D) {
55   assert(!(D->hasAttr<DLLImportAttr>() && D->hasAttr<DLLExportAttr>()) &&
56          "A declaration cannot be both dllimport and dllexport.");
57   if (auto *Import = D->getAttr<DLLImportAttr>())
58     return Import;
59   if (auto *Export = D->getAttr<DLLExportAttr>())
60     return Export;
61   return nullptr;
62 }
63 
64 /// Retrieve the depth and index of a template parameter.
65 inline std::pair<unsigned, unsigned> getDepthAndIndex(NamedDecl *ND) {
66   if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
67     return std::make_pair(TTP->getDepth(), TTP->getIndex());
68 
69   if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
70     return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
71 
72   const auto *TTP = cast<TemplateTemplateParmDecl>(ND);
73   return std::make_pair(TTP->getDepth(), TTP->getIndex());
74 }
75 
76 /// Retrieve the depth and index of an unexpanded parameter pack.
77 inline std::pair<unsigned, unsigned>
78 getDepthAndIndex(UnexpandedParameterPack UPP) {
79   if (const auto *TTP = UPP.first.dyn_cast<const TemplateTypeParmType *>())
80     return std::make_pair(TTP->getDepth(), TTP->getIndex());
81 
82   return getDepthAndIndex(UPP.first.get<NamedDecl *>());
83 }
84 
85 class TypoCorrectionConsumer : public VisibleDeclConsumer {
86   typedef SmallVector<TypoCorrection, 1> TypoResultList;
87   typedef llvm::StringMap<TypoResultList> TypoResultsMap;
88   typedef std::map<unsigned, TypoResultsMap> TypoEditDistanceMap;
89 
90 public:
91   TypoCorrectionConsumer(Sema &SemaRef,
92                          const DeclarationNameInfo &TypoName,
93                          Sema::LookupNameKind LookupKind,
94                          Scope *S, CXXScopeSpec *SS,
95                          std::unique_ptr<CorrectionCandidateCallback> CCC,
96                          DeclContext *MemberContext,
97                          bool EnteringContext)
98       : Typo(TypoName.getName().getAsIdentifierInfo()), CurrentTCIndex(0),
99         SavedTCIndex(0), SemaRef(SemaRef), S(S),
100         SS(SS ? std::make_unique<CXXScopeSpec>(*SS) : nullptr),
101         CorrectionValidator(std::move(CCC)), MemberContext(MemberContext),
102         Result(SemaRef, TypoName, LookupKind),
103         Namespaces(SemaRef.Context, SemaRef.CurContext, SS),
104         EnteringContext(EnteringContext), SearchNamespaces(false) {
105     Result.suppressDiagnostics();
106     // Arrange for ValidatedCorrections[0] to always be an empty correction.
107     ValidatedCorrections.push_back(TypoCorrection());
108   }
109 
110   bool includeHiddenDecls() const override { return true; }
111 
112   // Methods for adding potential corrections to the consumer.
113   void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,
114                  bool InBaseClass) override;
115   void FoundName(StringRef Name);
116   void addKeywordResult(StringRef Keyword);
117   void addCorrection(TypoCorrection Correction);
118 
119   bool empty() const {
120     return CorrectionResults.empty() && ValidatedCorrections.size() == 1;
121   }
122 
123   /// Return the list of TypoCorrections for the given identifier from
124   /// the set of corrections that have the closest edit distance, if any.
125   TypoResultList &operator[](StringRef Name) {
126     return CorrectionResults.begin()->second[Name];
127   }
128 
129   /// Return the edit distance of the corrections that have the
130   /// closest/best edit distance from the original typop.
131   unsigned getBestEditDistance(bool Normalized) {
132     if (CorrectionResults.empty())
133       return (std::numeric_limits<unsigned>::max)();
134 
135     unsigned BestED = CorrectionResults.begin()->first;
136     return Normalized ? TypoCorrection::NormalizeEditDistance(BestED) : BestED;
137   }
138 
139   /// Set-up method to add to the consumer the set of namespaces to use
140   /// in performing corrections to nested name specifiers. This method also
141   /// implicitly adds all of the known classes in the current AST context to the
142   /// to the consumer for correcting nested name specifiers.
143   void
144   addNamespaces(const llvm::MapVector<NamespaceDecl *, bool> &KnownNamespaces);
145 
146   /// Return the next typo correction that passes all internal filters
147   /// and is deemed valid by the consumer's CorrectionCandidateCallback,
148   /// starting with the corrections that have the closest edit distance. An
149   /// empty TypoCorrection is returned once no more viable corrections remain
150   /// in the consumer.
151   const TypoCorrection &getNextCorrection();
152 
153   /// Get the last correction returned by getNextCorrection().
154   const TypoCorrection &getCurrentCorrection() {
155     return CurrentTCIndex < ValidatedCorrections.size()
156                ? ValidatedCorrections[CurrentTCIndex]
157                : ValidatedCorrections[0];  // The empty correction.
158   }
159 
160   /// Return the next typo correction like getNextCorrection, but keep
161   /// the internal state pointed to the current correction (i.e. the next time
162   /// getNextCorrection is called, it will return the same correction returned
163   /// by peekNextcorrection).
164   const TypoCorrection &peekNextCorrection() {
165     auto Current = CurrentTCIndex;
166     const TypoCorrection &TC = getNextCorrection();
167     CurrentTCIndex = Current;
168     return TC;
169   }
170 
171   /// In the case of deeply invalid expressions, `getNextCorrection()` will
172   /// never be called since the transform never makes progress. If we don't
173   /// detect this we risk trying to correct typos forever.
174   bool hasMadeAnyCorrectionProgress() const { return CurrentTCIndex != 0; }
175 
176   /// Reset the consumer's position in the stream of viable corrections
177   /// (i.e. getNextCorrection() will return each of the previously returned
178   /// corrections in order before returning any new corrections).
179   void resetCorrectionStream() {
180     CurrentTCIndex = 0;
181   }
182 
183   /// Return whether the end of the stream of corrections has been
184   /// reached.
185   bool finished() {
186     return CorrectionResults.empty() &&
187            CurrentTCIndex >= ValidatedCorrections.size();
188   }
189 
190   /// Save the current position in the correction stream (overwriting any
191   /// previously saved position).
192   void saveCurrentPosition() {
193     SavedTCIndex = CurrentTCIndex;
194   }
195 
196   /// Restore the saved position in the correction stream.
197   void restoreSavedPosition() {
198     CurrentTCIndex = SavedTCIndex;
199   }
200 
201   ASTContext &getContext() const { return SemaRef.Context; }
202   const LookupResult &getLookupResult() const { return Result; }
203 
204   bool isAddressOfOperand() const { return CorrectionValidator->IsAddressOfOperand; }
205   const CXXScopeSpec *getSS() const { return SS.get(); }
206   Scope *getScope() const { return S; }
207   CorrectionCandidateCallback *getCorrectionValidator() const {
208     return CorrectionValidator.get();
209   }
210 
211 private:
212   class NamespaceSpecifierSet {
213     struct SpecifierInfo {
214       DeclContext* DeclCtx;
215       NestedNameSpecifier* NameSpecifier;
216       unsigned EditDistance;
217     };
218 
219     typedef SmallVector<DeclContext*, 4> DeclContextList;
220     typedef SmallVector<SpecifierInfo, 16> SpecifierInfoList;
221 
222     ASTContext &Context;
223     DeclContextList CurContextChain;
224     std::string CurNameSpecifier;
225     SmallVector<const IdentifierInfo*, 4> CurContextIdentifiers;
226     SmallVector<const IdentifierInfo*, 4> CurNameSpecifierIdentifiers;
227 
228     std::map<unsigned, SpecifierInfoList> DistanceMap;
229 
230     /// Helper for building the list of DeclContexts between the current
231     /// context and the top of the translation unit
232     static DeclContextList buildContextChain(DeclContext *Start);
233 
234     unsigned buildNestedNameSpecifier(DeclContextList &DeclChain,
235                                       NestedNameSpecifier *&NNS);
236 
237    public:
238     NamespaceSpecifierSet(ASTContext &Context, DeclContext *CurContext,
239                           CXXScopeSpec *CurScopeSpec);
240 
241     /// Add the DeclContext (a namespace or record) to the set, computing
242     /// the corresponding NestedNameSpecifier and its distance in the process.
243     void addNameSpecifier(DeclContext *Ctx);
244 
245     /// Provides flat iteration over specifiers, sorted by distance.
246     class iterator
247         : public llvm::iterator_facade_base<iterator, std::forward_iterator_tag,
248                                             SpecifierInfo> {
249       /// Always points to the last element in the distance map.
250       const std::map<unsigned, SpecifierInfoList>::iterator OuterBack;
251       /// Iterator on the distance map.
252       std::map<unsigned, SpecifierInfoList>::iterator Outer;
253       /// Iterator on an element in the distance map.
254       SpecifierInfoList::iterator Inner;
255 
256     public:
257       iterator(NamespaceSpecifierSet &Set, bool IsAtEnd)
258           : OuterBack(std::prev(Set.DistanceMap.end())),
259             Outer(Set.DistanceMap.begin()),
260             Inner(!IsAtEnd ? Outer->second.begin() : OuterBack->second.end()) {
261         assert(!Set.DistanceMap.empty());
262       }
263 
264       iterator &operator++() {
265         ++Inner;
266         if (Inner == Outer->second.end() && Outer != OuterBack) {
267           ++Outer;
268           Inner = Outer->second.begin();
269         }
270         return *this;
271       }
272 
273       SpecifierInfo &operator*() { return *Inner; }
274       bool operator==(const iterator &RHS) const { return Inner == RHS.Inner; }
275     };
276 
277     iterator begin() { return iterator(*this, /*IsAtEnd=*/false); }
278     iterator end() { return iterator(*this, /*IsAtEnd=*/true); }
279   };
280 
281   void addName(StringRef Name, NamedDecl *ND,
282                NestedNameSpecifier *NNS = nullptr, bool isKeyword = false);
283 
284   /// Find any visible decls for the given typo correction candidate.
285   /// If none are found, it to the set of candidates for which qualified lookups
286   /// will be performed to find possible nested name specifier changes.
287   bool resolveCorrection(TypoCorrection &Candidate);
288 
289   /// Perform qualified lookups on the queued set of typo correction
290   /// candidates and add the nested name specifier changes to each candidate if
291   /// a lookup succeeds (at which point the candidate will be returned to the
292   /// main pool of potential corrections).
293   void performQualifiedLookups();
294 
295   /// The name written that is a typo in the source.
296   IdentifierInfo *Typo;
297 
298   /// The results found that have the smallest edit distance
299   /// found (so far) with the typo name.
300   ///
301   /// The pointer value being set to the current DeclContext indicates
302   /// whether there is a keyword with this name.
303   TypoEditDistanceMap CorrectionResults;
304 
305   SmallVector<TypoCorrection, 4> ValidatedCorrections;
306   size_t CurrentTCIndex;
307   size_t SavedTCIndex;
308 
309   Sema &SemaRef;
310   Scope *S;
311   std::unique_ptr<CXXScopeSpec> SS;
312   std::unique_ptr<CorrectionCandidateCallback> CorrectionValidator;
313   DeclContext *MemberContext;
314   LookupResult Result;
315   NamespaceSpecifierSet Namespaces;
316   SmallVector<TypoCorrection, 2> QualifiedResults;
317   bool EnteringContext;
318   bool SearchNamespaces;
319 };
320 
321 inline Sema::TypoExprState::TypoExprState() {}
322 
323 inline Sema::TypoExprState::TypoExprState(TypoExprState &&other) noexcept {
324   *this = std::move(other);
325 }
326 
327 inline Sema::TypoExprState &Sema::TypoExprState::
328 operator=(Sema::TypoExprState &&other) noexcept {
329   Consumer = std::move(other.Consumer);
330   DiagHandler = std::move(other.DiagHandler);
331   RecoveryHandler = std::move(other.RecoveryHandler);
332   return *this;
333 }
334 
335 } // end namespace clang
336 
337 #endif
338