vendor/clang/clang-trunk-r351319

18 files changed, 157 insertions, 397 deletions

diff --git a/include/clang/Lex/CodeCompletionHandler.h b/include/clang/Lex/CodeCompletionHandler.h
index 87089fd7d50b0..bef804beed003 100644
--- a/include/clang/Lex/CodeCompletionHandler.h
+++ b/include/clang/Lex/CodeCompletionHandler.h
@@ -14,6 +14,8 @@
 #ifndef LLVM_CLANG_LEX_CODECOMPLETIONHANDLER_H
 #define LLVM_CLANG_LEX_CODECOMPLETIONHANDLER_H
 
+#include "llvm/ADT/StringRef.h"
+
 namespace clang {
 
 class IdentifierInfo;
@@ -60,6 +62,11 @@ public:
                                          MacroInfo *MacroInfo,
                                          unsigned ArgumentIndex) { }
 
+  /// Callback invoked when performing code completion inside the filename
+  /// part of an #include directive. (Also #import, #include_next, etc).
+  /// \p Dir is the directory relative to the include path.
+  virtual void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled) {}
+
   /// Callback invoked when performing code completion in a part of the
   /// file where we expect natural language, e.g., a comment, string, or
   /// \#error directive.
diff --git a/include/clang/Lex/DirectoryLookup.h b/include/clang/Lex/DirectoryLookup.h
index 55065b7d8547d..bfb496be50723 100644
--- a/include/clang/Lex/DirectoryLookup.h
+++ b/include/clang/Lex/DirectoryLookup.h
@@ -191,7 +191,7 @@ private:
       SmallVectorImpl<char> *RelativePath,
       Module *RequestingModule,
       ModuleMap::KnownHeader *SuggestedModule,
-      bool &InUserSpecifiedSystemHeader) const;
+      bool &InUserSpecifiedSystemFramework) const;
 
 };
 
diff --git a/include/clang/Lex/HeaderMap.h b/include/clang/Lex/HeaderMap.h
index 58bf79579a6a3..793e7edc2752f 100644
--- a/include/clang/Lex/HeaderMap.h
+++ b/include/clang/Lex/HeaderMap.h
@@ -71,7 +71,8 @@ class HeaderMap : private HeaderMapImpl {
 public:
   /// This attempts to load the specified file as a header map.  If it doesn't
   /// look like a HeaderMap, it gives up and returns null.
-  static const HeaderMap *Create(const FileEntry *FE, FileManager &FM);
+  static std::unique_ptr<HeaderMap> Create(const FileEntry *FE,
+                                           FileManager &FM);
 
   /// Check to see if the specified relative filename is located in this
   /// HeaderMap.  If so, open it and return its FileEntry.  If RawPath is not
diff --git a/include/clang/Lex/HeaderSearch.h b/include/clang/Lex/HeaderSearch.h
index 6bb0f58f2db9d..7c69e219cb571 100644
--- a/include/clang/Lex/HeaderSearch.h
+++ b/include/clang/Lex/HeaderSearch.h
@@ -17,6 +17,7 @@
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Lex/DirectoryLookup.h"
+#include "clang/Lex/HeaderMap.h"
 #include "clang/Lex/ModuleMap.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
@@ -38,7 +39,6 @@ class DirectoryEntry;
 class ExternalPreprocessorSource;
 class FileEntry;
 class FileManager;
-class HeaderMap;
 class HeaderSearchOptions;
 class IdentifierInfo;
 class LangOptions;
@@ -55,7 +55,7 @@ struct HeaderFileInfo {
   /// True if this is a \#pragma once file.
   unsigned isPragmaOnce : 1;
 
-  /// DirInfo - Keep track of whether this is a system header, and if so,
+  /// Keep track of whether this is a system header, and if so,
   /// whether it is C++ clean or not.  This can be set by the include paths or
   /// by \#pragma gcc system_header.  This is an instance of
   /// SrcMgr::CharacteristicKind.
@@ -219,16 +219,15 @@ class HeaderSearch {
   /// name like "Carbon" to the Carbon.framework directory.
   llvm::StringMap<FrameworkCacheEntry, llvm::BumpPtrAllocator> FrameworkMap;
 
-  /// IncludeAliases - maps include file names (including the quotes or
+  /// Maps include file names (including the quotes or
   /// angle brackets) to other include file names.  This is used to support the
   /// include_alias pragma for Microsoft compatibility.
   using IncludeAliasMap =
       llvm::StringMap<std::string, llvm::BumpPtrAllocator>;
   std::unique_ptr<IncludeAliasMap> IncludeAliases;
 
-  /// HeaderMaps - This is a mapping from FileEntry -> HeaderMap, uniquing
-  /// headermaps.  This vector owns the headermap.
-  std::vector<std::pair<const FileEntry *, const HeaderMap *>> HeaderMaps;
+  /// This is a mapping from FileEntry -> HeaderMap, uniquing headermaps.
+  std::vector<std::pair<const FileEntry *, std::unique_ptr<HeaderMap>>> HeaderMaps;
 
   /// The mapping between modules and headers.
   mutable ModuleMap ModMap;
@@ -264,7 +263,6 @@ public:
                const LangOptions &LangOpts, const TargetInfo *Target);
   HeaderSearch(const HeaderSearch &) = delete;
   HeaderSearch &operator=(const HeaderSearch &) = delete;
-  ~HeaderSearch();
 
   /// Retrieve the header-search options with which this header search
   /// was initialized.
@@ -314,7 +312,7 @@ public:
     (*IncludeAliases)[Source] = Dest;
   }
 
-  /// MapHeaderToIncludeAlias - Maps one header file name to a different header
+  /// Maps one header file name to a different header
   /// file name, for use with the include_alias pragma.  Note that the source
   /// file name should include the angle brackets or quotes.  Returns StringRef
   /// as null if the header cannot be mapped.
@@ -408,7 +406,7 @@ public:
   /// HIToolbox is a subframework within Carbon.framework.  If so, return
   /// the FileEntry for the designated file, otherwise return null.
   const FileEntry *LookupSubframeworkHeader(
-      StringRef Filename, const FileEntry *RelativeFileEnt,
+      StringRef Filename, const FileEntry *ContextFileEnt,
       SmallVectorImpl<char> *SearchPath, SmallVectorImpl<char> *RelativePath,
       Module *RequestingModule, ModuleMap::KnownHeader *SuggestedModule);
 
@@ -425,7 +423,7 @@ public:
   /// if we should include it.
   bool ShouldEnterIncludeFile(Preprocessor &PP, const FileEntry *File,
                               bool isImport, bool ModulesEnabled,
-                              Module *CorrespondingModule);
+                              Module *M);
 
   /// Return whether the specified file is a normal header,
   /// a system header, or a C++ friendly system header.
@@ -448,9 +446,9 @@ public:
   }
 
   /// Mark the specified file as part of a module.
