feat(ops): abstract op groups with TOML-driven concrete instances

crates/rpl_config/src/lib.rs

@@ -2,10 +2,13 @@ use std::path::{Path, PathBuf};
 
 use serde::Deserialize;
 
+mod ops;
 mod patterns;
 mod run;
 mod util;
 
+pub use ops::RawOpInstance;
+
 #[derive(Debug, thiserror::Error)]
 pub enum ConfigError {
     #[error("failed to read {path}: {source}")]
@@ -46,9 +49,11 @@ pub enum ConfigError {
 }
 
 #[derive(Debug, Deserialize)]
-struct RplConfig {
-    run: Option<run::RunConfig>,
-    patterns: Option<patterns::PatternsConfig>,
+pub struct RplConfig {
+    pub(crate) run: Option<run::RunConfig>,
+    pub(crate) patterns: Option<patterns::PatternsConfig>,
+    #[serde(default)]
+    pub ops: std::collections::HashMap<String, Vec<RawOpInstance>>,
 }
 
 #[derive(Debug)]
@@ -72,3 +77,22 @@ pub fn load_config(manifest_path: Option<&Path>, selected_groups: &[String]) ->
         inline_mir,
     })
 }
+
+/// Load the raw op-group instances from `rpl.toml` in the current directory
+/// (or adjacent to `manifest_path` if given).
+///
+/// Returns an empty map when no `rpl.toml` exists or when the file contains
+/// no `[ops]` table.  Errors during config file reading are surfaced as
+/// `Err(ConfigError)`.
+pub fn load_raw_ops(
+    manifest_path: Option<&Path>,
+) -> Result<std::collections::HashMap<String, Vec<RawOpInstance>>, ConfigError> {
+    let base_dir = util::resolve_base_dir(manifest_path)?;
+    let config_path = base_dir.join("rpl.toml");
+    if config_path.exists() {
+        let config = util::read_config(&config_path)?;
+        Ok(config.ops)
+    } else {
+        Ok(std::collections::HashMap::new())
+    }
+}

crates/rpl_config/src/ops.rs

@@ -0,0 +1,57 @@
+use std::collections::BTreeMap;
+
+use serde::Deserialize;
+
+/// One instance of an op-group as declared in `rpl.toml`.
+///
+/// All values are stored as raw strings; substitution happens later in `rpl_context`.
+#[derive(Debug, Clone)]
+pub struct RawOpInstance {
+    /// Existential type-placeholder names declared via `type = [...]`.
+    pub free: Vec<String>,
+    /// Every other key/value pair (op-level meta-var bindings + op-name bindings).
+    pub bindings: BTreeMap<String, String>,
+}
+
+impl<'de> Deserialize<'de> for RawOpInstance {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let mut raw: BTreeMap<String, toml::Value> = BTreeMap::deserialize(deserializer)?;
+
+        let free = match raw.remove("type") {
+            None => Vec::new(),
+            Some(toml::Value::Array(arr)) => arr
+                .into_iter()
+                .map(|v| match v {
+                    toml::Value::String(s) => Ok(s),
+                    other => Err(serde::de::Error::custom(format!(
+                        "ops 'type' entries must be strings, got {other:?}"
+                    ))),
+                })
+                .collect::<Result<Vec<_>, D::Error>>()?,
+            Some(other) => {
+                return Err(serde::de::Error::custom(format!(
+                    "ops 'type' must be an array of strings, got {other:?}"
+                )));
+            },
+        };
+
+        let mut bindings = BTreeMap::new();
+        for (k, v) in raw {
+            match v {
+                toml::Value::String(s) => {
+                    bindings.insert(k, s);
+                },
+                other => {
+                    return Err(serde::de::Error::custom(format!(
+                        "ops binding '{k}' must be a string, got {other:?}"
+                    )));
+                },
+            }
+        }
+
+        Ok(RawOpInstance { free, bindings })
+    }
+}

