Struct flexi_parse::token::Ident

pub struct Ident { /* private fields */ }

An identifier consisting of alphanumeric characters and underscores, and starting with an alphabetic character or an underscore.

Implementations

impl Ident

pub const fn string(&self) -> &String

Returns the text that makes up the identifier.

Examples found in repository

examples/lox/resolver.rs (line 40)

    fn declare(&mut self, name: &Ident) {
        if let Some(scope) = self.scopes.last_mut() {
            if scope.contains_key(name.string()) {
                self.error(new_error(
                    "Already a variable with this name in scope".to_string(),
                    name,
                    error_codes::SHADOW,
                ));
            } else {
                scope.insert(name.string().to_owned(), false);
            }
        }
    }

    fn define(&mut self, name: &Ident) {
        if let Some(scope) = self.scopes.last_mut() {
            scope.insert(name.string().to_owned(), true);
        }
    }

    fn resolve_local(&self, name: &Ident, distance: &Cell<Option<usize>>) {
        for (i, scope) in self.scopes.iter().enumerate().rev() {
            if scope.contains_key(name.string()) {
                distance.set(Some(self.scopes.len() - 1 - i));
                return;
            }
        }
    }

    fn error(&mut self, error: Error) {
        if let Some(existing_error) = &mut self.error {
            existing_error.add(error);
        } else {
            self.error = Some(error);
        }
    }

    fn begin_scope(&mut self) {
        self.scopes.push(HashMap::new());
    }

    fn end_scope(&mut self) {
        self.scopes.pop();
    }
}

impl Expr {
    fn resolve(&self, state: &mut State) {
        match self {
            Expr::Assign {
                name,
                value,
                distance,
            } => {
                value.resolve(state);
                state.resolve_local(name, distance);
            }
            Expr::Binary(binary) => {
                binary.left().resolve(state);
                binary.right().resolve(state);
            }
            Expr::Call {
                callee,
                paren: _,
                arguments,
            } => {
                callee.resolve(state);
                for argument in arguments {
                    argument.resolve(state);
                }
            }
            Expr::Get { object, name: _ } => object.resolve(state),
            Expr::Group(expr) => expr.resolve(state),
            Expr::Literal(_) => {}
            Expr::Logical(logical) => {
                logical.left().resolve(state);
                logical.right().resolve(state);
            }
            Expr::Set {
                object,
                name: _,
                value,
            } => {
                object.resolve(state);
                value.resolve(state);
            }
            Expr::Super {
                keyword,
                distance,
                dot: _,
                method: _,
            } => {
                if state.current_class == ClassType::None {
                    state.error(new_error(
                        "Can't use 'super' outside of a class".to_string(),
                        keyword,
                        error_codes::INVALID_SUPER,
                    ));
                } else if state.current_class == ClassType::Class {
                    state.error(new_error(
                        "Can't use 'super' in a class with no superclass".to_string(),
                        keyword,
                        error_codes::INVALID_SUPER,
                    ));
                }
                state.resolve_local(keyword.ident(), distance);
            }
            Expr::This { keyword, distance } => {
                if state.current_class == ClassType::None {
                    state.error(new_error(
                        "Can't use 'this' outside of a class".to_string(),
                        keyword,
                        error_codes::THIS_OUTSIDE_CLASS,
                    ));
                }

                state.resolve_local(keyword.ident(), distance);
            }
            Expr::Unary(unary) => unary.right().resolve(state),
            Expr::Variable { name, distance } => {
                if let Some(scope) = state.scopes.last() {
                    if scope.get(name.string()) == Some(&false) {
                        state.error(new_error(
                            "Can't read a variable in its own intialiser".to_string(),
                            name,
                            error_codes::INVALID_INITIALISER,
                        ));
                    }
                }
                state.resolve_local(name, distance);
            }
        }
    }
}

impl Function {
    fn resolve(&self, state: &mut State, kind: FunctionType) {
        let enclosing = state.current_function;
        state.current_function = kind;
        state.begin_scope();
        for param in &self.params {
            state.declare(param);
            state.define(param);
        }
        for stmt in &self.body {
            stmt.resolve(state);
        }
        state.end_scope();
        state.current_function = enclosing;
    }
}