-  void MarkFileModuleHeader(const FileEntry *File,
+  void MarkFileModuleHeader(const FileEntry *FE,
                             ModuleMap::ModuleHeaderRole Role,
-                            bool IsCompiledModuleHeader);
+                            bool isCompilingModuleHeader);
 
   /// Increment the count for the number of times the specified
   /// FileEntry has been entered.
@@ -479,7 +477,7 @@ public:
   /// This routine does not consider the effect of \#import
   bool isFileMultipleIncludeGuarded(const FileEntry *File);
 
-  /// CreateHeaderMap - This method returns a HeaderMap for the specified
+  /// This method returns a HeaderMap for the specified
   /// FileEntry, uniquing them through the 'HeaderMaps' datastructure.
   const HeaderMap *CreateHeaderMap(const FileEntry *FE);
 
@@ -641,7 +639,7 @@ private:
   /// \return \c true if the file can be used, \c false if we are not permitted to
   ///         find this file due to requirements from \p RequestingModule.
   bool findUsableModuleForFrameworkHeader(
-      const FileEntry *File, StringRef FrameworkDir, Module *RequestingModule,
+      const FileEntry *File, StringRef FrameworkName, Module *RequestingModule,
       ModuleMap::KnownHeader *SuggestedModule, bool IsSystemFramework);
 
   /// Look up the file with the specified name and determine its owning
diff --git a/include/clang/Lex/LexDiagnostic.h b/include/clang/Lex/LexDiagnostic.h
index 5d724c0de8799..3a677b8345430 100644
--- a/include/clang/Lex/LexDiagnostic.h
+++ b/include/clang/Lex/LexDiagnostic.h
@@ -10,19 +10,6 @@
 #ifndef LLVM_CLANG_LEX_LEXDIAGNOSTIC_H
 #define LLVM_CLANG_LEX_LEXDIAGNOSTIC_H
 
-#include "clang/Basic/Diagnostic.h"
-
-namespace clang {
-  namespace diag {
-    enum {
-#define DIAG(ENUM,FLAGS,DEFAULT_MAPPING,DESC,GROUP,\
-             SFINAE,NOWERROR,SHOWINSYSHEADER,CATEGORY) ENUM,
-#define LEXSTART
-#include "clang/Basic/DiagnosticLexKinds.inc"
-#undef DIAG
-      NUM_BUILTIN_LEX_DIAGNOSTICS
-    };
-  }  // end namespace diag
-}  // end namespace clang
+#include "clang/Basic/DiagnosticLex.h"
 
 #endif
diff --git a/include/clang/Lex/Lexer.h b/include/clang/Lex/Lexer.h
index 624151ef877b0..a9b10b6273204 100644
--- a/include/clang/Lex/Lexer.h
+++ b/include/clang/Lex/Lexer.h
@@ -139,7 +139,7 @@ public:
   /// with the specified preprocessor managing the lexing process.  This lexer
   /// assumes that the associated file buffer and Preprocessor objects will
   /// outlive it, so it doesn't take ownership of either of them.
-  Lexer(FileID FID, const llvm::MemoryBuffer *InputBuffer, Preprocessor &PP);
+  Lexer(FileID FID, const llvm::MemoryBuffer *InputFile, Preprocessor &PP);
 
   /// Lexer constructor - Create a new raw lexer object.  This object is only
   /// suitable for calls to 'LexFromRawLexer'.  This lexer assumes that the
@@ -150,7 +150,7 @@ public:
   /// Lexer constructor - Create a new raw lexer object.  This object is only
   /// suitable for calls to 'LexFromRawLexer'.  This lexer assumes that the
   /// text range will outlive it, so it doesn't take ownership of it.
