tools/vim/chromium.ycm_extra_conf.py

   1 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 # Autocompletion config for YouCompleteMe in Chromium.
   6 #
   7 # USAGE:
   8 #
   9 #   1. Install YCM [https://github.com/Valloric/YouCompleteMe]
  10 #          (Googlers should check out [go/ycm])
  11 #
  12 #   2. Point to this config file in your .vimrc:
  13 #          let g:ycm_global_ycm_extra_conf =
  14 #              '<chrome_depot>/src/tools/vim/chromium.ycm_extra_conf.py'
  15 #
  16 #   3. Profit
  17 #
  18 #
  19 # Usage notes:
  20 #
  21 #   * You must use ninja & clang to build Chromium.
  22 #
  23 #   * You must have run gyp_chromium and built Chromium recently.
  24 #
  25 #
  26 # Hacking notes:
  27 #
  28 #   * The purpose of this script is to construct an accurate enough command line
  29 #     for YCM to pass to clang so it can build and extract the symbols.
  30 #
  31 #   * Right now, we only pull the -I and -D flags. That seems to be sufficient
  32 #     for everything I've used it for.
  33 #
  34 #   * That whole ninja & clang thing? We could support other configs if someone
  35 #     were willing to write the correct commands and a parser.
  36 #
  37 #   * This has only been tested on gPrecise.
  38
  39
  40 import os
  41 import os.path
  42 import re
  43 import subprocess
  44 import sys
  45
  46
  47 def SystemIncludeDirectoryFlags():
  48   """Determines compile flags to include the system include directories.
  49
  50   Use as a workaround for https://github.com/Valloric/YouCompleteMe/issues/303
  51
  52   Returns:
  53     (List of Strings) Compile flags to append.
  54   """
  55   try:
  56     with open(os.devnull, 'rb') as DEVNULL:
  57       output = subprocess.check_output(['clang', '-v', '-E', '-x', 'c++', '-'],
  58                                        stdin=DEVNULL, stderr=subprocess.STDOUT)
  59   except:
  60     return []
  61   includes_regex = r'#include <\.\.\.> search starts here:\s*' \
  62                    r'(.*?)End of search list\.'
  63   includes = re.search(includes_regex, output.decode(), re.DOTALL).group(1)
  64   flags = []
  65   for path in includes.splitlines():
  66     path = path.strip()
  67     if os.path.isdir(path):
  68       flags.append('-isystem')
  69       flags.append(path)
  70   return flags
  71
  72
  73 _system_include_flags = SystemIncludeDirectoryFlags()
  74
  75 # Flags from YCM's default config.
  76 flags = [
  77 '-DUSE_CLANG_COMPLETER',
  78 '-std=c++11',
  79 '-x',
  80 'c++',
  81 ]
  82
  83
  84 def PathExists(*args):
  85   return os.path.exists(os.path.join(*args))
  86
  87
  88 def FindChromeSrcFromFilename(filename):
  89   """Searches for the root of the Chromium checkout.
  90
  91   Simply checks parent directories until it finds .gclient and src/.
  92
  93   Args:
  94     filename: (String) Path to source file being edited.
  95
  96   Returns:
  97     (String) Path of 'src/', or None if unable to find.
  98   """
  99   curdir = os.path.normpath(os.path.dirname(filename))
 100   while not (os.path.basename(os.path.realpath(curdir)) == 'src'
 101              and PathExists(curdir, 'DEPS')
 102              and (PathExists(curdir, '..', '.gclient')
 103                   or PathExists(curdir, '.git'))):
 104     nextdir = os.path.normpath(os.path.join(curdir, '..'))
 105     if nextdir == curdir:
 106       return None
 107     curdir = nextdir
 108   return curdir
 109
 110
 111 def GetClangCommandFromNinjaForFilename(chrome_root, filename):
 112   """Returns the command line to build |filename|.
 113
 114   Asks ninja how it would build the source file. If the specified file is a
 115   header, tries to find its companion source file first.
 116
 117   Args:
 118     chrome_root: (String) Path to src/.
 119     filename: (String) Path to source file being edited.
 120
 121   Returns:
 122     (List of Strings) Command line arguments for clang.
 123   """
 124   if not chrome_root:
 125     return []
 126
 127   # Generally, everyone benefits from including Chromium's src/, because all of
 128   # Chromium's includes are relative to that.
 129   chrome_flags = ['-I' + os.path.join(chrome_root)]
 130
 131   # Version of Clang used to compile Chromium can be newer then version of
 132   # libclang that YCM uses for completion. So it's possible that YCM's libclang
 133   # doesn't know about some used warning options, which causes compilation
 134   # warnings (and errors, because of '-Werror');
 135   chrome_flags.append('-Wno-unknown-warning-option')
 136
 137   # Default file to get a reasonable approximation of the flags for a Blink
 138   # file.
 139   blink_root = os.path.join(chrome_root, 'third_party', 'WebKit')
 140   default_blink_file = os.path.join(blink_root, 'Source', 'core', 'Init.cpp')
 141
 142   # Header files can't be built. Instead, try to match a header file to its
 143   # corresponding source file.
 144   if filename.endswith('.h'):
 145     # Add config.h to Blink headers, which won't have it by default.
 146     if filename.startswith(blink_root):
 147       chrome_flags.append('-include')
 148       chrome_flags.append(os.path.join(blink_root, 'Source', 'config.h'))
 149
 150     alternates = ['.cc', '.cpp']
 151     for alt_extension in alternates:
 152       alt_name = filename[:-2] + alt_extension
 153       if os.path.exists(alt_name):
 154         filename = alt_name
 155         break
 156     else:
 157       if filename.startswith(blink_root):
 158         # If this is a Blink file, we can at least try to get a reasonable
 159         # approximation.
 160         filename = default_blink_file
 161       else:
 162         # If this is a standalone .h file with no source, the best we can do is
 163         # try to use the default flags.
 164         return chrome_flags
 165
 166   sys.path.append(os.path.join(chrome_root, 'tools', 'vim'))
 167   from ninja_output import GetNinjaOutputDirectory
 168   out_dir = os.path.realpath(GetNinjaOutputDirectory(chrome_root))
 169
 170   # Ninja needs the path to the source file relative to the output build
 171   # directory.
 172   rel_filename = os.path.relpath(os.path.realpath(filename), out_dir)
 173
 174   # Ask ninja how it would build our source file.
 175   p = subprocess.Popen(['ninja', '-v', '-C', out_dir, '-t',
 176                         'commands', rel_filename + '^'],
 177                        stdout=subprocess.PIPE)
 178   stdout, stderr = p.communicate()
 179   if p.returncode:
 180     return chrome_flags
 181
 182   # Ninja might execute several commands to build something. We want the last
 183   # clang command.
 184   clang_line = None
 185   for line in reversed(stdout.split('\n')):
 186     if 'clang' in line:
 187       clang_line = line
 188       break
 189   else:
 190     return chrome_flags
 191
 192   # Parse flags that are important for YCM's purposes.
 193   for flag in clang_line.split(' '):
 194     if flag.startswith('-I'):
 195       # Relative paths need to be resolved, because they're relative to the
 196       # output dir, not the source.
 197       if flag[2] == '/':
 198         chrome_flags.append(flag)
 199       else:
 200         abs_path = os.path.normpath(os.path.join(out_dir, flag[2:]))
 201         chrome_flags.append('-I' + abs_path)
 202     elif flag.startswith('-std'):
 203       chrome_flags.append(flag)
 204     elif flag.startswith('-') and flag[1] in 'DWFfmO':
 205       if flag == '-Wno-deprecated-register' or flag == '-Wno-header-guard':
 206         # These flags causes libclang (3.3) to crash. Remove it until things
 207         # are fixed.
 208         continue
 209       chrome_flags.append(flag)
 210
 211   return chrome_flags
 212
 213
 214 def FlagsForFile(filename):
 215   """This is the main entry point for YCM. Its interface is fixed.
 216
 217   Args:
 218     filename: (String) Path to source file being edited.
 219
 220   Returns:
 221     (Dictionary)
 222       'flags': (List of Strings) Command line flags.
 223       'do_cache': (Boolean) True if the result should be cached.
 224   """
 225   chrome_root = FindChromeSrcFromFilename(filename)
 226   chrome_flags = GetClangCommandFromNinjaForFilename(chrome_root,
 227                                                      filename)
 228   final_flags = flags + chrome_flags + _system_include_flags
 229
 230   return {
 231     'flags': final_flags,
 232     'do_cache': True
 233   }