Coverage Report

Created: 2020-09-22 08:39

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Sema/SemaInternal.h
Line
Count
Source (jump to first uncovered line)
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
1.37M
inline PartialDiagnostic Sema::PDiag(unsigned DiagID) {
25
1.37M
  return PartialDiagnostic(DiagID, Context.getDiagAllocator());
26
1.37M
}
27
28
inline bool
29
13.3M
FTIHasSingleVoidParameter(const DeclaratorChunk::FunctionTypeInfo &FTI) {
30
13.3M
  return FTI.NumParams == 1 && 
!FTI.isVariadic2.51M
&&
31
2.49M
         FTI.Params[0].Ident == nullptr && 
FTI.Params[0].Param899k
&&
32
899k
         cast<ParmVarDecl>(FTI.Params[0].Param)->getType()->isVoidType();
33
13.3M
}
34
35
inline bool
36
13.8M
FTIHasNonVoidParameters(const DeclaratorChunk::FunctionTypeInfo &FTI) {
37
  // Assume FTI is well-formed.
38
13.8M
  return FTI.NumParams && 
!FTIHasSingleVoidParameter(FTI)13.3M
;
39
13.8M
}
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
57
inline bool DeclAttrsMatchCUDAMode(const LangOptions &LangOpts, Decl *D) {
45
57
  if (!LangOpts.CUDA || 
!D18
)
46
39
    return true;
47
18
  bool isDeviceSideDecl = D->hasAttr<CUDADeviceAttr>() ||
48
10
                          D->hasAttr<CUDASharedAttr>() ||
49
8
                          D->hasAttr<CUDAGlobalAttr>();
50
18
  return isDeviceSideDecl == LangOpts.CUDAIsDevice;
51
18
}
52
53
/// Return a DLL attribute from the declaration.
54
20.7M
inline InheritableAttr *getDLLAttr(Decl *D) {
55
20.7M
  assert(!(D->hasAttr<DLLImportAttr>() && D->hasAttr<DLLExportAttr>()) &&
56
20.7M
         "A declaration cannot be both dllimport and dllexport.");
57
20.7M
  if (auto *Import = D->getAttr<DLLImportAttr>())
58
5.96k
    return Import;
59
20.7M
  if (auto *Export = D->getAttr<DLLExportAttr>())
60
6.50k
    return Export;
61
20.7M
  return nullptr;
62
20.7M
}
63
64
/// Retrieve the depth and index of a template parameter.
65
189k
inline std::pair<unsigned, unsigned> getDepthAndIndex(NamedDecl *ND) {
66
189k
  if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
67
89.5k
    return std::make_pair(TTP->getDepth(), TTP->getIndex());
68
69
99.5k
  if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
70
99.2k
    return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
71
72
243
  const auto *TTP = cast<TemplateTemplateParmDecl>(ND);
73
243
  return std::make_pair(TTP->getDepth(), TTP->getIndex());
74
243
}
75
76
/// Retrieve the depth and index of an unexpanded parameter pack.
77
inline std::pair<unsigned, unsigned>
78
49.1k
getDepthAndIndex(UnexpandedParameterPack UPP) {
79
49.1k
  if (const auto *TTP = UPP.first.dyn_cast<const TemplateTypeParmType *>())
80
44.4k
    return std::make_pair(TTP->getDepth(), TTP->getIndex());
81
82
4.65k
  return getDepthAndIndex(UPP.first.get<NamedDecl *>());
83
4.65k
}
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
5.71k
        EnteringContext(EnteringContext), SearchNamespaces(false) {
105
5.71k
    Result.suppressDiagnostics();
106
    // Arrange for ValidatedCorrections[0] to always be an empty correction.
107
5.71k
    ValidatedCorrections.push_back(TypoCorrection());
108
5.71k
  }
109
110
699
  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
5.53k
  bool empty() const {
120
5.53k
    return CorrectionResults.empty() && 
ValidatedCorrections.size() == 1134
;
121
5.53k
  }
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
0
  TypoResultList &operator[](StringRef Name) {
126
0
    return CorrectionResults.begin()->second[Name];
127
0
  }
