Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===--- ExternalSemaSource.h - External Sema Interface ---------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

//  This file defines the ExternalSemaSource interface.

//

//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_SEMA_EXTERNALSEMASOURCE_H

#define LLVM_CLANG_SEMA_EXTERNALSEMASOURCE_H

#include "clang/AST/ExternalASTSource.h"

#include "clang/AST/Type.h"

#include "clang/Sema/TypoCorrection.h"

#include "clang/Sema/Weak.h"

#include "llvm/ADT/MapVector.h"

#include <utility>

namespace llvm {

template <class T, unsigned n> class SmallSetVector;

}

namespace clang {

class CXXConstructorDecl;

class CXXRecordDecl;

class DeclaratorDecl;

class LookupResult;

class Scope;

class Sema;

class TypedefNameDecl;

class ValueDecl;

class VarDecl;

struct LateParsedTemplate;

/// A simple structure that captures a vtable use for the purposes of

/// the \c ExternalSemaSource.

struct ExternalVTableUse {

  CXXRecordDecl *Record;

  SourceLocation Location;

  bool DefinitionRequired;

};

/// An abstract interface that should be implemented by

/// external AST sources that also provide information for semantic

/// analysis.

class ExternalSemaSource : public ExternalASTSource {

  /// LLVM-style RTTI.

  static char ID;

public:

  ExternalSemaSource() = default;

  ~ExternalSemaSource() override;

  /// Initialize the semantic source with the Sema instance

  /// being used to perform semantic analysis on the abstract syntax

  /// tree.

  virtual void InitializeSema(Sema &S) {}

  /// Inform the semantic consumer that Sema is no longer available.

  virtual void ForgetSema() {}

  /// Load the contents of the global method pool for a given

  /// selector.

  virtual void ReadMethodPool(Selector Sel);

  /// Load the contents of the global method pool for a given

  /// selector if necessary.

  virtual void updateOutOfDateSelector(Selector Sel);

  /// Load the set of namespaces that are known to the external source,

  /// which will be used during typo correction.

  virtual void ReadKnownNamespaces(

                           SmallVectorImpl<NamespaceDecl *> &Namespaces);

  /// Load the set of used but not defined functions or variables with

  /// internal linkage, or used but not defined internal functions.

  virtual void

  ReadUndefinedButUsed(llvm::MapVector<NamedDecl *, SourceLocation> &Undefined);

  virtual void ReadMismatchingDeleteExpressions(llvm::MapVector<

      FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &);

  /// Do last resort, unqualified lookup on a LookupResult that

  /// Sema cannot find.

  ///

  /// \param R a LookupResult that is being recovered.

  ///

  /// \param S the Scope of the identifier occurrence.

  ///

  /// \return true to tell Sema to recover using the LookupResult.

  virtual bool LookupUnqualified(LookupResult &R, Scope *S) { return false; }

  /// Read the set of tentative definitions known to the external Sema

  /// source.

  ///

  /// The external source should append its own tentative definitions to the

  /// given vector of tentative definitions. Note that this routine may be

  /// invoked multiple times; the external source should take care not to

  /// introduce the same declarations repeatedly.

  virtual void ReadTentativeDefinitions(

                                  SmallVectorImpl<VarDecl *> &TentativeDefs) {}

  /// Read the set of unused file-scope declarations known to the

  /// external Sema source.

  ///

  /// The external source should append its own unused, filed-scope to the

  /// given vector of declarations. Note that this routine may be

  /// invoked multiple times; the external source should take care not to

  /// introduce the same declarations repeatedly.

  virtual void ReadUnusedFileScopedDecls(

                 SmallVectorImpl<const DeclaratorDecl *> &Decls) {}

  /// Read the set of delegating constructors known to the

  /// external Sema source.

  ///

  /// The external source should append its own delegating constructors to the

  /// given vector of declarations. Note that this routine may be

  /// invoked multiple times; the external source should take care not to

  /// introduce the same declarations repeatedly.

  virtual void ReadDelegatingConstructors(

                 SmallVectorImpl<CXXConstructorDecl *> &Decls) {}

  /// Read the set of ext_vector type declarations known to the

  /// external Sema source.

  ///

  /// The external source should append its own ext_vector type declarations to

