pydevd-pycharm 233.13763.11__tar.gz → 241.9959.30__tar.gz

{pydevd-pycharm-233.13763.11/pydevd_pycharm.egg-info → pydevd-pycharm-241.9959.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: pydevd-pycharm
-Version: 233.13763.11
+Version: 241.9959.30
 Summary: PyCharm Debugger (used in PyCharm and PyDev)
 Home-page: https://github.com/JetBrains/intellij-community
 Author: JetBrains, Fabio Zadrozny and others

pydevd-pycharm-241.9959.30/VERSION

@@ -0,0 +1 @@
+241.9959.30

{pydevd-pycharm-233.13763.11 → pydevd-pycharm-241.9959.30}/_pydevd_bundle/pydevd_bytecode_utils.py

@@ -1,12 +1,29 @@
-"""Bytecode analysing utils. Originally added for using in smart step into."""
+"""Bytecode analyzing utils that are primarily used for extracting smart steps into
+variants."""
+
 import dis
 import inspect
+import logging
+import os
+import sys
 from collections import namedtuple
 
-from _pydevd_bundle.pydevd_constants import IS_PY3K, IS_CPYTHON
+from _pydevd_bundle.pydevd_constants import IS_PY3K, IS_CPYTHON, IS_PY311_OR_GREATER
+
+__all__ = [
+    'find_last_call_name',
+    'find_last_func_call_order',
+    'get_smart_step_into_candidates',
+]
 
-__all__ = ["find_last_call_name", "find_last_func_call_order",
-           "get_smart_step_into_candidates"]
+_logger = logging.getLogger(__name__)
+DEBUG = os.environ.get('PYCHARM_SMART_STEP_INTO_DEBUG', 'False') == 'True'
+if DEBUG:
+    _logger.setLevel(logging.DEBUG)
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter('%(name)s:%(levelname)s:%(message)s')
+    handler.setFormatter(formatter)
+    _logger.addHandler(handler)
 
 _LOAD_OPNAMES = {
     'LOAD_BUILD_CLASS',
@@ -25,14 +42,16 @@ _CALL_OPNAMES = {
 }
 
 if IS_PY3K:
-    for opname in ('LOAD_CLASSDEREF', 'LOAD_METHOD'):
-        _LOAD_OPNAMES.add(opname)
-    for opname in ('CALL_FUNCTION_EX', 'CALL_METHOD'):
-        _CALL_OPNAMES.add(opname)
+    for each_opname in ('LOAD_CLASSDEREF', 'LOAD_METHOD'):
+        _LOAD_OPNAMES.add(each_opname)
+    for each_opname in ('CALL_FUNCTION_EX', 'CALL_METHOD'):
+        _CALL_OPNAMES.add(each_opname)
+    if IS_PY311_OR_GREATER:
+        _CALL_OPNAMES.add('CALL')
 else:
     _LOAD_OPNAMES.add('LOAD_LOCALS')
-    for opname in ('CALL_FUNCTION_VAR', 'CALL_FUNCTION_VAR_KW'):
-        _CALL_OPNAMES.add(opname)
+    for each_opname in ('CALL_FUNCTION_VAR', 'CALL_FUNCTION_VAR_KW'):
+        _CALL_OPNAMES.add(each_opname)
 
 _BINARY_OPS = set([opname for opname in dis.opname if opname.startswith('BINARY_')])
 
@@ -56,7 +75,8 @@ _BINARY_OP_MAP = {
 if not IS_PY3K:
     _BINARY_OP_MAP['BINARY_DIVIDE'] = '__div__'
 
-_UNARY_OPS = set([opname for opname in dis.opname if opname.startswith('UNARY_') and opname != 'UNARY_NOT'])
+_UNARY_OPS = set([opname for opname in dis.opname if opname.startswith('UNARY_')
+                  and opname != 'UNARY_NOT'])
 
 _UNARY_OP_MAP = {
     'UNARY_POSITIVE': '__pos__',
@@ -98,14 +118,25 @@ def _is_make_opname(opname):
     return opname in _MAKE_OPS
 
 
-# Similar to :py:class:`dis._Instruction` but without fields we don't use. Also :py:class:`dis._Instruction`
-# is not available in Python 2.
-Instruction = namedtuple("Instruction", ["opname", "opcode", "arg", "argval", "lineno", "offset"])
+# A truncated version of the named tuple from the CPython `dis` module that contains
+# only fields necessary for the extraction of stepping variants.
+_Instruction = namedtuple(
+    "_Instruction",
+    [
+        'opname',
+        'opcode',
+        'arg',
+        'argval',
+        'offset',
+        'lineno',
+    ]
+)
 
 if IS_PY3K:
     long = int
 
 try:
+    # noinspection PyProtectedMember,PyUnresolvedReferences
     _unpack_opargs = dis._unpack_opargs
 except AttributeError:
     def _unpack_opargs(code):
@@ -124,64 +155,104 @@ except AttributeError:
                 i += 2
                 if op == dis.EXTENDED_ARG:
                     extended_arg = arg * long(65536)
-            yield (offset, op, arg)
+            yield offset, op, arg
 
 
 def _code_to_name(inst):
-    """If thw instruction's ``argval`` is :py:class:`types.CodeType`, replace it with the name and return the updated instruction.
+    """If the instruction's ``argval`` is :py:class:`types.CodeType`,
+    replace it with the name and return the updated instruction.
 
-    :type inst: :py:class:`Instruction`
-    :rtype: :py:class:`Instruction`
+    :type inst: :py:class:`_Instruction`
+    :rtype: :py:class:`_Instruction`
     """
     if inspect.iscode(inst.argval):
+        # noinspection PyProtectedMember
         return inst._replace(argval=inst.argval.co_name)
     return inst
 
 
-def get_smart_step_into_candidates(code):
-    """Iterate through the bytecode and return a list of instructions which can be smart step into candidates.
+class _BytecodeParsingError(Exception):
+    """Raised when fail of bytecode parsing."""
+    def __init__(self, offset, opname, arg):
+        self.offset = offset
+        self.opname = opname
+        self.arg = arg
+
+    def __str__(self):
+        return "Bytecode parsing error at: offset(%d), opname(%s), arg(%d)" % (
+            self.offset, self.opname, self.arg)
+
 
-    :param code: A code object where we searching for calls.
+def _get_smart_step_into_candidates(code):
+    """Iterate through the bytecode and return a list of instructions which can be
+    smart step into candidates.
+
+    :param code: A code object where we are searching for calls.
     :type code: :py:class:`types.CodeType`
-    :return: list of :py:class:`~Instruction` that represents the objects that were called
-      by one of the Python call instructions.
-    :raise: :py:class:`RuntimeError` if failed to parse the bytecode.
+    :return: list of :py:class:`~_Instruction` that represents the objects that were
+      called by one of the Python call instructions.
+    :raise: :py:class:`_BytecodeParsingError` if failed to parse the bytecode.
     """
     if not IS_CPYTHON:
         # For implementations other than CPython we fall back to simple step into.
+        _logger.debug('Not CPython, returning the empty list of candidates')
         return []
 
     linestarts = dict(dis.findlinestarts(code))
+    _logger.debug('Instructions stating lines: {}'.format(linestarts))
+
     varnames = code.co_varnames
+    _logger.debug('Local variables in function: {}'.format(varnames))
+
     names = code.co_names
+    _logger.debug('Named used by bytecode in function: {}'.format(names))
+
     constants = code.co_consts
+    _logger.debug('Literals used by bytecode in function: {}'.format(constants))
+
     freevars = code.co_freevars
+    _logger.debug('Name of free variables in function: {}'.format(freevars))
+
     lineno = None
-    stk = []  # only the instructions related to calls are pushed in the stack
+    stk = []  # Only the instructions related to calls are pushed in the stack.
     result = []
 
     for offset, op, arg in _unpack_opargs(code.co_code):
+        _logger.debug('-------------------------')
+        _logger.debug('Current instruction stack: {}'.format(stk))
+        _logger.debug('offset[{}] - op[{}={}] - arg[{}]'.format(
+            offset, op, dis.opname[op], arg))
         try:
             if linestarts is not None:
-                lineno = linestarts.get(offset, None) or lineno
+                lineno = linestarts.get(offset, None)
             opname = dis.opname[op]
             argval = None
             if arg is None:
                 if _is_binary_opname(opname):
+                    _logger.debug('Handling binary operator')
                     stk.pop()
-                    result.append(Instruction(opname, op, arg, _BINARY_OP_MAP[opname], lineno, offset))
+                    result.append(_Instruction(
+                        opname, op, arg, _BINARY_OP_MAP[opname], offset, lineno))
                 elif _is_unary_opname(opname):
-                    result.append(Instruction(opname, op, arg, _UNARY_OP_MAP[opname], lineno, offset))
+                    _logger.debug('Handling unary operator')
+                    result.append(_Instruction(
+                        opname, op, arg, _UNARY_OP_MAP[opname], offset, lineno))
             if opname == 'COMPARE_OP':
+                _logger.debug('Handling comparison operation')
                 stk.pop()
                 cmp_op = dis.cmp_op[arg]
                 if cmp_op not in ('exception match', 'BAD'):
-                    result.append(Instruction(opname, op, arg, _COMP_OP_MAP[cmp_op], lineno, offset))
+                    result.append(_Instruction(
+                        opname, op, arg, _COMP_OP_MAP[cmp_op], offset, lineno))
             if _is_load_opname(opname):
+                _logger.debug('Handling load operation')
                 if opname == 'LOAD_CONST':
                     argval = constants[arg]
                 elif opname == 'LOAD_NAME' or opname == 'LOAD_GLOBAL':
-                    argval = names[arg]
+                    if IS_PY311_OR_GREATER:
+                        argval = names[arg >> 1]
+                    else:
+                        argval = names[arg]
                 elif opname == 'LOAD_ATTR':
                     stk.pop()
                     argval = names[arg]
@@ -192,9 +263,11 @@ def get_smart_step_into_candidates(code):
                     argval = names[arg]
                 elif opname == 'LOAD_DEREF':
                     argval = freevars[arg]
-                stk.append(Instruction(opname, op, arg, argval, lineno, offset))
+                stk.append(_Instruction(opname, op, arg, argval, offset, lineno))
             elif _is_make_opname(opname):
-                tos = stk.pop()  # qualified name of the function or function code in Python 2
+                # Qualified name of the function or function code in Python 2.
+                _logger.debug('Handling make operation')
+                tos = stk.pop()
                 argc = 0
                 if IS_PY3K:
                     stk.pop()  # function code
@@ -209,9 +282,12 @@ def get_smart_step_into_candidates(code):
                     argc -= 1
                 stk.append(tos)
             elif _is_call_opname(opname):
+                _logger.debug('Handling call operation')
                 argc = arg  # the number of the function or method arguments
-                if opname == 'CALL_FUNCTION_KW' or not IS_PY3K and opname == 'CALL_FUNCTION_VAR':
-                    stk.pop()  # pop the mapping or iterable with arguments or parameters
+                if (opname == 'CALL_FUNCTION_KW' or not IS_PY3K
+                        and opname == 'CALL_FUNCTION_VAR'):
+                    # Pop the mapping or iterable with arguments or parameters.
+                    stk.pop()
                 elif not IS_PY3K and opname == 'CALL_FUNCTION_VAR_KW':
                     stk.pop()  # pop the mapping with arguments
                     stk.pop()  # pop the iterable with parameters
@@ -231,43 +307,80 @@ def get_smart_step_into_candidates(code):
                 if tos.opname == 'LOAD_BUILD_CLASS':
                     # an internal `CALL_FUNCTION` for building a class
                     continue
-                result.append(tos._replace(offset=offset))  # the actual offset is not when a function was loaded but when it was called
-        except:
-            err_msg = "Bytecode parsing error at: offset(%d), opname(%s), arg(%d)" % (offset, dis.opname[op], arg)
-            raise RuntimeError(err_msg)
+                # The actual offset is not when a function was loaded but when
+                # it was called.
+                _logger.debug('Adding call target from the top of the stack: {}'.
+                              format(tos))
+                result.append(tos._replace(offset=offset))
+        except Exception as e:
+            err = _BytecodeParsingError(offset, dis.opname[op], arg)
+            err.__cause__ = e
+            raise err
     return result
 
 
+def _get_smart_step_into_candidates_311(code):
+    result = []
+    stk = []
+    for instruction in dis.get_instructions(code):
+        if instruction.opname == 'CALL':
+            while stk and stk[-1].opname not in ('LOAD_NAME', 'LOAD_GLOBAL',
+                                                 'LOAD_ATTR', 'LOAD_METHOD'):
+                stk.pop()
+            if not stk:
+                continue
+            tos = stk.pop()
+            result.append(_Instruction(
+                tos.opname,
+                tos.opcode,
+                tos.arg,
+                tos.argval,
+                tos.offset,
+                tos.positions.lineno
+            ))
+        else:
+            stk.append(instruction)
+    return result
+
+
+if IS_PY311_OR_GREATER:
+    get_smart_step_into_candidates = _get_smart_step_into_candidates_311
+else:
+    get_smart_step_into_candidates = _get_smart_step_into_candidates
+
+
 Variant = namedtuple('Variant', ['name', 'is_visited'])
 
 
-def calculate_smart_step_into_variants(frame, start_line, end_line):
-    """
-    Calculate smart step into variants for the given line range.
-    :param frame:
-    :type frame: :py:class:`types.FrameType`
-    :param start_line:
-    :param end_line:
-    :return: A list of call names from the first to the last.
-    :raise: :py:class:`RuntimeError` if failed to parse the bytecode.
-    """
-    variants = []
-    is_context_reached = False
+def find_stepping_targets(frame, start_line, end_line):
+    """Find the *ordered* stepping targets within the given line range."""
+    _logger.debug("Collecting stepping targets for '{}' and line range [{}, {}]".format(
+        frame.f_code.co_name, start_line, end_line))
+    if DEBUG:
+        _logger.debug('The disassembled version of the code:')
+        dis.dis(frame.f_code, file=sys.stderr)
+    stepping_targets = []
+    is_within_range = False
     code = frame.f_code
-    lasti = frame.f_lasti
+    last_instruction = frame.f_lasti
+    _logger.debug('Last executed instruction offset is {}'.format(last_instruction))
     for inst in get_smart_step_into_candidates(code):
+        _logger.debug('Checking {} smart step into candidate'.format(inst))
         if inst.lineno and inst.lineno > end_line:
             break
-        if not is_context_reached and inst.lineno is not None and inst.lineno >= start_line:
-            is_context_reached = True
-        if not is_context_reached:
+        if (not is_within_range and inst.lineno is not None
+                and inst.lineno >= start_line):
+            is_within_range = True
+        if not is_within_range:
             continue
-        variants.append(Variant(inst.argval, inst.offset <= lasti))
-    return variants
+        stepping_targets.append(Variant(inst.argval, inst.offset < last_instruction))
+    _logger.debug('Found stepping targets: {}'.format(stepping_targets))
+    return stepping_targets
 
 
 def find_last_func_call_order(frame, start_line):
-    """Find the call order of the last function call between ``start_line`` and last executed instruction.
+    """Find the call order of the last function call between ``start_line``
+    and last executed instruction.
 
     :param frame: A frame inside which we are looking the function call.
     :type frame: :py:class:`types.FrameType`
@@ -303,9 +416,9 @@ def find_last_call_name(frame):
     """
     last_call_name = None
     code = frame.f_code
-    lasti = frame.f_lasti
+    last_instruction = frame.f_lasti
     for inst in get_smart_step_into_candidates(code):
-        if inst.offset > lasti:
+        if inst.offset > last_instruction:
             break
         last_call_name = inst.argval
 

{pydevd-pycharm-233.13763.11 → pydevd-pycharm-241.9959.30}/_pydevd_bundle/pydevd_comm.py

@@ -148,7 +148,7 @@ from _pydevd_bundle.pydevd_comm_constants import (
 MAX_IO_MSG_SIZE = 1000  #if the io is too big, we'll not send all (could make the debugger too non-responsive)
 #this number can be changed if there's need to do so
 
-VERSION_STRING = "233.13763.11"
+VERSION_STRING = "241.9959.30"
 
 from _pydev_bundle._pydev_filesystem_encoding import getfilesystemencoding
 file_system_encoding = getfilesystemencoding()
@@ -1479,7 +1479,7 @@ class InternalGetSmartStepIntoVariants(InternalThreadCommand):
     def do_it(self, dbg):
         try:
             frame = pydevd_vars.find_frame(self.thread_id, self.frame_id)
-            variants = pydevd_bytecode_utils.calculate_smart_step_into_variants(frame, self.start_line, self.end_line)
+            variants = pydevd_bytecode_utils.find_stepping_targets(frame, self.start_line, self.end_line)
             xml = "<xml>"
 
             for name, is_visited in variants:

{pydevd-pycharm-233.13763.11 → pydevd-pycharm-241.9959.30}/_pydevd_bundle/pydevd_pep_669_tracing.py

@@ -398,7 +398,6 @@ class PyLineCallback(PEP669CallbackBase):
                 stop = False
 
                 if step_cmd == CMD_SMART_STEP_INTO:
-                    stop = False
                     if smart_stop_frame is frame:
                         if not is_within_context:
                             # We don't stop on jumps in multiline statements, which

{pydevd-pycharm-233.13763.11 → pydevd-pycharm-241.9959.30}/_pydevd_bundle/pydevd_thrift.py

@@ -194,7 +194,10 @@ class TypeResolveHandler(object):
             return None
 
         if provider is not None:
-            return provider.get_str(o, do_trim)
+            try:
+                return provider.get_str(o, do_trim)
+            except TypeError:
+                return provider.get_str(o)
 
         if not self._initialized:
             self._initialize()
@@ -202,7 +205,10 @@ class TypeResolveHandler(object):
         for provider in self._str_providers:
             if provider.can_provide(type_object, type_name):
                 self._type_to_str_provider_cache[type_object] = provider
-                return provider.get_str(o, do_trim)
+                try:
+                    return provider.get_str(o, do_trim)
+                except TypeError:
+                    return provider.get_str(o)
 
         self._type_to_str_provider_cache[type_object] = self.NO_PROVIDER
         return None

{pydevd-pycharm-233.13763.11 → pydevd-pycharm-241.9959.30}/_pydevd_bundle/pydevd_utils.py

@@ -54,7 +54,9 @@ def save_main_module(file, module_name):
         if hasattr(orig_module, attr):
             orig_attr = getattr(orig_module, attr)
             setattr(m, attr, orig_attr)
-    m.__file__ = file
+
+    if file is not None:
+        m.__file__ = file
 
     return m
 

{pydevd-pycharm-233.13763.11 → pydevd-pycharm-241.9959.30}/_pydevd_bundle/pydevd_xml.py

@@ -206,7 +206,10 @@ class TypeResolveHandler(object):
             return None
 
         if provider is not None:
-            return provider.get_str(o, do_trim)
+            try:
+                return provider.get_str(o, do_trim)
+            except TypeError:
+                return provider.get_str(o)
 
         if not self._initialized:
             self._initialize()
@@ -214,7 +217,10 @@ class TypeResolveHandler(object):
         for provider in self._str_providers:
             if provider.can_provide(type_object, type_name):
                 self._type_to_str_provider_cache[type_object] = provider
-                return provider.get_str(o, do_trim)
+                try:
+                    return provider.get_str(o, do_trim)
+                except TypeError:
+                    return provider.get_str(o)
 
         self._type_to_str_provider_cache[type_object] = self.NO_PROVIDER
         return None

{pydevd-pycharm-233.13763.11 → pydevd-pycharm-241.9959.30}/pydevconsole.py

@@ -75,7 +75,7 @@ class InterpreterInterface(BaseInterpreterInterface):
         self._input_error_printed = False
 
     def save_main(self):
-        m = save_main_module('<input>', 'pydevconsole')
+        m = save_main_module(None, 'pydevconsole')
         self.namespace = m.__dict__
         try:
             self.namespace['__builtins__'] = __builtins__

{pydevd-pycharm-233.13763.11 → pydevd-pycharm-241.9959.30/pydevd_pycharm.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.1
 Name: pydevd-pycharm
-Version: 233.13763.11
+Version: 241.9959.30
 Summary: PyCharm Debugger (used in PyCharm and PyDev)
 Home-page: https://github.com/JetBrains/intellij-community
 Author: JetBrains, Fabio Zadrozny and others

pydevd-pycharm-233.13763.11/VERSION

@@ -1 +0,0 @@
-233.13763.11