Remove unused code

Author: sergisiso

src/psyclone/domain/lfric/transformations/lfric_alg_invoke_2_psy_call_trans.py

@@ -65,10 +65,6 @@ def validate(self, node: LFRicAlgorithmInvokeCall,
                 "A dictionary containing LFRic kernel PSyIR must be passed "
                 "into the LFRicAlgInvoke2PSyCallTrans transformation but "
                 "this was not found.")
-        if not isinstance(kernels, dict):
-            raise TransformationError(
-                f"The value of 'kernels' in the options argument must be a "
-                f"dictionary but found '{type(kernels).__name__}'.")
         for kern_call in node.arguments:
             if isinstance(kern_call, LFRicBuiltinFunctor):
                 # Skip builtins as their metadata is stored internally

src/psyclone/psyir/transformations/psy_data_trans.py

@@ -12,8 +12,6 @@
 import warnings
 
 from psyclone.configuration import Config
-from psyclone.errors import InternalError
-from psyclone.psyGen import InvokeSchedule, Kern
 from psyclone.psyir.nodes import Node, PSyDataNode, Schedule, Return, \
     OMPDoDirective, ACCDirective, ACCLoopDirective, Routine
 from psyclone.psyir.transformations.region_trans import RegionTrans
@@ -84,62 +82,6 @@ class name as a string, which means that the same function can
 
         return self.__class__.__name__
 
-    # ------------------------------------------------------------------------
-    def get_unique_region_name(self, nodes, options):
-        '''This function returns the region and module name. If they are
-        specified in the user options, these names will just be returned (it
-        is then up to the user to guarantee uniqueness). Otherwise a name
-        based on the module and invoke will be created using indices to
-        make sure the name is unique.
-
-        :param nodes: a list of nodes.
-        :type nodes: list of :py:obj:`psyclone.psyir.nodes.Node`
-        :param options: a dictionary with options for transformations.
-        :type options: Dict[str, Any]
-        :param (str,str) options["region_name"]: an optional name to \
-            use for this PSyData area, provided as a 2-tuple containing a \
-            location name followed by a local name. The pair of strings \
-            should uniquely identify a region unless aggregate information \
-            is required (and is supported by the runtime library).
-
-        '''
-        # We don't use a static method here since it might be useful to
-        # overwrite this functions in derived classes
-        name = options.get("region_name", None)
-        if name:
-            # pylint: disable=too-many-boolean-expressions
-            if not isinstance(name, tuple) or not len(name) == 2 or \
-               not name[0] or not isinstance(name[0], str) or \
-               not name[1] or not isinstance(name[1], str):
-                raise InternalError(
-                    "Error in PSyDataTrans. The name must be a "
-                    "tuple containing two non-empty strings.")
-            # pylint: enable=too-many-boolean-expressions
-            # Valid PSyData names have been provided by the user.
-            return name
-
-        invoke = nodes[0].ancestor(InvokeSchedule).invoke
-        module_name = invoke.invokes.psy.name
-
-        # Use the invoke name as a starting point.
-        region_name = invoke.name
-        kerns = []
-        for node in nodes:
-            kerns.extend(node.walk(Kern))
-
-        if len(kerns) == 1:
-            # This PSyData region only has one kernel within it,
-            # so append the kernel name.
-            region_name += f"-{kerns[0].name}"
-
-        # Add a region index to ensure uniqueness when there are
-        # multiple regions in an invoke.
-        key = module_name + "|" + region_name
-        idx = PSyDataTrans._used_kernel_names.get(key, 0)
-        PSyDataTrans._used_kernel_names[key] = idx + 1
-        region_name += f"-r{idx}"
-        return (module_name, region_name)
-
     # ------------------------------------------------------------------------
     def validate(self, nodes: Union[Node, list[Node]],
                  options: Optional[dict[str, Any]] = None,

src/psyclone/tests/domain/lfric/transformations/lfric_alg_invoke_2_psy_call_trans_test.py

@@ -262,7 +262,7 @@ def test_lfai2psycall_get_arguments():
         [Reference(Symbol("arg1")), Reference(Symbol("arg2"))])
     call = LFRicAlgorithmInvokeCall.create(
         RoutineSymbol("mysub"), [builtin_functor], 0)
-    args = trans.get_arguments(call, kernels={})
+    args = trans.get_arguments(call)
     assert len(args) == 2
     assert isinstance(args[0], Reference)
     assert args[0].name == "arg1"

src/psyclone/tests/psyir/transformations/psy_data_trans_test.py

@@ -10,7 +10,6 @@
 import pytest
 
 from psyclone.configuration import Config
-from psyclone.errors import InternalError
 from psyclone.psyir.nodes import Assignment, Loop, PSyDataNode, Routine
 from psyclone.psyir.transformations import (
     OMPLoopTrans, PSyDataTrans, ReadOnlyVerifyTrans, TransformationError)
@@ -162,38 +161,6 @@ def test_class_definitions(fortran_writer):
     assert "as defined in /" in str(err.value)
 
 
-# -----------------------------------------------------------------------------
-def test_psy_data_get_unique_region_names():
-    '''Tests the get_unique_region_names function.'''
-    data_trans = PSyDataTrans()
-    region_name = data_trans.\
-        get_unique_region_name([], {"region_name": ("a", "b")})
-    assert region_name == ("a", "b")
-
-    with pytest.raises(InternalError) as err:
-        region_name = data_trans.\
-            get_unique_region_name([], {"region_name": 1})
-    assert "The name must be a tuple containing two non-empty strings." \
-        in str(err.value)
-
-    with pytest.raises(InternalError) as err:
-        region_name = data_trans.\
-            get_unique_region_name([], {"region_name": ("a", "")})
-    assert "The name must be a tuple containing two non-empty strings." \
-        in str(err.value)
-
-    _, invoke = get_invoke("test11_different_iterates_over_one_invoke.f90",
-                           "gocean", idx=0)
-    region_name = data_trans.get_unique_region_name(invoke.schedule, {})
-    assert region_name == ('psy_single_invoke_different_iterates_over',
-                           'invoke_0-r0')
-
-    region_name = data_trans.\
-        get_unique_region_name([invoke.schedule[0]], {})
-    assert region_name == ('psy_single_invoke_different_iterates_over',
-                           'invoke_0-compute_cv_code-r0')
-
-
 # -----------------------------------------------------------------------------
 def test_trans_with_shape_function(monkeypatch, fortran_reader,
                                    fortran_writer):