add GeneratorContext.scope_map to avoid need to pass around parent_node_id

Author: dwrensha

capnpc/src/codegen.rs

@@ -111,7 +111,7 @@ impl CodeGenerationCommand {
                 Line("// DO NOT EDIT.".to_string()),
                 Line(format!("// source: {}", requested_file.get_filename()?)),
                 BlankLine,
-                generate_node(&gen, id, &root_name, None)?,
+                generate_node(&gen, id, &root_name)?,
             ]);
 
             let text = stringify(&lines);
@@ -160,6 +160,11 @@ pub struct GeneratorContext<'a> {
     pub request: schema_capnp::code_generator_request::Reader<'a>,
     pub node_map: collections::hash_map::HashMap<u64, schema_capnp::node::Reader<'a>>,
     pub scope_map: collections::hash_map::HashMap<u64, Vec<String>>,
+
+    /// Map from node ID to the node ID of its parent scope. This is equal to node.scope_id
+    /// for all nodes except for autogenerated interface Param and Result structs;
+    /// those have scope_id set to 0. See the comment on paramStructType in schema.capnp.
+    pub node_parents: collections::hash_map::HashMap<u64, u64>,
 }
 
 impl<'a> GeneratorContext<'a> {
@@ -180,10 +185,28 @@ impl<'a> GeneratorContext<'a> {
             request: message.get_root()?,
             node_map: collections::hash_map::HashMap::<u64, schema_capnp::node::Reader<'a>>::new(),
             scope_map: collections::hash_map::HashMap::<u64, Vec<String>>::new(),
+            node_parents: collections::hash_map::HashMap::new(),
         };
 
         for node in gen.request.get_nodes()? {
             gen.node_map.insert(node.get_id(), node);
+            gen.node_parents.insert(node.get_id(), node.get_scope_id());
+        }
+
+        // Fix up "anonymous" method params and results scopes.
+        for node in gen.request.get_nodes()? {
+            if let Ok(schema_capnp::node::Interface(interface_reader)) = node.which() {
+                for method in interface_reader.get_methods()? {
+                    let param_struct_type = method.get_param_struct_type();
+                    if gen.node_parents.get(&param_struct_type) == Some(&0) {
+                        gen.node_parents.insert(param_struct_type, node.get_id());
+                    }
+                    let result_struct_type = method.get_result_struct_type();
+                    if gen.node_parents.get(&result_struct_type) == Some(&0) {
+                        gen.node_parents.insert(result_struct_type, node.get_id());
+                    }
+                }
+            }
         }
 
         for requested_file in gen.request.get_requested_files()? {
@@ -291,6 +314,7 @@ impl<'a> GeneratorContext<'a> {
                 }
             }
         }
+
         Ok(())
     }
 
