(Closes #1734 #2975 #2949) Add stricter checking for symbols

examples/lfric/eg16/create.py

@@ -62,10 +62,11 @@
 Config.get()
 
 # Add LFRic precision symbols and the module in which they are
-# contained to the symbol table
+# contained to the symbol table.
 SYMBOL_TABLE = SymbolTable()
-for symbol in [LFRicTypes("I_DEF"), LFRicTypes("R_DEF"),
-               LFRicTypes("constants_mod")]:
+for symbol in [LFRicTypes("constants_mod"),
+               LFRicTypes("I_DEF"),
+               LFRicTypes("R_DEF")]:
     SYMBOL_TABLE.add(symbol)
 
 # Create LFRic ndf and undf symbols and add them to the symbol table

src/psyclone/domain/common/transformations/kernel_module_inline_trans.py

@@ -42,7 +42,6 @@
 and move it to psyir/transformations/.
 
 '''
-from typing import List
 import warnings
 
 from psyclone.psyGen import Transformation, CodedKern
@@ -252,7 +251,7 @@ def _validate_schedule(self, node, kname, kern_or_call, kernel_schedule):
 
     @staticmethod
     def _prepare_code_to_inline(
-            routines_to_inline: List[Routine]) -> List[Routine]:
+            routines_to_inline: list[Routine]) -> list[Routine]:
         '''Prepare the PSyIR tree to inline by bringing in to the subroutine
         all referenced symbols so that the implementation is self contained.
 
@@ -262,7 +261,6 @@ def _prepare_code_to_inline(
         :param routines_to_inline: the routine(s) to module-inline.
 
         :returns: the updated routine(s) to module-inline.
-        :rtype: list[:py:class:`psyclone.psyir.node.Routine`]
 
         '''
         # pylint: disable=too-many-branches
@@ -291,15 +289,21 @@ def _prepare_code_to_inline(
             symbols_to_bring_in = set()
             for symbol in all_symbols:
                 if symbol.is_unresolved or symbol.is_import:
-                    # This symbol is already in the symbol table, but adding it
-                    # to the 'symbols_to_bring_in' will make the next step
-                    # bring into the subroutine all modules that it could come
-                    # from.
+                    # This symbol may already be in the local symbol table,
+                    # but adding it to the 'symbols_to_bring_in' will make the
+                    # next step bring into the subroutine all modules that it
+                    # could come from.
                     symbols_to_bring_in.add(symbol)
 
             # Bring the selected symbols inside the subroutine
             for symbol in symbols_to_bring_in:
                 if symbol.name not in code_to_inline.symbol_table:
+                    if symbol.is_import:
+                        # We must update its import interface (to ensure it
+                        # references a ContainerSymbol in the correct scope)
+                        # before it can be added to the table.
+                        code_to_inline.symbol_table.update_import_interface(
+                            symbol)
                     code_to_inline.symbol_table.add(symbol)
                 # And when necessary the modules where they come from
                 if symbol.is_unresolved:

src/psyclone/domain/lfric/kern_call_arg_list.py

@@ -55,7 +55,7 @@
     ArrayReference, Reference, StructureReference)
 from psyclone.psyir.symbols import (
     DataSymbol, DataTypeSymbol, UnresolvedType, ContainerSymbol,
-    ImportInterface, ScalarType, ArrayType, UnsupportedFortranType,
+    ImportInterface, ScalarType, ArrayType, Symbol, UnsupportedFortranType,
     ArgumentInterface)
 
 # psyir has classes created at runtime
@@ -93,20 +93,20 @@ def __init__(self, kern):
         self._nqp_positions = []
         self._ndf_positions = []
 
-    def get_user_type(self, module_name, user_type, name, tag=None):
+    def get_user_type(self, module_name: str,
+                      user_type: str, name: str,
+                      tag: Optional[str] = None) -> Symbol:
         # pylint: disable=too-many-arguments
         '''Returns the symbol for a user-defined type. If required, the
-        required import statements will all be generated.
+        source ContainerSymbols will be created too.
 
-        :param str module_name: the name of the module from which the \
+        :param module_name: the name of the module from which the
             user-defined type must be imported.
-        :param str user_type: the name of the user-defined type.
-        :param str name: the name of the variable to be used in the Reference.
-        :param Optional[str] tag: tag to use for the variable, defaults to \
-            the name
+        :param user_type: the name of the user-defined type.
+        :param name: the name of the variable to be used in the Reference.
+        :param tag: tag to use for the variable, defaults to the name
 
         :return: the symbol that is used in the reference
-        :rtype: :py:class:`psyclone.psyir.symbols.Symbol`
 
         '''
         if not tag:
@@ -119,12 +119,18 @@ def get_user_type(self, module_name, user_type, name, tag=None):
             pass
 
         # The symbol does not exist already. So we potentially need to
-        # create the import statement for the type:
+        # create the ContainerSymbol for the import for the type:
         try:
             # Check if the module is already declared:
             module = self._symtab.lookup(module_name)
-            # Get the symbol table in which the module is declared:
-            mod_sym_tab = module.find_symbol_table(self._kern)
+            # Get the symbol table in which the module is declared. Check
+            # the current table first:
+            if module in self._symtab.symbols:
+                mod_sym_tab = self._symtab
+            else:
+                # Otherwise, we have to search for the table.
+                mod_sym_tab = module.find_symbol_table(self._symtab.node)
+
         except KeyError:
             module = self._symtab.new_symbol(module_name,
                                              symbol_type=ContainerSymbol)

src/psyclone/domain/lfric/lfric_kern.py

@@ -60,9 +60,9 @@
 from psyclone.psyir.nodes import (
     Loop, Literal, Reference, KernelSchedule, Container, Routine)
 from psyclone.psyir.symbols import (
-    DataSymbol, GenericInterfaceSymbol, ScalarType, ArrayType, DataTypeSymbol,
-    UnresolvedType, ContainerSymbol, INTEGER_TYPE, UnresolvedInterface,
-    UnsupportedFortranType)
+    ArgumentInterface, ArrayType, ContainerSymbol, DataSymbol, DataTypeSymbol,
+    GenericInterfaceSymbol, ImportInterface, ScalarType, UnresolvedType,
+    INTEGER_TYPE, UnsupportedFortranType)
 
 
 class LFRicKern(CodedKern):
@@ -334,13 +334,14 @@ def _setup(self,
                 f"Evaluator shape(s) {list(invalid_shapes)} is/are not "
                 f"recognised. Must be one of {const.VALID_EVALUATOR_SHAPES}.")
 
-        # If this kernel operates into the halo then it must be passed a
+        # If this kernel operates into the halo and distributed-memory is
+        # enabled then it must be passed a
         # halo depth. This is currently restricted to being either a simple
         # variable name or a literal value.
         freader = FortranReader()
         invoke_schedule = self.ancestor(InvokeSchedule)
         symtab = invoke_schedule.symbol_table if invoke_schedule else None
-        if "halo" in ktype.iterates_over:
+        if "halo" in ktype.iterates_over and Config.get().distributed_memory:
             self._halo_depth = freader.psyir_from_expression(
                 args[-1].text.lower(), symbol_table=symtab)
             if isinstance(self._halo_depth, Reference):
@@ -350,8 +351,10 @@ def _setup(self,
                 if not hasattr(sym, "datatype"):
                     self._halo_depth.symbol.specialise(
                         DataSymbol,
-                        datatype=LFRicTypes("LFRicIntegerScalarDataType")())
-
+                        datatype=LFRicTypes("LFRicIntegerScalarDataType")(),
+                        interface=ArgumentInterface())
+                    if symtab:
+                        symtab.append_argument(self._halo_depth.symbol)
         # Check that compute-annexed-dofs is False if the kernel must operate
         # only on owned entities.
         api_conf = Config.get().api_conf()
@@ -401,19 +404,21 @@ def _setup(self,
 
             qr_arg = args[idx]
             quad_map = const.QUADRATURE_TYPE_MAP[shape]
-
             # Use the InvokeSchedule or Stub symbol_table that we obtained
             # earlier to create a unique symbol name
             if qr_arg.varname:
                 # If we have a name for the qr argument, we are dealing with
                 # an Invoke
+                mod_name = quad_map["module"]
+                mod_sym = symtab.find_or_create(
+                    mod_name, symbol_type=ContainerSymbol)
                 tag = "AlgArgs_" + qr_arg.text
                 qr_sym = symtab.find_or_create(
                     qr_arg.varname, tag=tag, symbol_type=DataSymbol,
                     datatype=symtab.find_or_create(
                         quad_map["type"], symbol_type=DataTypeSymbol,
                         datatype=UnresolvedType(),
-                        interface=UnresolvedInterface())
+                        interface=ImportInterface(mod_sym))
                 )
                 qr_name = qr_sym.name
             else:
@@ -758,7 +763,8 @@ def gen_stub(self) -> Container:
         stub_module = Container(self._base_name+"_mod")
 
         # Create the subroutine
-        stub_routine = Routine.create(self._base_name+"_code")
+        stub_routine = Routine.create(self._base_name+"_code",
+                                      symbol_table=LFRicSymbolTable())
         stub_module.addchild(stub_routine)
         self._stub_symbol_table = stub_routine.symbol_table
 
@@ -844,7 +850,8 @@ class creates the PSyIR schedule(s) on first invocation which is then
             for name in names:
                 rt_psyir = container.find_routine_psyir(name,
                                                         allow_private=True)
-                routines.append(rt_psyir)
+                if rt_psyir:
+                    routines.append(rt_psyir)
 
         # Otherwise, get the PSyIR Kernel Schedule(s) from the original
         # parse tree.

src/psyclone/domain/lfric/lfric_loop.py

@@ -53,7 +53,7 @@
     Call, BinaryOperation, ArrayOfStructuresReference, Directive, DataNode,
     Node, Routine)
 from psyclone.psyir.symbols import (
-    DataSymbol, INTEGER_TYPE, UnresolvedType, UnresolvedInterface)
+    AutomaticInterface, DataSymbol, INTEGER_TYPE, UnresolvedType)
 
 
 class LFRicLoop(PSyLoop):
@@ -951,7 +951,7 @@ def gen_mark_halos_clean_dirty(self):
                                 field.proxy_name,
                                 symbol_type=DataSymbol,
                                 datatype=UnresolvedType(),
-                                interface=UnresolvedInterface())
+                                interface=AutomaticInterface())
             # Avoid circular import
             # pylint: disable=import-outside-toplevel
             from psyclone.lfric import HaloWriteAccess

src/psyclone/domain/lfric/lfric_psy.py

@@ -43,11 +43,9 @@
 
 
 from psyclone.configuration import Config
-from psyclone.domain.lfric import (LFRicConstants, LFRicSymbolTable,
-                                   LFRicInvokes)
+from psyclone.domain.lfric import LFRicSymbolTable, LFRicInvokes
 from psyclone.psyGen import PSy
 from psyclone.psyir.nodes import ScopingNode
-from psyclone.psyir.symbols import ContainerSymbol
 
 
 class LFRicPSy(PSy):
@@ -67,14 +65,7 @@ def __init__(self, invoke_info):
         # TODO #1954: Remove the protected access using a factory
         ScopingNode._symbol_table_class = LFRicSymbolTable
         Config.get().api = "lfric"
-        PSy.__init__(self, invoke_info)
-
-        # Add a wildcard "constants_mod" import at the Container level
-        # since kinds are often disconnected.
-        const = LFRicConstants()
-        const_mod = const.UTILITIES_MOD_MAP["constants"]["module"]
-        self.container.symbol_table.add(
-            ContainerSymbol(const_mod, wildcard_import=True))
+        super().__init__(invoke_info)
 
         # Then initialise the Invokes
         self._invokes = LFRicInvokes(invoke_info.calls, self)