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