Need help with C++ function indexing query about elisp-tree-sitter

[jmataraz]

FWIW, I tried running a similar query on query.rs that is part of this project:

M-x tree-sitter-mode
M-: (ts-query-captures (ts-make-query (tree-sitter-require 'rust) [(function_item (identifier) @function)]) (ts-root-node tree-sitter-tree))

and this generated the expected vector of results. Something busted with the c/cpp grammar maybe?

[ubolonton]

The C++ grammar is different:

  function_definition: 
    primitive_type: 
    function_declarator: 
      scoped_identifier: 
        namespace_identifier: 
        identifier: 
      parameter_list: 
        parameter_declaration: 
          primitive_type: 
          identifier: 
        parameter_declaration: 
          primitive_type: 
          identifier: 
        parameter_declaration: 
          primitive_type: 
          identifier: 

This query works:

[(function_definition
  (function_declarator
   (scoped_identifier) @function))]

Also, if you are using the latest version, captures are now cons cells, not vectors.

[jmataraz]

I wasn't getting the query syntax. I reread the S-expression description on tree-sitter and it makes more sense now. Thanks for the help!

[jmataraz]

One more question, actually. I found that the example above missed out on regular functions that aren't part of a class or namespace. I considered two approaches:

1. Add another S-expression to the query: (function_definition (function_declarator (identifer) @function)
2. Change the query to capture the function_declarator and then pull the first child with (ts-get-nth-child node 0), which is always "identifier" or "scoped_identifier" and works for both cases.

In general, which is more performant? Are queries really cheap and fast? Faster than processing the node/capture when it comes back?

[ubolonton]

The first approach should be more performant, for 2 reasons:

• Rust is faster than Lisp.
• Crossing the module boundary (calling ts- functions) has some overhead.