feat: implement mapping language parser with AST and expression support (#44)

- Define AST types: Program, Statement (Rename, Select, Drop, Set,
  Default, Cast), Expr (Literal, Path, FunctionCall, BinaryOp, UnaryOp),
  Path with segments (Field, Index, Wildcard), CastType, BinOp, UnaryOp
- Implement recursive descent parser with precedence climbing for
  expressions: or < and < comparison < additive < multiplicative < unary
- Parse all 6 statement types with full syntax validation
- Support paths with nested fields, array indices, wildcards, and
  quoted string keys; keyword names allowed as field names
- Support expressions: literals (int, float, string, bool, null),
  path references, function calls (nested, multi-arg, zero-arg),
  binary ops (+, -, *, /, %, ==, !=, >, >=, <, <=, and, or),
  unary ops (not, -), and parenthesized grouping
- Cast type aliases: integer/int, float/number, string/str, bool/boolean
- Error messages with line:column positions and keyword suggestions
- Add 60+ tests covering: all statement types, literal types, paths
  (nested, array index, wildcard, quoted key, keyword field), function
  calls (single/multi/zero/nested args), all operators, precedence
  (mul before add, parens override, comparison after arithmetic, and
  before or), unary not, multi-statement programs, blank lines, comments,
  empty programs, string concatenation, error cases (missing arrow,
  missing =, unknown keyword, typo suggestions, missing path, unknown
  cast type, incomplete statements), and a complex 7-statement program

Fixes #16

Author: alvinreal

src/mapping/ast.rs

@@ -1 +1,103 @@
-// TODO: Mapping language AST types
+use crate::mapping::lexer::Span;
+
+/// A field path like `.name`, `.users.[0].name`, or `.a.b.c`.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Path {
+    pub segments: Vec<PathSegment>,
+    pub span: Span,
+}
+
+/// A single segment in a field path.
+#[derive(Debug, Clone, PartialEq)]
+pub enum PathSegment {
+    /// A named field: `.name`
+    Field(String),
+    /// An array index: `.[0]`
+    Index(i64),
+    /// A wildcard: `.[*]`
+    Wildcard,
+}
+
+/// The target type for cast operations.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum CastType {
+    Int,
+    Float,
+    String,
+    Bool,
+}
+
+/// A binary operator.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BinOp {
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Mod,
+    Eq,
+    NotEq,
+    Gt,
+    GtEq,
+    Lt,
+    LtEq,
+    And,
+    Or,
+}
+
+/// A unary operator.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum UnaryOp {
+    Neg,
+    Not,
+}
+
+/// An expression in the mapping language.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Expr {
+    /// A literal value: `42`, `"hello"`, `true`, `null`.
+    Literal(crate::value::Value),
+    /// A path reference: `.name`, `.users.[0].age`.
+    Path(Path),
+    /// A function call: `lower(.name)`, `replace(.s, "a", "b")`.
+    FunctionCall {
+        name: String,
+        args: Vec<Expr>,
+        span: Span,
+    },
+    /// A binary operation: `.a + .b`, `.x == 42`.
+    BinaryOp {
+        left: Box<Expr>,
+        op: BinOp,
+        right: Box<Expr>,
+    },
+    /// A unary operation: `not .active`, `-.value`.
+    UnaryOp { op: UnaryOp, expr: Box<Expr> },
+}
+
+/// A statement in the mapping language.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Statement {
+    /// `rename .old -> .new`
+    Rename { from: Path, to: Path, span: Span },
+    /// `select .a, .b, .c`
+    Select { paths: Vec<Path>, span: Span },
+    /// `drop .x, .y`
+    Drop { paths: Vec<Path>, span: Span },
+    /// `set .x = <expr>`
+    Set { path: Path, expr: Expr, span: Span },
+    /// `default .x = <expr>`
+    Default { path: Path, expr: Expr, span: Span },
+    /// `cast .x as int`
+    Cast {
+        path: Path,
+        target_type: CastType,
+        span: Span,
+    },
+}
+
+/// A parsed mapping program: a list of statements.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Program {
+    pub statements: Vec<Statement>,
+}