Carry an enum's enumerators as the constants they already are

PRIK models a Fortran enumerator as a constant `SemanticVariable`, but the
accessibility and re-export inventory never looked at `module.enums`.
`_module_declared_names()` listed procedures, derived types, variables and
interfaces, so a plain `use` of a module declaring `enumerator :: red = 1`
carried nothing for `red`. `_declared_entity_kind()` likewise did not
recognize one, so `use colors, only : red` produced a re-export of kind
`unknown` -- which a contract may still publish while the module-variable
publication machinery, which attaches a second namespace only to a re-export
classified `variable`, passes it by.

Read enumerators wherever this layer reads a module's variables, as the
variables they become. `_module_declaration_dependencies()` reads their
initializers too, so an enumerator whose value names an imported constant
records that constant as a declaration dependency rather than a publication.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DN6oB7jC7wZXgFmuec4B7Q

Author: saidctb

CHANGELOG.md

@@ -7,6 +7,14 @@ release tags add a leading `v` to the package version.
 
 ## Unreleased
 
+- An enum's enumerators are carried by `use` like the constants they are. A
+  plain `use` of a module declaring `enumerator :: red = 1` carried nothing for
+  `red`, and naming it in an `only` list produced a re-export of unknown kind,
+  which the module-variable publication machinery does not attach. Enumerators
+  are now read as variables wherever this layer reads a module's declarations,
+  including as declaration dependencies when an enumerator's value names an
+  imported constant.
+
 - Following a name through an intermediate module applies that module's own
   accessibility. A module importing `x` and declaring `private :: x` no longer
   passes a route to the declaration behind it, and a module reaching two

prik/semantics/fortran2ir.py

@@ -1694,6 +1694,18 @@ def _module_interfaces(module: FortranModule):
             if str(getattr(interface, "declaring_scope_kind", "module")).casefold() == "module"
         )
 
+    @staticmethod
+    def _module_enumerators(module: FortranModule):
+        """Return every enumerator one module's enum blocks declare.
+
+        An enumerator is a named constant the module declares, and PRIK models
+        it as one: a ``use`` carries it exactly as it carries a ``parameter``,
+        so this layer reads it wherever it reads the module's variables.
+        """
+        return tuple(
+            enumerator for enum in getattr(module, "enums", ()) for enumerator in getattr(enum, "enumerators", ())
+        )
+
     @staticmethod
     def _module_declared_names(module: FortranModule) -> set[str]:
         """Return the names declared by one module for accessibility resolution.
@@ -1703,11 +1715,14 @@ def _module_declared_names(module: FortranModule) -> set[str]:
         it, which is what another module imports to write a ``procedure(...)``
         declaration. A specific inside an ordinary generic is not separately
         declared here, because the generic is the name that block introduces.
+        An enumerator is a declared constant, so it is named here as a variable
+        is, which is what it becomes.
         """
         return {
             *(procedure.name.casefold() for procedure in module.procedures),
             *(derived.name.casefold() for derived in module.derived_types),
             *(variable.name.casefold() for variable in getattr(module, "variables", ())),
+            *(enumerator.name.casefold() for enumerator in FortranToIRConverter._module_enumerators(module)),
             *(
                 interface.name.casefold()
                 for interface in FortranToIRConverter._module_interfaces(module)
@@ -1779,6 +1794,10 @@ def add_procedure(procedure: FortranProcedureSignature) -> None:
         for interface in module.interfaces:
             for procedure in interface.procedures:
                 add_procedure(procedure)
+        for enumerator in cls._module_enumerators(module):
+            declaration_text.extend(
+                str(value) for value in (enumerator.symbolic_value, enumerator.value) if value is not None
+            )
 
         return {
             identifier.casefold()
@@ -2009,6 +2028,10 @@ def _declared_entity_kind(declaring: FortranModule | None, source_name: str) ->
             return "derived_type"
         if any(variable.name.casefold() == key for variable in getattr(declaring, "variables", ())):
             return "variable"
+        # An enumerator is a named constant, which is the representation it
+        # already has downstream, so a route reaching one names a variable.
+        if any(enumerator.name.casefold() == key for enumerator in FortranToIRConverter._module_enumerators(declaring)):
+            return "variable"
         return "unknown"
 
     @staticmethod

tests/fortran/modules/semantics/test_reexport_accessibility.py

@@ -714,3 +714,61 @@ def test_an_ordinary_chain_still_reaches_the_declaring_module(tmp_path: Path):
         "a_mod",
         "x",
     )
+
+
+def test_an_enumerator_is_carried_and_classified_as_the_constant_it_is(tmp_path: Path):
+    """An enum names constants, which is how every later stage models them."""
+    modules = _project_modules(
+        tmp_path,
+        """\
+module colors_mod
+  implicit none
+  enum, bind(c)
+    enumerator :: red = 1
+    enumerator :: green = 2
+  end enum
+end module colors_mod
+
+module facade_mod
+  use colors_mod
+  implicit none
+end module facade_mod
+
+module named_facade_mod
+  use colors_mod, only : red
+  implicit none
+end module named_facade_mod
+""",
+    )
+
+    # A plain `use` carries every public name, enumerators included.
+    carried = {item.local_name: item.entity_kind for item in modules["facade_mod"].reexports}
+    assert carried == {"red": "variable", "green": "variable"}
+
+    named = {item.local_name: item for item in modules["named_facade_mod"].reexports}
+    assert named["red"].entity_kind == "variable"
+    assert (named["red"].origin_module, named["red"].source_name) == ("colors_mod", "red")
+
+
+def test_an_enumerator_initializer_is_a_declaration_dependency(tmp_path: Path):
+    """A name an enum's value reads expresses a declaration, so it is a dependency."""
+    modules = _project_modules(
+        tmp_path,
+        """\
+module constants_mod
+  implicit none
+  integer, parameter :: base = 10
+end module constants_mod
+
+module colors_mod
+  use constants_mod, only : base
+  implicit none
+  enum, bind(c)
+    enumerator :: red = base
+  end enum
+end module colors_mod
+""",
+    )
+
+    reexports = {item.local_name: item for item in modules["colors_mod"].reexports}
+    assert reexports["base"].declaration_dependency is True