skullbrain-parser 0.1.0

use super::*;
use cstree::text::TextRange;

/// A trait for types that have a defined textual span within the source code.
pub trait Span {
    /// Returns the `TextRange` corresponding to the element's position
    /// in the source code.
    fn span(&self) -> TextRange;
}

impl Span for Ident {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for Literal {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for BinaryExpr {
    fn span(&self) -> TextRange {
        self.left().span().cover(self.right().span())
    }
}
impl Span for UnaryExpr {
    fn span(&self) -> TextRange {
        self.expr.span()
    }
}
impl Span for ChainExpr {
    fn span(&self) -> TextRange {
        self.object().span().cover(self.method().span())
    }
}
impl Span for ParenExpr {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for BlockExpr {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for Break {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for Continue {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for Return {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for Throw {
    fn span(&self) -> TextRange {
        self.span
    }
}

impl Span for While {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for ForLoop {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for TryCatch {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for CatchArm {
    fn span(&self) -> TextRange {
        self.span
    }
}

impl Span for VariableStmt {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for TypeAlias {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for Type {
    fn span(&self) -> TextRange {
        match self {
            Type::Ident(ident) => ident.span,
            Type::Function(function_signature) => function_signature.span(),
        }
    }
}

impl Span for FunctionSignature {
    fn span(&self) -> TextRange {
        self.span
    }
}

impl Span for IfElse {
    fn span(&self) -> TextRange {
        self.span
    }
}

impl Span for ElseBranch {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for Match {
    fn span(&self) -> TextRange {
        self.span
    }
}

impl Span for ImportStmt {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for Function {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for FunctionItem {
    fn span(&self) -> TextRange {
        self.span
    }
}

impl Span for Enum {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for Class {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for Trait {
    fn span(&self) -> TextRange {
        self.span
    }
}
impl Span for TraitImpl {
    fn span(&self) -> TextRange {
        self.span
    }
}

impl Span for Expr {
    fn span(&self) -> TextRange {
        match self {
            Expr::Literal(literal) => literal.span(),
            Expr::Ident(ident) => ident.span(),
            Expr::Binary(binary_expr) => binary_expr.span(),
            Expr::Unary(unary_expr) => unary_expr.span(),
            Expr::Chain(chain_expr) => chain_expr.span(),
            Expr::Paren(paren_expr) => paren_expr.span(),
            Expr::Block(block_expr) => block_expr.span(),
            Expr::Break(v) => v.span(),
            Expr::Continue(v) => v.span(),
            Expr::Return(v) => v.span(),
            Expr::Throw(throw) => throw.span(),
            Expr::While(v) => v.span(),
            Expr::For(for_loop) => for_loop.span(),
            Expr::If(if_else) => if_else.span(),
            Expr::Match(v) => v.span(),
            Expr::TryCatch(try_catch) => try_catch.span(),
            Expr::Variable(variable_stmt) => variable_stmt.span(),
            Expr::Function(function) => function.span(),
            Expr::Class(class) => class.span(),
            Expr::Trait(v) => v.span(),
            Expr::TraitImpl(trait_impl) => trait_impl.span(),
            Expr::Enum(v) => v.span(),
            Expr::TypeAlias(type_alias) => type_alias.span(),
            Expr::Import(import_stmt) => import_stmt.span(),
        }
    }
}