[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 26 matching lines @@
 #   * This has only been tested on gPrecise.
 
 
 import os
 import os.path
 import re
 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 FindChromeSrcFromFilename(filename):
   """Searches for the root of the Chromium checkout.
 
   Simply checks parent directories until it finds .gclient and src/.
 
   Args:
@@ skipping 107 matching lines @@
         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)
 
+  clang_path = clang_line.split(' ')[0]

[eroman, 2015/05/18 17:56:42]

This is too simplistic, the "path" may contain spaces.

For instance when using goma, my line starts with:

/usr/local/google/home/ericroman/goma/gomacc
../../third_party/llvm-build/Release+Asserts/bin/clang++

So there is at the very least going to be a space before clang++

How about instead taking clang path as everything from the start of the line up
until (and including) "clang++" ?

[asanka, 2015/05/18 19:36:48]

That's also a no-go due to the gomacc wrapper not liking the stdin source used
by SystemIncludeDirectoryFlags. I've updated the code to use shlex (so as not to
be confused by embedded whitespace), and looking at the first two tokens for a
Clang like command.

Let me know if we should be more general than this.

+  if clang_path.endswith('clang++'):
+    chrome_flags += SystemIncludeDirectoryFlags(clang_path, chrome_flags)
+
   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
   }