Method hook

codegraph-kernel/src/scala.rs:593–689

The visitNode hook (scala.ts:131-198). Returns true when consumed.

(&mut self, node: Node<'t>)

    /// The visitNode hook (scala.ts:131-198). Returns true when consumed.
    fn hook(&mut self, node: Node<'t>) -> bool {
        match node.kind() {
            "val_definition" | "var_definition" => {
                let is_val = node.kind() == "val_definition";
                let name = match self.val_var_name(node) {
                    Some(n) => n.to_string(),
                    None => return false,
                };
                // Enclosing-definition NODE-TYPE walk (scala.ts:146-156).
                let mut enclosing: Option<&'static str> = None;
                let mut p = node.parent();
                while let Some(parent) = p {
                    match parent.kind() {
                        "class_definition" => {
                            enclosing = Some("class_definition");
                            break;
                        }
                        "trait_definition" => {
                            enclosing = Some("trait_definition");
                            break;
                        }
                        "enum_definition" => {
                            enclosing = Some("enum_definition");
                            break;
                        }
                        "given_definition" => {
                            enclosing = Some("given_definition");
                            break;
                        }
                        "object_definition" => {
                            enclosing = Some("object_definition");
                            break;
                        }
                        _ => p = parent.parent(),
                    }
                }
                let is_instance_field = matches!(
                    enclosing,
                    Some("class_definition") | Some("trait_definition") | Some("enum_definition")
                        | Some("given_definition")
                );
                let kind: &'static str = if is_instance_field {
                    "field"
                } else if is_val {
                    "constant"
                } else {
                    "variable"
                };
                let type_node = node.child_by_field_name("type");
                let signature = type_node.map(|t| {
                    format!("{} {}: {}", if is_val { "val" } else { "var" }, name, self.text(t))
                });
                let visibility = self.visibility_of(node);
                let created = self.create_node(
                    kind,
                    &name,
                    node,
                    Extra { signature, visibility, ..Default::default() },