xlang-syntax 0.0.2-alpha

/// The location of an expression.
pub type Loc = std::ops::Range<usize>;

/// A trait which can locate an expression in its source file.
pub trait Locate {
    /// Returns the location of this expression.
    fn loc(&self) -> Loc;
}

/// A **`none`** value.
#[derive(Clone, Debug, PartialEq)]
pub struct None {
    pub loc: Loc,
}

impl None {
    /// Creates a new **`none`** value.
    pub fn new(loc: Loc) -> Self {
        Self { loc }
    }
}

impl Locate for None {
    fn loc(&self) -> Loc {
        self.loc.clone()
    }
}

/// A boolean constant.
#[derive(Clone, Debug, PartialEq)]
pub struct Bool<'input> {
    pub loc: Loc,
    pub value: &'input str,
}

impl<'input> Bool<'input> {
    /// Creates a new boolean constant.
    pub fn new(loc: Loc, value: &'input str) -> Self {
        Self { loc, value }
    }
}

impl<'input> Locate for Bool<'input> {
    fn loc(&self) -> Loc {
        self.loc.clone()
    }
}

/// The kind of a number.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum NumKind {
    /// A plain decimal integer.
    /// 
    /// ```xlang
    /// 042
    /// 1_000_000
    /// ```
    Dec,

    /// A hexadecimal integer.
    /// 
    /// ```xlang
    /// 0x123456
    /// 0xabcdef
    /// 0xa_b_c_d_e_f
    /// ```
    Hex,

    /// A binary integer.
    /// 
    /// ```xlang
    /// 0b0100_0001
    /// ```
    Bin,

    /// An octal integer.
    /// 
    /// ```xlang
    /// 0o01234567
    /// ```
    Oct,

    /// A floating point number.
    /// 
    /// ```xlang
    /// 0.
    /// 0.42
    /// 4.2e1
    /// ```
    Float,
}

/// A number constant.
#[derive(Clone, Debug, PartialEq)]
pub struct Num<'input> {
    pub loc: Loc,
    pub kind: NumKind,
    pub value: &'input str,
}

impl<'input> Num<'input> {
    /// Creates a new decimal integer number.
    pub fn dec(loc: Loc, value: &'input str) -> Self {
        Self { loc, kind: NumKind::Dec, value }
    }

    /// Creates a new hexadecimal integer number.
    pub fn hex(loc: Loc, value: &'input str) -> Self {
        Self { loc, kind: NumKind::Hex, value }
    }

    /// Creates a new binary integer number.
    pub fn bin(loc: Loc, value: &'input str) -> Self {
        Self { loc, kind: NumKind::Bin, value }
    }

    /// Creates a new octal integer number.
    pub fn oct(loc: Loc, value: &'input str) -> Self {
        Self { loc, kind: NumKind::Oct, value }
    }

    /// Creates a new floating point number.
    pub fn float(loc: Loc, value: &'input str) -> Self {
        Self { loc, kind: NumKind::Float, value }
    }
}

impl<'input> Locate for Num<'input> {
    fn loc(&self) -> Loc {
        self.loc.clone()
    }
}

/// An identifier literal.
#[derive(Clone, Debug, PartialEq)]
pub struct Ident<'input> {
    pub loc: Loc,
    pub value: &'input str,
}

impl<'input> Ident<'input> {
    /// Creates a new identifier literal.
    pub fn new(loc: Loc, value: &'input str) -> Self {
        Self { loc, value }
    }
}

impl<'input> Locate for Ident<'input> {
    fn loc(&self) -> Loc {
        self.loc.clone()
    }
}

/// An atom constant.
#[derive(Clone, Debug, PartialEq)]
pub struct Atom<'input> {
    pub loc: Loc,
    pub value: &'input str,
}

impl<'input> Atom<'input> {
    /// Creates a new atom constant.
    pub fn new(loc: Loc, value: &'input str) -> Self {
        Self { loc, value }
    }
}

impl<'input> Locate for Atom<'input> {
    fn loc(&self) -> Loc {
        self.loc.clone()
    }
}

/// A string literal.
#[derive(Clone, Debug, PartialEq)]
pub struct Str<'input> {
    pub loc: Loc,
    pub value: &'input str,
}

impl<'input> Str<'input> {
    /// Creates a new string literal.
    pub fn new(loc: Loc, value: &'input str) -> Self {
        Self { loc, value }
    }
}

impl<'input> Locate for Str<'input> {
    fn loc(&self) -> Loc {
        self.loc.clone()
    }
}

