Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

//===- Diagnostic.h - C Language Family Diagnostic Handling -----*- 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

//

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

//

/// \file

/// Defines the Diagnostic-related interfaces.

//

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

#ifndef LLVM_CLANG_BASIC_DIAGNOSTIC_H

#define LLVM_CLANG_BASIC_DIAGNOSTIC_H

#include "clang/Basic/DiagnosticIDs.h"

#include "clang/Basic/DiagnosticOptions.h"

#include "clang/Basic/SourceLocation.h"

#include "clang/Basic/Specifiers.h"

#include "llvm/ADT/ArrayRef.h"

#include "llvm/ADT/DenseMap.h"

#include "llvm/ADT/IntrusiveRefCntPtr.h"

#include "llvm/ADT/SmallVector.h"

#include "llvm/ADT/StringRef.h"

#include "llvm/ADT/iterator_range.h"

#include "llvm/Support/Compiler.h"

#include <cassert>

#include <cstdint>

#include <limits>

#include <list>

#include <map>

#include <memory>

#include <optional>

#include <string>

#include <type_traits>

#include <utility>

#include <vector>

namespace llvm {

class Error;

class raw_ostream;

} // namespace llvm

namespace clang {

class DeclContext;

class DiagnosticBuilder;

class DiagnosticConsumer;

class IdentifierInfo;

class LangOptions;

class Preprocessor;

class SourceManager;

class StoredDiagnostic;

namespace tok {

enum TokenKind : unsigned short;

} // namespace tok

/// Annotates a diagnostic with some code that should be

/// inserted, removed, or replaced to fix the problem.

///

/// This kind of hint should be used when we are certain that the

/// introduction, removal, or modification of a particular (small!)

/// amount of code will correct a compilation error. The compiler

/// should also provide full recovery from such errors, such that

/// suppressing the diagnostic output can still result in successful

/// compilation.

class FixItHint {

public:

  /// Code that should be replaced to correct the error. Empty for an

  /// insertion hint.

  CharSourceRange RemoveRange;

  /// Code in the specific range that should be inserted in the insertion

  /// location.

  CharSourceRange InsertFromRange;

  /// The actual code to insert at the insertion location, as a

  /// string.

  std::string CodeToInsert;

  bool BeforePreviousInsertions = false;

  /// Empty code modification hint, indicating that no code

  /// modification is known.

  FixItHint() = default;

  bool isNull() const {

    return !RemoveRange.isValid();

  }

  /// Create a code modification hint that inserts the given

  /// code string at a specific location.

  static FixItHint CreateInsertion(SourceLocation InsertionLoc,

                                   StringRef Code,

                                   bool BeforePreviousInsertions = false) {

    FixItHint Hint;

    Hint.RemoveRange =

      CharSourceRange::getCharRange(InsertionLoc, InsertionLoc);

    Hint.CodeToInsert = std::string(Code);

    Hint.BeforePreviousInsertions = BeforePreviousInsertions;

    return Hint;

  }

  /// Create a code modification hint that inserts the given

  /// code from \p FromRange at a specific location.

  static FixItHint CreateInsertionFromRange(SourceLocation InsertionLoc,

                                            CharSourceRange FromRange,

                                        bool BeforePreviousInsertions = false) {

    FixItHint Hint;

    Hint.RemoveRange =

      CharSourceRange::getCharRange(InsertionLoc, InsertionLoc);

    Hint.InsertFromRange = FromRange;

    Hint.BeforePreviousInsertions = BeforePreviousInsertions;

    return Hint;

  }

  /// Create a code modification hint that removes the given

  /// source range.

  static FixItHint CreateRemoval(CharSourceRange RemoveRange) {

    FixItHint Hint;

    Hint.RemoveRange = RemoveRange;

    return Hint;

  }

  static FixItHint CreateRemoval(SourceRange RemoveRange) {

    return CreateRemoval(CharSourceRange::getTokenRange(RemoveRange));

  }

  /// Create a code modification hint that replaces the given

  /// source range with the given code string.

  static FixItHint CreateReplacement(CharSourceRange RemoveRange,

                                     StringRef Code) {

    FixItHint Hint;

    Hint.RemoveRange = RemoveRange;

    Hint.CodeToInsert = std::string(Code);

    return Hint;

  }

  static FixItHint CreateReplacement(SourceRange RemoveRange,

                                     StringRef Code) {

    return CreateReplacement(CharSourceRange::getTokenRange(RemoveRange), Code);

  }

};

struct DiagnosticStorage {