impl Stmt {
    fn resolve(&self, state: &mut State) {
        match self {
            Stmt::Block(stmts) => {
                state.begin_scope();
                for stmt in stmts {
                    stmt.resolve(state);
                }
                state.end_scope();
            }
            Stmt::Class {
                name,
                superclass,
                superclass_distance,
                methods,
            } => {
                let enclosing = state.current_class;
                state.current_class = ClassType::Class;

                state.declare(name);
                state.define(name);

                if let Some(superclass) = superclass {
                    if name.string() == superclass.string() {
                        state.error(new_error(
                            "A class can't inherit from itself".to_string(),
                            superclass,
                            error_codes::CYCLICAL_INHERITANCE,
                        ));
                    }

                    state.current_class = ClassType::SubClass;

                    state.resolve_local(superclass, superclass_distance);

                    state.begin_scope();
                    state
                        .scopes
                        .last_mut()
                        .unwrap()
                        .insert("super".to_string(), true);
                }

                state.begin_scope();
                state
                    .scopes
                    .last_mut()
                    .unwrap()
                    .insert("this".to_string(), true);

                for method in methods {
                    let kind = if method.name.string() == "init" {
                        FunctionType::Initialiser
                    } else {
                        FunctionType::Method
                    };
                    method.resolve(state, kind);
                }

                state.end_scope();

                if superclass.is_some() {
                    state.end_scope();
                }

                state.current_class = enclosing;
            }
            Stmt::Expr(expr) | Stmt::Print(expr) => expr.resolve(state),
            Stmt::Function(function) => {
                state.declare(&function.name);
                state.declare(&function.name);
                function.resolve(state, FunctionType::Function);
            }
            Stmt::If {
                condition,
                then_branch,
                else_branch,
            } => {
                condition.resolve(state);
                then_branch.resolve(state);
                if let Some(else_branch) = else_branch {
                    else_branch.resolve(state);
                }
            }
            Stmt::Return { keyword, value } => {
                if state.current_function == FunctionType::None {
                    state.error(new_error(
                        "Can't return from top-level code".to_string(),
                        keyword,
                        error_codes::RETURN_OUTSIDE_FUNCTION,
                    ));
                }
                if let Some(value) = value {
                    value.resolve(state);
                }
            }
            Stmt::Variable { name, initialiser } => {
                state.declare(name);
                if let Some(initialiser) = initialiser {
                    initialiser.resolve(state);
                }
                state.define(name);
            }
            Stmt::While { condition, body } => {
                condition.resolve(state);
                body.resolve(state);
            }
        }
    }

examples/lox/interpreter.rs (line 124)

    fn call(&self, arguments: Vec<Value>, parentheses: &Parentheses) -> Result<Value> {
        let state = self.closure.start_scope();
        if self.declaration.params.len() != arguments.len() {
            return Err(arity_error(
                parentheses,
                self.declaration.params.len(),
                arguments.len(),
            ));
        }
        for (name, arg) in self.declaration.params.iter().zip(arguments) {
            state
                .environment
                .borrow_mut()
                .define(name.string().to_owned(), arg);
        }
        for stmt in &self.declaration.body {
            if let Some(value) = stmt.execute(&state)? {
                return Ok(value);
            }
        }
        Ok(Value::Nil)
    }

    fn bind(&self, instance: &'static RefCell<Instance>) -> Function {
        let scope = self.closure.start_scope();
        scope
            .environment
            .borrow_mut()
            .define("this".to_string(), Value::Instance(instance));
        Function {
            declaration: self.declaration.clone(),
            closure: scope,
            is_initialiser: self.is_initialiser,
        }
    }
}

impl PartialEq for Function {
    fn eq(&self, other: &Self) -> bool {
        self.declaration == other.declaration
    }
}

#[derive(Debug, Clone, PartialEq)]
struct Class {
    name: String,
    superclass: Option<Rc<Class>>,
    methods: HashMap<String, Function>,
}

