[diagnostics] Integrate clang -cc1as diagnostics into DiagnosticsEngine

[sanwou01]

Summary

Add initial support for printing assembly diagnostics using the
DiagnosticsEngine infrastructure. Add support for -w (no warnings) and
-Werror (warnings are errors) and print a summary with the number of
errors and warnings. -fcolor-diagnostics handling is implemented as
well.

This patch adds a subclass to FullSourceLoc, called UnifiedSourceLoc,
which can hold an llvm-style SourceLoc and SourceMgr. This class is
responsible for the translation from the clang::FullSourceLoc API to
llvm-style operations.

With these changes in place, it will be possible to convert inline
assembly diagnostics as well.

Missing is support for ranges and hints.

[olista01]

What advantages does this have over the current way of printing diagnostics? If this is just to get -w and -Werror working, would it not be easier to pass those through to the assembler, than to send all diagnostics back through clang? We already have some flags in MCTargetOptions that should be able to to the same things -w and -Werror do.

On the other hand, if this would enable other features, like -W options to promote/suppress categories of assembler warnings, than this might allow us to avoid duplicating a lot of clang's diagnostic system in the LLVM SourceMgr. Do you have any ideas for how this could be done?

[sanwou01]

Hi Oli,

Thanks for taking a look! You're right, -w and -Werror could be implemented by passing them as MCTargetOptions flags.

