codex: serialize symbolic parameter values

Author: saidctb

README.md

@@ -200,6 +200,8 @@ python -m x2py tests/data/fortran/general/basic_subroutine.f90 --parse --wrap-re
 ```
 
 This prints the wrappability status and blocker list for each input file.
+The JSON readiness payload keeps `wrappable` at file level and includes
+`unit_blockers` only for procedure/type/file units that own a blocker.
 
 ### Example 4: semantic IR JSON output
 
@@ -463,12 +465,18 @@ helpers parse variables, procedure arguments/results, and type fields, then
 push them into the active scope. Procedure execution bodies and internal
 subprograms are ignored for wrapper metadata; procedure-local interfaces are
 retained for callback typing.
-Parameter variables keep both `value` (best resolved value) and runtime
-`symbolic_value` (the original expression) when the parser has that information.
+Parameter variables keep both `value` and serialized `symbolic_value` when the
+parser has that information. `value` is literal/evaluated only; if an
+initializer cannot be evaluated safely, `value` is `None` and
+`symbolic_value` keeps the original expression.
 Module-level parameters used in procedure argument shapes remain symbolic in
 the signature while still being valid scoped references for readiness checks.
 
 The semantics layer consumes `FortranFile`/`FortranModule` objects and projects them into language-independent semantic IR (`SemanticModule`, `SemanticFunction`, `SemanticClass`, `SemanticType`). This keeps the semantic API model independent from parser internals, matching the project goal that parser output is a helper and the semantic interface/IR is the source of truth.
+For compiler-specific constants, use
+`collect_semantic_compile_time_requirements(parsed)` to extract unresolved
+values and pass a dictionary to semantic conversion via
+`compile_time_values`.
 
 For Fortran `use` imports, the parser stores each explicit imported symbol as a
 source/target mapping. A non-renamed `use iso_c_binding, only: c_int` maps

fortran_parser.md

@@ -67,6 +67,9 @@ and practical usage from terminal and Python.
 - Unsupported-pattern checks
 - Unknown argument declaration reporting
 - Final boolean readiness (`wrappable`)
+- Unit-scoped blocker records (`unit_blockers`) for wrapper-relevant
+  procedures and derived types, plus file-level blockers when diagnostics are
+  not owned by a single unit. The ready-to-wrap flag remains file-level only.
 
 ## 2) Public API surface
 
@@ -173,11 +176,12 @@ actual declarations.
 Most parser organization changes are structural, but behavior, model-schema,
 coverage, or fixture changes should be reflected in this reference.
 
-Parameter constants expose both `value` and runtime `symbolic_value` when
-available. `value` is the parser's best resolved expression after compile-time
-folding; `symbolic_value` preserves the original parameter initializer for
-validation, debugging, and downstream diagnostics without changing the legacy
-JSON fixture shape.
+Parameter constants expose both `value` and serialized `symbolic_value` when
+available. `value` is reserved for a literal/evaluated result after
+compile-time folding. If an initializer cannot be evaluated safely, such as
+`selected_real_kind(...)`, `value` is `None` and `symbolic_value` preserves the
+original initializer for validation, debugging, downstream diagnostics, and
+JSON consumers.
 
 Procedure-local parameters may be folded into argument shapes during procedure
 finalization. Module-level and `use`-associated parameters used in procedure
@@ -471,7 +475,8 @@ Expected behavior:
 
 - `parsed` is a `FortranFile` aggregate model with parsed units and symbols.
 - `readiness` includes counts, unsupported hits, unknown args, unresolved
-  imported derived-type/kind dependencies, and `wrappable`.
+  imported derived-type/kind dependencies, unit-scoped blockers, and the
+  file-level `wrappable` flag.
 
 ### 4.3 Structured argument specifications
 
@@ -955,3 +960,13 @@ Lower-level unit parsers are internal `FortranParser` methods.
 Semantic conversion lives in `semantics/fortran2ir.py`. It accepts parsed `FortranFile`
 (or selected `FortranModule`) structures and converts metadata into semantic IR
 consumed by the `.pyi` printer and later wrapper/runtime stages.
+
+The semantic converter also supports compile-time specialization for values the
+parser intentionally leaves symbolic. Use
+`collect_semantic_compile_time_requirements(parsed)` to list missing parameter
+or kind values, then pass a dictionary such as
+`{"selected_real_kind(12)": 8}` to
+`fortran_module_to_semantic_module(..., compile_time_values=...)` or
+`fortran_file_to_semantic_modules(..., compile_time_values=...)`. Existing
+semantic IR can be copied and specialized with
+`resolve_semantic_compile_time_values(module, {"n": 64})`.

fortran_parser/models.py

@@ -208,6 +208,7 @@ class FortranVariable:
     lbound: list[str | None] = field(default_factory=list)
     ubound: list[str | None] = field(default_factory=list)
     value: str | None = None
+    symbolic_value: str | None = None
     value_type: str = "unknown"
     is_parameter: bool = False
     dimensions: list[int] = field(default_factory=list)
@@ -217,14 +218,6 @@ def __post_init__(self) -> None:
         if self.kind is None:
             self.kind = ""
 
-    @property
-    def symbolic_value(self) -> str | None:
-        return getattr(self, "_symbolic_value", None)
-
-    @symbolic_value.setter
-    def symbolic_value(self, value: str | None) -> None:
-        self._symbolic_value = value
-
     @property
     def shape_info(self) -> list[dict[str, str | None]]:
         """Structured per-dimension shape metadata derived from `shape` tokens."""