impl Class {
    const fn new(
        name: String,
        superclass: Option<Rc<Class>>,
        methods: HashMap<String, Function>,
    ) -> Class {
        Class {
            name,
            superclass,
            methods,
        }
    }

    fn find_method(&self, name: &str) -> Option<&Function> {
        self.methods.get(name).map_or_else(
            || {
                self.superclass
                    .as_ref()
                    .and_then(|superclass| superclass.find_method(name))
            },
            Some,
        )
    }

    fn arity(&self) -> usize {
        self.find_method("init")
            .map_or(0, |f| f.declaration.params.len())
    }
}

#[derive(Clone, PartialEq)]
struct Instance {
    class: Rc<Class>,
    fields: HashMap<String, Value>,
}

impl Instance {
    fn new(class: Rc<Class>) -> Instance {
        Instance {
            class,
            fields: HashMap::new(),
        }
    }

    fn set(&mut self, name: &Ident, value: Value) {
        self.fields.insert(name.string().to_string(), value);
    }
}

fn get(instance: &'static RefCell<Instance>, name: &Ident) -> Result<Value> {
    let this = instance.borrow();
    if let Some(value) = this.fields.get(name.string()) {
        Ok(value.to_owned())
    } else if let Some(function) = this.class.find_method(name.string()) {
        Ok(Value::Function(function.bind(instance)))
    } else {
        Err(new_error(
            format!("Undefined property '{}'", name.string()),
            name,
            error_codes::UNDEFINED_NAME,
        ))
    }
}

impl fmt::Debug for Instance {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Instance")
            .field("class", &self.class.name)
            .field("fields", &self.fields)
            .finish()
    }
}

#[derive(Debug, Clone, PartialEq)]
enum Value {
    Nil,
    String(String),
    Number(f64),
    Bool(bool),
    Native(NativeFunction),
    Function(Function),
    Class(Rc<Class>),
    Instance(&'static RefCell<Instance>),
}

fn arity_error(parentheses: &Parentheses, expected: usize, actual: usize) -> Error {
    new_error(
        format!("Expected {expected} arguments but got {actual}"),
        parentheses.span().to_owned(),
        error_codes::INCORRECT_ARITY,
    )
}

impl Value {
    const fn as_class(&self) -> Option<&Rc<Class>> {
        if let Value::Class(class) = self {
            Some(class)
        } else {
            None
        }
    }

    const fn as_instance(&self) -> Option<&'static RefCell<Instance>> {
        if let Value::Instance(instance) = self {
            Some(*instance)
        } else {
            None
        }
    }

    const fn is_truthy(&self) -> bool {
        !matches!(self, Value::Nil | Value::Bool(false))
    }

    fn add(&self, op: &Punct!["+"], other: &Value) -> Result<Value> {
        match (self, other) {
            (Value::Number(n1), Value::Number(n2)) => Ok(Value::Number(n1 + n2)),
            (Value::String(s1), Value::String(s2)) => Ok(Value::String(s1.to_owned() + s2)),
            _ => Err(new_error(
                format!("Can't add '{self}' to '{other}'"),
                op,
                error_codes::TYPE_ERROR,
            )),
        }
    }

    fn sub(&self, op: &Punct!["-"], other: &Value) -> Result<Value> {
        if let (Value::Number(n1), Value::Number(n2)) = (self, other) {
            Ok(Value::Number(n1 - n2))
        } else {
            Err(new_error(
                format!("Can't subtract '{other}' from '{self}'"),
                op,
                error_codes::TYPE_ERROR,
            ))
        }
    }

    fn mul(&self, op: &Punct!["*"], other: &Value) -> Result<Value> {
        if let (Value::Number(n1), Value::Number(n2)) = (self, other) {
            Ok(Value::Number(n1 * n2))
        } else {
            Err(new_error(
                format!("Can't multiply '{self}' by '{other}'"),
                op,
                error_codes::TYPE_ERROR,
            ))
        }
    }

