Skip to main content

jshift/project/
jmespath.rs

1//! JMESPath parser → [`SelectExpr`].
2//!
3//! Supported surface (growing):
4//! * identifiers, `.` descent, `@` current, parentheses
5//! * `[N]` / `[-N]`, `[*]` / `[]`, slices `[start:end:step]` (signed)
6//! * filters `[?expr]` with `== != < <= > >=`, `&&`, `||`, `!`
7//! * multi-select hash / list, pipe `|`, flatten `| []`
8//! * functions: `length`, `keys`, `values`, `type`, `to_string`, `to_number`,
9//!   `starts_with`, `ends_with`, `contains`, `not_null`, `reverse`, `sort`,
10//!   `sort_by`, `max_by`, `min_by`, `map`, `group_by`, `join`, `max`, `min`,
11//!   `sum`, `avg`, `abs`, `ceil`, `floor`, `to_array`, `merge`
12//! * expression references `&expr` for higher-order functions
13//! * object projection `*` / `foo.*` / `*.bar` (multi-select wildcards on objects)
14//! * literals: numbers, `"…"` / `'…'` (raw), `` `…` `` (JSON literal), true/false/null
15//!
16//! JMESPath has no parent axis (`..`); use pipe from an outer context.
17
18use crate::error::Error;
19use crate::project::select::{
20    ArraySelect, CmpOp, HashField, ProjectPathSegment, SelectExpr,
21};
22
23/// Parse a JMESPath expression into a [`SelectExpr`].
24pub fn parse_jmespath_expr(input: &str) -> Result<SelectExpr, Error> {
25    let mut p = Parser::new(input);
26    let expr = p.parse_pipe()?;
27    p.skip_ws();
28    if !p.eof() {
29        return Err(Error::InvalidPath {
30            msg: "Trailing junk after JMESPath expression",
31        });
32    }
33    Ok(expr)
34}
35
36/// Build [`SelectExpr`] from a keep-list path.
37pub fn select_from_project_path(path: &str) -> Result<SelectExpr, Error> {
38    segs_to_select(&parse_project_path(path)?)
39}
40
41/// Parse projection path segments including signed slices and wildcards.
42pub fn parse_project_path(s: &str) -> Result<Vec<ProjectPathSegment>, Error> {
43    let mut rest = s.trim();
44    let mut segments = Vec::new();
45    if rest.is_empty() {
46        return Err(Error::InvalidPath {
47            msg: "Empty project path",
48        });
49    }
50    while !rest.is_empty() {
51        if rest.starts_with('.') {
52            rest = &rest[1..];
53            continue;
54        }
55        if rest.starts_with('[') {
56            let end_idx = rest.find(']').ok_or(Error::InvalidPath {
57                msg: "Unclosed '[' in project path",
58            })?;
59            let inner = rest[1..end_idx].trim();
60            if inner.is_empty() {
61                // Keep-list `[]` means every element (wildcard), not flatten.
62                segments.push(ProjectPathSegment::ArrayWildcard);
63            } else if inner == "*" {
64                segments.push(ProjectPathSegment::ArrayWildcard);
65            } else if inner.contains(':') {
66                segments.push(parse_slice_inner(inner)?);
67            } else {
68                let idx = parse_signed(inner).map_err(|_| Error::InvalidPath {
69                    msg: "Invalid array index",
70                })?;
71                segments.push(ProjectPathSegment::Index(idx));
72            }
73            rest = &rest[end_idx + 1..];
74        } else {
75            let end_key = rest.find(['.', '[']).unwrap_or(rest.len());
76            let key = &rest[..end_key];
77            if key.is_empty() {
78                return Err(Error::InvalidPath {
79                    msg: "Empty key segment in project path",
80                });
81            }
82            segments.push(ProjectPathSegment::Key(key.to_string()));
83            rest = &rest[end_key..];
84        }
85    }
86    Ok(segments)
87}
88
89fn parse_slice_inner(inner: &str) -> Result<ProjectPathSegment, Error> {
90    let parts: Vec<&str> = inner.split(':').collect();
91    if parts.len() > 3 {
92        return Err(Error::InvalidPath {
93            msg: "Slice has too many components",
94        });
95    }
96    let parse_opt = |s: &str| -> Result<Option<i64>, Error> {
97        let s = s.trim();
98        if s.is_empty() {
99            Ok(None)
100        } else {
101            Ok(Some(parse_signed(s).map_err(|_| Error::InvalidPath {
102                msg: "Invalid slice bound",
103            })?))
104        }
105    };
106    let start = parse_opt(parts.first().copied().unwrap_or(""))?;
107    let end = parse_opt(parts.get(1).copied().unwrap_or(""))?;
108    let step = if parts.len() == 3 {
109        parse_opt(parts[2])?
110    } else {
111        None
112    };
113    Ok(ProjectPathSegment::ArraySlice { start, end, step })
114}
115
116fn parse_signed(s: &str) -> Result<i64, ()> {
117    s.trim().parse().map_err(|_| ())
118}
119
120fn segs_to_select(segs: &[ProjectPathSegment]) -> Result<SelectExpr, Error> {
121    if segs.is_empty() {
122        return Ok(SelectExpr::Identity);
123    }
124    let mut expr = SelectExpr::Identity;
125    for seg in segs.iter().rev() {
126        expr = match seg {
127            ProjectPathSegment::Key(k) => {
128                if matches!(expr, SelectExpr::Identity | SelectExpr::Current) {
129                    SelectExpr::Field(k.clone())
130                } else {
131                    SelectExpr::Sub(Box::new(SelectExpr::Field(k.clone())), Box::new(expr))
132                }
133            }
134            ProjectPathSegment::Index(i) => {
135                let mut map = std::collections::HashMap::new();
136                map.insert(*i, expr);
137                SelectExpr::Array(ArraySelect::Indices(map))
138            }
139            ProjectPathSegment::ArrayWildcard => {
140                SelectExpr::Array(ArraySelect::Each(Box::new(expr)))
141            }
142            ProjectPathSegment::ArraySlice { start, end, step } => {
143                SelectExpr::Array(ArraySelect::Slice {
144                    start: *start,
145                    end: *end,
146                    step: *step,
147                    each: Box::new(expr),
148                })
149            }
150        };
151    }
152    Ok(expr)
153}
154
155struct Parser<'a> {
156    s: &'a str,
157    i: usize,
158}
159
160impl<'a> Parser<'a> {
161    fn new(s: &'a str) -> Self {
162        Self { s, i: 0 }
163    }
164
165    fn eof(&self) -> bool {
166        self.i >= self.s.len()
167    }
168
169    fn peek(&self) -> Option<char> {
170        self.s[self.i..].chars().next()
171    }
172
173    fn peek_str(&self) -> &str {
174        &self.s[self.i..]
175    }
176
177    fn bump(&mut self) -> Option<char> {
178        let c = self.peek()?;
179        self.i += c.len_utf8();
180        Some(c)
181    }
182
183    fn skip_ws(&mut self) {
184        while self.peek().is_some_and(|c| c.is_whitespace()) {
185            self.bump();
186        }
187    }
188
189    fn eat(&mut self, expected: char) -> Result<(), Error> {
190        self.skip_ws();
191        match self.bump() {
192            Some(c) if c == expected => Ok(()),
193            _ => Err(Error::InvalidPath {
194                msg: "Unexpected character in JMESPath",
195            }),
196        }
197    }
198
199    fn starts_with(&self, lit: &str) -> bool {
200        self.peek_str().starts_with(lit)
201    }
202
203    // pipe → or → and → not → cmp → project
204    fn parse_pipe(&mut self) -> Result<SelectExpr, Error> {
205        let mut left = self.parse_or()?;
206        loop {
207            self.skip_ws();
208            if self.peek() == Some('|') && !self.starts_with("||") {
209                self.bump();
210                self.skip_ws();
211                if self.peek() == Some('[') {
212                    let save = self.i;
213                    self.bump();
214                    self.skip_ws();
215                    if self.peek() == Some(']') {
216                        self.bump();
217                        left = SelectExpr::Flatten(Box::new(left));
218                        continue;
219                    }
220                    self.i = save;
221                }
222                let right = self.parse_or()?;
223                left = SelectExpr::Pipe(Box::new(left), Box::new(right));
224            } else {
225                break;
226            }
227        }
228        Ok(left)
229    }
230
231    fn parse_or(&mut self) -> Result<SelectExpr, Error> {
232        let mut left = self.parse_and()?;
233        loop {
234            self.skip_ws();
235            if self.starts_with("||") {
236                self.i += 2;
237                let right = self.parse_and()?;
238                left = SelectExpr::Or(Box::new(left), Box::new(right));
239            } else {
240                break;
241            }
242        }
243        Ok(left)
244    }
245
246    fn parse_and(&mut self) -> Result<SelectExpr, Error> {
247        let mut left = self.parse_not()?;
248        loop {
249            self.skip_ws();
250            if self.starts_with("&&") {
251                self.i += 2;
252                let right = self.parse_not()?;
253                left = SelectExpr::And(Box::new(left), Box::new(right));
254            } else {
255                break;
256            }
257        }
258        Ok(left)
259    }
260
261    fn parse_not(&mut self) -> Result<SelectExpr, Error> {
262        self.skip_ws();
263        if self.peek() == Some('!') && !self.starts_with("!=") {
264            self.bump();
265            let inner = self.parse_not()?;
266            return Ok(SelectExpr::Not(Box::new(inner)));
267        }
268        self.parse_compare()
269    }
270
271    fn parse_compare(&mut self) -> Result<SelectExpr, Error> {
272        let left = self.parse_project()?;
273        self.skip_ws();
274        let op = if self.starts_with("==") {
275            self.i += 2;
276            Some(CmpOp::Eq)
277        } else if self.starts_with("!=") {
278            self.i += 2;
279            Some(CmpOp::Ne)
280        } else if self.starts_with("<=") {
281            self.i += 2;
282            Some(CmpOp::Le)
283        } else if self.starts_with(">=") {
284            self.i += 2;
285            Some(CmpOp::Ge)
286        } else if self.peek() == Some('<') {
287            self.bump();
288            Some(CmpOp::Lt)
289        } else if self.peek() == Some('>') {
290            self.bump();
291            Some(CmpOp::Gt)
292        } else {
293            None
294        };
295        if let Some(op) = op {
296            let right = self.parse_project()?;
297            Ok(SelectExpr::Cmp {
298                op,
299                left: Box::new(left),
300                right: Box::new(right),
301            })
302        } else {
303            Ok(left)
304        }
305    }
306
307    fn parse_project(&mut self) -> Result<SelectExpr, Error> {
308        self.skip_ws();
309        // Expression reference binds tighter than pipe: &foo.bar
310        if self.peek() == Some('&') {
311            self.bump();
312            let inner = self.parse_project()?;
313            return Ok(SelectExpr::Expref(Box::new(inner)));
314        }
315        if self.peek() == Some('{') {
316            let expr = self.parse_multi_hash()?;
317            return self.parse_projection_suffixes(expr);
318        }
319        // leading bracket: multi-list / index / filter / slice (+ further suffixes)
320        if self.peek() == Some('[') {
321            let expr = self.parse_bracket_expr()?;
322            return self.parse_projection_suffixes(expr);
323        }
324        // leading object projection
325        if self.peek() == Some('*') {
326            self.bump();
327            let expr = SelectExpr::ObjectProjection(Box::new(SelectExpr::Identity));
328            return self.parse_projection_suffixes(expr);
329        }
330        let mut expr = self.parse_atom()?;
331        expr = self.parse_projection_suffixes(expr)?;
332        Ok(expr)
333    }
334
335    /// `.field`, `.*`, `[…]`, `(args)` suffixes after a projectable expr.
336    fn parse_projection_suffixes(&mut self, mut expr: SelectExpr) -> Result<SelectExpr, Error> {
337        loop {
338            self.skip_ws();
339            match self.peek() {
340                Some('.') => {
341                    self.bump();
342                    self.skip_ws();
343                    if self.peek() == Some('*') {
344                        self.bump();
345                        // object value projection after current
346                        expr = chain_sub(
347                            expr,
348                            SelectExpr::ObjectProjection(Box::new(SelectExpr::Identity)),
349                        );
350                    } else if self.peek() == Some('{') {
351                        let right = self.parse_multi_hash()?;
352                        // Empty multi-hash after `.` is a syntax error (`a.{}`).
353                        if matches!(&right, SelectExpr::MultiSelectHash(f) if f.is_empty()) {
354                            return Err(Error::InvalidPath {
355                                msg: "Empty multi-select hash after '.'",
356                            });
357                        }
358                        expr = chain_sub(expr, right);
359                    } else if self.peek() == Some('[') {
360                        // Multi-select list after `.` cannot start with a bare number
361                        // (jmespath: `foo.[0]` / `foo.[0,1]` are invalid).
362                        let save = self.i;
363                        self.bump(); // '['
364                        self.skip_ws();
365                        let bad_number = self
366                            .peek()
367                            .is_some_and(|c| c == '-' || c.is_ascii_digit());
368                        self.i = save;
369                        if bad_number {
370                            return Err(Error::InvalidPath {
371                                msg: "Multi-select list after '.' cannot start with a number",
372                            });
373                        }
374                        let right = self.parse_bracket_expr()?;
375                        // Reject multi-list items that are bare number literals mixed in.
376                        if let SelectExpr::MultiSelectList(items) = &right {
377                            for it in items {
378                                if matches!(it, SelectExpr::Literal(b) if is_json_number_lit(b)) {
379                                    return Err(Error::InvalidPath {
380                                        msg: "Number not allowed as multi-select list item here",
381                                    });
382                                }
383                            }
384                        }
385                        expr = chain_sub(expr, right);
386                    } else if self.peek() == Some('"') {
387                        // Quoted identifier: "foo.bar", "foo bar", escapes
388                        let name = self.parse_dq_string_raw()?;
389                        expr = chain_sub(expr, SelectExpr::FieldQuoted(name));
390                    } else {
391                        let name = self.parse_ident()?;
392                        if self.peek() == Some('(') {
393                            let args = self.parse_arg_list()?;
394                            expr = chain_sub(
395                                expr,
396                                SelectExpr::Call { name, args },
397                            );
398                        } else {
399                            expr = chain_sub(expr, SelectExpr::Field(name));
400                        }
401                    }
402                }
403                Some('[') => {
404                    let bracket = self.parse_bracket_suffix()?;
405                    expr = chain_sub(expr, bracket);
406                }
407                Some('(') => {
408                    // Only bare identifiers are function names (not quoted identifiers).
409                    if let SelectExpr::Field(name) = expr {
410                        let args = self.parse_arg_list()?;
411                        expr = SelectExpr::Call { name, args };
412                    } else if matches!(expr, SelectExpr::FieldQuoted(_)) {
413                        return Err(Error::InvalidPath {
414                            msg: "Quoted identifier is not a function name",
415                        });
416                    } else {
417                        break;
418                    }
419                }
420                _ => break,
421            }
422        }
423        Ok(expr)
424    }
425
426    fn parse_atom(&mut self) -> Result<SelectExpr, Error> {
427        self.skip_ws();
428        match self.peek() {
429            Some('@') => {
430                self.bump();
431                Ok(SelectExpr::Current)
432            }
433            Some('&') => {
434                self.bump();
435                let inner = self.parse_project()?;
436                Ok(SelectExpr::Expref(Box::new(inner)))
437            }
438            Some('*') => {
439                self.bump();
440                Ok(SelectExpr::ObjectProjection(Box::new(SelectExpr::Identity)))
441            }
442            Some('(') => {
443                self.bump();
444                let e = self.parse_pipe()?;
445                self.eat(')')?;
446                Ok(SelectExpr::Paren(Box::new(e)))
447            }
448            // Double-quoted = identifier (may contain dots/spaces). Single-quoted = string literal.
449            Some('"') => {
450                // Quoted identifier (not a callable function name).
451                let name = self.parse_dq_string_raw()?;
452                Ok(SelectExpr::FieldQuoted(name))
453            }
454            Some('\'') => self.parse_raw_string_literal(),
455            Some('`') => self.parse_backtick_literal(),
456            Some(c) if c == '-' || c.is_ascii_digit() => self.parse_number_literal(),
457            Some('{') => self.parse_multi_hash(),
458            Some('[') => self.parse_bracket_expr(),
459            Some(c) if is_ident_start(c) => {
460                let name = self.parse_ident()?;
461                self.skip_ws();
462                if self.peek() == Some('(') {
463                    let args = self.parse_arg_list()?;
464                    Ok(SelectExpr::Call { name, args })
465                } else if name == "true" {
466                    Ok(SelectExpr::Literal(b"true".to_vec()))
467                } else if name == "false" {
468                    Ok(SelectExpr::Literal(b"false".to_vec()))
469                } else if name == "null" {
470                    Ok(SelectExpr::Literal(b"null".to_vec()))
471                } else {
472                    Ok(SelectExpr::Field(name))
473                }
474            }
475            _ => Err(Error::InvalidPath {
476                msg: "Expected JMESPath atom",
477            }),
478        }
479    }
480
481    fn parse_arg_list(&mut self) -> Result<Vec<SelectExpr>, Error> {
482        self.eat('(')?;
483        let mut args = Vec::new();
484        self.skip_ws();
485        if self.peek() == Some(')') {
486            self.bump();
487            return Ok(args);
488        }
489        loop {
490            args.push(self.parse_pipe()?);
491            self.skip_ws();
492            match self.peek() {
493                Some(',') => {
494                    self.bump();
495                    continue;
496                }
497                Some(')') => {
498                    self.bump();
499                    break;
500                }
501                _ => {
502                    return Err(Error::InvalidPath {
503                        msg: "Expected ',' or ')' in function args",
504                    });
505                }
506            }
507        }
508        Ok(args)
509    }
510
511    fn parse_ident(&mut self) -> Result<String, Error> {
512        self.skip_ws();
513        let start = self.i;
514        match self.peek() {
515            Some(c) if is_ident_start(c) => {
516                self.bump();
517            }
518            _ => {
519                return Err(Error::InvalidPath {
520                    msg: "Expected identifier",
521                });
522            }
523        }
524        while self.peek().is_some_and(is_ident_continue) {
525            self.bump();
526        }
527        Ok(self.s[start..self.i].to_string())
528    }
529
530    fn parse_multi_hash(&mut self) -> Result<SelectExpr, Error> {
531        self.eat('{')?;
532        let mut fields = Vec::new();
533        self.skip_ws();
534        if self.peek() == Some('}') {
535            self.bump();
536            return Ok(SelectExpr::MultiSelectHash(fields));
537        }
538        loop {
539            self.skip_ws();
540            let key = if self.peek() == Some('"') {
541                self.parse_dq_string_raw()?
542            } else if self.peek() == Some('\'') {
543                self.parse_raw_string_raw()?
544            } else {
545                self.parse_ident()?
546            };
547            self.skip_ws();
548            self.eat(':')?;
549            let expr = self.parse_pipe()?;
550            fields.push(HashField::new(key, expr));
551            self.skip_ws();
552            match self.peek() {
553                Some(',') => {
554                    self.bump();
555                    continue;
556                }
557                Some('}') => {
558                    self.bump();
559                    break;
560                }
561                _ => {
562                    return Err(Error::InvalidPath {
563                        msg: "Expected ',' or '}' in multi-select hash",
564                    });
565                }
566            }
567        }
568        Ok(SelectExpr::MultiSelectHash(fields))
569    }
570
571    /// Bracket as a full expression (start of atom/project): list, index, filter, slice.
572    fn parse_bracket_expr(&mut self) -> Result<SelectExpr, Error> {
573        self.parse_bracket_common(true)
574    }
575
576    /// Bracket as a suffix after an expression.
577    fn parse_bracket_suffix(&mut self) -> Result<SelectExpr, Error> {
578        self.parse_bracket_common(false)
579    }
580
581    fn parse_bracket_common(&mut self, allow_multi_list: bool) -> Result<SelectExpr, Error> {
582        self.eat('[')?;
583        // Filter `?` must be immediately after `[` (no whitespace): `foo[?x]` ok, `foo[ ?x]` error.
584        if self.peek() == Some('?') {
585            self.bump();
586            let pred = self.parse_pipe()?;
587            self.eat(']')?;
588            return Ok(SelectExpr::Array(ArraySelect::Filter {
589                pred: Box::new(pred),
590                each: Box::new(SelectExpr::Identity),
591            }));
592        }
593        self.skip_ws();
594        // empty `[]` — JMESPath flatten operator / flatten-projection (not `[*]`).
595        // Represented as Flatten(Identity); chain_sub wraps prior expr as Flatten(prefix)
596        // and subsequent `.field` as Sub(Flatten(prefix), Each(field)).
597        if self.peek() == Some(']') {
598            self.bump();
599            return Ok(SelectExpr::Flatten(Box::new(SelectExpr::Identity)));
600        }
601        // `[*]` — list projection (no flatten). `[*.*]` is a multi-select list.
602        if self.peek() == Some('*') {
603            let save = self.i;
604            self.bump();
605            if self.peek() == Some(']') {
606                self.bump();
607                return Ok(SelectExpr::Array(ArraySelect::Each(Box::new(
608                    SelectExpr::Identity,
609                ))));
610            }
611            self.i = save;
612            // fall through to multi-select list / other forms
613        }
614        // peek if slice/index-only: number, colon, minus
615        let save = self.i;
616        if self.peek().is_some_and(|c| c == '-' || c == ':' || c.is_ascii_digit()) {
617            let inner_start = self.i;
618            while self.peek().is_some_and(|c| c != ']') {
619                self.bump();
620            }
621            let inner = self.s[inner_start..self.i].trim();
622            if self.peek() == Some(']') {
623                self.bump();
624                if inner.contains(':') {
625                    return match parse_slice_inner(inner)? {
626                        ProjectPathSegment::ArraySlice { start, end, step } => {
627                            Ok(SelectExpr::Array(ArraySelect::Slice {
628                                start,
629                                end,
630                                step,
631                                each: Box::new(SelectExpr::Identity),
632                            }))
633                        }
634                        _ => unreachable!(),
635                    };
636                }
637                if let Ok(idx) = parse_signed(inner) {
638                    let mut map = std::collections::HashMap::new();
639                    map.insert(idx, SelectExpr::Identity);
640                    return Ok(SelectExpr::Array(ArraySelect::Indices(map)));
641                }
642            }
643            self.i = save;
644        }
645        if !allow_multi_list {
646            return Err(Error::InvalidPath {
647                msg: "Invalid bracket suffix",
648            });
649        }
650        // multi-select list
651        let mut items = Vec::new();
652        loop {
653            items.push(self.parse_pipe()?);
654            self.skip_ws();
655            match self.peek() {
656                Some(',') => {
657                    self.bump();
658                    continue;
659                }
660                Some(']') => {
661                    self.bump();
662                    break;
663                }
664                _ => {
665                    return Err(Error::InvalidPath {
666                        msg: "Expected ',' or ']' in multi-select list",
667                    });
668                }
669            }
670        }
671        Ok(SelectExpr::MultiSelectList(items))
672    }
673
674    fn parse_dq_string_raw(&mut self) -> Result<String, Error> {
675        self.eat('"')?;
676        let mut out = String::new();
677        while let Some(c) = self.bump() {
678            match c {
679                '"' => return Ok(out),
680                '\\' => {
681                    let e = self.bump().ok_or(Error::InvalidPath {
682                        msg: "Bad escape",
683                    })?;
684                    match e {
685                        '"' | '\\' | '/' => out.push(e),
686                        'b' => out.push('\u{0008}'),
687                        'f' => out.push('\u{000c}'),
688                        'n' => out.push('\n'),
689                        't' => out.push('\t'),
690                        'r' => out.push('\r'),
691                        'u' => {
692                            let ch = self.parse_unicode_escape()?;
693                            out.push(ch);
694                        }
695                        other => out.push(other),
696                    }
697                }
698                c => out.push(c),
699            }
700        }
701        Err(Error::InvalidPath {
702            msg: "Unclosed string",
703        })
704    }
705
706    /// Parse `\uXXXX` (and surrogate pairs) after the `u` has already been consumed.
707    fn parse_unicode_escape(&mut self) -> Result<char, Error> {
708        let hi = self.read_u4_hex()?;
709        if (0xD800..=0xDBFF).contains(&hi) {
710            // High surrogate — require `\u` low surrogate.
711            if self.peek() != Some('\\') {
712                return Err(Error::InvalidPath {
713                    msg: "Lone UTF-16 high surrogate in quoted identifier",
714                });
715            }
716            self.bump();
717            if self.peek() != Some('u') {
718                return Err(Error::InvalidPath {
719                    msg: "Expected \\u after high surrogate",
720                });
721            }
722            self.bump();
723            let lo = self.read_u4_hex()?;
724            if !(0xDC00..=0xDFFF).contains(&lo) {
725                return Err(Error::InvalidPath {
726                    msg: "Invalid UTF-16 low surrogate",
727                });
728            }
729            let cp = 0x10000 + (((u32::from(hi) - 0xD800) << 10) | (u32::from(lo) - 0xDC00));
730            char::from_u32(cp).ok_or(Error::InvalidPath {
731                msg: "Invalid Unicode code point",
732            })
733        } else if (0xDC00..=0xDFFF).contains(&hi) {
734            Err(Error::InvalidPath {
735                msg: "Lone UTF-16 low surrogate in quoted identifier",
736            })
737        } else {
738            char::from_u32(u32::from(hi)).ok_or(Error::InvalidPath {
739                msg: "Invalid Unicode code point",
740            })
741        }
742    }
743
744    fn read_u4_hex(&mut self) -> Result<u16, Error> {
745        let mut v = 0u16;
746        for _ in 0..4 {
747            let c = self.bump().ok_or(Error::InvalidPath {
748                msg: "Incomplete \\u escape",
749            })?;
750            let dig = c.to_digit(16).ok_or(Error::InvalidPath {
751                msg: "Invalid hex in \\u escape",
752            })?;
753            v = (v << 4) | dig as u16;
754        }
755        Ok(v)
756    }
757
758    fn parse_raw_string_literal(&mut self) -> Result<SelectExpr, Error> {
759        let raw = self.parse_raw_string_raw()?;
760        Ok(SelectExpr::Literal(encode_json_string(&raw)))
761    }
762
763    fn parse_raw_string_raw(&mut self) -> Result<String, Error> {
764        self.eat('\'')?;
765        let mut out = String::new();
766        while let Some(c) = self.bump() {
767            // Match jmespath.rs: on `\`, always take the next char into the buffer
768            // (so `\'` keeps both chars, `\\` keeps both). Closing `'` is only when
769            // unescaped. Then replace `\'` → `'`.
770            if c == '\\' {
771                out.push('\\');
772                if let Some(n) = self.bump() {
773                    out.push(n);
774                }
775            } else if c == '\'' {
776                return Ok(out.replace("\\'", "'"));
777            } else {
778                out.push(c);
779            }
780        }
781        Err(Error::InvalidPath {
782            msg: "Unclosed raw string",
783        })
784    }
785
786    fn parse_backtick_literal(&mut self) -> Result<SelectExpr, Error> {
787        self.eat('`')?;
788        let mut raw = String::new();
789        while let Some(c) = self.peek() {
790            if c == '`' {
791                self.bump();
792                let inner = raw.trim();
793                // JSON fragment on the wire. Only `\`` is a JMESPath escape inside
794                // backticks; other backslashes are JSON escapes and must be preserved.
795                return Ok(SelectExpr::Literal(inner.as_bytes().to_vec()));
796            }
797            if c == '\\' {
798                self.bump();
799                match self.peek() {
800                    Some('`') => {
801                        self.bump();
802                        raw.push('`');
803                    }
804                    Some(e) => {
805                        // Preserve JSON escape sequences (\u, \", \\, …).
806                        raw.push('\\');
807                        raw.push(e);
808                        self.bump();
809                    }
810                    None => raw.push('\\'),
811                }
812            } else {
813                raw.push(c);
814                self.bump();
815            }
816        }
817        Err(Error::InvalidPath {
818            msg: "Unclosed backtick literal",
819        })
820    }
821
822    fn parse_number_literal(&mut self) -> Result<SelectExpr, Error> {
823        self.skip_ws();
824        let start = self.i;
825        if self.peek() == Some('-') {
826            self.bump();
827        }
828        while self.peek().is_some_and(|c| c.is_ascii_digit()) {
829            self.bump();
830        }
831        if self.peek() == Some('.') {
832            self.bump();
833            while self.peek().is_some_and(|c| c.is_ascii_digit()) {
834                self.bump();
835            }
836        }
837        let lit = self.s.as_bytes()[start..self.i].to_vec();
838        if lit.is_empty() || lit == b"-" {
839            return Err(Error::InvalidPath {
840                msg: "Invalid number literal",
841            });
842        }
843        Ok(SelectExpr::Literal(lit))
844    }
845}
846
847fn encode_json_string(raw: &str) -> Vec<u8> {
848    let mut bytes = Vec::with_capacity(raw.len() + 2);
849    bytes.push(b'"');
850    for b in raw.bytes() {
851        match b {
852            b'"' | b'\\' => {
853                bytes.push(b'\\');
854                bytes.push(b);
855            }
856            c if c < 0x20 => bytes.extend_from_slice(format!("\\u{c:04x}").as_bytes()),
857            c => bytes.push(c),
858        }
859    }
860    bytes.push(b'"');
861    bytes
862}
863
864fn is_ident_start(c: char) -> bool {
865    c.is_ascii_alphabetic() || c == '_'
866}
867
868fn is_json_number_lit(b: &[u8]) -> bool {
869    let t = b.trim_ascii();
870    if t.is_empty() {
871        return false;
872    }
873    t.iter()
874        .all(|c| c.is_ascii_digit() || *c == b'-' || *c == b'+' || *c == b'.' || *c == b'e' || *c == b'E')
875        && t.iter().any(|c| c.is_ascii_digit())
876}
877
878fn is_ident_continue(c: char) -> bool {
879    c.is_ascii_alphanumeric() || c == '_'
880}
881
882fn chain_sub(prefix: SelectExpr, suffix: SelectExpr) -> SelectExpr {
883    // `expr[]` → Flatten(expr)  (jmespath: Projection(Flatten(expr), Identity))
884    if let SelectExpr::Flatten(inner) = &suffix {
885        if matches!(inner.as_ref(), SelectExpr::Identity | SelectExpr::Current) {
886            return SelectExpr::Flatten(Box::new(prefix));
887        }
888        return SelectExpr::Flatten(Box::new(chain_sub(prefix, *inner.clone())));
889    }
890    match prefix {
891        SelectExpr::Field(name) => {
892            SelectExpr::Sub(Box::new(SelectExpr::Field(name)), Box::new(suffix))
893        }
894        SelectExpr::FieldQuoted(name) => {
895            SelectExpr::Sub(Box::new(SelectExpr::FieldQuoted(name)), Box::new(suffix))
896        }
897        SelectExpr::ObjectProjection(inner) => {
898            // foo.*.bar → project each object value with .bar
899            SelectExpr::ObjectProjection(Box::new(chain_into(*inner, suffix)))
900        }
901        // `foo[].bar` → Sub(Flatten(foo), Each(bar))
902        // (jmespath: Projection(Flatten(foo), bar))
903        SelectExpr::Flatten(inner) => SelectExpr::Sub(
904            Box::new(SelectExpr::Flatten(inner)),
905            Box::new(SelectExpr::Array(ArraySelect::Each(Box::new(suffix)))),
906        ),
907        SelectExpr::Array(ArraySelect::Each(inner)) => {
908            SelectExpr::Array(ArraySelect::Each(Box::new(chain_into(*inner, suffix))))
909        }
910        SelectExpr::Array(ArraySelect::Slice {
911            start,
912            end,
913            step,
914            each,
915        }) => SelectExpr::Array(ArraySelect::Slice {
916            start,
917            end,
918            step,
919            each: Box::new(chain_into(*each, suffix)),
920        }),
921        SelectExpr::Array(ArraySelect::Filter { pred, each }) => {
922            SelectExpr::Array(ArraySelect::Filter {
923                pred,
924                each: Box::new(chain_into(*each, suffix)),
925            })
926        }
927        SelectExpr::Array(ArraySelect::Indices(mut map)) if map.len() == 1 => {
928            let (k, v) = map.drain().next().unwrap();
929            map.insert(k, chain_into(v, suffix));
930            SelectExpr::Array(ArraySelect::Indices(map))
931        }
932        SelectExpr::Sub(left, right) => {
933            SelectExpr::Sub(left, Box::new(chain_into(*right, suffix)))
934        }
935        SelectExpr::Expref(inner) => SelectExpr::Expref(Box::new(chain_into(*inner, suffix))),
936        SelectExpr::Paren(inner) => chain_sub(*inner, suffix),
937        other => SelectExpr::Sub(Box::new(other), Box::new(suffix)),
938    }
939}
940
941fn chain_into(inner: SelectExpr, suffix: SelectExpr) -> SelectExpr {
942    if matches!(inner, SelectExpr::Identity | SelectExpr::Current) {
943        suffix
944    } else {
945        chain_sub(inner, suffix)
946    }
947}