Fix submodules

2 files changed, 0 insertions, 978 deletions

diff --git a/vim/bundle/YouCompleteMe b/vim/bundle/YouCompleteMe
new file mode 160000
+Subproject 0de1c0c9bb13ce82172b472c676035cd47cf6a6
diff --git a/vim/bundle/YouCompleteMe/python/ycm/vimsupport.py b/vim/bundle/YouCompleteMe/python/ycm/vimsupport.py
deleted file mode 100644
index c4a600c..0000000
--- a/vim/bundle/YouCompleteMe/python/ycm/vimsupport.py
+++ /dev/null
@@ -1,978 +0,0 @@
-# Copyright (C) 2011, 2012  Google Inc.
-#
-# This file is part of YouCompleteMe.
-#
-# YouCompleteMe is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# YouCompleteMe is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with YouCompleteMe.  If not, see <http://www.gnu.org/licenses/>.
-
-from __future__ import unicode_literals
-from __future__ import print_function
-from __future__ import division
-from __future__ import absolute_import
-from future import standard_library
-standard_library.install_aliases()
-from builtins import *  # noqa
-
-from future.utils import iterkeys
-import vim
-import os
-import tempfile
-import json
-import re
-from collections import defaultdict
-from ycmd.utils import ToUnicode, ToBytes
-from ycmd import user_options_store
-
-BUFFER_COMMAND_MAP = { 'same-buffer'      : 'edit',
-                       'horizontal-split' : 'split',
-                       'vertical-split'   : 'vsplit',
-                       'new-tab'          : 'tabedit' }
-
-FIXIT_OPENING_BUFFERS_MESSAGE_FORMAT = (
-    'The requested operation will apply changes to {0} files which are not '
-    'currently open. This will therefore open {0} new files in the hidden '
-    'buffers. The quickfix list can then be used to review the changes. No '
-    'files will be written to disk. Do you wish to continue?' )
-
-
-def CurrentLineAndColumn():
-  """Returns the 0-based current line and 0-based current column."""
-  # See the comment in CurrentColumn about the calculation for the line and
-  # column number
-  line, column = vim.current.window.cursor
-  line -= 1
-  return line, column
-
-
-def CurrentColumn():
-  """Returns the 0-based current column. Do NOT access the CurrentColumn in
-  vim.current.line. It doesn't exist yet when the cursor is at the end of the
-  line. Only the chars before the current column exist in vim.current.line."""
-
-  # vim's columns are 1-based while vim.current.line columns are 0-based
-  # ... but vim.current.window.cursor (which returns a (line, column) tuple)
-  # columns are 0-based, while the line from that same tuple is 1-based.
-  # vim.buffers buffer objects OTOH have 0-based lines and columns.
-  # Pigs have wings and I'm a loopy purple duck. Everything makes sense now.
-  return vim.current.window.cursor[ 1 ]
-
-
-def CurrentLineContents():
-  return ToUnicode( vim.current.line )
-
-
-def TextAfterCursor():
-  """Returns the text after CurrentColumn."""
-  return ToUnicode( vim.current.line[ CurrentColumn(): ] )
-
-
-def TextBeforeCursor():
-  """Returns the text before CurrentColumn."""
-  return ToUnicode( vim.current.line[ :CurrentColumn() ] )
-
-
-# Expects version_string in 'MAJOR.MINOR.PATCH' format, e.g. '7.4.301'
-def VimVersionAtLeast( version_string ):
-  major, minor, patch = [ int( x ) for x in version_string.split( '.' ) ]
-
-  # For Vim 7.4.301, v:version is '704'
-  actual_major_and_minor = GetIntValue( 'v:version' )
-  matching_major_and_minor = major * 100 + minor
-  if actual_major_and_minor != matching_major_and_minor:
-    return actual_major_and_minor > matching_major_and_minor
-
-  return GetBoolValue( 'has("patch{0}")'.format( patch ) )
-
-
-# Note the difference between buffer OPTIONS and VARIABLES; the two are not
-# the same.
-def GetBufferOption( buffer_object, option ):
-  # NOTE: We used to check for the 'options' property on the buffer_object which
-  # is available in recent versions of Vim and would then use:
-  #
-  #   buffer_object.options[ option ]
-  #
-  # to read the value, BUT this caused annoying flickering when the
-  # buffer_object was a hidden buffer (with option = 'ft'). This was all due to
-  # a Vim bug. Until this is fixed, we won't use it.
-
-  to_eval = 'getbufvar({0}, "&{1}")'.format( buffer_object.number, option )
-  return GetVariableValue( to_eval )
-
-
-def BufferModified( buffer_object ):
-  return bool( int( GetBufferOption( buffer_object, 'mod' ) ) )
-
-
-def GetUnsavedAndCurrentBufferData():
-  buffers_data = {}
-  for buffer_object in vim.buffers:
-    if not ( BufferModified( buffer_object ) or
-             buffer_object == vim.current.buffer ):
-      continue
-
-    buffers_data[ GetBufferFilepath( buffer_object ) ] = {
-      # Add a newline to match what gets saved to disk. See #1455 for details.
-      'contents': '\n'.join( ToUnicode( x ) for x in buffer_object ) + '\n',
-      'filetypes': FiletypesForBuffer( buffer_object )
-    }
-
-  return buffers_data
-
-
-def GetBufferNumberForFilename( filename, open_file_if_needed = True ):
-  return GetIntValue( u"bufnr('{0}', {1})".format(
-      EscapeForVim( os.path.realpath( filename ) ),
-      int( open_file_if_needed ) ) )
-
-
-def GetCurrentBufferFilepath():
-  return GetBufferFilepath( vim.current.buffer )
-
-
-def BufferIsVisible( buffer_number ):
-  if buffer_number < 0:
-    return False
-  window_number = GetIntValue( "bufwinnr({0})".format( buffer_number ) )
-  return window_number != -1
-
-
-def GetBufferFilepath( buffer_object ):
-  if buffer_object.name:
-    return buffer_object.name
-  # Buffers that have just been created by a command like :enew don't have any
-  # buffer name so we use the buffer number for that. Also, os.getcwd() throws
-  # an exception when the CWD has been deleted so we handle that.
-  try:
-    folder_path = os.getcwd()
-  except OSError:
-    folder_path = tempfile.gettempdir()
-  return os.path.join( folder_path, str( buffer_object.number ) )
-
-
-def UnplaceSignInBuffer( buffer_number, sign_id ):
-  if buffer_number < 0:
-    return
-  vim.command(
-    'try | exec "sign unplace {0} buffer={1}" | catch /E158/ | endtry'.format(
-        sign_id, buffer_number ) )
-
-
-def PlaceSign( sign_id, line_num, buffer_num, is_error = True ):
-  # libclang can give us diagnostics that point "outside" the file; Vim borks
-  # on these.
-  if line_num < 1:
-    line_num = 1
-
-  sign_name = 'YcmError' if is_error else 'YcmWarning'
-  vim.command( 'sign place {0} line={1} name={2} buffer={3}'.format(
-    sign_id, line_num, sign_name, buffer_num ) )
-
-
-def PlaceDummySign( sign_id, buffer_num, line_num ):
-    if buffer_num < 0 or line_num < 0:
-      return
-    vim.command( 'sign define ycm_dummy_sign' )
-    vim.command(
-      'sign place {0} name=ycm_dummy_sign line={1} buffer={2}'.format(
-        sign_id,
-        line_num,
-        buffer_num,
-      )
-    )
-
-
-def UnPlaceDummySign( sign_id, buffer_num ):
-    if buffer_num < 0:
-      return
-    vim.command( 'sign undefine ycm_dummy_sign' )
-    vim.command( 'sign unplace {0} buffer={1}'.format( sign_id, buffer_num ) )
-
-
-def ClearYcmSyntaxMatches():
-  matches = VimExpressionToPythonType( 'getmatches()' )
-  for match in matches:
-    if match[ 'group' ].startswith( 'Ycm' ):
-      vim.eval( 'matchdelete({0})'.format( match[ 'id' ] ) )
-
-
-# Returns the ID of the newly added match
-# Both line and column numbers are 1-based
-def AddDiagnosticSyntaxMatch( line_num,
-                              column_num,
-                              line_end_num = None,
-                              column_end_num = None,
-                              is_error = True ):
-  group = 'YcmErrorSection' if is_error else 'YcmWarningSection'
-
-  if not line_end_num:
-    line_end_num = line_num
-
-  line_num, column_num = LineAndColumnNumbersClamped( line_num, column_num )
-  line_end_num, column_end_num = LineAndColumnNumbersClamped( line_end_num,
-                                                              column_end_num )
-
-  if not column_end_num:
-    return GetIntValue(
-      "matchadd('{0}', '\%{1}l\%{2}c')".format( group, line_num, column_num ) )
-  else:
-    return GetIntValue(
-      "matchadd('{0}', '\%{1}l\%{2}c\_.\\{{-}}\%{3}l\%{4}c')".format(
-        group, line_num, column_num, line_end_num, column_end_num ) )
-
-
-# Clamps the line and column numbers so that they are not past the contents of
-# the buffer. Numbers are 1-based byte offsets.
-def LineAndColumnNumbersClamped( line_num, column_num ):
-  new_line_num = line_num
-  new_column_num = column_num
-
-  max_line = len( vim.current.buffer )
-  if line_num and line_num > max_line:
-    new_line_num = max_line
-
-  max_column = len( vim.current.buffer[ new_line_num - 1 ] )
-  if column_num and column_num > max_column:
-    new_column_num = max_column
-
-  return new_line_num, new_column_num
-
-
-def SetLocationList( diagnostics ):
-  """Diagnostics should be in qflist format; see ":h setqflist" for details."""
-  vim.eval( 'setloclist( 0, {0} )'.format( json.dumps( diagnostics ) ) )
-
-
-def SetQuickFixList( quickfix_list, focus = False, autoclose = False ):
-  """Populate the quickfix list and open it. List should be in qflist format:
-  see ":h setqflist" for details. When focus is set to True, the quickfix
-  window becomes the active window. When autoclose is set to True, the quickfix
-  window is automatically closed after an entry is selected."""
-  vim.eval( 'setqflist( {0} )'.format( json.dumps( quickfix_list ) ) )
-  OpenQuickFixList( focus, autoclose )
-
-
-def OpenQuickFixList( focus = False, autoclose = False ):
-  """Open the quickfix list to full width at the bottom of the screen with its
-  height automatically set to fit all entries. This behavior can be overridden
-  by using the YcmQuickFixOpened autocommand.
-  See the SetQuickFixList function for the focus and autoclose options."""
-  vim.command( 'botright copen' )
-
-  SetFittingHeightForCurrentWindow()
-
-  if autoclose:
-    # This autocommand is automatically removed when the quickfix window is
-    # closed.
-    vim.command( 'au WinLeave <buffer> q' )
-
-  if VariableExists( '#User#YcmQuickFixOpened' ):
-    vim.command( 'doautocmd User YcmQuickFixOpened' )
-
-  if not focus:
-    JumpToPreviousWindow()
-
-
-def SetFittingHeightForCurrentWindow():
-  window_width = GetIntValue( 'winwidth( 0 )' )
-  fitting_height = 0
-  for line in vim.current.buffer:
-    fitting_height += len( line ) // window_width + 1
-  vim.command( '{0}wincmd _'.format( fitting_height ) )
-
-
-def ConvertDiagnosticsToQfList( diagnostics ):
-  def ConvertDiagnosticToQfFormat( diagnostic ):
-    # See :h getqflist for a description of the dictionary fields.
-    # Note that, as usual, Vim is completely inconsistent about whether
-    # line/column numbers are 1 or 0 based in its various APIs. Here, it wants
-    # them to be 1-based. The documentation states quite clearly that it
-    # expects a byte offset, by which it means "1-based column number" as
-    # described in :h getqflist ("the first column is 1").
-    location = diagnostic[ 'location' ]
-    line_num = location[ 'line_num' ]
-
-    # libclang can give us diagnostics that point "outside" the file; Vim borks
-    # on these.
-    if line_num < 1:
-      line_num = 1
-
-    text = diagnostic[ 'text' ]
-    if diagnostic.get( 'fixit_available', False ):
-      text += ' (FixIt available)'
-
-    return {
-      'bufnr' : GetBufferNumberForFilename( location[ 'filepath' ] ),
-      'lnum'  : line_num,
-      'col'   : location[ 'column_num' ],
-      'text'  : text,
-      'type'  : diagnostic[ 'kind' ][ 0 ],
-      'valid' : 1
-    }
-
-  return [ ConvertDiagnosticToQfFormat( x ) for x in diagnostics ]
-
-
-def GetVimGlobalsKeys():
-  return vim.eval( 'keys( g: )' )
-
-
-def VimExpressionToPythonType( vim_expression ):
-  """Returns a Python type from the return value of the supplied Vim expression.
-  If the expression returns a list, dict or other non-string type, then it is
-  returned unmodified. If the string return can be converted to an
-  integer, returns an integer, otherwise returns the result converted to a
-  Unicode string."""
-
-  result = vim.eval( vim_expression )
-  if not ( isinstance( result, str ) or isinstance( result, bytes ) ):
-    return result
-
-  try:
-    return int( result )
-  except ValueError:
-    return ToUnicode( result )
-
-
-def HiddenEnabled( buffer_object ):
-  return bool( int( GetBufferOption( buffer_object, 'hid' ) ) )
-
-
-def BufferIsUsable( buffer_object ):
-  return not BufferModified( buffer_object ) or HiddenEnabled( buffer_object )
-
-
-def EscapedFilepath( filepath ):
-  return filepath.replace( ' ' , r'\ ' )
-
-
-# Both |line| and |column| need to be 1-based
-def TryJumpLocationInOpenedTab( filename, line, column ):
-  filepath = os.path.realpath( filename )
-
-  for tab in vim.tabpages:
-    for win in tab.windows:
-      if win.buffer.name == filepath:
-        vim.current.tabpage = tab
-        vim.current.window = win
-        vim.current.window.cursor = ( line, column - 1 )
-
-        # Center the screen on the jumped-to location
-        vim.command( 'normal! zz' )
-        return True
-  # 'filename' is not opened in any tab pages
-  return False
-
-
-# Maps User command to vim command
-def GetVimCommand( user_command, default = 'edit' ):
-  vim_command = BUFFER_COMMAND_MAP.get( user_command, default )
-  if vim_command == 'edit' and not BufferIsUsable( vim.current.buffer ):
-    vim_command = 'split'
-  return vim_command
-
-
-# Both |line| and |column| need to be 1-based
-def JumpToLocation( filename, line, column ):
-  # Add an entry to the jumplist
-  vim.command( "normal! m'" )
-
-  if filename != GetCurrentBufferFilepath():
-    # We prefix the command with 'keepjumps' so that opening the file is not
-    # recorded in the jumplist. So when we open the file and move the cursor to
-    # a location in it, the user can use CTRL-O to jump back to the original
-    # location, not to the start of the newly opened file.
-    # Sadly this fails on random occasions and the undesired jump remains in the
-    # jumplist.
-    user_command = user_options_store.Value( 'goto_buffer_command' )
-
-    if user_command == 'new-or-existing-tab':
-      if TryJumpLocationInOpenedTab( filename, line, column ):
-        return
-      user_command = 'new-tab'
-
-    vim_command = GetVimCommand( user_command )
-    try:
-      vim.command( 'keepjumps {0} {1}'.format( vim_command,
-                                               EscapedFilepath( filename ) ) )
-    # When the file we are trying to jump to has a swap file
-    # Vim opens swap-exists-choices dialog and throws vim.error with E325 error,
-    # or KeyboardInterrupt after user selects one of the options.
-    except vim.error as e:
-      if 'E325' not in str( e ):
-        raise
-      # Do nothing if the target file is still not opened (user chose (Q)uit)
-      if filename != GetCurrentBufferFilepath():
-        return
-    # Thrown when user chooses (A)bort in .swp message box
-    except KeyboardInterrupt:
-      return
-  vim.current.window.cursor = ( line, column - 1 )
-
-  # Center the screen on the jumped-to location
-  vim.command( 'normal! zz' )
-
-
-def NumLinesInBuffer( buffer_object ):
-  # This is actually less than obvious, that's why it's wrapped in a function
-  return len( buffer_object )
-
-
-# Calling this function from the non-GUI thread will sometimes crash Vim. At
-# the time of writing, YCM only uses the GUI thread inside Vim (this used to
-# not be the case).
-# We redraw the screen before displaying the message to avoid the "Press ENTER
-# or type command to continue" prompt when editing a new C-family file.
-def PostVimMessage( message ):
-  vim.command( "redraw | echohl WarningMsg | echom '{0}' | echohl None"
-               .format( EscapeForVim( ToUnicode( message ) ) ) )
-
-
-# Unlike PostVimMesasge, this supports messages with newlines in them because it
-# uses 'echo' instead of 'echomsg'. This also means that the message will NOT
-# appear in Vim's message log.
-def PostMultiLineNotice( message ):
-  vim.command( "echohl WarningMsg | echo '{0}' | echohl None"
-               .format( EscapeForVim( ToUnicode( message ) ) ) )
-
-
-def PresentDialog( message, choices, default_choice_index = 0 ):
-  """Presents the user with a dialog where a choice can be made.
-  This will be a dialog for gvim users or a question in the message buffer
-  for vim users or if `set guioptions+=c` was used.
-
-  choices is list of alternatives.
-  default_choice_index is the 0-based index of the default element
-  that will get choosen if the user hits <CR>. Use -1 for no default.
-
-  PresentDialog will return a 0-based index into the list
-  or -1 if the dialog was dismissed by using <Esc>, Ctrl-C, etc.
-
-  See also:
-    :help confirm() in vim (Note that vim uses 1-based indexes)
-
-  Example call:
-    PresentDialog("Is this a nice example?", ["Yes", "No", "May&be"])
-      Is this a nice example?
-      [Y]es, (N)o, May(b)e:"""
-  to_eval = "confirm('{0}', '{1}', {2})".format(
-    EscapeForVim( ToUnicode( message ) ),
-    EscapeForVim( ToUnicode( "\n" .join( choices ) ) ),
-    default_choice_index + 1 )
-  return int( vim.eval( to_eval ) ) - 1
-
-
-def Confirm( message ):
-  """Display |message| with Ok/Cancel operations. Returns True if the user
-  selects Ok"""
-  return bool( PresentDialog( message, [ "Ok", "Cancel" ] ) == 0 )
-
-
-def EchoText( text, log_as_message = True ):
-  def EchoLine( text ):
-    command = 'echom' if log_as_message else 'echo'
-    vim.command( "{0} '{1}'".format( command,
-                                     EscapeForVim( text ) ) )
-
-  for line in ToUnicode( text ).split( '\n' ):
-    EchoLine( line )
-
-
-# Echos text but truncates it so that it all fits on one line
-def EchoTextVimWidth( text ):
-  vim_width = GetIntValue( '&columns' )
-  truncated_text = ToUnicode( text )[ : int( vim_width * 0.9 ) ]
-  truncated_text.replace( '\n', ' ' )
-
-  old_ruler = GetIntValue( '&ruler' )
-  old_showcmd = GetIntValue( '&showcmd' )
-  vim.command( 'set noruler noshowcmd' )
-  vim.command( 'redraw' )
-
-  EchoText( truncated_text, False )
-
-  SetVariableValue( '&ruler', old_ruler )
-  SetVariableValue( '&showcmd', old_showcmd )
-
-
-def EscapeForVim( text ):
-  return ToUnicode( text.replace( "'", "''" ) )
-
-
-def CurrentFiletypes():
-  return VimExpressionToPythonType( "&filetype" ).split( '.' )
-
-
-def FiletypesForBuffer( buffer_object ):
-  # NOTE: Getting &ft for other buffers only works when the buffer has been
-  # visited by the user at least once, which is true for modified buffers
-  return GetBufferOption( buffer_object, 'ft' ).split( '.' )
-
-
-def VariableExists( variable ):
-  return GetBoolValue( "exists( '{0}' )".format( EscapeForVim( variable ) ) )
-
-
-def SetVariableValue( variable, value ):
-  vim.command( "let {0} = {1}".format( variable, json.dumps( value ) ) )
-
-
-def GetVariableValue( variable ):
-  return vim.eval( variable )
-
-
-def GetBoolValue( variable ):
-  return bool( int( vim.eval( variable ) ) )
-
-
-def GetIntValue( variable ):
-  return int( vim.eval( variable ) )
-
-
-def _SortChunksByFile( chunks ):
-  """Sort the members of the list |chunks| (which must be a list of dictionaries
-  conforming to ycmd.responses.FixItChunk) by their filepath. Returns a new
-  list in arbitrary order."""
-
-  chunks_by_file = defaultdict( list )
-
-  for chunk in chunks:
-    filepath = chunk[ 'range' ][ 'start' ][ 'filepath' ]
-    chunks_by_file[ filepath ].append( chunk )
-
-  return chunks_by_file
-
-
-def _GetNumNonVisibleFiles( file_list ):
-  """Returns the number of file in the iterable list of files |file_list| which
-  are not curerntly open in visible windows"""
-  return len(
-      [ f for f in file_list
-        if not BufferIsVisible( GetBufferNumberForFilename( f, False ) ) ] )
-
-
-def _OpenFileInSplitIfNeeded( filepath ):
-  """Ensure that the supplied filepath is open in a visible window, opening a
-  new split if required. Returns the buffer number of the file and an indication
-  of whether or not a new split was opened.
-
-  If the supplied filename is already open in a visible window, return just
-  return its buffer number. If the supplied file is not visible in a window
-  in the current tab, opens it in a new vertical split.
-
-  Returns a tuple of ( buffer_num, split_was_opened ) indicating the buffer
-  number and whether or not this method created a new split. If the user opts
-  not to open a file, or if opening fails, this method raises RuntimeError,
-  otherwise, guarantees to return a visible buffer number in buffer_num."""
-
-  buffer_num = GetBufferNumberForFilename( filepath, False )
-
-  # We only apply changes in the current tab page (i.e. "visible" windows).
-  # Applying changes in tabs does not lead to a better user experience, as the
-  # quickfix list no longer works as you might expect (doesn't jump into other
-  # tabs), and the complexity of choosing where to apply edits is significant.
-  if BufferIsVisible( buffer_num ):
-    # file is already open and visible, just return that buffer number (and an
-    # idicator that we *didn't* open a split)
-    return ( buffer_num, False )
-
-  # The file is not open in a visible window, so we open it in a split.
-  # We open the file with a small, fixed height. This means that we don't
-  # make the current buffer the smallest after a series of splits.
-  OpenFilename( filepath, {
-    'focus': True,
-    'fix': True,
-    'size': GetIntValue( '&previewheight' ),
-  } )
-
-  # OpenFilename returns us to the original cursor location. This is what we
-  # want, because we don't want to disorientate the user, but we do need to
-  # know the (now open) buffer number for the filename
-  buffer_num = GetBufferNumberForFilename( filepath, False )
-  if not BufferIsVisible( buffer_num ):
-    # This happens, for example, if there is a swap file and the user
-    # selects the "Quit" or "Abort" options. We just raise an exception to
-    # make it clear to the user that the abort has left potentially
-    # partially-applied changes.
-    raise RuntimeError(
-        'Unable to open file: {0}\nFixIt/Refactor operation '
-        'aborted prior to completion. Your files have not been '
-        'fully updated. Please use undo commands to revert the '
-        'applied changes.'.format( filepath ) )
-
-  # We opened this file in a split
-  return ( buffer_num, True )
-
-
-def ReplaceChunks( chunks ):
-  """Apply the source file deltas supplied in |chunks| to arbitrary files.
-  |chunks| is a list of changes defined by ycmd.responses.FixItChunk,
-  which may apply arbitrary modifications to arbitrary files.
-
-  If a file specified in a particular chunk is not currently open in a visible
-  buffer (i.e., one in a window visible in the current tab), we:
-    - issue a warning to the user that we're going to open new files (and offer
-      her the option to abort cleanly)
-    - open the file in a new split, make the changes, then hide the buffer.
-
-  If for some reason a file could not be opened or changed, raises RuntimeError.
-  Otherwise, returns no meaningful value."""
-
-  # We apply the edits file-wise for efficiency, and because we must track the
-  # file-wise offset deltas (caused by the modifications to the text).
-  chunks_by_file = _SortChunksByFile( chunks )
-
-  # We sort the file list simply to enable repeatable testing
-  sorted_file_list = sorted( iterkeys( chunks_by_file ) )
-
-  # Make sure the user is prepared to have her screen mutilated by the new
-  # buffers
-  num_files_to_open = _GetNumNonVisibleFiles( sorted_file_list )
-
-  if num_files_to_open > 0:
-    if not Confirm(
-            FIXIT_OPENING_BUFFERS_MESSAGE_FORMAT.format( num_files_to_open ) ):
-      return
-
-  # Store the list of locations where we applied changes. We use this to display
-  # the quickfix window showing the user where we applied changes.
-  locations = []
-
-  for filepath in sorted_file_list:
-    ( buffer_num, close_window ) = _OpenFileInSplitIfNeeded( filepath )
-
-    ReplaceChunksInBuffer( chunks_by_file[ filepath ],
-                           vim.buffers[ buffer_num ],
-                           locations )
-
-    # When opening tons of files, we don't want to have a split for each new
-    # file, as this simply does not scale, so we open the window, make the
-    # edits, then hide the window.
-    if close_window:
-      # Some plugins (I'm looking at you, syntastic) might open a location list
-      # for the window we just opened. We don't want that location list hanging
-      # around, so we close it. lclose is a no-op if there is no location list.
-      vim.command( 'lclose' )
-
-      # Note that this doesn't lose our changes. It simply "hides" the buffer,
-      # which can later be re-accessed via the quickfix list or `:ls`
-      vim.command( 'hide' )
-
-  # Open the quickfix list, populated with entries for each location we changed.
-  if locations:
-    SetQuickFixList( locations )
-
-  EchoTextVimWidth( "Applied " + str( len( chunks ) ) + " changes" )
-
-
-def ReplaceChunksInBuffer( chunks, vim_buffer, locations ):
-  """Apply changes in |chunks| to the buffer-like object |buffer|. Append each
-  chunk's start to the list |locations|"""
-
-  # We need to track the difference in length, but ensuring we apply fixes
-  # in ascending order of insertion point.
-  chunks.sort( key = lambda chunk: (
-    chunk[ 'range' ][ 'start' ][ 'line_num' ],
-    chunk[ 'range' ][ 'start' ][ 'column_num' ]
-  ) )
-
-  # Remember the line number we're processing. Negative line number means we
-  # haven't processed any lines yet (by nature of being not equal to any
-  # real line number).
-  last_line = -1
-
-  line_delta = 0
-  for chunk in chunks:
-    if chunk[ 'range' ][ 'start' ][ 'line_num' ] != last_line:
-      # If this chunk is on a different line than the previous chunk,
-      # then ignore previous deltas (as offsets won't have changed).
-      last_line = chunk[ 'range' ][ 'end' ][ 'line_num' ]
-      char_delta = 0
-
-    ( new_line_delta, new_char_delta ) = ReplaceChunk(
-      chunk[ 'range' ][ 'start' ],
-      chunk[ 'range' ][ 'end' ],
-      chunk[ 'replacement_text' ],
-      line_delta, char_delta,
-      vim_buffer,
-      locations )
-    line_delta += new_line_delta
-    char_delta += new_char_delta
-
-
-# Replace the chunk of text specified by a contiguous range with the supplied
-# text.
-# * start and end are objects with line_num and column_num properties
-# * the range is inclusive
-# * indices are all 1-based
-# * the returned character delta is the delta for the last line
-#
-# returns the delta (in lines and characters) that any position after the end
-# needs to be adjusted by.
-#
-# NOTE: Works exclusively with bytes() instances and byte offsets as returned
-# by ycmd and used within the Vim buffers
-def ReplaceChunk( start, end, replacement_text, line_delta, char_delta,
-                  vim_buffer, locations = None ):
-  # ycmd's results are all 1-based, but vim's/python's are all 0-based
-  # (so we do -1 on all of the values)
-  start_line = start[ 'line_num' ] - 1 + line_delta
-  end_line = end[ 'line_num' ] - 1 + line_delta
-
-  source_lines_count = end_line - start_line + 1
-  start_column = start[ 'column_num' ] - 1 + char_delta
-  end_column = end[ 'column_num' ] - 1
-  if source_lines_count == 1:
-    end_column += char_delta
-
-  # NOTE: replacement_text is unicode, but all our offsets are byte offsets,
-  # so we convert to bytes
-  replacement_lines = ToBytes( replacement_text ).splitlines( False )
-  if not replacement_lines:
-    replacement_lines = [ bytes( b'' ) ]
-  replacement_lines_count = len( replacement_lines )
-
-  end_existing_text = vim_buffer[ end_line ][ end_column : ]
-  start_existing_text = vim_buffer[ start_line ][ : start_column ]
-
-  new_char_delta = ( len( replacement_lines[ -1 ] )
-                     - ( end_column - start_column ) )
-  if replacement_lines_count > 1:
-    new_char_delta -= start_column
-
-  replacement_lines[ 0 ] = start_existing_text + replacement_lines[ 0 ]
-  replacement_lines[ -1 ] = replacement_lines[ -1 ] + end_existing_text
-
-  vim_buffer[ start_line : end_line + 1 ] = replacement_lines[:]
-
-  if locations is not None:
-    locations.append( {
-      'bufnr': vim_buffer.number,
-      'filename': vim_buffer.name,
-      # line and column numbers are 1-based in qflist
-      'lnum': start_line + 1,
-      'col': start_column + 1,
-      'text': replacement_text,
-      'type': 'F',
-    } )
-
-  new_line_delta = replacement_lines_count - source_lines_count
-  return ( new_line_delta, new_char_delta )
-
-
-def InsertNamespace( namespace ):
-  if VariableExists( 'g:ycm_csharp_insert_namespace_expr' ):
-    expr = GetVariableValue( 'g:ycm_csharp_insert_namespace_expr' )
-    if expr:
-      SetVariableValue( "g:ycm_namespace_to_insert", namespace )
-      vim.eval( expr )
-      return
-
-  pattern = '^\s*using\(\s\+[a-zA-Z0-9]\+\s\+=\)\?\s\+[a-zA-Z0-9.]\+\s*;\s*'
-  line = SearchInCurrentBuffer( pattern )
-  existing_line = LineTextInCurrentBuffer( line )
-  existing_indent = re.sub( r"\S.*", "", existing_line )
-  new_line = "{0}using {1};\n\n".format( existing_indent, namespace )
-  replace_pos = { 'line_num': line + 1, 'column_num': 1 }
-  ReplaceChunk( replace_pos, replace_pos, new_line, 0, 0 )
-  PostVimMessage( "Add namespace: {0}".format( namespace ) )
-
-
-def SearchInCurrentBuffer( pattern ):
-  return GetIntValue( "search('{0}', 'Wcnb')".format( EscapeForVim( pattern )))
-
-
-def LineTextInCurrentBuffer( line ):
-  return vim.current.buffer[ line ]
-
-
-def ClosePreviewWindow():
-  """ Close the preview window if it is present, otherwise do nothing """
-  vim.command( 'silent! pclose!' )
-
-
-def JumpToPreviewWindow():
-  """ Jump the vim cursor to the preview window, which must be active. Returns
-  boolean indicating if the cursor ended up in the preview window """
-  vim.command( 'silent! wincmd P' )
-  return vim.current.window.options[ 'previewwindow' ]
-
-
-def JumpToPreviousWindow():
-  """ Jump the vim cursor to its previous window position """
-  vim.command( 'silent! wincmd p' )
-
-
-def JumpToTab( tab_number ):
-  """Jump to Vim tab with corresponding number """
-  vim.command( 'silent! tabn {0}'.format( tab_number ) )
-
-
-def OpenFileInPreviewWindow( filename ):
-  """ Open the supplied filename in the preview window """
-  vim.command( 'silent! pedit! ' + filename )
-
-
-def WriteToPreviewWindow( message ):
-  """ Display the supplied message in the preview window """
-
-  # This isn't something that comes naturally to Vim. Vim only wants to show
-  # tags and/or actual files in the preview window, so we have to hack it a
-  # little bit. We generate a temporary file name and "open" that, then write
-  # the data to it. We make sure the buffer can't be edited or saved. Other
-  # approaches include simply opening a split, but we want to take advantage of
-  # the existing Vim options for preview window height, etc.
-
-  ClosePreviewWindow()
-
-  OpenFileInPreviewWindow( vim.eval( 'tempname()' ) )
-
-  if JumpToPreviewWindow():
-    # We actually got to the preview window. By default the preview window can't
-    # be changed, so we make it writable, write to it, then make it read only
-    # again.
-    vim.current.buffer.options[ 'modifiable' ] = True
-    vim.current.buffer.options[ 'readonly' ]   = False
-
-    vim.current.buffer[:] = message.splitlines()
-
-    vim.current.buffer.options[ 'buftype' ]    = 'nofile'
-    vim.current.buffer.options[ 'swapfile' ]   = False
-    vim.current.buffer.options[ 'modifiable' ] = False
-    vim.current.buffer.options[ 'readonly' ]   = True
-
-    # We need to prevent closing the window causing a warning about unsaved
-    # file, so we pretend to Vim that the buffer has not been changed.
-    vim.current.buffer.options[ 'modified' ]   = False
-
-    JumpToPreviousWindow()
-  else:
-    # We couldn't get to the preview window, but we still want to give the user
-    # the information we have. The only remaining option is to echo to the
-    # status area.
-    EchoText( message )
-
-
-def CheckFilename( filename ):
-  """Check if filename is openable."""
-  try:
-    # We don't want to check for encoding issues when trying to open the file
-    # so we open it in binary mode.
-    open( filename, mode = 'rb' ).close()
-  except TypeError:
-    raise RuntimeError( "'{0}' is not a valid filename".format( filename ) )
-  except IOError as error:
-    raise RuntimeError(
-      "filename '{0}' cannot be opened. {1}.".format( filename,
-                                                      error.strerror ) )
-
-
-def BufferIsVisibleForFilename( filename ):
-  """Check if a buffer exists for a specific file."""
-  buffer_number = GetBufferNumberForFilename( filename, False )
-  return BufferIsVisible( buffer_number )
-
-
-def CloseBuffersForFilename( filename ):
-  """Close all buffers for a specific file."""
-  buffer_number = GetBufferNumberForFilename( filename, False )
-  while buffer_number != -1:
-    vim.command( 'silent! bwipeout! {0}'.format( buffer_number ) )
-    new_buffer_number = GetBufferNumberForFilename( filename, False )
-    if buffer_number == new_buffer_number:
-      raise RuntimeError( "Buffer {0} for filename '{1}' should already be "
-                          "wiped out.".format( buffer_number, filename ) )
-    buffer_number = new_buffer_number
-
-
-def OpenFilename( filename, options = {} ):
-  """Open a file in Vim. Following options are available:
-  - command: specify which Vim command is used to open the file. Choices
-  are same-buffer, horizontal-split, vertical-split, and new-tab (default:
-  horizontal-split);
-  - size: set the height of the window for a horizontal split or the width for
-  a vertical one (default: '');
-  - fix: set the winfixheight option for a horizontal split or winfixwidth for
-  a vertical one (default: False). See :h winfix for details;
-  - focus: focus the opened file (default: False);
-  - watch: automatically watch for changes (default: False). This is useful
-  for logs;
-  - position: set the position where the file is opened (default: start).
-  Choices are start and end."""
-
-  # Set the options.
-  command = GetVimCommand( options.get( 'command', 'horizontal-split' ),
-                           'horizontal-split' )
-  size = ( options.get( 'size', '' ) if command in [ 'split', 'vsplit' ] else
-           '' )
-  focus = options.get( 'focus', False )
-
-  # There is no command in Vim to return to the previous tab so we need to
-  # remember the current tab if needed.
-  if not focus and command == 'tabedit':
-    previous_tab = GetIntValue( 'tabpagenr()' )
-  else:
-    previous_tab = None
-
-  # Open the file
-  CheckFilename( filename )
-  try:
-    vim.command( '{0}{1} {2}'.format( size, command, filename ) )
-  # When the file we are trying to jump to has a swap file,
-  # Vim opens swap-exists-choices dialog and throws vim.error with E325 error,
-  # or KeyboardInterrupt after user selects one of the options which actually
-  # opens the file (Open read-only/Edit anyway).
-  except vim.error as e:
-    if 'E325' not in str( e ):
-      raise
-
-    # Otherwise, the user might have chosen Quit. This is detectable by the
-    # current file not being the target file
-    if filename != GetCurrentBufferFilepath():
-      return
-  except KeyboardInterrupt:
-    # Raised when the user selects "Abort" after swap-exists-choices
-    return
-
-  _SetUpLoadedBuffer( command,
-                      filename,
-                      options.get( 'fix', False ),
-                      options.get( 'position', 'start' ),
-                      options.get( 'watch', False ) )
-
-  # Vim automatically set the focus to the opened file so we need to get the
-  # focus back (if the focus option is disabled) when opening a new tab or
-  # window.
-  if not focus:
-    if command == 'tabedit':
-      JumpToTab( previous_tab )
-    if command in [ 'split', 'vsplit' ]:
-      JumpToPreviousWindow()
-
-
-def _SetUpLoadedBuffer( command, filename, fix, position, watch ):
-  """After opening a buffer, configure it according to the supplied options,
-  which are as defined by the OpenFilename method."""
-
-  if command == 'split':
-    vim.current.window.options[ 'winfixheight' ] = fix
-  if command == 'vsplit':
-    vim.current.window.options[ 'winfixwidth' ] = fix
-
-  if watch:
-    vim.current.buffer.options[ 'autoread' ] = True
-    vim.command( "exec 'au BufEnter <buffer> :silent! checktime {0}'"
-                 .format( filename ) )
-
-  if position == 'end':
-    vim.command( 'silent! normal G zz' )