include/clang/Basic/DiagnosticIDs.h - platform/external/clang - Git at Google

 //===--- DiagnosticIDs.h - Diagnostic IDs Handling --------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the Diagnostic IDs-related interfaces.
 //
 //===----------------------------------------------------------------------===//

 #ifndef LLVM_CLANG_DIAGNOSTICIDS_H
 #define LLVM_CLANG_DIAGNOSTICIDS_H

 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/StringRef.h"
 #include "clang/Basic/LLVM.h"

 namespace llvm {
   template<typename T, unsigned> class SmallVector;
 }

 namespace clang {
   class DiagnosticsEngine;
   class SourceLocation;
   struct WarningOption;

   // Import the diagnostic enums themselves.
   namespace diag {
     // Start position for diagnostics.
     enum {
       DIAG_START_DRIVER        =                               300,
       DIAG_START_FRONTEND      = DIAG_START_DRIVER          +  100,
       DIAG_START_SERIALIZATION = DIAG_START_FRONTEND        +  100,
       DIAG_START_LEX           = DIAG_START_SERIALIZATION   +  120,
       DIAG_START_PARSE         = DIAG_START_LEX             +  300,
       DIAG_START_AST           = DIAG_START_PARSE           +  400,
       DIAG_START_SEMA          = DIAG_START_AST             +  100,
       DIAG_START_ANALYSIS      = DIAG_START_SEMA            + 3000,
       DIAG_UPPER_LIMIT         = DIAG_START_ANALYSIS        +  100
     };

     class CustomDiagInfo;

     /// diag::kind - All of the diagnostics that can be emitted by the frontend.
     typedef unsigned kind;

     // Get typedefs for common diagnostics.
     enum {
 #define DIAG(ENUM,FLAGS,DEFAULT_MAPPING,DESC,GROUP,\
              SFINAE,ACCESS,CATEGORY,NOWERROR,SHOWINSYSHEADER) ENUM,
 #include "clang/Basic/DiagnosticCommonKinds.inc"
       NUM_BUILTIN_COMMON_DIAGNOSTICS
 #undef DIAG
     };

     /// Enum values that allow the client to map NOTEs, WARNINGs, and EXTENSIONs
     /// to either MAP_IGNORE (nothing), MAP_WARNING (emit a warning), MAP_ERROR
     /// (emit as an error).  It allows clients to map errors to
     /// MAP_ERROR/MAP_DEFAULT or MAP_FATAL (stop emitting diagnostics after this
     /// one).
     enum Mapping {
       // NOTE: 0 means "uncomputed".
       MAP_IGNORE  = 1,     ///< Map this diagnostic to nothing, ignore it.
       MAP_WARNING = 2,     ///< Map this diagnostic to a warning.
       MAP_ERROR   = 3,     ///< Map this diagnostic to an error.
       MAP_FATAL   = 4      ///< Map this diagnostic to a fatal error.
     };
   }

 class DiagnosticMappingInfo {
   unsigned Mapping : 3;
   unsigned IsUser : 1;
   unsigned IsPragma : 1;
   unsigned HasShowInSystemHeader : 1;
   unsigned HasNoWarningAsError : 1;
   unsigned HasNoErrorAsFatal : 1;

 public:
   static DiagnosticMappingInfo Make(diag::Mapping Mapping, bool IsUser,
                                     bool IsPragma) {
     DiagnosticMappingInfo Result;
     Result.Mapping = Mapping;
     Result.IsUser = IsUser;
     Result.IsPragma = IsPragma;
     Result.HasShowInSystemHeader = 0;
     Result.HasNoWarningAsError = 0;
     Result.HasNoErrorAsFatal = 0;
     return Result;
   }

   diag::Mapping getMapping() const { return diag::Mapping(Mapping); }
   void setMapping(diag::Mapping Value) { Mapping = Value; }

   bool isUser() const { return IsUser; }
   bool isPragma() const { return IsPragma; }

   bool hasShowInSystemHeader() const { return HasShowInSystemHeader; }
   void setShowInSystemHeader(bool Value) { HasShowInSystemHeader = Value; }

   bool hasNoWarningAsError() const { return HasNoWarningAsError; }
   void setNoWarningAsError(bool Value) { HasNoWarningAsError = Value; }

   bool hasNoErrorAsFatal() const { return HasNoErrorAsFatal; }
   void setNoErrorAsFatal(bool Value) { HasNoErrorAsFatal = Value; }
 };

 /// \brief Used for handling and querying diagnostic IDs. Can be used and shared
 /// by multiple Diagnostics for multiple translation units.
 class DiagnosticIDs : public RefCountedBase<DiagnosticIDs> {
 public:
   /// Level - The level of the diagnostic, after it has been through mapping.
   enum Level {
     Ignored, Note, Warning, Error, Fatal
   };

 private:
   /// CustomDiagInfo - Information for uniquing and looking up custom diags.
   diag::CustomDiagInfo *CustomDiagInfo;

 public:
   DiagnosticIDs();
   ~DiagnosticIDs();

   /// getCustomDiagID - Return an ID for a diagnostic with the specified message
   /// and level.  If this is the first request for this diagnosic, it is
   /// registered and created, otherwise the existing ID is returned.
   unsigned getCustomDiagID(Level L, StringRef Message);

   //===--------------------------------------------------------------------===//
   // Diagnostic classification and reporting interfaces.
   //

   /// getDescription - Given a diagnostic ID, return a description of the
   /// issue.
   StringRef getDescription(unsigned DiagID) const;

   /// isBuiltinWarningOrExtension - Return true if the unmapped diagnostic level
   /// of the specified diagnostic ID is a Warning or Extension.  This only works
   /// on builtin diagnostics, not custom ones, and is not legal to call on
   /// NOTEs.
   static bool isBuiltinWarningOrExtension(unsigned DiagID);

   /// \brief Return true if the specified diagnostic is mapped to errors by
   /// default.
   static bool isDefaultMappingAsError(unsigned DiagID);

   /// \brief Determine whether the given built-in diagnostic ID is a
   /// Note.
   static bool isBuiltinNote(unsigned DiagID);

   /// isBuiltinExtensionDiag - Determine whether the given built-in diagnostic
   /// ID is for an extension of some sort.
   ///
   static bool isBuiltinExtensionDiag(unsigned DiagID) {
     bool ignored;
     return isBuiltinExtensionDiag(DiagID, ignored);
   }

   /// isBuiltinExtensionDiag - Determine whether the given built-in diagnostic
   /// ID is for an extension of some sort.  This also returns EnabledByDefault,
   /// which is set to indicate whether the diagnostic is ignored by default (in
   /// which case -pedantic enables it) or treated as a warning/error by default.
   ///
   static bool isBuiltinExtensionDiag(unsigned DiagID, bool &EnabledByDefault);


   /// getWarningOptionForDiag - Return the lowest-level warning option that
   /// enables the specified diagnostic.  If there is no -Wfoo flag that controls
   /// the diagnostic, this returns null.
   static StringRef getWarningOptionForDiag(unsigned DiagID);

   /// getCategoryNumberForDiag - Return the category number that a specified
   /// DiagID belongs to, or 0 if no category.
   static unsigned getCategoryNumberForDiag(unsigned DiagID);

   /// getNumberOfCategories - Return the number of categories
   static unsigned getNumberOfCategories();

   /// getCategoryNameFromID - Given a category ID, return the name of the
   /// category.
   static StringRef getCategoryNameFromID(unsigned CategoryID);

   /// isARCDiagnostic - Return true if a given diagnostic falls into an
   /// ARC diagnostic category;
   static bool isARCDiagnostic(unsigned DiagID);

   /// \brief Enumeration describing how the the emission of a diagnostic should
   /// be treated when it occurs during C++ template argument deduction.
   enum SFINAEResponse {
     /// \brief The diagnostic should not be reported, but it should cause
     /// template argument deduction to fail.
     ///
     /// The vast majority of errors that occur during template argument
     /// deduction fall into this category.
     SFINAE_SubstitutionFailure,

     /// \brief The diagnostic should be suppressed entirely.
     ///
     /// Warnings generally fall into this category.
     SFINAE_Suppress,

     /// \brief The diagnostic should be reported.
     ///
     /// The diagnostic should be reported. Various fatal errors (e.g.,
     /// template instantiation depth exceeded) fall into this category.
     SFINAE_Report,

     /// \brief The diagnostic is an access-control diagnostic, which will be
     /// substitution failures in some contexts and reported in others.
     SFINAE_AccessControl
   };

   /// \brief Determines whether the given built-in diagnostic ID is
   /// for an error that is suppressed if it occurs during C++ template
   /// argument deduction.
   ///
   /// When an error is suppressed due to SFINAE, the template argument
   /// deduction fails but no diagnostic is emitted. Certain classes of
   /// errors, such as those errors that involve C++ access control,
   /// are not SFINAE errors.
   static SFINAEResponse getDiagnosticSFINAEResponse(unsigned DiagID);

   /// \brief Get the set of all diagnostic IDs in the group with the given name.
   ///
   /// \param Diags [out] - On return, the diagnostics in the group.
   /// \returns True if the given group is unknown, false otherwise.
   bool getDiagnosticsInGroup(StringRef Group,
                              llvm::SmallVectorImpl<diag::kind> &Diags) const;

   /// \brief Get the set of all diagnostic IDs.
   void getAllDiagnostics(llvm::SmallVectorImpl<diag::kind> &Diags) const;

   /// \brief Get the warning option with the closest edit distance to the given
   /// group name.
   static StringRef getNearestWarningOption(StringRef Group);

 private:
   /// \brief Get the set of all diagnostic IDs in the given group.
   ///
   /// \param Diags [out] - On return, the diagnostics in the group.
   void getDiagnosticsInGroup(const WarningOption *Group,
                              llvm::SmallVectorImpl<diag::kind> &Diags) const;

   /// \brief Based on the way the client configured the DiagnosticsEngine
   /// object, classify the specified diagnostic ID into a Level, consumable by
   /// the DiagnosticClient.
   ///
   /// \param Loc The source location we are interested in finding out the
   /// diagnostic state. Can be null in order to query the latest state.
   DiagnosticIDs::Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc,
                                           const DiagnosticsEngine &Diag) const;

   /// getDiagnosticLevel - This is an internal implementation helper used when
   /// DiagClass is already known.
   DiagnosticIDs::Level getDiagnosticLevel(unsigned DiagID,
                                           unsigned DiagClass,
                                           SourceLocation Loc,
                                           const DiagnosticsEngine &Diag) const;

   /// ProcessDiag - This is the method used to report a diagnostic that is
   /// finally fully formed.
   ///
   /// \returns true if the diagnostic was emitted, false if it was
   /// suppressed.
   bool ProcessDiag(DiagnosticsEngine &Diag) const;

   /// \brief Whether the diagnostic may leave the AST in a state where some
   /// invariants can break.
   bool isUnrecoverable(unsigned DiagID) const;

   friend class DiagnosticsEngine;
 };

 }  // end namespace clang

 #endif
	//===--- DiagnosticIDs.h - Diagnostic IDs Handling --------------- C++ --===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//
	//
	// This file defines the Diagnostic IDs-related interfaces.
	//
	//===----------------------------------------------------------------------===//

	#ifndef LLVM_CLANG_DIAGNOSTICIDS_H
	#define LLVM_CLANG_DIAGNOSTICIDS_H

	#include "llvm/ADT/IntrusiveRefCntPtr.h"
	#include "llvm/ADT/StringRef.h"
	#include "clang/Basic/LLVM.h"

	namespace llvm {
	template<typename T, unsigned> class SmallVector;
	}

	namespace clang {
	class DiagnosticsEngine;
	class SourceLocation;
	struct WarningOption;

	// Import the diagnostic enums themselves.
	namespace diag {
	// Start position for diagnostics.
	enum {
	DIAG_START_DRIVER = 300,
	DIAG_START_FRONTEND = DIAG_START_DRIVER + 100,
	DIAG_START_SERIALIZATION = DIAG_START_FRONTEND + 100,
	DIAG_START_LEX = DIAG_START_SERIALIZATION + 120,
	DIAG_START_PARSE = DIAG_START_LEX + 300,
	DIAG_START_AST = DIAG_START_PARSE + 400,
	DIAG_START_SEMA = DIAG_START_AST + 100,
	DIAG_START_ANALYSIS = DIAG_START_SEMA + 3000,
	DIAG_UPPER_LIMIT = DIAG_START_ANALYSIS + 100
	};

	class CustomDiagInfo;

	/// diag::kind - All of the diagnostics that can be emitted by the frontend.
	typedef unsigned kind;

	// Get typedefs for common diagnostics.
	enum {
	#define DIAG(ENUM,FLAGS,DEFAULT_MAPPING,DESC,GROUP,\
	SFINAE,ACCESS,CATEGORY,NOWERROR,SHOWINSYSHEADER) ENUM,
	#include "clang/Basic/DiagnosticCommonKinds.inc"
	NUM_BUILTIN_COMMON_DIAGNOSTICS
	#undef DIAG
	};

	/// Enum values that allow the client to map NOTEs, WARNINGs, and EXTENSIONs
	/// to either MAP_IGNORE (nothing), MAP_WARNING (emit a warning), MAP_ERROR
	/// (emit as an error). It allows clients to map errors to
	/// MAP_ERROR/MAP_DEFAULT or MAP_FATAL (stop emitting diagnostics after this
	/// one).
	enum Mapping {
	// NOTE: 0 means "uncomputed".
	MAP_IGNORE = 1, ///< Map this diagnostic to nothing, ignore it.
	MAP_WARNING = 2, ///< Map this diagnostic to a warning.
	MAP_ERROR = 3, ///< Map this diagnostic to an error.
	MAP_FATAL = 4 ///< Map this diagnostic to a fatal error.
	};
	}

	class DiagnosticMappingInfo {
	unsigned Mapping : 3;
	unsigned IsUser : 1;
	unsigned IsPragma : 1;
	unsigned HasShowInSystemHeader : 1;
	unsigned HasNoWarningAsError : 1;
	unsigned HasNoErrorAsFatal : 1;

	public:
	static DiagnosticMappingInfo Make(diag::Mapping Mapping, bool IsUser,
	bool IsPragma) {
	DiagnosticMappingInfo Result;
	Result.Mapping = Mapping;
	Result.IsUser = IsUser;
	Result.IsPragma = IsPragma;
	Result.HasShowInSystemHeader = 0;
	Result.HasNoWarningAsError = 0;
	Result.HasNoErrorAsFatal = 0;
	return Result;
	}

	diag::Mapping getMapping() const { return diag::Mapping(Mapping); }
	void setMapping(diag::Mapping Value) { Mapping = Value; }

	bool isUser() const { return IsUser; }
	bool isPragma() const { return IsPragma; }

	bool hasShowInSystemHeader() const { return HasShowInSystemHeader; }
	void setShowInSystemHeader(bool Value) { HasShowInSystemHeader = Value; }

	bool hasNoWarningAsError() const { return HasNoWarningAsError; }
	void setNoWarningAsError(bool Value) { HasNoWarningAsError = Value; }

	bool hasNoErrorAsFatal() const { return HasNoErrorAsFatal; }
	void setNoErrorAsFatal(bool Value) { HasNoErrorAsFatal = Value; }
	};

	/// \brief Used for handling and querying diagnostic IDs. Can be used and shared
	/// by multiple Diagnostics for multiple translation units.
	class DiagnosticIDs : public RefCountedBase<DiagnosticIDs> {
	public:
	/// Level - The level of the diagnostic, after it has been through mapping.
	enum Level {
	Ignored, Note, Warning, Error, Fatal
	};

	private:
	/// CustomDiagInfo - Information for uniquing and looking up custom diags.
	diag::CustomDiagInfo *CustomDiagInfo;

	public:
	DiagnosticIDs();
	~DiagnosticIDs();

	/// getCustomDiagID - Return an ID for a diagnostic with the specified message
	/// and level. If this is the first request for this diagnosic, it is
	/// registered and created, otherwise the existing ID is returned.
	unsigned getCustomDiagID(Level L, StringRef Message);

	//===--------------------------------------------------------------------===//
	// Diagnostic classification and reporting interfaces.
	//

	/// getDescription - Given a diagnostic ID, return a description of the
	/// issue.
	StringRef getDescription(unsigned DiagID) const;

	/// isBuiltinWarningOrExtension - Return true if the unmapped diagnostic level
	/// of the specified diagnostic ID is a Warning or Extension. This only works
	/// on builtin diagnostics, not custom ones, and is not legal to call on
	/// NOTEs.
	static bool isBuiltinWarningOrExtension(unsigned DiagID);

	/// \brief Return true if the specified diagnostic is mapped to errors by
	/// default.
	static bool isDefaultMappingAsError(unsigned DiagID);

	/// \brief Determine whether the given built-in diagnostic ID is a
	/// Note.
	static bool isBuiltinNote(unsigned DiagID);

	/// isBuiltinExtensionDiag - Determine whether the given built-in diagnostic
	/// ID is for an extension of some sort.
	///
	static bool isBuiltinExtensionDiag(unsigned DiagID) {
	bool ignored;
	return isBuiltinExtensionDiag(DiagID, ignored);
	}

	/// isBuiltinExtensionDiag - Determine whether the given built-in diagnostic
	/// ID is for an extension of some sort. This also returns EnabledByDefault,
	/// which is set to indicate whether the diagnostic is ignored by default (in
	/// which case -pedantic enables it) or treated as a warning/error by default.
	///
	static bool isBuiltinExtensionDiag(unsigned DiagID, bool &EnabledByDefault);


	/// getWarningOptionForDiag - Return the lowest-level warning option that
	/// enables the specified diagnostic. If there is no -Wfoo flag that controls
	/// the diagnostic, this returns null.
	static StringRef getWarningOptionForDiag(unsigned DiagID);

	/// getCategoryNumberForDiag - Return the category number that a specified
	/// DiagID belongs to, or 0 if no category.
	static unsigned getCategoryNumberForDiag(unsigned DiagID);

	/// getNumberOfCategories - Return the number of categories
	static unsigned getNumberOfCategories();

	/// getCategoryNameFromID - Given a category ID, return the name of the
	/// category.
	static StringRef getCategoryNameFromID(unsigned CategoryID);

	/// isARCDiagnostic - Return true if a given diagnostic falls into an
	/// ARC diagnostic category;
	static bool isARCDiagnostic(unsigned DiagID);

	/// \brief Enumeration describing how the the emission of a diagnostic should
	/// be treated when it occurs during C++ template argument deduction.
	enum SFINAEResponse {
	/// \brief The diagnostic should not be reported, but it should cause
	/// template argument deduction to fail.
	///
	/// The vast majority of errors that occur during template argument
	/// deduction fall into this category.
	SFINAE_SubstitutionFailure,

	/// \brief The diagnostic should be suppressed entirely.
	///
	/// Warnings generally fall into this category.
	SFINAE_Suppress,

	/// \brief The diagnostic should be reported.
	///
	/// The diagnostic should be reported. Various fatal errors (e.g.,
	/// template instantiation depth exceeded) fall into this category.
	SFINAE_Report,

	/// \brief The diagnostic is an access-control diagnostic, which will be
	/// substitution failures in some contexts and reported in others.
	SFINAE_AccessControl
	};

	/// \brief Determines whether the given built-in diagnostic ID is
	/// for an error that is suppressed if it occurs during C++ template
	/// argument deduction.
	///
	/// When an error is suppressed due to SFINAE, the template argument
	/// deduction fails but no diagnostic is emitted. Certain classes of
	/// errors, such as those errors that involve C++ access control,
	/// are not SFINAE errors.
	static SFINAEResponse getDiagnosticSFINAEResponse(unsigned DiagID);

	/// \brief Get the set of all diagnostic IDs in the group with the given name.
	///
	/// \param Diags [out] - On return, the diagnostics in the group.
	/// \returns True if the given group is unknown, false otherwise.
	bool getDiagnosticsInGroup(StringRef Group,
	llvm::SmallVectorImpl<diag::kind> &Diags) const;

	/// \brief Get the set of all diagnostic IDs.
	void getAllDiagnostics(llvm::SmallVectorImpl<diag::kind> &Diags) const;

	/// \brief Get the warning option with the closest edit distance to the given
	/// group name.
	static StringRef getNearestWarningOption(StringRef Group);

	private:
	/// \brief Get the set of all diagnostic IDs in the given group.
	///
	/// \param Diags [out] - On return, the diagnostics in the group.
	void getDiagnosticsInGroup(const WarningOption *Group,
	llvm::SmallVectorImpl<diag::kind> &Diags) const;

	/// \brief Based on the way the client configured the DiagnosticsEngine
	/// object, classify the specified diagnostic ID into a Level, consumable by
	/// the DiagnosticClient.
	///
	/// \param Loc The source location we are interested in finding out the
	/// diagnostic state. Can be null in order to query the latest state.
	DiagnosticIDs::Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc,
	const DiagnosticsEngine &Diag) const;

	/// getDiagnosticLevel - This is an internal implementation helper used when
	/// DiagClass is already known.
	DiagnosticIDs::Level getDiagnosticLevel(unsigned DiagID,
	unsigned DiagClass,
	SourceLocation Loc,
	const DiagnosticsEngine &Diag) const;

	/// ProcessDiag - This is the method used to report a diagnostic that is
	/// finally fully formed.
	///
	/// \returns true if the diagnostic was emitted, false if it was
	/// suppressed.
	bool ProcessDiag(DiagnosticsEngine &Diag) const;

	/// \brief Whether the diagnostic may leave the AST in a state where some
	/// invariants can break.
	bool isUnrecoverable(unsigned DiagID) const;

	friend class DiagnosticsEngine;
	};

	} // end namespace clang

	#endif