    fn div(&self, op: &Punct!["/"], other: &Value) -> Result<Value> {
        if let (Value::Number(n1), Value::Number(n2)) = (self, other) {
            Ok(Value::Number(n1 / n2))
        } else {
            Err(new_error(
                format!("Can't divide '{other}' by '{self}'"),
                op,
                error_codes::TYPE_ERROR,
            ))
        }
    }

    fn neg(&self, op: &Punct!["-"]) -> Result<Value> {
        if let Value::Number(n) = self {
            Ok(Value::Number(-n))
        } else {
            Err(new_error(
                format!("Can't negate '{self}'"),
                op,
                error_codes::TYPE_ERROR,
            ))
        }
    }

    fn cmp<T: Token>(&self, op: &T, other: &Value) -> Result<Ordering> {
        if self == other {
            return Ok(Ordering::Equal);
        }

        match (self, other) {
            (Value::String(s1), Value::String(s2)) => Ok(s1.cmp(s2).into()),
            (Value::Number(n1), Value::Number(n2)) => Ok(n1.partial_cmp(n2).into()),
            (Value::Bool(b1), Value::Bool(b2)) => Ok(b1.cmp(b2).into()),
            _ => Err(new_error(
                format!("Can't compare '{self}' with '{other}'"),
                op,
                error_codes::TYPE_ERROR,
            )),
        }
    }

    fn call(&self, arguments: Vec<Value>, parentheses: &Parentheses) -> Result<Value> {
        match self {
            Value::Native(NativeFunction {
                function, arity, ..
            }) => {
                if *arity != arguments.len() {
                    return Err(arity_error(parentheses, *arity, arguments.len()));
                }
                function(arguments)
            }
            Value::Function(function) => function.call(arguments, parentheses),
            Value::Class(class) => {
                if class.arity() != arguments.len() {
                    return Err(arity_error(parentheses, class.arity(), arguments.len()));
                }

                let instance = allocate(Instance::new(Rc::clone(class)));
                if let Some(initialiser) = class.find_method("init") {
                    initialiser.bind(instance).call(arguments, parentheses)?;
                }
                Ok(Value::Instance(instance))
            }
            Value::Nil
            | Value::String(_)
            | Value::Number(_)
            | Value::Bool(_)
            | Value::Instance(_) => Err(new_error(
                format!("Can't call '{self}'"),
                parentheses.span().clone(),
                error_codes::TYPE_ERROR,
            )),
        }
    }
}

impl fmt::Display for Value {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Value::Nil => f.write_str("nil"),
            Value::String(s) => f.write_str(s),
            Value::Number(n) => write!(f, "{n}"),
            Value::Bool(b) => write!(f, "{b}"),
            Value::Native(NativeFunction { name, .. }) => write!(f, "<native fn '{name}'>"),
            Value::Function(Function {
                declaration: FunctionDecl { name, .. },
                ..
            }) => write!(f, "<fn {}>", name.string()),
            Value::Class(class) => f.write_str(&class.name),
            Value::Instance(instance) => write!(f, "'{}' instance", instance.borrow().class.name),
        }
    }
}

#[derive(Debug, Clone)]
struct State {
    environment: Rc<RefCell<Environment>>,
    globals: Rc<RefCell<Environment>>,
}

impl State {
    fn new() -> Self {
        let mut values = HashMap::new();

        values.insert(
            "clock".to_string(),
            Value::Native(NativeFunction {
                function: natives::clock,
                arity: 0,
                name: "clock",
            }),
        );

        let environment = Rc::new(RefCell::new(Environment {
            values,
            enclosing: None,
            sub: vec![],
            mark: Cell::new(false),
        }));

        State {
            environment: Rc::clone(&environment),
            globals: environment,
        }
    }

    #[must_use]
    fn start_scope(&self) -> State {
        let environment = Rc::new(RefCell::new(Environment {
            values: HashMap::new(),
            enclosing: Some(Rc::clone(&self.environment)),
            sub: vec![],
            mark: Cell::new(false),
        }));
        self.environment
            .borrow_mut()
            .sub
            .push(Rc::downgrade(&environment));
        State {
            environment,
            globals: Rc::clone(&self.globals),
        }
    }

