query: Match nodes not the child of a parent

[dvdsk]

I am building a spell/grammar checker for multiple languages. I use tree-sitter to extract strings/comments/text. For latex, a markup language, I do not want to match all text nodes only those that are not part of a mathematical formula.

Can I capture any text nodes that is not the child of a inline_formula parent? See this example:

Is there a way to do this in the query? I can not seem to find a negate parent option.

[gagbo]

Did you end up finding something? I'm facing the same issue right now. I think I'll have to handle that in bindings, since it looks like there's a way to walk the parents of all nodes programmatically, so a filter can be implemented there. I'm currently doing

    fn is_within_mod_item(node: Node) -> bool {
        let mut walk = node;
        loop {
            if walk.kind() == "mod_item" {
                break true;
            }
            if let Some(parent) = walk.parent() {
                walk = parent;
                continue;
            }
            break false;
        }
    }

you can change "mod_item" for any type you want to exclude

EDIT: and a bigger version, with maximum recursion limit, and access to the source code to log things:

    fn is_within_mod_item(node: Node, max_parent: Option<Node>, source: &str) -> bool {
        let mut walk = node;
        loop {
            if walk.kind() == "mod_item" {
                eprintln!(
                    "Node was inside a mod.\nNode:{}\nMax Parent:{}\n",
                    node.utf8_text(source.as_bytes())
                        .map(ToString::to_string)
                        .unwrap(),
                    if let Some(node) = max_parent {
                        node.utf8_text(source.as_bytes())
                            .map(ToString::to_string)
                            .unwrap()
                    } else {
                        source.to_string()
                    }
                );
                break true;
            }
            if let Some(parent) = walk.parent() {
                if max_parent.map_or(false, |max_parent| parent.id() == max_parent.id()) {
                    break false;
                }

                walk = parent;
                continue;
            }
            break false;
        }
    }

[dvdsk]

I ended up doing the same I think.

Its been a while and that project was abandoned in favor of an LSP. I did find this code snippet:

if node:parent():type() == "inline_formula" then
	return
end

So I think you are on the only right path there. Good luck!