def find_param_usages(self, filepath):
# print('HU param usage')
src = self.context.src
src = src[:self.context.method.block.begin()] + \
'%s' % self.context.word.name
offset = len(codecs.encode(src, 'utf-8')) + 1
src += ';' + self.context.src[self.context.method.block.begin():]
complete = HaxeComplete_inst()
with open(filepath, 'w') as f:
f.write(src)
usage = complete.run_haxe(self.view, dict(
mode='usage',
filename=filepath,
offset=offset,
commas=None
))
if usage:
tree = self.parse_xml(usage[0])
if tree is not None:
usages = [i.text for i in tree.getiterator('pos')]
if usages:
usages.pop(0)
for u in usages:
self.parse_and_append_usage(u)
self.finish()
def find_param_usages(self, filepath):
# print('HU param usage')
src = self.context.src
src = src[:self.context.method.block.begin()] + \
'%s' % self.context.word.name
offset = len(codecs.encode(src, 'utf-8')) + 1
src += ';' + self.context.src[self.context.method.block.begin():]
complete = HaxeComplete_inst()
with open(filepath, 'w') as f:
f.write(src)
usage = complete.run_haxe(
self.view,
dict(mode='usage', filename=filepath, offset=offset, commas=None))
if usage:
tree = self.parse_xml(usage[0])
if tree is not None:
usages = [i.text for i in tree.getiterator('pos')]
if usages:
usages.pop(0)
for u in usages:
self.parse_and_append_usage(u)
self.finish()
def run(self, paths=[]):
win = self.window
for p in paths:
if os.path.isfile(p):
for b in HaxeComplete_inst().read_hxml(p):
HaxeComplete_inst().add_build(b)
if (int(sublime.version()) > 3000):
proj = win.project_file_name()
if proj is not None:
proj_path = os.path.dirname(proj)
rel_path = os.path.relpath(p, proj_path)
else:
rel_path = p
data = win.project_data()
if 'settings' not in data:
data['settings'] = {}
if 'haxe_builds' not in data['settings']:
data['settings']['haxe_builds'] = []
build_files = data['settings']['haxe_builds']
build_files.append(rel_path)
win.set_project_data(data)
def get_param_type(self):
view = self.window.active_view()
complete = HaxeComplete_inst()
comps, hints = complete.get_haxe_completions(view, view.sel()[0].end(), ignoreTopLevel=True)
return hints
def get_param_type(self):
view = self.window.active_view()
complete = HaxeComplete_inst()
comps, hints = complete.get_haxe_completions(
view, view.sel()[0].end(), ignoreTopLevel=True)
return hints
def get_param_type(self):
view = self.window.active_view()
complete = HaxeComplete_inst()
for r in view.sel():
comps, hints = complete.get_haxe_completions(view, r.end())
return hints
def get_param_type(self):
view = self.window.active_view()
complete = HaxeComplete_inst()
for r in view.sel():
comps, hints = complete.get_haxe_completions(view, r.end())
return hints
def run(self, edit, input=''):
complete = HaxeComplete_inst()
view = self.view
if not input:
pos = view.sel()[0].end()
if view.substr(pos) == '(' and view.score_selector(
pos - 1, 'source.haxe.2 meta.parameters.haxe.2') == 0:
view.run_command('haxe_show_type')
return
if input == '(':
sel = view.sel()
emptySel = True
for r in sel:
if not r.empty():
emptySel = False
break
autoMatch = view.settings().get('auto_match_enabled', False)
if autoMatch:
if emptySel:
view.run_command('insert_snippet', {
'contents': '($0)'
})
else:
view.run_command('insert_snippet', {
'contents': '(${0:$SELECTION})'
})
else:
view.run_command('insert', {
'characters': '('
})
else:
view.run_command('insert', {
'characters': input
})
if input and not view.settings().get('haxe_auto_complete', True):
return
haxe_smart_snippets = view.settings().get('haxe_smart_snippets', False)
haxe_use_popup = view.settings().get('haxe_use_popup', True) and \
int(sublime.version()) >= 3070
if not haxe_smart_snippets and not haxe_use_popup:
return
for r in view.sel():
comps, hints = complete.get_haxe_completions(
view, r.end(), ignoreTopLevel=True)
if haxe_use_popup:
self.show_popup(hints)
elif haxe_smart_snippets and input:
self.insert_snippet(hints)
def init_build_class_map(view):
if HaxeOrganizeImports.std_type_map is None:
HaxeOrganizeImports.std_type_map = \
init_type_map(HaxeComplete_inst().__class__.stdClasses)
if HaxeOrganizeImports.build_classes is None:
build = HaxeComplete_inst().get_build(view)
HaxeOrganizeImports.build_classes, _ = build.get_types()
HaxeOrganizeImports.build_type_map = init_type_map(
HaxeOrganizeImports.build_classes, HaxeOrganizeImports.std_type_map)
def init_build_class_map(view):
if HaxeOrganizeImports.std_type_map is None:
HaxeOrganizeImports.std_type_map = \
init_type_map(HaxeComplete_inst().__class__.stdClasses)
if HaxeOrganizeImports.build_classes is None:
build = HaxeComplete_inst().get_build(view)
HaxeOrganizeImports.build_classes, _ = build.get_types()
HaxeOrganizeImports.build_type_map = init_type_map(
HaxeOrganizeImports.build_classes,
HaxeOrganizeImports.std_type_map)
def find_classpaths(self):
view = self.window.active_view()
self.classpaths = []
build = HaxeComplete_inst().get_build(view)
self.classpaths.extend(HaxeComplete_inst().__class__.stdPaths)
for cp in build.classpaths:
self.classpaths.append(os.path.join(build.cwd, cp))
for lib in build.libs:
if lib is not None:
self.classpaths.append(lib.path)
def run(self, edit, input=''):
complete = HaxeComplete_inst()
view = self.view
if not input:
pos = view.sel()[0].end()
if view.substr(pos) == '(' and view.score_selector(
pos - 1, 'source.haxe.2 meta.parameters.haxe.2') == 0:
view.run_command('haxe_show_type')
return
if input == '(':
sel = view.sel()
emptySel = True
for r in sel:
if not r.empty():
emptySel = False
break
autoMatch = view.settings().get('auto_match_enabled', False)
if autoMatch:
if emptySel:
view.run_command('insert_snippet', {'contents': '($0)'})
else:
view.run_command('insert_snippet',
{'contents': '(${0:$SELECTION})'})
else:
view.run_command('insert', {'characters': '('})
else:
view.run_command('insert', {'characters': input})
if input and not view.settings().get('haxe_auto_complete', True):
return
haxe_smart_snippets = view.settings().get('haxe_smart_snippets', False)
haxe_use_popup = view.settings().get('haxe_use_popup', True) and \
int(sublime.version()) >= 3070
if not haxe_smart_snippets and not haxe_use_popup:
return
for r in view.sel():
comps, hints = complete.get_haxe_completions(view,
r.end(),
ignoreTopLevel=True)
if haxe_use_popup:
self.show_popup(hints)
elif haxe_smart_snippets and input:
self.insert_snippet(hints)
def run(self, edit, input=''):
complete = HaxeComplete_inst()
view = self.view
if input == '(':
sel = view.sel()
emptySel = True
for r in sel:
if not r.empty():
emptySel = False
break
autoMatch = view.settings().get('auto_match_enabled', False)
if autoMatch:
if emptySel:
view.run_command('insert_snippet', {
'contents': '($0)'
})
else:
view.run_command('insert_snippet', {
'contents': '(${0:$SELECTION})'
})
else:
view.run_command('insert', {
'characters': '('
})
else:
view.run_command('insert', {
'characters': input
})
autocomplete = view.settings().get('auto_complete', True)
if not autocomplete:
return
haxe_smart_snippets = view.settings().get('haxe_smart_snippets', False)
haxe_use_popup = view.settings().get('haxe_use_popup', True) and \
int(sublime.version()) >= 3070
if not haxe_smart_snippets and not haxe_use_popup:
return
for r in view.sel():
comps, hints = complete.get_haxe_completions(view, r.end())
if haxe_use_popup:
self.show_popup(hints)
elif haxe_smart_snippets and input:
self.insert_snippet(hints)
def run(self, paths=[], t="class"):
builds = HaxeComplete_inst().builds
HaxeCreateType.currentType = t
view = sublime.active_window().active_view()
scopes = view.scope_name(view.sel()[0].end()).split()
fn = view.file_name()
pack = []
if fn is None:
return
if len(builds) == 0:
HaxeComplete_inst().extract_build_args(view)
if len(paths) == 0:
paths.append(fn)
for path in paths:
if os.path.isfile(path):
path = os.path.dirname(path)
if HaxeCreateType.classpath is None:
HaxeCreateType.classpath = path
for b in builds:
for cp in b.classpaths:
if path.startswith(cp):
HaxeCreateType.classpath = path[0:len(cp)]
for p in path[len(cp):].split(os.sep):
if "." in p:
break
elif p:
pack.append(p)
if HaxeCreateType.classpath is None:
if len(builds) > 0:
HaxeCreateType.classpath = builds[0].classpaths[0]
# so default text ends with .
if len(pack) > 0:
pack.append("")
win = sublime.active_window()
sublime.status_message("Current classpath : " +
HaxeCreateType.classpath)
win.show_input_panel("Enter " + t + " name : ", ".".join(pack),
self.on_done, self.on_change, self.on_cancel)
def run(self, mode=None):
view = self.window.active_view()
if view is None or view.is_loading() or not is_haxe_scope(view):
return
self.classpath = \
HaxeComplete_inst().get_build(view).get_classpath(view)
if self.classpath is None:
return
self.classes, self.packages = self.extract_modules(self.classpath)
self.mode = mode
idx = 0
self.options = None
if mode == 'module':
self.options = self.classes
cl = to_haxe_form(self.classpath, view.file_name(), True)
if cl in self.options:
idx = self.options.index(cl)
elif mode == 'package':
self.options = self.packages
pk = to_haxe_form(
self.classpath, os.path.dirname(view.file_name()))
if pk in self.options:
idx = self.options.index(pk)
else:
return
self.window.show_quick_panel(self.options, self.on_select, 0, idx)
def poll(ctx):
view = ctx.view
cmds = []
if HaxeRefactor.is_installed == -1:
HaxeRefactor.check_refactor_lib(ctx.view)
if HaxeRefactor.is_installed == 0:
return cmds
classpath = HaxeComplete_inst().get_build(view).get_classpath(view)
if classpath is None or classpath not in view.file_name():
return cmds
for w in sublime.windows():
for v in w.views():
if v.is_dirty():
return cmds
# if ctx.word:
if True:
cmds.append((
'Rename/Move module ...',
'haxe_refactor',
{'mode': 'module'}))
if True:
cmds.append((
'Rename package ...',
'haxe_refactor',
{'mode': 'package'}))
return cmds
def run(self):
win = self.window
view = win.active_view()
if view is None or view.is_loading() or not is_haxe_scope(view):
return
self.context = get_context(view)
if not self.context.type:
return
method_names = {'new': True}
for methodCtx in self.context.type.methods:
method_names[methodCtx.name] = True
tmp_name = '__sublime_tmp_method__'
method_names[tmp_name] = True
win.run_command(
'haxe_override_method_edit',
{'pos': self.context.type.block.begin(), 'name': tmp_name})
complete = HaxeComplete_inst()
temp = complete.save_temp_file(view)
_, _, _, _, fields = complete.run_haxe(view, dict(
mode=None,
filename=view.file_name(),
offset=0,
commas=None))
complete.clear_temp_file(view, temp)
win.run_command('undo')
self.methods = []
for field in fields:
name = field[0]
args = field[1]
if args is None or name in method_names:
continue
self.methods.append(field)
options = []
for method in self.methods:
options.append('%s()' % method[0])
show_quick_panel(
win, options, self.on_select, sublime.MONOSPACE_FONT, 0)
def init_build_class_map(view):
HaxeOrganizeImports.std_type_map = init_type_map(
HaxeComplete_inst().__class__.stdClasses)
# print('OI: Std')
# lst = HaxeComplete_inst().__class__.stdClasses
# print("\n".join([k for k in sorted(lst)]))
build = HaxeComplete_inst().get_build(view)
HaxeOrganizeImports.build_classes, _ = build.get_types()
# print('OI: Build')
# lst = HaxeOrganizeImports.build_classes
# print("\n".join([k for k in sorted(lst)]))
HaxeOrganizeImports.build_type_map = init_type_map(
HaxeOrganizeImports.build_classes, HaxeOrganizeImports.std_type_map)
def init_build_class_map(view):
HaxeOrganizeImports.std_type_map = init_type_map(
HaxeComplete_inst().__class__.stdClasses)
# print('OI: Std')
# lst = HaxeComplete_inst().__class__.stdClasses
# print("\n".join([k for k in sorted(lst)]))
build = HaxeComplete_inst().get_build(view)
HaxeOrganizeImports.build_classes, _ = build.get_types()
# print('OI: Build')
# lst = HaxeOrganizeImports.build_classes
# print("\n".join([k for k in sorted(lst)]))
HaxeOrganizeImports.build_type_map = init_type_map(
HaxeOrganizeImports.build_classes,
HaxeOrganizeImports.std_type_map)
def find_usages(self,
offset=0,
type_paths=None,
field=None,
is_static=False):
static = 'true' if is_static else 'false'
if self.hx_files is None:
self.scan_hx_files()
complete = HaxeComplete_inst()
args = None
if type_paths:
field = 'null' if field is None else '"%s"' % field
args = []
for tp in type_paths:
args.append(
('--macro', 'addMetadata("@:usage", "%s", %s, %s)' %
(tp, field, static)))
num_files = len(self.hx_files)
def find(idx, t):
if idx >= num_files:
self.finish()
return
t0 = time.time()
f = self.hx_files[idx]
sublime.status_message('Find usages in \'%s\'' % f)
usage = complete.run_haxe(
self.view,
dict(mode='usage',
filename=f,
offset=offset,
commas=None,
serverMode=False), args)
tree = self.parse_xml(usage[0])
if tree is not None:
for i in tree.getiterator('pos'):
self.parse_and_append_usage(i.text)
t += time.time() - t0
idx += 1
if t > 0.5:
t = 0
sublime.set_timeout(lambda: find(idx, t), 10)
else:
find(idx, t)
sublime.set_timeout(lambda: find(0, 0), 10)
def find_local_usages(self, filepath, usage_line):
self.append_usage(self.view.file_name(), usage_line)
rgn = self.word.region
pos_cols = (self.view.rowcol(rgn.begin())[1],
self.view.rowcol(rgn.end())[1])
src = self.view.substr(
sublime.Region(self.context.word.region.end(),
self.context.method.region.end()))
idx = 0
idx = src.find(self.context.word.name, idx)
complete = HaxeComplete_inst()
while idx != -1:
offset = self.context.word.region.end() + idx + \
len(self.context.word.name)
src_o = self.view.substr(sublime.Region(0, offset))
offset = len(codecs.encode(src_o, 'utf-8')) + 1
position = complete.run_haxe(
self.view,
dict(mode='position',
filename=filepath,
offset=offset,
commas=None))
if position:
mo = re_haxe_position.search(position)
if mo:
line = int(mo.group(2))
cols = (int(mo.group(3)), int(mo.group(4)))
if line == usage_line and \
cols[0] <= pos_cols[0] and pos_cols[1] <= cols[1]:
self.find_usages(offset)
return
else:
self.has_pos_errors = True
idx = src.find(self.context.word.name, idx + 1)
self.finish()
def find_local_usages(self, filepath, usage_line):
self.append_usage(self.view.file_name(), usage_line)
rgn = self.word.region
pos_cols = (
self.view.rowcol(rgn.begin())[1],
self.view.rowcol(rgn.end())[1])
src = self.view.substr(sublime.Region(
self.context.word.region.end(), self.context.method.region.end()))
idx = 0
idx = src.find(self.context.word.name, idx)
complete = HaxeComplete_inst()
while idx != -1:
offset = self.context.word.region.end() + idx + \
len(self.context.word.name)
src_o = self.view.substr(sublime.Region(0, offset))
offset = len(codecs.encode(src_o, 'utf-8')) + 1
position = complete.run_haxe(self.view, dict(
mode='position',
filename=filepath,
offset=offset,
commas=None
))
if position:
mo = re_haxe_position.search(position)
if mo:
line = int(mo.group(2))
cols = (int(mo.group(3)), int(mo.group(4)))
if line == usage_line and \
cols[0] <= pos_cols[0] and pos_cols[1] <= cols[1]:
self.find_usages(offset)
return
else:
self.has_pos_errors = True
idx = src.find(self.context.word.name, idx + 1)
self.finish()
def run(self, edit, input=''):
complete = HaxeComplete_inst()
view = self.view
if input == '(':
sel = view.sel()
emptySel = True
for r in sel:
if not r.empty():
emptySel = False
break
autoMatch = view.settings().get('auto_match_enabled', False)
if autoMatch:
if emptySel:
view.run_command('insert_snippet', {'contents': '($0)'})
else:
view.run_command('insert_snippet',
{'contents': '(${0:$SELECTION})'})
else:
view.run_command('insert', {'characters': '('})
else:
view.run_command('insert', {'characters': input})
autocomplete = view.settings().get('auto_complete', True)
if not autocomplete:
return
haxe_smart_snippets = view.settings().get('haxe_smart_snippets', False)
haxe_use_popup = view.settings().get('haxe_use_popup', True) and \
int(sublime.version()) >= 3070
if not haxe_smart_snippets and not haxe_use_popup:
return
for r in view.sel():
comps, hints = complete.get_haxe_completions(view, r.end())
if haxe_use_popup:
self.show_popup(hints)
elif haxe_smart_snippets and input:
self.insert_snippet(hints)
def get_type(view, pos, name):
win = view.window()
win.run_command(
'haxe_promote_var_edit',
{'pos0': pos, 'pos1': pos, 'text': '%s.|' % name})
complete = HaxeComplete_inst()
temp = complete.save_temp_file(view)
tp = complete.run_haxe(view, dict(
mode="type",
filename=view.file_name(),
offset=0,
commas=None
))
complete.clear_temp_file(view, temp)
win.run_command('undo')
return tp
def poll(ctx):
if HaxeComplete_inst().compilerVersion < 3.2:
return []
for w in sublime.windows():
for v in w.views():
if v.is_dirty() and v.score_selector(0, 'source.haxe.2') > 0:
return []
if ctx.word:
return [('Find Usages: %s ...' % ctx.word.name, 'haxe_usage', {})]
return []
def run(self, edit):
view = self.view
if view.score_selector(0, 'source.haxe.2') == 0 or \
int(sublime.version()) < 3000:
return
# get word under cursor
word = view.word(view.sel()[0])
# get utf-8 byte offset to the end of the word
src = view.substr(sublime.Region(0, word.b))
offset = len(codecs.encode(src, "utf-8")) + 1
# add 1 because offset is 1-based
complete = HaxeComplete_inst()
# save file and run completion
temp = complete.save_temp_file(view)
hint = complete.run_haxe(view, dict(
mode="type",
filename=view.file_name(),
offset=offset,
commas=None
))
complete.clear_temp_file(view, temp)
if hint is None:
status = "No type information for '%s'." % \
view.substr(sublime.Region(word.a, word.b))
view.set_status("haxe-status", status)
else:
hint = format_statement(view, hint)
if int(sublime.version()) >= 3070 and \
view.settings().get("haxe_use_popup", True):
view.run_command('haxe_show_popup', {'text': hint})
else:
view.show_popup_menu([hint], lambda i: None)
view.set_status("haxe-status", hint)
def find_method_positions(self, type_paths, word):
# print('HU positions:', word)
filepath = os.path.join(self.root_dir, 'SublimeHaxeUsage.hx')
complete = HaxeComplete_inst()
def find(idx, t):
if idx >= len(type_paths):
try:
os.remove(filepath)
except OSError:
pass
self.find_usages(0, type_paths, self.context.word.name)
return
t0 = time.time()
type_path = type_paths[idx]
s = ('class SublimeHaxeUsage {'
'static var temp:%s;'
'static function main() {temp.%s.|;}'
'}') % (type_path, word)
sublime.status_message('Find method in \'%s\'' % type_path)
with open(filepath, 'w') as f:
f.write(s)
position = complete.run_haxe(
self.view,
dict(mode='position', filename=filepath, offset=0,
commas=None))
if position:
self.parse_and_append_usage(position)
else:
self.has_pos_errors = True
t += time.time() - t0
idx += 1
if t > 0.5:
t = 0
sublime.set_timeout(lambda: find(idx, t), 10)
else:
find(idx, t)
sublime.set_timeout(lambda: find(0, 0), 10)
def finish(self):
if self.usages:
self.output_view.find_all_results()
self.has_errors = self.has_errors or self.has_pos_errors
if self.has_pos_errors:
usage = HaxeComplete_inst().run_haxe(
self.view,
dict(mode='usage',
filename=self.view.file_name(),
offset=0,
commas=None))
if usage:
self.parse_xml(usage[0])
self.log('[Finished]')
HaxeUsage.is_active = False
def run( self , edit ) :
view = self.view
# get word under cursor
word = view.word(view.sel()[0])
# get utf-8 byte offset to the end of the word
src = view.substr(sublime.Region(0, word.b))
offset = len(codecs.encode(src, "utf-8")) + 1 # add 1 because offset is 1-based
complete = HaxeComplete_inst()
# save file and run completion
temp = complete.save_temp_file( view )
pos = complete.run_haxe(view, dict(
mode="position",
filename=view.file_name(),
offset=offset,
commas=None
))
complete.clear_temp_file( view , temp )
if pos is None:
status = "Definition of '" + view.substr(sublime.Region(word.a, word.b)) + "' not found."
self.view.set_status( "haxe-status", status )
return
else :
pos = pos.strip()
# parse position
m = posRe.match(pos)
filename = m.group(1)
line = int(m.group(2)) - 1
mode = m.group(3)
start = int(m.group(4))
if mode == "lines":
start = 0
if os.name == "nt":
filename = self.get_windows_path(filename)
# open definition file in the active window and go to given position
window = sublime.active_window()
view = window.open_file(filename)
self.goto_pos(view, line, start)
def run(self):
win = self.window
view = win.active_view()
if view is None or view.is_loading() or not is_haxe_scope(view):
return
self.context = get_context(view)
if not self.context.type:
return
method_names = {'new': True}
for methodCtx in self.context.type.methods:
method_names[methodCtx.name] = True
tmp_name = '__sublime_tmp_method__'
method_names[tmp_name] = True
win.run_command('haxe_override_method_edit', {
'pos': self.context.type.block.begin(),
'name': tmp_name
})
complete = HaxeComplete_inst()
temp = complete.save_temp_file(view)
_, _, _, _, fields = complete.run_haxe(
view,
dict(mode=None, filename=view.file_name(), offset=0, commas=None))
complete.clear_temp_file(view, temp)
win.run_command('undo')
self.methods = []
for field in fields:
name = field[0]
args = field[1]
if args is None or name in method_names:
continue
self.methods.append(field)
options = []
for method in self.methods:
options.append('%s()' % method[0])
show_quick_panel(win, options, self.on_select, sublime.MONOSPACE_FONT,
0)
def poll(ctx):
view = ctx.view
cmds = []
classpath = HaxeComplete_inst().get_build(view).get_classpath(view)
if classpath is None:
return cmds
filename = os.path.splitext(os.path.basename(view.file_name()))[0]
filedir = os.path.dirname(view.file_name())
src = ctx.src
mos = [mo for mo in re_type.finditer(src)]
if len(mos) == 1:
mo = mos[0]
if filename != mo.group(2):
cmds.append(
('Rename %s %s to %s' %
(mo.group(1), mo.group(2), filename), 'haxe_fix_module', {
'cname': filename
}))
mo = re_package.search(src)
cur_package = mo.group(1) if mo else ''
if classpath in filedir:
package = os.path.relpath(filedir, classpath)
if package == '.':
package = ''
package = package.replace(os.sep, '.')
if package != cur_package:
cmds.append(('Rename package \'%s\' to \'%s\'' %
(cur_package, package), 'haxe_fix_module', {
'package': package
}))
return cmds
def run(self, edit):
view = self.view
if view.score_selector(0, 'source.haxe.2') == 0 or \
int(sublime.version()) < 3000:
return
# get word under cursor
word = view.word(view.sel()[0])
# get utf-8 byte offset to the end of the word
src = view.substr(sublime.Region(0, word.b))
offset = len(codecs.encode(src, "utf-8")) + 1
# add 1 because offset is 1-based
complete = HaxeComplete_inst()
# save file and run completion
temp = complete.save_temp_file(view)
hint = complete.run_haxe(
view,
dict(mode="type",
filename=view.file_name(),
offset=offset,
commas=None))
complete.clear_temp_file(view, temp)
if hint is None:
status = "No type information for '%s'." % \
view.substr(sublime.Region(word.a, word.b))
view.set_status("haxe-status", status)
else:
hint = format_statement(view, hint)
view.set_status("haxe-status", hint)
hint = hint.replace('<', '<')
hint = hint.replace('>', '>')
hint = re_params.sub(r'<b>\1</b>\2:', hint)
if int(sublime.version()) >= 3070 and \
view.settings().get("haxe_use_popup", True):
view.run_command('haxe_show_popup', {'text': hint})
else:
view.show_popup_menu([hint], lambda i: None)
def get_type(view, pos, name):
win = view.window()
win.run_command('haxe_promote_var_edit', {
'pos0': pos,
'pos1': pos,
'text': '%s.|' % name
})
complete = HaxeComplete_inst()
temp = complete.save_temp_file(view)
tp = complete.run_haxe(
view,
dict(mode="type", filename=view.file_name(), offset=0, commas=None))
complete.clear_temp_file(view, temp)
win.run_command('undo')
return tp
def on_build_change(self, view):
build = HaxeComplete_inst().get_build(view)
if build is not None:
HaxeOrganizeImports.build_classes, _ = build.get_types()
HaxeOrganizeImports.build_type_map = None
def find_local_or_field_usages(self):
self.show_panel()
self.log('Find usages: %s' % self.word.name)
# print('HU local_or_field')
ctx = self.context
is_param = ctx.method and \
ctx.method.region.begin() < ctx.word.region.begin() and \
self.word.region.end() <= ctx.method.block.begin() and \
'(' in ctx.src[ctx.method.region.begin():ctx.word.region.begin()]
complete = HaxeComplete_inst()
temp = complete.save_temp_file(self.view, is_param)
filepath = None
usage_line = 0
src = self.view.substr(sublime.Region(0, ctx.word.region.end()))
offset = len(codecs.encode(src, 'utf-8')) + 1
mos = [
mo for mo in re.finditer(
r'\b(for\s*\(\s*|var\s+|function\s+)%s\b' %
ctx.word.name, src, re.M)
]
mo = mos[-1] if mos else None
is_declaration = mo and mo.end(0) == ctx.word.region.end()
is_field = False
view_filepath = os.path.realpath(self.view.file_name())
if is_declaration or is_param:
filepath = os.path.realpath(self.view.file_name())
usage_line, _ = self.view.rowcol(ctx.word.region.end())
usage_line += 1
self.append_usage(filepath, usage_line)
if is_declaration:
is_field = not ctx.method or \
ctx.word.region.end() <= ctx.method.block.begin()
else:
position = complete.run_haxe(
self.view,
dict(mode='position',
filename=self.view.file_name(),
offset=offset,
commas=None))
if position:
filepath, usage_line, begin, end = \
self.parse_and_append_usage(position)
begin = self.view.text_point(usage_line, begin)
end = self.view.text_point(usage_line, end)
is_field = view_filepath != filepath or \
not ctx.method or \
end <= ctx.method.block.begin() or \
begin >= ctx.method.block.end()
else:
self.has_pos_errors = True
if filepath:
if filepath != view_filepath:
self.find_field_usages(filepath, usage_line)
else:
if is_param:
self.find_param_usages(filepath)
elif not is_field:
# print('HU local usages')
self.hx_files = [filepath]
if is_declaration:
self.find_local_usages(filepath, usage_line)
else:
self.find_usages(offset)
else:
self.find_field_usages(filepath, usage_line)
else:
self.finish()
complete.clear_temp_file(self.view, temp)
def on_build_change(self, view):
build = HaxeComplete_inst().get_build(view)
if build is not None:
HaxeOrganizeImports.build_classes, _ = build.get_types()
HaxeOrganizeImports.build_type_map = None
def run( self ) :
view = sublime.active_window().active_view()
HaxeComplete_inst().stop_server()
HaxeComplete_inst().start_server( view )
def find_local_or_field_usages(self):
self.show_panel()
self.log('Find usages: %s' % self.word.name)
# print('HU local_or_field')
ctx = self.context
is_param = ctx.method and \
ctx.method.region.begin() < ctx.word.region.begin() and \
self.word.region.end() <= ctx.method.block.begin() and \
'(' in ctx.src[ctx.method.region.begin():ctx.word.region.begin()]
complete = HaxeComplete_inst()
temp = complete.save_temp_file(self.view, is_param)
filepath = None
usage_line = 0
src = self.view.substr(
sublime.Region(0, ctx.word.region.end()))
offset = len(codecs.encode(src, 'utf-8')) + 1
mos = [mo for mo in re.finditer(
r'\b(for\s*\(\s*|var\s+|function\s+)%s\b' % ctx.word.name,
src, re.M)]
mo = mos[-1] if mos else None
is_declaration = mo and mo.end(0) == ctx.word.region.end()
is_field = False
view_filepath = os.path.realpath(self.view.file_name())
if is_declaration or is_param:
filepath = os.path.realpath(self.view.file_name())
usage_line, _ = self.view.rowcol(ctx.word.region.end())
usage_line += 1
self.append_usage(filepath, usage_line)
if is_declaration:
is_field = not ctx.method or \
ctx.word.region.end() <= ctx.method.block.begin()
else:
position = complete.run_haxe(self.view, dict(
mode='position',
filename=self.view.file_name(),
offset=offset,
commas=None
))
if position:
filepath, usage_line, begin, end = \
self.parse_and_append_usage(position)
begin = self.view.text_point(usage_line, begin)
end = self.view.text_point(usage_line, end)
is_field = view_filepath != filepath or \
not ctx.method or \
end <= ctx.method.block.begin() or \
begin >= ctx.method.block.end()
else:
self.has_pos_errors = True
if filepath:
if filepath != view_filepath:
self.find_field_usages(filepath, usage_line)
else:
if is_param:
self.find_param_usages(filepath)
elif not is_field:
# print('HU local usages')
self.hx_files = [filepath]
if is_declaration:
self.find_local_usages(filepath, usage_line)
else:
self.find_usages(offset)
else:
self.find_field_usages(filepath, usage_line)
else:
self.finish()
complete.clear_temp_file(self.view, temp)
