lee/renderdoc
1
0
Fork 0
mirror of https://github.com/baldurk/renderdoc.git synced 2026-05-04 09:00:44 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
3f5766950912c5338e622ee456e76cb17176cb8a
renderdoc/docs/pycharm_helpers/module_redeclarator.patch
T

452 lines
22 KiB
Diff
Raw Blame History

--- "/c/Program Files/JetBrains/PyCharm Community Edition 2020.3.2/plugins/python-ce/helpers/generator3/module_redeclarator.py" 2020-12-30 17:08:24.000000000 +0000
+++ pycharm_helpers/plugins/python-ce/helpers/generator3/module_redeclarator.py 2021-01-27 14:13:18.876000000 +0000
@@ -2,6 +2,15 @@
from generator3.util_methods import *
from generator3.util_methods import get_relative_path_by_qname
from generator3.docstring_parsing import *
+import re
+import enum
+
+# Add patterns for identifying declarations we care about
+RTYPE_PATTERN = re.compile(r"[:@]rtype:\s*(.*)")
+TYPE_PATTERN = re.compile(r"[:@]type\s*:\s*(.*)")
+PARAM_PATTERN = re.compile(r"[:@]param\s+([^:]*)\s+([^: ]*):")
+NAMESPACE_PATTERN = re.compile(r"([^[\]]+\.)*([a-zA-Z][a-zA-Z0-9_]+)")
+DEFAULTS = re.compile(r"(=.*)")
class emptylistdict(dict):
@@ -79,6 +88,8 @@
# we write things into buffers out-of-order
self.header_buf = Buf(self)
self.imports_buf = Buf(self)
+ # each class gets its own list of dependency imports, and so do functions
+ self.func_imports_buf = Buf(self)
self.functions_buf = Buf(self)
self.classes_buf = Buf(self)
self.classes_buffs = list()
@@ -94,6 +105,8 @@
self.doing_builtins = doing_builtins
self.ret_type_cache = {}
self.used_imports = emptylistdict() # qual_mod_name -> [imported_names,..]: actually used imported names
+ # if we use Typing hints, import some things for it
+ self.used_typing = False
def _initializeQApp4(self):
try: # QtGui should be imported _before_ QtCore package.
@@ -129,19 +142,23 @@
if self.split_modules:
last_pkg_dir = build_pkg_structure(self.cache_dir, self.qname)
with fopen(os.path.join(last_pkg_dir, "__init__.py"), "w") as init:
- for buf in (self.header_buf, self.imports_buf, self.functions_buf, self.classes_buf):
+ for buf in (self.header_buf, self.imports_buf, self.classes_buf):
buf.flush(init)
data = ""
- for buf in self.classes_buffs:
+ for (buf,imports) in self.classes_buffs:
with fopen(os.path.join(last_pkg_dir, buf.name) + '.py', "w") as dummy:
self.header_buf.flush(dummy)
self.imports_buf.flush(dummy)
+ imports.flush(dummy)
buf.flush(dummy)
data += self.create_local_import(buf.name)
init.write(data)
- self.footer_buf.flush(init)
+
+ # Write out functions last so they can reference the classes imported above
+ for buf in (self.func_imports_buf, self.functions_buf, self.footer_buf):
+ buf.flush(init)
else:
last_pkg_dir = build_pkg_structure(self.cache_dir, '.'.join(qname_parts[:-1]))
# In some rare cases submodules of a binary might have been generated earlier than the module
@@ -155,13 +172,16 @@
else:
skeleton_path = os.path.join(last_pkg_dir, qname_parts[-1] + '.py')
with fopen(skeleton_path, "w") as mod:
- for buf in (self.header_buf, self.imports_buf, self.functions_buf, self.classes_buf):
+ for buf in (self.header_buf, self.imports_buf, self.classes_buf):
buf.flush(mod)
- for buf in self.classes_buffs:
+ for (buf,imports) in self.classes_buffs:
+ imports.flush(mod)
buf.flush(mod)
- self.footer_buf.flush(mod)
+ # Write out functions last so they can reference the classes imported above
+ for buf in (self.func_imports_buf, self.functions_buf, self.footer_buf):
+ buf.flush(mod)
# Some builtin classes effectively change __init__ signature without overriding it.
# This callable serves as a placeholder to be replaced via REDEFINED_BUILTIN_SIGS
@@ -177,6 +197,50 @@
data += "."
data += name + " import " + name + "\n"
return data
+
+ # Parse a typing declaration and add the actual types references
+ def add_import_types(self, import_types, type_decl):
+ if '[' not in type_decl:
+ import_types.add(type_decl)
+ return
+
+ match = re.match('^[tT]uple\[(.*)\]$', type_decl)
+ if match:
+ for i in match.group(1).split(','):
+ self.add_import_types(import_types, i.strip())
+ return
+
+ match = re.match('^[lL]ist\[(.*)\]$', type_decl)
+ if match:
+ self.add_import_types(import_types, match.group(1).strip())
+ return
+
+ match = re.match('^[cC]allable\[\[(.*)\]\s*,\s*(.*)\]$', type_decl)
+ if match:
+ for i in match.group(1).split(','):
+ self.add_import_types(import_types, i.strip())
+ self.add_import_types(import_types, match.group(2).strip())
+ return
+
+ # For a given type that's referenced, figure out where to import it from and add
+ # to the list
+ def process_import_type(self, used_imports, p_modname, classname, import_type):
+ parent = None
+
+ if import_type == '...':
+ return
+
+ if import_type in dir(sys.modules[p_modname]):
+ if import_type != classname:
+ parent = '.'
+ child = import_type
+ elif '.' in import_type:
+ imp_split = import_type.split('.')
+ parent = '.'.join(imp_split)
+ child = imp_split[-1]
+
+ if parent is not None and child not in used_imports[parent]:
+ used_imports[parent].append(child)
def find_imported_name(self, item):
"""
@@ -433,7 +497,43 @@
if first_param:
seq.insert(0, first_param)
seq = make_names_unique(seq)
- return (seq, ret_type, doc_node)
+
+ import_types = set()
+ ret_hint = None
+
+ # Try to use :rtype: to add explicit type annotations to return type, since PyCharm
+ # doesn't parse rtype properly (at least with split modules)
+ if ret_type is None and ':rtype:' in signature_string:
+ result = RTYPE_PATTERN.search(signature_string)
+ if result is not None:
+ type_decl = result.group(1).strip()
+ if type_decl != class_name:
+ self.add_import_types(import_types, type_decl)
+ ret_hint = NAMESPACE_PATTERN.sub(r'\2', type_decl)
+ else:
+ ret_hint = "'" + type_decl + "'"
+ self.used_typing = True
+
+ # Also use :param: to add necessary imports and fix up the parameters.
+ # PyCharm supports parsing :param: but the skeletons need the right imports
+ # and it fails for namespaced parameters (since the 'raw' parameter type
+ # foo.bar refers to a generated submodule called bar with the skeleton bar
+ # inside.
+ for p in PARAM_PATTERN.findall(signature_string):
+ type_decl = p[0]
+ if type_decl != class_name:
+ self.add_import_types(import_types, type_decl)
+ try:
+ defaults_match = [DEFAULTS.search(s) for s in seq]
+ idx = [DEFAULTS.sub('', s) for s in seq].index(p[1])
+ seq[idx] = '{}: {}'.format(p[1], NAMESPACE_PATTERN.sub(r'\2', p[0]))
+ if defaults_match[idx]:
+ seq[idx] += defaults_match[idx].group(1)
+ except ValueError:
+ note("Warning: Unrecognised parameter {} in parameter list {}".format(p, seq))
+ pass
+
+ return (seq, ret_type, doc_node, list(import_types), ret_hint)
def parse_func_doc(self, func_doc, func_id, func_name, class_name, deco=None, sip_generated=False):
"""
@@ -453,18 +553,23 @@
overloads.append(part[i + len(signature):])
if len(overloads) > 1:
docstring_results = [self.restore_by_docstring(overload, class_name, deco) for overload in overloads]
+ import_types = []
ret_types = []
for result in docstring_results:
rt = result[1]
if rt and rt not in ret_types:
ret_types.append(rt)
+ imps = result[3]
+ for imp in imps:
+ if imp and imp not in import_types:
+ import_types.append(imp)
if ret_types:
ret_literal = " or ".join(ret_types)
else:
ret_literal = None
param_lists = [result[0] for result in docstring_results]
spec = build_signature(func_name, restore_parameters_for_overloads(param_lists))
- return (spec, ret_literal, "restored from __doc__ with multiple overloads")
+ return (spec, ret_literal, "restored from __doc__ with multiple overloads", import_types)
# find the first thing to look like a definition
prefix_re = re.compile(r"\s*(?:(\w+)[ \t]+)?" + func_id + r"\s*\(") # "foo(..." or "int foo(..."
@@ -472,18 +577,21 @@
# parse the part that looks right
if match:
ret_hint = match.group(1)
- params, ret_literal, doc_note = self.restore_by_docstring(func_doc[match.end():], class_name, deco, ret_hint)
+ params, ret, doc_note, import_types, ret_hint = self.restore_by_docstring(func_doc[match.end():], class_name, deco, ret_hint)
spec = func_name + flatten(params)
- return (spec, ret_literal, doc_note)
+ # if we got a type hint, put it on the function declaration
+ if ret_hint:
+ spec = spec + ' -> ' + ret_hint
+ return (spec, ret, doc_note, import_types)
else:
- return (None, None, None)
+ return (None, None, None, [])
def is_predefined_builtin(self, module_name, class_name, func_name):
return self.doing_builtins and module_name == BUILTIN_MOD_NAME and (
class_name, func_name) in PREDEFINED_BUILTIN_SIGS
- def redo_function(self, out, p_func, p_name, indent, p_class=None, p_modname=None, classname=None, seen=None):
+ def redo_function(self, out, p_func, p_name, indent, p_class=None, p_modname=None, classname=None, seen=None, used_imports=None):
"""
Restore function argument list as best we can.
@param out output function of a Buf
@@ -531,6 +639,8 @@
deco = "classmethod"
elif type(p_func).__name__.startswith('staticmethod'):
deco = "staticmethod"
+ elif str(descriptor).startswith('<staticmethod'):
+ deco = "staticmethod"
if p_name == "__new__":
deco = "staticmethod"
deco_comment = " # known case of __new__"
@@ -580,11 +690,17 @@
sig_restored = False
action("parsing doc of func %r of class %r", p_name, p_class)
if isinstance(funcdoc, STR_TYPES):
- (spec, ret_literal, more_notes) = self.parse_func_doc(funcdoc, p_name, p_name, classname, deco,
+ (spec, ret_literal, more_notes, import_types) = self.parse_func_doc(funcdoc, p_name, p_name, classname, deco,
sip_generated)
if spec is None and p_name == '__init__' and classname:
- (spec, ret_literal, more_notes) = self.parse_func_doc(funcdoc, classname, p_name, classname, deco,
+ (spec, ret_literal, more_notes, import_types) = self.parse_func_doc(funcdoc, classname, p_name, classname, deco,
sip_generated)
+
+ # if we have some imported types, process and add them to the used imports
+ if used_imports is not None:
+ for imp in import_types:
+ self.process_import_type(used_imports, p_modname, classname, imp)
+
sig_restored = spec is not None
if more_notes:
if sig_note:
@@ -613,7 +729,7 @@
out(indent, p_name, " = ", deco, "(", p_name, ")", deco_comment)
out(0, "") # empty line after each item
- def redo_class(self, out, p_class, p_name, indent, p_modname=None, seen=None, inspect_dir=False):
+ def redo_class(self, out, p_class, p_name, indent, p_modname=None, seen=None, inspect_dir=False, used_imports=None):
"""
Restores a class definition.
@param out output function of a relevant buf
@@ -644,6 +760,11 @@
skipped_bases.append(str(base))
continue
# somehow import every base class
+ # Ignore the SwigPyObject internal class, which can't be added to KNOWN_FAKE_BASES
+ # because it is never directly accessible
+ if base.__name__ == 'SwigPyObject':
+ skipped_bases.append(str(base))
+ continue
base_name = base.__name__
qual_module_name = qualifier_of(base, skip_qualifiers)
got_existing_import = False
@@ -704,6 +825,11 @@
continue
except Exception:
continue
+
+ # Don't generate skeleton for internal enum properties
+ if isinstance(p_class, enum.EnumMeta) and (is_callable(item) or item_name[0] == '_'):
+ continue
+
if is_callable(item) and not isinstance(item, type):
methods[item_name] = item
elif is_property(item):
@@ -727,7 +853,7 @@
for item_name in sorted_no_case(methods.keys()):
item = methods[item_name]
try:
- self.redo_function(out, item, item_name, indent + 1, p_class, p_modname, classname=p_name, seen=seen_funcs)
+ self.redo_function(out, item, item_name, indent + 1, p_class, p_modname, classname=p_name, seen=seen_funcs, used_imports=used_imports)
except:
handle_error_func(item_name, out)
#
@@ -760,9 +886,41 @@
out(indent + 1, '""":type: ', prop_type, '"""')
out(0, "")
else:
- out(indent + 1, item_name, " = property(lambda self: object(), lambda self, v: None, lambda self: None) # default")
+ # for properties with docstrings put them inside the getter so that PyCharm
+ # displays them
if prop_docstring:
- out(indent + 1, '"""', prop_docstring, '"""')
+ ret = ''
+ param = ''
+
+ # Additionally if we see :type: in the docstring, add type hints
+ result = TYPE_PATTERN.search(prop_docstring)
+ if result is not None:
+ type_decl = result.group(1).strip()
+ import_types = set()
+ if type_decl == p_name or type_decl == 'List[{}]'.format(p_name):
+ type_decl = "'" + type_decl + "'"
+ else:
+ self.add_import_types(import_types, type_decl)
+ for imp in import_types:
+ self.process_import_type(used_imports, p_modname, p_name, imp)
+ type_decl = type_decl.replace('...', '__ellipses__').split('.')[-1].replace('__ellipses__', '...')
+ ret = ' -> {}'.format(type_decl)
+ param = ': {}'.format(type_decl)
+
+ out(indent + 1, "@property")
+ out(indent + 1, "def {}(self){}:".format(item_name, ret))
+ out(indent + 2, '"""', prop_docstring, '"""')
+ out(indent + 2, 'pass')
+ out(0, "")
+ out(indent + 1, "@{}.setter".format(item_name))
+ out(indent + 1, "def {}(self, value{}):".format(item_name, param))
+ out(indent + 2, 'pass')
+ out(0, "")
+
+ self.used_typing = True
+ continue
+
+ out(indent + 1, item_name, " = property(lambda self: object(), lambda self, v: None, lambda self: None) # default")
out(0, "")
if properties:
out(0, "") # empty line after the block
@@ -990,15 +1148,20 @@
out(0, "# functions")
out(0, "")
seen_funcs = {}
+ func_used_imports = emptylistdict()
for item_name in sorted_no_case(funcs.keys()):
if item_name in omitted_names:
out(0, "# definition of ", item_name, " omitted")
continue
item = funcs[item_name]
try:
- self.redo_function(out, item, item_name, 0, p_modname=p_name, seen=seen_funcs)
+ self.redo_function(out, item, item_name, 0, p_modname=p_name, seen=seen_funcs, used_imports=func_used_imports)
except:
handle_error_func(item_name, out)
+ # don't import anything from . for functions, functions are emitted in __init__
+ # and all local classes are imported by the time they're defined
+ func_used_imports['.'] = []
+ self.output_import_froms(self.func_imports_buf.out, func_used_imports)
else:
self.functions_buf.out(0, "# no functions")
#
@@ -1020,13 +1183,22 @@
self.split_modules = self.mod_filename and len(cls_list) >= 30
for item_name in [cls_item[0] for cls_item in cls_list]:
buf = ClassBuf(item_name, self)
- self.classes_buffs.append(buf)
+ imports = ClassBuf(item_name + '_imports', self)
+ self.classes_buffs.append((buf,imports))
out = buf.out
if item_name in omitted_names:
out(0, "# definition of ", item_name, " omitted")
continue
item = classes[item_name]
- self.redo_class(out, item, item_name, 0, p_modname=p_name, seen=seen_classes, inspect_dir=inspect_dir)
+ used_imports = emptylistdict()
+ self.redo_class(out, item, item_name, 0, p_modname=p_name, seen=seen_classes, inspect_dir=inspect_dir, used_imports=used_imports)
+ # if we don't have split modules we can't import dependencies, but we also
+ # have an ordering constraint - classes need to be declared after any classes
+ # they reference in type hints. This is broken either way though even with the
+ # return literals
+ if not self.split_modules:
+ func_used_imports['.'] = []
+ self.output_import_froms(imports.out, used_imports)
self._defined[item_name] = True
out(0, "") # empty line after each item
@@ -1083,19 +1255,38 @@
for value in values_to_add:
self.footer_buf.out(0, value)
# imports: last, because previous parts could alter used_imports or hidden_imports
- self.output_import_froms()
+
+ out = self.imports_buf.out
+ self.output_import_froms(out, self.used_imports)
+
+ if self.hidden_imports:
+ self.add_import_header_if_needed()
+ for mod_name in sorted_no_case(self.hidden_imports.keys()):
+ out(0, 'import ', mod_name, ' as ', self.hidden_imports[mod_name])
+ out(0, "") # empty line after group
+
+ if self.used_typing:
+ self.add_import_header_if_needed()
+ out(0, 'from typing import List, Tuple, Callable, Any')
+ out(0, "") # empty line after group
+
if self.imports_buf.isEmpty():
- self.imports_buf.out(0, "# no imports")
- self.imports_buf.out(0, "") # empty line after imports
+ out(0, "# no imports")
+ out(0, "") # empty line after imports
- def output_import_froms(self):
+ def output_import_froms(self, out, imports_list):
"""Mention all imported names known within the module, wrapping as per PEP."""
- out = self.imports_buf.out
- if self.used_imports:
+ if imports_list:
self.add_import_header_if_needed()
- for mod_name in sorted_no_case(self.used_imports.keys()):
- import_names = self.used_imports[mod_name]
- if import_names:
+ for mod_name in sorted_no_case(imports_list.keys()):
+ import_names = imports_list[mod_name]
+ if mod_name == '.':
+ # if this is a local import, we need to treat it specially to import
+ # the class inside the referenced module
+ for n in import_names:
+ out(0, "from .%s import %s" % (n, n)) # empty line after group
+ out(0, "") # empty line after group
+ elif import_names:
self._defined[mod_name] = True
right_pos = 0 # tracks width of list to fold it at right margin
import_heading = "from % s import (" % mod_name
@@ -1127,10 +1318,4 @@
out(0, "") # empty line after group
- if self.hidden_imports:
- self.add_import_header_if_needed()
- for mod_name in sorted_no_case(self.hidden_imports.keys()):
- out(0, 'import ', mod_name, ' as ', self.hidden_imports[mod_name])
- out(0, "") # empty line after group
-
Reference in New Issue View Git Blame Copy Permalink