-  Lexer(FileID FID, const llvm::MemoryBuffer *InputBuffer,
+  Lexer(FileID FID, const llvm::MemoryBuffer *FromFile,
         const SourceManager &SM, const LangOptions &LangOpts);
 
   Lexer(const Lexer &) = delete;
@@ -310,8 +310,8 @@ public:
   /// location.
   static StringRef getSpelling(SourceLocation loc,
                                SmallVectorImpl<char> &buffer,
-                               const SourceManager &SourceMgr,
-                               const LangOptions &LangOpts,
+                               const SourceManager &SM,
+                               const LangOptions &options,
                                bool *invalid = nullptr);
 
   /// MeasureTokenLength - Relex the token at the specified location and return
@@ -339,7 +339,7 @@ public:
   /// Get the physical length (including trigraphs and escaped newlines) of the
   /// first \p Characters characters of the token starting at TokStart.
   static unsigned getTokenPrefixLength(SourceLocation TokStart,
-                                       unsigned Characters,
+                                       unsigned CharNo,
                                        const SourceManager &SM,
                                        const LangOptions &LangOpts);
 
@@ -711,20 +711,22 @@ private:
 
   bool isHexaLiteral(const char *Start, const LangOptions &LangOpts);
 
+  void codeCompleteIncludedFile(const char *PathStart,
+                                const char *CompletionPoint, bool IsAngled);
 
   /// Read a universal character name.
   ///
-  /// \param CurPtr The position in the source buffer after the initial '\'.
-  ///               If the UCN is syntactically well-formed (but not necessarily
-  ///               valid), this parameter will be updated to point to the
-  ///               character after the UCN.
+  /// \param StartPtr The position in the source buffer after the initial '\'.
+  ///                 If the UCN is syntactically well-formed (but not 
+  ///                 necessarily valid), this parameter will be updated to
+  ///                 point to the character after the UCN.
   /// \param SlashLoc The position in the source buffer of the '\'.
-  /// \param Tok The token being formed. Pass \c nullptr to suppress diagnostics
-  ///            and handle token formation in the caller.
+  /// \param Result   The token being formed. Pass \c nullptr to suppress
+  ///                 diagnostics and handle token formation in the caller.
   ///
   /// \return The Unicode codepoint specified by the UCN, or 0 if the UCN is
   ///         invalid.
-  uint32_t tryReadUCN(const char *&CurPtr, const char *SlashLoc, Token *Tok);
+  uint32_t tryReadUCN(const char *&StartPtr, const char *SlashLoc, Token *Result);
 
   /// Try to consume a UCN as part of an identifier at the current
   /// location.
diff --git a/include/clang/Lex/MacroInfo.h b/include/clang/Lex/MacroInfo.h
index 0cc1cb92e67e7..a06de132b4969 100644
--- a/include/clang/Lex/MacroInfo.h
+++ b/include/clang/Lex/MacroInfo.h
@@ -395,7 +395,8 @@ public:
 
   /// Find macro definition active in the specified source location. If
   /// this macro was not defined there, return NULL.
-  const DefInfo findDirectiveAtLoc(SourceLocation L, SourceManager &SM) const;
+  const DefInfo findDirectiveAtLoc(SourceLocation L,
+                                   const SourceManager &SM) const;
 
   void dump() const;
 
diff --git a/include/clang/Lex/ModuleMap.h b/include/clang/Lex/ModuleMap.h
index aa519891c1ce8..a38c8d7819db4 100644
--- a/include/clang/Lex/ModuleMap.h
+++ b/include/clang/Lex/ModuleMap.h
@@ -45,6 +45,8 @@ class SourceManager;
 /// A mechanism to observe the actions of the module map parser as it
 /// reads module map files.
 class ModuleMapCallbacks {
+  virtual void anchor();
+
 public:
   virtual ~ModuleMapCallbacks() = default;
 
@@ -92,9 +94,9 @@ class ModuleMap {
   /// named LangOpts::CurrentModule, if we've loaded it).
   Module *SourceModule = nullptr;
 
-  /// The global module for the current TU, if we still own it. (Ownership is
-  /// transferred if/when we create an enclosing module.
-  std::unique_ptr<Module> PendingGlobalModule;
+  /// Submodules of the current module that have not yet been attached to it.
+  /// (Ownership is transferred if/when we create an enclosing module.)
+  llvm::SmallVector<std::unique_ptr<Module>, 8> PendingSubmodules;
 
   /// The top-level modules that are known.
   llvm::StringMap<Module *> Modules;
@@ -519,8 +521,7 @@ public:
                                                bool IsFramework,
                                                bool IsExplicit);
 
-  /// Create a 'global module' for a C++ Modules TS module interface
-  /// unit.
+  /// Create a 'global module' for a C++ Modules TS module interface unit.
   ///
   /// We model the global module as a submodule of the module interface unit.
   /// Unfortunately, we can't create the module interface unit's Module until
@@ -537,6 +538,9 @@ public:
   Module *createModuleForInterfaceUnit(SourceLocation Loc, StringRef Name,
                                        Module *GlobalModule);
 
+  /// Create a header module from the specified list of headers.
+  Module *createHeaderModule(StringRef Name, ArrayRef<Module::Header> Headers);
+
   /// Infer the contents of a framework module map from the given
   /// framework directory.
   Module *inferFrameworkModule(const DirectoryEntry *FrameworkDir,
@@ -580,7 +584,7 @@ public:
   /// getContainingModuleMapFile().
   const FileEntry *getModuleMapFileForUniquing(const Module *M) const;
 
-  void setInferredModuleAllowedBy(Module *M, const FileEntry *ModuleMap);
+  void setInferredModuleAllowedBy(Module *M, const FileEntry *ModMap);
 
   /// Get any module map files other than getModuleMapFileForUniquing(M)
   /// that define submodules of a top-level module \p M. This is cheaper than
diff --git a/include/clang/Lex/PPCallbacks.h b/include/clang/Lex/PPCallbacks.h
index 45c2d18da6e2b..2448b34c8af49 100644
--- a/include/clang/Lex/PPCallbacks.h
+++ b/include/clang/Lex/PPCallbacks.h
@@ -276,6 +276,12 @@ public:
                        SourceRange Range) {
   }
 
+  /// Hook called when a '__has_include' or '__has_include_next' directive is
+  /// read.
+  virtual void HasInclude(SourceLocation Loc, StringRef FileName, bool IsAngled,
+                          const FileEntry *File,
+                          SrcMgr::CharacteristicKind FileType) {}
+
   /// Hook called when a source range is skipped.
   /// \param Range The SourceRange that was skipped. The range begins at the
   /// \#if/\#else directive and ends after the \#endif/\#else directive.
@@ -443,6 +449,13 @@ public:
     Second->PragmaDiagnostic(Loc, Namespace, mapping, Str);
   }
 
+  void HasInclude(SourceLocation Loc, StringRef FileName, bool IsAngled,
+                  const FileEntry *File,
+                  SrcMgr::CharacteristicKind FileType) override {
+    First->HasInclude(Loc, FileName, IsAngled, File, FileType);
+    Second->HasInclude(Loc, FileName, IsAngled, File, FileType);
+  }
+
   void PragmaOpenCLExtension(SourceLocation NameLoc, const IdentifierInfo *Name,
                              SourceLocation StateLoc, unsigned State) override {
     First->PragmaOpenCLExtension(NameLoc, Name, StateLoc, State);
diff --git a/include/clang/Lex/PTHLexer.h b/include/clang/Lex/PTHLexer.h
deleted file mode 100644
index 0b84df1434aec..0000000000000
--- a/include/clang/Lex/PTHLexer.h
+++ /dev/null
@@ -1,107 +0,0 @@
-//===- PTHLexer.h - Lexer based on Pre-tokenized input ----------*- 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 PTHLexer interface.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_LEX_PTHLEXER_H
-#define LLVM_CLANG_LEX_PTHLEXER_H
-
-#include "clang/Basic/SourceLocation.h"
-#include "clang/Basic/TokenKinds.h"
-#include "clang/Lex/PreprocessorLexer.h"
-#include "clang/Lex/Token.h"
-
-namespace clang {
-
-class Preprocessor;
-class PTHManager;
-
-class PTHLexer : public PreprocessorLexer {
-  SourceLocation FileStartLoc;
-
-  /// TokBuf - Buffer from PTH file containing raw token data.
-  const unsigned char* TokBuf;
-
-  /// CurPtr - Pointer into current offset of the token buffer where
-  ///  the next token will be read.
-  const unsigned char* CurPtr;
-
-  /// LastHashTokPtr - Pointer into TokBuf of the last processed '#'
-  ///  token that appears at the start of a line.
-  const unsigned char* LastHashTokPtr = nullptr;
-
-  /// PPCond - Pointer to a side table in the PTH file that provides a
-  ///  a concise summary of the preprocessor conditional block structure.
-  ///  This is used to perform quick skipping of conditional blocks.
-  const unsigned char* PPCond;
-
-  /// CurPPCondPtr - Pointer inside PPCond that refers to the next entry
-  ///  to process when doing quick skipping of preprocessor blocks.
-  const unsigned char* CurPPCondPtr;
-
-  /// ReadToken - Used by PTHLexer to read tokens TokBuf.
-  void ReadToken(Token &T);
-
-  bool LexEndOfFile(Token &Result);
-
-  /// PTHMgr - The PTHManager object that created this PTHLexer.
-  PTHManager& PTHMgr;
-
-  Token EofToken;
-
-protected:
-  friend class PTHManager;
-
-  /// Create a PTHLexer for the specified token stream.
-  PTHLexer(Preprocessor &pp, FileID FID, const unsigned char *D,
-           const unsigned char* ppcond, PTHManager &PM);
-
-public:
-  PTHLexer(const PTHLexer &) = delete;
-  PTHLexer &operator=(const PTHLexer &) = delete;
-  ~PTHLexer() override = default;
-
-  /// Lex - Return the next token.
-  bool Lex(Token &Tok);
-
-  void getEOF(Token &Tok);
-
-  /// DiscardToEndOfLine - Read the rest of the current preprocessor line as an
-  /// uninterpreted string.  This switches the lexer out of directive mode.
-  void DiscardToEndOfLine();
-
-  /// isNextPPTokenLParen - Return 1 if the next unexpanded token will return a
-  /// tok::l_paren token, 0 if it is something else and 2 if there are no more
-  /// tokens controlled by this lexer.
-  unsigned isNextPPTokenLParen() {
-    // isNextPPTokenLParen is not on the hot path, and all we care about is
-    // whether or not we are at a token with kind tok::eof or tok::l_paren.
-    // Just read the first byte from the current token pointer to determine
-    // its kind.
-    tok::TokenKind x = (tok::TokenKind)*CurPtr;
-    return x == tok::eof ? 2 : x == tok::l_paren;
-  }
-
-  /// IndirectLex - An indirect call to 'Lex' that can be invoked via
-  ///  the PreprocessorLexer interface.
-  void IndirectLex(Token &Result) override { Lex(Result); }
-
-  /// getSourceLocation - Return a source location for the token in
-  /// the current file.
-  SourceLocation getSourceLocation() override;
-
-  /// SkipBlock - Used by Preprocessor to skip the current conditional block.
-  bool SkipBlock();
-};
-
-} // namespace clang
-
-#endif // LLVM_CLANG_LEX_PTHLEXER_H
diff --git a/include/clang/Lex/PTHManager.h b/include/clang/Lex/PTHManager.h
deleted file mode 100644
index 483b69f23a9cc..0000000000000
--- a/include/clang/Lex/PTHManager.h
+++ /dev/null
@@ -1,149 +0,0 @@
-//===- PTHManager.h - Manager object for PTH processing ---------*- 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 PTHManager interface.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_LEX_PTHMANAGER_H
-#define LLVM_CLANG_LEX_PTHMANAGER_H
-
-#include "clang/Basic/IdentifierTable.h"
-#include "clang/Basic/SourceLocation.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Allocator.h"
-#include "llvm/Support/OnDiskHashTable.h"
-#include <memory>
-
-namespace llvm {
-
-class MemoryBuffer;
-
-} // namespace llvm
-
-namespace clang {
-
-class DiagnosticsEngine;
-class FileSystemStatCache;
-class Preprocessor;
-class PTHLexer;
-
-class PTHManager : public IdentifierInfoLookup {
-  friend class PTHLexer;
-  friend class PTHStatCache;
-
-  class PTHFileLookupTrait;
-  class PTHStringLookupTrait;
-
-  using PTHStringIdLookup = llvm::OnDiskChainedHashTable<PTHStringLookupTrait>;
-  using PTHFileLookup = llvm::OnDiskChainedHashTable<PTHFileLookupTrait>;
-
-  /// The memory mapped PTH file.
-  std::unique_ptr<const llvm::MemoryBuffer> Buf;
-
-  /// Alloc - Allocator used for IdentifierInfo objects.
-  llvm::BumpPtrAllocator Alloc;
-
-  /// IdMap - A lazily generated cache mapping from persistent identifiers to
-  ///  IdentifierInfo*.
-  std::unique_ptr<IdentifierInfo *[], llvm::FreeDeleter> PerIDCache;
-
-  /// FileLookup - Abstract data structure used for mapping between files
-  ///  and token data in the PTH file.
-  std::unique_ptr<PTHFileLookup> FileLookup;
-
-  /// IdDataTable - Array representing the mapping from persistent IDs to the
-  ///  data offset within the PTH file containing the information to
-  ///  reconsitute an IdentifierInfo.
-  const unsigned char* const IdDataTable;
-
-  /// SortedIdTable - Abstract data structure mapping from strings to
-  ///  persistent IDs.  This is used by get().
-  std::unique_ptr<PTHStringIdLookup> StringIdLookup;
-
-  /// NumIds - The number of identifiers in the PTH file.
-  const unsigned NumIds;
-
-  /// PP - The Preprocessor object that will use this PTHManager to create
-  ///  PTHLexer objects.
-  Preprocessor* PP = nullptr;
-
-  /// SpellingBase - The base offset within the PTH memory buffer that
-  ///  contains the cached spellings for literals.
-  const unsigned char* const SpellingBase;
-
-  /// OriginalSourceFile - A null-terminated C-string that specifies the name
-  ///  if the file (if any) that was to used to generate the PTH cache.
-  const char* OriginalSourceFile;
-
-  /// This constructor is intended to only be called by the static 'Create'
-  /// method.
-  PTHManager(std::unique_ptr<const llvm::MemoryBuffer> buf,
-             std::unique_ptr<PTHFileLookup> fileLookup,
-             const unsigned char *idDataTable,
-             std::unique_ptr<IdentifierInfo *[], llvm::FreeDeleter> perIDCache,
-             std::unique_ptr<PTHStringIdLookup> stringIdLookup, unsigned numIds,
-             const unsigned char *spellingBase, const char *originalSourceFile);
-
-  /// getSpellingAtPTHOffset - Used by PTHLexer classes to get the cached
-  ///  spelling for a token.
-  unsigned getSpellingAtPTHOffset(unsigned PTHOffset, const char*& Buffer);
-
-  /// GetIdentifierInfo - Used to reconstruct IdentifierInfo objects from the
-  ///  PTH file.
-  IdentifierInfo *GetIdentifierInfo(unsigned PersistentID) {
-    // Check if the IdentifierInfo has already been resolved.
-    if (IdentifierInfo* II = PerIDCache[PersistentID])
-      return II;
-    return LazilyCreateIdentifierInfo(PersistentID);
-  }
-  IdentifierInfo* LazilyCreateIdentifierInfo(unsigned PersistentID);
-
-public:
-  // The current PTH version.
-  enum { Version = 10 };
-
-  PTHManager(const PTHManager &) = delete;
-  PTHManager &operator=(const PTHManager &) = delete;
-  ~PTHManager() override;
-
-  /// getOriginalSourceFile - Return the full path to the original header
-  ///  file name that was used to generate the PTH cache.
-  const char* getOriginalSourceFile() const {
-    return OriginalSourceFile;
-  }
-
-  /// get - Return the identifier token info for the specified named identifier.
-  ///  Unlike the version in IdentifierTable, this returns a pointer instead
-  ///  of a reference.  If the pointer is nullptr then the IdentifierInfo cannot
-  ///  be found.
-  IdentifierInfo *get(StringRef Name) override;
-
-  /// Create - This method creates PTHManager objects.  The 'file' argument
-  ///  is the name of the PTH file.  This method returns nullptr upon failure.
-  static PTHManager *Create(StringRef file, DiagnosticsEngine &Diags);
-
-  void setPreprocessor(Preprocessor *pp) { PP = pp; }
-
-  /// CreateLexer - Return a PTHLexer that "lexes" the cached tokens for the
-  ///  specified file.  This method returns nullptr if no cached tokens exist.
-  ///  It is the responsibility of the caller to 'delete' the returned object.
-  PTHLexer *CreateLexer(FileID FID);
-
-  /// createStatCache - Returns a FileSystemStatCache object for use with
-  ///  FileManager objects.  These objects use the PTH data to speed up
-  ///  calls to stat by memoizing their results from when the PTH file
-  ///  was generated.
-  std::unique_ptr<FileSystemStatCache> createStatCache();
-};
-
-} // namespace clang
-
-#endif // LLVM_CLANG_LEX_PTHMANAGER_H
diff --git a/include/clang/Lex/Pragma.h b/include/clang/Lex/Pragma.h
index 4d74face52756..fb2942f0916b7 100644
--- a/include/clang/Lex/Pragma.h
+++ b/include/clang/Lex/Pragma.h
@@ -113,7 +113,7 @@ public:
   bool IsEmpty() const { return Handlers.empty(); }
 
   void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
-                    Token &FirstToken) override;
+                    Token &Tok) override;
 
   PragmaNamespace *getIfNamespace() override { return this; }
 };