  enum {

    /// The maximum number of arguments we can hold. We

    /// currently only support up to 10 arguments (%0-%9).

    ///

    /// A single diagnostic with more than that almost certainly has to

    /// be simplified anyway.

    MaxArguments = 10

  };

  /// The number of entries in Arguments.

  unsigned char NumDiagArgs = 0;

  /// Specifies for each argument whether it is in DiagArgumentsStr

  /// or in DiagArguments.

  unsigned char DiagArgumentsKind[MaxArguments];

  /// The values for the various substitution positions.

  ///

  /// This is used when the argument is not an std::string. The specific value

  /// is mangled into an uint64_t and the interpretation depends on exactly

  /// what sort of argument kind it is.

  uint64_t DiagArgumentsVal[MaxArguments];

  /// The values for the various substitution positions that have

  /// string arguments.

  std::string DiagArgumentsStr[MaxArguments];

  /// The list of ranges added to this diagnostic.

  SmallVector<CharSourceRange, 8> DiagRanges;

  /// If valid, provides a hint with some code to insert, remove, or

  /// modify at a particular position.

  SmallVector<FixItHint, 6> FixItHints;

  DiagnosticStorage() = default;

};

/// Concrete class used by the front-end to report problems and issues.

///

/// This massages the diagnostics (e.g. handling things like "report warnings

/// as errors" and passes them off to the DiagnosticConsumer for reporting to

/// the user. DiagnosticsEngine is tied to one translation unit and one

/// SourceManager.

class DiagnosticsEngine : public RefCountedBase<DiagnosticsEngine> {

public:

  /// The level of the diagnostic, after it has been through mapping.

  enum Level {

    Ignored = DiagnosticIDs::Ignored,

    Note = DiagnosticIDs::Note,

    Remark = DiagnosticIDs::Remark,

    Warning = DiagnosticIDs::Warning,

    Error = DiagnosticIDs::Error,

    Fatal = DiagnosticIDs::Fatal

  };

  enum ArgumentKind {

    /// std::string

    ak_std_string,

    /// const char *

    ak_c_string,

    /// int

    ak_sint,

    /// unsigned

    ak_uint,

    /// enum TokenKind : unsigned

    ak_tokenkind,

    /// IdentifierInfo

    ak_identifierinfo,

    /// address space

    ak_addrspace,

    /// Qualifiers

    ak_qual,

    /// QualType

    ak_qualtype,

    /// DeclarationName

    ak_declarationname,

    /// NamedDecl *

    ak_nameddecl,

    /// NestedNameSpecifier *

    ak_nestednamespec,

    /// DeclContext *

    ak_declcontext,

    /// pair<QualType, QualType>

    ak_qualtype_pair,

    /// Attr *

    ak_attr

  };

  /// Represents on argument value, which is a union discriminated

  /// by ArgumentKind, with a value.

  using ArgumentValue = std::pair<ArgumentKind, intptr_t>;

private:

  // Used by __extension__

  unsigned char AllExtensionsSilenced = 0;

  // Treat fatal errors like errors.

  bool FatalsAsError = false;

  // Suppress all diagnostics.

  bool SuppressAllDiagnostics = false;

  // Elide common types of templates.

  bool ElideType = true;

  // Print a tree when comparing templates.

  bool PrintTemplateTree = false;

  // Color printing is enabled.

  bool ShowColors = false;

  // Which overload candidates to show.

  OverloadsShown ShowOverloads = Ovl_All;

  // With Ovl_Best, the number of overload candidates to show when we encounter

  // an error.

  //

  // The value here is the number of candidates to show in the first nontrivial

  // error.  Future errors may show a different number of candidates.

  unsigned NumOverloadsToShow = 32;

  // Cap of # errors emitted, 0 -> no limit.

  unsigned ErrorLimit = 0;

  // Cap on depth of template backtrace stack, 0 -> no limit.

  unsigned TemplateBacktraceLimit = 0;

  // Cap on depth of constexpr evaluation backtrace stack, 0 -> no limit.

  unsigned ConstexprBacktraceLimit = 0;

  IntrusiveRefCntPtr<DiagnosticIDs> Diags;

  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;

  DiagnosticConsumer *Client = nullptr;

  std::unique_ptr<DiagnosticConsumer> Owner;

  SourceManager *SourceMgr = nullptr;

