tools/docgen: simplify comment_and_requirement

Simplify the logic by handling the case where `prev` is a comment that
may/may not have a feature req previous to the comment up-front.

Then, when we're looking at a `prev` that wasn't a comment, but was
`kind == expression_statement` we can recurse with `prev_prev` to handle
it as a comment that may/may not have a feature req previous to itself.

Lastly, if we know we don't have a comment and we don't have an
expression statement, try to see if we have a bare feature requirement.
We know cbindgen won't make a comment ahead of these and so can
disregard `prev_prev` for this case.

Author: cpu

tools/src/bin/docgen/main.rs

@@ -202,31 +202,33 @@ fn comment_and_requirement(
     src: &[u8],
 ) -> Result<(Option<Comment>, Option<Feature>), Box<dyn Error>> {
     let prev_prev = prev.prev_named_sibling();
-    let mut maybe_comment = Comment::new(prev, src).ok();
 
-    // If node wasn't a comment, see if it was an expression_statement
-    // that itself was preceded by a comment.  This skips over
-    // expression-like preprocessor attributes on function decls.
-    if let (None, "expression_statement", Some(prev_prev)) =
-        (&maybe_comment, prev.kind(), prev_prev)
-    {
-        maybe_comment = Comment::new(prev_prev, src).ok();
+    // In the simple case, `prev` is a comment and `prev_prev` may
+    // be a feature requirement.
+    if let Ok(comment) = Comment::new(prev, src) {
+        let feature = match prev_prev {
+            Some(prev_prev) => Feature::new(prev_prev, src).ok(),
+            None => None,
+        };
+        return Ok((Some(comment), feature));
     }
 
-    // If prev wasn't a comment, see if it was a feature requirement.
-    if maybe_comment.is_none() {
-        return Ok(match Feature::new(prev, src).ok() {
-            Some(feat_req) => (None, Some(feat_req)),
-            None => (None, None),
-        });
+    // If `prev` wasn't a comment, see if it was an expression_statement
+    // that itself was preceded by a comment.  This skips over
+    // expression-like preprocessor attributes on function decls.
+    if prev.kind() == "expression_statement" {
+        return match prev_prev {
+            Some(prev_prev) => comment_and_requirement(prev_prev, src),
+            None => Ok((None, None)),
+        };
     }
 
-    // Otherwise, check the prev of the comment for a feature requirement
-    let Some(prev_prev) = prev_prev else {
-        return Ok((maybe_comment, None));
-    };
-
-    Ok((maybe_comment, Feature::new(prev_prev, src).ok()))
+    // If `prev` wasn't a comment, or an expression_statement preceded by a comment,
+    // then it's either a bare feature requirement or we have no metadata to return.
+    Ok(match Feature::new(prev, src).ok() {
+        Some(feat_req) => (None, Some(feat_req)),
+        None => (None, None),
+    })
 }
 
 #[derive(Debug, Default, Serialize)]