Raise a deprecation warning if Operator.decomposition is a staticmethod

pennylane/gradients/gradient_transform.py

@@ -47,7 +47,7 @@ def grad_method_validation(method, tape):
 
     diff_methods = {
         idx: info["grad_method"]
-        for idx, info in tape._par_info.items()
+        for idx, info in tape._par_info.items()  # pylint: disable=protected-access
         if idx in tape.trainable_params
     }
 

pennylane/operation.py

@@ -1266,7 +1266,22 @@ def expand(self):
         tape = qml.tape.QuantumTape(do_queue=False)
 
         with tape:
-            self.decomposition()
+
+            try:
+                self.decomposition()
+
+            except TypeError:
+                if self.num_params == 0:
+                    self.decomposition(wires=self.wires)
+                else:
+                    self.decomposition(*self.parameters, wires=self.wires)
+
+                warnings.warn(
+                    "Operator.decomposition() is now an instance method, and no longer accepts parameters. "
+                    "Either define the static method 'compute_decomposition' instead, or use "
+                    "'self.wires' and 'self.parameters'.",
+                    UserWarning,
+                )
 
         if not self.data:
             # original operation has no trainable parameters

tests/test_operation.py

@@ -16,6 +16,7 @@
 """
 import itertools
 from functools import reduce
+import warnings
 
 import pytest
 import numpy as np
@@ -1845,3 +1846,91 @@ def test_eigvals_tensor_deprecation(self):
             m1 = op.eigvals
 
         assert np.allclose(m1, op.get_eigvals())
+
+    def test_decomposition_deprecation_no_parameters(self):
+        """Test that old-style staticmethod decompositions for an operation
+        with no parameters raises a warning"""
+        dev = qml.device("default.qubit", wires=1)
+
+        class MyOp(Operation):
+            num_wires = 1
+            num_params = 0
+
+            @staticmethod
+            def decomposition(wires):
+                qml.RY(0.5, wires=wires[0])
+
+        @qml.qnode(dev)
+        def qnode():
+            MyOp(wires=0)
+            return qml.state()
+
+        with pytest.warns(UserWarning, match="is now an instance method"):
+            result1 = qnode()
+
+        # using an instance method will not raise a deprecation warning
+
+        class MyOp(Operation):
+            num_wires = 1
+            num_params = 0
+
+            def decomposition(self):
+                qml.RY(0.5, wires=self.wires[0])
+
+        @qml.qnode(dev)
+        def qnode():
+            MyOp(wires=0)
+            return qml.state()
+
+        with warnings.catch_warnings():
+            # any warnings emitted will be raised as errors
+            warnings.simplefilter("error")
+            result2 = qnode()
+
+        assert np.allclose(result1, result2)
+
+    def test_decomposition_deprecation_parameters(self):
+        """Test that old-style staticmethod decompositions for an operation
+        with parameters raises a warning"""
+        dev = qml.device("default.qubit", wires=1)
+
+        class MyOp(Operation):
+            num_wires = 1
+            num_params = 2
+
+            @staticmethod
+            def decomposition(*params, wires):
+                qml.RY(params[0], wires=wires[0])
+                qml.PauliZ(wires=wires[0])
+                qml.RX(params[1], wires=wires[0])
+
+        @qml.qnode(dev)
+        def qnode(*params):
+            MyOp(*params, wires=0)
+            return qml.state()
+
+        with pytest.warns(UserWarning, match="is now an instance method"):
+            result1 = qnode(0.1, 0.2)
+
+        # using an instance method will not raise a deprecation warning
+
+        class MyOp(Operation):
+            num_wires = 1
+            num_params = 2
+
+            def decomposition(self):
+                qml.RY(self.parameters[0], wires=self.wires[0])
+                qml.PauliZ(wires=self.wires[0])
+                qml.RX(self.parameters[1], wires=self.wires[0])
+
+        @qml.qnode(dev)
+        def qnode(*params):
+            MyOp(*params, wires=0)
+            return qml.state()
+
+        with warnings.catch_warnings():
+            # any warnings emitted will be raised as errors
+            warnings.simplefilter("error")
+            result2 = qnode(0.1, 0.2)
+
+        assert np.allclose(result1, result2)