diff --git a/include/clang/Lex/PreprocessingRecord.h b/include/clang/Lex/PreprocessingRecord.h
index 44d79d9b62290..027dd3ac5d55b 100644
--- a/include/clang/Lex/PreprocessingRecord.h
+++ b/include/clang/Lex/PreprocessingRecord.h
@@ -15,6 +15,7 @@
 #ifndef LLVM_CLANG_LEX_PREPROCESSINGRECORD_H
 #define LLVM_CLANG_LEX_PREPROCESSINGRECORD_H
 
+#include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Lex/PPCallbacks.h"
diff --git a/include/clang/Lex/Preprocessor.h b/include/clang/Lex/Preprocessor.h
index e718f5b6bbd00..64ddb5307fb0e 100644
--- a/include/clang/Lex/Preprocessor.h
+++ b/include/clang/Lex/Preprocessor.h
@@ -29,7 +29,6 @@
 #include "clang/Lex/ModuleLoader.h"
 #include "clang/Lex/ModuleMap.h"
 #include "clang/Lex/PPCallbacks.h"
-#include "clang/Lex/PTHLexer.h"
 #include "clang/Lex/Token.h"
 #include "clang/Lex/TokenLexer.h"
 #include "llvm/ADT/ArrayRef.h"
@@ -79,7 +78,6 @@ class PragmaNamespace;
 class PreprocessingRecord;
 class PreprocessorLexer;
 class PreprocessorOptions;
