yeast-schema: Track leaf node kinds

The `rules!` macro needs this information to decide whether a bare
output node should inherit the value of the matched input node.

Author: tausbn

shared/yeast-schema/src/node_types_yaml.rs

@@ -361,6 +361,7 @@ fn apply_yaml_to_schema(yaml: &YamlNodeTypes, schema: &mut crate::schema::Schema
     // Register named node kinds and their fields
     for (name, fields_opt) in &yaml.named {
         schema.register_kind(name);
+        schema.set_leaf_kind(name, fields_opt.as_ref().map_or(true, BTreeMap::is_empty));
         register_fields(schema, fields_opt.as_ref());
     }
     for supertype in yaml.supertypes.values() {
@@ -810,6 +811,36 @@ unnamed:
         assert_eq!(end["named"], false);
     }
 
+    #[test]
+    fn test_leaf_kinds_are_recorded_in_schema() {
+        let schema = schema_from_yaml(
+            r#"
+named:
+  identifier:
+  empty_fields: {}
+  call:
+    callee: identifier
+"#,
+        )
+        .unwrap();
+
+        assert!(schema.is_leaf_kind("identifier"));
+        assert!(schema.is_leaf_kind("empty_fields"));
+        assert!(!schema.is_leaf_kind("call"));
+
+        let mut schema = schema;
+        extend_schema_from_yaml(
+            &mut schema,
+            r#"
+named:
+  identifier:
+    child: empty_fields
+"#,
+        )
+        .unwrap();
+        assert!(!schema.is_leaf_kind("identifier"));
+    }
+
     #[test]
     fn test_explicit_unnamed_disambiguation() {
         let yaml = r#"

shared/yeast-schema/src/schema.rs

@@ -44,6 +44,7 @@ pub struct Schema {
     field_types: BTreeMap<(String, FieldId), Vec<NodeType>>,
     field_cardinalities: BTreeMap<(String, FieldId), FieldCardinality>,
     supertypes: BTreeMap<String, Vec<NodeType>>,
+    leaf_kinds: BTreeSet<String>,
     /// Per-node-kind declared field order (named fields only), as written in
     /// the source node-types YAML. Field ids are not a stable ordering key
     /// across front-ends, so this preserves the authored order for
@@ -70,6 +71,7 @@ impl Schema {
             field_types: BTreeMap::new(),
             field_cardinalities: BTreeMap::new(),
             supertypes: BTreeMap::new(),
+            leaf_kinds: BTreeSet::new(),
             field_order: BTreeMap::new(),
         }
     }
@@ -347,6 +349,20 @@ impl Schema {
         self.supertypes.contains_key(kind)
     }
 
+    pub(crate) fn set_leaf_kind(&mut self, kind: &str, is_leaf: bool) {
+        if is_leaf {
+            self.leaf_kinds.insert(kind.to_string());
+        } else {
+            // TODO: This is only needed for schema extensions. Consider removing
+            // extension support, after which non-leaf kinds can simply be ignored.
+            self.leaf_kinds.remove(kind);
+        }
+    }
+
+    pub fn is_leaf_kind(&self, kind: &str) -> bool {
+        self.leaf_kinds.contains(kind)
+    }
+
     fn allows_node(
         &self,
         node_type: &NodeType,