text: //===--- SemaInternal.h - Internal Sema Interfaces --------------*- 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 provides common API and #includes for the internal
  // implementation of Sema.
  //
  //===----------------------------------------------------------------------===//
  
  #ifndef LLVM_CLANG_SEMA_SEMAINTERNAL_H
  #define LLVM_CLANG_SEMA_SEMAINTERNAL_H
  
  #include "clang/AST/ASTContext.h"
  #include "clang/Sema/Lookup.h"
  #include "clang/Sema/Sema.h"
  #include "clang/Sema/SemaDiagnostic.h"
  
  namespace clang {
  
  inline PartialDiagnostic Sema::PDiag(unsigned DiagID) {
    return PartialDiagnostic(DiagID, Context.getDiagAllocator());
  }
  
  inline bool
  FTIHasSingleVoidParameter(const DeclaratorChunk::FunctionTypeInfo &FTI) {
    return FTI.NumParams == 1 && !FTI.isVariadic &&
           FTI.Params[0].Ident == nullptr && FTI.Params[0].Param &&
           cast<ParmVarDecl>(FTI.Params[0].Param)->getType()->isVoidType();
  }
  
  inline bool
  FTIHasNonVoidParameters(const DeclaratorChunk::FunctionTypeInfo &FTI) {
    // Assume FTI is well-formed.
    return FTI.NumParams && !FTIHasSingleVoidParameter(FTI);
  }
  
  // Helper function to check whether D's attributes match current CUDA mode.
  // Decls with mismatched attributes and related diagnostics may have to be
  // ignored during this CUDA compilation pass.
  inline bool DeclAttrsMatchCUDAMode(const LangOptions &LangOpts, Decl *D) {
    if (!LangOpts.CUDA || !D)
      return true;
    bool isDeviceSideDecl = D->hasAttr<CUDADeviceAttr>() ||
                            D->hasAttr<CUDASharedAttr>() ||
                            D->hasAttr<CUDAGlobalAttr>();
    return isDeviceSideDecl == LangOpts.CUDAIsDevice;
  }
  
  /// Return a DLL attribute from the declaration.
  inline InheritableAttr *getDLLAttr(Decl *D) {
    assert(!(D->hasAttr<DLLImportAttr>() && D->hasAttr<DLLExportAttr>()) &&
           "A declaration cannot be both dllimport and dllexport.");
    if (auto *Import = D->getAttr<DLLImportAttr>())
      return Import;
    if (auto *Export = D->getAttr<DLLExportAttr>())
      return Export;
    return nullptr;
  }
  
  /// Retrieve the depth and index of a template parameter.
  inline std::pair<unsigned, unsigned> getDepthAndIndex(NamedDecl *ND) {
    if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(ND))
      return std::make_pair(TTP->getDepth(), TTP->getIndex());
  
    if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(ND))
      return std::make_pair(NTTP->getDepth(), NTTP->getIndex());
  
    const auto *TTP = cast<TemplateTemplateParmDecl>(ND);
    return std::make_pair(TTP->getDepth(), TTP->getIndex());
  }
  
  /// Retrieve the depth and index of an unexpanded parameter pack.
  inline std::pair<unsigned, unsigned>
  getDepthAndIndex(UnexpandedParameterPack UPP) {
    if (const auto *TTP = UPP.first.dyn_cast<const TemplateTypeParmType *>())
      return std::make_pair(TTP->getDepth(), TTP->getIndex());
  
    return getDepthAndIndex(UPP.first.get<NamedDecl *>());
  }
  
  class TypoCorrectionConsumer : public VisibleDeclConsumer {
    typedef SmallVector<TypoCorrection, 1> TypoResultList;
    typedef llvm::StringMap<TypoResultList> TypoResultsMap;
    typedef std::map<unsigned, TypoResultsMap> TypoEditDistanceMap;
  
  public:
    TypoCorrectionConsumer(Sema &SemaRef,
                           const DeclarationNameInfo &TypoName,
                           Sema::LookupNameKind LookupKind,
                           Scope *S, CXXScopeSpec *SS,
                           std::unique_ptr<CorrectionCandidateCallback> CCC,
                           DeclContext *MemberContext,
                           bool EnteringContext)
        : Typo(TypoName.getName().getAsIdentifierInfo()), CurrentTCIndex(0),
          SavedTCIndex(0), SemaRef(SemaRef), S(S),
          SS(SS ? std::make_unique<CXXScopeSpec>(*SS) : nullptr),
          CorrectionValidator(std::move(CCC)), MemberContext(MemberContext),
          Result(SemaRef, TypoName, LookupKind),
          Namespaces(SemaRef.Context, SemaRef.CurContext, SS),
          EnteringContext(EnteringContext), SearchNamespaces(false) {
      Result.suppressDiagnostics();
      // Arrange for ValidatedCorrections[0] to always be an empty correction.
      ValidatedCorrections.push_back(TypoCorrection());
    }
  
    bool includeHiddenDecls() const override { return true; }
  
    // Methods for adding potential corrections to the consumer.
    void FoundDecl(NamedDecl *ND, NamedDecl *Hiding, DeclContext *Ctx,
                   bool InBaseClass) override;
    void FoundName(StringRef Name);
    void addKeywordResult(StringRef Keyword);
    void addCorrection(TypoCorrection Correction);
  
    bool empty() const {
      return CorrectionResults.empty() && ValidatedCorrections.size() == 1;
    }
  
    /// Return the list of TypoCorrections for the given identifier from
    /// the set of corrections that have the closest edit distance, if any.
    TypoResultList &operator[](StringRef Name) {
      return CorrectionResults.begin()->second[Name];
    }
  
    /// Return the edit distance of the corrections that have the
    /// closest/best edit distance from the original typop.
    unsigned getBestEditDistance(bool Normalized) {
      if (CorrectionResults.empty())
        return (std::numeric_limits<unsigned>::max)();
  
      unsigned BestED = CorrectionResults.begin()->first;
      return Normalized ? TypoCorrection::NormalizeEditDistance(BestED) : BestED;
    }
  
    /// Set-up method to add to the consumer the set of namespaces to use
    /// in performing corrections to nested name specifiers. This method also
    /// implicitly adds all of the known classes in the current AST context to the
    /// to the consumer for correcting nested name specifiers.
    void
    addNamespaces(const llvm::MapVector<NamespaceDecl *, bool> &KnownNamespaces);
  
    /// Return the next typo correction that passes all internal filters
    /// and is deemed valid by the consumer's CorrectionCandidateCallback,
    /// starting with the corrections that have the closest edit distance. An
    /// empty TypoCorrection is returned once no more viable corrections remain
    /// in the consumer.
    const TypoCorrection &getNextCorrection();
  
    /// Get the last correction returned by getNextCorrection().
    const TypoCorrection &getCurrentCorrection() {
      return CurrentTCIndex < ValidatedCorrections.size()
                 ? ValidatedCorrections[CurrentTCIndex]
                 : ValidatedCorrections[0];  // The empty correction.
    }
  
    /// Return the next typo correction like getNextCorrection, but keep
    /// the internal state pointed to the current correction (i.e. the next time
    /// getNextCorrection is called, it will return the same correction returned
    /// by peekNextcorrection).
    const TypoCorrection &peekNextCorrection() {
      auto Current = CurrentTCIndex;
      const TypoCorrection &TC = getNextCorrection();
      CurrentTCIndex = Current;
      return TC;
    }
  
    /// Reset the consumer's position in the stream of viable corrections
    /// (i.e. getNextCorrection() will return each of the previously returned
    /// corrections in order before returning any new corrections).
    void resetCorrectionStream() {
      CurrentTCIndex = 0;
    }
  
    /// Return whether the end of the stream of corrections has been
    /// reached.
    bool finished() {
      return CorrectionResults.empty() &&
             CurrentTCIndex >= ValidatedCorrections.size();
    }
  
    /// Save the current position in the correction stream (overwriting any
    /// previously saved position).
    void saveCurrentPosition() {
      SavedTCIndex = CurrentTCIndex;
    }
  
    /// Restore the saved position in the correction stream.
    void restoreSavedPosition() {
      CurrentTCIndex = SavedTCIndex;
    }
  
    ASTContext &getContext() const { return SemaRef.Context; }
    const LookupResult &getLookupResult() const { return Result; }
  
    bool isAddressOfOperand() const { return CorrectionValidator->IsAddressOfOperand; }
    const CXXScopeSpec *getSS() const { return SS.get(); }
    Scope *getScope() const { return S; }
    CorrectionCandidateCallback *getCorrectionValidator() const {
      return CorrectionValidator.get();
    }
  
  private:
    class NamespaceSpecifierSet {
      struct SpecifierInfo {
        DeclContext* DeclCtx;
        NestedNameSpecifier* NameSpecifier;
        unsigned EditDistance;
      };
  
      typedef SmallVector<DeclContext*, 4> DeclContextList;
      typedef SmallVector<SpecifierInfo, 16> SpecifierInfoList;
  
      ASTContext &Context;
      DeclContextList CurContextChain;
      std::string CurNameSpecifier;
      SmallVector<const IdentifierInfo*, 4> CurContextIdentifiers;
      SmallVector<const IdentifierInfo*, 4> CurNameSpecifierIdentifiers;
  
      std::map<unsigned, SpecifierInfoList> DistanceMap;
  
      /// Helper for building the list of DeclContexts between the current
      /// context and the top of the translation unit
      static DeclContextList buildContextChain(DeclContext *Start);
  
      unsigned buildNestedNameSpecifier(DeclContextList &DeclChain,
                                        NestedNameSpecifier *&NNS);
  
     public:
      NamespaceSpecifierSet(ASTContext &Context, DeclContext *CurContext,
                            CXXScopeSpec *CurScopeSpec);
  
      /// Add the DeclContext (a namespace or record) to the set, computing
      /// the corresponding NestedNameSpecifier and its distance in the process.
      void addNameSpecifier(DeclContext *Ctx);
  
      /// Provides flat iteration over specifiers, sorted by distance.
      class iterator
          : public llvm::iterator_facade_base<iterator, std::forward_iterator_tag,
                                              SpecifierInfo> {
        /// Always points to the last element in the distance map.
        const std::map<unsigned, SpecifierInfoList>::iterator OuterBack;
        /// Iterator on the distance map.
        std::map<unsigned, SpecifierInfoList>::iterator Outer;
        /// Iterator on an element in the distance map.
        SpecifierInfoList::iterator Inner;
  
      public:
        iterator(NamespaceSpecifierSet &Set, bool IsAtEnd)
            : OuterBack(std::prev(Set.DistanceMap.end())),
              Outer(Set.DistanceMap.begin()),
              Inner(!IsAtEnd ? Outer->second.begin() : OuterBack->second.end()) {
          assert(!Set.DistanceMap.empty());
        }
  
        iterator &operator++() {
          ++Inner;
          if (Inner == Outer->second.end() && Outer != OuterBack) {
            ++Outer;
            Inner = Outer->second.begin();
          }
          return *this;
        }
  
        SpecifierInfo &operator*() { return *Inner; }
        bool operator==(const iterator &RHS) const { return Inner == RHS.Inner; }
      };
  
      iterator begin() { return iterator(*this, /*IsAtEnd=*/false); }
      iterator end() { return iterator(*this, /*IsAtEnd=*/true); }
    };
  
    void addName(StringRef Name, NamedDecl *ND,
                 NestedNameSpecifier *NNS = nullptr, bool isKeyword = false);
  
    /// Find any visible decls for the given typo correction candidate.
    /// If none are found, it to the set of candidates for which qualified lookups
    /// will be performed to find possible nested name specifier changes.
    bool resolveCorrection(TypoCorrection &Candidate);
  
    /// Perform qualified lookups on the queued set of typo correction
    /// candidates and add the nested name specifier changes to each candidate if
    /// a lookup succeeds (at which point the candidate will be returned to the
    /// main pool of potential corrections).
    void performQualifiedLookups();
  
    /// The name written that is a typo in the source.
    IdentifierInfo *Typo;
  
    /// The results found that have the smallest edit distance
    /// found (so far) with the typo name.
    ///
    /// The pointer value being set to the current DeclContext indicates
    /// whether there is a keyword with this name.
    TypoEditDistanceMap CorrectionResults;
  
    SmallVector<TypoCorrection, 4> ValidatedCorrections;
    size_t CurrentTCIndex;
    size_t SavedTCIndex;
  
    Sema &SemaRef;
    Scope *S;
    std::unique_ptr<CXXScopeSpec> SS;
    std::unique_ptr<CorrectionCandidateCallback> CorrectionValidator;
    DeclContext *MemberContext;
    LookupResult Result;
    NamespaceSpecifierSet Namespaces;
    SmallVector<TypoCorrection, 2> QualifiedResults;
    bool EnteringContext;
    bool SearchNamespaces;
  };
  
  inline Sema::TypoExprState::TypoExprState() {}
  
  inline Sema::TypoExprState::TypoExprState(TypoExprState &&other) noexcept {
    *this = std::move(other);
  }
  
  inline Sema::TypoExprState &Sema::TypoExprState::
  operator=(Sema::TypoExprState &&other) noexcept {
    Consumer = std::move(other.Consumer);
    DiagHandler = std::move(other.DiagHandler);
    RecoveryHandler = std::move(other.RecoveryHandler);
    return *this;
  }
  
  } // end namespace clang
  
  #endif
  