    fn super_scope(self) -> Option<State> {
        Some(State {
            environment: Rc::clone(self.environment.borrow().enclosing.as_ref()?),
            globals: self.globals,
        })
    }
}

fn allocate<T>(value: T) -> &'static RefCell<T> {
    Box::leak(Box::new(RefCell::new(value)))
}

struct Environment {
    values: HashMap<String, Value>,
    enclosing: Option<Rc<RefCell<Environment>>>,
    sub: Vec<Weak<RefCell<Environment>>>,
    mark: Cell<bool>,
}

impl Environment {
    fn get(&self, name: &Ident) -> Result<Value> {
        self.values.get(name.string()).map_or_else(
            || {
                self.enclosing.as_ref().map_or_else(
                    || {
                        Err(new_error(
                            format!("Undefined variable '{}'", name.string()),
                            name,
                            error_codes::UNDEFINED_NAME,
                        ))
                    },
                    |enclosing| enclosing.borrow().get(name),
                )
            },
            |value| Ok(value.to_owned()),
        )
    }

    fn get_at(&self, name: &Ident, distance: usize) -> Result<Value> {
        if distance == 0 {
            self.get(name)
        } else {
            self.enclosing
                .as_ref()
                .unwrap()
                .borrow()
                .get_at(name, distance - 1)
        }
    }

    fn define(&mut self, name: String, value: Value) {
        self.values.insert(name, value);
    }

    fn assign(&mut self, name: &Ident, value: Value) -> Result<()> {
        if self.values.contains_key(name.string()) {
            self.values.insert(name.string().clone(), value);
            Ok(())
        } else if let Some(enclosing) = &self.enclosing {
            enclosing.borrow_mut().assign(name, value)
        } else {
            Err(new_error(
                format!("Undefined variable '{}'", name.string()),
                name,
                error_codes::UNDEFINED_NAME,
            ))
        }
    }

    fn assign_at(&mut self, name: &Ident, value: Value, distance: usize) -> Result<()> {
        if distance == 0 {
            self.assign(name, value)
        } else {
            self.enclosing
                .as_ref()
                .unwrap()
                .borrow_mut()
                .assign_at(name, value, distance - 1)
        }
    }
}

struct EnvValuesDebug<'a>(&'a HashMap<String, Value>);

impl fmt::Debug for EnvValuesDebug<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_map()
            .entries(self.0.iter().map(|(k, v)| (k, v.to_string())))
            .finish()
    }
}

impl fmt::Debug for Environment {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Environment")
            .field("values", &EnvValuesDebug(&self.values))
            .field("enclosing", &self.enclosing)
            .field("sub", &self.sub)
            .field("mark", &self.mark)
            .finish()
    }
}

impl Binary {
    fn evaluate(&self, state: &State) -> Result<Value> {
        match self {
            Binary::Mul(left, op, right) => left.evaluate(state)?.mul(op, &right.evaluate(state)?),
            Binary::Div(left, op, right) => left.evaluate(state)?.div(op, &right.evaluate(state)?),
            Binary::Add(left, op, right) => left.evaluate(state)?.add(op, &right.evaluate(state)?),
            Binary::Sub(left, op, right) => left.evaluate(state)?.sub(op, &right.evaluate(state)?),
            Binary::Equal(left, _, right) => {
                Ok(Value::Bool(left.evaluate(state)? == right.evaluate(state)?))
            }
            Binary::NotEqual(left, _, right) => {
                Ok(Value::Bool(left.evaluate(state)? != right.evaluate(state)?))
            }
            Binary::Greater(left, op, right) => Ok(Value::Bool(
                left.evaluate(state)?.cmp(op, &right.evaluate(state)?)?.gt(),
            )),
            Binary::GreaterEqual(left, op, right) => Ok(Value::Bool(
                left.evaluate(state)?.cmp(op, &right.evaluate(state)?)?.ge(),
            )),
            Binary::Less(left, op, right) => Ok(Value::Bool(
                left.evaluate(state)?.cmp(op, &right.evaluate(state)?)?.lt(),
            )),
            Binary::LessEqual(left, op, right) => Ok(Value::Bool(
                left.evaluate(state)?.cmp(op, &right.evaluate(state)?)?.le(),
            )),
        }
    }
}

