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 23 namespace clang { 24 25 inline PartialDiagnostic Sema::PDiag(unsigned DiagID) { 26 return PartialDiagnostic(DiagID, Context.getDiagAllocator()); 27 } 28 29 inline bool 30 FTIHasSingleVoidParameter(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 36 inline bool 37 FTIHasNonVoidParameters(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. 44 inline 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. 54 inline 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. 70 inline 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. 93 inline 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 103 class TypoCorrectionConsumer : public VisibleDeclConsumer { 104 typedef SmallVector<TypoCorrection, 1> TypoResultList; 105 typedef llvm::StringMap<TypoResultList> TypoResultsMap; 106 typedef std::map<unsigned, TypoResultsMap> TypoEditDistanceMap; 107 108 public: 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 224 private: 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 334 inline Sema::TypoExprState::TypoExprState() {} 335 336 inline Sema::TypoExprState::TypoExprState(TypoExprState &&other) noexcept { 337 *this = std::move(other); 338 } 339 340 inline Sema::TypoExprState &Sema::TypoExprState:: 341 operator=(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