@@ -1527,9 +1551,6 @@ fn generate_node(
     gen: &GeneratorContext,
     node_id: u64,
     node_name: &str,
-    // Ugh. We need this to deal with the anonymous Params and Results
-    // structs that go with RPC methods.
-    parent_node_id: Option<u64>,
 ) -> ::capnp::Result<FormattedText> {
     use crate::schema_capnp::*;
 
@@ -1540,15 +1561,15 @@ fn generate_node(
     let nested_nodes = node_reader.get_nested_nodes()?;
     for nested_node in nested_nodes {
         let id = nested_node.get_id();
-        nested_output.push(generate_node(gen, id, gen.get_last_name(id)?, None)?);
+        nested_output.push(generate_node(gen, id, gen.get_last_name(id)?)?);
     }
 
     match node_reader.which()? {
         node::File(()) => {
             output.push(Branch(nested_output));
         }
         node::Struct(struct_reader) => {
-            let params = node_reader.parameters_texts(gen, parent_node_id);
+            let params = node_reader.parameters_texts(gen);
             output.push(BlankLine);
 
             let is_generic = node_reader.get_is_generic();
@@ -1634,7 +1655,7 @@ fn generate_node(
 
                 if let Ok(field::Group(group)) = field.which() {
                     let id = group.get_type_id();
-                    let text = generate_node(gen, id, gen.get_last_name(id)?, None)?;
+                    let text = generate_node(gen, id, gen.get_last_name(id)?)?;
                     nested_output.push(text);
                 }
             }
@@ -1968,7 +1989,7 @@ fn generate_node(
         }
 
         node::Interface(interface) => {
-            let params = node_reader.parameters_texts(gen, parent_node_id);
+            let params = node_reader.parameters_texts(gen);
             output.push(BlankLine);
 
             let is_generic = node_reader.get_is_generic();
@@ -2002,7 +2023,7 @@ fn generate_node(
                 let (param_scopes, params_ty_params) = if param_node.get_scope_id() == 0 {
                     let mut names = names.clone();
                     let local_name = module_name(&format!("{name}Params"));
-                    nested_output.push(generate_node(gen, param_id, &local_name, Some(node_id))?);
+                    nested_output.push(generate_node(gen, param_id, &local_name)?);
                     names.push(local_name);
                     (names, params.params.clone())
                 } else {
@@ -2025,7 +2046,7 @@ fn generate_node(
                 let (result_scopes, results_ty_params) = if result_node.get_scope_id() == 0 {
                     let mut names = names.clone();
                     let local_name = module_name(&format!("{name}Results"));
-                    nested_output.push(generate_node(gen, result_id, &local_name, Some(node_id))?);
+                    nested_output.push(generate_node(gen, result_id, &local_name)?);
                     names.push(local_name);
                     (names, params.params.clone())
                 } else {

capnpc/src/codegen_types.rs

@@ -88,11 +88,7 @@ pub struct TypeParameterTexts {
 
 // this is a collection of helpers acting on a "Node" (most of them are Type definitions)
 pub trait RustNodeInfo {
-    fn parameters_texts(
-        &self,
-        gen: &crate::codegen::GeneratorContext,
-        parent_node_id: Option<u64>,
-    ) -> TypeParameterTexts;
+    fn parameters_texts(&self, gen: &crate::codegen::GeneratorContext) -> TypeParameterTexts;
 }
 
 // this is a collection of helpers acting on a "Type" (someplace where a Type is used, not defined)
@@ -104,13 +100,9 @@ pub trait RustTypeInfo {
 }
 
 impl<'a> RustNodeInfo for node::Reader<'a> {
-    fn parameters_texts(
-        &self,
-        gen: &crate::codegen::GeneratorContext,
-        parent_node_id: Option<u64>,
-    ) -> TypeParameterTexts {
+    fn parameters_texts(&self, gen: &crate::codegen::GeneratorContext) -> TypeParameterTexts {
         if self.get_is_generic() {
-            let params = get_type_parameters(gen, self.get_id(), parent_node_id);
+            let params = get_type_parameters(gen, self.get_id());
             let type_parameters = params
                 .iter()
                 .map(|param| param.to_string())
@@ -431,28 +423,21 @@ pub fn do_branding(
         arguments = arguments))
 }
 
-pub fn get_type_parameters(
-    gen: &GeneratorContext,
-    node_id: u64,
-    mut parent_scope_id: Option<u64>,
-) -> Vec<String> {
+pub fn get_type_parameters(gen: &GeneratorContext, node_id: u64) -> Vec<String> {
     let mut current_node_id = node_id;
     let mut accumulator: Vec<Vec<String>> = Vec::new();
     loop {
-        let Some(current_node) = gen.node_map.get(&current_node_id) else {
-            break
-        };
+        let current_node = gen.node_map[&current_node_id];
         let mut params = Vec::new();
         for param in current_node.get_parameters().unwrap() {
             params.push(param.get_name().unwrap().to_string());
         }
 
         accumulator.push(params);
-        current_node_id = current_node.get_scope_id();
-        if let (0, Some(id)) = (current_node_id, parent_scope_id) {
-            current_node_id = id
-        }
-        parent_scope_id = None; // Only consider on the first time around.
+        current_node_id = match gen.node_parents.get(&current_node_id).copied() {
+            Some(0) | None => break,
+            Some(id) => id,
+        };
     }
 
     accumulator.reverse();