def HandleFileParseRequest( self, block = False ): if not self.IsServerReady(): return current_buffer = self.CurrentBuffer() # Order is important here: # FileParseRequestReady has a low cost, while # NativeFiletypeCompletionUsable is a blocking server request if ( not current_buffer.IsResponseHandled() and current_buffer.FileParseRequestReady( block ) and self.NativeFiletypeCompletionUsable() ): if self._user_options[ 'show_diagnostics_ui' ]: # Forcefuly update the location list, etc. from the parse request when # doing something like :YcmDiags async_diags = any( self._message_poll_requests.get( filetype ) for filetype in vimsupport.CurrentFiletypes() ) current_buffer.UpdateDiagnostics( block or not async_diags ) else: # If the user disabled diagnostics, we just want to check # the _latest_file_parse_request for any exception or UnknownExtraConf # response, to allow the server to raise configuration warnings, etc. # to the user. We ignore any other supplied data. current_buffer.GetResponse() # We set the file parse request as handled because we want to prevent # repeated issuing of the same warnings/errors/prompts. Setting this # makes IsRequestHandled return True until the next request is created. # # Note: it is the server's responsibility to determine the frequency of # error/warning/prompts when receiving a FileReadyToParse event, but # it is our responsibility to ensure that we only apply the # warning/error/prompt received once (for each event). current_buffer.MarkResponseHandled()
def LastEnteredCharIsIdentifierChar(): line, current_column = vimsupport.CurrentLineContentsAndCodepointColumn() if current_column - 1 < 0: return False filetype = vimsupport.CurrentFiletypes()[0] return (identifier_utils.StartOfLongestIdentifierEndingAtIndex( line, current_column, filetype) != current_column)
def SendSignatureHelpRequest( self ): filetype = vimsupport.CurrentFiletypes()[ 0 ] if not self._signature_help_available_requests[ filetype ].Done(): return sig_help_available = self._signature_help_available_requests[ filetype ].Response() if sig_help_available == 'NO': return if sig_help_available == 'PENDING': # Send another /signature_help_available request self._signature_help_available_requests[ filetype ].Start( filetype ) return if not self.NativeFiletypeCompletionUsable(): return if not self._latest_completion_request: return request_data = self._latest_completion_request.request_data.copy() request_data[ 'signature_help_state' ] = self._signature_help_state.state self._AddExtraConfDataIfNeeded( request_data ) self._latest_signature_help_request = SignatureHelpRequest( request_data ) self._latest_signature_help_request.Start()
def IsAllowed(self, diagnostic): # NOTE: in this class's implementation, we ask vimsupport for # the current filetypes and delegate automatically; it is probably, # more efficient, however, to call SubsetForTypes() and reuse # the returned DiagnosticFilter if it will be checked repeatedly. filetypes = vimsupport.CurrentFiletypes() return self.SubsetForTypes(filetypes).IsAllowed(diagnostic)
def OnCompleteDone(self): if not self.Done(): return if 'cs' in vimsupport.CurrentFiletypes(): self._OnCompleteDone_Csharp() else: extra_datas = self._GetExtraDataUserMayHaveCompleted() if not extra_datas: return # If we have user_data in completions (8.0.1493 or later), then we would # only ever return max. 1 completion here. However, if we had to guess, it # is possible that we matched multiple completion items (e.g. for # overloads, or similar classes in multiple packages). In any case, rather # than prompting the user and disturbing her workflow, we just apply the # first one. This might be wrong, but the solution is to use a newer # version of Vim which supports user_data on completion items completion_extra_data = extra_datas[0] self._OnCompleteDone_FixIt(completion_extra_data) snippet = completion_extra_data.get('snippet', None) if snippet: self._OnCompleteDone_Snippet(snippet)
def SendSignatureHelpRequest( self ): """Send a signature help request, if we're ready to. Return whether or not a request was sent (and should be checked later)""" if not self.NativeFiletypeCompletionUsable(): return False for filetype in vimsupport.CurrentFiletypes(): if not self.SignatureHelpAvailableRequestComplete( filetype ): continue sig_help_available = self._signature_help_available_requests[ filetype ].Response() if sig_help_available == 'NO': continue if sig_help_available == 'PENDING': # Send another /signature_help_available request self._signature_help_available_requests[ filetype ].Start( filetype ) continue if not self._latest_completion_request: return False request_data = self._latest_completion_request.request_data.copy() request_data[ 'signature_help_state' ] = self._signature_help_state.state self._AddExtraConfDataIfNeeded( request_data ) self._latest_signature_help_request = SignatureHelpRequest( request_data ) self._latest_signature_help_request.Start() return True return False
def OnCompleteDone(self): if not self.Done(): return if 'cs' in vimsupport.CurrentFiletypes(): self._OnCompleteDone_Csharp() else: self._OnCompleteDone_FixIt()
def CurrentFiletypeCompletionEnabled(self): filetypes = vimsupport.CurrentFiletypes() filetype_to_disable = self._user_options[ 'filetype_specific_completion_to_disable'] if '*' in filetype_to_disable: return False else: return not any([x in filetype_to_disable for x in filetypes])
def OnBufferVisit(self): for filetype in vimsupport.CurrentFiletypes(): # Send the signature help available request for these filetypes if we need # to (as a side effect of checking if it is complete) self.SignatureHelpAvailableRequestComplete(filetype, True) extra_data = {} self._AddUltiSnipsDataIfNeeded(extra_data) SendEventNotificationAsync('BufferVisit', extra_data=extra_data)
def OnBufferVisit(self): filetype = vimsupport.CurrentFiletypes()[0] # The constructor of dictionary values starts the request, # so the line below fires a new request only if the dictionary # value is accessed for the first time. self._signature_help_available_requests[filetype].Done() extra_data = {} self._AddUltiSnipsDataIfNeeded(extra_data) SendEventNotificationAsync('BufferVisit', extra_data=extra_data)
def _CurrentFiletype(self): filetypes = vimsupport.CurrentFiletypes() supported = self.SupportedFiletypes() for filetype in filetypes: if filetype in supported: return filetype return filetypes[0]
def _AddSyntaxDataIfNeeded(self, extra_data): if not self._user_options['seed_identifiers_with_syntax']: return filetype = vimsupport.CurrentFiletypes()[0] if filetype in self._filetypes_with_keywords_loaded: return self._filetypes_with_keywords_loaded.add(filetype) extra_data['syntax_keywords'] = list( syntax_parse.SyntaxKeywordsForCurrentBuffer())
def _ApplyDiagnosticFilter( self, diags, extra_predicate = None ): filetypes = vimsupport.CurrentFiletypes() diag_filter = self._diag_filter.SubsetForTypes( filetypes ) predicate = diag_filter.IsAllowed if extra_predicate is not None: def Filter( diag ): return extra_predicate( diag ) and diag_filter.IsAllowed( diag ) predicate = Filter return filter( predicate, diags )
def CurrentIdentifierFinished(): line, current_column = vimsupport.CurrentLineContentsAndCodepointColumn() previous_char_index = current_column - 1 if previous_char_index < 0: return True filetype = vimsupport.CurrentFiletypes()[0] regex = identifier_utils.IdentifierRegexForFiletype(filetype) for match in regex.finditer(line): if match.end() == previous_char_index: return True # If the whole line is whitespace, that means the user probably finished an # identifier on the previous line. return line[:current_column].isspace()
def GetFiletypeCompleter( self ): filetypes = vimsupport.CurrentFiletypes() completers = [ self.GetFiletypeCompleterForFiletype( filetype ) for filetype in filetypes ] if not completers: return None # Try to find a native completer first for completer in completers: if completer and completer is not self.omnicomp: return completer # Return the omni completer for the first filetype return completers[0]
def BuildRequestData(start_column=None, query=None, include_buffer_data=True): line, column = vimsupport.CurrentLineAndColumn() filepath = vimsupport.GetCurrentBufferFilepath() request_data = { 'filetypes': vimsupport.CurrentFiletypes(), 'line_num': line, 'column_num': column, 'start_column': start_column, 'line_value': vim.current.line, 'filepath': filepath } if include_buffer_data: request_data['file_data'] = vimsupport.GetUnsavedAndCurrentBufferData() if query: request_data['query'] = query return request_data
def _GetCompleteDoneHooks(self): filetypes = vimsupport.CurrentFiletypes() for key, value in iteritems(self._complete_done_hooks): if key in filetypes: yield value
def InCFamilyFile(): return any([ filetype in CLANG_FILETYPES for filetype in vimsupport.CurrentFiletypes() ])
def DiagnosticUiSupportedForCurrentFiletype(self): return any([ x in DIAGNOSTIC_UI_FILETYPES for x in vimsupport.CurrentFiletypes() ])
def NativeFiletypeCompletionAvailable(self): return any([ self.FiletypeCompleterExistsForFiletype(x) for x in vimsupport.CurrentFiletypes() ])
def _CurrentFiletypeCompletionEnabled(): filetypes = vimsupport.CurrentFiletypes() return not all( [x in FILETYPE_SPECIFIC_COMPLETION_TO_DISABLE for x in filetypes])
def CompletionStartColumn(): return ( request_wrap.CompletionStartColumn( vimsupport.CurrentLineContents(), vimsupport.CurrentColumn() + 1, vimsupport.CurrentFiletypes()[ 0 ] ) - 1 )
def OnFileTypeSet(self): buffer_number = vimsupport.GetCurrentBufferNumber() filetypes = vimsupport.CurrentFiletypes() self._buffers[buffer_number].UpdateFromFileTypes(filetypes) self.OnBufferVisit()