crates/rpl_config/src/patterns.rs

@@ -149,6 +149,19 @@ pub(crate) fn resolve_patterns_env(
         None => return Ok(None),
     };
 
+    // An empty paths vector here can arise when `rpl.toml` exists but contains
+    // no `[patterns]` table (e.g. only `[run]` or `[[ops.<group>]]`) and the
+    // caller did not pass `--patterns`.  In that case `resolve_patterns` takes
+    // the vacuous-true branch of `selected_groups.iter().all(is_remote_spec)`
+    // and returns `Some(ResolvedPatterns { paths: vec![] })`.  Joining zero
+    // paths yields the empty string, which would propagate to the child
+    // process as `RPL_PATS=""` and trip
+    // `rpl_meta::cli E100: Cannot locate RPL pattern file ""`.  Map empty to
+    // `None` here so the child falls back to the built-in pattern set.
+    if resolved.paths.is_empty() {
+        return Ok(None);
+    }
+
     let mut entries = Vec::with_capacity(resolved.paths.len());
     for path in resolved.paths {
         if path.to_str().is_none() {

crates/rpl_config/tests/ops_loading.rs

@@ -0,0 +1,39 @@
+use rpl_config::{RawOpInstance, RplConfig};
+
+const TOML: &str = r#"
+[[patterns.local]]
+name = "g"
+path = ["patterns/foo.rpl"]
+
+[[ops.sync]]
+type = ["$1"]
+T = "std::sync::Mutex<$1>"
+U = "std::sync::MutexGuard<$1>"
+lock = "$T::lock"
+unlock = "$U::drop"
+
+[[ops.sync]]
+type = ["$1"]
+T = "parking_lot::Mutex<$1>"
+U = "parking_lot::MutexGuard<$1>"
+lock = "$T::lock"
+unlock = "$U::drop"
+"#;
+
+#[test]
+fn loads_two_sync_instances() {
+    let cfg: RplConfig = toml::from_str(TOML).expect("parse");
+    let sync_instances = cfg.ops.get("sync").expect("sync key present");
+    assert_eq!(sync_instances.len(), 2);
+    let i0: &RawOpInstance = &sync_instances[0];
+    assert_eq!(i0.free, vec!["$1".to_string()]);
+    assert_eq!(i0.bindings.get("T").unwrap(), "std::sync::Mutex<$1>");
+    assert_eq!(i0.bindings.get("lock").unwrap(), "$T::lock");
+}
+
+#[test]
+fn type_key_is_not_in_bindings() {
+    let cfg: RplConfig = toml::from_str(TOML).expect("parse");
+    let i0 = &cfg.ops["sync"][0];
+    assert!(!i0.bindings.contains_key("type"));
+}

crates/rpl_context/Cargo.toml

@@ -10,11 +10,15 @@ edition.workspace = true
 [dependencies]
 derive_more.workspace = true
 pest_typed.workspace = true
+rpl_config.workspace = true
 rpl_meta.workspace = true
 rpl_parser.workspace = true
 rpl_constraints.workspace = true
 sync-arena.workspace = true
 
+[dev-dependencies]
+rpl_config.workspace = true
+
 [features]
 
 [package.metadata.rust-analyzer]

crates/rpl_context/src/context.rs

@@ -203,7 +203,7 @@ impl<'pcx> PatCtxt<'pcx> {
     ) {
         let pattern = self.new_pattern();
         // FIXME: process utils
-        let (utils, patts, diags) = collect_blocks(main);
+        let (utils, patts, ops, diags) = collect_blocks(main);
 
         let symbol_tables = &mctx.symbol_tables.get(id).unwrap();
         {
@@ -217,6 +217,22 @@ impl<'pcx> PatCtxt<'pcx> {
                 );
             });
         }
+        {
+            for ops_block in &ops {
+                let wf_errors = pattern.add_ops_block(with_path(mctx.get_active_path(), ops_block));
+                for err in &wf_errors {
+                    warn!("ops well-formedness: {}", err);
+                }
+            }
+            // R6: op-level meta-vars (declared in `ops { ... }`) must not leak
+            // into pattern-block bodies.  Implemented but previously never
+            // invoked — the rule was unenforced.  Surface violations as
+            // warnings here, alongside R1–R3.
+            let r6_errors = pat::check_r6_patt_vs_ops(&ops, &patts);
+            for err in &r6_errors {
+                warn!("ops well-formedness (R6): {}", err);
+            }
+        }
         {
             let patt_items = patts.iter().flat_map(|patt| patt.get_matched().3.iter_matched());
             let patt_symbol_tables = &symbol_tables.patt_symbol_tables;
@@ -237,6 +253,12 @@ impl<'pcx> PatCtxt<'pcx> {
             }
         }
 
+        // R4/R5 post-lowering use-site checks + referenced_op_groups population.
+        pattern.check_and_populate_op_refs();
+        for err in pattern.op_ref_errors() {
+            warn!("op-ref use-site: {}", err);
+        }
+
         let mut patterns = self.rpl_patterns.lock();
         debug_assert_eq!(patterns.next_index(), id);
         patterns.push(pattern);

crates/rpl_context/src/pat/mir/mod.rs

@@ -875,6 +875,11 @@ pub enum Operand<'pcx> {
     Move(Place<'pcx>),
     Constant(ConstOperand<'pcx>),
     FnPat(Symbol),
+    /// Reference to an operation `$group::$op` declared in the `ops` block.
+    OpRef {
+        group: Symbol,
+        op: Symbol,
+    },
 }
 
 impl<'pcx> Operand<'pcx> {
@@ -929,19 +934,25 @@ impl<'pcx> Operand<'pcx> {
     ) -> Self {
         let p = op.path;
         match op.inner.deref() {
-            Choice5::_0(copy_) => Self::from_copy(WithPath::new(p, copy_.get_matched().1), pcx, fn_sym_tab),
-            Choice5::_1(move_) => Self::from_move(WithPath::new(p, move_.get_matched().1), pcx, fn_sym_tab),
-            Choice5::_2(type_path) => Self::Constant(ConstOperand::from_type_path(
+            Choice6::_0(copy_) => Self::from_copy(WithPath::new(p, copy_.get_matched().1), pcx, fn_sym_tab),
+            Choice6::_1(move_) => Self::from_move(WithPath::new(p, move_.get_matched().1), pcx, fn_sym_tab),
+            Choice6::_2(type_path) => Self::Constant(ConstOperand::from_type_path(
                 WithPath::new(p, type_path),
                 pcx,
                 fn_sym_tab,
             )),
-            Choice5::_3(lang_item) => Self::Constant(ConstOperand::from_lang_item(
+            Choice6::_3(lang_item) => Self::Constant(ConstOperand::from_lang_item(
                 WithPath::new(p, lang_item),
                 pcx,
                 fn_sym_tab,
             )),
-            Choice5::_4(meta_var) => Self::from_meta_var(meta_var),
+            Choice6::_4(op_ref) => {
+                let (group_meta, op_meta) = op_ref.MetaVariable();
+                let group = Symbol::intern(group_meta.span.as_str().trim_start_matches('$'));
+                let op = Symbol::intern(op_meta.span.as_str().trim_start_matches('$'));
+                Self::OpRef { group, op }
+            },
+            Choice6::_5(meta_var) => Self::from_meta_var(meta_var),
         }
     }
 }
@@ -1569,3 +1580,74 @@ impl BasicBlockData<'_> {
 pub(crate) fn with_path<T>(path: &'_ std::path::Path, inner: T) -> WithPath<'_, T> {
     WithPath { path, inner }
 }
+
+#[cfg(test)]
+mod tests {
+    use rustc_span::Symbol;
+
+    use super::Operand;
+
+    #[test]
+    fn op_ref_constructs_and_matches() {
+        rustc_span::create_session_if_not_set_then(rustc_span::edition::LATEST_STABLE_EDITION, |_| {
+            let group = Symbol::intern("sync");
+            let op = Symbol::intern("lock");
+            let operand: Operand<'_> = Operand::OpRef { group, op };
+            match operand {
+                Operand::OpRef { group: g, op: o } => {
+                    assert_eq!(g.as_str(), "sync");
+                    assert_eq!(o.as_str(), "lock");
+                },
+                _ => panic!("expected OpRef variant"),
+            }
+        });
+    }
+
+    /// Verify that `Operand::from_fn_op` strips the leading `$` when lowering an
+    /// `OpRef` (`$group::$op`) from the parser, so the stored symbols are bare
+    /// and will match the keys used by `OpGroup.name` / Task 7's resolver lookup.
+    ///
+    /// This test uses the simplified extraction form (parse → access OpRef node →
+    /// apply the same `trim_start_matches('$')` as `from_fn_op` does) rather than
+    /// calling `from_fn_op` directly, because `from_fn_op` requires a `PatCtxt`
+    /// that cannot be constructed in a unit test.  The test would have FAILED
+    /// before the fix because `group_meta.span.as_str()` returned `"$sync"` and
+    /// `op_meta.span.as_str()` returned `"$lock"`.
+    #[test]
+    fn op_ref_lowers_with_bare_symbols() {
+        use pest_typed::TypedParser as _;
+        use rpl_parser::parser::{Grammar, pairs};
+
+        let parsed =
+            Grammar::try_parse::<pairs::MirFnOperand>("$sync::$lock").expect("$sync::$lock must parse as MirFnOperand");
+
+        // `MirFnOperand` is `Choice6`; variant `_4` is `OpRef`.
+        let op_ref = parsed
+            .OpRef()
+            .expect("$sync::$lock must lower to the OpRef variant of MirFnOperand");
+
+        let (group_meta, op_meta) = op_ref.MetaVariable();
+
+        // Replicate the exact logic from `from_fn_op`'s `Choice6::_4` arm.
+        let group_raw = group_meta.span.as_str();
+        let op_raw = op_meta.span.as_str();
+
+        // Before the fix both of these would be "$sync" / "$lock".
+        let group_bare = group_raw.trim_start_matches('$');
+        let op_bare = op_raw.trim_start_matches('$');
+
+        assert_eq!(group_bare, "sync", "group symbol must be bare (no $ prefix)");
+        assert_eq!(op_bare, "lock", "op symbol must be bare (no $ prefix)");
+
+        // Also assert the raw span really does start with `$`, confirming that
+        // the trim is necessary (i.e., the test would have caught the bug).
+        assert!(
+            group_raw.starts_with('$'),
+            "parser span must include the $ sigil; got {group_raw:?}"
+        );
+        assert!(
+            op_raw.starts_with('$'),
+            "parser span must include the $ sigil; got {op_raw:?}"
+        );
+    }
+}

crates/rpl_context/src/pat/mir/pretty.rs

@@ -211,6 +211,7 @@ impl Operand<'_> {
             Self::Move(place) => write!(f, "(move {place:?})"),
             Self::Constant(konst) => write!(f, "{konst:?}"),
             Self::FnPat(fn_pat) => write!(f, "${fn_pat}"),
+            Self::OpRef { group, op } => write!(f, "${group}::{op}"),
         }
     }
 }
@@ -223,6 +224,7 @@ impl fmt::Debug for Operand<'_> {
             Self::Move(place) => write!(f, "move {place:?}"),
             Self::Constant(konst) => write!(f, "const {konst:?}"),
             Self::FnPat(fn_pat) => write!(f, "const ${fn_pat}"),
+            Self::OpRef { group, op } => write!(f, "${group}::{op}"),
         }
     }
 }