From faec8e60b2c38f0b42ce8cad2a0c49ac19254e70 Mon Sep 17 00:00:00 2001 From: Nash Aschenbath Date: Sun, 22 Nov 2026 18:53:11 +0800 Subject: [PATCH] Refuse inlining methods decorated with abc.abstractmethod --- rope/refactor/inline.py | 10 ++++++++++ ropetest/refactor/inlinetest.py | 34 +++++++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+) diff --git a/rope/refactor/inline.py b/rope/refactor/inline.py index 768d30b7d..ab68d6816 100644 --- a/rope/refactor/inline.py +++ b/rope/refactor/inline.py @@ -98,6 +98,16 @@ def __init__(self, *args, **kwds): super().__init__(*args, **kwds) self.pyfunction = self.pyname.get_object() self.pymodule = self.pyfunction.get_module() + scope = self.pyfunction.parent.get_scope() + for decorator in self.pyfunction.decorators: + pyname = evaluate.eval_node(scope, decorator) + pyobject = pyname.get_object() if pyname is not None else None + if ( + isinstance(pyobject, pyobjects.PyFunction) + and pyobject.get_name() == "abstractmethod" + and pyobject.get_module().get_name() == "abc" + ): + raise exceptions.RefactoringError("Cannot inline an abstract method.") self.resource = self.pyfunction.get_module().get_resource() self.occurrence_finder = occurrences.create_finder( self.project, self.name, self.pyname diff --git a/ropetest/refactor/inlinetest.py b/ropetest/refactor/inlinetest.py index 8ded0143c..07e291b30 100644 --- a/ropetest/refactor/inlinetest.py +++ b/ropetest/refactor/inlinetest.py @@ -37,6 +37,40 @@ def test_simple_case(self): refactored = self._inline(code, code.index("a_var") + 1) self.assertEqual("another_var = 10\n", refactored) + def test_refuses_abstract_method_inlining(self): + for import_line, decorator in [ + ("from abc import abstractmethod", "abstractmethod"), + ("import abc", "abc.abstractmethod"), + ("from abc import abstractmethod as abstract", "abstract"), + ]: + with self.subTest(decorator=decorator): + code = ( + import_line + "\nclass Base:\n" + " @" + decorator + "\n" + " def method(self):\n return 1\n" + "Base().method()\n" + ) + for offset in [code.index("def method") + 5, code.rindex("method")]: + self.mod.write(code) + with self.assertRaisesRegex( + rope.base.exceptions.RefactoringError, "abstract method" + ): + inline.create_inline(self.project, self.mod, offset) + self.assertEqual(self.mod.read(), code) + + def test_same_named_custom_decorator_is_not_abstract(self): + code = dedent("""\ + def abstractmethod(func): + return func + class Base: + @abstractmethod + def method(self): + return 1 + result = Base().method() + """) + refactored = self._inline(code, code.index("def method") + 5) + self.assertIn("result = 1", refactored) + def test_empty_case(self): code = "a_var = 10\n" refactored = self._inline(code, code.index("a_var") + 1)