impl Literal {
    fn evaluate(&self) -> Value {
        match self {
            Literal::False(_) => Value::Bool(false),
            Literal::Float(value) => Value::Number(value.value()),
            #[allow(clippy::cast_precision_loss)]
            Literal::Int(value) => Value::Number(value.value() as f64),
            Literal::Nil(_) => Value::Nil,
            Literal::String(string) => Value::String(string.string().clone()),
            Literal::True(_) => Value::Bool(true),
        }
    }
}

impl Logical {
    fn evaluate(&self, state: &State) -> Result<Value> {
        match self {
            Logical::And(left, _, right) => {
                let left = left.evaluate(state)?;
                if left.is_truthy() {
                    Ok(left)
                } else {
                    right.evaluate(state)
                }
            }
            Logical::Or(left, _, right) => {
                let left = left.evaluate(state)?;
                if left.is_truthy() {
                    right.evaluate(state)
                } else {
                    Ok(left)
                }
            }
        }
    }
}

impl Unary {
    fn evaluate(&self, state: &State) -> Result<Value> {
        match self {
            Unary::Neg(op, expr) => expr.evaluate(state)?.neg(op),
            Unary::Not(_, expr) => Ok(Value::Bool(!expr.evaluate(state)?.is_truthy())),
        }
    }
}

impl Expr {
    fn evaluate(&self, state: &State) -> Result<Value> {
        match self {
            Expr::Assign {
                name,
                value,
                distance,
            } => {
                let value = value.evaluate(state)?;
                if let Some(distance) = distance.get() {
                    state
                        .environment
                        .borrow_mut()
                        .assign_at(name, value.clone(), distance)?;
                } else {
                    state.globals.borrow_mut().assign(name, value.clone())?;
                }
                Ok(value)
            }
            Expr::Binary(binary) => binary.evaluate(state),
            Expr::Call {
                callee,
                paren,
                arguments,
            } => {
                let callee = callee.evaluate(state)?;
                let mut evaluated_args = Vec::with_capacity(arguments.len());
                for arg in arguments {
                    evaluated_args.push(arg.evaluate(state)?);
                }
                callee.call(evaluated_args, paren)
            }
            Expr::Get { object, name } => {
                if let Value::Instance(instance) = object.evaluate(state)? {
                    get(instance, name)
                } else {
                    Err(new_error(
                        "Only instances have properties".to_string(),
                        name,
                        error_codes::TYPE_ERROR,
                    ))
                }
            }
            Expr::Group(expr) => expr.evaluate(state),
            Expr::Literal(literal) => Ok(literal.evaluate()),
            Expr::Logical(logical) => logical.evaluate(state),
            Expr::Set {
                object,
                name,
                value,
            } => {
                if let Value::Instance(instance) = object.evaluate(state)? {
                    let value = value.evaluate(state)?;
                    instance.borrow_mut().set(name, value.clone());
                    Ok(value)
                } else {
                    Err(new_error(
                        "Only instances have fields".to_string(),
                        name,
                        error_codes::TYPE_ERROR,
                    ))
                }
            }
            Expr::Super {
                keyword,
                distance,
                dot: _,
                method,
            } => {
                let superclass = state
                    .environment
                    .borrow()
                    .get_at(keyword.ident(), distance.clone().into_inner().unwrap())?;

                let object = state.environment.borrow().get_at(
                    &Ident::new("this".to_string(), keyword.span().clone()),
                    distance.clone().into_inner().unwrap() - 1,
                )?;

                superclass
                    .as_class()
                    .unwrap()
                    .find_method(method.string())
                    .map_or_else(
                        || {
                            Err(new_error(
                                format!("Undefined property '{}'", method.string()),
                                method,
                                error_codes::UNDEFINED_NAME,
                            ))
                        },
                        |method| Ok(Value::Function(method.bind(object.as_instance().unwrap()))),
                    )
            }
            Expr::This { keyword, distance } => distance.get().map_or_else(
                || state.globals.borrow().get(keyword.ident()),
                |distance| state.environment.borrow().get_at(keyword.ident(), distance),
            ),
            Expr::Unary(unary) => unary.evaluate(state),
            Expr::Variable { name, distance } => distance.get().map_or_else(
                || state.globals.borrow().get(name),
                |distance| state.environment.borrow().get_at(name, distance),
            ),
        }
    }
}

