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
22namespace clang {
23
24inline PartialDiagnostic Sema::PDiag(unsigned DiagID) {
25  return PartialDiagnostic(DiagID, Context.getDiagAllocator());
26}
27
28inline bool
29FTIHasSingleVoidParameter(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
35inline bool
36FTIHasNonVoidParameters(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.
44inline 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.
54inline 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.
65inline 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.
77inline std::pair<unsigned, unsigned>
78getDepthAndIndex(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
85class TypoCorrectionConsumer : public VisibleDeclConsumer {
86  typedef SmallVector<TypoCorrection, 1> TypoResultList;
87  typedef llvm::StringMap<TypoResultList> TypoResultsMap;
88  typedef std::map<unsigned, TypoResultsMap> TypoEditDistanceMap;
89
90public:
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  /// Reset the consumer's position in the stream of viable corrections
172  /// (i.e. getNextCorrection() will return each of the previously returned
173  /// corrections in order before returning any new corrections).
174  void resetCorrectionStream() {
175    CurrentTCIndex = 0;
176  }
177
178  /// Return whether the end of the stream of corrections has been
179  /// reached.
180  bool finished() {
181    return CorrectionResults.empty() &&
182           CurrentTCIndex >= ValidatedCorrections.size();
183  }
184
185  /// Save the current position in the correction stream (overwriting any
186  /// previously saved position).
187  void saveCurrentPosition() {
188    SavedTCIndex = CurrentTCIndex;
189  }
190
191  /// Restore the saved position in the correction stream.
192  void restoreSavedPosition() {
193    CurrentTCIndex = SavedTCIndex;
194  }
195
196  ASTContext &getContext() const { return SemaRef.Context; }
197  const LookupResult &getLookupResult() const { return Result; }
198
199  bool isAddressOfOperand() const { return CorrectionValidator->IsAddressOfOperand; }
200  const CXXScopeSpec *getSS() const { return SS.get(); }
201  Scope *getScope() const { return S; }
202  CorrectionCandidateCallback *getCorrectionValidator() const {
203    return CorrectionValidator.get();
204  }
205
206private:
207  class NamespaceSpecifierSet {
208    struct SpecifierInfo {
209      DeclContext* DeclCtx;
210      NestedNameSpecifier* NameSpecifier;
211      unsigned EditDistance;
212    };
213
214    typedef SmallVector<DeclContext*, 4> DeclContextList;
215    typedef SmallVector<SpecifierInfo, 16> SpecifierInfoList;
216
217    ASTContext &Context;
218    DeclContextList CurContextChain;
219    std::string CurNameSpecifier;
220    SmallVector<const IdentifierInfo*, 4> CurContextIdentifiers;
221    SmallVector<const IdentifierInfo*, 4> CurNameSpecifierIdentifiers;
222
223    std::map<unsigned, SpecifierInfoList> DistanceMap;
224
225    /// Helper for building the list of DeclContexts between the current
226    /// context and the top of the translation unit
227    static DeclContextList buildContextChain(DeclContext *Start);
228
229    unsigned buildNestedNameSpecifier(DeclContextList &DeclChain,
230                                      NestedNameSpecifier *&NNS);
231
232   public:
233    NamespaceSpecifierSet(ASTContext &Context, DeclContext *CurContext,
234                          CXXScopeSpec *CurScopeSpec);
235
236    /// Add the DeclContext (a namespace or record) to the set, computing
237    /// the corresponding NestedNameSpecifier and its distance in the process.
238    void addNameSpecifier(DeclContext *Ctx);
239
240    /// Provides flat iteration over specifiers, sorted by distance.
241    class iterator
242        : public llvm::iterator_facade_base<iterator, std::forward_iterator_tag,
243                                            SpecifierInfo> {
244      /// Always points to the last element in the distance map.
245      const std::map<unsigned, SpecifierInfoList>::iterator OuterBack;
246      /// Iterator on the distance map.
247      std::map<unsigned, SpecifierInfoList>::iterator Outer;
248      /// Iterator on an element in the distance map.
249      SpecifierInfoList::iterator Inner;
250
251    public:
252      iterator(NamespaceSpecifierSet &Set, bool IsAtEnd)
253          : OuterBack(std::prev(Set.DistanceMap.end())),
254            Outer(Set.DistanceMap.begin()),
255            Inner(!IsAtEnd ? Outer->second.begin() : OuterBack->second.end()) {
256        assert(!Set.DistanceMap.empty());
257      }
258
259      iterator &operator++() {
260        ++Inner;
261        if (Inner == Outer->second.end() && Outer != OuterBack) {
262          ++Outer;
263          Inner = Outer->second.begin();
264        }
265        return *this;
266      }
267
268      SpecifierInfo &operator*() { return *Inner; }
269      bool operator==(const iterator &RHS) const { return Inner == RHS.Inner; }
270    };
271
272    iterator begin() { return iterator(*this, /*IsAtEnd=*/false); }
273    iterator end() { return iterator(*this, /*IsAtEnd=*/true); }
274  };
275
276  void addName(StringRef Name, NamedDecl *ND,
277               NestedNameSpecifier *NNS = nullptr, bool isKeyword = false);
278
279  /// Find any visible decls for the given typo correction candidate.
280  /// If none are found, it to the set of candidates for which qualified lookups
281  /// will be performed to find possible nested name specifier changes.
282  bool resolveCorrection(TypoCorrection &Candidate);
283
284  /// Perform qualified lookups on the queued set of typo correction
285  /// candidates and add the nested name specifier changes to each candidate if
286  /// a lookup succeeds (at which point the candidate will be returned to the
287  /// main pool of potential corrections).
288  void performQualifiedLookups();
289
290  /// The name written that is a typo in the source.
291  IdentifierInfo *Typo;
292
293  /// The results found that have the smallest edit distance
294  /// found (so far) with the typo name.
295  ///
296  /// The pointer value being set to the current DeclContext indicates
297  /// whether there is a keyword with this name.
298  TypoEditDistanceMap CorrectionResults;
299
300  SmallVector<TypoCorrection, 4> ValidatedCorrections;
301  size_t CurrentTCIndex;
302  size_t SavedTCIndex;
303
304  Sema &SemaRef;
305  Scope *S;
306  std::unique_ptr<CXXScopeSpec> SS;
307  std::unique_ptr<CorrectionCandidateCallback> CorrectionValidator;
308  DeclContext *MemberContext;
309  LookupResult Result;
310  NamespaceSpecifierSet Namespaces;
311  SmallVector<TypoCorrection, 2> QualifiedResults;
312  bool EnteringContext;
313  bool SearchNamespaces;
314};
315
316inline Sema::TypoExprState::TypoExprState() {}
317
318inline Sema::TypoExprState::TypoExprState(TypoExprState &&other) noexcept {
319  *this = std::move(other);
320}
321
322inline Sema::TypoExprState &Sema::TypoExprState::
323operator=(Sema::TypoExprState &&other) noexcept {
324  Consumer = std::move(other.Consumer);
325  DiagHandler = std::move(other.DiagHandler);
326  RecoveryHandler = std::move(other.RecoveryHandler);
327  return *this;
328}
329
330} // end namespace clang
331
332#endif
333