/// A operator which takes two operands.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum BinaryOp {
    /// **`.`**
    /// 
    /// ```xlang
    /// my_value.my_value2
    /// ```
    ObjIdx,
    
    /// **`::`**
    /// 
    /// ```xlang
    /// my_value::my_value2
    /// ```
    StaticIdx,

    /// **`[..]`**
    /// 
    /// ```xlang
    /// my_value["my_value2"]
    /// ```
    ExprIdx,

    /// **`*`**
    /// 
    /// ```xlang
    /// 42 * 2 // => 84
    /// ```
    Mul,

    /// **`/`**
    /// 
    /// ```xlang
    /// 42 / 2 // => 21
    /// ```
    Div,

    /// **`%`**
    /// 
    /// ```xlang
    /// 100 % 1 == 0
    /// ```
    Mod,

    /// **`+`**
    /// 
    /// ```xlang
    /// 1 + 1 == 2
    /// ```
    Add,

    /// **`-`**
    /// 
    /// ```xlang
    /// 1 - 1 == 0
    /// ```
    Sub,

    /// **`<<`**
    /// 
    /// ```xlang
    /// 0b01 << 1 == 0b10
    /// ```
    Shl,

    /// **`>>`**
    /// 
    /// ```xlang
    /// 0b10 >> 1 == 0b01
    /// ```
    Shr,

    /// **`&`**
    /// 
    /// ```
    /// 0b101 & 0b011 == 0b001 // => true
    /// ```
    BitAnd,

    /// **`^`**
    /// 
    /// ```
    /// 0b101 & 0b011 == 0b110 // => true
    /// ```
    BitXor,

    /// **`|`**
    /// 
    /// ```
    /// 0b101 | 0b011 == 0b111 // => true
    /// ```
    BitOr,

    /// **`==`**
    /// 
    /// ```xlang
    /// 1 == 1 // => true
    /// ```
    Eq,

    /// **`!=`**
    /// 
    /// ```xlang
    /// 1 != 1 // => false
    /// ```
    Neq,

    /// **`<`**
    /// 
    /// ```xlang
    /// 0 < 1 // => true
    /// ```
    Lt,

    /// **`>`**
    /// 
    /// ```xlang
    /// 0 > 1 // => false
    /// ```
    Gt,

    /// **`<=`**
    /// 
    /// ```xlang
    /// 0 <= 1 // => true
    /// 0 <= 0 // => true
    /// 0 <= -1 // => false
    /// ```
    LtEq,

    /// **`>=`**
    /// 
    /// ```xlang
    /// 0 >= 1 // => false
    /// 0 >= 0 // => false
    /// 0 >= -1 // => true
    /// ```
    GtEq,

    /// **`&&`**
    /// 
    /// ```xlang
    /// 1 > 0 && 0 < 1 // => true
    /// ```
    And,

    /// **`||`**
    /// 
    /// ```xlang
    /// false || true // => true
    /// ```
    Or,
}

/// A binary operation.
#[derive(Clone, Debug, PartialEq)]
pub struct Binary<'input> {
    pub loc: Loc,
    pub op: BinaryOp,
    pub left: Box<Expr<'input>>,
    pub right: Box<Expr<'input>>,
}

impl<'input> Binary<'input> {
    /// Creates a new binary operation.
    pub fn new(loc: Loc, op: BinaryOp, left: Box<Expr<'input>>, right: Box<Expr<'input>>) -> Self {
        Self { loc, op, left, right }
    }
}

impl<'input> Locate for Binary<'input> {
    fn loc(&self) -> Loc {
        self.loc.clone()
    }
}

/// A function call.
#[derive(Clone, Debug, PartialEq)]
pub struct Call<'input> {
    pub loc: Loc,
    pub fun: Box<Expr<'input>>,
    pub args: Vec<Expr<'input>>,
}

impl<'input> Call<'input> {
    /// Creates a new function call operation.
    pub fn new(loc: Loc, fun: Box<Expr<'input>>, args: Vec<Expr<'input>>) -> Self {
        Self { loc, fun, args }
    }
}

impl<'input> Locate for Call<'input> {
    fn loc(&self) -> Loc {
        self.loc.clone()
    }
}

/// An operator which takes only one operand.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum UnaryOp {
    /// **`.deref`**
    Deref,

    /// **`.cloned`**
    Cloned,

    /// **`+`**
    Pos,

    /// **`-`**
    Neg,

    /// **`!`**
    Not,

    /// **`~`**
    BitNot,
}

/// A unary operation.
#[derive(Clone, Debug, PartialEq)]
pub struct Unary<'input> {
    pub loc: Loc,
    pub op: UnaryOp,
    pub subject: Box<Expr<'input>>,
}

impl<'input> Unary<'input> {
    /// Creates a new unary operation.
    pub fn new(loc: Loc, op: UnaryOp, subject: Box<Expr<'input>>) -> Self {
        Self { loc, op, subject }
    }
}