  /// the given vector of declarations. Note that this routine may be

  /// invoked multiple times; the external source should take care not to

  /// introduce the same declarations repeatedly.

  virtual void ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {}

  /// Read the set of potentially unused typedefs known to the source.

  ///

  /// The external source should append its own potentially unused local

  /// typedefs to the given vector of declarations. Note that this routine may

  /// be invoked multiple times; the external source should take care not to

  /// introduce the same declarations repeatedly.

  virtual void ReadUnusedLocalTypedefNameCandidates(

      llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {}

  /// Read the set of referenced selectors known to the

  /// external Sema source.

  ///

  /// The external source should append its own referenced selectors to the

  /// given vector of selectors. Note that this routine

  /// may be invoked multiple times; the external source should take care not

  /// to introduce the same selectors repeatedly.

  virtual void ReadReferencedSelectors(

                 SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {}

  /// Read the set of weak, undeclared identifiers known to the

  /// external Sema source.

  ///

  /// The external source should append its own weak, undeclared identifiers to

  /// the given vector. Note that this routine may be invoked multiple times;

  /// the external source should take care not to introduce the same identifiers

  /// repeatedly.

  virtual void ReadWeakUndeclaredIdentifiers(

                 SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WI) {}

  /// Read the set of used vtables known to the external Sema source.

  ///

  /// The external source should append its own used vtables to the given

  /// vector. Note that this routine may be invoked multiple times; the external

  /// source should take care not to introduce the same vtables repeatedly.

  virtual void ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {}

  /// Read the set of pending instantiations known to the external

  /// Sema source.

  ///

  /// The external source should append its own pending instantiations to the

  /// given vector. Note that this routine may be invoked multiple times; the

  /// external source should take care not to introduce the same instantiations

  /// repeatedly.

  virtual void ReadPendingInstantiations(

                 SmallVectorImpl<std::pair<ValueDecl *,

                                           SourceLocation> > &Pending) {}

  /// Read the set of late parsed template functions for this source.

  ///

  /// The external source should insert its own late parsed template functions

  /// into the map. Note that this routine may be invoked multiple times; the

  /// external source should take care not to introduce the same map entries

  /// repeatedly.

  virtual void ReadLateParsedTemplates(

      llvm::MapVector<const FunctionDecl *, std::unique_ptr<LateParsedTemplate>>

          &LPTMap) {}

  /// Read the set of decls to be checked for deferred diags.

  ///

  /// The external source should append its own potentially emitted function

  /// and variable decls which may cause deferred diags. Note that this routine

  /// may be invoked multiple times; the external source should take care not to

  /// introduce the same declarations repeatedly.

  virtual void

  ReadDeclsToCheckForDeferredDiags(llvm::SmallSetVector<Decl *, 4> &Decls) {}

  /// \copydoc Sema::CorrectTypo

  /// \note LookupKind must correspond to a valid Sema::LookupNameKind

  ///

  /// ExternalSemaSource::CorrectTypo is always given the first chance to

  /// correct a typo (really, to offer suggestions to repair a failed lookup).

  /// It will even be called when SpellChecking is turned off or after a

  /// fatal error has already been detected.

  virtual TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,

                                     int LookupKind, Scope *S, CXXScopeSpec *SS,

                                     CorrectionCandidateCallback &CCC,

                                     DeclContext *MemberContext,

                                     bool EnteringContext,

                                     const ObjCObjectPointerType *OPT) {

    return TypoCorrection();

  }

  /// Produces a diagnostic note if the external source contains a

  /// complete definition for \p T.

  ///

  /// \param Loc the location at which a complete type was required but not

  /// provided

  ///

  /// \param T the \c QualType that should have been complete at \p Loc

  ///

  /// \return true if a diagnostic was produced, false otherwise.

  virtual bool MaybeDiagnoseMissingCompleteType(SourceLocation Loc,

                                                QualType T) {

    return false;

  }

  /// LLVM-style RTTI.

  /// \{

  bool isA(const void *ClassID) const override {

    return ClassID == &ID || ExternalASTSource::isA(ClassID);

  }

  static bool classof(const ExternalASTSource *S) { return S->isA(&ID); }

  /// \}

};

} // end namespace clang

#endif