contrib/llvm/tools/clang/include/clang/Sema/ExternalSemaSource.h

   1 //===--- ExternalSemaSource.h - External Sema Interface ---------*- 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 defines the ExternalSemaSource interface.
  10 //
  11 //===----------------------------------------------------------------------===//
  12 #ifndef LLVM_CLANG_SEMA_EXTERNALSEMASOURCE_H
  13 #define LLVM_CLANG_SEMA_EXTERNALSEMASOURCE_H
  14
  15 #include "clang/AST/ExternalASTSource.h"
  16 #include "clang/AST/Type.h"
  17 #include "clang/Sema/TypoCorrection.h"
  18 #include "clang/Sema/Weak.h"
  19 #include "llvm/ADT/MapVector.h"
  20 #include <utility>
  21
  22 namespace llvm {
  23 template <class T, unsigned n> class SmallSetVector;
  24 }
  25
  26 namespace clang {
  27
  28 class CXXConstructorDecl;
  29 class CXXDeleteExpr;
  30 class CXXRecordDecl;
  31 class DeclaratorDecl;
  32 class LookupResult;
  33 struct ObjCMethodList;
  34 class Scope;
  35 class Sema;
  36 class TypedefNameDecl;
  37 class ValueDecl;
  38 class VarDecl;
  39 struct LateParsedTemplate;
  40
  41 /// A simple structure that captures a vtable use for the purposes of
  42 /// the \c ExternalSemaSource.
  43 struct ExternalVTableUse {
  44   CXXRecordDecl *Record;
  45   SourceLocation Location;
  46   bool DefinitionRequired;
  47 };
  48
  49 /// An abstract interface that should be implemented by
  50 /// external AST sources that also provide information for semantic
  51 /// analysis.
  52 class ExternalSemaSource : public ExternalASTSource {
  53 public:
  54   ExternalSemaSource() {
  55     ExternalASTSource::SemaSource = true;
  56   }
  57
  58   ~ExternalSemaSource() override;
  59
  60   /// Initialize the semantic source with the Sema instance
  61   /// being used to perform semantic analysis on the abstract syntax
  62   /// tree.
  63   virtual void InitializeSema(Sema &S) {}
  64
  65   /// Inform the semantic consumer that Sema is no longer available.
  66   virtual void ForgetSema() {}
  67
  68   /// Load the contents of the global method pool for a given
  69   /// selector.
  70   virtual void ReadMethodPool(Selector Sel);
  71
  72   /// Load the contents of the global method pool for a given
  73   /// selector if necessary.
  74   virtual void updateOutOfDateSelector(Selector Sel);
  75
  76   /// Load the set of namespaces that are known to the external source,
  77   /// which will be used during typo correction.
  78   virtual void ReadKnownNamespaces(
  79                            SmallVectorImpl<NamespaceDecl *> &Namespaces);
  80
  81   /// Load the set of used but not defined functions or variables with
  82   /// internal linkage, or used but not defined internal functions.
  83   virtual void
  84   ReadUndefinedButUsed(llvm::MapVector<NamedDecl *, SourceLocation> &Undefined);
  85
  86   virtual void ReadMismatchingDeleteExpressions(llvm::MapVector<
  87       FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &);
  88
  89   /// Do last resort, unqualified lookup on a LookupResult that
  90   /// Sema cannot find.
  91   ///
  92   /// \param R a LookupResult that is being recovered.
  93   ///
  94   /// \param S the Scope of the identifier occurrence.
  95   ///
  96   /// \return true to tell Sema to recover using the LookupResult.
  97   virtual bool LookupUnqualified(LookupResult &R, Scope *S) { return false; }
  98
  99   /// Read the set of tentative definitions known to the external Sema
 100   /// source.
 101   ///
 102   /// The external source should append its own tentative definitions to the
 103   /// given vector of tentative definitions. Note that this routine may be
 104   /// invoked multiple times; the external source should take care not to
 105   /// introduce the same declarations repeatedly.
 106   virtual void ReadTentativeDefinitions(
 107                                   SmallVectorImpl<VarDecl *> &TentativeDefs) {}
 108
 109   /// Read the set of unused file-scope declarations known to the
 110   /// external Sema source.
 111   ///
 112   /// The external source should append its own unused, filed-scope to the
 113   /// given vector of declarations. Note that this routine may be
 114   /// invoked multiple times; the external source should take care not to
 115   /// introduce the same declarations repeatedly.
 116   virtual void ReadUnusedFileScopedDecls(
 117                  SmallVectorImpl<const DeclaratorDecl *> &Decls) {}
 118
 119   /// Read the set of delegating constructors known to the
 120   /// external Sema source.
 121   ///
 122   /// The external source should append its own delegating constructors to the
 123   /// given vector of declarations. Note that this routine may be
 124   /// invoked multiple times; the external source should take care not to
 125   /// introduce the same declarations repeatedly.
 126   virtual void ReadDelegatingConstructors(
 127                  SmallVectorImpl<CXXConstructorDecl *> &Decls) {}
 128
 129   /// Read the set of ext_vector type declarations known to the
 130   /// external Sema source.
 131   ///
 132   /// The external source should append its own ext_vector type declarations to
 133   /// the given vector of declarations. Note that this routine may be
 134   /// invoked multiple times; the external source should take care not to
 135   /// introduce the same declarations repeatedly.
 136   virtual void ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {}
 137
 138   /// Read the set of potentially unused typedefs known to the source.
 139   ///
 140   /// The external source should append its own potentially unused local
 141   /// typedefs to the given vector of declarations. Note that this routine may
 142   /// be invoked multiple times; the external source should take care not to
 143   /// introduce the same declarations repeatedly.
 144   virtual void ReadUnusedLocalTypedefNameCandidates(
 145       llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {}
 146
 147   /// Read the set of referenced selectors known to the
 148   /// external Sema source.
 149   ///
 150   /// The external source should append its own referenced selectors to the
 151   /// given vector of selectors. Note that this routine
 152   /// may be invoked multiple times; the external source should take care not
 153   /// to introduce the same selectors repeatedly.
 154   virtual void ReadReferencedSelectors(
 155                  SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {}
 156
 157   /// Read the set of weak, undeclared identifiers known to the
 158   /// external Sema source.
 159   ///
 160   /// The external source should append its own weak, undeclared identifiers to
 161   /// the given vector. Note that this routine may be invoked multiple times;
 162   /// the external source should take care not to introduce the same identifiers
 163   /// repeatedly.
 164   virtual void ReadWeakUndeclaredIdentifiers(
 165                  SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WI) {}
 166
 167   /// Read the set of used vtables known to the external Sema source.
 168   ///
 169   /// The external source should append its own used vtables to the given
 170   /// vector. Note that this routine may be invoked multiple times; the external
 171   /// source should take care not to introduce the same vtables repeatedly.
 172   virtual void ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {}
 173
 174   /// Read the set of pending instantiations known to the external
 175   /// Sema source.
 176   ///
 177   /// The external source should append its own pending instantiations to the
 178   /// given vector. Note that this routine may be invoked multiple times; the
 179   /// external source should take care not to introduce the same instantiations
 180   /// repeatedly.
 181   virtual void ReadPendingInstantiations(
 182                  SmallVectorImpl<std::pair<ValueDecl *,
 183                                            SourceLocation> > &Pending) {}
 184
 185   /// Read the set of late parsed template functions for this source.
 186   ///
 187   /// The external source should insert its own late parsed template functions
 188   /// into the map. Note that this routine may be invoked multiple times; the
 189   /// external source should take care not to introduce the same map entries
 190   /// repeatedly.
 191   virtual void ReadLateParsedTemplates(
 192       llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>
 193           &LPTMap) {}
 194
 195   /// \copydoc Sema::CorrectTypo
 196   /// \note LookupKind must correspond to a valid Sema::LookupNameKind
 197   ///
 198   /// ExternalSemaSource::CorrectTypo is always given the first chance to
 199   /// correct a typo (really, to offer suggestions to repair a failed lookup).
 200   /// It will even be called when SpellChecking is turned off or after a
 201   /// fatal error has already been detected.
 202   virtual TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,
 203                                      int LookupKind, Scope *S, CXXScopeSpec *SS,
 204                                      CorrectionCandidateCallback &CCC,
 205                                      DeclContext *MemberContext,
 206                                      bool EnteringContext,
 207                                      const ObjCObjectPointerType *OPT) {
 208     return TypoCorrection();
 209   }
 210
 211   /// Produces a diagnostic note if the external source contains a
 212   /// complete definition for \p T.
 213   ///
 214   /// \param Loc the location at which a complete type was required but not
 215   /// provided
 216   ///
 217   /// \param T the \c QualType that should have been complete at \p Loc
 218   ///
 219   /// \return true if a diagnostic was produced, false otherwise.
 220   virtual bool MaybeDiagnoseMissingCompleteType(SourceLocation Loc,
 221                                                 QualType T) {
 222     return false;
 223   }
 224
 225   // isa/cast/dyn_cast support
 226   static bool classof(const ExternalASTSource *Source) {
 227     return Source->SemaSource;
 228   }
 229 };
 230
 231 } // end namespace clang
 232
 233 #endif