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