keeps include path order when emulate msvc compiler

[comicfans44]

Summary

clang will drop user supplied include path if it's already in system include paths to emulate gcc. if two files with same name both exist in user path and system path, and user set system path first in arguments, this leads different behavior to msvc. this patch preserve user include path order when emulating msvc.

clang/lib/Frontend/InitHeaderSearch.cpp

public:
   /// AddDefaultSystemIncludePaths - Adds the default system include paths so
   ///  that e.g. stdio.h is found.
   void AddDefaultIncludePaths(const LangOptions &Lang,
                               const llvm::Triple &triple,
                               const HeaderSearchOptions &HSOpts);
 
   /// Realize - Merges all search path lists into one list and send it to
   /// HeaderSearch.
-  void Realize(const LangOptions &Lang);
+  void Realize(const LangOptions &Lang, bool msvc);
 };
 
 }  // end anonymous namespace.
 
 static bool CanPrefixSysroot(StringRef Path) {
 #if defined(LLVM_ON_WIN32)
   return !Path.empty() && llvm::sys::path::is_separator(Path[0]);
 #else
if (HSOpts.UseStandardSystemIncludes) {
     }
   }
 }
 
 /// RemoveDuplicates - If there are duplicate directory entries in the specified
 /// search list, remove the later (dead) ones.  Returns the number of non-system
 /// headers removed, which is used to update NumAngled.
 static unsigned RemoveDuplicates(std::vector<DirectoryLookup> &SearchList,
-                                 unsigned First, bool Verbose) {
+                                 unsigned First, bool Verbose, bool msvc) {
   llvm::SmallPtrSet<const DirectoryEntry *, 8> SeenDirs;
   llvm::SmallPtrSet<const DirectoryEntry *, 8> SeenFrameworkDirs;
   llvm::SmallPtrSet<const HeaderMap *, 8> SeenHeaderMaps;
   unsigned NonSystemRemoved = 0;
   for (unsigned i = First; i != SearchList.size(); ++i) {
     unsigned DirToRemove = i;
 
     const DirectoryLookup &CurEntry = SearchList[i];
for (unsigned i = First; i != SearchList.size(); ++i) {
 
     // If we have a normal #include dir/framework/headermap that is shadowed
     // later in the chain by a system include location, we actually want to
     // ignore the user's request and drop the user dir... keeping the system
     // dir.  This is weird, but required to emulate GCC's search path correctly.
     //
     // Since dupes of system dirs are rare, just rescan to find the original
     // that we're nuking instead of using a DenseMap.
-    if (CurEntry.getDirCharacteristic() != SrcMgr::C_User) {
+    if (!msvc && (CurEntry.getDirCharacteristic() != SrcMgr::C_User)) {
       // Find the dir that this is the same of.
       unsigned FirstDir;
       for (FirstDir = First;; ++FirstDir) {
         assert(FirstDir != i && "Didn't find dupe?");
 
         const DirectoryLookup &SearchEntry = SearchList[FirstDir];
 
         // If these are different lookup types, then they can't be the dupe.
for (unsigned i = First; i != SearchList.size(); ++i) {
     // DirToRemove (usually the current dir).
     SearchList.erase(SearchList.begin()+DirToRemove);
     --i;
   }
   return NonSystemRemoved;
 }
 
 
-void InitHeaderSearch::Realize(const LangOptions &Lang) {
+void InitHeaderSearch::Realize(const LangOptions &Lang, bool msvc) {
   // Concatenate ANGLE+SYSTEM+AFTER chains together into SearchList.
   std::vector<DirectoryLookup> SearchList;
   SearchList.reserve(IncludePath.size());
 
   // Quoted arguments go first.
   for (auto &Include : IncludePath)
     if (Include.first == Quoted)
       SearchList.push_back(Include.second);
 
   // Deduplicate and remember index.
-  RemoveDuplicates(SearchList, 0, Verbose);
+  RemoveDuplicates(SearchList, 0, Verbose, msvc);
   unsigned NumQuoted = SearchList.size();
 
   for (auto &Include : IncludePath)
     if (Include.first == Angled || Include.first == IndexHeaderMap)
       SearchList.push_back(Include.second);
 
-  RemoveDuplicates(SearchList, NumQuoted, Verbose);
+  RemoveDuplicates(SearchList, NumQuoted, Verbose, msvc);
   unsigned NumAngled = SearchList.size();
 
   for (auto &Include : IncludePath)
     if (Include.first == System || Include.first == ExternCSystem ||
         (!Lang.ObjC1 && !Lang.CPlusPlus && Include.first == CSystem) ||
         (/*FIXME !Lang.ObjC1 && */ Lang.CPlusPlus &&
          Include.first == CXXSystem) ||
         (Lang.ObjC1 && !Lang.CPlusPlus && Include.first == ObjCSystem) ||
         (Lang.ObjC1 && Lang.CPlusPlus && Include.first == ObjCXXSystem))
       SearchList.push_back(Include.second);
 
   for (auto &Include : IncludePath)
     if (Include.first == After)
       SearchList.push_back(Include.second);
 
   // Remove duplicates across both the Angled and System directories.  GCC does
   // this and failing to remove duplicates across these two groups breaks
   // #include_next.
-  unsigned NonSystemRemoved = RemoveDuplicates(SearchList, NumQuoted, Verbose);
+  unsigned NonSystemRemoved =
+      RemoveDuplicates(SearchList, NumQuoted, Verbose, msvc);
   NumAngled -= NonSystemRemoved;
 
   bool DontSearchCurDir = false;  // TODO: set to true if -I- is set?
   Headers.SetSearchPaths(SearchList, NumQuoted, NumAngled, DontSearchCurDir);
 
   Headers.SetSystemHeaderPrefixes(SystemHeaderPrefixes);
 
   // If verbose, print the list of directories that will be searched.
void clang::ApplyHeaderSearchOptions(HeaderSearch &HS,
   if (HSOpts.UseBuiltinIncludes) {
     // Set up the builtin include directory in the module map.
     SmallString<128> P = StringRef(HSOpts.ResourceDir);
     llvm::sys::path::append(P, "include");
     if (const DirectoryEntry *Dir = HS.getFileMgr().getDirectory(P))
       HS.getModuleMap().setBuiltinIncludeDir(Dir);
   }
 
-  Init.Realize(Lang);
+  Init.Realize(Lang,
+               Triple.getEnvironment() == llvm::Triple::EnvironmentType::MSVC);
 }