Add Try node

Author: cdce8p

ChangeLog

@@ -99,6 +99,9 @@ Release date: TBA
 
   Refs #2141
 
+* Add new ``nodes.Try`` to better match Python AST. Replaces the ``TryExcept``
+  and ``TryFinally`` nodes which have been removed.
+
 
 What's New in astroid 2.15.4?
 =============================

astroid/__init__.py

@@ -161,8 +161,7 @@
     Slice,
     Starred,
     Subscript,
-    TryExcept,
-    TryFinally,
+    Try,
     Tuple,
     UnaryOp,
     Unknown,

astroid/inference.py

@@ -1260,7 +1260,7 @@ def infer_functiondef(
         isinstance(val, objects.Property) for val in parent_frame.locals[self.name]
     )
     # We also don't want to pass parent if the definition is within a Try node
-    if isinstance(self.parent, (nodes.TryExcept, nodes.TryFinally, nodes.If)):
+    if isinstance(self.parent, (nodes.Try, nodes.If)):
         property_already_in_parent_locals = True
 
     prop_func = objects.Property(

astroid/node_classes.py

@@ -74,8 +74,7 @@
     Slice,
     Starred,
     Subscript,
-    TryExcept,
-    TryFinally,
+    Try,
     Tuple,
     UnaryOp,
     Unknown,

astroid/nodes/__init__.py

@@ -82,8 +82,7 @@
     Slice,
     Starred,
     Subscript,
-    TryExcept,
-    TryFinally,
+    Try,
     TryStar,
     Tuple,
     UnaryOp,
@@ -195,8 +194,7 @@
     Slice,
     Starred,
     Subscript,
-    TryExcept,
-    TryFinally,
+    Try,
     Tuple,
     UnaryOp,
     Unknown,
@@ -289,8 +287,7 @@
     "Starred",
     "Statement",
     "Subscript",
-    "TryExcept",
-    "TryFinally",
+    "Try",
     "Tuple",
     "UnaryOp",
     "Unknown",

astroid/nodes/as_string.py

@@ -10,6 +10,7 @@
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from astroid import nodes
     from astroid.nodes import Const
     from astroid.nodes.node_classes import (
         Match,
@@ -480,21 +481,17 @@ def visit_subscript(self, node) -> str:
             idxstr = idxstr[1:-1]
         return f"{self._precedence_parens(node, node.value)}[{idxstr}]"
 
-    def visit_tryexcept(self, node) -> str:
-        """return an astroid.TryExcept node as string"""
+    def visit_try(self, node: nodes.Try) -> str:
+        """return an astroid.Try node as string"""
         trys = [f"try:\n{self._stmt_list(node.body)}"]
         for handler in node.handlers:
             trys.append(handler.accept(self))
         if node.orelse:
             trys.append(f"else:\n{self._stmt_list(node.orelse)}")
+        if node.finalbody:
+            trys.append(f"finally:\n{self._stmt_list(node.finalbody)}")
         return "\n".join(trys)
 
-    def visit_tryfinally(self, node) -> str:
-        """return an astroid.TryFinally node as string"""
-        return "try:\n{}\nfinally:\n{}".format(
-            self._stmt_list(node.body), self._stmt_list(node.finalbody)
-        )
-
     def visit_tuple(self, node) -> str:
         """return an astroid.Tuple node as string"""
         if len(node.elts) == 1:

astroid/nodes/node_classes.py

@@ -132,7 +132,7 @@ def are_exclusive(stmt1, stmt2, exceptions: list[str] | None = None) -> bool:
     previous = stmt2
     for node in stmt2.node_ancestors():
         if node in stmt1_parents:
-            # if the common parent is a If or TryExcept statement, look if
+            # if the common parent is a If or Try statement, look if
             # nodes are in exclusive branches
             if isinstance(node, If) and exceptions is None:
                 c2attr, c2node = node.locate_child(previous)
@@ -144,7 +144,7 @@ def are_exclusive(stmt1, stmt2, exceptions: list[str] | None = None) -> bool:
                 if c1attr != c2attr:
                     # different `If` branches (`If.body` and `If.orelse`)
                     return True
-            elif isinstance(node, TryExcept):
+            elif isinstance(node, Try):
                 c2attr, c2node = node.locate_child(previous)
                 c1attr, c1node = node.locate_child(children[node])
                 if c1node is not c2node:
@@ -3110,97 +3110,33 @@ def get_children(self):
         yield self.slice
 
 
-class TryExcept(_base_nodes.MultiLineWithElseBlockNode, _base_nodes.Statement):
-    """Class representing an :class:`ast.TryExcept` node.
+class Try(_base_nodes.MultiLineWithElseBlockNode, _base_nodes.Statement):
+    """Class representing a :class:`ast.Try` node.
 
     >>> import astroid
     >>> node = astroid.extract_node('''
         try:
             do_something()
         except Exception as error:
             print("Error!")
+        finally:
+            print("Cleanup!")
         ''')
     >>> node
-    <TryExcept l.2 at 0x7f23b2e9d908>
+    <Try l.2 at 0x7f23b2e41d68>
     """
 
-    _astroid_fields = ("body", "handlers", "orelse")
-    _multi_line_block_fields = ("body", "handlers", "orelse")
-
-    body: list[NodeNG]
-    """The contents of the block to catch exceptions from."""
-
-    handlers: list[ExceptHandler]
-    """The exception handlers."""
-
-    orelse: list[NodeNG]
-    """The contents of the ``else`` block."""
-
-    def postinit(
-        self,
-        body: list[NodeNG],
-        handlers: list[ExceptHandler],
-        orelse: list[NodeNG],
-    ) -> None:
-        self.body = body
-        self.handlers = handlers
-        self.orelse = orelse
-
-    def _infer_name(self, frame, name):
-        return name
-
-    def block_range(self, lineno: int) -> tuple[int, int]:
-        """Get a range from the given line number to where this node ends.
-
-        :param lineno: The line number to start the range at.
-
-        :returns: The range of line numbers that this node belongs to,
-            starting at the given line number.
-        """
-        last = None
-        for exhandler in self.handlers:
-            if exhandler.type and lineno == exhandler.type.fromlineno:
-                return lineno, lineno
-            if exhandler.body[0].fromlineno <= lineno <= exhandler.body[-1].tolineno:
-                return lineno, exhandler.body[-1].tolineno
-            if last is None:
-                last = exhandler.body[0].fromlineno - 1
-        return self._elsed_block_range(lineno, self.orelse, last)
-
-    def get_children(self):
-        yield from self.body
-
-        yield from self.handlers or ()
-        yield from self.orelse or ()
-
-
-class TryFinally(_base_nodes.MultiLineWithElseBlockNode, _base_nodes.Statement):
-    """Class representing an :class:`ast.TryFinally` node.
-
-    >>> import astroid
-    >>> node = astroid.extract_node('''
-    try:
-        do_something()
-    except Exception as error:
-        print("Error!")
-    finally:
-        print("Cleanup!")
-    ''')
-    >>> node
-    <TryFinally l.2 at 0x7f23b2e41d68>
-    """
-
-    _astroid_fields = ("body", "finalbody")
-    _multi_line_block_fields = ("body", "finalbody")
+    _astroid_fields = ("body", "handlers", "orelse", "finalbody")
+    _multi_line_block_fields = ("body", "handlers", "orelse", "finalbody")
 
     def __init__(
         self,
+        *,
         lineno: int | None = None,
         col_offset: int | None = None,
-        parent: NodeNG | None = None,
-        *,
         end_lineno: int | None = None,
         end_col_offset: int | None = None,
+        parent: NodeNG | None = None,
     ) -> None:
         """
         :param lineno: The line that this node appears on in the source code.
@@ -3215,8 +3151,14 @@ def __init__(
         :param end_col_offset: The end column this node appears on in the
             source code. Note: This is after the last symbol.
         """
-        self.body: list[NodeNG | TryExcept] = []
-        """The try-except that the finally is attached to."""
+        self.body: list[NodeNG] = []
+        """The contents of the block to catch exceptions from."""
+
+        self.handlers: list[ExceptHandler] = []
+        """The exception handlers."""
+
+        self.orelse: list[NodeNG] = []
+        """The contents of the ``else`` block."""
 
         self.finalbody: list[NodeNG] = []
         """The contents of the ``finally`` block."""
@@ -3231,40 +3173,62 @@ def __init__(
 
     def postinit(
         self,
-        body: list[NodeNG | TryExcept] | None = None,
+        *,
+        body: list[NodeNG] | None = None,
+        handlers: list[ExceptHandler] | None = None,
+        orelse: list[NodeNG] | None = None,
         finalbody: list[NodeNG] | None = None,
     ) -> None:
         """Do some setup after initialisation.
 
-        :param body: The try-except that the finally is attached to.
+        :param body: The contents of the block to catch exceptions from.
+
+        :param handlers: The exception handlers.
+
+        :param orelse: The contents of the ``else`` block.
 
         :param finalbody: The contents of the ``finally`` block.
         """
-        if body is not None:
+        if body:
             self.body = body
-        if finalbody is not None:
+        if handlers:
+            self.handlers = handlers
+        if orelse:
+            self.orelse = orelse
+        if finalbody:
             self.finalbody = finalbody
 
-    def block_range(self, lineno: int) -> tuple[int, int]:
-        """Get a range from the given line number to where this node ends.
-
-        :param lineno: The line number to start the range at.
+    def _infer_name(self, frame, name):
+        return name
 
-        :returns: The range of line numbers that this node belongs to,
-            starting at the given line number.
-        """
-        child = self.body[0]
-        # py2.5 try: except: finally:
-        if (
-            isinstance(child, TryExcept)
-            and child.fromlineno == self.fromlineno
-            and child.tolineno >= lineno > self.fromlineno
-        ):
-            return child.block_range(lineno)
-        return self._elsed_block_range(lineno, self.finalbody)
+    def block_range(self, lineno: int) -> tuple[int, int]:
+        """Get a range from a given line number to where this node ends."""
+        if lineno == self.fromlineno:
+            return lineno, lineno
+        if self.body and self.body[0].fromlineno <= lineno <= self.body[-1].tolineno:
+            # Inside try body - return from lineno till end of try body
+            return lineno, self.body[-1].tolineno
+        for exhandler in self.handlers:
+            if exhandler.type and lineno == exhandler.type.fromlineno:
+                return lineno, lineno
+            if exhandler.body[0].fromlineno <= lineno <= exhandler.body[-1].tolineno:
+                return lineno, exhandler.body[-1].tolineno
+        if self.orelse:
+            if self.orelse[0].fromlineno - 1 == lineno:
+                return lineno, lineno
+            if self.orelse[0].fromlineno <= lineno <= self.orelse[-1].tolineno:
+                return lineno, self.orelse[-1].tolineno
+        if self.finalbody:
+            if self.finalbody[0].fromlineno - 1 == lineno:
+                return lineno, lineno
+            if self.finalbody[0].fromlineno <= lineno <= self.finalbody[-1].tolineno:
+                return lineno, self.finalbody[-1].tolineno
+        return lineno, self.tolineno
 
     def get_children(self):
         yield from self.body
+        yield from self.handlers
+        yield from self.orelse
         yield from self.finalbody
 
 

astroid/nodes/node_ng.py

@@ -587,7 +587,7 @@ def _get_yield_nodes_skip_lambdas(self):
         yield from ()
 
     def _infer_name(self, frame, name):
-        # overridden for ImportFrom, Import, Global, TryExcept and Arguments
+        # overridden for ImportFrom, Import, Global, Try, TryStar and Arguments
         pass
 
     def _infer(