  /// Mapping information for diagnostics.

  ///

  /// Mapping info is packed into four bits per diagnostic.  The low three

  /// bits are the mapping (an instance of diag::Severity), or zero if unset.

  /// The high bit is set when the mapping was established as a user mapping.

  /// If the high bit is clear, then the low bits are set to the default

  /// value, and should be mapped with -pedantic, -Werror, etc.

  ///

  /// A new DiagState is created and kept around when diagnostic pragmas modify

  /// the state so that we know what is the diagnostic state at any given

  /// source location.

  class DiagState {

    llvm::DenseMap<unsigned, DiagnosticMapping> DiagMap;

  public:

    // "Global" configuration state that can actually vary between modules.

    // Ignore all warnings: -w

    unsigned IgnoreAllWarnings : 1;

    // Enable all warnings.

    unsigned EnableAllWarnings : 1;

    // Treat warnings like errors.

    unsigned WarningsAsErrors : 1;

    // Treat errors like fatal errors.

    unsigned ErrorsAsFatal : 1;

    // Suppress warnings in system headers.

    unsigned SuppressSystemWarnings : 1;

    // Map extensions to warnings or errors?

    diag::Severity ExtBehavior = diag::Severity::Ignored;

    DiagState()

        : IgnoreAllWarnings(false), EnableAllWarnings(false),

          WarningsAsErrors(false), ErrorsAsFatal(false),

          SuppressSystemWarnings(false) {}

    using iterator = llvm::DenseMap<unsigned, DiagnosticMapping>::iterator;

    using const_iterator =

        llvm::DenseMap<unsigned, DiagnosticMapping>::const_iterator;

    void setMapping(diag::kind Diag, DiagnosticMapping Info) {

      DiagMap[Diag] = Info;

    }

    DiagnosticMapping lookupMapping(diag::kind Diag) const {

      return DiagMap.lookup(Diag);

    }

    DiagnosticMapping &getOrAddMapping(diag::kind Diag);

    const_iterator begin() const { return DiagMap.begin(); }

    const_iterator end() const { return DiagMap.end(); }

  };

  /// Keeps and automatically disposes all DiagStates that we create.

  std::list<DiagState> DiagStates;

  /// A mapping from files to the diagnostic states for those files. Lazily

  /// built on demand for files in which the diagnostic state has not changed.

  class DiagStateMap {

  public:

    /// Add an initial diagnostic state.

    void appendFirst(DiagState *State);

    /// Add a new latest state point.

    void append(SourceManager &SrcMgr, SourceLocation Loc, DiagState *State);

    /// Look up the diagnostic state at a given source location.

    DiagState *lookup(SourceManager &SrcMgr, SourceLocation Loc) const;

    /// Determine whether this map is empty.

    bool empty() const { return Files.empty(); }

    /// Clear out this map.

    void clear() {

      Files.clear();

      FirstDiagState = CurDiagState = nullptr;

      CurDiagStateLoc = SourceLocation();

    }

    /// Produce a debugging dump of the diagnostic state.

    LLVM_DUMP_METHOD void dump(SourceManager &SrcMgr,

                               StringRef DiagName = StringRef()) const;

    /// Grab the most-recently-added state point.

    DiagState *getCurDiagState() const { return CurDiagState; }

    /// Get the location at which a diagnostic state was last added.

    SourceLocation getCurDiagStateLoc() const { return CurDiagStateLoc; }

  private:

    friend class ASTReader;

    friend class ASTWriter;

    /// Represents a point in source where the diagnostic state was

    /// modified because of a pragma.

    ///

    /// 'Loc' can be null if the point represents the diagnostic state

    /// modifications done through the command-line.

    struct DiagStatePoint {

      DiagState *State;

      unsigned Offset;

      DiagStatePoint(DiagState *State, unsigned Offset)

          : State(State), Offset(Offset) {}

    };

    /// Description of the diagnostic states and state transitions for a

    /// particular FileID.

    struct File {

      /// The diagnostic state for the parent file. This is strictly redundant,

      /// as looking up the DecomposedIncludedLoc for the FileID in the Files

      /// map would give us this, but we cache it here for performance.

      File *Parent = nullptr;

      /// The offset of this file within its parent.

      unsigned ParentOffset = 0;

      /// Whether this file has any local (not imported from an AST file)

      /// diagnostic state transitions.

      bool HasLocalTransitions = false;

      /// The points within the file where the state changes. There will always

