mirror of https://github.com/helix-editor/helix
tmp
Pascal Kuthe
7 months ago
parent
0cd8817d06
commit
1bd36f528a
@ -0,0 +1,288 @@
|
||||
use std::error::Error;
|
||||
use std::ptr::NonNull;
|
||||
use std::{fmt, slice};
|
||||
|
||||
use crate::tree_sitter::query::property::QueryProperty;
|
||||
use crate::tree_sitter::query::{Capture, Pattern, Query, QueryData, QueryStr};
|
||||
|
||||
use regex_cursor::engines::meta::Regex;
|
||||
|
||||
macro_rules! bail {
|
||||
($($args:tt)*) => {{
|
||||
return Err(InvalidPredicateError {msg: format!($($args)*).into() })
|
||||
}}
|
||||
}
|
||||
|
||||
macro_rules! ensure {
|
||||
($cond: expr, $($args:tt)*) => {{
|
||||
if !$cond {
|
||||
return Err(InvalidPredicateError { msg: format!($($args)*).into() })
|
||||
}
|
||||
}}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub(super) enum TextPredicateKind {
|
||||
EqString(QueryStr),
|
||||
EqCapture(Capture),
|
||||
MatchString(Regex),
|
||||
AnyString(Box<[QueryStr]>),
|
||||
}
|
||||
|
||||
pub(super) struct TextPredicate {
|
||||
capture: Capture,
|
||||
kind: TextPredicateKind,
|
||||
negated: bool,
|
||||
match_all: bool,
|
||||
}
|
||||
|
||||
impl Query {
|
||||
pub(super) fn parse_pattern_predicates(
|
||||
&mut self,
|
||||
pattern_index: u32,
|
||||
mut custom_predicate: impl FnMut(Predicate) -> Result<(), InvalidPredicateError>,
|
||||
) -> Result<Pattern, InvalidPredicateError> {
|
||||
let text_predicate_start = self.text_predicates.len() as u32;
|
||||
let property_start = self.properties.len() as u32;
|
||||
|
||||
let predicate_steps = unsafe {
|
||||
let mut len = 0u32;
|
||||
let raw_predicates = ts_query_predicates_for_pattern(self.raw, pattern_index, &mut len);
|
||||
(len != 0)
|
||||
.then(|| slice::from_raw_parts(raw_predicates, len as usize))
|
||||
.unwrap_or_default()
|
||||
};
|
||||
let predicates = predicate_steps
|
||||
.split(|step| step.kind == PredicateStepKind::Done)
|
||||
.filter(|predicate| !predicate.is_empty());
|
||||
|
||||
for predicate in predicates {
|
||||
let predicate = unsafe { Predicate::new(self, predicate)? };
|
||||
|
||||
match predicate.name() {
|
||||
"eq?" | "not-eq?" | "any-eq?" | "any-not-eq?" => {
|
||||
predicate.check_arg_count(2)?;
|
||||
let capture_idx = predicate.capture_arg(0)?;
|
||||
let arg2 = predicate.arg(1);
|
||||
|
||||
let negated = matches!(predicate.name(), "not-eq?" | "not-any-eq?");
|
||||
let match_all = matches!(predicate.name(), "eq?" | "not-eq?");
|
||||
let kind = match arg2 {
|
||||
PredicateArg::Capture(capture) => TextPredicateKind::EqCapture(capture),
|
||||
PredicateArg::String(str) => TextPredicateKind::EqString(str),
|
||||
};
|
||||
self.text_predicates.push(TextPredicate {
|
||||
capture: capture_idx,
|
||||
kind,
|
||||
negated,
|
||||
match_all,
|
||||
});
|
||||
}
|
||||
|
||||
"match?" | "not-match?" | "any-match?" | "any-not-match?" => {
|
||||
predicate.check_arg_count(2)?;
|
||||
let capture_idx = predicate.capture_arg(0)?;
|
||||
let regex = predicate.str_arg(1)?.get(self);
|
||||
|
||||
let negated = matches!(predicate.name(), "not-match?" | "any-not-match?");
|
||||
let match_all = matches!(predicate.name(), "match?" | "not-match?");
|
||||
let regex = match Regex::new(regex) {
|
||||
Ok(regex) => regex,
|
||||
Err(err) => bail!("invalid regex '{regex}', {err}"),
|
||||
};
|
||||
self.text_predicates.push(TextPredicate {
|
||||
capture: capture_idx,
|
||||
kind: TextPredicateKind::MatchString(regex),
|
||||
negated,
|
||||
match_all,
|
||||
});
|
||||
}
|
||||
|
||||
"set!" => self.properties.push(QueryProperty::parse(&predicate)?),
|
||||
|
||||
"any-of?" | "not-any-of?" => {
|
||||
predicate.check_min_arg_count(1)?;
|
||||
let capture = predicate.capture_arg(0)?;
|
||||
let negated = predicate.name() == "not-any-of?";
|
||||
let values: Result<_, InvalidPredicateError> = (1..predicate.num_args())
|
||||
.map(|i| predicate.str_arg(i))
|
||||
.collect();
|
||||
self.text_predicates.push(TextPredicate {
|
||||
capture,
|
||||
kind: TextPredicateKind::AnyString(values?),
|
||||
negated,
|
||||
match_all: false,
|
||||
});
|
||||
}
|
||||
|
||||
// is and is-not are better handeled as custom predicates since interpreting is context dependent
|
||||
// "is?" => property_predicates.push((QueryProperty::parse(&predicate), false)),
|
||||
// "is-not?" => property_predicates.push((QueryProperty::parse(&predicate), true)),
|
||||
_ => custom_predicate(predicate)?,
|
||||
}
|
||||
}
|
||||
Ok(Pattern {
|
||||
text_predicates: text_predicate_start..self.text_predicates.len() as u32,
|
||||
properties: property_start..self.properties.len() as u32,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
pub enum PredicateArg {
|
||||
Capture(Capture),
|
||||
String(QueryStr),
|
||||
}
|
||||
|
||||
pub struct Predicate<'a> {
|
||||
pub name: QueryStr,
|
||||
args: &'a [PredicateStep],
|
||||
query: &'a Query,
|
||||
}
|
||||
|
||||
impl<'a> Predicate<'a> {
|
||||
unsafe fn new(
|
||||
query: &'a Query,
|
||||
predicate: &'a [PredicateStep],
|
||||
) -> Result<Predicate<'a>, InvalidPredicateError> {
|
||||
ensure!(
|
||||
predicate[0].kind == PredicateStepKind::String,
|
||||
"expected predicate to start with a function name. Got @{}.",
|
||||
Capture(predicate[0].value_id).name(query)
|
||||
);
|
||||
let operator_name = QueryStr(predicate[0].value_id);
|
||||
Ok(Predicate {
|
||||
name: operator_name,
|
||||
args: &predicate[1..],
|
||||
query,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn name(&self) -> &str {
|
||||
self.name.get(self.query)
|
||||
}
|
||||
|
||||
pub fn check_arg_count(&self, n: usize) -> Result<(), InvalidPredicateError> {
|
||||
ensure!(
|
||||
self.args.len() == n,
|
||||
"expected {n} arguments for #{}, got {}",
|
||||
self.name(),
|
||||
self.args.len()
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn check_min_arg_count(&self, n: usize) -> Result<(), InvalidPredicateError> {
|
||||
ensure!(
|
||||
n <= self.args.len(),
|
||||
"expected at least {n} arguments for #{}, got {}",
|
||||
self.name(),
|
||||
self.args.len()
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn check_max_arg_count(&self, n: usize) -> Result<(), InvalidPredicateError> {
|
||||
ensure!(
|
||||
self.args.len() <= n,
|
||||
"expected at most {n} arguments for #{}, got {}",
|
||||
self.name(),
|
||||
self.args.len()
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub fn str_arg(&self, i: usize) -> Result<QueryStr, InvalidPredicateError> {
|
||||
match self.arg(i) {
|
||||
PredicateArg::String(str) => Ok(str),
|
||||
PredicateArg::Capture(capture) => bail!(
|
||||
"{i}. argument to #{} must be a literal, got capture @{:?}",
|
||||
self.name(),
|
||||
capture.name(self.query)
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn num_args(&self) -> usize {
|
||||
self.args.len()
|
||||
}
|
||||
|
||||
pub fn capture_arg(&self, i: usize) -> Result<Capture, InvalidPredicateError> {
|
||||
match self.arg(i) {
|
||||
PredicateArg::Capture(capture) => Ok(capture),
|
||||
PredicateArg::String(str) => bail!(
|
||||
"{i}. argument to #{} expected a capture, got literal {:?}",
|
||||
self.name(),
|
||||
str.get(self.query)
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn arg(&self, i: usize) -> PredicateArg {
|
||||
self.args[i].try_into().unwrap()
|
||||
}
|
||||
|
||||
pub fn args(&self) -> impl Iterator<Item = PredicateArg> + '_ {
|
||||
self.args.iter().map(|&arg| arg.try_into().unwrap())
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct InvalidPredicateError {
|
||||
pub(super) msg: Box<str>,
|
||||
}
|
||||
|
||||
impl fmt::Display for InvalidPredicateError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
f.write_str(&self.msg)
|
||||
}
|
||||
}
|
||||
|
||||
impl Error for InvalidPredicateError {}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
enum PredicateStepKind {
|
||||
Done = 0,
|
||||
Capture = 1,
|
||||
String = 2,
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
struct PredicateStep {
|
||||
kind: PredicateStepKind,
|
||||
value_id: u32,
|
||||
}
|
||||
|
||||
impl TryFrom<PredicateStep> for PredicateArg {
|
||||
type Error = ();
|
||||
|
||||
fn try_from(step: PredicateStep) -> Result<Self, Self::Error> {
|
||||
match step.kind {
|
||||
PredicateStepKind::String => Ok(PredicateArg::String(QueryStr(step.value_id))),
|
||||
PredicateStepKind::Capture => Ok(PredicateArg::Capture(Capture(step.value_id))),
|
||||
PredicateStepKind::Done => Err(()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extern "C" {
|
||||
/// Get all of the predicates for the given pattern in the query. The
|
||||
/// predicates are represented as a single array of steps. There are three
|
||||
/// types of steps in this array, which correspond to the three legal values
|
||||
/// for the `type` field: - `TSQueryPredicateStepTypeCapture` - Steps with
|
||||
/// this type represent names of captures. Their `value_id` can be used
|
||||
/// with the [`ts_query_capture_name_for_id`] function to obtain the name
|
||||
/// of the capture. - `TSQueryPredicateStepTypeString` - Steps with this
|
||||
/// type represent literal strings. Their `value_id` can be used with the
|
||||
/// [`ts_query_string_value_for_id`] function to obtain their string value.
|
||||
/// - `TSQueryPredicateStepTypeDone` - Steps with this type are *sentinels*
|
||||
/// that represent the end of an individual predicate. If a pattern has two
|
||||
/// predicates, then there will be two steps with this `type` in the array.
|
||||
fn ts_query_predicates_for_pattern(
|
||||
query: NonNull<QueryData>,
|
||||
pattern_index: u32,
|
||||
step_count: &mut u32,
|
||||
) -> *const PredicateStep;
|
||||
|
||||
}
|
||||
@ -0,0 +1,19 @@
|
||||
use crate::tree_sitter::query::predicate::{InvalidPredicateError, Predicate};
|
||||
use crate::tree_sitter::query::QueryStr;
|
||||
|
||||
pub struct QueryProperty {
|
||||
pub key: QueryStr,
|
||||
pub val: Option<QueryStr>,
|
||||
}
|
||||
|
||||
impl QueryProperty {
|
||||
pub fn parse(predicate: &Predicate) -> Result<Self, InvalidPredicateError> {
|
||||
predicate.check_min_arg_count(1)?;
|
||||
predicate.check_max_arg_count(2)?;
|
||||
let key = predicate.str_arg(0)?;
|
||||
let val = (predicate.num_args() == 1)
|
||||
.then(|| predicate.str_arg(1))
|
||||
.transpose()?;
|
||||
Ok(QueryProperty { key, val })
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue