class_docstr: Mapping bytecode to ast-node based on the source positions, which where introduced in pyhon 3.11.
  In general every ast-node can be exactly referenced by its begin/end line/col_offset, which is stored in the bytecode.
  There are only some exceptions for methods and attributes.
code: def known_issues(
      self, node: EnhancedAST, instruction: dis.Instruction
  ) -> None:
      if instruction.opname in (
          "COMPARE_OP",
          "IS_OP",
          "CONTAINS_OP",
      ) and isinstance(node, types_cmp_issue):
          if isinstance(node, types_cmp_issue_fix):
              # this is a workaround for https://github.com/python/cpython/issues/95921
              # we can fix cases with only on comparison inside the test condition
              #
              # we can not fix cases like:
              # if a<b<c and d<e<f: pass
              # if (a<b<c)!=d!=e: pass
              # because we don't know which comparison caused the problem
  
              comparisons = [
                  n
                  for n in ast.walk(node.test)  # type: ignore[attr-defined]
                  if isinstance(n, ast.Compare) and len(n.ops) > 1
              ]
  
              assert_(comparisons, "expected at least one comparison")
  
              if len(comparisons) == 1:
                  node = self.result = cast(EnhancedAST, comparisons[0])
              else:
                  raise KnownIssue(
                      "multiple chain comparison inside %s can not be fixed"
                      % (node)
                  )
  
          else:
              # Comprehension and generators get not fixed for now.
              raise KnownIssue(
                  "chain comparison inside %s can not be fixed" % (node)
              )
  
      if (
          sys.version_info[:3] == (3, 11, 1)
          and isinstance(node, ast.Compare)
          and instruction.opname == "CALL"
          and any(
              isinstance(n, ast.Assert) for n in node_and_parents(node)
          )
      ):
          raise KnownIssue(
              "known bug in 3.11.1 https://github.com/python/cpython/issues/95921"
          )
  
      if isinstance(node, ast.Assert):
          # pytest assigns the position of the assertion to all expressions of the rewritten assertion.
          # All the rewritten expressions get mapped to ast.Assert, which is the wrong ast-node.
          # We don't report this wrong result.
          raise KnownIssue("assert")
  
      if any(
          isinstance(n, ast.pattern) for n in node_and_parents(node)
      ):
          # TODO: investigate
          raise KnownIssue("pattern matching ranges seems to be wrong")
  
      if (
          sys.version_info >= (3, 12)
          and isinstance(node, ast.Call)
          and isinstance(node.func, ast.Name)
          and node.func.id == "super"
      ):
          # super is optimized to some instructions which do not map nicely to a Call
  
          # find the enclosing function
          func = node.parent
          while hasattr(func, "parent") and not isinstance(
              func, (ast.AsyncFunctionDef, ast.FunctionDef)
          ):
              func = func.parent
  
          # get the first function argument (self/cls)
          first_arg = None
  
          if hasattr(func, "args"):
              args = [*func.args.posonlyargs, *func.args.args]
              if args:
                  first_arg = args[0].arg
  
          if (instruction.opname, instruction.argval) in [
              ("LOAD_DEREF", "__class__"),
              ("LOAD_FAST", first_arg),
              ("LOAD_DEREF", first_arg),
          ]:
              raise KnownIssue("super optimization")
  
      if self.is_except_cleanup(instruction, node):
          raise KnownIssue(
              "exeption cleanup does not belong to the last node in a except block"
          )
  
      if (
          instruction.opname == "STORE_NAME"
          and instruction.argval == "__classcell__"
      ):
          # handle stores to __classcell__ as KnownIssue,
          # because they get complicated if they are used in `if` or `for` loops
          # example:
          #
          # class X:
          #     # ... something
          #     if some_condition:
          #         def method(self):
          #             super()
          #
          # The `STORE_NAME` instruction gets mapped to the `ast.If` node,
          # because it is the last element in the class.
          # This last element could be anything and gets dificult to verify.
  
          raise KnownIssue("store __classcell__")
  
      if (
          instruction.opname == "CALL"
          and not isinstance(node, ast.Call)
          and any(isinstance(p, ast.Assert) for p in parents(node))
          and sys.version_info >= (3, 11, 2)
      ):
          raise KnownIssue("exception generation maps to condition")
  
imports: import ast
  import sys
  import dis
  from types import CodeType, FrameType
  from typing import Any, Callable, Iterator, Optional, Sequence, Set, Tuple, Type, Union, cast
  from .executing import EnhancedAST, NotOneValueFound, Source, only, function_node_types, assert_
  from ._exceptions import KnownIssue, VerifierFailure
  from functools import lru_cache
label_desc: Use image node_id 3 for calling the PositionNodeFinder obj's underlying member method code with example usage: obj.known_issues(node, instruction) without return types