[Vim/YCM] Calculate system library paths based on Clang++ binary path.

tools/vim/chromium.ycm_extra_conf.py

 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # Autocompletion config for YouCompleteMe in Chromium.
 #
 # USAGE:
 #
 #   1. Install YCM [https://github.com/Valloric/YouCompleteMe]
 #          (Googlers should check out [go/ycm])
@@ skipping 22 matching lines @@
 #
 #   * That whole ninja & clang thing? We could support other configs if someone
 #     were willing to write the correct commands and a parser.
 #
 #   * This has only been tested on gPrecise.
 
 
 import os
 import os.path
 import re
+import shlex
 import subprocess
 import sys
 
 
-def SystemIncludeDirectoryFlags():
+def SystemIncludeDirectoryFlags(clang_binary, clang_flags):
   """Determines compile flags to include the system include directories.
 
   Use as a workaround for https://github.com/Valloric/YouCompleteMe/issues/303
 
+  Args:
+    clang_binary: (String) Path to clang binary.
+    clang_flags: (List of Strings) List of additional flags to clang. It may
+      affect the choice of system include directories if -stdlib= is specified.
+
   Returns:
     (List of Strings) Compile flags to append.
   """
+  all_flags = ['-v', '-E', '-x', 'c++'] + clang_flags + ['-']
   try:
     with open(os.devnull, 'rb') as DEVNULL:
-      output = subprocess.check_output(['clang', '-v', '-E', '-x', 'c++', '-'],
+      output = subprocess.check_output([clang_binary] + all_flags,
                                        stdin=DEVNULL, stderr=subprocess.STDOUT)
   except:
     return []
   includes_regex = r'#include <\.\.\.> search starts here:\s*' \
                    r'(.*?)End of search list\.'
   includes = re.search(includes_regex, output.decode(), re.DOTALL).group(1)
   flags = []
   for path in includes.splitlines():
     path = path.strip()
     if os.path.isdir(path):
       flags.append('-isystem')
       flags.append(path)
   return flags
 
-
-_system_include_flags = SystemIncludeDirectoryFlags()
-
 # Flags from YCM's default config.
-flags = [
-'-DUSE_CLANG_COMPLETER',
-'-std=c++11',
-'-x',
-'c++',
+_default_flags = [
+  '-DUSE_CLANG_COMPLETER',
+  '-std=c++11',
+  '-x',
+  'c++',
 ]
 
-
 def PathExists(*args):
   return os.path.exists(os.path.join(*args))
 
+def LooksLikeClangCommand(command):
+  return command.endswith('clang++') or command.endswith('clang')
 
 def FindChromeSrcFromFilename(filename):
   """Searches for the root of the Chromium checkout.
 
   Simply checks parent directories until it finds .gclient and src/.
 
   Args:
     filename: (String) Path to source file being edited.
 
   Returns:
@@ skipping 86 matching lines @@
   # clang command.
   clang_line = None
   for line in reversed(stdout.split('\n')):
     if 'clang' in line:
       clang_line = line
       break
   else:
     return chrome_flags
 
   # Parse flags that are important for YCM's purposes.
-  for flag in clang_line.split(' '):
+  clang_tokens = shlex.split(clang_line)
+  for flag in clang_tokens:
     if flag.startswith('-I'):
       # Relative paths need to be resolved, because they're relative to the
       # output dir, not the source.
       if flag[2] == '/':
         chrome_flags.append(flag)
       else:
         abs_path = os.path.normpath(os.path.join(out_dir, flag[2:]))
         chrome_flags.append('-I' + abs_path)
     elif flag.startswith('-std'):
       chrome_flags.append(flag)
     elif flag.startswith('-') and flag[1] in 'DWFfmO':
       if flag == '-Wno-deprecated-register' or flag == '-Wno-header-guard':
         # These flags causes libclang (3.3) to crash. Remove it until things
         # are fixed.
         continue
       chrome_flags.append(flag)
 
+  # Assume that the command for invoking clang++ looks like one of the
+  # following:
+  #   1) /path/to/clang/clang++ arguments
+  #   2) /some/wrapper /path/to/clang++ arguments
+  #
+  # We'll look for a token that looks like Clang command within the first two
+  # tokens of the command line and treat it as the clang++ binary. Using the
+  # command line upto the Clang-like token isn't always feasible since the
+  # wrapper may not like the invocation used by SystemIncludeDirectoryFlags()
+  # although the real clang++ binary does.
+  for command in clang_tokens[0:2]:
+    if LooksLikeClangCommand(command):
+      chrome_flags += SystemIncludeDirectoryFlags(command, chrome_flags)
+      break
+
   return chrome_flags
 
 
 def FlagsForFile(filename):
   """This is the main entry point for YCM. Its interface is fixed.
 
   Args:
     filename: (String) Path to source file being edited.
 
   Returns:
     (Dictionary)
       'flags': (List of Strings) Command line flags.
       'do_cache': (Boolean) True if the result should be cached.
   """
   chrome_root = FindChromeSrcFromFilename(filename)
   chrome_flags = GetClangCommandFromNinjaForFilename(chrome_root,
                                                      filename)
-  final_flags = flags + chrome_flags + _system_include_flags
+  final_flags = _default_flags + chrome_flags
 
   return {
     'flags': final_flags,
     'do_cache': True
   }