def get_completions(self, view, locations): "Get all the completions related to the current file." current_file_name = view.file_name() if not current_file_name: return [] Logging.log('AutoCompleter.get_completions.', Logging.LOG_DEBUG) self.current_filename = current_file_name project_name = Common.locate_cabal_project_from_view(view)[1] line_contents = Common.get_line_contents(view, locations[0]) qsymbol = Common.get_qualified_symbol(line_contents) qualified_prefix = qsymbol.qualified_name() Logging.log('qsymbol {0}'.format(qsymbol), Logging.LOG_DEBUG) Logging.log('current_file_name {0} qualified_prefix {1}'.format(current_file_name, qualified_prefix), Logging.LOG_DEBUG) view_settings = view.settings() wide = view_settings.get('subhask_wide_completion') suggestions = [] completions = [] if qsymbol.module: if qsymbol.is_import_list: current_module = Utils.head_of(BackendManager.active_backend().module(project_name, current_file_name)) if current_module and current_module.location.project: # Search for declarations of qsymbol.module within current project q_module = Utils.head_of(BackendManager.active_backend().scope_modules(project_name, current_file_name, lookup=qsymbol.module, search_type='exact')) if q_module is not None: if q_module.by_source(): proj_module = BackendManager.active_backend().resolve(file=q_module.location.filename, exports=True) if proj_module: suggestions = proj_module.declarations.values() elif q_module.by_cabal(): cabal_module = Utils.head_of(BackendManager.active_backend().module(project_name, lookup=q_module.name, search_type='exact', package=q_module.location.package.name)) if cabal_module: suggestions = cabal_module.declarations.values() else: suggestions = BackendManager.active_backend().complete(qualified_prefix, current_file_name, wide=wide) completions = make_completions(suggestions) else: with self.cache as cache_: if wide: completions += cache_.global_completions() else: completions += cache_.files.get(current_file_name, cache_.global_completions()) completions += self.keyword_completions(qsymbol.name) sort_completions(completions) return completions
def do_hover(self): if self.hover_zone == sublime.HOVER_TEXT: qsymbol = Common.get_qualified_symbol_at_point(self.view, self.point) ## print('hover: qualified symbol {0}'.format(qsymbol)) module_word = qsymbol.module ident = qsymbol.name if module_word is not None and ident is None: # TODO: Any ideas for popup about module? pass elif ident is not None: whois_name = qsymbol.qualified_name() full_name = qsymbol.full_name() # Try get type of hovered symbol typed_expr = None if types.SourceHaskellTypeCache().has(self.filename): typed_expr = self.get_type(types.SourceHaskellTypeCache().get(self.filename), whois_name) else: project_name = Common.locate_cabal_project_from_view(self.view)[1] point_rgn = sublime.Region(self.point, self.point) typed_expr = self.get_type(types.get_type_view(self.view, project_name, point_rgn), whois_name) # Try whois suggest_import = False decl = Utils.head_of(BackendManager.active_backend().whois(whois_name, self.filename)) if not decl: suggest_import = True decl = Utils.head_of(BackendManager.active_backend().lookup(full_name, self.filename)) self.create_symbol_popup(typed_expr, decl, suggest_import) elif self.hover_zone == sublime.HOVER_GUTTER: errs = [err for err in ParseOutput.MARKER_MANAGER.marks_for_view(self.view) if err.region.start.line == self.line] if errs: popup_parts = [self.STYLES.gen_style(self.view.settings().get('color_scheme'))] for err in errs: msg = UnicodeOpers.use_unicode_operators(symbols.escape_text(err.message)) # Decorate first word with style decors = { 'Error': 'error', 'Warning': 'warning', 'Hint': 'hint' } for dec, dec_style in decors.items(): msg = msg.replace(dec, u'<span class="{0}">{1}</span>'.format(dec_style, dec)) popup_parts.append(u'<p>{0}</p>'.format(msg)) if err.correction is not None: popup_parts.append(err.correction.popup()) popup_text = u''.join(popup_parts) self.shown = True self.view.show_popup(popup_text, sublime.HIDE_ON_MOUSE_MOVE_AWAY, self.point, 600, 600, self.on_navigate, self.on_hide)
def do_hover(self): if self.hover_zone == sublime.HOVER_TEXT: qsymbol = Common.get_qualified_symbol_at_point(self.view, self.point) ## print('hover: qualified symbol {0}'.format(qsymbol)) module_word = qsymbol.module ident = qsymbol.name if module_word is not None and ident is None: # TODO: Any ideas for popup about module? pass elif ident is not None: whois_name = qsymbol.qualified_name() full_name = qsymbol.full_name() # Try get type of hovered symbol typed_expr = None if types.SourceHaskellTypeCache().has(self.filename): typed_expr = self.get_type(types.SourceHaskellTypeCache().get(self.filename), whois_name) else: project_name = Common.locate_cabal_project_from_view(self.view)[1] point_rgn = sublime.Region(self.point, self.point) typed_expr = self.get_type(types.get_type_view(self.view, project_name, point_rgn), whois_name) # Try whois suggest_import = False decl = Utils.head_of(BackendManager.active_backend().whois(whois_name, self.filename)) if not decl: suggest_import = True decl = Utils.head_of(BackendManager.active_backend().lookup(full_name, self.filename)) self.create_symbol_popup(typed_expr, decl, suggest_import) elif self.hover_zone == sublime.HOVER_GUTTER: errs = [err for err in ParseOutput.errors_for_view(self.view) if err.region.start.line == self.line] if errs: popup_parts = [self.STYLES.gen_style(self.view.settings().get('color_scheme'))] for err in errs: msg = UnicodeOpers.use_unicode_operators(symbols.escape_text(err.message)) # Decorate first word with style decors = { 'Error': 'error', 'Warning': 'warning', 'Hint': 'hint' } for dec, dec_style in decors.items(): msg = msg.replace(dec, u'<span class="{0}">{1}</span>'.format(dec_style, dec)) popup_parts.append(u'<p>{0}</p>'.format(msg)) if err.correction is not None: popup_parts.append(err.correction.popup()) popup_text = u''.join(popup_parts) self.view.show_popup(popup_text, sublime.HIDE_ON_MOUSE_MOVE_AWAY, self.point, 600, 600, self.on_navigate, self.on_hide)
def contents_to_module(self, file, contents): self.set_file_contents(file, contents) m = self.module(file=file, header=True) proj = self.project(path=m.location.project) build_tool = proj['build-tool'] self.scan_file(file=file, build_tool=build_tool, wait_complete=True) return Utils.head_of(self.module(None, file=file))
def completions_for_module(self, project_name, module, filename): """ Returns completions for module """ retval = [] backend = BackendManager.active_backend() if module: mods = backend.scope_modules( project_name, filename, lookup=module, search_type='exact') if filename else [] mod_file = mods[0].location.filename if mods and mods[0].by_source( ) else None cache_db = mods[0].location.db if mods and mods[0].by_cabal( ) else None package = mods[0].location.package.name if mods and mods[ 0].by_cabal() else None mod_decls = Utils.head_of( backend.module(project_name, lookup=module, search_type='exact', file=mod_file, symdb=cache_db, package=package)) retval = make_completions( mod_decls.declarations.values()) if mod_decls else [] return retval
def is_in_project(self, view): file_shown_in_view = Common.window_view_and_file(view)[2] if file_shown_in_view is None: return False src_module = Utils.head_of(BackendManager.active_backend().module(file=file_shown_in_view)) return src_module is not None and src_module.location.project is not None
def run(self, edit, **kwargs): current_file_name = kwargs.get('filename', self.view.file_name()) project_name = Common.locate_cabal_project_from_view(self.view)[1] backend = BackendManager.active_backend() imp_module = Utils.head_of(backend.module(project_name, file=current_file_name)) if imp_module: imports = sorted(imp_module.imports, key=lambda i: i.position.line) supported, result = backend.clean_imports(current_file_name) print(result) if supported: if len(imports) == len(result): Logging.log('replacing imports for {0}'.format(current_file_name), Logging.LOG_TRACE) erased = 0 for imp, new_imp in zip(imports, result): point = self.view.text_point(imp.position.line - 1 - erased, 0) if new_imp.endswith('()'): self.view.erase(edit, self.view.full_line(point)) erased = erased + 1 else: self.view.replace(edit, self.view.line(point), new_imp) else: Common.sublime_status_message('different number of imports: {0} and {1}'.format(len(imports), len(result))) else: if len(result) == 1: Common.sublime_status_message(result[0]) else: sublime.message_dialog('\n'.join(result)) else: Common.sublime_status_message('Clean Imports failed: module not scanned')
def completions_for_module(self, project_name, module, filename): """ Returns completions for module """ retval = [] backend = BackendManager.active_backend() if module: mods = backend.scope_modules( project_name, filename, lookup=module, search_type='exact') if filename else [] mod_file = mods[0].location.filename if mods and mods[0].by_source( ) else None package = mods[0].location.package.name if mods and mods[ 0].by_cabal() else None mod_id = mods[0] if mods else None mod_decls = Utils.head_of( list( filter( lambda m: mod_id == m, backend.module(project_name, lookup=module, search_type='exact', file=mod_file, package=package)))) retval = make_completions(mod_decls.exports) if mod_decls else [] return retval
def generate_completions_cache(self, project_name, file_name, contents=None): def log_result(result): retval = result or [] if Settings.COMPONENT_DEBUG.completions: print('completions: {0}'.format(len(retval))) return retval comps = [] update_cabal = False update_sources = False with self.cache as cache_: if file_name in cache_.files: del cache_.files[file_name] else: update_cabal = not cache_.cabal update_sources = not cache_.sources ## Not sure what these were supposed to do -- the actual methods are no-ops. if update_cabal: self.update_cabal_completions() if update_sources: self.update_sources_completions() with self.cache as cache_: comps = cache_.global_completions() import_names = [] if file_name: if Settings.COMPONENT_DEBUG.completions: print('preparing completions for {0} ({1})'.format(project_name, file_name)) backend = BackendManager.active_backend() comps = make_completions(backend.complete(Common.QualifiedSymbol(''), file_name, contents=contents)) current_module = Utils.head_of(backend.module(project_name, file_name)) if Settings.COMPONENT_DEBUG.completions: print('current_module {0}'.format(current_module)) if current_module: # Get import names # # Note, that if module imported with 'as', then it can be used only with its synonym # instead of full name import_names.extend([('{0}\tmodule {1}'.format(i.import_as, i.module), i.import_as) for i in current_module.imports if i.import_as]) import_names.extend([('{0}\tmodule'.format(i.module), i.module) for i in current_module.imports if not i.import_as]) comps.extend(import_names) sort_completions(comps) with self.cache as cache_: cache_.files[file_name] = comps return log_result(cache_.files[file_name]) else: return log_result(comps)
def run(self, _edit, **kwargs): module_name = kwargs.get('module_name') filename = kwargs.get('filename') symdb = kwargs.get('db') scope = kwargs.get('scope') self.candidates = [] self.current_file_name = self.view.window().active_view().file_name() the_module = None project_name = Common.locate_cabal_project_from_view(self.view.window().active_view())[1] if filename: the_module = Utils.head_of(BackendManager.active_backend().module(project_name, file=filename)) if not the_module: Common.sublime_status_message('Module {0} not found'.format(filename)) return elif module_name: cand_mods = self.candidate_modules(project_name, module_name, scope, symdb) if not cand_mods: Common.sublime_status_message('Module {0} not found'.format(module_name)) return elif len(cand_mods) == 1: the_module = self.get_module_info(project_name, cand_mods[0], module_name) if the_module: the_module = Utils.head_of(the_module) else: self.candidates.extend([(m, [m.name, m.location.to_string()]) for m in cand_mods]) else: if self.current_file_name: cand_mods = BackendManager.active_backend().scope_modules(project_name, self.current_file_name) else: symbol_db = symbols.PackageDb.from_string(symdb) if symdb else None cand_mods = BackendManager.active_backend().list_modules(symdb=symbol_db) self.candidates.extend([(m, [m.name, m.location.to_string()]) for m in cand_mods]) if the_module: self.candidates = sorted(list(the_module.declarations.values()), key=lambda d: d.brief()) results = [[decl.brief(use_unicode=False), decl.docs.splitlines()[0] if decl.docs else ''] for decl in self.candidates] self.view.window().show_quick_panel(results, self.on_symbol_selected) else: self.candidates.sort(key=lambda c: c[1][0]) self.view.window().show_quick_panel([c[1] for c in self.candidates], self.on_done)
def on_inspected(self, result): imp_module = None if self.view.is_dirty(): # Use the buffer's contents pyresult = json.loads(result).get('result') if pyresult is not None: if Logging.is_log_level(Logging.LOG_DEBUG): pprint.pprint(pyresult, width=80) modinfo = pyresult.get('module') if modinfo is not None: imp_module = HsDevResultParse.parse_module(modinfo) else: # Otherwise, use the actual file imp_module = Utils.head_of( hsdev.client.module(file=self.current_file_name)) if imp_module is not None: imports = sorted(imp_module.imports, key=lambda i: i.position.line) after = [i for i in imports if i.module > self.module_name] insert_line = 0 insert_gap = False if len(after) > 0: # Insert before after[0] insert_line = after[0].position.line - 1 elif len(imports) > 0: # Insert after all imports insert_line = imports[-1].position.line elif len(imp_module.declarations) > 0: # Insert before first declaration insert_line = min([ d.position.line for d in imp_module.declarations.values() ]) - 1 insert_gap = True else: # Try to add the import just after the "where" of the module declaration contents = self.view.substr(sublime.Region( 0, self.view.size())) mod_decl = re.search('module.*where', contents, re.MULTILINE) if mod_decl is not None: insert_line = mod_decl.end() insert_gap = True else: # Punt! Insert at the end of the file insert_line = self.view.rowcol(self.view.size())[0] insert_text = 'import {0}\n'.format( self.module_name) + ('\n' if insert_gap else '') point = self.view.text_point(insert_line, 0) self.view.insert(self.edit, point, insert_text) Common.show_status_message( 'Import {0} added'.format(self.module_name), True)
def get_types(self, filename=None, line=None, column=None): if not filename: filename = self.view.file_name() if (not line) or (not column): line, column = self.view.rowcol(self.view.sel()[0].b) module_name = Utils.head_of(hsdev.client.module(file=filename)) return get_type(self.view, filename, module_name, line, column)
def get_type_view(view, selection=None): filename = view.file_name() if selection is None: selection = view.sel()[0] line, column = view.rowcol(selection.b) module_name = Utils.head_of(hsdev.client.module(file=filename)) return get_type(view, filename, module_name, line, column)
def get_type_view(view, project_name, selection=None): filename = view.file_name() project_name = Common.locate_cabal_project_from_view(view)[1] if selection is None: selection = view.sel()[0] line, column = view.rowcol(selection.b) module_name = Utils.head_of(BackendManager.active_backend().module(project_name, file=filename)) return get_type(view, project_name, filename, module_name, line, column)
def get_completions_async(self, project_name, file_name): def log_result(result): retval = result or [] Logging.log('completions: {0}'.format(len(retval)), Logging.LOG_TRACE) return retval comps = [] update_cabal = False update_sources = False with self.cache as cache_: if file_name in cache_.files: return log_result(cache_.files.get(file_name, [])) else: update_cabal = not cache_.cabal update_sources = not cache_.sources if update_cabal: self.update_cabal_completions() if update_sources: self.update_sources_completions() with self.cache as cache_: comps = cache_.global_completions() import_names = [] if file_name is None: return log_result(comps) else: Logging.log('preparing completions for {0}/{1}'.format(project_name, file_name), Logging.LOG_DEBUG) comps = make_completions(BackendManager.active_backend().complete('', file_name)) current_module = Utils.head_of(BackendManager.active_backend().module(project_name, file_name)) Logging.log('current_module {0}'.format(current_module)) if current_module: # Get import names # # Note, that if module imported with 'as', then it can be used only with its synonym # instead of full name import_names.extend([('{0}\tmodule {1}'.format(i.import_as, i.module), i.import_as) for i in current_module.imports if i.import_as]) import_names.extend([('{0}\tmodule'.format(i.module), i.module) for i in current_module.imports if not i.import_as]) comps.extend(import_names) sort_completions(comps) with self.cache as cache_: cache_.files[file_name] = comps return log_result(cache_.files[file_name])
def rescan_source(self, project_name, filename, drop_all=True): if Settings.COMPONENT_DEBUG.inspection: print('{0}.rescan_source: {1}/{2}'.format( type(self).__name__, project_name, filename)) with self.backend_mgr: if self.backend_mgr.active_backend().auto_rescan(): if Utils.head_of(BackendManager.active_backend().module( None, file=filename, header=True)) is not None: return with self.backend_mgr.inspector() as insp: if not filename.endswith('.cabal'): insp.mark_file_dirty(filename) else: insp.mark_cabal_dirty(filename) EventCommon.update_completions_async(self.autocompleter, project_name, [filename], drop_all)
def completions_for_module(self, project_name, module, filename): """ Returns completions for module """ retval = [] backend = BackendManager.active_backend() if module: mods = backend.scope_modules(project_name, filename, lookup=module, search_type='exact') if filename else [] mod_file = mods[0].location.filename if mods and mods[0].by_source() else None cache_db = mods[0].location.db if mods and mods[0].by_cabal() else None package = mods[0].location.package.name if mods and mods[0].by_cabal() else None mod_decls = Utils.head_of(backend.module(project_name, lookup=module, search_type='exact', file=mod_file, symdb=cache_db, package=package)) retval = make_completions(mod_decls.declarations.values()) if mod_decls else [] return retval
def run(self, **kwargs): project = kwargs.get('project') or False decls = [] if project: project_name = Common.locate_cabal_project_from_view(self.view)[1] modules = BackendManager.active_backend().module(project_name, file=self.current_filename) current_project = Utils.head_of(modules).location.project if not current_project: Common.sublime_status_message('File {0} is not in project'.format(self.current_filename)) return decls = self.sorted_decls_name(BackendManager.active_backend().symbol(project=current_project)) self.declarations = [[decl.brief(True, use_unicode=False), decl.module.name] for decl in decls] else: decls = self.sorted_decls_pos(BackendManager.active_backend().symbol(file=self.current_filename, local_names=True)) self.declarations = [[(decl.position.column * ' ') + decl.brief(True, use_unicode=False)] for decl in decls] self.decls = decls[:] if decls: self.window.show_quick_panel(self.declarations, self.on_done, 0, self.closest_idx(decls), self.on_highlighted if not project else None)
def is_scanned_source(self, view): file_shown_in_view = Common.get_haskell_command_window_view_file_project( view)[2] return file_shown_in_view is not None and \ Utils.head_of(BackendManager.active_backend().module(file=file_shown_in_view)) is not None
def get_types(self, project_name, filename, line, column): module_name = Utils.head_of(BackendManager.active_backend().module( project_name, file=filename)) return get_type(self.view, project_name, filename, module_name, line, column)
def get_type(self, type_list, qual_name): filt_types = [t for t in type_list if t.substr(self.view) == qual_name and t.region(self.view).contains(self.point)] return Utils.head_of(filt_types)
def get_types(self, project_name, filename, line, column): module_name = Utils.head_of(BackendManager.active_backend().module(project_name, file=filename)) return get_type(self.view, project_name, filename, module_name, line, column)
def on_hover(self, view, point, hover_zone): if not Common.is_haskell_source(view): return self.view = view self.current_file_name = self.view.file_name() # If the column is needed: (line, column) = self.view.rowcol(point) [remove subscript] line = self.view.rowcol(point)[0] self.decl = None self.typed_expr = None if hover_zone == sublime.HOVER_TEXT: qsymbol = Common.get_qualified_symbol_at_point(self.view, point) module_word = qsymbol.module ident = qsymbol.name if ident is None and module_word: # TODO: Any ideas for popup about module? pass if ident: self.whois_name = qsymbol.qualified_name() self.full_name = qsymbol.full_name() # Try get type of hovered symbol self.point = point self.typed_expr = None if types.FILE_TYPES.has(self.current_file_name): self.typed_expr = self.get_type( types.FILE_TYPES.get(self.current_file_name)) else: types.get_types(self.current_file_name, self.on_types) # Try whois self.suggest_import = False self.decl = Utils.head_of( hsdev.client.whois(self.whois_name, self.current_file_name)) if not self.decl: self.suggest_import = True self.decl = Utils.head_of( hsdev.client.lookup(self.full_name, self.current_file_name)) self.create_symbol_popup() elif hover_zone == sublime.HOVER_GUTTER: self.view = view self.current_file_name = self.view.file_name() errs = list( filter(lambda e: e.region.start.line == line, parseoutput.errors_for_view(self.view))) if errs: popup_parts = [ SUBHASK_STYLES.gen_style( self.view.settings().get('color_scheme')) ] for err in errs: msg = UnicodeOpers.use_unicode_operators( symbols.escape_text(err.message)) # Decorate first word with style decors = { 'Error': 'error', 'Warning': 'warning', 'Hint': 'hint' } for dec, dec_style in decors.items(): msg = msg.replace( dec, u'<span class="{0}">{1}</span>'.format( dec_style, dec)) popup_parts.append(u'<p>{0}</p>'.format(msg)) if err.correction is not None: popup_parts.append(err.correction.popup()) popup_text = u''.join(popup_parts) self.view.show_popup(popup_text, sublime.HIDE_ON_MOUSE_MOVE_AWAY, point, 600, 600, self.on_navigate, self.on_hide)
def get_completions(self, view, locations): "Get all the completions related to the current file." current_file_name = view.file_name() if not current_file_name: return [] if Settings.COMPONENT_DEBUG.completions: print('AutoCompleter.get_completions.') self.current_filename = current_file_name _, project_name = Common.locate_cabal_project_from_view(view) line_contents = Common.get_line_contents(view, locations[0]) qsymbol = Common.get_qualified_symbol(line_contents) qualified_prefix = qsymbol.qualified_name() if Settings.COMPONENT_DEBUG.completions: print('qsymbol {0}'.format(qsymbol)) print('current_file_name {0} qualified_prefix {1}'.format( current_file_name, qualified_prefix)) view_settings = view.settings() wide = view_settings.get('subhask_wide_completion') backend = BackendManager.active_backend() suggestions = [] completions = [] if qsymbol.module: if qsymbol.is_import_list: current_module = Utils.head_of( backend.module(project_name, current_file_name)) if current_module and current_module.location.project: # Search for declarations of qsymbol.module within current project q_module = Utils.head_of( backend.scope_modules(project_name, current_file_name, lookup=qsymbol.module, search_type='exact')) if q_module is not None: if q_module.by_source(): proj_module = backend.module( None, file=q_module.location.filename) if proj_module: suggestions = proj_module.exports elif q_module.by_cabal(): cabal_module = Utils.head_of( backend.module( project_name, lookup=q_module.name, search_type='exact', package=q_module.location.package.name)) if cabal_module: suggestions = cabal_module.exports else: if Settings.COMPONENT_DEBUG.completions: print('completions: querying module-specific completions') suggestions = backend.complete(qsymbol, current_file_name, wide=wide) completions = make_completions(suggestions) else: with self.cache as cache_: if wide: if Settings.COMPONENT_DEBUG.completions: print('completions: returning global completions') completions += cache_.global_completions() else: if Settings.COMPONENT_DEBUG.completions: print( 'completions: returning file-specific completions') completions += cache_.files.get( current_file_name, cache_.global_completions()) completions += self.keyword_completions(qsymbol.name) sort_completions(completions) return completions
def get_completions(self, view, locations): "Get all the completions related to the current file." current_file_name = view.file_name() if not current_file_name: return [] if Settings.COMPONENT_DEBUG.completions: print('AutoCompleter.get_completions.') self.current_filename = current_file_name _, project_name = Common.locate_cabal_project_from_view(view) line_contents = Common.get_line_contents(view, locations[0]) qsymbol = Common.get_qualified_symbol(line_contents) qualified_prefix = qsymbol.qualified_name() if Settings.COMPONENT_DEBUG.completions: print('qsymbol {0}'.format(qsymbol)) print('current_file_name {0} qualified_prefix {1}'.format(current_file_name, qualified_prefix)) view_settings = view.settings() wide = view_settings.get('subhask_wide_completion') backend = BackendManager.active_backend() suggestions = [] completions = [] if qsymbol.module: if qsymbol.is_import_list: current_module = Utils.head_of(backend.module(project_name, current_file_name)) if current_module and current_module.location.project: # Search for declarations of qsymbol.module within current project q_module = Utils.head_of(backend.scope_modules(project_name, current_file_name, lookup=qsymbol.module, search_type='exact')) if q_module is not None: if q_module.by_source(): proj_module = backend.resolve(file=q_module.location.filename, exports=True) if proj_module: suggestions = proj_module.declarations.values() elif q_module.by_cabal(): cabal_module = Utils.head_of(backend.module(project_name, lookup=q_module.name, search_type='exact', package=q_module.location.package.name)) if cabal_module: suggestions = cabal_module.declarations.values() else: if Settings.COMPONENT_DEBUG.completions: print('completions: querying module-specific completions') suggestions = backend.complete(qsymbol, current_file_name, wide=wide) completions = make_completions(suggestions) else: with self.cache as cache_: if wide: if Settings.COMPONENT_DEBUG.completions: print('completions: returning global completions') completions += cache_.global_completions() else: if Settings.COMPONENT_DEBUG.completions: print('completions: returning file-specific completions') completions += cache_.files.get(current_file_name, cache_.global_completions()) completions += self.keyword_completions(qsymbol.name) sort_completions(completions) return completions
def get_type(self, type_list, qual_name): filt_types = [ t for t in type_list if t.substr(self.view) == qual_name and t.region(self.view).contains(self.point) ] return Utils.head_of(filt_types)
def is_scanned_source(self, view): file_shown_in_view = Common.window_view_and_file(view)[2] return file_shown_in_view is not None and \ Utils.head_of(BackendManager.active_backend().module(None, file=file_shown_in_view, header=True)) is not None
def is_scanned_source(self, view): file_shown_in_view = Common.window_view_and_file(view)[2] return file_shown_in_view is not None and \ Utils.head_of(BackendManager.active_backend().module(file=file_shown_in_view)) is not None