Add a YouCompleteMe config for Chromium.

tools/vim/chromium.ycm_extra_conf.py

+# Autocompletion config for YouCompleteMe in Chromium.
+#
+# USAGE:
+#
+#   1. Install YCM [https://github.com/Valloric/YouCompleteMe]
+#          (Googlers should check out [go/ycm])
+#
+#   2. Point to this config file in your .vimrc:
+#          let g:ycm_global_ycm_extra_conf =
+#              '<chrome_depot>/src/tools/vim/chromium.ycm_extra_conf.py'
+#
+#   3. Profit
+#
+#
+# Usage notes:
+#
+#   * You must use ninja & clang to build Chromium.
+#
+#   * You must have run gyp_chromium and built Chromium recently.
+#
+#
+# Hacking notes:
+#
+#   * The purpose of this script is to construct an accurate enough command line
+#     for YCM to pass to clang so it can build and extract the symbols.
+#
+#   * Right now, we only pull the -I and -D flags. That seems to be sufficient
+#     for everything I've used it for.
+#
+#   * 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 subprocess
+
+# Flags from YCM's default config.
+flags = [
+'-Wall',
+'-Wextra',
+'-Werror',
+'-Wno-long-long',
+'-Wno-variadic-macros',
+'-Wno-unused-parameter',
+'-fexceptions',
+'-DNDEBUG',
+'-DUSE_CLANG_COMPLETER',
+'-std=c++11',
+'-x',
+'c++',
+]
+
+
+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:
+    (String) Path of 'src/', or None if unable to find.
+  """
+  curdir = os.path.normpath(os.path.dirname(filename))
+  while not (os.path.exists(os.path.join(curdir, '.gclient'))
+             and os.path.exists(os.path.join(curdir, 'src'))):
+    nextdir = os.path.normpath(os.path.join(curdir, '..'))
+    if nextdir == curdir:
+      return None
+    curdir = nextdir
+  return os.path.join(curdir, 'src')
+
+
+def GetClangCommandFromNinjaForFilename(chrome_root, filename):
+  """Returns the command line to build |filename|.
+
+  Figures out where the .o file for this source file will end up. Then asks
+  ninja how it would build that object and parses the result.
+
+  Args:
+    chrome_root: (String) Path to src/.
+    filename: (String) Path to source file being edited.
+
+  Returns:
+    (List of Strings) Command line arguments for clang.
+  """
+  if not chrome_root:
+    return []
+
+  # First we need to determine which directory this source file's .o will end up
+  # in. This should be the same relative path as the source file, but in
+  # out/Release/obj/.
+  dirname = os.path.dirname(filename)
+  # Cut off the common part and /.
+  rel_dirname = dirname[len(chrome_root)+1:]
+  out_dir = os.path.abspath(os.path.join(
+      chrome_root, 'out', 'Release', 'obj', rel_dirname))
+
+  # The object file will be prefixed with its GYP target. We have no idea what
+  # the target is, so we search for files with the same name.
+  # First, remove the extension so .cc and .h map to the same .o.
+  filebase = os.path.basename(filename[:filename.find('.')])
+  obj_path = None
+  for name in os.listdir(out_dir):

[jamesr, 2013/02/05 21:15:53]

This won't work for files that haven't been compiled yet, will it?  ninja has to
know the mapping of source files -> output files in a way that doesn't involve
going through the output dir so that it can know what to rebuild when files
change

[jamesr, 2013/02/05 21:26:07]

FWIW wrapping this in a try:/except: is needed, but this seems to work OK-ish
even if there isn't a build with this

+    # The .d file is slightly more likely to exist, so check for that.
+    if name.endswith('.' + filebase + '.o.d'):
+      # But really we want to build the .o, so trim off the .d.

[Nico, 2013/02/05 21:26:16]

Urgh.

Could you do something like `ninja -C out/Release -t commands | grep filename`
and have a whitelist filter for the ones you need instead? (-IDFfmOW, -isysroot,
-arch are probably all?)



…oh, I see you're doing this below. Just pass `../../path/to/file.cc^` to ninja
below, that'll build the first dependent of file.cc and you don't need to do
this dance to get an .o name.

+      obj_path = os.path.join('obj', rel_dirname, name[:-2])
+  if not obj_path:
+    return []
+
+  # Ask ninja how it would build our .o file.
+  p = subprocess.Popen(['ninja', '-v', '-C', chrome_root + '/out/Release', '-t',
+                        'commands', obj_path],
+                       stdout=subprocess.PIPE)
+  stdout, stderr = p.communicate()
+  if p.returncode:
+    return []
+
+  # Ninja might execute several commands to build something. We want the last
+  # clang command.
+  clang_line = None
+  for line in reversed(stdout.split('\n')):
+    if line.startswith('clang'):
+      clang_line = line
+      break
+  if not clang_line:
+    return []
+
+  # Parse out the -I and -D flags. These seem to be the only ones that are
+  # important for YCM's purposes.
+  chrome_flags = []
+  for flag in clang_line.split(' '):
+    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(
+            chrome_root, 'out', 'Release', flag[2:]))
+        chrome_flags.append('-I' + abs_path)
+    elif flag.startswith('-D'):
+      chrome_flags.append(flag)
+
+  # Also include Chromium's src/, because all of Chromium's includes are
+  # relative to that.
+  chrome_flags.append('-I' + os.path.join(chrome_root))
+  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
+
+  return {
+    'flags': final_flags,
+    'do_cache': True
+  }