      /// be at least one of these (the state on entry to the file).

      llvm::SmallVector<DiagStatePoint, 4> StateTransitions;

      DiagState *lookup(unsigned Offset) const;

    };

    /// The diagnostic states for each file.

    mutable std::map<FileID, File> Files;

    /// The initial diagnostic state.

    DiagState *FirstDiagState;

    /// The current diagnostic state.

    DiagState *CurDiagState;

    /// The location at which the current diagnostic state was established.

    SourceLocation CurDiagStateLoc;

    /// Get the diagnostic state information for a file.

    File *getFile(SourceManager &SrcMgr, FileID ID) const;

  };

  DiagStateMap DiagStatesByLoc;

  /// Keeps the DiagState that was active during each diagnostic 'push'

  /// so we can get back at it when we 'pop'.

  std::vector<DiagState *> DiagStateOnPushStack;

  DiagState *GetCurDiagState() const {

    return DiagStatesByLoc.getCurDiagState();

  }

  void PushDiagStatePoint(DiagState *State, SourceLocation L);

  /// Finds the DiagStatePoint that contains the diagnostic state of

  /// the given source location.

  DiagState *GetDiagStateForLoc(SourceLocation Loc) const {

    return SourceMgr ? DiagStatesByLoc.lookup(*SourceMgr, Loc)

                     : DiagStatesByLoc.getCurDiagState();

  }

  /// Sticky flag set to \c true when an error is emitted.

  bool ErrorOccurred;

  /// Sticky flag set to \c true when an "uncompilable error" occurs.

  /// I.e. an error that was not upgraded from a warning by -Werror.

  bool UncompilableErrorOccurred;

  /// Sticky flag set to \c true when a fatal error is emitted.

  bool FatalErrorOccurred;

  /// Indicates that an unrecoverable error has occurred.

  bool UnrecoverableErrorOccurred;

  /// Counts for DiagnosticErrorTrap to check whether an error occurred

  /// during a parsing section, e.g. during parsing a function.

  unsigned TrapNumErrorsOccurred;

  unsigned TrapNumUnrecoverableErrorsOccurred;

  /// The level of the last diagnostic emitted.

  ///

  /// This is used to emit continuation diagnostics with the same level as the

  /// diagnostic that they follow.

  DiagnosticIDs::Level LastDiagLevel;

  /// Number of warnings reported

  unsigned NumWarnings;

  /// Number of errors reported

  unsigned NumErrors;

  /// A function pointer that converts an opaque diagnostic

  /// argument to a strings.

  ///

  /// This takes the modifiers and argument that was present in the diagnostic.

  ///

  /// The PrevArgs array indicates the previous arguments formatted for this

  /// diagnostic.  Implementations of this function can use this information to

  /// avoid redundancy across arguments.

  ///

  /// This is a hack to avoid a layering violation between libbasic and libsema.

  using ArgToStringFnTy = void (*)(

      ArgumentKind Kind, intptr_t Val,

      StringRef Modifier, StringRef Argument,

      ArrayRef<ArgumentValue> PrevArgs,

      SmallVectorImpl<char> &Output,

      void *Cookie,

      ArrayRef<intptr_t> QualTypeVals);

  void *ArgToStringCookie = nullptr;

  ArgToStringFnTy ArgToStringFn;

  /// ID of the "delayed" diagnostic, which is a (typically

  /// fatal) diagnostic that had to be delayed because it was found

  /// while emitting another diagnostic.

  unsigned DelayedDiagID;

  /// First string argument for the delayed diagnostic.

  std::string DelayedDiagArg1;

  /// Second string argument for the delayed diagnostic.

  std::string DelayedDiagArg2;

  /// Third string argument for the delayed diagnostic.

  std::string DelayedDiagArg3;

  /// Optional flag value.

  ///

  /// Some flags accept values, for instance: -Wframe-larger-than=<value> and

  /// -Rpass=<value>. The content of this string is emitted after the flag name

  /// and '='.

  std::string FlagValue;

public:

  explicit DiagnosticsEngine(IntrusiveRefCntPtr<DiagnosticIDs> Diags,

                             IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,

                             DiagnosticConsumer *client = nullptr,

                             bool ShouldOwnClient = true);

  DiagnosticsEngine(const DiagnosticsEngine &) = delete;

  DiagnosticsEngine &operator=(const DiagnosticsEngine &) = delete;

  ~DiagnosticsEngine();