-class PTHManager;
 class ScratchBuffer;
 class TargetInfo;
 
@@ -143,10 +141,6 @@ class Preprocessor {
   /// External source of macros.
   ExternalPreprocessorSource *ExternalSource;
 
-  /// An optional PTHManager object used for getting tokens from
-  /// a token cache rather than lexing the original source file.
-  std::unique_ptr<PTHManager> PTH;
-
   /// A BumpPtrAllocator object used to quickly allocate and release
   /// objects internal to the Preprocessor.
   llvm::BumpPtrAllocator BP;
@@ -310,6 +304,9 @@ class Preprocessor {
   /// on the stem that is to be code completed.
   IdentifierInfo *CodeCompletionII = nullptr;
 
+  /// Range for the code completion token.
+  SourceRange CodeCompletionTokenRange;
+
   /// The directory that the main file should be considered to occupy,
   /// if it does not correspond to a real file (as happens when building a
   /// module).
@@ -322,6 +319,10 @@ class Preprocessor {
   /// This is used when loading a precompiled preamble.
   std::pair<int, bool> SkipMainFilePreamble;
 
+  /// Whether we hit an error due to reaching max allowed include depth. Allows
+  /// to avoid hitting the same error over and over again.
+  bool HasReachedMaxIncludeDepth = false;
+
 public:
   struct PreambleSkipInfo {
     SourceLocation HashTokenLoc;
@@ -389,19 +390,13 @@ private:
   /// The current top of the stack that we're lexing from if
   /// not expanding a macro and we are lexing directly from source code.
   ///
-  /// Only one of CurLexer, CurPTHLexer, or CurTokenLexer will be non-null.
+  /// Only one of CurLexer, or CurTokenLexer will be non-null.
   std::unique_ptr<Lexer> CurLexer;
 
-  /// The current top of stack that we're lexing from if
-  /// not expanding from a macro and we are lexing from a PTH cache.
-  ///
-  /// Only one of CurLexer, CurPTHLexer, or CurTokenLexer will be non-null.
-  std::unique_ptr<PTHLexer> CurPTHLexer;
-
   /// The current top of the stack what we're lexing from
   /// if not expanding a macro.
   ///
-  /// This is an alias for either CurLexer or  CurPTHLexer.
+  /// This is an alias for CurLexer.
   PreprocessorLexer *CurPPLexer = nullptr;
 
   /// Used to find the current FileEntry, if CurLexer is non-null
@@ -419,7 +414,6 @@ private:
   /// The kind of lexer we're currently working with.
   enum CurLexerKind {
     CLK_Lexer,
-    CLK_PTHLexer,
     CLK_TokenLexer,
     CLK_CachingLexer,
     CLK_LexAfterModuleImport
@@ -436,7 +430,6 @@ private:
     enum CurLexerKind           CurLexerKind;
     Module                     *TheSubmodule;
     std::unique_ptr<Lexer>      TheLexer;
-    std::unique_ptr<PTHLexer>   ThePTHLexer;
     PreprocessorLexer          *ThePPLexer;
     std::unique_ptr<TokenLexer> TheTokenLexer;
     const DirectoryLookup      *TheDirLookup;
@@ -445,13 +438,11 @@ private:
     // versions, only needed to pacify MSVC.
     IncludeStackInfo(enum CurLexerKind CurLexerKind, Module *TheSubmodule,
                      std::unique_ptr<Lexer> &&TheLexer,
-                     std::unique_ptr<PTHLexer> &&ThePTHLexer,
                      PreprocessorLexer *ThePPLexer,
                      std::unique_ptr<TokenLexer> &&TheTokenLexer,
                      const DirectoryLookup *TheDirLookup)
         : CurLexerKind(std::move(CurLexerKind)),
           TheSubmodule(std::move(TheSubmodule)), TheLexer(std::move(TheLexer)),
-          ThePTHLexer(std::move(ThePTHLexer)),
           ThePPLexer(std::move(ThePPLexer)),
           TheTokenLexer(std::move(TheTokenLexer)),
           TheDirLookup(std::move(TheDirLookup)) {}
@@ -723,6 +714,9 @@ private:
   /// The file ID for the PCH through header.
   FileID PCHThroughHeaderFileID;
 
+  /// Whether tokens are being skipped until a #pragma hdrstop is seen.
+  bool SkippingUntilPragmaHdrStop = false;
+
   /// Whether tokens are being skipped until the through header is seen.
   bool SkippingUntilPCHThroughHeader = false;
 
@@ -832,10 +826,6 @@ public:
   Builtin::Context &getBuiltinInfo() { return BuiltinInfo; }
   llvm::BumpPtrAllocator &getPreprocessorAllocator() { return BP; }
 
-  void setPTHManager(PTHManager* pm);
-
-  PTHManager *getPTHManager() { return PTH.get(); }
-
   void setExternalSource(ExternalPreprocessorSource *Source) {
     ExternalSource = Source;
   }
@@ -1122,6 +1112,10 @@ public:
     CodeComplete = nullptr;
   }
 
+  /// Hook used by the lexer to invoke the "included file" code
+  /// completion point.
+  void CodeCompleteIncludedFile(llvm::StringRef Dir, bool IsAngled);
+
   /// Hook used by the lexer to invoke the "natural language" code
   /// completion point.
   void CodeCompleteNaturalLanguage();
@@ -1131,6 +1125,16 @@ public:
     CodeCompletionII = Filter;
   }
 
+  /// Set the code completion token range for detecting replacement range later
+  /// on.
+  void setCodeCompletionTokenRange(const SourceLocation Start,
+                                   const SourceLocation End) {
+    CodeCompletionTokenRange = {Start, End};
+  }
+  SourceRange getCodeCompletionTokenRange() const {
+    return CodeCompletionTokenRange;
+  }
+
   /// Get the code completion token for filtering purposes.
   StringRef getCodeCompletionFilter() {
     if (CodeCompletionII)
@@ -1147,7 +1151,7 @@ public:
   void createPreprocessingRecord();
 
   /// Returns true if the FileEntry is the PCH through header.
-  bool isPCHThroughHeader(const FileEntry *File);
+  bool isPCHThroughHeader(const FileEntry *FE);
 
   /// True if creating a PCH with a through header.
   bool creatingPCHWithThroughHeader();
@@ -1155,11 +1159,19 @@ public:
   /// True if using a PCH with a through header.
   bool usingPCHWithThroughHeader();
 
-  /// Skip tokens until after the #include of the through header.
-  void SkipTokensUntilPCHThroughHeader();
+  /// True if creating a PCH with a #pragma hdrstop.
+  bool creatingPCHWithPragmaHdrStop();
+
+  /// True if using a PCH with a #pragma hdrstop.
+  bool usingPCHWithPragmaHdrStop();
 
-  /// Process directives while skipping until the through header is found.
-  void HandleSkippedThroughHeaderDirective(Token &Result,
+  /// Skip tokens until after the #include of the through header or
+  /// until after a #pragma hdrstop.
+  void SkipTokensWhileUsingPCH();
+
+  /// Process directives while skipping until the through header or
+  /// #pragma hdrstop is found.
+  void HandleSkippedDirectiveWhileUsingPCH(Token &Result,
                                            SourceLocation HashLoc);
 
   /// Enter the specified FileID as the main source file,
@@ -1173,7 +1185,7 @@ public:
   /// start lexing tokens from it instead of the current buffer.
   ///
   /// Emits a diagnostic, doesn't enter the file, and returns true on error.
-  bool EnterSourceFile(FileID CurFileID, const DirectoryLookup *Dir,
+  bool EnterSourceFile(FileID FID, const DirectoryLookup *Dir,
                        SourceLocation Loc);
 
   /// Add a Macro to the top of the include stack and start lexing
@@ -1182,7 +1194,7 @@ public:
   /// \param Args specifies the tokens input to a function-like macro.
   /// \param ILEnd specifies the location of the ')' for a function-like macro
   /// or the identifier for an object-like macro.
-  void EnterMacro(Token &Identifier, SourceLocation ILEnd, MacroInfo *Macro,
+  void EnterMacro(Token &Tok, SourceLocation ILEnd, MacroInfo *Macro,
                   MacroArgs *Args);
 
   /// Add a "macro" context to the top of the include stack,
@@ -1428,7 +1440,7 @@ public:
       CachedTokens[CachedLexPos-1] = Tok;
   }
 
-  /// Recompute the current lexer kind based on the CurLexer/CurPTHLexer/
+  /// Recompute the current lexer kind based on the CurLexer/
   /// CurTokenLexer pointers.
   void recomputeCurLexerKind();
 
@@ -1736,7 +1748,7 @@ public:
   void SetPoisonReason(IdentifierInfo *II, unsigned DiagID);
 
   /// Display reason for poisoned identifier.
-  void HandlePoisonedIdentifier(Token & Tok);
+  void HandlePoisonedIdentifier(Token & Identifier);
 
   void MaybeHandlePoisonedIdentifier(Token & Identifier) {
     if(IdentifierInfo * II = Identifier.getIdentifierInfo()) {
@@ -1801,7 +1813,7 @@ public:
   /// If not, emit a diagnostic and consume up until the eod.
   /// If \p EnableMacros is true, then we consider macros that expand to zero
   /// tokens as being ok.
-  void CheckEndOfDirective(const char *Directive, bool EnableMacros = false);
+  void CheckEndOfDirective(const char *DirType, bool EnableMacros = false);
 
   /// Read and discard all tokens remaining on the current line until
   /// the tok::eod token is found.
@@ -1830,7 +1842,7 @@ public:
   ///
   /// \returns true if the input filename was in <>'s or false if it was
   /// in ""'s.
-  bool GetIncludeFilenameSpelling(SourceLocation Loc,StringRef &Filename);
+  bool GetIncludeFilenameSpelling(SourceLocation Loc,StringRef &Buffer);
 
   /// Given a "foo" or \<foo> reference, look up the indicated file.
   ///
@@ -1873,7 +1885,7 @@ public:
 
   /// Lex an on-off-switch (C99 6.10.6p2) and verify that it is
   /// followed by EOD.  Return true if the token is not a valid on-off-switch.
-  bool LexOnOffSwitch(tok::OnOffSwitch &OOS);
+  bool LexOnOffSwitch(tok::OnOffSwitch &Result);
 
   bool CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef,
                       bool *ShadowFlag = nullptr);
@@ -1887,15 +1899,13 @@ private:
   void PushIncludeMacroStack() {
     assert(CurLexerKind != CLK_CachingLexer && "cannot push a caching lexer");
     IncludeMacroStack.emplace_back(CurLexerKind, CurLexerSubmodule,
-                                   std::move(CurLexer), std::move(CurPTHLexer),
-                                   CurPPLexer, std::move(CurTokenLexer),
-                                   CurDirLookup);
+                                   std::move(CurLexer), CurPPLexer,
+                                   std::move(CurTokenLexer), CurDirLookup);
     CurPPLexer = nullptr;
   }
 
   void PopIncludeMacroStack() {
     CurLexer = std::move(IncludeMacroStack.back().TheLexer);
-    CurPTHLexer = std::move(IncludeMacroStack.back().ThePTHLexer);
     CurPPLexer = IncludeMacroStack.back().ThePPLexer;
     CurTokenLexer = std::move(IncludeMacroStack.back().TheTokenLexer);
     CurDirLookup  = IncludeMacroStack.back().TheDirLookup;
@@ -1964,9 +1974,6 @@ private:
                                     bool FoundNonSkipPortion, bool FoundElse,
                                     SourceLocation ElseLoc = SourceLocation());
 
-  /// A fast PTH version of SkipExcludedConditionalBlock.
-  void PTHSkipExcludedConditionalBlock();
-
   /// Information about the result for evaluating an expression for a
   /// preprocessor directive.
   struct DirectiveEvalResult {
@@ -1993,7 +2000,7 @@ private:
   /// If an identifier token is read that is to be expanded as a macro, handle
   /// it and return the next token as 'Tok'.  If we lexed a token, return true;
   /// otherwise the caller should lex again.
-  bool HandleMacroExpandedIdentifier(Token &Tok, const MacroDefinition &MD);
+  bool HandleMacroExpandedIdentifier(Token &Identifier, const MacroDefinition &MD);
 
   /// Cache macro expanded tokens for TokenLexers.
   //
@@ -2013,7 +2020,7 @@ private:
   /// After reading "MACRO(", this method is invoked to read all of the formal
   /// arguments specified for the macro invocation.  Returns null on error.
   MacroArgs *ReadMacroCallArgumentList(Token &MacroName, MacroInfo *MI,
-                                       SourceLocation &ExpansionEnd);
+                                       SourceLocation &MacroEnd);
 
   /// If an identifier token is read that is to be expanded
   /// as a builtin macro, handle it and return the next token as 'Tok'.
@@ -2032,10 +2039,6 @@ private:
   /// start lexing tokens from it instead of the current buffer.
   void EnterSourceFileWithLexer(Lexer *TheLexer, const DirectoryLookup *Dir);
 
-  /// Add a lexer to the top of the include stack and
-  /// start getting tokens from it using the PTH cache.
-  void EnterSourceFileWithPTH(PTHLexer *PL, const DirectoryLookup *Dir);
-
   /// Set the FileID for the preprocessor predefines.
   void setPredefinesFileID(FileID FID) {
     assert(PredefinesFileID.isInvalid() && "PredefinesFileID already set!");
@@ -2066,8 +2069,7 @@ private:
   bool InCachingLexMode() const {
     // If the Lexer pointers are 0 and IncludeMacroStack is empty, it means
     // that we are past EOF, not that we are in CachingLex mode.
-    return !CurPPLexer && !CurTokenLexer && !CurPTHLexer &&
-           !IncludeMacroStack.empty();
+    return !CurPPLexer && !CurTokenLexer && !IncludeMacroStack.empty();
   }
 
   void EnterCachingLexMode();
@@ -2164,17 +2166,17 @@ private:
   void replayPreambleConditionalStack();
 
   // Macro handling.
-  void HandleDefineDirective(Token &Tok, bool ImmediatelyAfterTopLevelIfndef);
+  void HandleDefineDirective(Token &Tok, bool ImmediatelyAfterHeaderGuard);
   void HandleUndefDirective();
 
   // Conditional Inclusion.
-  void HandleIfdefDirective(Token &Tok, const Token &HashToken,
+  void HandleIfdefDirective(Token &Result, const Token &HashToken,
                             bool isIfndef, bool ReadAnyTokensBeforeDirective);
-  void HandleIfDirective(Token &Tok, const Token &HashToken,
+  void HandleIfDirective(Token &IfToken, const Token &HashToken,
                          bool ReadAnyTokensBeforeDirective);
-  void HandleEndifDirective(Token &Tok);
-  void HandleElseDirective(Token &Tok, const Token &HashToken);
-  void HandleElifDirective(Token &Tok, const Token &HashToken);
+  void HandleEndifDirective(Token &EndifToken);
+  void HandleElseDirective(Token &Result, const Token &HashToken);
+  void HandleElifDirective(Token &ElifToken, const Token &HashToken);
 
   // Pragmas.
   void HandlePragmaDirective(SourceLocation IntroducerLoc,
@@ -2190,11 +2192,12 @@ public:
   void HandlePragmaPopMacro(Token &Tok);
   void HandlePragmaIncludeAlias(Token &Tok);
   void HandlePragmaModuleBuild(Token &Tok);
+  void HandlePragmaHdrstop(Token &Tok);
   IdentifierInfo *ParsePragmaPushOrPopMacro(Token &Tok);
 
   // Return true and store the first token only if any CommentHandler
   // has inserted some tokens and getCommentRetentionState() is false.
-  bool HandleComment(Token &Token, SourceRange Comment);
+  bool HandleComment(Token &result, SourceRange Comment);
 
   /// A macro is used, update information about macros that need unused
   /// warnings.
diff --git a/include/clang/Lex/PreprocessorLexer.h b/include/clang/Lex/PreprocessorLexer.h
index b619f192f5306..de918a2153023 100644
--- a/include/clang/Lex/PreprocessorLexer.h
+++ b/include/clang/Lex/PreprocessorLexer.h
@@ -135,7 +135,7 @@ public:
   ///
   /// If the sequence parsed is not lexically legal, emit a diagnostic and
   /// return a result EOD token.
-  void LexIncludeFilename(Token &Result);
+  void LexIncludeFilename(Token &FilenameTok);
 
   /// Inform the lexer whether or not we are currently lexing a
   /// preprocessor directive.
diff --git a/include/clang/Lex/PreprocessorOptions.h b/include/clang/Lex/PreprocessorOptions.h
index 5134aeaa6a297..f1ac72c474281 100644
--- a/include/clang/Lex/PreprocessorOptions.h
+++ b/include/clang/Lex/PreprocessorOptions.h
@@ -54,6 +54,16 @@ public:
   /// definitions and expansions.
   bool DetailedRecord = false;
 
+  /// When true, we are creating or using a PCH where a #pragma hdrstop is
+  /// expected to indicate the beginning or end of the PCH.
+  bool PCHWithHdrStop = false;
+
+  /// When true, we are creating a PCH or creating the PCH object while
+  /// expecting a #pragma hdrstop to separate the two.  Allow for a
+  /// missing #pragma hdrstop, which generates a PCH for the whole file,
+  /// and creates an empty PCH object.
+  bool PCHWithHdrStopCreate = false;
+
   /// If non-empty, the filename used in an #include directive in the primary
   /// source file (or command-line preinclude) that is used to implement
   /// MSVC-style precompiled headers. When creating a PCH, after the #include
@@ -100,13 +110,6 @@ public:
   /// clients don't use them.
   bool WriteCommentListToPCH = true;
 
-  /// The implicit PTH input included at the start of the translation unit, or
-  /// empty.
-  std::string ImplicitPTHInclude;
-
-  /// If given, a PTH cache file to use for speeding up header parsing.
-  std::string TokenCache;
-
   /// When enabled, preprocessor is in a mode for parsing a single file only.
   ///
   /// Disables #includes of other files and if there are unresolved identifiers
@@ -194,8 +197,6 @@ public:
     ChainedIncludes.clear();
     DumpDeserializedPCHDecls = false;
     ImplicitPCHInclude.clear();
-    ImplicitPTHInclude.clear();
-    TokenCache.clear();
     SingleFileParseMode = false;
     LexEditorPlaceholders = true;
     RetainRemappedFileBuffers = true;
diff --git a/include/clang/Lex/TokenConcatenation.h b/include/clang/Lex/TokenConcatenation.h
index 60c182b509a4d..3199e36f0d269 100644
--- a/include/clang/Lex/TokenConcatenation.h
+++ b/include/clang/Lex/TokenConcatenation.h
@@ -29,7 +29,7 @@ namespace clang {
   /// and ")" next to each other is safe.
   ///
   class TokenConcatenation {
-    Preprocessor &PP;
+    const Preprocessor &PP;
 
     enum AvoidConcatInfo {
       /// By default, a token never needs to avoid concatenation.  Most tokens
@@ -56,7 +56,7 @@ namespace clang {
     /// method.
     char TokenInfo[tok::NUM_TOKENS];
   public:
-    TokenConcatenation(Preprocessor &PP);
+    TokenConcatenation(const Preprocessor &PP);
 
     bool AvoidConcat(const Token &PrevPrevTok,
                      const Token &PrevTok,
diff --git a/include/clang/Lex/TokenLexer.h b/include/clang/Lex/TokenLexer.h
index 98935ad9c4fa2..6aae9eec7bfa5 100644
--- a/include/clang/Lex/TokenLexer.h
+++ b/include/clang/Lex/TokenLexer.h
@@ -31,18 +31,17 @@ class VAOptExpansionContext;
 class TokenLexer {
   friend class Preprocessor;
 
-  /// Macro - The macro we are expanding from.  This is null if expanding a
-  /// token stream.
+  /// The macro we are expanding from. This is null if expanding a token stream.
   MacroInfo *Macro = nullptr;
 
-  /// ActualArgs - The actual arguments specified for a function-like macro, or
-  /// null.  The TokenLexer owns the pointed-to object.
+  /// The actual arguments specified for a function-like macro, or null. The
+  /// TokenLexer owns the pointed-to object.
   MacroArgs *ActualArgs = nullptr;
 
-  /// PP - The current preprocessor object we are expanding for.
+  /// The current preprocessor object we are expanding for.
   Preprocessor &PP;
 
-  /// Tokens - This is the pointer to an array of tokens that the macro is
+  /// This is the pointer to an array of tokens that the macro is
   /// defined to, with arguments expanded for function-like macros.  If this is
   /// a token stream, these are the tokens we are returning.  This points into
   /// the macro definition we are lexing from, a cache buffer that is owned by
@@ -52,14 +51,13 @@ class TokenLexer {
   /// may update the pointer as needed.
   const Token *Tokens;
 
-  /// NumTokens - This is the length of the Tokens array.
+  /// This is the length of the Tokens array.
   unsigned NumTokens;
 
   /// This is the index of the next token that Lex will return.
   unsigned CurTokenIdx;
 
-  /// ExpandLocStart/End - The source location range where this macro was
-  /// expanded.
+  /// The source location range where this macro was expanded.
   SourceLocation ExpandLocStart, ExpandLocEnd;
 
   /// Source location pointing at the source location entry chunk that
@@ -81,7 +79,7 @@ class TokenLexer {
   bool AtStartOfLine : 1;
   bool HasLeadingSpace : 1;
 
-  // NextTokGetsSpace - When this is true, the next token appended to the
+  // When this is true, the next token appended to the
   // output list during function argument expansion will get a leading space,
   // regardless of whether it had one to begin with or not. This is used for
   // placemarker support. If still true after function argument expansion, the
@@ -89,13 +87,13 @@ class TokenLexer {
   // expansion.
   bool NextTokGetsSpace : 1;
 
-  /// OwnsTokens - This is true if this TokenLexer allocated the Tokens
+  /// This is true if this TokenLexer allocated the Tokens
   /// array, and thus needs to free it when destroyed.  For simple object-like
   /// macros (for example) we just point into the token buffer of the macro
   /// definition, we don't make a copy of it.
   bool OwnsTokens : 1;
 
-  /// DisableMacroExpansion - This is true when tokens lexed from the TokenLexer
+  /// This is true when tokens lexed from the TokenLexer
   /// should not be subject to further macro expansion.
   bool DisableMacroExpansion : 1;
 
@@ -123,14 +121,14 @@ public:
   TokenLexer &operator=(const TokenLexer &) = delete;
   ~TokenLexer() { destroy(); }
 
-  /// Init - Initialize this TokenLexer to expand from the specified macro
+  /// Initialize this TokenLexer to expand from the specified macro
   /// with the specified argument information.  Note that this ctor takes
   /// ownership of the ActualArgs pointer.  ILEnd specifies the location of the
   /// ')' for a function-like macro or the identifier for an object-like macro.
-  void Init(Token &Tok, SourceLocation ILEnd, MacroInfo *MI,
-            MacroArgs *ActualArgs);
+  void Init(Token &Tok, SourceLocation ELEnd, MacroInfo *MI,
+            MacroArgs *Actuals);
 
-  /// Init - Initialize this TokenLexer with the specified token stream.
+  /// Initialize this TokenLexer with the specified token stream.
   /// This does not take ownership of the specified token vector.
   ///
   /// DisableExpansion is true when macro expansion of tokens lexed from this
@@ -138,12 +136,12 @@ public:
   void Init(const Token *TokArray, unsigned NumToks,
             bool DisableMacroExpansion, bool OwnsTokens);
 
-  /// isNextTokenLParen - If the next token lexed will pop this macro off the
+  /// If the next token lexed will pop this macro off the
   /// expansion stack, return 2.  If the next unexpanded token is a '(', return
   /// 1, otherwise return 0.
   unsigned isNextTokenLParen() const;
 
-  /// Lex - Lex and return a token from this macro stream.
+  /// Lex and return a token from this macro stream.
   bool Lex(Token &Tok);
 
   /// isParsingPreprocessorDirective - Return true if we are in the middle of a
@@ -153,8 +151,8 @@ public:
 private:
   void destroy();
 
-  /// isAtEnd - Return true if the next lex call will pop this macro off the
-  /// include stack.
+  /// Return true if the next lex call will pop this macro off the include
+  /// stack.
   bool isAtEnd() const {
     return CurTokenIdx == NumTokens;
   }
@@ -193,7 +191,7 @@ private:
   /// them into a string.  \p VCtx is used to determine which token represents
   /// the first __VA_OPT__ replacement token.
   ///
-  /// \param[in,out] ReplacementToks - Contains the current Replacement Tokens
+  /// \param[in,out] ResultToks - Contains the current Replacement Tokens
   /// (prior to rescanning and token pasting), the tail end of which represents
   /// the tokens just expanded through __VA_OPT__ processing.  These (sub)
   /// sequence of tokens are folded into one stringified token.
@@ -201,7 +199,7 @@ private:
   /// \param[in] VCtx - contains relevant contextual information about the
   /// state of the tokens around and including the __VA_OPT__ token, necessary
   /// for stringification.
-  void stringifyVAOPTContents(SmallVectorImpl<Token> &ReplacementToks,
+  void stringifyVAOPTContents(SmallVectorImpl<Token> &ResultToks,
                               const VAOptExpansionContext &VCtx,
                               SourceLocation VAOPTClosingParenLoc);
 
@@ -209,7 +207,7 @@ private:
   /// return preexpanded tokens from Tokens.
   void ExpandFunctionArguments();
 
-  /// HandleMicrosoftCommentPaste - In microsoft compatibility mode, /##/ pastes
+  /// In microsoft compatibility mode, /##/ pastes
   /// together to form a comment that comments out everything in the current
   /// macro, other active macros, and anything left on the current physical
   /// source line of the expanded buffer.  Handle this by returning the