macro_rules! propagate_return {
    ( $expr:expr ) => {
        if let Some(_tmp) = $expr {
            return Ok(Some(_tmp));
        }
    };
}

impl Stmt {
    fn execute(&self, state: &State) -> Result<Option<Value>> {
        match self {
            Stmt::Block(stmts) => {
                let inner_state = state.start_scope();
                for stmt in stmts {
                    propagate_return!(stmt.execute(&inner_state)?);
                }
            }
            Stmt::Class {
                name,
                superclass,
                superclass_distance,
                methods,
            } => {
                let superclass = if let Some(superclass_name) = superclass {
                    let superclass = Expr::Variable {
                        name: superclass_name.clone(),
                        distance: superclass_distance.clone(),
                    }
                    .evaluate(state)?;
                    if let Value::Class(superclass) = superclass {
                        Some(superclass)
                    } else {
                        return Err(new_error(
                            "Superclass must be a class".to_string(),
                            superclass_name,
                            error_codes::INHERIT_FROM_VALUE,
                        ));
                    }
                } else {
                    None
                };

                state
                    .environment
                    .borrow_mut()
                    .define(name.string().to_owned(), Value::Nil);

                let superclass_is_some = superclass.is_some();
                let mut state = superclass.as_ref().map_or_else(
                    || state.clone(),
                    |superclass| {
                        let state = state.start_scope();
                        state
                            .environment
                            .borrow_mut()
                            .define("super".to_string(), Value::Class(Rc::clone(superclass)));
                        state
                    },
                );

                let methods = methods
                    .iter()
                    .map(|declaration| {
                        (
                            declaration.name.string().to_owned(),
                            Function::new(
                                declaration.clone(),
                                state.clone(),
                                declaration.name.string() == "init",
                            ),
                        )
                    })
                    .collect();
                let class = Class::new(name.string().to_owned(), superclass, methods);

                if superclass_is_some {
                    state = state.super_scope().unwrap();
                }

                state
                    .environment
                    .borrow_mut()
                    .assign(name, Value::Class(Rc::new(class)))?;
            }
            Stmt::Expr(expr) => {
                expr.evaluate(state)?;
            }
            Stmt::Function(function) => {
                let value =
                    Value::Function(Function::new(function.to_owned(), state.clone(), false));
                state
                    .environment
                    .borrow_mut()
                    .define(function.name.string().to_owned(), value);
            }
            Stmt::If {
                condition,
                then_branch,
                else_branch,
            } => {
                if condition.evaluate(state)?.is_truthy() {
                    propagate_return!(then_branch.execute(state)?);
                } else if let Some(else_branch) = else_branch {
                    propagate_return!(else_branch.execute(state)?);
                }
            }
            Stmt::Print(expr) => {
                let value = expr.evaluate(state)?;
                println!("{value}");
            }
            Stmt::Return { keyword: _, value } => {
                return Ok(Some(
                    value
                        .as_ref()
                        .map_or(Ok(Value::Nil), |v| v.evaluate(state))?,
                ));
            }
            Stmt::Variable { name, initialiser } => {
                let value = if let Some(initialiser) = initialiser {
                    initialiser.evaluate(state)?
                } else {
                    Value::Nil
                };
                state
                    .environment
                    .borrow_mut()
                    .define(name.string().to_owned(), value);
            }
            Stmt::While { condition, body } => {
                while condition.evaluate(state)?.is_truthy() {
                    propagate_return!(body.execute(state)?);
                }
            }
        }

        Ok(None)
    }

pub const fn new(string: String, span: Span) -> Ident

Creates a new identifier in the given ParseStream with the given string.

Examples found in repository

examples/lox/interpreter.rs (line 708)