  friend void DiagnosticsTestHelper(DiagnosticsEngine &);

  LLVM_DUMP_METHOD void dump() const;

  LLVM_DUMP_METHOD void dump(StringRef DiagName) const;

  const IntrusiveRefCntPtr<DiagnosticIDs> &getDiagnosticIDs() const {

    return Diags;

  }

  /// Retrieve the diagnostic options.

  DiagnosticOptions &getDiagnosticOptions() const { return *DiagOpts; }

  using diag_mapping_range = llvm::iterator_range<DiagState::const_iterator>;

  /// Get the current set of diagnostic mappings.

  diag_mapping_range getDiagnosticMappings() const {

    const DiagState &DS = *GetCurDiagState();

    return diag_mapping_range(DS.begin(), DS.end());

  }

  DiagnosticConsumer *getClient() { return Client; }

  const DiagnosticConsumer *getClient() const { return Client; }

  /// Determine whether this \c DiagnosticsEngine object own its client.

  bool ownsClient() const { return Owner != nullptr; }

  /// Return the current diagnostic client along with ownership of that

  /// client.

  std::unique_ptr<DiagnosticConsumer> takeClient() { return std::move(Owner); }

  bool hasSourceManager() const { return SourceMgr != nullptr; }

  SourceManager &getSourceManager() const {

    assert(SourceMgr && "SourceManager not set!");

    return *SourceMgr;

  }

  void setSourceManager(SourceManager *SrcMgr) {

    assert(DiagStatesByLoc.empty() &&

           "Leftover diag state from a different SourceManager.");

    SourceMgr = SrcMgr;

  }

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

  //  DiagnosticsEngine characterization methods, used by a client to customize

  //  how diagnostics are emitted.

  //

  /// Copies the current DiagMappings and pushes the new copy

  /// onto the top of the stack.

  void pushMappings(SourceLocation Loc);

  /// Pops the current DiagMappings off the top of the stack,

  /// causing the new top of the stack to be the active mappings.

  ///

  /// \returns \c true if the pop happens, \c false if there is only one

  /// DiagMapping on the stack.

  bool popMappings(SourceLocation Loc);

  /// Set the diagnostic client associated with this diagnostic object.

  ///

  /// \param ShouldOwnClient true if the diagnostic object should take

  /// ownership of \c client.

  void setClient(DiagnosticConsumer *client, bool ShouldOwnClient = true);

  /// Specify a limit for the number of errors we should

  /// emit before giving up.

  ///

  /// Zero disables the limit.

  void setErrorLimit(unsigned Limit) { ErrorLimit = Limit; }

  /// Specify the maximum number of template instantiation

  /// notes to emit along with a given diagnostic.

  void setTemplateBacktraceLimit(unsigned Limit) {

    TemplateBacktraceLimit = Limit;

  }

  /// Retrieve the maximum number of template instantiation

  /// notes to emit along with a given diagnostic.

  unsigned getTemplateBacktraceLimit() const {

    return TemplateBacktraceLimit;

  }

  /// Specify the maximum number of constexpr evaluation

  /// notes to emit along with a given diagnostic.

  void setConstexprBacktraceLimit(unsigned Limit) {

    ConstexprBacktraceLimit = Limit;

  }

  /// Retrieve the maximum number of constexpr evaluation

  /// notes to emit along with a given diagnostic.

  unsigned getConstexprBacktraceLimit() const {

    return ConstexprBacktraceLimit;

  }

  /// When set to true, any unmapped warnings are ignored.

  ///

  /// If this and WarningsAsErrors are both set, then this one wins.

  void setIgnoreAllWarnings(bool Val) {

    GetCurDiagState()->IgnoreAllWarnings = Val;

  }

  bool getIgnoreAllWarnings() const {

    return GetCurDiagState()->IgnoreAllWarnings;

  }

  /// When set to true, any unmapped ignored warnings are no longer

  /// ignored.

  ///

  /// If this and IgnoreAllWarnings are both set, then that one wins.

  void setEnableAllWarnings(bool Val) {

    GetCurDiagState()->EnableAllWarnings = Val;

  }

  bool getEnableAllWarnings() const {

    return GetCurDiagState()->EnableAllWarnings;

  }

  /// When set to true, any warnings reported are issued as errors.

  void setWarningsAsErrors(bool Val) {

    GetCurDiagState()->WarningsAsErrors = Val;

  }