impl<'input> Locate for Unary<'input> {
    fn loc(&self) -> Loc {
        self.loc.clone()
    }
}

/// An assignment operator.
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum AssignOp {
    Assign,
    AssignAdd,
    AssignSub,
    AssignMul,
    AssignDiv,
    AssignMod,
    AssignBitOr,
    AssignBitXor,
    AssignShl,
    AssignShr,
}

/// An assignment operation.
#[derive(Clone, Debug, PartialEq)]
pub struct Assign<'input> {
    pub loc: Loc,
    pub op: AssignOp,
    pub left: Box<Expr<'input>>,
    pub right: Box<Expr<'input>>,
}

impl<'input> Assign<'input> {
    /// Creates a new assignment operation.
    pub fn new(loc: Loc, op: AssignOp, left: Box<Expr<'input>>, right: Box<Expr<'input>>) -> Self {
        Self { loc, op, left, right }
    }
}

impl<'input> Locate for Assign<'input> {
    fn loc(&self) -> Loc {
        self.loc.clone()
    }
}

/// A code block.
#[derive(Clone, Debug, PartialEq)]
pub struct Block<'input> {
    pub loc: Loc,
    pub action: Vec<Expr<'input>>,
}

impl<'input> Block<'input> {
    /// Creates a new code block.
    pub fn new(loc: Loc, action: Vec<Expr<'input>>) -> Self {
        Self { loc, action }
    }
}

impl<'input> Locate for Block<'input> {
    fn loc(&self) -> Loc {
        self.loc.clone()
    }
}

/// An **`else if`** branch.
#[derive(Clone, Debug, PartialEq)]
pub struct ElseIf<'input> {
    pub loc: Loc,
    pub cond: Box<Expr<'input>>,
    pub block: Block<'input>,
}

impl<'input> ElseIf<'input> {
    /// Creates a new **`else if`** branch.
    pub fn new(loc: Loc, cond: Box<Expr<'input>>, block: Block<'input>) -> Self {
        Self { loc, cond, block }
    }
}

impl<'input> Locate for ElseIf<'input> {
    fn loc(&self) -> Loc {
        self.loc.clone()
    }
}

/// An **`else`** branch.
#[derive(Clone, Debug, PartialEq)]
pub struct Else<'input> {
    pub loc: Loc,
    pub block: Block<'input>,
}

impl<'input> Else<'input> {
    /// Creates a new **`else`** branch.
    pub fn new(loc: Loc, block: Block<'input>) -> Self {
        Self { loc, block }
    }
}

impl<'input> Locate for Else<'input> {
    fn loc(&self) -> Loc {
        self.loc.clone()
    }
}

/// A branch from an **`if`** statement.
#[derive(Clone, Debug, PartialEq)]
pub enum IfBranch<'input> {
    ElseIf(ElseIf<'input>),
    Else(Else<'input>),
}

impl<'input> Locate for IfBranch<'input> {
    fn loc(&self) -> Loc {
        match self {
            Self::ElseIf(branch) => branch.loc(),
            Self::Else(branch) => branch.loc(),
        }
    }
}

/// An **`if`** statement.
#[derive(Clone, Debug, PartialEq)]
pub struct If<'input> {
    pub loc: Loc,
    pub label: Option<Ident<'input>>,
    pub cond: Box<Expr<'input>>,
    pub block: Block<'input>,
    pub branches: Vec<IfBranch<'input>>,
}

impl<'input> If<'input> {
    /// Creates a new **`if`** statement.
    pub fn new(loc: Loc, label: Option<Ident<'input>>, cond: Box<Expr<'input>>, block: Block<'input>, branches: Vec<IfBranch<'input>>) -> Self {
        Self { loc, label, cond, block, branches }
    }
}

impl<'input> Locate for If<'input> {
    fn loc(&self) -> Loc {
        self.loc.clone()
    }
}

/// An inline function.
#[derive(Clone, Debug, PartialEq)]
pub struct InlineFun<'input> {
    pub loc: Loc,
    pub args: Vec<Ident<'input>>,
    pub block: Block<'input>,
}

impl<'input> InlineFun<'input> {
    /// Creates a new function value.
    pub fn new(loc: Loc, args: Vec<Ident<'input>>, block: Block<'input>) -> Self {
        Self { loc, args, block }
    }
}

impl<'input> Locate for InlineFun<'input> {
    fn loc(&self) -> Loc {
        self.loc.clone()
    }
}

/// A function declaration.
#[derive(Clone, Debug, PartialEq)]
pub struct Fun<'input> {
    pub loc: Loc,
    pub publ: bool,
    pub name: Ident<'input>,
    pub args: Vec<Ident<'input>>,
    pub block: Block<'input>,
}

