chore(grit): implement Grit snippet bindings (#3162)

crates/biome_grit_patterns/Cargo.toml

@@ -24,6 +24,8 @@ biome_rowan = { workspace = true }
 grit-pattern-matcher = { version = "0.3" }
 grit-util = { version = "0.3" }
 im = { version = "15.1.0" }
+path-absolutize = { version = "3.1.1", optional = false, features = ["use_unix_paths_on_wasm"] }
+regex = { workspace = true }
 rustc-hash = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 

crates/biome_grit_patterns/src/errors.rs

@@ -1,6 +1,7 @@
 use biome_diagnostics::serde::Diagnostic as SerializableDiagnostic;
 use biome_diagnostics::Diagnostic;
 use biome_rowan::SyntaxError;
+use grit_util::ByteRange;
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Deserialize, Diagnostic, Serialize)]
@@ -37,6 +38,12 @@ pub enum CompileError {
  /// If a function or bubble pattern has multiple parameters with the same name.
  DuplicateParameters,
 
+ /// A metavariable was expected at the given range.
+ InvalidMetavariableRange(ByteRange),
+
+ /// Incorrect reference to a metavariable.
+ MetavariableNotFound(String),
+
  /// Tried to declare or assign a Grit reserved metavariable.
  ReservedMetavariable(String),
 

crates/biome_grit_patterns/src/grit_binding.rs

@@ -1,21 +1,32 @@
 use crate::{
  grit_context::GritQueryContext, grit_target_language::GritTargetLanguage,
- grit_target_node::GritTargetNode,
+ grit_target_node::GritTargetNode, grit_tree::GritTree, source_location_ext::SourceFileExt,
 };
+use biome_diagnostics::{display::SourceFile, SourceCode};
 use grit_pattern_matcher::{binding::Binding, constant::Constant};
-use grit_util::{ByteRange, CodeRange, Range};
+use grit_util::{Ast, AstNode, ByteRange, CodeRange, Range};
 use std::path::Path;
 
 #[derive(Clone, Debug, PartialEq)]
-pub(crate) struct GritBinding;
+pub(crate) enum GritBinding<'a> {
+ Tree(&'a GritTree),
+ Node(GritTargetNode),
+ Constant(&'a Constant),
+}
 
-impl<'a> Binding<'a, GritQueryContext> for GritBinding {
- fn from_constant(_constant: &'a Constant) -> Self {
- todo!()
+impl<'a> GritBinding<'a> {
+ pub fn from_tree(tree: &'a GritTree) -> Self {
+ Self::Tree(tree)
+ }
+}
+
+impl<'a> Binding<'a, GritQueryContext> for GritBinding<'a> {
+ fn from_constant(constant: &'a Constant) -> Self {
+ Self::Constant(constant)
  }
 
- fn from_node(_node: GritTargetNode) -> Self {
- todo!()
+ fn from_node(node: GritTargetNode) -> Self {
+ Self::Node(node)
  }
 
  fn from_path(_path: &'a Path) -> Self {
@@ -26,24 +37,61 @@ impl<'a> Binding<'a, GritQueryContext> for GritBinding {
  todo!()
  }
 
+ /// Returns the only node bound by this binding.
+ ///
+ /// This includes list bindings that only match a single child.
+ ///
+ /// Returns `None` if the binding has no associated node, or if there is
+ /// more than one associated node.
  fn singleton(&self) -> Option<GritTargetNode> {
- todo!()
+ match self {
+ Self::Node(node) => Some(node.clone()),
+ Self::Tree(..) | Self::Constant(..) => None,
+ }
  }
 
  fn get_sexp(&self) -> Option<String> {
- todo!()
+ None
  }
 
  fn position(&self, _language: &GritTargetLanguage) -> Option<Range> {
- todo!()
+ match self {
+ GritBinding::Tree(tree) => {
+ let source = tree.source();
+ let source = SourceFile::new(SourceCode {
+ text: &source,
+ line_starts: None,
+ });
+ source.to_grit_range(tree.root_node().text_range())
+ }
+ GritBinding::Node(node) => {
+ // TODO: This is probably very inefficient.
+ let root = node.ancestors().last()?;
+ let source = root.text().to_string();
+ let source = SourceFile::new(SourceCode {
+ text: &source,
+ line_starts: None,
+ });
+ source.to_grit_range(root.text_trimmed_range())
+ }
+ GritBinding::Constant(_) => None,
+ }
  }
 
  fn range(&self, _language: &GritTargetLanguage) -> Option<ByteRange> {
- todo!()
+ match self {
+ GritBinding::Tree(tree) => Some(tree.root_node().byte_range()),
+ GritBinding::Node(node) => Some(node.byte_range()),
+ GritBinding::Constant(_) => None,
+ }
  }
 
  fn code_range(&self, _language: &GritTargetLanguage) -> Option<CodeRange> {
- todo!()
+ match self {
+ GritBinding::Tree(tree) => Some(tree.root_node().code_range()),
+ GritBinding::Node(node) => Some(node.code_range()),
+ GritBinding::Constant(_) => None,
+ }
  }
 
  fn is_equivalent_to(&self, _other: &Self, _language: &GritTargetLanguage) -> bool {

crates/biome_grit_patterns/src/grit_code_snippet.rs

@@ -1,13 +1,17 @@
 use crate::grit_context::{GritExecContext, GritQueryContext};
-use crate::resolved_pattern::GritResolvedPattern;
+use crate::grit_resolved_pattern::GritResolvedPattern;
+use crate::grit_target_node::GritTargetSyntaxKind;
 use anyhow::Result;
+use grit_pattern_matcher::binding::Binding;
+use grit_pattern_matcher::context::ExecContext;
 use grit_pattern_matcher::pattern::{
- CodeSnippet, DynamicPattern, Matcher, Pattern, PatternName, State,
+ CodeSnippet, DynamicPattern, Matcher, Pattern, PatternName, ResolvedPattern, State,
 };
 use grit_util::AnalysisLogs;
 
 #[derive(Clone, Debug)]
 pub(crate) struct GritCodeSnippet {
+ pub(crate) patterns: Vec<(GritTargetSyntaxKind, Pattern<GritQueryContext>)>,
  pub(crate) source: String,
  pub(crate) dynamic_snippet: Option<DynamicPattern<GritQueryContext>>,
 }
@@ -25,12 +29,24 @@ impl CodeSnippet<GritQueryContext> for GritCodeSnippet {
 impl Matcher<GritQueryContext> for GritCodeSnippet {
  fn execute<'a>(
  &'a self,
- _binding: &GritResolvedPattern,
- _state: &mut State<'a, GritQueryContext>,
- _context: &'a GritExecContext,
- _logs: &mut AnalysisLogs,
+ resolved: &GritResolvedPattern<'a>,
+ state: &mut State<'a, GritQueryContext>,
+ context: &'a GritExecContext,
+ logs: &mut AnalysisLogs,
  ) -> Result<bool> {
- todo!()
+ let Some(binding) = resolved.get_last_binding() else {
+ return Ok(resolved.text(&state.files, context.language())?.trim() == self.source);
+ };
+
+ let Some(node) = binding.singleton() else {
+ return Ok(false);
+ };
+
+ if let Some((_, pattern)) = self.patterns.iter().find(|(kind, _)| *kind == node.kind()) {
+ pattern.execute(resolved, state, context, logs)
+ } else {
+ Ok(false)
+ }
  }
 }
 

crates/biome_grit_patterns/src/grit_context.rs

@@ -2,10 +2,10 @@ use crate::grit_binding::GritBinding;
 use crate::grit_code_snippet::GritCodeSnippet;
 use crate::grit_file::GritFile;
 use crate::grit_node_patterns::{GritLeafNodePattern, GritNodePattern};
+use crate::grit_resolved_pattern::GritResolvedPattern;
 use crate::grit_target_language::GritTargetLanguage;
 use crate::grit_target_node::GritTargetNode;
 use crate::grit_tree::GritTree;
-use crate::resolved_pattern::GritResolvedPattern;
 use anyhow::Result;
 use grit_pattern_matcher::context::{ExecContext, QueryContext};
 use grit_pattern_matcher::file_owners::FileOwners;
@@ -14,24 +14,32 @@ use grit_pattern_matcher::pattern::{
 };
 use grit_util::AnalysisLogs;
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq)]
 pub(crate) struct GritQueryContext;
 
 impl QueryContext for GritQueryContext {
  type Node<'a> = GritTargetNode;
  type NodePattern = GritNodePattern;
  type LeafNodePattern = GritLeafNodePattern;
  type ExecContext<'a> = GritExecContext;
- type Binding<'a> = GritBinding;
+ type Binding<'a> = GritBinding<'a>;
  type CodeSnippet = GritCodeSnippet;
- type ResolvedPattern<'a> = GritResolvedPattern;
+ type ResolvedPattern<'a> = GritResolvedPattern<'a>;
  type Language<'a> = GritTargetLanguage;
- type File<'a> = GritFile;
+ type File<'a> = GritFile<'a>;
  type Tree<'a> = GritTree;
 }
 
 #[derive(Debug)]
-pub(crate) struct GritExecContext;
+pub(crate) struct GritExecContext {
+ lang: GritTargetLanguage,
+}
+
+impl GritExecContext {
+ pub fn new(lang: GritTargetLanguage) -> Self {
+ Self { lang }
+ }
+}
 
 impl<'a> ExecContext<'a, GritQueryContext> for GritExecContext {
  fn pattern_definitions(&self) -> &[PatternDefinition<GritQueryContext>] {
@@ -56,7 +64,7 @@ impl<'a> ExecContext<'a, GritQueryContext> for GritExecContext {
  _context: &'a Self,
  _state: &mut State<'a, GritQueryContext>,
  _logs: &mut AnalysisLogs,
- ) -> Result<GritResolvedPattern> {
+ ) -> Result<GritResolvedPattern<'a>> {
  todo!()
  }
 
@@ -65,7 +73,7 @@ impl<'a> ExecContext<'a, GritQueryContext> for GritExecContext {
  }
 
  fn language(&self) -> &GritTargetLanguage {
- todo!()
+ &self.lang
  }
 
  fn exec_step(

crates/biome_grit_patterns/src/grit_file.rs

@@ -1,28 +1,65 @@
+use std::path::Path;
+
 use crate::grit_context::GritQueryContext;
+use crate::grit_resolved_pattern::GritResolvedPattern;
 use crate::grit_target_language::GritTargetLanguage;
-use crate::resolved_pattern::GritResolvedPattern;
-use grit_pattern_matcher::pattern::{File, FileRegistry};
+use grit_pattern_matcher::{
+ constant::Constant,
+ pattern::{File, FilePtr, FileRegistry, ResolvedFile, ResolvedPattern},
+};
+use grit_util::Ast;
+use path_absolutize::Absolutize;
 
-pub(crate) struct GritFile;
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) enum GritFile<'a> {
+ Resolved(Box<ResolvedFile<'a, GritQueryContext>>),
+ Ptr(FilePtr),
+}
 
-impl<'a> File<'a, GritQueryContext> for GritFile {
- fn name(&self, _files: &FileRegistry<'a, GritQueryContext>) -> GritResolvedPattern {
- todo!()
+impl<'a> File<'a, GritQueryContext> for GritFile<'a> {
+ fn name(&self, files: &FileRegistry<'a, GritQueryContext>) -> GritResolvedPattern<'a> {
+ match self {
+ Self::Resolved(resolved) => resolved.name.clone(),
+ Self::Ptr(ptr) => GritResolvedPattern::from_path_binding(files.get_file_name(*ptr)),
+ }
  }
 
  fn absolute_path(
  &self,
- _files: &FileRegistry<'a, GritQueryContext>,
- _language: &GritTargetLanguage,
- ) -> anyhow::Result<GritResolvedPattern> {
- todo!()
+ files: &FileRegistry<'a, GritQueryContext>,
+ language: &GritTargetLanguage,
+ ) -> anyhow::Result<GritResolvedPattern<'a>> {
+ match self {
+ Self::Resolved(resolved) => {
+ let name = resolved.name.text(files, language)?;
+ let absolute_path = Path::new(name.as_ref()).absolutize()?;
+ Ok(ResolvedPattern::from_constant(Constant::String(
+ absolute_path.to_string_lossy().to_string(),
+ )))
+ }
+ Self::Ptr(ptr) => Ok(ResolvedPattern::from_path_binding(
+ files.get_absolute_path(*ptr)?,
+ )),
+ }
  }
 
- fn body(&self, _files: &FileRegistry<'a, GritQueryContext>) -> GritResolvedPattern {
- todo!()
+ fn body(&self, files: &FileRegistry<'a, GritQueryContext>) -> GritResolvedPattern<'a> {
+ match self {
+ Self::Resolved(resolved) => resolved.body.clone(),
+ Self::Ptr(ptr) => {
+ let file = &files.get_file_owner(*ptr);
+ GritResolvedPattern::from_tree(&file.tree)
+ }
+ }
  }
 
- fn binding(&self, _files: &FileRegistry<'a, GritQueryContext>) -> GritResolvedPattern {
- todo!()
+ fn binding(&self, files: &FileRegistry<'a, GritQueryContext>) -> GritResolvedPattern<'a> {
+ match self {
+ Self::Resolved(resolved) => resolved.body.clone(),
+ Self::Ptr(ptr) => {
+ let file = &files.get_file_owner(*ptr);
+ ResolvedPattern::from_node_binding(file.tree.root_node())
+ }
+ }
  }
 }