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// Directly mark a variable odr-used. Given a choice, prefer to use
52// MarkVariableReferenced since it does additional checks and then
53// calls MarkVarDeclODRUsed.
54// If the variable must be captured:
55//  - if FunctionScopeIndexToStopAt is null, capture it in the CurContext
56//  - else capture it in the DeclContext that maps to the
57//    *FunctionScopeIndexToStopAt on the FunctionScopeInfo stack.
58inline void MarkVarDeclODRUsed(VarDecl *Var,
59    SourceLocation Loc, Sema &SemaRef,
60    const unsigned *const FunctionScopeIndexToStopAt) {
61  // Keep track of used but undefined variables.
62  // FIXME: We shouldn't suppress this warning for static data members.
63  if (Var->hasDefinition(SemaRef.Context) == VarDecl::DeclarationOnly &&
64    !Var->isExternallyVisible() &&
65    !(Var->isStaticDataMember() && Var->hasInit())) {
66      SourceLocation &old = SemaRef.UndefinedButUsed[Var->getCanonicalDecl()];
67      if (old.isInvalid()) old = Loc;
68  }
69  QualType CaptureType, DeclRefType;
70  SemaRef.tryCaptureVariable(Var, Loc, Sema::TryCapture_Implicit,
71    /*EllipsisLoc*/ SourceLocation(),
72    /*BuildAndDiagnose*/ true,
73    CaptureType, DeclRefType,
74    FunctionScopeIndexToStopAt);
75
76  Var->markUsed(SemaRef.Context);
77}
78
79/// Return a DLL attribute from the declaration.
80inline InheritableAttr *getDLLAttr(Decl *D) {
81  assert(!(D->hasAttr<DLLImportAttr>() && D->hasAttr<DLLExportAttr>()) &&
82         "A declaration cannot be both dllimport and dllexport.");
83  if (auto *Import = D->getAttr<DLLImportAttr>())
84    return Import;
85  if (auto *Export = D->getAttr<DLLExportAttr>())
86    return Export;
87  return nullptr;
88}
89
90class TypoCorrectionConsumer : public VisibleDeclConsumer {
91  typedef SmallVector<TypoCorrection, 1> TypoResultList;
92  typedef llvm::StringMap<TypoResultList> TypoResultsMap;
93  typedef std::map<unsigned, TypoResultsMap> TypoEditDistanceMap;
94
95public:
96  TypoCorrectionConsumer(Sema &SemaRef,
97                         const DeclarationNameInfo &TypoName,
98                         Sema::LookupNameKind LookupKind,
99                         Scope *S, CXXScopeSpec *SS,
100                         std::unique_ptr<CorrectionCandidateCallback> CCC,
101                         DeclContext *MemberContext,
102                         bool EnteringContext)
103      : Typo(TypoName.getName().getAsIdentifierInfo()), CurrentTCIndex(0),
104        SavedTCIndex(0), SemaRef(SemaRef), S(S),
105        SS(SS ? llvm::make_unique<CXXScopeSpec>(*SS) : nullptr),
106        CorrectionValidator(std::move(CCC)), MemberContext(MemberContext),
107        Result(SemaRef, TypoName, LookupKind),
108        Namespaces(SemaRef.Context, SemaRef.CurContext, SS),
109        EnteringContext(EnteringContext), SearchNamespaces(false) {
110    Result.suppressDiagnostics();
111    // Arrange for ValidatedCorrections[0] to always be an empty correction.
112    ValidatedCorrections.push_back(TypoCorrection());
113  }
114
115  bool includeHiddenDecls() const override { return true; }
116
117  // Methods for adding potential corrections to the consumer.
118  void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,
119                 bool InBaseClass) override;
120  void FoundName(StringRef Name);
121  void addKeywordResult(StringRef Keyword);
122  void addCorrection(TypoCorrection Correction);
123
124  bool empty() const {
125    return CorrectionResults.empty() && ValidatedCorrections.size() == 1;
126  }
127
128  /// \brief Return the list of TypoCorrections for the given identifier from
129  /// the set of corrections that have the closest edit distance, if any.
130  TypoResultList &operator[](StringRef Name) {
131    return CorrectionResults.begin()->second[Name];
132  }
133
134  /// \brief Return the edit distance of the corrections that have the
135  /// closest/best edit distance from the original typop.
136  unsigned getBestEditDistance(bool Normalized) {
137    if (CorrectionResults.empty())
138      return (std::numeric_limits<unsigned>::max)();
139
140    unsigned BestED = CorrectionResults.begin()->first;
141    return Normalized ? TypoCorrection::NormalizeEditDistance(BestED) : BestED;
142  }
143
144  /// \brief Set-up method to add to the consumer the set of namespaces to use
145  /// in performing corrections to nested name specifiers. This method also
146  /// implicitly adds all of the known classes in the current AST context to the
147  /// to the consumer for correcting nested name specifiers.
148  void
149  addNamespaces(const llvm::MapVector<NamespaceDecl *, bool> &KnownNamespaces);
150
151  /// \brief Return the next typo correction that passes all internal filters
152  /// and is deemed valid by the consumer's CorrectionCandidateCallback,
153  /// starting with the corrections that have the closest edit distance. An
154  /// empty TypoCorrection is returned once no more viable corrections remain
155  /// in the consumer.
156  const TypoCorrection &getNextCorrection();
157
158  /// \brief Get the last correction returned by getNextCorrection().
159  const TypoCorrection &getCurrentCorrection() {
160    return CurrentTCIndex < ValidatedCorrections.size()
161               ? ValidatedCorrections[CurrentTCIndex]
162               : ValidatedCorrections[0];  // The empty correction.
163  }
164
165  /// \brief Return the next typo correction like getNextCorrection, but keep
166  /// the internal state pointed to the current correction (i.e. the next time
167  /// getNextCorrection is called, it will return the same correction returned
168  /// by peekNextcorrection).
169  const TypoCorrection &peekNextCorrection() {
170    auto Current = CurrentTCIndex;
171    const TypoCorrection &TC = getNextCorrection();
172    CurrentTCIndex = Current;
173    return TC;
174  }
175
176  /// \brief 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  /// \brief 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  /// \brief Save the current position in the correction stream (overwriting any
191  /// previously saved position).
192  void saveCurrentPosition() {
193    SavedTCIndex = CurrentTCIndex;
194  }
195
196  /// \brief 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
208private:
209  class NamespaceSpecifierSet {
210    struct SpecifierInfo {
211      DeclContext* DeclCtx;
212      NestedNameSpecifier* NameSpecifier;
213      unsigned EditDistance;
214    };
215
216    typedef SmallVector<DeclContext*, 4> DeclContextList;
217    typedef SmallVector<SpecifierInfo, 16> SpecifierInfoList;
218
219    ASTContext &Context;
220    DeclContextList CurContextChain;
221    std::string CurNameSpecifier;
222    SmallVector<const IdentifierInfo*, 4> CurContextIdentifiers;
223    SmallVector<const IdentifierInfo*, 4> CurNameSpecifierIdentifiers;
224
225    std::map<unsigned, SpecifierInfoList> DistanceMap;
226
227    /// \brief Helper for building the list of DeclContexts between the current
228    /// context and the top of the translation unit
229    static DeclContextList buildContextChain(DeclContext *Start);
230
231    unsigned buildNestedNameSpecifier(DeclContextList &DeclChain,
232                                      NestedNameSpecifier *&NNS);
233
234   public:
235    NamespaceSpecifierSet(ASTContext &Context, DeclContext *CurContext,
236                          CXXScopeSpec *CurScopeSpec);
237
238    /// \brief Add the DeclContext (a namespace or record) to the set, computing
239    /// the corresponding NestedNameSpecifier and its distance in the process.
240    void addNameSpecifier(DeclContext *Ctx);
241
242    /// \brief Provides flat iteration over specifiers, sorted by distance.
243    class iterator
244        : public llvm::iterator_facade_base<iterator, std::forward_iterator_tag,
245                                            SpecifierInfo> {
246      /// Always points to the last element in the distance map.
247      const std::map<unsigned, SpecifierInfoList>::iterator OuterBack;
248      /// Iterator on the distance map.
249      std::map<unsigned, SpecifierInfoList>::iterator Outer;
250      /// Iterator on an element in the distance map.
251      SpecifierInfoList::iterator Inner;
252
253    public:
254      iterator(NamespaceSpecifierSet &Set, bool IsAtEnd)
255          : OuterBack(std::prev(Set.DistanceMap.end())),
256            Outer(Set.DistanceMap.begin()),
257            Inner(!IsAtEnd ? Outer->second.begin() : OuterBack->second.end()) {
258        assert(!Set.DistanceMap.empty());
259      }
260
261      iterator &operator++() {
262        ++Inner;
263        if (Inner == Outer->second.end() && Outer != OuterBack) {
264          ++Outer;
265          Inner = Outer->second.begin();
266        }
267        return *this;
268      }
269
270      SpecifierInfo &operator*() { return *Inner; }
271      bool operator==(const iterator &RHS) const { return Inner == RHS.Inner; }
272    };
273
274    iterator begin() { return iterator(*this, /*IsAtEnd=*/false); }
275    iterator end() { return iterator(*this, /*IsAtEnd=*/true); }
276  };
277
278  void addName(StringRef Name, NamedDecl *ND,
279               NestedNameSpecifier *NNS = nullptr, bool isKeyword = false);
280
281  /// \brief Find any visible decls for the given typo correction candidate.
282  /// If none are found, it to the set of candidates for which qualified lookups
283  /// will be performed to find possible nested name specifier changes.
284  bool resolveCorrection(TypoCorrection &Candidate);
285
286  /// \brief Perform qualified lookups on the queued set of typo correction
287  /// candidates and add the nested name specifier changes to each candidate if
288  /// a lookup succeeds (at which point the candidate will be returned to the
289  /// main pool of potential corrections).
290  void performQualifiedLookups();
291
292  /// \brief The name written that is a typo in the source.
293  IdentifierInfo *Typo;
294
295  /// \brief The results found that have the smallest edit distance
296  /// found (so far) with the typo name.
297  ///
298  /// The pointer value being set to the current DeclContext indicates
299  /// whether there is a keyword with this name.
300  TypoEditDistanceMap CorrectionResults;
301
302  SmallVector<TypoCorrection, 4> ValidatedCorrections;
303  size_t CurrentTCIndex;
304  size_t SavedTCIndex;
305
306  Sema &SemaRef;
307  Scope *S;
308  std::unique_ptr<CXXScopeSpec> SS;
309  std::unique_ptr<CorrectionCandidateCallback> CorrectionValidator;
310  DeclContext *MemberContext;
311  LookupResult Result;
312  NamespaceSpecifierSet Namespaces;
313  SmallVector<TypoCorrection, 2> QualifiedResults;
314  bool EnteringContext;
315  bool SearchNamespaces;
316};
317
318inline Sema::TypoExprState::TypoExprState() {}
319
320inline Sema::TypoExprState::TypoExprState(TypoExprState &&other) LLVM_NOEXCEPT {
321  *this = std::move(other);
322}
323
324inline Sema::TypoExprState &Sema::TypoExprState::operator=(
325    Sema::TypoExprState &&other) LLVM_NOEXCEPT {
326  Consumer = std::move(other.Consumer);
327  DiagHandler = std::move(other.DiagHandler);
328  RecoveryHandler = std::move(other.RecoveryHandler);
329  return *this;
330}
331
332} // end namespace clang
333
334#endif
335