This patch is indeed intended to enable -W options to promote or silence (categories of) warnings. To enable that, the first step is to be able to associate a diagnostic with an identifier. Clang defines IDs (and their warning groups) in Diagnostic*Kinds.td. The IDs need to be available where a diagnostic is raised, so a table for LLVM diagnostics (or just the enum) needs to live on the LLVM side (but they'd share encoding space with the clang enum, e.g., the clang diag enum starts where the llvm diag enum ends). It is then a matter of plumbing this ID from the point where the diagnostic gets raised, into an SMDiagnostic, and into the DiagnosticsEngine on the clang side.

Once the infrastructure is in place, the calls to Report() and friends can be updated with IDs on a case by case basis.

Thanks,
Sanne

[olista01]

That all sounds sensible from an assembler perspective, especially the ability to gradually move diagnostics into categories rather than having one big change that touches every assembler diag. However, I've not done much work in clang, so it would be good to get someone more familiar with the clang diagnostics/driver side of things to have a look at this too.

[sanwou01]

Rebase on top of D31709 and D32159

[sanwou01]

Don't include the changes from D31709 and D32159 in this patch (oops).

include/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/iterator_range.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/Support/SMLoc.h"
 #include <algorithm>
 #include <cassert>
 #include <cstdint>
 #include <list>
 #include <map>
 #include <memory>
 #include <string>
 #include <type_traits>
 #include <utility>
 #include <vector>
 
+namespace llvm {
+
+class SourceMgr;
+}
+
 namespace clang {
 
 class DeclContext;
 class DiagnosticBuilder;
 class DiagnosticConsumer;
 class IdentifierInfo;
 class LangOptions;
 class Preprocessor;
public:
   /// This actually returns an instance of DiagnosticBuilder which emits the
   /// diagnostics (through @c ProcessDiag) when it is destroyed.
   ///
   /// \param DiagID A member of the @c diag::kind enum.
   /// \param Loc Represents the source location associated with the diagnostic,
   /// which can be an invalid location if no position information is available.
   inline DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID);
   inline DiagnosticBuilder Report(unsigned DiagID);
+  inline DiagnosticBuilder Report(const llvm::SourceMgr *SM, llvm::SMLoc Loc,
+                                  unsigned DiagID);
 
   void Report(const StoredDiagnostic &storedDiag);
 
   /// \brief Determine whethere there is already a diagnostic in flight.
   bool isDiagnosticInFlight() const { return CurDiagID != ~0U; }
 
   /// \brief Set the "delayed" diagnostic that will be emitted once
   /// the current diagnostic completes.
private:
   // diagnostic is in flight at a time.
   friend class DiagnosticIDs;
   friend class DiagnosticBuilder;
   friend class Diagnostic;
   friend class PartialDiagnostic;
   friend class DiagnosticErrorTrap;
   
   /// \brief The location of the current diagnostic that is in flight.
-  SourceLocation CurDiagLoc;
+  UnifiedSourceLoc CurDiagLoc;
 
   /// \brief The ID of the current diagnostic that is in flight.
   ///
   /// This is set to ~0U when there is no diagnostic in flight.
   unsigned CurDiagID;
 
   enum {
     /// \brief The maximum number of arguments we can hold.

 typedef std::pair<NullabilityKind, bool> DiagNullabilityKind;
 
 const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                     DiagNullabilityKind nullability);
 
 inline DiagnosticBuilder DiagnosticsEngine::Report(SourceLocation Loc,
                                                    unsigned DiagID) {
   assert(CurDiagID == ~0U && "Multiple diagnostics in flight at once!");
-  CurDiagLoc = Loc;
+
+  if (!Loc.isValid() || !hasSourceManager())
+    CurDiagLoc = UnifiedSourceLoc();
+  else
+    CurDiagLoc = UnifiedSourceLoc(Loc, getSourceManager());
+
   CurDiagID = DiagID;
   FlagValue.clear();
   return DiagnosticBuilder(this);
 }
 
 inline DiagnosticBuilder DiagnosticsEngine::Report(unsigned DiagID) {
   return Report(SourceLocation(), DiagID);
 }
 
+inline DiagnosticBuilder DiagnosticsEngine::Report(const llvm::SourceMgr *SM,
+                                                   llvm::SMLoc Loc,
+                                                   unsigned DiagID) {
+  auto DB = Report(DiagID);
+
+  if (!Loc.isValid() || !SM)
+    CurDiagLoc = UnifiedSourceLoc();
+  else
+    CurDiagLoc = UnifiedSourceLoc(Loc, *SM);
+
+  return DB;
+}
+
 //===----------------------------------------------------------------------===//
 // Diagnostic
 //===----------------------------------------------------------------------===//
 
 /// A little helper class (which is basically a smart pointer that forwards
 /// info from DiagnosticsEngine) that allows clients to enquire about the
 /// currently in-flight diagnostic.
 class Diagnostic {
   const DiagnosticsEngine *DiagObj;
   StringRef StoredDiagMessage;
 
 public:
   explicit Diagnostic(const DiagnosticsEngine *DO) : DiagObj(DO) {}
   Diagnostic(const DiagnosticsEngine *DO, StringRef storedDiagMessage)
     : DiagObj(DO), StoredDiagMessage(storedDiagMessage) {}
 
   const DiagnosticsEngine *getDiags() const { return DiagObj; }
   unsigned getID() const { return DiagObj->CurDiagID; }
-  const SourceLocation &getLocation() const { return DiagObj->CurDiagLoc; }
+  const UnifiedSourceLoc &getLocation() const { return DiagObj->CurDiagLoc; }
   bool hasSourceManager() const { return DiagObj->hasSourceManager(); }
   SourceManager &getSourceManager() const { return DiagObj->getSourceManager();}
 
   unsigned getNumArgs() const { return DiagObj->NumDiagArgs; }
 
   /// \brief Return the kind of the specified index.
   ///
   /// Based on the kind of argument, the accessors below can be used to get

include/clang/Basic/SourceLocation.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_BASIC_SOURCELOCATION_H
 #define LLVM_CLANG_BASIC_SOURCELOCATION_H
 
 #include "clang/Basic/LLVM.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/PointerLikeTypeTraits.h"
+#include "llvm/Support/SMLoc.h"
 #include <cassert>
 #include <functional>
 #include <string>
 #include <utility>
 
 namespace llvm {
   class MemoryBuffer;
+  class SourceMgr;
   template <typename T> struct DenseMapInfo;
   template <typename T> struct isPodLike;
 }
 
 namespace clang {
 
 class SourceManager;
 
public:
 
   friend inline bool
   operator!=(const FullSourceLoc &LHS, const FullSourceLoc &RHS) {
     return !(LHS == RHS);
   }
 
 };
 
+class UnifiedPLoc : public PresumedLoc {
+  const llvm::SourceMgr *SrcMgr = nullptr;
+  llvm::SMLoc Loc = llvm::SMLoc();
 
+public:
+  UnifiedPLoc() : PresumedLoc() {}
+  UnifiedPLoc(PresumedLoc Loc) : PresumedLoc(Loc) {}
+  explicit UnifiedPLoc(llvm::SMLoc Loc, const llvm::SourceMgr &SM)
+      : PresumedLoc(), SrcMgr(&SM), Loc(Loc) {}
+
+  bool isValid() const;
+  bool isInvalid() const;
+  unsigned getLine() const;
+  unsigned getColumn() const;
+  StringRef getFilename() const;
+
+  SourceLocation getIncludeLoc() const;
+};
+
+class UnifiedSourceLoc : public FullSourceLoc {
+  const llvm::SourceMgr *SrcMgr = nullptr;
+  llvm::SMLoc Loc = llvm::SMLoc();
+
+public:
+  UnifiedSourceLoc() : FullSourceLoc() {}
+  UnifiedSourceLoc(FullSourceLoc Loc) : FullSourceLoc(Loc) {}
+  UnifiedSourceLoc(SourceLocation Loc, const SourceManager &SM)
+      : FullSourceLoc(Loc, SM) {}
+  explicit UnifiedSourceLoc(llvm::SMLoc Loc, const llvm::SourceMgr &SM)
+      : FullSourceLoc(), SrcMgr(&SM), Loc(Loc) {}
+
+  bool isValid() const;
+  UnifiedSourceLoc getFileLoc() const;
+  UnifiedPLoc getPresumedLoc(bool UseLineDirectives = true) const;
+  bool isLLVMLocation() const;
+  std::pair<FileID, unsigned> getDecomposedLoc() const;
+  StringRef getBufferData(bool *Invalid = nullptr) const;
+  unsigned getLineNumber() const;
+  unsigned getColumnNumber() const;
+
+  friend inline bool operator==(const UnifiedSourceLoc &LHS,
+                                const UnifiedSourceLoc &RHS) {
+    if (!LHS.SrcMgr && !RHS.SrcMgr)
+      return static_cast<FullSourceLoc>(LHS) == static_cast<FullSourceLoc>(RHS);
+
+    return LHS.Loc == RHS.Loc && LHS.SrcMgr == RHS.SrcMgr;
+  }
+
+  friend inline bool operator!=(const UnifiedSourceLoc &LHS,
+                                const UnifiedSourceLoc &RHS) {
+    return !(LHS == RHS);
+  }
+};
 
 }  // end namespace clang
 
 namespace llvm {
   /// Define DenseMapInfo so that FileID's can be used as keys in DenseMap and
   /// DenseSets.
   template <>
   struct DenseMapInfo<clang::FileID> {

include/clang/Driver/Options.h

 #ifndef LLVM_CLANG_DRIVER_OPTIONS_H
 #define LLVM_CLANG_DRIVER_OPTIONS_H
 
 #include <memory>
 
 namespace llvm {
 namespace opt {
 class OptTable;
+class ArgList;
 }
 }
 
 namespace clang {
+class DiagnosticOptions;
+class DiagnosticsEngine;
 namespace driver {
 
 namespace options {
 /// Flags specifically for clang options.  Must not overlap with
 /// llvm::opt::DriverFlag.
 enum ClangFlags {
   DriverOption = (1 << 4),
   LinkerInput = (1 << 5),

include/clang/Driver/Options.td

def Wno_nonportable_cfstrings : Joined<["-"], "Wno-nonportable-cfstrings">, Group<W_Group>,
   Flags<[CC1Option]>;
 def Wnonportable_cfstrings : Joined<["-"], "Wnonportable-cfstrings">, Group<W_Group>,
   Flags<[CC1Option]>;
 def Wp_COMMA : CommaJoined<["-"], "Wp,">,
   HelpText<"Pass the comma separated arguments in <arg> to the preprocessor">,
   MetaVarName<"<arg>">, Group<Preprocessor_Group>;
 def Wwrite_strings : Flag<["-"], "Wwrite-strings">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;
 def Wno_write_strings : Flag<["-"], "Wno-write-strings">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;
-def W_Joined : Joined<["-"], "W">, Group<W_Group>, Flags<[CC1Option, CoreOption]>,
+def W_Joined : Joined<["-"], "W">, Group<W_Group>, Flags<[CC1Option, CC1AsOption, CoreOption]>,
   MetaVarName<"<warning>">, HelpText<"Enable the specified warning">;
 def Xanalyzer : Separate<["-"], "Xanalyzer">,
   HelpText<"Pass <arg> to the static analyzer">, MetaVarName<"<arg>">,
   Group<StaticAnalyzer_Group>;
 def Xarch__ : JoinedAndSeparate<["-"], "Xarch_">, Flags<[DriverOption]>;
 def Xassembler : Separate<["-"], "Xassembler">,
   HelpText<"Pass <arg> to the assembler">, MetaVarName<"<arg>">,
   Group<CompileOnly_Group>;

 def fborland_extensions : Flag<["-"], "fborland-extensions">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Accept non-standard constructs supported by the Borland compiler">;
 def fbuiltin : Flag<["-"], "fbuiltin">, Group<f_Group>;
 def fbuiltin_module_map : Flag <["-"], "fbuiltin-module-map">, Group<f_Group>,
   Flags<[DriverOption]>, HelpText<"Load the clang builtins module map file.">;
 def fcaret_diagnostics : Flag<["-"], "fcaret-diagnostics">, Group<f_Group>;
 def fclasspath_EQ : Joined<["-"], "fclasspath=">, Group<f_Group>;
 def fcolor_diagnostics : Flag<["-"], "fcolor-diagnostics">, Group<f_Group>,
-  Flags<[CoreOption, CC1Option]>, HelpText<"Use colors in diagnostics">;
+  Flags<[CoreOption, CC1Option, CC1AsOption]>, HelpText<"Use colors in diagnostics">;
 def fdiagnostics_color : Flag<["-"], "fdiagnostics-color">, Group<f_Group>,
   Flags<[CoreOption, DriverOption]>;
 def fdiagnostics_color_EQ : Joined<["-"], "fdiagnostics-color=">, Group<f_Group>;
 def fansi_escape_codes : Flag<["-"], "fansi-escape-codes">, Group<f_Group>,
   Flags<[CoreOption, CC1Option]>, HelpText<"Use ANSI escape codes for diagnostics">;
 def fcomment_block_commands : CommaJoined<["-"], "fcomment-block-commands=">, Group<f_clang_Group>, Flags<[CC1Option]>,
   HelpText<"Treat each comma separated argument in <arg> as a documentation comment block command">,
   MetaVarName<"<arg>">;

 def verify_debug_info : Flag<["--"], "verify-debug-info">, Flags<[DriverOption]>,
   HelpText<"Verify the binary representation of debug output">;
 def weak_l : Joined<["-"], "weak-l">, Flags<[LinkerInput]>;
 def weak__framework : Separate<["-"], "weak_framework">, Flags<[LinkerInput]>;
 def weak__library : Separate<["-"], "weak_library">, Flags<[LinkerInput]>;
 def weak__reference__mismatches : Separate<["-"], "weak_reference_mismatches">;
 def whatsloaded : Flag<["-"], "whatsloaded">;
 def whyload : Flag<["-"], "whyload">;
-def w : Flag<["-"], "w">, HelpText<"Suppress all warnings">, Flags<[CC1Option]>;
+def w : Flag<["-"], "w">, HelpText<"Suppress all warnings">, Flags<[CC1Option,CC1AsOption]>;
 def x : JoinedOrSeparate<["-"], "x">, Flags<[DriverOption,CC1Option]>,
   HelpText<"Treat subsequent input files as having type <language>">,
   MetaVarName<"<language>">;
 def y : Joined<["-"], "y">;
 
 def fintegrated_as : Flag<["-"], "fintegrated-as">, Flags<[DriverOption]>,
                      Group<f_Group>, HelpText<"Enable the integrated assembler">;
 def fno_integrated_as : Flag<["-"], "fno-integrated-as">,

include/clang/Frontend/DiagnosticRenderer.h

protected:
   const LangOptions &LangOpts;
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
   
   /// \brief The location of the previous diagnostic if known.
   ///
   /// This will be invalid in cases where there is no (known) previous
   /// diagnostic location, or that location itself is invalid or comes from
   /// a different source manager than SM.
-  SourceLocation LastLoc;
-  
+  UnifiedSourceLoc LastLoc;
   /// \brief The location of the last include whose stack was printed if known.
   ///
   /// Same restriction as LastLoc essentially, but tracking include stack
   /// root locations rather than diagnostic locations.
   SourceLocation LastIncludeLoc;
   
   /// \brief The level of the last diagnostic emitted.
   ///
   /// The level of the last diagnostic emitted. Used to detect level changes
   /// which change the amount of information displayed.
   DiagnosticsEngine::Level LastLevel;
 
   DiagnosticRenderer(const LangOptions &LangOpts,
                      DiagnosticOptions *DiagOpts);
   
   virtual ~DiagnosticRenderer();
 
-  virtual void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
+  virtual void emitDiagnosticMessage(UnifiedSourceLoc Loc, UnifiedPLoc PLoc,
                                      DiagnosticsEngine::Level Level,
                                      StringRef Message,
                                      ArrayRef<CharSourceRange> Ranges,
                                      DiagOrStoredDiag Info) = 0;
 
-  virtual void emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
+  virtual void emitDiagnosticLoc(UnifiedSourceLoc Loc, UnifiedPLoc PLoc,
                                  DiagnosticsEngine::Level Level,
                                  ArrayRef<CharSourceRange> Ranges) = 0;
 
-  virtual void emitCodeContext(FullSourceLoc Loc,
+  virtual void emitCodeContext(UnifiedSourceLoc Loc,
                                DiagnosticsEngine::Level Level,
                                SmallVectorImpl<CharSourceRange> &Ranges,
                                ArrayRef<FixItHint> Hints) = 0;
 
-  virtual void emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) = 0;
-  virtual void emitImportLocation(FullSourceLoc Loc, PresumedLoc PLoc,
+  virtual void emitIncludeLocation(UnifiedSourceLoc Loc, UnifiedPLoc PLoc) = 0;
+  virtual void emitImportLocation(UnifiedSourceLoc Loc, UnifiedPLoc PLoc,
                                   StringRef ModuleName) = 0;
-  virtual void emitBuildingModuleLocation(FullSourceLoc Loc, PresumedLoc PLoc,
+  virtual void emitBuildingModuleLocation(UnifiedSourceLoc Loc,
+                                          UnifiedPLoc PLoc,
                                           StringRef ModuleName) = 0;
 
   virtual void beginDiagnostic(DiagOrStoredDiag D,
                                DiagnosticsEngine::Level Level) {}
   virtual void endDiagnostic(DiagOrStoredDiag D,
                              DiagnosticsEngine::Level Level) {}
 
   
 private:
   void emitBasicNote(StringRef Message);
-  void emitIncludeStack(FullSourceLoc Loc, PresumedLoc PLoc,
+  void emitIncludeStack(UnifiedSourceLoc Loc, UnifiedPLoc PLoc,
                         DiagnosticsEngine::Level Level);
-  void emitIncludeStackRecursively(FullSourceLoc Loc);
-  void emitImportStack(FullSourceLoc Loc);
-  void emitImportStackRecursively(FullSourceLoc Loc, StringRef ModuleName);
+  void emitIncludeStackRecursively(UnifiedSourceLoc Loc);
+  void emitImportStack(UnifiedSourceLoc Loc);
+  void emitImportStackRecursively(UnifiedSourceLoc Loc, StringRef ModuleName);
   void emitModuleBuildStack(const SourceManager &SM);
-  void emitCaret(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
+  void emitCaret(UnifiedSourceLoc Loc, DiagnosticsEngine::Level Level,
                  ArrayRef<CharSourceRange> Ranges, ArrayRef<FixItHint> Hints);
-  void emitSingleMacroExpansion(FullSourceLoc Loc,
+  void emitSingleMacroExpansion(UnifiedSourceLoc Loc,
                                 DiagnosticsEngine::Level Level,
                                 ArrayRef<CharSourceRange> Ranges);
-  void emitMacroExpansions(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
+  void emitMacroExpansions(UnifiedSourceLoc Loc, DiagnosticsEngine::Level Level,
                            ArrayRef<CharSourceRange> Ranges,
                            ArrayRef<FixItHint> Hints);
 
 public:
   /// \brief Emit a diagnostic.
   ///
   /// This is the primary entry point for emitting diagnostic messages.
   /// It handles formatting and rendering the message as well as any ancillary
   /// information needed based on macros whose expansions impact the
   /// diagnostic.
   ///
   /// \param Loc The location for this caret.
   /// \param Level The level of the diagnostic to be emitted.
   /// \param Message The diagnostic message to emit.
   /// \param Ranges The underlined ranges for this code snippet.
   /// \param FixItHints The FixIt hints active for this diagnostic.
   /// \param SM The SourceManager; will be null if the diagnostic came from the
   ///        frontend, thus \p Loc will be invalid.
-  void emitDiagnostic(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
+  void emitDiagnostic(UnifiedSourceLoc Loc, DiagnosticsEngine::Level Level,
                       StringRef Message, ArrayRef<CharSourceRange> Ranges,
                       ArrayRef<FixItHint> FixItHints,
                       DiagOrStoredDiag D = (Diagnostic *)nullptr);
 
   void emitStoredDiagnostic(StoredDiagnostic &Diag);
 };
   
 /// Subclass of DiagnosticRender that turns all subdiagostics into explicit
 /// notes.  It is up to subclasses to further define the behavior.
 class DiagnosticNoteRenderer : public DiagnosticRenderer {
 public:
   DiagnosticNoteRenderer(const LangOptions &LangOpts,
                          DiagnosticOptions *DiagOpts)
     : DiagnosticRenderer(LangOpts, DiagOpts) {}
 
   ~DiagnosticNoteRenderer() override;
 
-  void emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) override;
+  void emitIncludeLocation(UnifiedSourceLoc Loc, UnifiedPLoc PLoc) override;
 
-  void emitImportLocation(FullSourceLoc Loc, PresumedLoc PLoc,
+  void emitImportLocation(UnifiedSourceLoc Loc, UnifiedPLoc PLoc,
                           StringRef ModuleName) override;
 
-  void emitBuildingModuleLocation(FullSourceLoc Loc, PresumedLoc PLoc,
+  void emitBuildingModuleLocation(UnifiedSourceLoc Loc, UnifiedPLoc PLoc,
                                   StringRef ModuleName) override;
 
-  virtual void emitNote(FullSourceLoc Loc, StringRef Message) = 0;
+  virtual void emitNote(UnifiedSourceLoc Loc, StringRef Message) = 0;
 };
 } // end clang namespace
 #endif

include/clang/Frontend/TextDiagnostic.h

public:
   /// \param Columns The number of columns to use in line-wrapping, 0 disables
   ///                all line-wrapping.
   /// \param ShowColors Enable colorizing of the message.
   static void printDiagnosticMessage(raw_ostream &OS, bool IsSupplemental,
                                      StringRef Message, unsigned CurrentColumn,
                                      unsigned Columns, bool ShowColors);
 
 protected:
-  void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
+  void emitDiagnosticMessage(UnifiedSourceLoc Loc, UnifiedPLoc PLoc,
                              DiagnosticsEngine::Level Level, StringRef Message,
                              ArrayRef<CharSourceRange> Ranges,
                              DiagOrStoredDiag D) override;
 
-  void emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
+  void emitDiagnosticLoc(UnifiedSourceLoc Loc, UnifiedPLoc PLoc,
                          DiagnosticsEngine::Level Level,
                          ArrayRef<CharSourceRange> Ranges) override;
 
-  void emitCodeContext(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
+  void emitCodeContext(UnifiedSourceLoc Loc, DiagnosticsEngine::Level Level,
                        SmallVectorImpl<CharSourceRange> &Ranges,
                        ArrayRef<FixItHint> Hints) override {
     emitSnippetAndCaret(Loc, Level, Ranges, Hints);
   }
 
-  void emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) override;
+  void emitIncludeLocation(UnifiedSourceLoc Loc, UnifiedPLoc PLoc) override;
 
-  void emitImportLocation(FullSourceLoc Loc, PresumedLoc PLoc,
+  void emitImportLocation(UnifiedSourceLoc Loc, UnifiedPLoc PLoc,
                           StringRef ModuleName) override;
 
-  void emitBuildingModuleLocation(FullSourceLoc Loc, PresumedLoc PLoc,
+  void emitBuildingModuleLocation(UnifiedSourceLoc Loc, UnifiedPLoc PLoc,
                                   StringRef ModuleName) override;
 
 private:
-  void emitFilename(StringRef Filename, const SourceManager &SM);
+  void emitFilename(StringRef Filename, const SourceManager *SM);
 
-  void emitSnippetAndCaret(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
+  void emitSnippetAndCaret(UnifiedSourceLoc Loc, DiagnosticsEngine::Level Level,
                            SmallVectorImpl<CharSourceRange> &Ranges,
                            ArrayRef<FixItHint> Hints);
 
   void emitSnippet(StringRef SourceLine);
 
   void emitParseableFixits(ArrayRef<FixItHint> Hints, const SourceManager &SM);
 };
 
 } // end namespace clang
 
 #endif

lib/Basic/SourceLocation.cpp

 FullSourceLoc FullSourceLoc::getFileLoc() const {
   assert(isValid());
   return FullSourceLoc(SrcMgr->getFileLoc(*this), *SrcMgr);
 }
 
 std::pair<FullSourceLoc, FullSourceLoc>
 FullSourceLoc::getImmediateExpansionRange() const {
   assert(isValid());
-  std::pair<SourceLocation, SourceLocation> Range =
-      SrcMgr->getImmediateExpansionRange(*this);
+  auto Range = SrcMgr->getImmediateExpansionRange(*this);
   return std::make_pair(FullSourceLoc(Range.first, *SrcMgr),
                         FullSourceLoc(Range.second, *SrcMgr));
 }
 
 PresumedLoc FullSourceLoc::getPresumedLoc(bool UseLineDirectives) const {
   if (!isValid())
     return PresumedLoc();
 
FullSourceLoc FullSourceLoc::getImmediateMacroCallerLoc() const {
   assert(isValid());
   return FullSourceLoc(SrcMgr->getImmediateMacroCallerLoc(*this), *SrcMgr);
 }
 
 std::pair<FullSourceLoc, StringRef> FullSourceLoc::getModuleImportLoc() const {
   if (!isValid())
     return std::make_pair(FullSourceLoc(), StringRef());
 
-  std::pair<SourceLocation, StringRef> ImportLoc =
-      SrcMgr->getModuleImportLoc(*this);
+  auto ImportLoc = SrcMgr->getModuleImportLoc(*this);
   return std::make_pair(FullSourceLoc(ImportLoc.first, *SrcMgr),
                         ImportLoc.second);
 }
 
 unsigned FullSourceLoc::getFileOffset() const {
   assert(isValid());
   return SrcMgr->getFileOffset(*this);
 }
 
 unsigned FullSourceLoc::getLineNumber(bool *Invalid) const {
   assert(isValid());
   return SrcMgr->getLineNumber(getFileID(), getFileOffset(), Invalid);
 }
 
 unsigned FullSourceLoc::getColumnNumber(bool *Invalid) const {
   assert(isValid());
   return SrcMgr->getColumnNumber(getFileID(), getFileOffset(), Invalid);
 }
 
 std::pair<FullSourceLoc, FullSourceLoc>
 FullSourceLoc::getExpansionRange() const {
   assert(isValid());
-  std::pair<SourceLocation, SourceLocation> Range =
-      SrcMgr->getExpansionRange(*this);
+  auto Range = SrcMgr->getExpansionRange(*this);
   return std::make_pair(FullSourceLoc(Range.first, *SrcMgr),
                         FullSourceLoc(Range.second, *SrcMgr));
 }
 
 const FileEntry *FullSourceLoc::getFileEntry() const {
   assert(isValid());
   return SrcMgr->getFileEntryForID(getFileID());
 }
StringRef FullSourceLoc::getBufferData(bool *Invalid) const {
   assert(isValid());
   return SrcMgr->getBuffer(SrcMgr->getFileID(*this), Invalid)->getBuffer();
 }
 
 std::pair<FileID, unsigned> FullSourceLoc::getDecomposedLoc() const {
   return SrcMgr->getDecomposedLoc(*this);
 }
 
+bool UnifiedSourceLoc::isValid() const {
+  if (!SrcMgr)
+    return FullSourceLoc::isValid();
+
+  return Loc.isValid();
+}
+
+UnifiedSourceLoc UnifiedSourceLoc::getFileLoc() const {
+  if (!SrcMgr)
+    return FullSourceLoc::getFileLoc();
+
+  // Just return the current location.
+  return *this;
+}
+
+UnifiedPLoc UnifiedSourceLoc::getPresumedLoc(bool UseLineDirectives) const {
+  if (!SrcMgr)
+    return FullSourceLoc::getPresumedLoc(UseLineDirectives);
+
+  // Return the current location as a PresumedLoc.
+  return UnifiedPLoc(Loc, *SrcMgr);
+}
+
+bool UnifiedSourceLoc::isLLVMLocation() const { return !!SrcMgr; }
+
+std::pair<FileID, unsigned> UnifiedSourceLoc::getDecomposedLoc() const {
+  if (!SrcMgr)
+    return FullSourceLoc::getDecomposedLoc();
+
+  unsigned Offset = Loc.getPointer() - getBufferData().data();
+  return std::make_pair(FileID(), Offset);
+}
+
+StringRef UnifiedSourceLoc::getBufferData(bool *Invalid) const {
+  if (!SrcMgr)
+    return FullSourceLoc::getBufferData(Invalid);
+
+  unsigned BufID = SrcMgr->FindBufferContainingLoc(Loc);
+  return SrcMgr->getMemoryBuffer(BufID)->getBuffer();
+}
+
+unsigned UnifiedSourceLoc::getLineNumber() const {
+  if (!SrcMgr)
+    return FullSourceLoc::getLineNumber();
+
+  return SrcMgr->getLineAndColumn(Loc).first;
+}
+
+unsigned UnifiedSourceLoc::getColumnNumber() const {
+  if (!SrcMgr)
+    return FullSourceLoc::getColumnNumber();
+
+  return SrcMgr->getLineAndColumn(Loc).second;
+}
+
+bool UnifiedPLoc::isValid() const {
+  if (!SrcMgr)
+    return PresumedLoc::isValid();
+
+  return Loc.isValid();
+}
+
+bool UnifiedPLoc::isInvalid() const { return !isValid(); }
+
+unsigned UnifiedPLoc::getLine() const {
+  if (!SrcMgr)
+    return PresumedLoc::getLine();
+
+  return SrcMgr->getLineAndColumn(Loc).first;
+}
+
+unsigned UnifiedPLoc::getColumn() const {
+  if (!SrcMgr)
+    return PresumedLoc::getColumn();
+
+  return SrcMgr->getLineAndColumn(Loc).second;
+}
+
+StringRef UnifiedPLoc::getFilename() const {
+  if (!SrcMgr)
+    return PresumedLoc::getFilename();
+
+  unsigned CurBuf = SrcMgr->FindBufferContainingLoc(Loc);
+  assert(CurBuf && "Invalid or unspecified location!");
+
+  const llvm::MemoryBuffer *CurMB = SrcMgr->getMemoryBuffer(CurBuf);
+  return CurMB->getBufferIdentifier();
+}
+
+SourceLocation UnifiedPLoc::getIncludeLoc() const {
+  if (!SrcMgr)
+    return PresumedLoc::getIncludeLoc();
+
+  return SourceLocation();
+}
+
 } // end namespace clang

lib/Driver/DriverOptions.cpp

 //===--- DriverOptions.cpp - Driver Options Table -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/DiagnosticOptions.h"
+#include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
+#include "clang/Frontend/Utils.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Option/Option.h"
+#include "llvm/Support/Process.h"
 
 using namespace clang::driver;
 using namespace clang::driver::options;
 using namespace llvm::opt;
 
 #define PREFIX(NAME, VALUE) static const char *const NAME[] = VALUE;
 #include "clang/Driver/Options.inc"
 #undef PREFIX

lib/Driver/ToolChains/Clang.cpp

 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/ObjCRuntime.h"
 #include "clang/Basic/Version.h"
 #include "clang/Config/config.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/SanitizerArgs.h"
 #include "clang/Driver/XRayArgs.h"
+#include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/YAMLParser.h"
for (auto &A: Args) {
     for (auto &it: ASL)
       CDB << ", \"" << escape(it) << "\"";
   }
   Buf = "--target=";
   Buf += Target;
   CDB << ", \"" << escape(Buf) << "\"]},\n";
 }
 
+static void CollectArgsForColorDiagnostics(const ArgList &Args,
+                                           ArgStringList &CmdArgs,
+                                           const Driver &D) {
+  // Color diagnostics are parsed by the driver directly from argv
+  // and later re-parsed to construct this job; claim any possible
+  // color diagnostic here to avoid warn_drv_unused_argument and
+  // diagnose bad OPT_fdiagnostics_color_EQ values.
+  for (Arg *A : Args) {
+    const Option &O = A->getOption();
+    if (!O.matches(options::OPT_fcolor_diagnostics) &&
+        !O.matches(options::OPT_fdiagnostics_color) &&
+        !O.matches(options::OPT_fno_color_diagnostics) &&
+        !O.matches(options::OPT_fno_diagnostics_color) &&
+        !O.matches(options::OPT_fdiagnostics_color_EQ))
+      continue;
+    if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
+      StringRef Value(A->getValue());
+      if (Value != "always" && Value != "never" && Value != "auto")
+        D.Diag(diag::err_drv_clang_unsupported)
+            << ("-fdiagnostics-color=" + Value).str();
+    }
+    A->claim();
+  }
+  if (D.getDiags().getDiagnosticOptions().ShowColors)
+    CmdArgs.push_back("-fcolor-diagnostics");
+}
+
 static void CollectArgsForIntegratedAssembler(Compilation &C,
                                               const ArgList &Args,
                                               ArgStringList &CmdArgs,
                                               const Driver &D) {
   if (UseRelaxAll(C, Args))
     CmdArgs.push_back("-mrelax-all");
 
   // Only default to -mincremental-linker-compatible if we think we are
if (Arg *A = Args.getLastArg(
           options::OPT_fno_diagnostics_show_note_include_stack)) {
     if (A->getOption().matches(
             options::OPT_fdiagnostics_show_note_include_stack))
       CmdArgs.push_back("-fdiagnostics-show-note-include-stack");
     else
       CmdArgs.push_back("-fno-diagnostics-show-note-include-stack");
   }
 
-  // Color diagnostics are parsed by the driver directly from argv
-  // and later re-parsed to construct this job; claim any possible
-  // color diagnostic here to avoid warn_drv_unused_argument and
-  // diagnose bad OPT_fdiagnostics_color_EQ values.
-  for (Arg *A : Args) {
-    const Option &O = A->getOption();
-    if (!O.matches(options::OPT_fcolor_diagnostics) &&
-        !O.matches(options::OPT_fdiagnostics_color) &&
-        !O.matches(options::OPT_fno_color_diagnostics) &&
-        !O.matches(options::OPT_fno_diagnostics_color) &&
-        !O.matches(options::OPT_fdiagnostics_color_EQ))
-      continue;
-    if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
-      StringRef Value(A->getValue());
-      if (Value != "always" && Value != "never" && Value != "auto")
-        getToolChain().getDriver().Diag(diag::err_drv_clang_unsupported)
-              << ("-fdiagnostics-color=" + Value).str();
-    }
-    A->claim();
-  }
-  if (D.getDiags().getDiagnosticOptions().ShowColors)
-    CmdArgs.push_back("-fcolor-diagnostics");
+  CollectArgsForColorDiagnostics(Args, CmdArgs, getToolChain().getDriver());
 
   if (Args.hasArg(options::OPT_fansi_escape_codes))
     CmdArgs.push_back("-fansi-escape-codes");
 
   if (!Args.hasFlag(options::OPT_fshow_source_location,
                     options::OPT_fno_show_source_location))
     CmdArgs.push_back("-fno-show-source-location");
 
void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
   ArgStringList CmdArgs;
 
   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
   const InputInfo &Input = Inputs[0];
 
   const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
   const std::string &TripleStr = Triple.getTriple();
 
-  // Don't warn about "clang -w -c foo.s"
-  Args.ClaimAllArgs(options::OPT_w);
-  // and "clang -emit-llvm -c foo.s"
+  // Don't warn about "clang -emit-llvm -c foo.s"
   Args.ClaimAllArgs(options::OPT_emit_llvm);
 
   claimNoWarnArgs(Args);
 
   // Invoke ourselves in -cc1as mode.
   //
   // FIXME: Implement custom jobs for internal actions.
   CmdArgs.push_back("-cc1as");
case llvm::Triple::mips64el:
     break;
 
   case llvm::Triple::x86:
   case llvm::Triple::x86_64:
     AddX86TargetArgs(Args, CmdArgs);
     break;
   }
 
-  // Consume all the warning flags. Usually this would be handled more
-  // gracefully by -cc1 (warning about unknown warning flags, etc) but -cc1as
-  // doesn't handle that so rather than warning about unused flags that are
-  // actually used, we'll lie by omission instead.
-  // FIXME: Stop lying and consume only the appropriate driver flags
-  Args.ClaimAllArgs(options::OPT_W_Group);
+  // Pass all warning flags to -cc1as.
+  Args.AddAllArgs(CmdArgs, options::OPT_W_Group);
+  Args.AddLastArg(CmdArgs, options::OPT_w);
+
+  CollectArgsForColorDiagnostics(Args, CmdArgs, getToolChain().getDriver());
 
   CollectArgsForIntegratedAssembler(C, Args, CmdArgs,
                                     getToolChain().getDriver());
 
   Args.AddAllArgs(CmdArgs, options::OPT_mllvm);
 
   assert(Output.isFilename() && "Unexpected lipo output.");
   CmdArgs.push_back("-o");

lib/Frontend/DiagnosticRenderer.cpp

static void mergeFixits(ArrayRef<FixItHint> FixItHints,
 
   edit::EditedSource Editor(SM, LangOpts);
   if (Editor.commit(commit)) {
     FixitReceiver Rec(MergedFixits);
     Editor.applyRewrites(Rec);
   }
 }
 
-void DiagnosticRenderer::emitDiagnostic(FullSourceLoc Loc,
+void DiagnosticRenderer::emitDiagnostic(UnifiedSourceLoc Loc,
                                         DiagnosticsEngine::Level Level,
                                         StringRef Message,
                                         ArrayRef<CharSourceRange> Ranges,
                                         ArrayRef<FixItHint> FixItHints,
                                         DiagOrStoredDiag D) {
-  assert(Loc.hasManager() || Loc.isInvalid());
-
   beginDiagnostic(D, Level);
 
   if (!Loc.isValid())
     // If we have no source location, just emit the diagnostic message.
-    emitDiagnosticMessage(Loc, PresumedLoc(), Level, Message, Ranges, D);
+    emitDiagnosticMessage(Loc, UnifiedPLoc(), Level, Message, Ranges, D);
   else {
     // Get the ranges into a local array we can hack on.
     SmallVector<CharSourceRange, 20> MutableRanges(Ranges.begin(),
                                                    Ranges.end());
 
     SmallVector<FixItHint, 8> MergedFixits;
     if (!FixItHints.empty()) {
       mergeFixits(FixItHints, Loc.getManager(), LangOpts, MergedFixits);
       FixItHints = MergedFixits;
     }
 
     for (ArrayRef<FixItHint>::const_iterator I = FixItHints.begin(),
          E = FixItHints.end();
          I != E; ++I)
       if (I->RemoveRange.isValid())
         MutableRanges.push_back(I->RemoveRange);
 
-    FullSourceLoc UnexpandedLoc = Loc;
+    UnifiedSourceLoc UnexpandedLoc = Loc;
 
     // Find the ultimate expansion location for the diagnostic.
     Loc = Loc.getFileLoc();
 
-    PresumedLoc PLoc = Loc.getPresumedLoc(DiagOpts->ShowPresumedLoc);
+    UnifiedPLoc PLoc = Loc.getPresumedLoc(DiagOpts->ShowPresumedLoc);
 
     // First, if this diagnostic is not in the main file, print out the
     // "included from" lines.
+    if (!Loc.isLLVMLocation())
       emitIncludeStack(Loc, PLoc, Level);
 
     // Next, emit the actual diagnostic message and caret.
     emitDiagnosticMessage(Loc, PLoc, Level, Message, Ranges, D);
     emitCaret(Loc, Level, MutableRanges, FixItHints);
 
     // If this location is within a macro, walk from UnexpandedLoc up to Loc
     // and produce a macro backtrace.
     if (UnexpandedLoc.isValid() && UnexpandedLoc.isMacroID()) {
emitDiagnostic(
       Diag.getLocation().isValid()
           ? FullSourceLoc(Diag.getLocation(), Diag.getLocation().getManager())
           : FullSourceLoc(),
       Diag.getLevel(), Diag.getMessage(), Diag.getRanges(), Diag.getFixIts(),
       &Diag);
 }
 
 void DiagnosticRenderer::emitBasicNote(StringRef Message) {
-  emitDiagnosticMessage(FullSourceLoc(), PresumedLoc(), DiagnosticsEngine::Note,
-                        Message, None, DiagOrStoredDiag());
+  emitDiagnosticMessage(UnifiedSourceLoc(), UnifiedPLoc(),
+                        DiagnosticsEngine::Note, Message, None,
+                        DiagOrStoredDiag());
 }
 
 /// \brief Prints an include stack when appropriate for a particular
 /// diagnostic level and location.
 ///
 /// This routine handles all the logic of suppressing particular include
 /// stacks (such as those for notes) and duplicate include stacks when
 /// repeated warnings occur within the same file. It also handles the logic
 /// of customizing the formatting and display of the include stack.
 ///
 /// \param Loc   The diagnostic location.
 /// \param PLoc  The presumed location of the diagnostic location.
 /// \param Level The diagnostic level of the message this stack pertains to.
-void DiagnosticRenderer::emitIncludeStack(FullSourceLoc Loc, PresumedLoc PLoc,
+void DiagnosticRenderer::emitIncludeStack(UnifiedSourceLoc Loc,
+                                          UnifiedPLoc PLoc,
                                           DiagnosticsEngine::Level Level) {
-  FullSourceLoc IncludeLoc =
-      PLoc.isInvalid() ? FullSourceLoc()
-                       : FullSourceLoc(PLoc.getIncludeLoc(), Loc.getManager());
+  UnifiedSourceLoc IncludeLoc =
+      PLoc.isInvalid()
+          ? UnifiedSourceLoc()
+          : UnifiedSourceLoc(PLoc.getIncludeLoc(), Loc.getManager());
 
   // Skip redundant include stacks altogether.
   if (LastIncludeLoc == IncludeLoc)
     return;
   
   LastIncludeLoc = IncludeLoc;
   
   if (!DiagOpts->ShowNoteIncludeStack && Level == DiagnosticsEngine::Note)
     return;
 
   if (IncludeLoc.isValid())
     emitIncludeStackRecursively(IncludeLoc);
   else {
     emitModuleBuildStack(Loc.getManager());
     emitImportStack(Loc);
   }
 }
 
 /// \brief Helper to recursivly walk up the include stack and print each layer
 /// on the way back down.
-void DiagnosticRenderer::emitIncludeStackRecursively(FullSourceLoc Loc) {
+void DiagnosticRenderer::emitIncludeStackRecursively(UnifiedSourceLoc Loc) {
   if (Loc.isInvalid()) {
     emitModuleBuildStack(Loc.getManager());
     return;
   }
 
-  PresumedLoc PLoc = Loc.getPresumedLoc(DiagOpts->ShowPresumedLoc);
+  UnifiedPLoc PLoc = Loc.getPresumedLoc(DiagOpts->ShowPresumedLoc);
   if (PLoc.isInvalid())
     return;
 
   // If this source location was imported from a module, print the module
   // import stack rather than the 
   // FIXME: We want submodule granularity here.
-  std::pair<FullSourceLoc, StringRef> Imported = Loc.getModuleImportLoc();
+  std::pair<UnifiedSourceLoc, StringRef> Imported = Loc.getModuleImportLoc();
   if (!Imported.second.empty()) {
     // This location was imported by a module. Emit the module import stack.
     emitImportStackRecursively(Imported.first, Imported.second);
     return;
   }
 
   // Emit the other include frames first.
   emitIncludeStackRecursively(
-      FullSourceLoc(PLoc.getIncludeLoc(), Loc.getManager()));
+      UnifiedSourceLoc(PLoc.getIncludeLoc(), Loc.getManager()));
 
   // Emit the inclusion text/note.
   emitIncludeLocation(Loc, PLoc);
 }
 
 /// \brief Emit the module import stack associated with the current location.
-void DiagnosticRenderer::emitImportStack(FullSourceLoc Loc) {
+void DiagnosticRenderer::emitImportStack(UnifiedSourceLoc Loc) {
   if (Loc.isInvalid()) {
     emitModuleBuildStack(Loc.getManager());
     return;
   }
 
-  std::pair<FullSourceLoc, StringRef> NextImportLoc = Loc.getModuleImportLoc();
+  std::pair<UnifiedSourceLoc, StringRef> NextImportLoc =
+      Loc.getModuleImportLoc();
   emitImportStackRecursively(NextImportLoc.first, NextImportLoc.second);
 }
 
 /// \brief Helper to recursivly walk up the import stack and print each layer
 /// on the way back down.
-void DiagnosticRenderer::emitImportStackRecursively(FullSourceLoc Loc,
+void DiagnosticRenderer::emitImportStackRecursively(UnifiedSourceLoc Loc,
                                                     StringRef ModuleName) {
   if (ModuleName.empty()) {
     return;
   }
 
-  PresumedLoc PLoc = Loc.getPresumedLoc(DiagOpts->ShowPresumedLoc);
+  UnifiedPLoc PLoc = Loc.getPresumedLoc(DiagOpts->ShowPresumedLoc);
 
   // Emit the other import frames first.
-  std::pair<FullSourceLoc, StringRef> NextImportLoc = Loc.getModuleImportLoc();
+  std::pair<UnifiedSourceLoc, StringRef> NextImportLoc =
+      Loc.getModuleImportLoc();
   emitImportStackRecursively(NextImportLoc.first, NextImportLoc.second);
 
   // Emit the inclusion text/note.
   emitImportLocation(Loc, PLoc, ModuleName);
 }
 
 /// \brief Emit the module build stack, for cases where a module is (re-)built
 /// on demand.

 //
 // To find locations which correspond to the caret, we crawl the macro caller
 // chain for the beginning and end of each range.  If the caret location
 // is in a macro expansion, we search each chain for a location
 // in the same expansion as the caret; otherwise, we crawl to the top of
 // each chain. Two locations are part of the same macro expansion
 // iff the FileID is the same.
 static void
-mapDiagnosticRanges(FullSourceLoc CaretLoc, ArrayRef<CharSourceRange> Ranges,
+mapDiagnosticRanges(UnifiedSourceLoc CaretLoc, ArrayRef<CharSourceRange> Ranges,
                     SmallVectorImpl<CharSourceRange> &SpellingRanges) {
   FileID CaretLocFileID = CaretLoc.getFileID();
 
   const SourceManager *SM = &CaretLoc.getManager();
 
   for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
     if (I->isInvalid()) continue;
 
for (auto I = Ranges.begin(), E = Ranges.end(); I != E; ++I) {
     Begin = SM->getSpellingLoc(Begin);
     End = SM->getSpellingLoc(End);
 
     SpellingRanges.push_back(CharSourceRange(SourceRange(Begin, End),
                                              IsTokenRange));
   }
 }
 
-void DiagnosticRenderer::emitCaret(FullSourceLoc Loc,
+void DiagnosticRenderer::emitCaret(UnifiedSourceLoc Loc,
                                    DiagnosticsEngine::Level Level,
                                    ArrayRef<CharSourceRange> Ranges,
                                    ArrayRef<FixItHint> Hints) {
   SmallVector<CharSourceRange, 4> SpellingRanges;
+  if (!Ranges.empty())
     mapDiagnosticRanges(Loc, Ranges, SpellingRanges);
   emitCodeContext(Loc, Level, SpellingRanges, Hints);
 }
 
 /// \brief A helper function for emitMacroExpansion to print the
 /// macro expansion message
 void DiagnosticRenderer::emitSingleMacroExpansion(
-    FullSourceLoc Loc, DiagnosticsEngine::Level Level,
+    UnifiedSourceLoc Loc, DiagnosticsEngine::Level Level,
     ArrayRef<CharSourceRange> Ranges) {
   // Find the spelling location for the macro definition. We must use the
   // spelling location here to avoid emitting a macro backtrace for the note.
-  FullSourceLoc SpellingLoc = Loc.getSpellingLoc();
+  UnifiedSourceLoc SpellingLoc = Loc.getSpellingLoc();
 
   // Map the ranges into the FileID of the diagnostic location.
   SmallVector<CharSourceRange, 4> SpellingRanges;
   mapDiagnosticRanges(Loc, Ranges, SpellingRanges);
 
   SmallString<100> MessageStorage;
   llvm::raw_svector_ostream Message(MessageStorage);
   StringRef MacroName = Lexer::getImmediateMacroNameForDiagnostics(
while (BegLoc != EndLoc) {
     BegLoc.getLocWithOffset(1);
   }
 
   return checkLocForMacroArgExpansion(BegLoc, SM, ArgumentLoc);
 }
 
 /// A helper function to check if the current ranges are all inside the same
 /// macro argument expansion as Loc.
-static bool checkRangesForMacroArgExpansion(FullSourceLoc Loc,
+static bool checkRangesForMacroArgExpansion(UnifiedSourceLoc Loc,
                                             ArrayRef<CharSourceRange> Ranges) {
   assert(Loc.isMacroID() && "Must be a macro expansion!");
 
   SmallVector<CharSourceRange, 4> SpellingRanges;
   mapDiagnosticRanges(Loc, Ranges, SpellingRanges);
 
   /// Count all valid ranges.
   unsigned ValidCount = 0;
   for (auto I : Ranges)
     if (I.isValid()) ValidCount++;
 
   if (ValidCount > SpellingRanges.size())
     return false;
 
   /// To store the source location of the argument location.
-  FullSourceLoc ArgumentLoc;
+  UnifiedSourceLoc ArgumentLoc;
 
   /// Set the ArgumentLoc to the beginning location of the expansion of Loc
   /// so to check if the ranges expands to the same beginning location.
   if (!Loc.isMacroArgExpansion(&ArgumentLoc))
     return false;
 
   for (auto I = SpellingRanges.begin(), E = SpellingRanges.end(); I != E; ++I) {
     if (!checkRangeForMacroArgExpansion(*I, Loc.getManager(), ArgumentLoc))

 /// Walks up the macro expansion stack printing expansion notes, the code
 /// snippet, caret, underlines and FixItHint display as appropriate at each
 /// level.
 ///
 /// \param Loc The location for this caret.
 /// \param Level The diagnostic level currently being emitted.
 /// \param Ranges The underlined ranges for this code snippet.
 /// \param Hints The FixIt hints active for this diagnostic.
-void DiagnosticRenderer::emitMacroExpansions(FullSourceLoc Loc,
+void DiagnosticRenderer::emitMacroExpansions(UnifiedSourceLoc Loc,
                                              DiagnosticsEngine::Level Level,
                                              ArrayRef<CharSourceRange> Ranges,
                                              ArrayRef<FixItHint> Hints) {
   assert(Loc.isValid() && "must have a valid source location here");
 
   // Produce a stack of macro backtraces.
-  SmallVector<FullSourceLoc, 8> LocationStack;
+  SmallVector<UnifiedSourceLoc, 8> LocationStack;
   unsigned IgnoredEnd = 0;
   while (Loc.isMacroID()) {
     // If this is the expansion of a macro argument, point the caret at the
     // use of the argument in the definition of the macro, not the expansion.
     if (Loc.isMacroArgExpansion())
       LocationStack.push_back(Loc.getImmediateExpansionRange().first);
     else
       LocationStack.push_back(Loc);
void DiagnosticRenderer::emitMacroExpansions(UnifiedSourceLoc Loc,
   for (auto I = LocationStack.rend() - MacroEndMessages,
             E = LocationStack.rend();
        I != E; ++I)
     emitSingleMacroExpansion(*I, Level, Ranges);
 }
 
 DiagnosticNoteRenderer::~DiagnosticNoteRenderer() {}
 
-void DiagnosticNoteRenderer::emitIncludeLocation(FullSourceLoc Loc,
-                                                 PresumedLoc PLoc) {
+void DiagnosticNoteRenderer::emitIncludeLocation(UnifiedSourceLoc Loc,
+                                                 UnifiedPLoc PLoc) {
   // Generate a note indicating the include location.
   SmallString<200> MessageStorage;
   llvm::raw_svector_ostream Message(MessageStorage);
   Message << "in file included from " << PLoc.getFilename() << ':'
           << PLoc.getLine() << ":";
   emitNote(Loc, Message.str());
 }
 
-void DiagnosticNoteRenderer::emitImportLocation(FullSourceLoc Loc,
-                                                PresumedLoc PLoc,
+void DiagnosticNoteRenderer::emitImportLocation(UnifiedSourceLoc Loc,
+                                                UnifiedPLoc PLoc,
                                                 StringRef ModuleName) {
   // Generate a note indicating the include location.
   SmallString<200> MessageStorage;
   llvm::raw_svector_ostream Message(MessageStorage);
   Message << "in module '" << ModuleName;
   if (PLoc.isValid())
     Message << "' imported from " << PLoc.getFilename() << ':'
             << PLoc.getLine();
   Message << ":";
   emitNote(Loc, Message.str());
 }
 
-void DiagnosticNoteRenderer::emitBuildingModuleLocation(FullSourceLoc Loc,
-                                                        PresumedLoc PLoc,
+void DiagnosticNoteRenderer::emitBuildingModuleLocation(UnifiedSourceLoc Loc,
+                                                        UnifiedPLoc PLoc,
                                                         StringRef ModuleName) {
   // Generate a note indicating the include location.
   SmallString<200> MessageStorage;
   llvm::raw_svector_ostream Message(MessageStorage);
   if (PLoc.isValid())
     Message << "while building module '" << ModuleName << "' imported from "
             << PLoc.getFilename() << ':' << PLoc.getLine() << ":";
   else
     Message << "while building module '" << ModuleName << "':";
   emitNote(Loc, Message.str());
 }

lib/Frontend/SerializedDiagnosticPrinter.cpp

 public:
   SDiagsRenderer(SDiagsWriter &Writer, const LangOptions &LangOpts,
                  DiagnosticOptions *DiagOpts)
     : DiagnosticNoteRenderer(LangOpts, DiagOpts), Writer(Writer) {}
 
   ~SDiagsRenderer() override {}
 
 protected:
-  void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
+  void emitDiagnosticMessage(UnifiedSourceLoc Loc, UnifiedPLoc PLoc,
                              DiagnosticsEngine::Level Level, StringRef Message,
                              ArrayRef<CharSourceRange> Ranges,
                              DiagOrStoredDiag D) override;
 
-  void emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
+  void emitDiagnosticLoc(UnifiedSourceLoc Loc, UnifiedPLoc PLoc,
                          DiagnosticsEngine::Level Level,
                          ArrayRef<CharSourceRange> Ranges) override {}
 
-  void emitNote(FullSourceLoc Loc, StringRef Message) override;
+  void emitNote(UnifiedSourceLoc Loc, StringRef Message) override;
 
-  void emitCodeContext(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
+  void emitCodeContext(UnifiedSourceLoc Loc, DiagnosticsEngine::Level Level,
                        SmallVectorImpl<CharSourceRange> &Ranges,
                        ArrayRef<FixItHint> Hints) override;
 
   void beginDiagnostic(DiagOrStoredDiag D,
                        DiagnosticsEngine::Level Level) override;
   void endDiagnostic(DiagOrStoredDiag D,
                      DiagnosticsEngine::Level Level) override;
 };
if (const Diagnostic *Info = D.dyn_cast<const Diagnostic*>()) {
     Record.push_back(getEmitDiagnosticFlag(Level));
   }
 
   Record.push_back(Message.size());
   Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_DIAG), Record, Message);
 }
 
 void SDiagsRenderer::emitDiagnosticMessage(
-    FullSourceLoc Loc, PresumedLoc PLoc, DiagnosticsEngine::Level Level,
+    UnifiedSourceLoc Loc, UnifiedPLoc PLoc, DiagnosticsEngine::Level Level,
     StringRef Message, ArrayRef<clang::CharSourceRange> Ranges,
     DiagOrStoredDiag D) {
   Writer.EmitDiagnosticMessage(Loc, PLoc, Level, Message, D);
 }
 
 void SDiagsWriter::EnterDiagBlock() {
   State->Stream.EnterSubblock(BLOCK_DIAG, 4);
 }
for (ArrayRef<FixItHint>::iterator I = Hints.begin(), E = Hints.end();
     Record.push_back(RECORD_FIXIT);
     AddCharSourceRangeToRecord(Fix.RemoveRange, Record, SM);
     Record.push_back(Fix.CodeToInsert.size());
     Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_FIXIT), Record,
                               Fix.CodeToInsert);
   }
 }
 
-void SDiagsRenderer::emitCodeContext(FullSourceLoc Loc,
+void SDiagsRenderer::emitCodeContext(UnifiedSourceLoc Loc,
                                      DiagnosticsEngine::Level Level,
                                      SmallVectorImpl<CharSourceRange> &Ranges,
                                      ArrayRef<FixItHint> Hints) {
   Writer.EmitCodeContext(Ranges, Hints, Loc.getManager());
 }
 
-void SDiagsRenderer::emitNote(FullSourceLoc Loc, StringRef Message) {
+void SDiagsRenderer::emitNote(UnifiedSourceLoc Loc, StringRef Message) {
   Writer.EnterDiagBlock();
   PresumedLoc PLoc = Loc.hasManager() ? Loc.getPresumedLoc() : PresumedLoc();
   Writer.EmitDiagnosticMessage(Loc, PLoc, DiagnosticsEngine::Note, Message,
                                DiagOrStoredDiag());
   Writer.ExitDiagBlock();
 }
 
 DiagnosticsEngine *SDiagsWriter::getMetaDiags() {

lib/Frontend/TextDiagnostic.cpp

 TextDiagnostic::TextDiagnostic(raw_ostream &OS,
                                const LangOptions &LangOpts,
                                DiagnosticOptions *DiagOpts)
   : DiagnosticRenderer(LangOpts, DiagOpts), OS(OS) {}
 
 TextDiagnostic::~TextDiagnostic() {}
 
 void TextDiagnostic::emitDiagnosticMessage(
-    FullSourceLoc Loc, PresumedLoc PLoc, DiagnosticsEngine::Level Level,
+    UnifiedSourceLoc Loc, UnifiedPLoc PLoc, DiagnosticsEngine::Level Level,
     StringRef Message, ArrayRef<clang::CharSourceRange> Ranges,
     DiagOrStoredDiag D) {
   uint64_t StartOfLocationInfo = OS.tell();
 
   // Emit the location of this particular diagnostic.
   if (Loc.isValid())
     emitDiagnosticLoc(Loc, PLoc, Level, Ranges);
 
else {
     assert(Normal && "Formatting should have returned to normal");
   }
 
   if (ShowColors)
     OS.resetColor();
   OS << '\n';
 }
 
-void TextDiagnostic::emitFilename(StringRef Filename, const SourceManager &SM) {
+void TextDiagnostic::emitFilename(StringRef Filename, const SourceManager *SM) {
   SmallVector<char, 128> AbsoluteFilename;
-  if (DiagOpts->AbsolutePath) {
-    const DirectoryEntry *Dir = SM.getFileManager().getDirectory(
+  if (SM && DiagOpts->AbsolutePath) {
+    const DirectoryEntry *Dir = SM->getFileManager().getDirectory(
         llvm::sys::path::parent_path(Filename));
     if (Dir) {
-      StringRef DirName = SM.getFileManager().getCanonicalName(Dir);
+      StringRef DirName = SM->getFileManager().getCanonicalName(Dir);
       llvm::sys::path::append(AbsoluteFilename, DirName,
                               llvm::sys::path::filename(Filename));
       Filename = StringRef(AbsoluteFilename.data(), AbsoluteFilename.size());
     }
   }
 
   OS << Filename;
 }
 
 /// \brief Print out the file/line/column information and include trace.
 ///
 /// This method handlen the emission of the diagnostic location information.
 /// This includes extracting as much location information as is present for
 /// the diagnostic and printing it, as well as any include stack or source
 /// ranges necessary.
-void TextDiagnostic::emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
+void TextDiagnostic::emitDiagnosticLoc(UnifiedSourceLoc Loc, UnifiedPLoc PLoc,
                                        DiagnosticsEngine::Level Level,
                                        ArrayRef<CharSourceRange> Ranges) {
   if (PLoc.isInvalid()) {
     // At least print the file name if available:
     FileID FID = Loc.getFileID();
     if (FID.isValid()) {
       const FileEntry *FE = Loc.getFileEntry();
       if (FE && FE->isValid()) {
-        emitFilename(FE->getName(), Loc.getManager());
+        emitFilename(FE->getName(), &Loc.getManager());
         if (FE->isInPCH())
           OS << " (in PCH)";
         OS << ": ";
       }
     }
     return;
   }
   unsigned LineNo = PLoc.getLine();
 
   if (!DiagOpts->ShowLocation)
     return;
 
   if (DiagOpts->ShowColors)
     OS.changeColor(savedColor, true);
 
-  emitFilename(PLoc.getFilename(), Loc.getManager());
+  emitFilename(PLoc.getFilename(),
+               Loc.hasManager() ? &Loc.getManager() : nullptr);
   switch (DiagOpts->getFormat()) {
   case DiagnosticOptions::Clang: OS << ':'  << LineNo; break;
   case DiagnosticOptions::MSVC:  OS << '('  << LineNo; break;
   case DiagnosticOptions::Vi:    OS << " +" << LineNo; break;
   }
 
   if (DiagOpts->ShowColumn)
     // Compute the column number.
if (DiagOpts->ShowSourceRanges && !Ranges.empty()) {
     bool PrintedRange = false;
 
     for (ArrayRef<CharSourceRange>::const_iterator RI = Ranges.begin(),
          RE = Ranges.end();
          RI != RE; ++RI) {
       // Ignore invalid ranges.
       if (!RI->isValid()) continue;
 
-      FullSourceLoc B =
-          FullSourceLoc(RI->getBegin(), Loc.getManager()).getExpansionLoc();
-      FullSourceLoc E =
-          FullSourceLoc(RI->getEnd(), Loc.getManager()).getExpansionLoc();
+      UnifiedSourceLoc B =
+          UnifiedSourceLoc(RI->getBegin(), Loc.getManager()).getExpansionLoc();
+      UnifiedSourceLoc E =
+          UnifiedSourceLoc(RI->getEnd(), Loc.getManager()).getExpansionLoc();
 
       // If the End location and the start location are the same and are a
       // macro location, then the range was something that came from a
       // macro expansion or _Pragma.  If this is an object-like macro, the
       // best we can do is to highlight the range.  If this is a
       // function-like macro, we'd also like to highlight the arguments.
       if (B == E && RI->getEnd().isMacroID())
-        E = FullSourceLoc(RI->getEnd(), Loc.getManager())
+        E = UnifiedSourceLoc(RI->getEnd(), Loc.getManager())
                 .getExpansionRange()
                 .second;
 
       std::pair<FileID, unsigned> BInfo = B.getDecomposedLoc();
       std::pair<FileID, unsigned> EInfo = E.getDecomposedLoc();
 
       // If the start or end of the range is in another file, just discard
       // it.
if (DiagOpts->ShowSourceRanges && !Ranges.empty()) {
     }
 
     if (PrintedRange)
       OS << ':';
   }
   OS << ' ';
 }
 
-void TextDiagnostic::emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) {
+void TextDiagnostic::emitIncludeLocation(UnifiedSourceLoc Loc,
+                                         UnifiedPLoc PLoc) {
   if (DiagOpts->ShowLocation && PLoc.isValid())
     OS << "In file included from " << PLoc.getFilename() << ':'
        << PLoc.getLine() << ":\n";
   else
     OS << "In included file:\n"; 
 }
 
-void TextDiagnostic::emitImportLocation(FullSourceLoc Loc, PresumedLoc PLoc,
+void TextDiagnostic::emitImportLocation(UnifiedSourceLoc Loc, UnifiedPLoc PLoc,
                                         StringRef ModuleName) {
   if (DiagOpts->ShowLocation && PLoc.isValid())
     OS << "In module '" << ModuleName << "' imported from "
        << PLoc.getFilename() << ':' << PLoc.getLine() << ":\n";
   else
     OS << "In module '" << ModuleName << "':\n";
 }
 
-void TextDiagnostic::emitBuildingModuleLocation(FullSourceLoc Loc,
-                                                PresumedLoc PLoc,
+void TextDiagnostic::emitBuildingModuleLocation(UnifiedSourceLoc Loc,
+                                                UnifiedPLoc PLoc,
                                                 StringRef ModuleName) {
   if (DiagOpts->ShowLocation && PLoc.isValid())
     OS << "While building module '" << ModuleName << "' imported from "
       << PLoc.getFilename() << ':' << PLoc.getLine() << ":\n";
   else
     OS << "While building module '" << ModuleName << "':\n";
 }
 

 /// \brief Emit a code snippet and caret line.
 ///
 /// This routine emits a single line's code snippet and caret line..
 ///
 /// \param Loc The location for the caret.
 /// \param Ranges The underlined ranges for this code snippet.
 /// \param Hints The FixIt hints active for this diagnostic.
 void TextDiagnostic::emitSnippetAndCaret(
-    FullSourceLoc Loc, DiagnosticsEngine::Level Level,
+    UnifiedSourceLoc Loc, DiagnosticsEngine::Level Level,
     SmallVectorImpl<CharSourceRange> &Ranges, ArrayRef<FixItHint> Hints) {
   assert(Loc.isValid() && "must have a valid source location here");
   assert(Loc.isFileID() && "must have a file location here");
 
   // If caret diagnostics are enabled and we have location, we want to
   // emit the caret.  However, we only do this if the location moved
   // from the last diagnostic, if the last diagnostic was a note that
   // was part of a different warning or error diagnostic, or if the
   // diagnostic has ranges.  We don't want to emit the same caret
   // multiple times if one loc has multiple diagnostics.
   if (!DiagOpts->ShowCarets)
     return;
+
   if (Loc == LastLoc && Ranges.empty() && Hints.empty() &&
-      (LastLevel != DiagnosticsEngine::Note || Level == LastLevel))
+      (LastLevel != DiagnosticsEngine::Note || Level == LastLevel)) {
     return;
+  }
 
   // Decompose the location into a FID/Offset pair.
   std::pair<FileID, unsigned> LocInfo = Loc.getDecomposedLoc();
   FileID FID = LocInfo.first;
   unsigned FileOffset = LocInfo.second;
 
   // Get information about the buffer it points into.
   bool Invalid = false;
highlightRange(*I, LineNo, FID, sourceColMap, CaretLine, Loc.getManager(),
                    LangOpts);
 
   // Next, insert the caret itself.
   ColNo = sourceColMap.byteToContainingColumn(ColNo-1);
   if (CaretLine.size()<ColNo+1)
     CaretLine.resize(ColNo+1, ' ');
   CaretLine[ColNo] = '^';
 
-  std::string FixItInsertionLine = buildFixItInsertionLine(
+  std::string FixItInsertionLine;
+  if (!Hints.empty())
+    FixItInsertionLine = buildFixItInsertionLine(
         LineNo, sourceColMap, Hints, Loc.getManager(), DiagOpts.get());
 
   // If the source line is too long for our terminal, select only the
   // "interesting" source region within that line.
   unsigned Columns = DiagOpts->MessageLength;
   if (Columns)
     selectInterestingSourceRegion(SourceLine, CaretLine, FixItInsertionLine,
                                   Columns, sourceColMap);
 
if (!FixItInsertionLine.empty()) {
     if (DiagOpts->ShowSourceRanges)
       OS << ' ';
     OS << FixItInsertionLine << '\n';
     if (DiagOpts->ShowColors)
       OS.resetColor();
   }
 
   // Print out any parseable fixit information requested by the options.
+  if (!Hints.empty())
     emitParseableFixits(Hints, Loc.getManager());
 }
 
 void TextDiagnostic::emitSnippet(StringRef line) {
   if (line.empty())
     return;
 
   size_t i = 0;
   
for (ArrayRef<FixItHint>::iterator I = Hints.begin(), E = Hints.end();
     std::pair<FileID, unsigned> EInfo = SM.getDecomposedLoc(ELoc);
 
     // Adjust for token ranges.
     if (I->RemoveRange.isTokenRange())
       EInfo.second += Lexer::MeasureTokenLength(ELoc, SM, LangOpts);
 
     // We specifically do not do word-wrapping or tab-expansion here,
     // because this is supposed to be easy to parse.
-    PresumedLoc PLoc = SM.getPresumedLoc(BLoc);
+    UnifiedPLoc PLoc = SM.getPresumedLoc(BLoc);
     if (PLoc.isInvalid())
       break;
 
     OS << "fix-it:\"";
     OS.write_escaped(PLoc.getFilename());
     OS << "\":{" << SM.getLineNumber(BInfo.first, BInfo.second)
       << ':' << SM.getColumnNumber(BInfo.first, BInfo.second)
       << '-' << SM.getLineNumber(EInfo.first, EInfo.second)
       << ':' << SM.getColumnNumber(EInfo.first, EInfo.second)
       << "}:\"";
     OS.write_escaped(I->CodeToInsert);
     OS << "\"\n";
   }
 }

lib/Frontend/TextDiagnosticPrinter.cpp

TextDiagnostic::printDiagnosticMessage(OS, Level, DiagMessageStream.str(),
                                            DiagOpts->MessageLength,
                                            DiagOpts->ShowColors);
     OS.flush();
     return;
   }
 
   // Assert that the rest of our infrastructure is setup properly.
   assert(DiagOpts && "Unexpected diagnostic without options set");
-  assert(Info.hasSourceManager() &&
-         "Unexpected diagnostic with no source manager");
   assert(TextDiag && "Unexpected diagnostic outside source file processing");
 
-  TextDiag->emitDiagnostic(
-      FullSourceLoc(Info.getLocation(), Info.getSourceManager()), Level,
-      DiagMessageStream.str(), Info.getRanges(), Info.getFixItHints());
-
+  TextDiag->emitDiagnostic(Info.getLocation(), Level, DiagMessageStream.str(),
+                           Info.getRanges(), Info.getFixItHints());
   OS.flush();
 }

test/Driver/asm-diags.s

+# RUN: not %clang --target=arm-linux-gnueabi -march=armv8-m.main -c %s 2>&1 | FileCheck %s
+# RUN: not %clang --target=arm-linux-gnueabi -march=armv8-m.main -w -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-NO-WARNINGS
+# RUN: not %clang --target=arm-linux-gnueabi -march=armv8-m.main -Werror -c %s 2>&1 | FileCheck %s --check-prefix=CHECK-FATAL-WARNINGS
+
+.thumb
+  ADD r0, r0, #0xFFFF0001
+  LDM r0, {r1, r0}
+
+# CHECK: asm-diags.s:6:14: error:
+# CHECK:  ADD r0, r0, #0xFFFF0001
+# CHECK: asm-diags.s:7:15: warning:
+# CHECK:  LDM r0, {r1, r0}
+# CHECK: 1 warning and 1 error generated.
+
+# CHECK-NO-WARNINGS: asm-diags.s:6:14: error:
+# CHECK-NO-WARNINGS:  ADD r0, r0, #0xFFFF0001
+# CHECK-NO-WARNINGS: 1 error generated.
+
+# CHECK-FATAL-WARNINGS: asm-diags.s:6:14: error:
+# CHECK-FATAL-WARNINGS:   ADD r0, r0, #0xFFFF0001
+# CHECK-FATAL-WARNINGS: asm-diags.s:7:15: error:
+# CHECK-FATAL-WARNINGS:   LDM r0, {r1, r0}
+# CHECK-FATAL-WARNINGS: 2 errors generated.

tools/driver/cc1as_main.cpp

 //===-- cc1as_main.cpp - Clang Assembler  ---------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This is the entry point to the clang -cc1as functionality, which implements
 // the direct interface to the LLVM MC based assembler.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
+#include "clang/Basic/FileManager.h"
+#include "clang/Basic/FileSystemOptions.h"
+#include "clang/Basic/LangOptions.h"
+#include "clang/Basic/SourceManager.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "clang/Frontend/DiagnosticOptions.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Frontend/Utils.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"

 #include "llvm/Option/OptTable.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 #include <system_error>
if (EC) {
     Diags.Report(diag::err_fe_unable_to_open_output) << Opts.OutputPath
                                                      << EC.message();
     return nullptr;
   }
 
   return Out;
 }
 
+struct DiagsHandlerContext {
+  DiagnosticsEngine &Diags;
+  const SourceMgr *SrcMgr;
+};
+
+static void AssemblerDiagsHandler(const SMDiagnostic &D, void *Context) {
+  auto &Diags = *static_cast<DiagnosticsEngine *>(Context);
+  unsigned DiagID;
+  switch (D.getKind()) {
+  case llvm::SourceMgr::DK_Error:
+    DiagID = diag::err_fe_inline_asm;
+    break;
+  case llvm::SourceMgr::DK_Warning:
+    DiagID = diag::warn_fe_inline_asm;
+    break;
+  case llvm::SourceMgr::DK_Note:
+    DiagID = diag::note_fe_inline_asm;
+    break;
+  }
+
+  Diags.Report(D.getSourceMgr(), D.getLoc(), DiagID) << D.getMessage();
+}
+
 static bool ExecuteAssembler(AssemblerInvocation &Opts,
                              DiagnosticsEngine &Diags) {
   // Get the target specific parser.
   std::string Error;
   const Target *TheTarget = TargetRegistry::lookupTarget(Opts.Triple, Error);
   if (!TheTarget)
     return Diags.Report(diag::err_target_unknown_triple) << Opts.Triple;
 
static bool ExecuteAssembler(AssemblerInvocation &Opts,
 
   // Tell SrcMgr about this buffer, which is what the parser will pick up.
   SrcMgr.AddNewSourceBuffer(std::move(*Buffer), SMLoc());
 
   // Record the location of the include directories so that the lexer can find
   // it later.
   SrcMgr.setIncludeDirs(Opts.IncludePaths);
 
+  SrcMgr.setDiagHandler(AssemblerDiagsHandler, &Diags);
+
   std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(Opts.Triple));
   assert(MRI && "Unable to create target register info!");
 
   std::unique_ptr<MCAsmInfo> MAI(TheTarget->createMCAsmInfo(*MRI, Opts.Triple));
   assert(MAI && "Unable to create target asm info!");
 
   // Ensure MCAsmInfo initialization occurs before any use, otherwise sections
   // may be created with a combination of default and explicit settings.
int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
   InitializeAllTargetInfos();
   InitializeAllTargetMCs();
   InitializeAllAsmParsers();
 
   // Construct our diagnostic client.
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   TextDiagnosticPrinter *DiagClient
     = new TextDiagnosticPrinter(errs(), &*DiagOpts);
-  DiagClient->setPrefix("clang -cc1as");
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
   DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);
 
   // Set an error handler, so that any LLVM backend diagnostics go through our
   // error handler.
   ScopedFatalErrorHandler FatalErrorHandler
     (LLVMErrorHandler, static_cast<void*>(&Diags));
 
if (!Asm.LLVMArgs.empty()) {
     const char **Args = new const char*[NumArgs + 2];
     Args[0] = "clang (LLVM option parsing)";
     for (unsigned i = 0; i != NumArgs; ++i)
       Args[i + 1] = Asm.LLVMArgs[i].c_str();
     Args[NumArgs + 1] = nullptr;
     llvm::cl::ParseCommandLineOptions(NumArgs + 1, Args);
   }
 
+  ProcessWarningOptions(Diags, Diags.getDiagnosticOptions(), true);
+
+  LangOptions LangOpts;
+  DiagClient->BeginSourceFile(LangOpts, nullptr);
+
   // Execute the invocation, unless there were parsing errors.
   bool Failed = Diags.hasErrorOccurred() || ExecuteAssembler(Asm, Diags);
 
+  DiagClient->EndSourceFile();
+
+  // Notify the diagnostic client that all files were processed.
+  Diags.getClient()->finish();
+
+  if (Diags.getDiagnosticOptions().ShowCarets) {
+    // We can have multiple diagnostics sharing one diagnostic client.
+    // Get the total number of warnings/errors from the client.
+    unsigned NumWarnings = Diags.getClient()->getNumWarnings();
+    unsigned NumErrors = Diags.getClient()->getNumErrors();
+
+    if (NumWarnings)
+      errs() << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
+    if (NumWarnings && NumErrors)
+      errs() << " and ";
+    if (NumErrors)
+      errs() << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
+    if (NumWarnings || NumErrors)
+      errs() << " generated.\n";
+  }
+
   // If any timers were active but haven't been destroyed yet, print their
   // results now.
   TimerGroup::printAll(errs());
 
   return !!Failed;
 }

tools/libclang/CIndexDiagnostic.cpp

void beginDiagnostic(DiagOrStoredDiag D,
     auto Owner = llvm::make_unique<CXStoredDiagnostic>(*SD, LangOpts);
     CXStoredDiagnostic &CD = *Owner;
     CurrentSet->appendDiagnostic(std::move(Owner));
 
     if (Level != DiagnosticsEngine::Note)
       CurrentSet = &CD.getChildDiagnostics();
   }
 
-  void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
+  void emitDiagnosticMessage(UnifiedSourceLoc Loc, UnifiedPLoc PLoc,
                              DiagnosticsEngine::Level Level, StringRef Message,
                              ArrayRef<CharSourceRange> Ranges,
                              DiagOrStoredDiag D) override {
     if (!D.isNull())
       return;
     
     CXSourceLocation L;
     if (Loc.hasManager())
       L = translateSourceLocation(Loc.getManager(), LangOpts, Loc);
     else
       L = clang_getNullLocation();
     CurrentSet->appendDiagnostic(
         llvm::make_unique<CXDiagnosticCustomNoteImpl>(Message, L));
   }
 
-  void emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
+  void emitDiagnosticLoc(UnifiedSourceLoc Loc, UnifiedPLoc PLoc,
                          DiagnosticsEngine::Level Level,
                          ArrayRef<CharSourceRange> Ranges) override {}
 
-  void emitCodeContext(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
+  void emitCodeContext(UnifiedSourceLoc Loc, DiagnosticsEngine::Level Level,
                        SmallVectorImpl<CharSourceRange> &Ranges,
                        ArrayRef<FixItHint> Hints) override {}
 
-  void emitNote(FullSourceLoc Loc, StringRef Message) override {
+  void emitNote(UnifiedSourceLoc Loc, StringRef Message) override {
     CXSourceLocation L;
     if (Loc.hasManager())
       L = translateSourceLocation(Loc.getManager(), LangOpts, Loc);
     else
       L = clang_getNullLocation();
     CurrentSet->appendDiagnostic(
         llvm::make_unique<CXDiagnosticCustomNoteImpl>(Message, L));
   }