  bool getWarningsAsErrors() const {

    return GetCurDiagState()->WarningsAsErrors;

  }

  /// When set to true, any error reported is made a fatal error.

  void setErrorsAsFatal(bool Val) { GetCurDiagState()->ErrorsAsFatal = Val; }

  bool getErrorsAsFatal() const { return GetCurDiagState()->ErrorsAsFatal; }

  /// \brief When set to true, any fatal error reported is made an error.

  ///

  /// This setting takes precedence over the setErrorsAsFatal setting above.

  void setFatalsAsError(bool Val) { FatalsAsError = Val; }

  bool getFatalsAsError() const { return FatalsAsError; }

  /// When set to true mask warnings that come from system headers.

  void setSuppressSystemWarnings(bool Val) {

    GetCurDiagState()->SuppressSystemWarnings = Val;

  }

  bool getSuppressSystemWarnings() const {

    return GetCurDiagState()->SuppressSystemWarnings;

  }

  /// Suppress all diagnostics, to silence the front end when we

  /// know that we don't want any more diagnostics to be passed along to the

  /// client

  void setSuppressAllDiagnostics(bool Val) { SuppressAllDiagnostics = Val; }

  bool getSuppressAllDiagnostics() const { return SuppressAllDiagnostics; }

  /// Set type eliding, to skip outputting same types occurring in

  /// template types.

  void setElideType(bool Val) { ElideType = Val; }

  bool getElideType() { return ElideType; }

  /// Set tree printing, to outputting the template difference in a

  /// tree format.

  void setPrintTemplateTree(bool Val) { PrintTemplateTree = Val; }

  bool getPrintTemplateTree() { return PrintTemplateTree; }

  /// Set color printing, so the type diffing will inject color markers

  /// into the output.

  void setShowColors(bool Val) { ShowColors = Val; }

  bool getShowColors() { return ShowColors; }

  /// Specify which overload candidates to show when overload resolution

  /// fails.

  ///

  /// By default, we show all candidates.

  void setShowOverloads(OverloadsShown Val) {

    ShowOverloads = Val;

  }

  OverloadsShown getShowOverloads() const { return ShowOverloads; }

  /// When a call or operator fails, print out up to this many candidate

  /// overloads as suggestions.

  ///

  /// With Ovl_Best, we set a high limit for the first nontrivial overload set

  /// we print, and a lower limit for later sets.  This way the user has a

  /// chance of diagnosing at least one callsite in their program without

  /// having to recompile with -fshow-overloads=all.

  unsigned getNumOverloadCandidatesToShow() const {

    switch (getShowOverloads()) {

    case Ovl_All:

      // INT_MAX rather than UINT_MAX so that we don't have to think about the

      // effect of implicit conversions on this value. In practice we'll never

      // hit 2^31 candidates anyway.

      return std::numeric_limits<int>::max();

    case Ovl_Best:

      return NumOverloadsToShow;

    }

    llvm_unreachable("invalid OverloadsShown kind");

  }

  /// Call this after showing N overload candidates.  This influences the value

  /// returned by later calls to getNumOverloadCandidatesToShow().

  void overloadCandidatesShown(unsigned N) {

    // Current heuristic: Start out with a large value for NumOverloadsToShow,

    // and then once we print one nontrivially-large overload set, decrease it

    // for future calls.

    if (N > 4) {

      NumOverloadsToShow = 4;

    }

  }

  /// Pretend that the last diagnostic issued was ignored, so any

  /// subsequent notes will be suppressed, or restore a prior ignoring

  /// state after ignoring some diagnostics and their notes, possibly in

  /// the middle of another diagnostic.

  ///

  /// This can be used by clients who suppress diagnostics themselves.

  void setLastDiagnosticIgnored(bool Ignored) {

    if (LastDiagLevel == DiagnosticIDs::Fatal)

      FatalErrorOccurred = true;

    LastDiagLevel = Ignored ? DiagnosticIDs::Ignored : DiagnosticIDs::Warning;

  }

  /// Determine whether the previous diagnostic was ignored. This can

  /// be used by clients that want to determine whether notes attached to a

  /// diagnostic will be suppressed.

  bool isLastDiagnosticIgnored() const {

    return LastDiagLevel == DiagnosticIDs::Ignored;

  }

  /// Controls whether otherwise-unmapped extension diagnostics are

  /// mapped onto ignore/warning/error.

  ///

  /// This corresponds to the GCC -pedantic and -pedantic-errors option.

