2 files changed, 84 insertions, 29 deletions

diff --git a/cli/doc/mod.rs b/cli/doc/mod.rs
index b0f7cf60a..81cc2f9fb 100644
--- a/cli/doc/mod.rs
+++ b/cli/doc/mod.rs
@@ -24,43 +24,50 @@ pub use parser::DocParser;
 #[cfg(test)]
 mod tests;
 
-pub fn find_node_by_name_recursively(
+pub fn find_nodes_by_name_recursively(
   doc_nodes: Vec<DocNode>,
   name: String,
-) -> Option<DocNode> {
+) -> Vec<DocNode> {
   let mut parts = name.splitn(2, '.');
   let name = parts.next();
   let leftover = parts.next();
-  name?;
-  let node = find_node_by_name(doc_nodes, name.unwrap().to_string());
-  match node {
-    Some(node) => match node.kind {
-      DocNodeKind::Namespace => {
-        if let Some(leftover) = leftover {
-          find_node_by_name_recursively(
-            node.namespace_def.unwrap().elements,
-            leftover.to_string(),
-          )
-        } else {
-          Some(node)
-        }
-      }
-      _ => {
-        if leftover.is_none() {
-          Some(node)
-        } else {
-          None
-        }
+  if name.is_none() {
+    return doc_nodes;
+  }
+
+  let name = name.unwrap();
+  let doc_nodes = find_nodes_by_name(doc_nodes, name.to_string());
+
+  let mut found: Vec<DocNode> = vec![];
+  match leftover {
+    Some(leftover) => {
+      for node in doc_nodes {
+        let children = find_children_by_name(node, leftover.to_string());
+        found.extend(children);
       }
-    },
-    _ => None,
+      found
+    }
+    None => doc_nodes,
+  }
+}
+
+fn find_nodes_by_name(doc_nodes: Vec<DocNode>, name: String) -> Vec<DocNode> {
+  let mut found: Vec<DocNode> = vec![];
+  for node in doc_nodes {
+    if node.name == name {
+      found.push(node);
+    }
   }
+  found
 }
 
-fn find_node_by_name(doc_nodes: Vec<DocNode>, name: String) -> Option<DocNode> {
-  let node = doc_nodes.iter().find(|node| node.name == name);
-  match node {
-    Some(node) => Some(node.clone()),
-    None => None,
+fn find_children_by_name(node: DocNode, name: String) -> Vec<DocNode> {
+  match node.kind {
+    DocNodeKind::Namespace => {
+      let namespace_def = node.namespace_def.unwrap();
+      find_nodes_by_name_recursively(namespace_def.elements, name)
+    }
+    // TODO(#4516) handle class, interface etc...
+    _ => vec![],
   }
 }
diff --git a/cli/doc/tests.rs b/cli/doc/tests.rs
index f3355a520..8886f76be 100644
--- a/cli/doc/tests.rs
+++ b/cli/doc/tests.rs
@@ -1557,3 +1557,51 @@ export type numLit = 5;
   ]);
   assert_eq!(actual, expected_json);
 }
+
+#[tokio::test]
+async fn filter_nodes_by_name() {
+  use super::find_nodes_by_name_recursively;
+  let source_code = r#"
+export namespace Deno {
+  export class Buffer {}
+  export function test(options: object): void;
+  export function test(name: string, fn: Function): void;
+  export function test(name: string | object, fn?: Function): void {}
+}
+
+export namespace Deno {
+  export namespace Inner {
+    export function a(): void {}
+    export const b = 100;
+  }
+}
+"#;
+  let loader =
+    TestLoader::new(vec![("test.ts".to_string(), source_code.to_string())]);
+  let entries = DocParser::new(loader).parse("test.ts").await.unwrap();
+
+  let found =
+    find_nodes_by_name_recursively(entries.clone(), "Deno".to_string());
+  assert_eq!(found.len(), 2);
+  assert_eq!(found[0].name, "Deno".to_string());
+  assert_eq!(found[1].name, "Deno".to_string());
+
+  let found =
+    find_nodes_by_name_recursively(entries.clone(), "Deno.test".to_string());
+  assert_eq!(found.len(), 3);
+  assert_eq!(found[0].name, "test".to_string());
+  assert_eq!(found[1].name, "test".to_string());
+  assert_eq!(found[2].name, "test".to_string());
+
+  let found =
+    find_nodes_by_name_recursively(entries.clone(), "Deno.Inner.a".to_string());
+  assert_eq!(found.len(), 1);
+  assert_eq!(found[0].name, "a".to_string());
+
+  let found =
+    find_nodes_by_name_recursively(entries.clone(), "Deno.test.a".to_string());
+  assert_eq!(found.len(), 0);
+
+  let found = find_nodes_by_name_recursively(entries, "a.b.c".to_string());
+  assert_eq!(found.len(), 0);
+}