    fn evaluate(&self, state: &State) -> Result<Value> {
        match self {
            Expr::Assign {
                name,
                value,
                distance,
            } => {
                let value = value.evaluate(state)?;
                if let Some(distance) = distance.get() {
                    state
                        .environment
                        .borrow_mut()
                        .assign_at(name, value.clone(), distance)?;
                } else {
                    state.globals.borrow_mut().assign(name, value.clone())?;
                }
                Ok(value)
            }
            Expr::Binary(binary) => binary.evaluate(state),
            Expr::Call {
                callee,
                paren,
                arguments,
            } => {
                let callee = callee.evaluate(state)?;
                let mut evaluated_args = Vec::with_capacity(arguments.len());
                for arg in arguments {
                    evaluated_args.push(arg.evaluate(state)?);
                }
                callee.call(evaluated_args, paren)
            }
            Expr::Get { object, name } => {
                if let Value::Instance(instance) = object.evaluate(state)? {
                    get(instance, name)
                } else {
                    Err(new_error(
                        "Only instances have properties".to_string(),
                        name,
                        error_codes::TYPE_ERROR,
                    ))
                }
            }
            Expr::Group(expr) => expr.evaluate(state),
            Expr::Literal(literal) => Ok(literal.evaluate()),
            Expr::Logical(logical) => logical.evaluate(state),
            Expr::Set {
                object,
                name,
                value,
            } => {
                if let Value::Instance(instance) = object.evaluate(state)? {
                    let value = value.evaluate(state)?;
                    instance.borrow_mut().set(name, value.clone());
                    Ok(value)
                } else {
                    Err(new_error(
                        "Only instances have fields".to_string(),
                        name,
                        error_codes::TYPE_ERROR,
                    ))
                }
            }
            Expr::Super {
                keyword,
                distance,
                dot: _,
                method,
            } => {
                let superclass = state
                    .environment
                    .borrow()
                    .get_at(keyword.ident(), distance.clone().into_inner().unwrap())?;

                let object = state.environment.borrow().get_at(
                    &Ident::new("this".to_string(), keyword.span().clone()),
                    distance.clone().into_inner().unwrap() - 1,
                )?;

                superclass
                    .as_class()
                    .unwrap()
                    .find_method(method.string())
                    .map_or_else(
                        || {
                            Err(new_error(
                                format!("Undefined property '{}'", method.string()),
                                method,
                                error_codes::UNDEFINED_NAME,
                            ))
                        },
                        |method| Ok(Value::Function(method.bind(object.as_instance().unwrap()))),
                    )
            }
            Expr::This { keyword, distance } => distance.get().map_or_else(
                || state.globals.borrow().get(keyword.ident()),
                |distance| state.environment.borrow().get_at(keyword.ident(), distance),
            ),
            Expr::Unary(unary) => unary.evaluate(state),
            Expr::Variable { name, distance } => distance.get().map_or_else(
                || state.globals.borrow().get(name),
                |distance| state.environment.borrow().get_at(name, distance),
            ),
        }
    }

Trait Implementations

impl Clone for Ident

fn clone(&self) -> Ident

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Ident

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Ident

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Ident

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl Parse for Ident

fn parse(input: ParseStream<'_>) -> Result<Self>

Parses the input into this type.

impl PartialEq for Ident

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Ident

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl ToTokens for Ident

fn to_tokens(&self, tokens: &mut TokenStream)

Append self to the given TokenStream.

fn into_token_stream(self) -> TokenStream

Convert self directly into a TokenStream.

fn to_token_stream(&self) -> TokenStream

Convert self directly into a TokenStream.

impl Token for Ident

fn span(&self) -> &Span

Returns the span covered by this token.

impl Eq for Ident