  void setExtensionHandlingBehavior(diag::Severity H) {

    GetCurDiagState()->ExtBehavior = H;

  }

  diag::Severity getExtensionHandlingBehavior() const {

    return GetCurDiagState()->ExtBehavior;

  }

  /// Counter bumped when an __extension__  block is/ encountered.

  ///

  /// When non-zero, all extension diagnostics are entirely silenced, no

  /// matter how they are mapped.

  void IncrementAllExtensionsSilenced() { ++AllExtensionsSilenced; }

  void DecrementAllExtensionsSilenced() { --AllExtensionsSilenced; }

  bool hasAllExtensionsSilenced() { return AllExtensionsSilenced != 0; }

  /// This allows the client to specify that certain warnings are

  /// ignored.

  ///

  /// Notes can never be mapped, errors can only be mapped to fatal, and

  /// WARNINGs and EXTENSIONs can be mapped arbitrarily.

  ///

  /// \param Loc The source location that this change of diagnostic state should

  /// take affect. It can be null if we are setting the latest state.

  void setSeverity(diag::kind Diag, diag::Severity Map, SourceLocation Loc);

  /// Change an entire diagnostic group (e.g. "unknown-pragmas") to

  /// have the specified mapping.

  ///

  /// \returns true (and ignores the request) if "Group" was unknown, false

  /// otherwise.

  ///

  /// \param Flavor The flavor of group to affect. -Rfoo does not affect the

  /// state of the -Wfoo group and vice versa.

  ///

  /// \param Loc The source location that this change of diagnostic state should

  /// take affect. It can be null if we are setting the state from command-line.

  bool setSeverityForGroup(diag::Flavor Flavor, StringRef Group,

                           diag::Severity Map,

                           SourceLocation Loc = SourceLocation());

  bool setSeverityForGroup(diag::Flavor Flavor, diag::Group Group,

                           diag::Severity Map,

                           SourceLocation Loc = SourceLocation());

  /// Set the warning-as-error flag for the given diagnostic group.

  ///

  /// This function always only operates on the current diagnostic state.

  ///

  /// \returns True if the given group is unknown, false otherwise.

  bool setDiagnosticGroupWarningAsError(StringRef Group, bool Enabled);

  /// Set the error-as-fatal flag for the given diagnostic group.

  ///

  /// This function always only operates on the current diagnostic state.

  ///

  /// \returns True if the given group is unknown, false otherwise.

  bool setDiagnosticGroupErrorAsFatal(StringRef Group, bool Enabled);

  /// Add the specified mapping to all diagnostics of the specified

  /// flavor.

  ///

  /// Mainly to be used by -Wno-everything to disable all warnings but allow

  /// subsequent -W options to enable specific warnings.

  void setSeverityForAll(diag::Flavor Flavor, diag::Severity Map,

                         SourceLocation Loc = SourceLocation());

  bool hasErrorOccurred() const { return ErrorOccurred; }

  /// Errors that actually prevent compilation, not those that are

  /// upgraded from a warning by -Werror.

  bool hasUncompilableErrorOccurred() const {

    return UncompilableErrorOccurred;

  }

  bool hasFatalErrorOccurred() const { return FatalErrorOccurred; }

  /// Determine whether any kind of unrecoverable error has occurred.

  bool hasUnrecoverableErrorOccurred() const {

    return FatalErrorOccurred || UnrecoverableErrorOccurred;

  }

  unsigned getNumErrors() const { return NumErrors; }

  unsigned getNumWarnings() const { return NumWarnings; }

  void setNumWarnings(unsigned NumWarnings) {

    this->NumWarnings = NumWarnings;

  }

  /// Return an ID for a diagnostic with the specified format string and

  /// level.

  ///

  /// If this is the first request for this diagnostic, it is registered and

  /// created, otherwise the existing ID is returned.

  ///

  /// \param FormatString A fixed diagnostic format string that will be hashed

  /// and mapped to a unique DiagID.

  template <unsigned N>

  unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) {

    return Diags->getCustomDiagID((DiagnosticIDs::Level)L,

                                  StringRef(FormatString, N - 1));

  }

  /// Converts a diagnostic argument (as an intptr_t) into the string

  /// that represents it.

  void ConvertArgToString(ArgumentKind Kind, intptr_t Val,

                          StringRef Modifier, StringRef Argument,

                          ArrayRef<ArgumentValue> PrevArgs,