Update verify to check for model vs no model

The current verify does not check that the RPCs are marked as modelled
or not consistently between the verify and the types table.

Change it so that it does.

Author: jamillambert

verify/src/main.rs

@@ -92,6 +92,13 @@ fn verify_version(version: Version, test_output: Option<&String>, quiet: bool) -
         Err(e) => { if !quiet { eprintln!("{}", e); } close(false, quiet); failures += 1; }
     }
 
+    let msg = "Checking that 'Returns' column matches model requirements";
+    check(msg, quiet);
+    match verify_returns_method(version) {
+        Ok(()) => close(true, quiet),
+        Err(e) => { if !quiet { eprintln!("{}", e); } close(false, quiet); failures += 1; }
+    }
+
     if failures > 0 {
         return Err(anyhow::anyhow!("verification failed ({} check(s) failed)", failures));
     }
@@ -204,6 +211,45 @@ fn output_method(method: &Method) -> String {
     }
 }
 
+/// Verifies that the 'Returns' table entry ("version" vs "version + model") matches the
+/// method definition in verfiy.
+fn verify_returns_method(version: Version) -> Result<()> {
+    use verify::versioned::{returns_map, ReturnsDoc};
+
+    let map = returns_map(version)?;
+    let mut failures = 0;
+
+    for (name, entry) in map.into_iter() {
+        let Some(method) = Method::from_name(version, &name) else { continue };
+
+        match entry {
+            ReturnsDoc::Version => {
+                if method.requires_model {
+                    eprintln!(
+                        "'Returns' says 'version' but method is marked as requiring a model: {}",
+                        output_method(method)
+                    );
+                    failures += 1;
+                }
+            }
+            ReturnsDoc::VersionPlusModel => {
+                if !method.requires_model {
+                    eprintln!(
+                        "'Returns' says 'version + model' but method is marked as not requiring a model: {}",
+                        output_method(method)
+                    );
+                    failures += 1;
+                }
+            }
+            ReturnsDoc::Other(_) => {}
+        }
+    }
+
+    if failures > 0 { return Err(anyhow::anyhow!("returns/model verification failed ({} issue(s))", failures)); }
+
+    Ok(())
+}
+
 // Use a module because a file with this name is confusing.
 mod check_integration_test_crate {
     //! Things related to parsing the `integration_test` crate.

verify/src/versioned.rs

@@ -96,6 +96,47 @@ pub fn type_exists(version: Version, method_name: &str) -> Result<bool> {
     Ok(false)
 }
 
+/// The value from the `Returns` column in the versioned rustdoc table.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ReturnsDoc {
+    /// The table says the method is implemented for this version and no model is required.
+    Version,
+    /// The table says the method is implemented for this version and a model is required.
+    VersionPlusModel,
+    /// Any other entry (omitted, TODO, returns nothing/numeric/bool/string, etc.).
+    Other(String),
+}
+
+/// Parses the version-specific module rustdocs and returns a mapping to `ReturnsDoc`.
+pub fn returns_map(version: Version) -> Result<std::collections::BTreeMap<String, ReturnsDoc>> {
+    use std::collections::BTreeMap;
+
+    let path = path(version);
+    let file = File::open(&path)
+        .with_context(|| format!("Failed to grep rustdocs in {}", path.display()))?;
+    let reader = io::BufReader::new(file);
+
+    let re = Regex::new(r"//! \| ([a-z]+) .* \| ([a-z +]+?) \|.*\|").unwrap();
+
+    let mut map: BTreeMap<String, ReturnsDoc> = BTreeMap::new();
+    for line in reader.lines() {
+        let line = line?;
+        if let Some(caps) = re.captures(&line) {
+            let method_name = caps.get(1).unwrap().as_str();
+            let returns_column = caps.get(2).unwrap().as_str().trim();
+
+            let entry = match returns_column {
+                "version" => ReturnsDoc::Version,
+                "version + model" => ReturnsDoc::VersionPlusModel,
+                other => ReturnsDoc::Other(other.to_string()),
+            };
+            map.insert(method_name.to_string(), entry);
+        }
+    }
+
+    Ok(map)
+}
+
 /// A list item from rustdocs (e.g. in in `types/src/v17/mod.rs`).
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 // TODO: This name is overloaded (`method::Method`).