Getting matched Node (without captures) from queries

[osa1]

let query = Query::new(language, &query).unwrap();
let root = tree.root_node();

println!("Matches:");
let mut query_cursor = QueryCursor::new();
for match_ in query_cursor.matches(&query, root, to_callback(&file_contents)) {
    println!("  {:?} (pattern_index={})", match_, match_.pattern_index);
    for capture in match_.captures {
        let node = capture.node;
        println!("    {:?} (index={})", node, capture.index);
    }
}

If I run the code above using Rust parser and a query like (function_item name: (identifier)) the first loop prints a bunch of matches, but as far as I can see QueryMatch doesn't have a Node field so it's not possible to know the matching Node's row/column. Is there a way to do this? I can use captures but I have to capture the whole pattern, something like (function_item name: (identifier)) @node. This is fine but I want to get the queries from users, and the program won't work as expected if they forget to add a capture to the whole pattern. It would be great if matches also returned the matching Node.

As far as I can see from the documentation, C API also doesn't support this. Is this difficult to do?

One idea is to add some dummy capture for every query string, like <query> @blah where <query> is the query string provided by the user. I wonder if there's a better way to do this.

[maxbrunsfeld]

There isn't always one root node to a pattern; you can write a pattern like this:

(
  (comment)+
  (function_definition)
)

One idea is to add some dummy capture for every query string

I think that in most cases this will work. Even if the user writes a top-level capture, it is still valid to have multiple captures like

(return_statement) @foo @bar

There will just be two named captures for the same node.