128
129
  /// Return the edit distance of the corrections that have the
130
  /// closest/best edit distance from the original typop.
131
5.40k
  unsigned getBestEditDistance(bool Normalized) {
132
5.40k
    if (CorrectionResults.empty())
133
0
      return (std::numeric_limits<unsigned>::max)();
134
135
5.40k
    unsigned BestED = CorrectionResults.begin()->first;
136
5.40k
    return Normalized ? TypoCorrection::NormalizeEditDistance(BestED) : 
BestED0
;
137
5.40k
  }
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
2.91k
  const TypoCorrection &getCurrentCorrection() {
155
2.91k
    return CurrentTCIndex < ValidatedCorrections.size()
156
2.91k
               ? ValidatedCorrections[CurrentTCIndex]
157
0
               : ValidatedCorrections[0];  // The empty correction.
158
2.91k
  }
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
593
  const TypoCorrection &peekNextCorrection() {
165
593
    auto Current = CurrentTCIndex;
166
593
    const TypoCorrection &TC = getNextCorrection();
167
593
    CurrentTCIndex = Current;
168
593
    return TC;
169
593
  }
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
2.67k
  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
4.64k
  void resetCorrectionStream() {
180
4.64k
    CurrentTCIndex = 0;
181
4.64k
  }
182
183
  /// Return whether the end of the stream of corrections has been
184
  /// reached.
185
2.67k
  bool finished() {
186
2.67k
    return CorrectionResults.empty() &&
187
2.63k
           CurrentTCIndex >= ValidatedCorrections.size();
188
2.67k
  }
189
190
  /// Save the current position in the correction stream (overwriting any
191
  /// previously saved position).
192
52
  void saveCurrentPosition() {
193
52
    SavedTCIndex = CurrentTCIndex;
194
52
  }
195
196
  /// Restore the saved position in the correction stream.
197
5
  void restoreSavedPosition() {
198
5
    CurrentTCIndex = SavedTCIndex;
199
5
  }
200
201
0
  ASTContext &getContext() const { return SemaRef.Context; }
202
832
  const LookupResult &getLookupResult() const { return Result; }
203
204
75
  bool isAddressOfOperand() const { return CorrectionValidator->IsAddressOfOperand; }
205
416
  const CXXScopeSpec *getSS() const { return SS.get(); }
206
17
  Scope *getScope() const { return S; }
207
5.67k
  CorrectionCandidateCallback *getCorrectionValidator() const {
208
5.67k
    return CorrectionValidator.get();
209
5.67k
  }
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
11.2k
            Inner(!IsAtEnd ? Outer->second.begin() : OuterBack->second.end()) {
261
11.2k
        assert(!Set.DistanceMap.empty());
262
11.2k
      }
263
264
113k
      iterator &operator++() {
265
113k
        ++Inner;
266
113k
        if (Inner == Outer->second.end() && 
Outer != OuterBack8.50k
) {
267
2.86k
          ++Outer;
268
2.86k
          Inner = Outer->second.begin();
269
2.86k
        }
270
113k
        return *this;
271
113k
      }
272
273
113k
      SpecifierInfo &operator*() { return *Inner; }
274
119k
      bool operator==(const iterator &RHS) const { return Inner == RHS.Inner; }
275
    };
276
277
5.64k
    iterator begin() { return iterator(*this, /*IsAtEnd=*/false); }
278
5.64k
    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
2.99k
inline Sema::TypoExprState::TypoExprState() {}
322
323
6.02k
inline Sema::TypoExprState::TypoExprState(TypoExprState &&other) noexcept {
324
6.02k
  *this = std::move(other);
325
6.02k
}
326
327
inline Sema::TypoExprState &Sema::TypoExprState::
328
6.09k
operator=(Sema::TypoExprState &&other) noexcept {
329
6.09k
  Consumer = std::move(other.Consumer);
330
6.09k
  DiagHandler = std::move(other.DiagHandler);
331
6.09k
  RecoveryHandler = std::move(other.RecoveryHandler);
332
6.09k
  return *this;
333
6.09k
}
334
335
} // end namespace clang
336
337
#endif