impl<'input> Fun<'input> {
    /// Creates a new function value.
    pub fn new(loc: Loc, publ: bool, name: Ident<'input>, args: Vec<Ident<'input>>, block: Block<'input>) -> Self {
        Self { loc, publ, name, args, block }
    }
}

impl<'input> Locate for Fun<'input> {
    fn loc(&self) -> Loc {
        self.loc.clone()
    }
}

/// An *xlang* expression.
#[derive(Clone, Debug, PartialEq)]
pub enum Expr<'input> {
    None(None),
    Bool(Bool<'input>),
    Num(Num<'input>),
    Ident(Ident<'input>),
    Atom(Atom<'input>),
    Str(Str<'input>),
    Binary(Binary<'input>),
    Call(Call<'input>),
    Unary(Unary<'input>),
    Assign(Assign<'input>),
    If(If<'input>),
    InlineFun(InlineFun<'input>),
    Fun(Fun<'input>),
    Block(Block<'input>),
}

impl<'input> Expr<'input> {
    /// Creates a new **`none`** expression.
    #[inline]
    pub fn none(loc: Loc) -> Self {
        Self::None(None::new(loc))
    }

    /// Creates a new boolean expression.
    #[inline]
    pub fn bool(loc: Loc, value: &'input str) -> Self {
        Self::Bool(Bool::new(loc, value))
    }

    /// Creates a new decimal integer expression.
    #[inline]
    pub fn dec(loc: Loc, value: &'input str) -> Self {
        Self::Num(Num::dec(loc, value))
    }

    /// Creates a new hexadecimal integer expression.
    #[inline]
    pub fn hex(loc: Loc, value: &'input str) -> Self {
        Self::Num(Num::hex(loc, value))
    }

    /// Creates a new binary integer expression.
    #[inline]
    pub fn bin(loc: Loc, value: &'input str) -> Self {
        Self::Num(Num::bin(loc, value))
    }

    /// Creates a new octal integer expression.
    #[inline]
    pub fn oct(loc: Loc, value: &'input str) -> Self {
        Self::Num(Num::oct(loc, value))
    }

    /// Creates a new floating point number expression.
    #[inline]
    pub fn float(loc: Loc, value: &'input str) -> Self {
        Self::Num(Num::float(loc, value))
    }

    /// Creates a new identifier expression.
    #[inline]
    pub fn ident(loc: Loc, value: &'input str) -> Self {
        Self::Ident(Ident::new(loc, value))
    }

    /// Creates a new atom expression.
    #[inline]
    pub fn atom(loc: Loc, value: &'input str) -> Self {
        Self::Ident(Ident::new(loc, value))
    }

    /// Creates a new string expression.
    #[inline]
    pub fn str(loc: Loc, value: &'input str) -> Self {
        Self::Str(Str::new(loc, value))
    }

    /// Creates a new binary operation.
    #[inline]
    pub fn binary(loc: Loc, left: Self, op: BinaryOp, right: Self) -> Self {
        Self::Binary(Binary::new(loc, op, Box::new(left), Box::new(right)))
    }

    /// Creates a new function call operation.
    #[inline]
    pub fn call(loc: Loc, fun: Self, args: Vec<Self>) -> Self {
        Self::Call(Call::new(loc, Box::new(fun), args))
    }

    /// Creates a new function call operation.
    #[inline]
    pub fn unary(loc: Loc, op: UnaryOp, subject: Self) -> Self {
        Self::Unary(Unary::new(loc, op, Box::new(subject)))
    }

    /// Creates a new assignment operation.
    #[inline]
    pub fn assign(loc: Loc, left: Self, op: AssignOp, right: Self) -> Self {
        Self::Assign(Assign::new(loc, op, Box::new(left), Box::new(right)))
    }
}

impl<'input> Locate for Expr<'input> {
    fn loc(&self) -> Loc {
        match self {
            Expr::None(expr) => expr.loc(),
            Expr::Bool(expr) => expr.loc(),
            Expr::Num(expr) => expr.loc(),
            Expr::Ident(expr) => expr.loc(),
            Expr::Atom(expr) => expr.loc(),
            Expr::Str(expr) => expr.loc(),
            Expr::Binary(expr) => expr.loc(),
            Expr::Call(expr) => expr.loc(),
            Expr::Unary(expr) => expr.loc(),
            Expr::Assign(expr) => expr.loc(),
            Expr::If(expr) => expr.loc(),
            Expr::InlineFun(expr) => expr.loc(),
            Expr::Fun(expr) => expr.loc(),
            Expr::Block(expr) => expr.loc(),
        }
    }
}