()
+ .map_or_else(Self::empty, store_in_cache)
}
}
impl EnvironmentCache {
diff --git a/src/builtin_parser/docs.md b/src/builtin_parser/docs.md
new file mode 100644
index 0000000..5b8b312
--- /dev/null
+++ b/src/builtin_parser/docs.md
@@ -0,0 +1,201 @@
+
+The built-in parser provides a mini-language that can evaluate expressions, call commands, and modify resources.
+
+
+Note
+
+This guide assumes you already have used Rust before and that you know how it works.
+
+
+## Basic variable assignments and math
+
+For simplicity, the `let` keyword is not required for creating variables.
+
+You can do most basic operations:
+
+- Arithmetic: Addition/Subtraction/Multiplication/Division/Modulus
+- Bitwise operations: AND/XOR/OR/NOT
+- ~~Comparisons~~ (Coming soon-ish)
+
+```rust
+# bevy_dev_console::test_builtin_parser!({
+$ x = 5 + 4
+# ;
+> 9 (integer)
+# }{
+$ x - 2
+# ;
+> 7 (integer)
+# }{
+$ x = x * -3
+# ;
+> -27 (integer)
+# }{
+$ !true
+# ;
+> false
+# }{
+$ !5u8
+# ;
+> 250 (u8)
+# }{
+$ 84 ^ 32
+# ;
+> 116 (integer)
+# })
+```
+
+## Ownership and Borrowing
+
+The built-in parser uses the a similar memory model to Rust's.
+
+This means assigning a variable's value to another causes the original variable to get moved.
+
+```rust
+# bevy_dev_console::test_builtin_parser!({
+$ x = "Hello World!"
+# ;
+> "Hello World!"
+# }{
+$ y = x
+# ;
+> "Hello World!"
+# }{
+$ x
+# ; err "
+ERROR variable `x` was moved
+# " });
+```
+
+For simplicity, references are always mutable, and you can have multiple of them.
+
+You can deference references to modify the value they are references.
+
+```rust
+# bevy_dev_console::test_builtin_parser!({
+$ x = "Hi"
+# ;
+> "Hi"
+# }{
+$ y = &x
+# ;
+> "Hi"
+# }{
+$ z = &x
+# ;
+> "Hi"
+# }{
+$ *z = "Bye"
+# ;
+> "Bye"
+# }{
+$ x
+# ;
+> "Bye"
+# }{
+$ y
+# ;
+> "Bye"
+# });
+```
+
+You can also use dereferencing to clone a variable's value.
+
+```rust
+# bevy_dev_console::test_builtin_parser!({
+$ x = "Hmmm"
+# }{
+$ y = *x
+# }{
+$ z = x
+# });
+```
+
+### Copy types
+
+Certain types are `Copy`, which, like in Rust, means they are automatically copied instead of moved.
+This means they never can be moved.
+
+The copy types in the builtin parser are: `()`, all number types, and `bool`.
+
+```rust
+# bevy_dev_console::test_builtin_parser!({
+$ x = 12
+# ;
+> 12 (integer)
+# }{
+$ drop x
+# }{
+$ x
+# ;
+> 12 (integer)
+# });
+```
+
+## Types
+
+Every value can have one of these types:
+
+- **None**: The same as `()` in Rust.
+- **Number**: Any type of Rust number (You can specify a type like this: `5usize`, `2.4f32`, `8f64`), along with these 2 additional types:
+ - **Integer**: A generic integer of an unknown size that can get downcasted to the appropriate size when used with an integer of a known size.
+ - **Float**: A generic float of an unknown size that can get downcasted to the appropriate size when used with a float of a known size.
+- **Boolean**: A value that can either be `true` or `false`.
+- **String**: An array of characters, the same as the [`String`] type in Rust.
+- **Reference**: A mutable reference to another value.
+- **Object**: A dynamic object, equivalent to [`HashMap`](std::collections::HashMap) in Rust.
+- **StructObject**: A dynamic object, but with a name. Mostly used for enum assignments.
+- **Tuple**: A dynamic tuple.
+- **StructTuple**: A dynamic tuple, but with a name. Mostly used for enum assignments.
+- **Resource**: A reference to a resource that can be modified.
+
+## Functions
+
+You can call functions by the name, followed by space separated arguments.
+
+```rust
+# bevy_dev_console::test_builtin_parser!({
+$ print "Hello World!"
+# }); stringify!( // TODO maybe test log output one day?
+INFO "Hello World!"
+# );
+```
+
+Custom native functions can be created and added, see the [`custom_functions` example](https://github.com/doonv/bevy_dev_console/blob/master/examples/custom_functions.rs) for an example.
+
+## Resource Modification
+
+You can modify [`Resource`]s that implement the [`Reflect`] trait by their name. See the [`resources` example](https://github.com/doonv/bevy_dev_console/blob/master/examples/resources.rs) for some resources to play around with.
+
+
+Note
+
+Error handling for this is not finished, expect panics.
+
+
+```rust,ignore
+MyStructResource.number1 = 100
+MyEnumResource = Option2
+MyEnumResource = StructVariant { a: 5.2, b: "Hi!" }
+MyEnumResource = TupleVariant(false, 5u64)
+```
+
+## Entity Queries and Modification
+
+[*Coming soon...*](https://github.com/doonv/bevy_dev_console/issues/3)
+
+## Loops
+
+[*Coming soon...*](https://github.com/doonv/bevy_dev_console/issues/8)
+
+## Functions/Closures
+
+[*Coming soon...*](https://github.com/doonv/bevy_dev_console/issues/12)
+
+## Boolean comparisons
+
+*Coming soon...*
+
+## The end, for now
+
+`bevy_dev_console` is still in active development, and more features will be added soon.
diff --git a/src/builtin_parser/lexer.rs b/src/builtin_parser/lexer.rs
index f15311c..20ec2e7 100644
--- a/src/builtin_parser/lexer.rs
+++ b/src/builtin_parser/lexer.rs
@@ -36,6 +36,11 @@ pub enum Token {
#[token("%")]
Modulo,
+ #[token("!")]
+ Not,
+ #[token("^")]
+ Xor,
+
#[token(".", priority = 10)]
Dot,
#[token("&")]
@@ -47,6 +52,8 @@ pub enum Token {
For,
#[token("while")]
While,
+ #[token("if")]
+ If,
#[token("in")]
In,
@@ -57,6 +64,8 @@ pub enum Token {
SemiColon,
#[token(",")]
Comma,
+ #[token("|")]
+ Pipe,
#[token("true")]
True,
@@ -69,24 +78,10 @@ pub enum Token {
#[regex("[a-zA-Z_][a-zA-Z0-9_]*")]
Identifier,
- #[regex(r#"[0-9]+"#)]
+ #[regex(r#"[0-9]+[A-Za-z0-9_]*"#)]
IntegerNumber,
- #[regex(r#"[0-9]+\.[0-9]*"#)]
+ #[regex(r#"[0-9]+\.[0-9]*[A-Za-z0-9_]*"#)]
FloatNumber,
-
- #[token("i8")]
- #[token("i16")]
- #[token("i32")]
- #[token("i64")]
- #[token("isize")]
- #[token("u8")]
- #[token("u16")]
- #[token("u32")]
- #[token("u64")]
- #[token("usize")]
- #[token("f32")]
- #[token("f64")]
- NumberType,
}
/// A wrapper for the lexer which provides token peeking and other helper functions
@@ -100,12 +95,16 @@ pub struct TokenStream<'a> {
impl<'a> TokenStream<'a> {
/// Creates a new [`TokenStream`] from `src`.
+ #[must_use]
pub fn new(src: &'a str) -> Self {
let mut lexer = Token::lexer(src);
- let current_slice = lexer.slice();
- let current_span = lexer.span();
let next = lexer.next();
+ let (current_span, current_slice) = if let Some(Err(FailedToLexCharacter)) = next {
+ (0..1, &src[0..1])
+ } else {
+ (lexer.span(), lexer.slice())
+ };
Self {
lexer,
@@ -125,6 +124,12 @@ impl<'a> TokenStream<'a> {
val
}
+ /// Returns advances the iterator and discards the [`Token`]
+ pub fn skip_one(&mut self) -> &mut Self {
+ self.next();
+ self
+ }
+
// pub fn next_pe(&mut self) -> Result {
// let token = self.next();
@@ -154,6 +159,24 @@ impl<'a> TokenStream<'a> {
self.current_span.clone()
}
+ /// Advances the stream until a certain [`Token`] is reached and returns the entire span between now and that [`Token`].
+ #[must_use]
+ pub fn span_until(&mut self, token: Token) -> Span {
+ let start = self.current_span.start;
+ loop {
+ match self.next() {
+ Some(Ok(t)) if t == token => break,
+ Some(Err(_)) | None => break,
+ Some(Ok(_)) => {}
+ }
+ }
+
+ Span {
+ start,
+ end: self.current_span.end,
+ }
+ }
+
/// Get a [`str`] slice of the current [`Token`].
#[inline]
#[must_use]
diff --git a/src/builtin_parser/number.rs b/src/builtin_parser/number.rs
index bb57ea1..b93a90b 100644
--- a/src/builtin_parser/number.rs
+++ b/src/builtin_parser/number.rs
@@ -1,225 +1,962 @@
-use std::fmt::Display;
+#![allow(missing_docs, non_camel_case_types)]
+
+use std::fmt::{Debug, Display};
use std::ops::*;
use bevy::reflect::Reflect;
+use kinded::Kinded;
use logos::Span;
-use super::{EvalError, SpanExtension, Spanned};
+use crate::builtin_parser::parser::BinaryOperator;
+use crate::builtin_parser::{Diagnostic, ErrorExtension, VALUE};
-/// An enum that contains any type of number.
-///
-/// The [`Integer`](Number::Integer) and [`Float`](Number::Float) types
-/// are generic types that then get downcasted when they first interact
-/// with a concrete type. (i.e. calling a function, etc)
-#[derive(Debug, Clone, Copy)]
-#[allow(missing_docs, non_camel_case_types)]
-pub enum Number {
- /// Generic integer that can get downcasted.
- Integer(i128),
- /// Generic float that can get downcasted to a [`f64`] and [`f32`]
- Float(f64),
+use super::runner::error::EvalError;
+use super::{SpanExtension, Spanned};
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Kinded)]
+#[kinded(skip_derive(Display))]
+pub enum UnsignedInteger {
u8(u8),
u16(u16),
u32(u32),
u64(u64),
usize(usize),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Kinded)]
+#[kinded(skip_derive(Display))]
+pub enum SignedInteger {
i8(i8),
i16(i16),
i32(i32),
i64(i64),
isize(isize),
+ /// Generic integer that can get downcasted.
+ Unspecified(i128),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Integer {
+ Unsigned(UnsignedInteger),
+ Signed(SignedInteger),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Kinded)]
+#[kinded(skip_derive(Display))]
+pub enum Float {
f32(f32),
f64(f64),
+ /// Generic float that can get downcasted to a [`f64`] and [`f32`]
+ Unspecified(f64),
}
-impl Number {
+/// An enum that contains any type of number.
+///
+/// The [`Integer`](SignedInteger::Unspecified) and [`Float`](Float::Float) types
+/// are generic types that then get downcasted when they first interact
+/// with a concrete type. (i.e. calling a function, etc)
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Number {
+ Integer(Integer),
+ Float(Float),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum IntegerKind {
+ Unsigned(UnsignedIntegerKind),
+ Signed(SignedIntegerKind),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum NumberKind {
+ Integer(IntegerKind),
+ Float(FloatKind),
+}
+
+impl kinded::Kind for IntegerKind {
+ fn all() -> &'static [Self] {
+ &[]
+ }
+}
+
+impl kinded::Kind for NumberKind {
+ fn all() -> &'static [Self] {
+ &[]
+ }
+}
+
+impl Kinded for Integer {
+ type Kind = IntegerKind;
+
+ fn kind(&self) -> Self::Kind {
+ match self {
+ Integer::Unsigned(v) => IntegerKind::Unsigned(v.kind()),
+ Integer::Signed(v) => IntegerKind::Signed(v.kind()),
+ }
+ }
+}
+
+impl Kinded for Number {
+ type Kind = NumberKind;
+
+ fn kind(&self) -> Self::Kind {
+ match self {
+ Number::Integer(v) => NumberKind::Integer(v.kind()),
+ Number::Float(v) => NumberKind::Float(v.kind()),
+ }
+ }
+}
+
+impl Integer {
/// Converts this into a [`Box`](Reflect).
- pub fn reflect(self, span: Span, ty: &str) -> Result, EvalError> {
+ pub fn reflect(self, span: Span, ty: &str) -> Result, Diagnostic> {
match self {
- Number::u8(number) => Ok(Box::new(number)),
- Number::u16(number) => Ok(Box::new(number)),
- Number::u32(number) => Ok(Box::new(number)),
- Number::u64(number) => Ok(Box::new(number)),
- Number::usize(number) => Ok(Box::new(number)),
- Number::i8(number) => Ok(Box::new(number)),
- Number::i16(number) => Ok(Box::new(number)),
- Number::i32(number) => Ok(Box::new(number)),
- Number::i64(number) => Ok(Box::new(number)),
- Number::isize(number) => Ok(Box::new(number)),
- Number::f32(number) => Ok(Box::new(number)),
- Number::f64(number) => Ok(Box::new(number)),
- Number::Integer(number) => match ty {
- "u8" => Ok(Box::new(number as u8)),
- "u16" => Ok(Box::new(number as u16)),
- "u32" => Ok(Box::new(number as u32)),
- "u64" => Ok(Box::new(number as u64)),
- "usize" => Ok(Box::new(number as usize)),
- "i8" => Ok(Box::new(number as i8)),
- "i16" => Ok(Box::new(number as i16)),
- "i32" => Ok(Box::new(number as i32)),
- "i64" => Ok(Box::new(number as i64)),
- "isize" => Ok(Box::new(number as isize)),
- ty => Err(EvalError::IncompatibleReflectTypes {
- expected: "integer".to_string(),
- actual: ty.to_string(),
- span,
- }),
+ Integer::Unsigned(number) => match number {
+ UnsignedInteger::u8(number) => Ok(Box::new(number)),
+ UnsignedInteger::u16(number) => Ok(Box::new(number)),
+ UnsignedInteger::u32(number) => Ok(Box::new(number)),
+ UnsignedInteger::u64(number) => Ok(Box::new(number)),
+ UnsignedInteger::usize(number) => Ok(Box::new(number)),
},
- Number::Float(number) => match ty {
- "f32" => Ok(Box::new(number as f32)),
- "f64" => Ok(Box::new(number)),
- ty => Err(EvalError::IncompatibleReflectTypes {
- expected: "float".to_string(),
- actual: ty.to_string(),
- span,
- }),
+ Integer::Signed(number) => match number {
+ SignedInteger::i8(number) => Ok(Box::new(number)),
+ SignedInteger::i16(number) => Ok(Box::new(number)),
+ SignedInteger::i32(number) => Ok(Box::new(number)),
+ SignedInteger::i64(number) => Ok(Box::new(number)),
+ SignedInteger::isize(number) => Ok(Box::new(number)),
+ SignedInteger::Unspecified(number) => match ty {
+ "u8" => Ok(Box::new(number as u8)),
+ "u16" => Ok(Box::new(number as u16)),
+ "u32" => Ok(Box::new(number as u32)),
+ "u64" => Ok(Box::new(number as u64)),
+ "usize" => Ok(Box::new(number as usize)),
+ "i8" => Ok(Box::new(number as i8)),
+ "i16" => Ok(Box::new(number as i16)),
+ "i32" => Ok(Box::new(number as i32)),
+ "i64" => Ok(Box::new(number as i64)),
+ "isize" => Ok(Box::new(number as isize)),
+ ty => Err(span.diagnose(EvalError::IncompatibleReflectTypes {
+ expected: "integer".to_owned(),
+ actual: ty.to_owned(),
+ })),
+ },
},
}
}
+}
- /// Returns the kind of [`Number`] as a [string slice](str).
- /// You may want to use [`natural_kind`](Self::natural_kind)
+impl Number {
+ /// Converts this into a [`Box`](Reflect).
+ pub fn reflect(self, span: Span, ty: &str) -> Result, Diagnostic> {
+ match self {
+ Number::Integer(integer) => integer.reflect(span, ty),
+ Number::Float(number) => match number {
+ Float::f32(number) => Ok(Box::new(number)),
+ Float::f64(number) => Ok(Box::new(number)),
+ Float::Unspecified(number) => match ty {
+ "f32" => Ok(Box::new(number as f32)),
+ "f64" => Ok(Box::new(number)),
+ ty => Err(span.diagnose(EvalError::IncompatibleReflectTypes {
+ expected: "float".to_owned(),
+ actual: ty.to_owned(),
+ })),
+ },
+ },
+ }
+ }
+}
+
+impl Display for UnsignedInteger {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ UnsignedInteger::u8(number) => write!(f, "{VALUE}{number}{VALUE:#} (u8)"),
+ UnsignedInteger::u16(number) => write!(f, "{VALUE}{number}{VALUE:#} (u16)"),
+ UnsignedInteger::u32(number) => write!(f, "{VALUE}{number}{VALUE:#} (u32)"),
+ UnsignedInteger::u64(number) => write!(f, "{VALUE}{number}{VALUE:#} (u64)"),
+ UnsignedInteger::usize(number) => write!(f, "{VALUE}{number}{VALUE:#} (usize)"),
+ }
+ }
+}
+
+impl Display for SignedInteger {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ SignedInteger::i8(number) => write!(f, "{VALUE}{number}{VALUE:#} (i8)"),
+ SignedInteger::i16(number) => write!(f, "{VALUE}{number}{VALUE:#} (i16)"),
+ SignedInteger::i32(number) => write!(f, "{VALUE}{number}{VALUE:#} (i32)"),
+ SignedInteger::i64(number) => write!(f, "{VALUE}{number}{VALUE:#} (i64)"),
+ SignedInteger::isize(number) => write!(f, "{VALUE}{number}{VALUE:#} (isize)"),
+ SignedInteger::Unspecified(number) => {
+ write!(f, "{VALUE}{number}{VALUE:#} (integer)")
+ }
+ }
+ }
+}
+
+impl Display for Float {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Float::f32(number) => write!(f, "{VALUE}{number}{VALUE:#} (f32)"),
+ Float::f64(number) => write!(f, "{VALUE}{number}{VALUE:#} (f64)"),
+ Float::Unspecified(number) => write!(f, "{VALUE}{number}{VALUE:#} (float)"),
+ }
+ }
+}
+
+impl Display for Integer {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Integer::Unsigned(number) => Display::fmt(number, f),
+ Integer::Signed(number) => Display::fmt(number, f),
+ }
+ }
+}
+
+impl Display for Number {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ Number::Integer(number) => Display::fmt(number, f),
+ Number::Float(number) => Display::fmt(number, f),
+ }
+ }
+}
+
+macro_rules! impl_kind_methods {
+ ($kind:ident, $($variant:ident => ($str:expr, $natural:expr)),*$(,)?) => {
+ impl $kind {
+ /// Converts this kind into a [`&'static str`](str)
+ /// You may want to use [`as_natural`](Self::as_natural)
+ /// instead for more natural sounding error messages
+ #[must_use]
+ pub const fn as_str(&self) -> &'static str {
+ match self {
+ $(Self::$variant => $str),*
+ }
+ }
+
+ /// Returns the kind of value as a [string slice](str) with an `a` or `an` prepended to it.
+ /// Used for more natural sounding error messages.
+ #[must_use]
+ pub const fn as_natural(&self) -> &'static str {
+ match self {
+ $(Self::$variant => $natural),*
+ }
+ }
+ }
+ impl Display for $kind {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ if f.alternate() {
+ f.write_str(self.as_natural())
+ } else {
+ f.write_str(self.as_str())
+ }
+ }
+ }
+ };
+}
+
+impl_kind_methods!(UnsignedIntegerKind,
+ u8 => ("u8", "a u8"),
+ u16 => ("u16", "a u16"),
+ u32 => ("u32", "a u32"),
+ u64 => ("u64", "a u64"),
+ usize => ("usize", "a usize"),
+);
+
+impl_kind_methods!(SignedIntegerKind,
+ i8 => ("i8", "a i8"),
+ i16 => ("i16", "a i16"),
+ i32 => ("i32", "a i32"),
+ i64 => ("i64", "a i64"),
+ isize => ("isize", "an isize"),
+ Unspecified => ("integer", "an integer"),
+);
+
+impl_kind_methods!(FloatKind,
+ f32 => ("f32", "a f32"),
+ f64 => ("f64", "a f64"),
+ Unspecified => ("float", "a float"),
+);
+
+impl IntegerKind {
+ /// Converts this [`IntegerKind`] into a [`&'static str`](str)
+ /// You may want to use [`as_natural`](Self::as_natural)
/// instead for more natural sounding error messages
- pub const fn kind(&self) -> &'static str {
+ #[must_use]
+ pub const fn as_str(&self) -> &'static str {
match self {
- Number::Float(_) => "float",
- Number::Integer(_) => "integer",
- Number::u8(_) => "u8",
- Number::u16(_) => "u16",
- Number::u32(_) => "u32",
- Number::u64(_) => "u64",
- Number::usize(_) => "usize",
- Number::i8(_) => "i8",
- Number::i16(_) => "i16",
- Number::i32(_) => "i32",
- Number::i64(_) => "i64",
- Number::isize(_) => "usize",
- Number::f32(_) => "f32",
- Number::f64(_) => "f64",
+ Self::Unsigned(kind) => kind.as_str(),
+ Self::Signed(kind) => kind.as_str(),
}
}
- /// Returns the kind of [`Number`] as a [string slice](str) with an `a` or `an` prepended to it.
+ /// Returns the kind of [`Integer`] as a [string slice](str) with an `a` or `an` prepended to it.
/// Used for more natural sounding error messages.
- pub const fn natural_kind(&self) -> &'static str {
+ #[must_use]
+ pub const fn as_natural(&self) -> &'static str {
match self {
- Number::Float(_) => "a float",
- Number::Integer(_) => "an integer",
- Number::u8(_) => "a u8",
- Number::u16(_) => "a u16",
- Number::u32(_) => "a u32",
- Number::u64(_) => "a u64",
- Number::usize(_) => "a usize",
- Number::i8(_) => "a i8",
- Number::i16(_) => "a i16",
- Number::i32(_) => "a i32",
- Number::i64(_) => "a i64",
- Number::isize(_) => "a usize",
- Number::f32(_) => "a f32",
- Number::f64(_) => "a f64",
+ Self::Unsigned(kind) => kind.as_natural(),
+ Self::Signed(kind) => kind.as_natural(),
+ }
+ }
+}
+impl Display for IntegerKind {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ if f.alternate() {
+ f.write_str(self.as_natural())
+ } else {
+ f.write_str(self.as_str())
}
}
}
-impl Display for Number {
+impl NumberKind {
+ /// Converts this [`NumberKind`] into a [`&'static str`](str)
+ /// You may want to use [`as_natural`](Self::as_natural)
+ /// instead for more natural sounding error messages
+ #[must_use]
+ pub const fn as_str(&self) -> &'static str {
+ match self {
+ Self::Integer(kind) => kind.as_str(),
+ Self::Float(kind) => kind.as_str(),
+ }
+ }
+
+ /// Returns the kind of [`Number`] as a [string slice](str) with an `a` or `an` prepended to it.
+ /// Used for more natural sounding error messages.
+ #[must_use]
+ pub const fn as_natural(&self) -> &'static str {
+ match self {
+ Self::Integer(kind) => kind.as_natural(),
+ Self::Float(kind) => kind.as_natural(),
+ }
+ }
+}
+impl Display for NumberKind {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ if f.alternate() {
+ f.write_str(self.as_natural())
+ } else {
+ f.write_str(self.as_str())
+ }
+ }
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("cannot apply unary operator `-` to type `{0}`")]
+pub struct CannotNegateUnsignedInteger(pub NumberKind);
+
+#[derive(Debug, thiserror::Error)]
+#[error("Incompatible number types; `{left}` and `{right}` are incompatible.")]
+pub struct IncompatibleNumberTypes {
+ pub left: NumberKind,
+ pub right: NumberKind,
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("cannot {operator} {left} by {right}")]
+pub struct InvalidBinaryOperation {
+ pub left: Number,
+ pub right: Number,
+ pub operator: BinaryOperator,
+}
+
+#[derive(Debug, thiserror::Error)]
+#[error("integer value `{value}` out of range for type `{ty}`")]
+pub struct ValueOutOfRange {
+ pub value: i128,
+ pub ty: NumberKind,
+}
+
+#[derive(thiserror::Error, Debug)]
+pub enum NumberError {
+ #[error(transparent)]
+ InvalidBinaryOperation(#[from] InvalidBinaryOperation),
+ #[error(transparent)]
+ ValueOutOfRange(#[from] ValueOutOfRange),
+ #[error(transparent)]
+ IncompatibleNumberTypes(#[from] IncompatibleNumberTypes),
+ #[error(transparent)]
+ CannotNegateUnsignedInteger(#[from] CannotNegateUnsignedInteger),
+ #[error(
+ "cannot apply bitwise operator `{operator}` to type `{operand}`. only integers are supported."
+ )]
+ InvalidBitwiseOperation {
+ operator: BinaryOperator,
+ operand: NumberKind,
+ },
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum IntegerOperationError {
+ #[error(transparent)]
+ IncompatibleTypes(#[from] IncompatibleNumberTypes),
+ #[error(transparent)]
+ InvalidBinaryOperation(#[from] InvalidBinaryOperation),
+ #[error(transparent)]
+ ValueOutOfRange(#[from] ValueOutOfRange),
+}
+
+impl From for NumberError {
+ fn from(error: IntegerOperationError) -> Self {
+ match error {
+ IntegerOperationError::IncompatibleTypes(e) => Self::IncompatibleNumberTypes(e),
+ IntegerOperationError::InvalidBinaryOperation(e) => Self::InvalidBinaryOperation(e),
+ IntegerOperationError::ValueOutOfRange(e) => Self::ValueOutOfRange(e),
+ }
+ }
+}
+
+macro_rules! impl_unsigned_op {
+ ($trait:ident, $method:ident, $checked:ident, $operator:ident) => {
+ impl $trait for UnsignedInteger {
+ type Output = Result;
+ fn $method(self, rhs: Self) -> Self::Output {
+ match (self, rhs) {
+ (Self::u8(l), Self::u8(r)) => l.$checked(r).map(Self::u8),
+ (Self::u16(l), Self::u16(r)) => l.$checked(r).map(Self::u16),
+ (Self::u32(l), Self::u32(r)) => l.$checked(r).map(Self::u32),
+ (Self::u64(l), Self::u64(r)) => l.$checked(r).map(Self::u64),
+ (Self::usize(l), Self::usize(r)) => l.$checked(r).map(Self::usize),
+ _ => {
+ return Err(IncompatibleNumberTypes {
+ left: self.kind().into(),
+ right: rhs.kind().into(),
+ }
+ .into());
+ }
+ }
+ .ok_or_else(|| {
+ InvalidBinaryOperation {
+ left: self.into(),
+ right: rhs.into(),
+ operator: BinaryOperator::$operator,
+ }
+ .into()
+ })
+ }
+ }
+ };
+}
+
+impl_unsigned_op!(Add, add, checked_add, Add);
+impl_unsigned_op!(Sub, sub, checked_sub, Sub);
+impl_unsigned_op!(Mul, mul, checked_mul, Mul);
+impl_unsigned_op!(Div, div, checked_div, Div);
+impl_unsigned_op!(Rem, rem, checked_rem, Mod);
+
+macro_rules! impl_unsigned_bitwise_op {
+ ($trait:ident, $method:ident) => {
+ impl $trait for UnsignedInteger {
+ type Output = Result;
+ fn $method(self, rhs: Self) -> Self::Output {
+ match (self, rhs) {
+ (Self::u8(l), Self::u8(r)) => Ok(Self::u8(l.$method(r))),
+ (Self::u16(l), Self::u16(r)) => Ok(Self::u16(l.$method(r))),
+ (Self::u32(l), Self::u32(r)) => Ok(Self::u32(l.$method(r))),
+ (Self::u64(l), Self::u64(r)) => Ok(Self::u64(l.$method(r))),
+ (Self::usize(l), Self::usize(r)) => Ok(Self::usize(l.$method(r))),
+ _ => Err(IncompatibleNumberTypes {
+ left: self.kind().into(),
+ right: rhs.kind().into(),
+ }),
+ }
+ }
+ }
+ };
+}
+
+impl_unsigned_bitwise_op!(BitAnd, bitand);
+impl_unsigned_bitwise_op!(BitOr, bitor);
+impl_unsigned_bitwise_op!(BitXor, bitxor);
+
+impl Not for UnsignedInteger {
+ type Output = Self;
+ fn not(self) -> Self::Output {
+ match self {
+ Self::u8(v) => Self::u8(!v),
+ Self::u16(v) => Self::u16(!v),
+ Self::u32(v) => Self::u32(!v),
+ Self::u64(v) => Self::u64(!v),
+ Self::usize(v) => Self::usize(!v),
+ }
+ }
+}
+
+macro_rules! impl_signed_op {
+ ($trait:ident, $method:ident, $checked:ident, $operator:ident) => {
+ impl $trait for SignedInteger {
+ type Output = Result;
+ fn $method(self, rhs: Self) -> Self::Output {
+ match (self, rhs) {
+ (Self::i8(l), Self::i8(r)) => l.$checked(r).map(Self::i8),
+ (Self::i16(l), Self::i16(r)) => l.$checked(r).map(Self::i16),
+ (Self::i32(l), Self::i32(r)) => l.$checked(r).map(Self::i32),
+ (Self::i64(l), Self::i64(r)) => l.$checked(r).map(Self::i64),
+ (Self::isize(l), Self::isize(r)) => l.$checked(r).map(Self::isize),
+ (Self::Unspecified(l), Self::Unspecified(r)) => {
+ l.$checked(r).map(Self::Unspecified)
+ }
+ _ => {
+ return Err(IncompatibleNumberTypes {
+ left: self.kind().into(),
+ right: rhs.kind().into(),
+ }
+ .into());
+ }
+ }
+ .ok_or_else(|| {
+ InvalidBinaryOperation {
+ left: self.into(),
+ right: rhs.into(),
+ operator: BinaryOperator::$operator,
+ }
+ .into()
+ })
+ }
+ }
+ };
+}
+
+impl_signed_op!(Add, add, checked_add, Add);
+impl_signed_op!(Sub, sub, checked_sub, Sub);
+impl_signed_op!(Mul, mul, checked_mul, Mul);
+impl_signed_op!(Div, div, checked_div, Div);
+impl_signed_op!(Rem, rem, checked_rem, Mod);
+
+macro_rules! impl_signed_bitwise_op {
+ ($trait:ident, $method:ident) => {
+ impl $trait for SignedInteger {
+ type Output = Result;
+ fn $method(self, rhs: Self) -> Self::Output {
+ match (self, rhs) {
+ (Self::i8(l), Self::i8(r)) => Ok(Self::i8(l.$method(r))),
+ (Self::i16(l), Self::i16(r)) => Ok(Self::i16(l.$method(r))),
+ (Self::i32(l), Self::i32(r)) => Ok(Self::i32(l.$method(r))),
+ (Self::i64(l), Self::i64(r)) => Ok(Self::i64(l.$method(r))),
+ (Self::isize(l), Self::isize(r)) => Ok(Self::isize(l.$method(r))),
+ (Self::Unspecified(l), Self::Unspecified(r)) => {
+ Ok(Self::Unspecified(l.$method(r)))
+ }
+ _ => Err(IncompatibleNumberTypes {
+ left: self.kind().into(),
+ right: rhs.kind().into(),
+ }),
+ }
+ }
+ }
+ };
+}
+
+impl_signed_bitwise_op!(BitAnd, bitand);
+impl_signed_bitwise_op!(BitOr, bitor);
+impl_signed_bitwise_op!(BitXor, bitxor);
+
+impl Not for SignedInteger {
+ type Output = Self;
+ fn not(self) -> Self::Output {
+ match self {
+ Self::i8(v) => Self::i8(!v),
+ Self::i16(v) => Self::i16(!v),
+ Self::i32(v) => Self::i32(!v),
+ Self::i64(v) => Self::i64(!v),
+ Self::isize(v) => Self::isize(!v),
+ Self::Unspecified(v) => Self::Unspecified(!v),
+ }
+ }
+}
+
+impl Neg for SignedInteger {
+ type Output = Self;
+ fn neg(self) -> Self::Output {
+ match self {
+ Self::i8(v) => Self::i8(-v),
+ Self::i16(v) => Self::i16(-v),
+ Self::i32(v) => Self::i32(-v),
+ Self::i64(v) => Self::i64(-v),
+ Self::isize(v) => Self::isize(-v),
+ Self::Unspecified(v) => Self::Unspecified(-v),
+ }
+ }
+}
+
+macro_rules! impl_integer_op {
+ ($trait:ident, $method:ident, $operator:ident) => {
+ impl $trait for Integer {
+ type Output = Result;
+ fn $method(self, rhs: Self) -> Self::Output {
+ match (self, rhs) {
+ (Self::Signed(SignedInteger::Unspecified(l)), Self::Unsigned(r)) => {
+ let l_converted =
+ match r {
+ UnsignedInteger::u8(_) => u8::try_from(l)
+ .map(|v| Integer::Unsigned(UnsignedInteger::u8(v))),
+ UnsignedInteger::u16(_) => u16::try_from(l)
+ .map(|v| Integer::Unsigned(UnsignedInteger::u16(v))),
+ UnsignedInteger::u32(_) => u32::try_from(l)
+ .map(|v| Integer::Unsigned(UnsignedInteger::u32(v))),
+ UnsignedInteger::u64(_) => u64::try_from(l)
+ .map(|v| Integer::Unsigned(UnsignedInteger::u64(v))),
+ UnsignedInteger::usize(_) => usize::try_from(l)
+ .map(|v| Integer::Unsigned(UnsignedInteger::usize(v))),
+ }
+ .map_err(|_| ValueOutOfRange {
+ value: l,
+ ty: rhs.kind().into(),
+ })?;
+ l_converted.$method(rhs)
+ }
+ (Self::Unsigned(l), Self::Signed(SignedInteger::Unspecified(r))) => {
+ let r_converted =
+ match l {
+ UnsignedInteger::u8(_) => u8::try_from(r)
+ .map(|v| Integer::Unsigned(UnsignedInteger::u8(v))),
+ UnsignedInteger::u16(_) => u16::try_from(r)
+ .map(|v| Integer::Unsigned(UnsignedInteger::u16(v))),
+ UnsignedInteger::u32(_) => u32::try_from(r)
+ .map(|v| Integer::Unsigned(UnsignedInteger::u32(v))),
+ UnsignedInteger::u64(_) => u64::try_from(r)
+ .map(|v| Integer::Unsigned(UnsignedInteger::u64(v))),
+ UnsignedInteger::usize(_) => usize::try_from(r)
+ .map(|v| Integer::Unsigned(UnsignedInteger::usize(v))),
+ }
+ .map_err(|_| ValueOutOfRange {
+ value: r,
+ ty: l.kind().into(),
+ })?;
+ self.$method(r_converted)
+ }
+ (Self::Signed(SignedInteger::Unspecified(l)), Self::Signed(r)) => match r {
+ SignedInteger::Unspecified(r_val) => pastey::paste! {
+ l.[](r_val)
+ }
+ .map(|v| Self::Signed(SignedInteger::Unspecified(v)))
+ .ok_or_else(|| {
+ InvalidBinaryOperation {
+ left: self.into(),
+ right: rhs.into(),
+ operator: BinaryOperator::$operator,
+ }
+ .into()
+ }),
+ _ => {
+ let l_converted =
+ match r {
+ SignedInteger::i8(_) => i8::try_from(l)
+ .map(|v| Integer::Signed(SignedInteger::i8(v))),
+ SignedInteger::i16(_) => i16::try_from(l)
+ .map(|v| Integer::Signed(SignedInteger::i16(v))),
+ SignedInteger::i32(_) => i32::try_from(l)
+ .map(|v| Integer::Signed(SignedInteger::i32(v))),
+ SignedInteger::i64(_) => i64::try_from(l)
+ .map(|v| Integer::Signed(SignedInteger::i64(v))),
+ SignedInteger::isize(_) => isize::try_from(l)
+ .map(|v| Integer::Signed(SignedInteger::isize(v))),
+ SignedInteger::Unspecified(_) => unreachable!(),
+ }
+ .map_err(|_| ValueOutOfRange {
+ value: l,
+ ty: r.kind().into(),
+ })?;
+ l_converted.$method(rhs)
+ }
+ },
+ (Self::Signed(l), Self::Signed(SignedInteger::Unspecified(r))) => match l {
+ SignedInteger::Unspecified(_) => unreachable!("Caught by arm above"),
+ _ => {
+ let r_converted =
+ match l {
+ SignedInteger::i8(_) => i8::try_from(r)
+ .map(|v| Integer::Signed(SignedInteger::i8(v))),
+ SignedInteger::i16(_) => i16::try_from(r)
+ .map(|v| Integer::Signed(SignedInteger::i16(v))),
+ SignedInteger::i32(_) => i32::try_from(r)
+ .map(|v| Integer::Signed(SignedInteger::i32(v))),
+ SignedInteger::i64(_) => i64::try_from(r)
+ .map(|v| Integer::Signed(SignedInteger::i64(v))),
+ SignedInteger::isize(_) => isize::try_from(r)
+ .map(|v| Integer::Signed(SignedInteger::isize(v))),
+ SignedInteger::Unspecified(_) => unreachable!(),
+ }
+ .map_err(|_| ValueOutOfRange {
+ value: r,
+ ty: l.kind().into(),
+ })?;
+ self.$method(r_converted)
+ }
+ },
+ (Self::Unsigned(l), Self::Unsigned(r)) => Ok(Self::Unsigned(l.$method(r)?)),
+ (Self::Signed(l), Self::Signed(r)) => Ok(Self::Signed(l.$method(r)?)),
+ _ => Err(IncompatibleNumberTypes {
+ left: self.kind().into(),
+ right: rhs.kind().into(),
+ }
+ .into()),
+ }
+ }
+ }
+ };
+}
+
+impl_integer_op!(Add, add, Add);
+impl_integer_op!(Sub, sub, Sub);
+impl_integer_op!(Mul, mul, Mul);
+impl_integer_op!(Div, div, Div);
+impl_integer_op!(Rem, rem, Mod);
+
+macro_rules! impl_integer_bitwise_op {
+ ($trait:ident, $method:ident) => {
+ impl $trait for Integer {
+ type Output = Result;
+ fn $method(self, rhs: Self) -> Self::Output {
+ match (self, rhs) {
+ (Self::Signed(SignedInteger::Unspecified(l)), Self::Unsigned(r)) => {
+ let l_converted =
+ match r {
+ UnsignedInteger::u8(_) => u8::try_from(l)
+ .map(|v| Integer::Unsigned(UnsignedInteger::u8(v))),
+ UnsignedInteger::u16(_) => u16::try_from(l)
+ .map(|v| Integer::Unsigned(UnsignedInteger::u16(v))),
+ UnsignedInteger::u32(_) => u32::try_from(l)
+ .map(|v| Integer::Unsigned(UnsignedInteger::u32(v))),
+ UnsignedInteger::u64(_) => u64::try_from(l)
+ .map(|v| Integer::Unsigned(UnsignedInteger::u64(v))),
+ UnsignedInteger::usize(_) => usize::try_from(l)
+ .map(|v| Integer::Unsigned(UnsignedInteger::usize(v))),
+ }
+ .map_err(|_| ValueOutOfRange {
+ value: l,
+ ty: rhs.kind().into(),
+ })?;
+ l_converted.$method(rhs)
+ }
+ (Self::Unsigned(l), Self::Signed(SignedInteger::Unspecified(r))) => {
+ let r_converted =
+ match l {
+ UnsignedInteger::u8(_) => u8::try_from(r)
+ .map(|v| Integer::Unsigned(UnsignedInteger::u8(v))),
+ UnsignedInteger::u16(_) => u16::try_from(r)
+ .map(|v| Integer::Unsigned(UnsignedInteger::u16(v))),
+ UnsignedInteger::u32(_) => u32::try_from(r)
+ .map(|v| Integer::Unsigned(UnsignedInteger::u32(v))),
+ UnsignedInteger::u64(_) => u64::try_from(r)
+ .map(|v| Integer::Unsigned(UnsignedInteger::u64(v))),
+ UnsignedInteger::usize(_) => usize::try_from(r)
+ .map(|v| Integer::Unsigned(UnsignedInteger::usize(v))),
+ }
+ .map_err(|_| ValueOutOfRange {
+ value: r,
+ ty: l.kind().into(),
+ })?;
+ self.$method(r_converted)
+ }
+ (Self::Signed(SignedInteger::Unspecified(l)), Self::Signed(r)) => match r {
+ SignedInteger::Unspecified(r_val) => {
+ Ok(Self::Signed(SignedInteger::Unspecified(l.$method(r_val))))
+ }
+ _ => {
+ let l_converted =
+ match r {
+ SignedInteger::i8(_) => i8::try_from(l)
+ .map(|v| Integer::Signed(SignedInteger::i8(v))),
+ SignedInteger::i16(_) => i16::try_from(l)
+ .map(|v| Integer::Signed(SignedInteger::i16(v))),
+ SignedInteger::i32(_) => i32::try_from(l)
+ .map(|v| Integer::Signed(SignedInteger::i32(v))),
+ SignedInteger::i64(_) => i64::try_from(l)
+ .map(|v| Integer::Signed(SignedInteger::i64(v))),
+ SignedInteger::isize(_) => isize::try_from(l)
+ .map(|v| Integer::Signed(SignedInteger::isize(v))),
+ SignedInteger::Unspecified(_) => unreachable!(),
+ }
+ .map_err(|_| ValueOutOfRange {
+ value: l,
+ ty: r.kind().into(),
+ })?;
+ l_converted.$method(rhs)
+ }
+ },
+ (Self::Signed(l), Self::Signed(SignedInteger::Unspecified(r))) => match l {
+ SignedInteger::Unspecified(_) => unreachable!("Caught by arm above"),
+ _ => {
+ let r_converted =
+ match l {
+ SignedInteger::i8(_) => i8::try_from(r)
+ .map(|v| Integer::Signed(SignedInteger::i8(v))),
+ SignedInteger::i16(_) => i16::try_from(r)
+ .map(|v| Integer::Signed(SignedInteger::i16(v))),
+ SignedInteger::i32(_) => i32::try_from(r)
+ .map(|v| Integer::Signed(SignedInteger::i32(v))),
+ SignedInteger::i64(_) => i64::try_from(r)
+ .map(|v| Integer::Signed(SignedInteger::i64(v))),
+ SignedInteger::isize(_) => isize::try_from(r)
+ .map(|v| Integer::Signed(SignedInteger::isize(v))),
+ SignedInteger::Unspecified(_) => unreachable!(),
+ }
+ .map_err(|_| ValueOutOfRange {
+ value: r,
+ ty: l.kind().into(),
+ })?;
+ self.$method(r_converted)
+ }
+ },
+ (Self::Unsigned(l), Self::Unsigned(r)) => Ok(Self::Unsigned(l.$method(r)?)),
+ (Self::Signed(l), Self::Signed(r)) => Ok(Self::Signed(l.$method(r)?)),
+ _ => Err(IncompatibleNumberTypes {
+ left: self.kind().into(),
+ right: rhs.kind().into(),
+ }
+ .into()),
+ }
+ }
+ }
+ };
+}
+
+impl_integer_bitwise_op!(BitAnd, bitand);
+impl_integer_bitwise_op!(BitOr, bitor);
+impl_integer_bitwise_op!(BitXor, bitxor);
+
+impl Not for Integer {
+ type Output = Self;
+ fn not(self) -> Self::Output {
+ match self {
+ Self::Unsigned(v) => Self::Unsigned(!v),
+ Self::Signed(v) => Self::Signed(!v),
+ }
+ }
+}
+
+impl Neg for Integer {
+ type Output = Result;
+ fn neg(self) -> Self::Output {
+ match self {
+ Self::Unsigned(_) => Err(CannotNegateUnsignedInteger(self.kind().into())),
+ Self::Signed(v) => Ok(Self::Signed(-v)),
+ }
+ }
+}
+
+macro_rules! impl_float_op {
+ ($trait:ident, $method:ident) => {
+ impl $trait for Float {
+ type Output = Result;
+ fn $method(self, rhs: Self) -> Self::Output {
+ match (self, rhs) {
+ (Self::f32(l), Self::f32(r)) => Ok(Self::f32(l.$method(r))),
+ (Self::f64(l), Self::f64(r)) => Ok(Self::f64(l.$method(r))),
+ (Self::Unspecified(l), Self::Unspecified(r)) => {
+ Ok(Self::Unspecified(l.$method(r)))
+ }
+ (Self::Unspecified(l), Self::f32(r)) => Ok(Self::f32((l as f32).$method(r))),
+ (Self::Unspecified(l), Self::f64(r)) => Ok(Self::f64(l.$method(r))),
+ (Self::f32(l), Self::Unspecified(r)) => Ok(Self::f32(l.$method(r as f32))),
+ (Self::f64(l), Self::Unspecified(r)) => Ok(Self::f64(l.$method(r))),
+ _ => Err(IncompatibleNumberTypes {
+ left: self.kind().into(),
+ right: rhs.kind().into(),
+ }),
+ }
+ }
+ }
+ };
+}
+
+impl_float_op!(Add, add);
+impl_float_op!(Sub, sub);
+impl_float_op!(Mul, mul);
+impl_float_op!(Div, div);
+impl_float_op!(Rem, rem);
+
+impl Neg for Float {
+ type Output = Self;
+ fn neg(self) -> Self::Output {
match self {
- Number::Float(number) => write!(f, "{number} (float)"),
- Number::Integer(number) => write!(f, "{number} (integer)"),
- Number::u8(number) => write!(f, "{number} (u8)"),
- Number::u16(number) => write!(f, "{number} (u16)"),
- Number::u32(number) => write!(f, "{number} (u32)"),
- Number::u64(number) => write!(f, "{number} (u64)"),
- Number::usize(number) => write!(f, "{number} (usize)"),
- Number::i8(number) => write!(f, "{number} (i8)"),
- Number::i16(number) => write!(f, "{number} (i16)"),
- Number::i32(number) => write!(f, "{number} (i32)"),
- Number::i64(number) => write!(f, "{number} (i64)"),
- Number::isize(number) => write!(f, "{number} (isize)"),
- Number::f32(number) => write!(f, "{number} (f32)"),
- Number::f64(number) => write!(f, "{number} (f64)"),
- }
- }
-}
-
-macro_rules! impl_op {
- ($fn:ident, $op:tt, $checked:ident)=> {
- impl Number {
- #[doc = concat!("Performs the `", stringify!($op), "` calculation.")]
- pub fn $fn(left: Number, right: Number, span: Span) -> Result {
- let op_err = || EvalError::InvalidOperation {
- left,
- right,
- operation: stringify!($fn),
- span: span.clone(),
- };
- match (left, right) {
- (Number::u8(left), Number::u8(right)) => Ok(Number::u8(left.$checked(right).ok_or_else(op_err)?)),
- (Number::u16(left), Number::u16(right)) => Ok(Number::u16(left.$checked(right).ok_or_else(op_err)?)),
- (Number::u32(left), Number::u32(right)) => Ok(Number::u32(left.$checked(right).ok_or_else(op_err)?)),
- (Number::u64(left), Number::u64(right)) => Ok(Number::u64(left.$checked(right).ok_or_else(op_err)?)),
- (Number::usize(left), Number::usize(right)) => Ok(Number::usize(left.$checked(right).ok_or_else(op_err)?)),
- (Number::i8(left), Number::i8(right)) => Ok(Number::i8(left.$checked(right).ok_or_else(op_err)?)),
- (Number::i16(left), Number::i16(right)) => Ok(Number::i16(left.$checked(right).ok_or_else(op_err)?)),
- (Number::i32(left), Number::i32(right)) => Ok(Number::i32(left.$checked(right).ok_or_else(op_err)?)),
- (Number::i64(left), Number::i64(right)) => Ok(Number::i64(left.$checked(right).ok_or_else(op_err)?)),
- (Number::isize(left), Number::isize(right)) => Ok(Number::isize(left.$checked(right).ok_or_else(op_err)?)),
- (Number::f32(left), Number::f32(right)) => Ok(Number::f32(left $op right)),
- (Number::f64(left), Number::f64(right)) => Ok(Number::f64(left $op right)),
-
- (Number::Integer(left), Number::u8(right)) => Ok(Number::u8((left as u8).$checked(right).ok_or_else(op_err)?)),
- (Number::Integer(left), Number::u16(right)) => Ok(Number::u16((left as u16).$checked(right).ok_or_else(op_err)?)),
- (Number::Integer(left), Number::u32(right)) => Ok(Number::u32((left as u32).$checked(right).ok_or_else(op_err)?)),
- (Number::Integer(left), Number::u64(right)) => Ok(Number::u64((left as u64).$checked(right).ok_or_else(op_err)?)),
- (Number::Integer(left), Number::usize(right)) => Ok(Number::usize((left as usize).$checked(right).ok_or_else(op_err)?)),
- (Number::Integer(left), Number::i8(right)) => Ok(Number::i8((left as i8).$checked(right).ok_or_else(op_err)?)),
- (Number::Integer(left), Number::i16(right)) => Ok(Number::i16((left as i16).$checked(right).ok_or_else(op_err)?)),
- (Number::Integer(left), Number::i32(right)) => Ok(Number::i32((left as i32).$checked(right).ok_or_else(op_err)?)),
- (Number::Integer(left), Number::i64(right)) => Ok(Number::i64((left as i64).$checked(right).ok_or_else(op_err)?)),
- (Number::Integer(left), Number::isize(right)) => Ok(Number::isize((left as isize).$checked(right).ok_or_else(op_err)?)),
- (Number::Integer(left), Number::Integer(right)) => Ok(Number::Integer(left.$checked(right).ok_or_else(op_err)?)),
- (Number::u8(left), Number::Integer(right)) => Ok(Number::u8(left.$checked(right as u8).ok_or_else(op_err)?)),
- (Number::u16(left), Number::Integer(right)) => Ok(Number::u16(left.$checked(right as u16).ok_or_else(op_err)?)),
- (Number::u32(left), Number::Integer(right)) => Ok(Number::u32(left.$checked(right as u32).ok_or_else(op_err)?)),
- (Number::u64(left), Number::Integer(right)) => Ok(Number::u64(left.$checked(right as u64).ok_or_else(op_err)?)),
- (Number::usize(left), Number::Integer(right)) => Ok(Number::usize(left.$checked(right as usize).ok_or_else(op_err)?)),
- (Number::i8(left), Number::Integer(right)) => Ok(Number::i8(left.$checked(right as i8).ok_or_else(op_err)?)),
- (Number::i16(left), Number::Integer(right)) => Ok(Number::i16(left.$checked(right as i16).ok_or_else(op_err)?)),
- (Number::i32(left), Number::Integer(right)) => Ok(Number::i32(left.$checked(right as i32).ok_or_else(op_err)?)),
- (Number::i64(left), Number::Integer(right)) => Ok(Number::i64(left.$checked(right as i64).ok_or_else(op_err)?)),
- (Number::isize(left), Number::Integer(right)) => Ok(Number::isize(left.$checked(right as isize).ok_or_else(op_err)?)),
-
- (Number::Float(left), Number::f32(right)) => Ok(Number::f32(left as f32 $op right)),
- (Number::Float(left), Number::f64(right)) => Ok(Number::f64(left as f64 $op right)),
- (Number::Float(left), Number::Float(right)) => Ok(Number::Float(left $op right)),
- (Number::f32(left), Number::Float(right)) => Ok(Number::f32(left $op right as f32)),
- (Number::f64(left), Number::Float(right)) => Ok(Number::f64(left $op right as f64)),
- _ => Err(EvalError::IncompatibleNumberTypes {
- left: left.natural_kind(),
- right: right.natural_kind(),
- span
- })
+ Self::f32(v) => Self::f32(-v),
+ Self::f64(v) => Self::f64(-v),
+ Self::Unspecified(v) => Self::Unspecified(-v),
+ }
+ }
+}
+
+macro_rules! impl_number_op {
+ ($trait:ident, $method:ident, $operator:ident) => {
+ impl $trait for Number {
+ type Output = Result;
+ fn $method(self, rhs: Self) -> Self::Output {
+ match (self, rhs) {
+ (Self::Integer(l), Self::Integer(r)) => Ok(Self::Integer(l.$method(r)?)),
+ (Self::Float(l), Self::Float(r)) => Ok(Self::Float(l.$method(r)?)),
+ _ => Err(IncompatibleNumberTypes {
+ left: self.kind(),
+ right: rhs.kind(),
+ }
+ .into()),
}
}
}
};
}
-impl_op!(add, +, checked_add);
-impl_op!(sub, -, checked_sub);
-impl_op!(mul, *, checked_mul);
-impl_op!(div, /, checked_div);
-impl_op!(rem, %, checked_rem);
+impl_number_op!(Add, add, Add);
+impl_number_op!(Sub, sub, Sub);
+impl_number_op!(Mul, mul, Mul);
+impl_number_op!(Div, div, Div);
+impl_number_op!(Rem, rem, Mod);
+
+macro_rules! impl_number_bitwise_op {
+ ($trait:ident, $method:ident, $operator:ident) => {
+ impl $trait for Number {
+ type Output = Result;
+ fn $method(self, rhs: Self) -> Self::Output {
+ match (self, rhs) {
+ (Self::Integer(l), Self::Integer(r)) => Ok(Self::Integer(l.$method(r)?)),
+ _ => Err(NumberError::InvalidBitwiseOperation {
+ operator: BinaryOperator::$operator,
+ operand: self.kind(),
+ }),
+ }
+ }
+ }
+ };
+}
+
+impl_number_bitwise_op!(BitAnd, bitand, And);
+impl_number_bitwise_op!(BitOr, bitor, Or);
+impl_number_bitwise_op!(BitXor, bitxor, Xor);
+
+impl Not for Number {
+ type Output = Result;
+ fn not(self) -> Self::Output {
+ match self {
+ Self::Integer(v) => Ok(Self::Integer(!v)),
+ _ => Err(NumberError::InvalidBitwiseOperation {
+ operator: crate::builtin_parser::parser::BinaryOperator::And, // Dummy
+ operand: self.kind(),
+ }),
+ }
+ }
+}
+
+impl Neg for Number {
+ type Output = Result;
+ fn neg(self) -> Self::Output {
+ match self {
+ Self::Integer(v) => Ok(Self::Integer(
+ v.neg().map_err(NumberError::CannotNegateUnsignedInteger)?,
+ )),
+ Self::Float(v) => Ok(Self::Float(-v)),
+ }
+ }
+}
macro_rules! impl_op_spanned {
($trait:ident, $method:ident) => {
impl $trait for Spanned {
- type Output = Result;
+ type Output = Result>;
fn $method(self, rhs: Self) -> Self::Output {
- let span = self.span.join(rhs.span);
-
- Number::$method(self.value, rhs.value, span)
+ let span = self.span.join(&rhs.span);
+ (self.value.$method(rhs.value)).diagnosed(span)
}
}
};
@@ -230,60 +967,140 @@ impl_op_spanned!(Sub, sub);
impl_op_spanned!(Mul, mul);
impl_op_spanned!(Rem, rem);
-impl Number {
- /// Performs the unary `-` operation.
- pub fn neg(self, span: Span) -> Result {
- match self {
- Number::u8(_) => Err(EvalError::CannotNegateUnsignedInteger(Spanned {
- span,
- value: self,
- })),
- Number::u16(_) => Err(EvalError::CannotNegateUnsignedInteger(Spanned {
- span,
- value: self,
- })),
- Number::u32(_) => Err(EvalError::CannotNegateUnsignedInteger(Spanned {
- span,
- value: self,
- })),
- Number::u64(_) => Err(EvalError::CannotNegateUnsignedInteger(Spanned {
- span,
- value: self,
- })),
- Number::usize(_) => Err(EvalError::CannotNegateUnsignedInteger(Spanned {
- span,
- value: self,
- })),
- Number::i8(number) => Ok(Number::i8(-number)),
- Number::i16(number) => Ok(Number::i16(-number)),
- Number::i32(number) => Ok(Number::i32(-number)),
- Number::i64(number) => Ok(Number::i64(-number)),
- Number::isize(number) => Ok(Number::isize(-number)),
- Number::f32(number) => Ok(Number::f32(-number)),
- Number::f64(number) => Ok(Number::f64(-number)),
- Number::Float(number) => Ok(Number::Float(-number)),
- Number::Integer(number) => Ok(Number::Integer(-number)),
- }
- }
-}
-
-macro_rules! from_primitive {
- ($primitive:ident) => {
- impl From<$primitive> for Number {
- fn from(value: $primitive) -> Self {
- Number::$primitive(value)
+impl_op_spanned!(BitAnd, bitand);
+impl_op_spanned!(BitOr, bitor);
+impl_op_spanned!(BitXor, bitxor);
+
+macro_rules! from_primitive_integer {
+ ($($primitive:ident => $group:ident, $enum:ident, $variant:ident),+) => {
+ $(
+ impl From<$primitive> for Number {
+ fn from(value: $primitive) -> Self {
+ Number::Integer(Integer::$group($enum::$variant(value)))
+ }
}
- }
+ impl From<$primitive> for Integer {
+ fn from(value: $primitive) -> Self {
+ Integer::$group($enum::$variant(value))
+ }
+ }
+ impl From<$primitive> for $enum {
+ fn from(value: $primitive) -> Self {
+ $enum::$variant(value)
+ }
+ }
+ )+
+ };
+}
+
+from_primitive_integer!(
+ u8 => Unsigned, UnsignedInteger, u8,
+ u16 => Unsigned, UnsignedInteger, u16,
+ u32 => Unsigned, UnsignedInteger, u32,
+ u64 => Unsigned, UnsignedInteger, u64,
+ usize => Unsigned, UnsignedInteger, usize,
+ i8 => Signed, SignedInteger, i8,
+ i16 => Signed, SignedInteger, i16,
+ i32 => Signed, SignedInteger, i32,
+ i64 => Signed, SignedInteger, i64,
+ isize => Signed, SignedInteger, isize
+);
+
+macro_rules! from_primitive_float {
+ ($($primitive:ident => $enum:ident, $variant:ident),+) => {
+ $(
+ impl From<$primitive> for Number {
+ fn from(value: $primitive) -> Self {
+ Number::Float($enum::$variant(value))
+ }
+ }
+ impl From<$primitive> for Float {
+ fn from(value: $primitive) -> Self {
+ Float::$variant(value)
+ }
+ }
+ )+
};
}
-from_primitive!(u8);
-from_primitive!(u16);
-from_primitive!(u32);
-from_primitive!(u64);
-from_primitive!(i8);
-from_primitive!(i16);
-from_primitive!(i32);
-from_primitive!(i64);
-from_primitive!(f32);
-from_primitive!(f64);
+from_primitive_float!(
+ f32 => Float, f32,
+ f64 => Float, f64
+);
+
+impl From for Number {
+ fn from(value: Integer) -> Self {
+ Number::Integer(value)
+ }
+}
+impl From for Number {
+ fn from(value: UnsignedInteger) -> Self {
+ Number::Integer(Integer::Unsigned(value))
+ }
+}
+impl From for Number {
+ fn from(value: SignedInteger) -> Self {
+ Number::Integer(Integer::Signed(value))
+ }
+}
+impl From for Integer {
+ fn from(value: UnsignedInteger) -> Self {
+ Integer::Unsigned(value)
+ }
+}
+impl From for Integer {
+ fn from(value: SignedInteger) -> Self {
+ Integer::Signed(value)
+ }
+}
+impl From for Number {
+ fn from(value: Float) -> Self {
+ Number::Float(value)
+ }
+}
+
+impl From for NumberKind {
+ fn from(kind: IntegerKind) -> Self {
+ NumberKind::Integer(kind)
+ }
+}
+impl From for IntegerKind {
+ fn from(kind: UnsignedIntegerKind) -> Self {
+ IntegerKind::Unsigned(kind)
+ }
+}
+impl From for IntegerKind {
+ fn from(kind: SignedIntegerKind) -> Self {
+ IntegerKind::Signed(kind)
+ }
+}
+impl From for NumberKind {
+ fn from(kind: UnsignedIntegerKind) -> Self {
+ NumberKind::Integer(IntegerKind::Unsigned(kind))
+ }
+}
+impl From for NumberKind {
+ fn from(kind: SignedIntegerKind) -> Self {
+ NumberKind::Integer(IntegerKind::Signed(kind))
+ }
+}
+impl From for NumberKind {
+ fn from(kind: FloatKind) -> Self {
+ NumberKind::Float(kind)
+ }
+}
+
+impl From> for Diagnostic {
+ fn from(diagnostic: Diagnostic) -> Self {
+ Diagnostic {
+ spans: diagnostic.spans,
+ error: Box::new(EvalError::Number(*diagnostic.error)),
+ }
+ }
+}
+
+impl From for EvalError {
+ fn from(error: CannotNegateUnsignedInteger) -> Self {
+ EvalError::Number(NumberError::CannotNegateUnsignedInteger(error))
+ }
+}
diff --git a/src/builtin_parser/parser.rs b/src/builtin_parser/parser.rs
index a248b40..44efa86 100644
--- a/src/builtin_parser/parser.rs
+++ b/src/builtin_parser/parser.rs
@@ -1,282 +1,51 @@
//! Generates an abstract syntax tree from a list of tokens.
+mod ast;
+mod error;
+#[cfg(test)]
+mod tests;
+
+pub use ast::*;
+pub use error::*;
+
use logos::Span;
use std::collections::HashMap;
use std::num::IntErrorKind;
-use crate::command::{CommandHint, CommandHintColor};
+use crate::builtin_parser::number::{
+ Float, NumberKind, SignedInteger, SignedIntegerKind, UnsignedInteger, UnsignedIntegerKind,
+};
use super::lexer::{FailedToLexCharacter, Token, TokenStream};
use super::number::Number;
use super::runner::environment::Function;
-use super::{Environment, SpanExtension, Spanned};
-
-/// An [Abstract Syntax Tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
-///
-/// This type represents a list of expressions, which is what makes up a command.
-pub type Ast = Vec>;
+use super::{Diagnostic, Environment, SpanExtension, Spanned};
macro_rules! expect {
($tokens:ident, $($token:tt)+) => {
match $tokens.next() {
Some(Ok($($token)+)) => ($($token)+) ,
Some(Ok(token)) => {
- return Err(ParseError::ExpectedTokenButGot {
+ return Err($tokens.span().wrap(ParseError::ExpectedTokenButGot {
expected: $($token)+,
got: token,
- span: $tokens.span(),
- })
+ }).into())
}
Some(Err(FailedToLexCharacter)) => {
- return Err(ParseError::FailedToLexCharacters($tokens.span().wrap($tokens.slice().to_string())))
+ return Err($tokens.span().diagnose(ParseError::FailedToLexCharacters($tokens.slice().to_owned())))
}
- None => return Err(ParseError::ExpectedMoreTokens($tokens.span())),
+ None => return Err($tokens.span().diagnose(ParseError::ExpectedMoreTokens)),
}
};
}
-/// A type that represents an expression.
-#[derive(Debug, Clone)]
-pub enum Expression {
- // Primitives
- None,
- Boolean(bool),
- Number(Number),
- Variable(String),
- String(String),
- Borrow(Box>),
- Dereference(Box>),
- Object(HashMap>),
- StructObject {
- name: String,
- map: HashMap>,
- },
- Tuple(Vec>),
- StructTuple {
- name: String,
- tuple: Vec>,
- },
-
- // Expressions
- BinaryOp {
- left: Box>,
- operator: Operator,
- right: Box>,
- },
- UnaryOp(Box>),
- Member {
- left: Box>,
- right: Spanned,
- },
-
- // Statement-like
- VarAssign {
- name: Box>,
- value: Box>,
- },
- Function {
- name: String,
- arguments: Vec>,
- },
- ForLoop {
- index_name: String,
- loop_count: u64,
- block: Ast,
- },
-}
-
-/// A singular element access within a [`Expression::Member`].
-///
-/// Based on `bevy_reflect`'s `Access`.
-#[derive(Debug, Clone)]
-pub enum Access {
- /// A name-based field access on a struct.
- Field(String),
- /// An index-based access on a tuple.
- TupleIndex(usize),
- // /// An index-based access on a list.
- // ListIndex(usize),
-}
-pub enum AccessKind {
- Field,
- TupleIndex,
-}
-impl Access {
- pub const fn kind(&self) -> AccessKind {
- match self {
- Access::Field(_) => AccessKind::Field,
- Access::TupleIndex(_) => AccessKind::TupleIndex,
- }
- }
- /// Returns the kind of [`Access`] as a [string slice](str) with an `a` or `an` prepended to it.
- /// Used for more natural sounding error messages.
- pub const fn natural_kind(&self) -> &'static str {
- self.kind().natural()
- }
-}
-
-impl AccessKind {
- /// Returns the kind of [`Access`] as a [string slice](str) with an `a` or `an` prepended to it.
- /// Used for more natural sounding error messages.
- pub const fn natural(&self) -> &'static str {
- match self {
- AccessKind::Field => "a field",
- AccessKind::TupleIndex => "a tuple",
- }
- }
-}
-
-/// Get the access if its of a certain type, if not, return a [`EvalError`](super::runner::error::EvalError).
-///
-/// For examples, take a look at existing uses in the code.
-macro_rules! access_unwrap {
- ($expected:literal, $($variant:ident($variant_inner:ident))|+ = $val:expr => $block:block) => {{
- let val = $val;
- if let $(Access::$variant($variant_inner))|+ = val.value $block else {
- use $crate::builtin_parser::parser::AccessKind;
- use $crate::builtin_parser::runner::error::EvalError;
-
- // We have to put this in a `const` first to avoid a
- // `temporary value dropped while borrowed` error.
- const EXPECTED_ACCESS: &[&str] = &[$(AccessKind::$variant.natural()),+];
- Err(EvalError::IncorrectAccessOperation {
- span: val.span,
- expected_access: EXPECTED_ACCESS,
- expected_type: $expected,
- got: val.value,
- })?
- }
- }};
-}
-pub(crate) use access_unwrap;
-
-impl Expression {
- pub const fn kind(&self) -> &'static str {
- match self {
- Expression::None => "nothing",
- Expression::Boolean(..) => "a boolean",
- Expression::Number(..) => "a number",
- Expression::Variable(..) => "a variable name",
- Expression::String(..) => "a string",
- Expression::Borrow(..) => "a borrow",
- Expression::Dereference(..) => "a dereference",
- Expression::Object(..) => "an object",
- Expression::StructObject { .. } => "a struct object",
- Expression::Tuple(..) => "a tuple",
- Expression::StructTuple { .. } => "a struct tuple",
-
- Expression::BinaryOp { .. } => "a binary operation",
- Expression::UnaryOp(..) => "a unary operation",
- Expression::Member { .. } => "a member expression",
- Expression::VarAssign { .. } => "a variable assignment",
- Expression::Function { .. } => "a function call",
- Expression::ForLoop { .. } => "a for loop",
- }
- }
-}
-
-#[derive(Debug, Clone)]
-pub enum Operator {
- Add,
- Sub,
- Mul,
- Div,
- Mod,
-}
-
-#[derive(Debug)]
-pub enum ParseError {
- FailedToLexCharacters(Spanned),
- ExpectedMoreTokens(Span),
- ExpectedTokenButGot {
- expected: Token,
- got: Token,
- span: Span,
- },
- ExpectedEndline(Spanned),
- ExpectedLiteral(Spanned),
- InvalidSuffixForFloat(Spanned),
- NegativeIntOverflow {
- span: Span,
- number: String,
- number_kind: &'static str,
- },
- PositiveIntOverflow {
- span: Span,
- number: String,
- number_kind: &'static str,
- },
- ExpectedObjectContinuation(Spanned>>),
- ExpectedIndexer {
- got: Token,
- span: Span,
- },
- UnsupportedLoop {
- ty: &'static str,
- span: Span,
- },
-}
-
-impl ParseError {
- pub fn span(&self) -> Span {
- use ParseError as E;
-
- match self {
- E::FailedToLexCharacters(Spanned { span, value: _ }) => span,
- E::ExpectedMoreTokens(span) => span,
- E::ExpectedTokenButGot { span, .. } => span,
- E::ExpectedEndline(Spanned { span, value: _ }) => span,
- E::ExpectedLiteral(Spanned { span, value: _ }) => span,
- E::InvalidSuffixForFloat(Spanned { span, value: _ }) => span,
- E::PositiveIntOverflow { span, .. } => span,
- E::NegativeIntOverflow { span, .. } => span,
- E::ExpectedObjectContinuation(Spanned { span, value: _ }) => span,
- E::ExpectedIndexer { got: _, span } => span,
- E::UnsupportedLoop { ty: _, span } => span,
- }
- .clone()
- }
-
- pub fn hint(&self) -> CommandHint {
- CommandHint {
- color: CommandHintColor::Error,
- span: self.span(),
- description: self.to_string().into(),
- }
- }
-}
-
-impl std::fmt::Display for ParseError {
- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- use ParseError as E;
-
- match self {
- E::FailedToLexCharacters(Spanned { span: _, value }) => write!(f, "Invalid character(s) \"{value}\" (Did you mean to use a string?)"),
- E::ExpectedMoreTokens(_) => write!(f, "Expected more tokens, got nothing."),
- E::ExpectedTokenButGot {
- expected,
- got,
- span: _,
- } => write!(f, "Expected token {expected:?}, got token {got:?} instead."),
- E::ExpectedEndline(_) => write!(f, "Expected a semicolon or endline after a complete statement, but got more tokens than expected."),
- E::ExpectedLiteral(Spanned { span: _, value }) => write!(f, "Expected a literal token, got {value:?} which is not a valid literal."),
- E::InvalidSuffixForFloat(Spanned { span: _, value: suffix }) => write!(f, r#""{suffix}" is an invalid suffix for a float. The only valid suffixes are "f32" and "f64"."#),
- E::NegativeIntOverflow { span: _, number, number_kind } => write!(f, "{number} cannot be represented as a {number_kind} as it is too small."),
- E::PositiveIntOverflow { span: _, number, number_kind } => write!(f, "{number} cannot be represented as a {number_kind} as it is too large."),
- E::ExpectedObjectContinuation(Spanned { span: _, value: got }) => write!(f, "Expected a continuation to the object declaration (such as a comma or a closing bracket), but got {got:?} instead."),
- E::ExpectedIndexer { got, span: _ } => write!(f, "Expected an identifier or integer when accessing member of variable, got {got:?} instead."),
- E::UnsupportedLoop { ty, span : _} => write!(f, "{ty} loops are not yet supported. See issue #8.")
- }
- }
-}
-impl std::error::Error for ParseError {}
-
const FLOAT_PARSE_EXPECT_REASON: &str =
"Float parsing errors are handled by the lexer, and floats cannot overflow.";
-const NUMBER_TYPE_WILDCARD_UNREACHABLE_REASON: &str =
- "Lexer guarantees `NumberType`'s slice to be included one of the match arms.";
-pub fn parse(tokens: &mut TokenStream, environment: &Environment) -> Result {
+pub fn parse(
+ tokens: &mut TokenStream,
+ environment: &Environment,
+) -> Result> {
let mut ast = Vec::new();
while tokens.peek().is_some() {
@@ -284,11 +53,17 @@ pub fn parse(tokens: &mut TokenStream, environment: &Environment) -> Result continue,
- Some(Ok(token)) => return Err(ParseError::ExpectedEndline(tokens.span().wrap(token))),
+ Some(Ok(token)) => {
+ return Err(tokens
+ .span()
+ .wrap(ParseError::ExpectedEndline(token))
+ .into());
+ }
Some(Err(FailedToLexCharacter)) => {
- return Err(ParseError::FailedToLexCharacters(
- tokens.span().wrap(tokens.slice().to_string()),
- ))
+ return Err(tokens
+ .span()
+ .wrap(ParseError::FailedToLexCharacters(tokens.slice().to_owned()))
+ .into());
}
None => break,
}
@@ -300,20 +75,37 @@ pub fn parse(tokens: &mut TokenStream, environment: &Environment) -> Result Result, ParseError> {
+) -> Result, Diagnostic> {
match tokens.peek() {
- Some(Ok(Token::Loop)) => Err(ParseError::UnsupportedLoop {
- ty: "infinite",
- span: tokens.peek_span(),
- }),
- Some(Ok(Token::While)) => Err(ParseError::UnsupportedLoop {
- ty: "while",
- span: tokens.peek_span(),
- }),
- Some(Ok(Token::For)) => Err(ParseError::UnsupportedLoop {
- ty: "for",
- span: tokens.peek_span(),
- }),
+ Some(Ok(Token::Loop)) => Err(tokens
+ .peek_span()
+ .wrap(ParseError::UnsupportedFeature {
+ feature: "infinite loops",
+ issue: 8,
+ })
+ .into()),
+ Some(Ok(Token::While)) => Err(tokens
+ .peek_span()
+ .wrap(ParseError::UnsupportedFeature {
+ feature: "while loops",
+ issue: 8,
+ })
+ .into()),
+ Some(Ok(Token::For)) => Err(tokens
+ .peek_span()
+ .wrap(ParseError::UnsupportedFeature {
+ feature: "for loops",
+ issue: 8,
+ })
+ .into()),
+ Some(Ok(Token::If)) => Err(tokens
+ .skip_one()
+ .span_until(Token::RightBracket)
+ .wrap(ParseError::UnsupportedFeature {
+ feature: "if statements",
+ issue: 0,
+ })
+ .into()),
Some(Ok(_)) => {
let expr = parse_additive(tokens, environment)?;
@@ -322,37 +114,45 @@ fn parse_expression(
_ => Ok(expr),
}
}
- Some(Err(FailedToLexCharacter)) => Err(ParseError::FailedToLexCharacters(
- tokens.peek_span().wrap(tokens.slice().to_string()),
- )),
- None => Err(ParseError::ExpectedMoreTokens(tokens.peek_span())),
+ Some(Err(FailedToLexCharacter)) => Err(tokens
+ .peek_span()
+ .wrap(ParseError::FailedToLexCharacters(tokens.slice().to_owned()))
+ .into()),
+ None => Err(tokens
+ .peek_span()
+ .wrap(ParseError::ExpectedMoreTokens)
+ .into()),
}
}
-fn _parse_block(tokens: &mut TokenStream, environment: &Environment) -> Result {
+fn _parse_block(
+ tokens: &mut TokenStream,
+ environment: &Environment,
+) -> Result> {
expect!(tokens, Token::LeftBracket);
let ast = parse(tokens, environment)?;
expect!(tokens, Token::RightBracket);
+
Ok(ast)
}
fn parse_additive(
tokens: &mut TokenStream,
environment: &Environment,
-) -> Result, ParseError> {
+) -> Result, Diagnostic> {
let mut node = parse_multiplicitive(tokens, environment)?;
while let Some(Ok(Token::Plus | Token::Minus)) = tokens.peek() {
let operator = match tokens.next() {
- Some(Ok(Token::Plus)) => Operator::Add,
- Some(Ok(Token::Minus)) => Operator::Sub,
+ Some(Ok(Token::Plus)) => BinaryOperator::Add,
+ Some(Ok(Token::Minus)) => BinaryOperator::Sub,
_ => unreachable!(),
};
let right = parse_multiplicitive(tokens, environment)?;
node = Spanned {
- span: node.span.start..right.span.end,
+ span: node.span.join(&right.span),
value: Expression::BinaryOp {
left: Box::new(node),
operator,
@@ -366,18 +166,18 @@ fn parse_additive(
fn parse_multiplicitive(
tokens: &mut TokenStream,
environment: &Environment,
-) -> Result, ParseError> {
- let mut node = parse_value(tokens, environment)?;
+) -> Result, Diagnostic> {
+ let mut node = parse_and(tokens, environment)?;
while let Some(Ok(Token::Asterisk | Token::Slash | Token::Modulo)) = tokens.peek() {
let operator = match tokens.next() {
- Some(Ok(Token::Asterisk)) => Operator::Mul,
- Some(Ok(Token::Slash)) => Operator::Div,
- Some(Ok(Token::Modulo)) => Operator::Mod,
+ Some(Ok(Token::Asterisk)) => BinaryOperator::Mul,
+ Some(Ok(Token::Slash)) => BinaryOperator::Div,
+ Some(Ok(Token::Modulo)) => BinaryOperator::Mod,
_ => unreachable!(),
};
- let right = parse_value(tokens, environment)?;
+ let right = parse_and(tokens, environment)?;
node = Spanned {
span: node.span.start..right.span.end,
@@ -391,16 +191,45 @@ fn parse_multiplicitive(
Ok(node)
}
+macro_rules! parse_bitwise {
+ ($op:ident, $token:ident: $name:ident => $next:ident) => {
+ fn $name(
+ tokens: &mut TokenStream,
+ environment: &Environment,
+ ) -> Result, Diagnostic> {
+ let mut node = $next(tokens, environment)?;
+
+ while let Some(Ok(Token::$token)) = tokens.peek() {
+ tokens.next();
+ let right = $next(tokens, environment)?;
+
+ node = Spanned {
+ span: node.span.start..right.span.end,
+ value: Expression::BinaryOp {
+ left: Box::new(node),
+ operator: BinaryOperator::$op,
+ right: Box::new(right),
+ },
+ };
+ }
+
+ Ok(node)
+ }
+ };
+}
+parse_bitwise!(And, Ampersand: parse_and => parse_xor);
+parse_bitwise!(Xor, Xor: parse_xor => parse_or);
+parse_bitwise!(Or, Pipe: parse_or => parse_value);
fn parse_value(
tokens: &mut TokenStream,
environment: &Environment,
-) -> Result, ParseError> {
+) -> Result, Diagnostic> {
/// Parses a literal (value without member expressions)
fn parse_literal(
tokens: &mut TokenStream,
environment: &Environment,
- ) -> Result, ParseError> {
+ ) -> Result, Diagnostic> {
match tokens.next() {
Some(Ok(Token::LeftParen)) => {
let start = tokens.span().start;
@@ -437,7 +266,7 @@ fn parse_value(
}
Some(Ok(Token::Identifier)) => {
let start = tokens.span().start;
- let name = tokens.slice().to_string();
+ let name = tokens.slice().to_owned();
match tokens.peek() {
Some(Ok(Token::LeftParen)) => {
@@ -475,13 +304,21 @@ fn parse_value(
if let Some(Function { argument_count, .. }) =
environment.get_function(&name)
{
- dbg!(argument_count);
-
let mut arguments = Vec::new();
for _ in 0..(*argument_count) {
let expr = parse_expression(tokens, environment)?;
arguments.push(expr);
}
+ while !matches!(
+ tokens.peek(),
+ Some(Ok(Token::SemiColon
+ | Token::RightBrace
+ | Token::RightBracket
+ | Token::RightParen))
+ ) && let Ok(additional) = parse_expression(tokens, environment)
+ {
+ arguments.push(additional);
+ }
Ok(Spanned {
span: start..tokens.span().end,
value: Expression::Function { name, arguments },
@@ -502,12 +339,19 @@ fn parse_value(
}
Some(Ok(Token::String)) => {
let slice = tokens.slice();
- let string = slice[1..slice.len() - 1].to_string();
+ let string = slice[1..slice.len() - 1].to_owned();
Ok(tokens.span().wrap(Expression::String(string)))
}
- Some(Ok(Token::Minus)) => {
+ Some(Ok(token @ (Token::Minus | Token::Not))) => {
let expr = parse_literal(tokens, environment)?;
- Ok(tokens.span().wrap(Expression::UnaryOp(Box::new(expr))))
+ Ok(tokens.span().wrap(Expression::UnaryOp {
+ operator: match token {
+ Token::Minus => UnaryOperator::Minus,
+ Token::Not => UnaryOperator::Not,
+ _ => unreachable!(),
+ },
+ operand: Box::new(expr),
+ }))
}
Some(Ok(Token::Ampersand)) => {
let expr = parse_literal(tokens, environment)?;
@@ -522,44 +366,68 @@ fn parse_value(
parse_number(tokens).map(|s| s.map(Expression::Number))
}
Some(Ok(Token::FloatNumber)) => {
- if let Some(Ok(Token::NumberType)) = tokens.peek() {
- let number: Number = match tokens.peek_slice() {
- "u8" | "u16" | "u32" | "u64" | "usize" | "i8" | "i16" | "i32" | "i64"
- | "isize" => Err(ParseError::InvalidSuffixForFloat(
- tokens.span().wrap(tokens.slice().to_string()),
- ))?,
- "f32" => {
- Number::f32(tokens.slice().parse().expect(FLOAT_PARSE_EXPECT_REASON))
- }
- "f64" => {
- Number::f64(tokens.slice().parse().expect(FLOAT_PARSE_EXPECT_REASON))
- }
- _ => unreachable!("{NUMBER_TYPE_WILDCARD_UNREACHABLE_REASON}"),
- };
- let start_span = tokens.span().end;
-
- tokens.next();
-
- Ok(Spanned {
- span: start_span..tokens.span().end,
- value: Expression::Number(number),
- })
- } else {
- let number = Number::Float(tokens.slice().parse().unwrap());
+ let (number, suffix) = split_number(tokens);
+ let number: Number = match suffix {
+ "u8" | "u16" | "u32" | "u64" | "usize" | "i8" | "i16" | "i32" | "i64"
+ | "isize" => Err(Diagnostic::single(
+ tokens.span().add(number.len()..0),
+ ParseError::IntegerSuffixOnFloat(suffix.to_owned()),
+ ))?,
+ "f32" => {
+ Number::Float(Float::f32(number.parse().expect(FLOAT_PARSE_EXPECT_REASON)))
+ }
+ "f64" => {
+ Number::Float(Float::f64(number.parse().expect(FLOAT_PARSE_EXPECT_REASON)))
+ }
+ "" => Number::Float(Float::Unspecified(
+ number.parse().expect(FLOAT_PARSE_EXPECT_REASON),
+ )),
+ _ => {
+ return Err(tokens
+ .span()
+ .add(number.len()..0)
+ .wrap(ParseError::InvalidSuffixForFloat(suffix.to_owned()))
+ .into());
+ }
+ };
+ let start_span = tokens.span().end;
- Ok(Spanned {
- span: tokens.span(),
- value: Expression::Number(number),
- })
- }
+ Ok(Spanned {
+ span: start_span..tokens.span().end,
+ value: Expression::Number(number),
+ })
}
Some(Ok(Token::True)) => Ok(tokens.span().wrap(Expression::Boolean(true))),
Some(Ok(Token::False)) => Ok(tokens.span().wrap(Expression::Boolean(false))),
- Some(Ok(token)) => Err(ParseError::ExpectedLiteral(tokens.span().wrap(token))),
- Some(Err(FailedToLexCharacter)) => Err(ParseError::FailedToLexCharacters(
- tokens.span().wrap(tokens.slice().to_string()),
- )),
- None => Err(ParseError::ExpectedMoreTokens(tokens.span())),
+ Some(Ok(Token::LeftBrace)) => Err(tokens
+ .span_until(Token::RightBrace)
+ .wrap(ParseError::UnsupportedFeature {
+ feature: "lists and vectors",
+ issue: 10,
+ })
+ .into()),
+ Some(Ok(Token::Pipe)) => Err(tokens
+ .span_until(Token::Pipe)
+ .wrap(ParseError::UnsupportedFeature {
+ feature: "closures",
+ issue: 12,
+ })
+ .into()),
+ Some(Ok(Token::RightBrace | Token::RightBracket | Token::RightParen)) => Err(tokens
+ .span()
+ .wrap(ParseError::MismatchedDelimiter {
+ delimiter: tokens.slice().chars().next().unwrap(),
+ })
+ .into()),
+ Some(Ok(token)) => Err(tokens
+ .span()
+ .wrap(ParseError::ExpectedLiteral(token))
+ .into()),
+ Some(Err(FailedToLexCharacter)) => Err(tokens
+ .span()
+ .wrap(ParseError::FailedToLexCharacters(tokens.slice().to_owned()))
+ .into()),
+ None => Err(tokens.span().diagnose(ParseError::ExpectedMoreTokens)),
}
}
@@ -569,7 +437,7 @@ fn parse_value(
tokens.next(); // Skip the dot
match tokens.next() {
Some(Ok(Token::Identifier)) => {
- let right = tokens.slice().to_string();
+ let right = tokens.slice().to_owned();
expr = Spanned {
span: expr.span.start..tokens.span().end,
value: Expression::Member {
@@ -582,7 +450,7 @@ fn parse_value(
let right = tokens.slice().parse().map_err(map_parseint_error(
tokens.span(),
tokens.slice(),
- "usize",
+ UnsignedIntegerKind::usize.into(),
))?;
expr = Spanned {
@@ -594,17 +462,18 @@ fn parse_value(
};
}
Some(Ok(token)) => {
- return Err(ParseError::ExpectedIndexer {
- got: token,
- span: tokens.span(),
- })
+ return Err(tokens
+ .span()
+ .wrap(ParseError::ExpectedIndexer { got: token })
+ .into());
}
Some(Err(FailedToLexCharacter)) => {
- return Err(ParseError::FailedToLexCharacters(
- tokens.span().wrap(tokens.slice().to_string()),
- ))
+ return Err(tokens
+ .span()
+ .wrap(ParseError::FailedToLexCharacters(tokens.slice().to_owned()))
+ .into());
}
- None => return Err(ParseError::ExpectedMoreTokens(tokens.span())),
+ None => return Err(tokens.span().diagnose(ParseError::ExpectedMoreTokens)),
}
}
Ok(expr)
@@ -613,103 +482,114 @@ fn parse_value(
fn map_parseint_error<'s>(
span: Span,
slice: &'s str,
- number_kind: &'static str,
-) -> impl FnOnce(std::num::ParseIntError) -> ParseError + 's {
- move |error| match error.kind() {
- IntErrorKind::PosOverflow => ParseError::PositiveIntOverflow {
- span,
- number: slice.to_string(),
- number_kind,
- },
- IntErrorKind::NegOverflow => ParseError::NegativeIntOverflow {
- span,
- number: slice.to_string(),
- number_kind,
- },
- IntErrorKind::Empty | IntErrorKind::InvalidDigit | IntErrorKind::Zero => unreachable!(
- "Lexer makes sure other errors aren't possible. Create an bevy_dev_console issue!"
- ),
- _ => unimplemented!(), // Required due to IntErrorKind being #[non_exhaustive]
+ number_kind: crate::builtin_parser::number::NumberKind,
+) -> impl FnOnce(std::num::ParseIntError) -> Diagnostic + 's {
+ move |error| {
+ let error = match error.kind() {
+ IntErrorKind::PosOverflow => ParseError::PositiveIntOverflow {
+ number: slice.to_owned(),
+ number_kind,
+ },
+ IntErrorKind::NegOverflow => ParseError::NegativeIntOverflow {
+ number: slice.to_owned(),
+ number_kind,
+ },
+ IntErrorKind::Empty | IntErrorKind::InvalidDigit | IntErrorKind::Zero => unreachable!(
+ "Lexer makes sure other errors aren't possible. Create an bevy_dev_console issue!"
+ ),
+ _ => unimplemented!(), // Required due to IntErrorKind being #[non_exhaustive]
+ };
+ span.diagnose(error)
}
}
-fn parse_number(tokens: &mut TokenStream) -> Result, ParseError> {
- if let Some(Ok(Token::NumberType)) = tokens.peek() {
- let number: Number = match tokens.peek_slice() {
- "u8" => Number::u8(tokens.slice().parse().map_err(map_parseint_error(
- tokens.span(),
- tokens.slice(),
- "u8",
- ))?),
- "u16" => Number::u16(tokens.slice().parse().map_err(map_parseint_error(
- tokens.span(),
- tokens.slice(),
- "u16",
- ))?),
- "u32" => Number::u32(tokens.slice().parse().map_err(map_parseint_error(
- tokens.span(),
- tokens.slice(),
- "u32",
- ))?),
- "u64" => Number::u64(tokens.slice().parse().map_err(map_parseint_error(
- tokens.span(),
- tokens.slice(),
- "u64",
- ))?),
- "usize" => Number::usize(tokens.slice().parse().map_err(map_parseint_error(
- tokens.span(),
- tokens.slice(),
- "usize",
- ))?),
- "i8" => Number::i8(tokens.slice().parse().map_err(map_parseint_error(
- tokens.span(),
- tokens.slice(),
- "i8",
- ))?),
- "i16" => Number::i16(tokens.slice().parse().map_err(map_parseint_error(
- tokens.span(),
- tokens.slice(),
- "i16",
- ))?),
- "i32" => Number::i32(tokens.slice().parse().map_err(map_parseint_error(
- tokens.span(),
- tokens.slice(),
- "i32",
- ))?),
- "isize" => Number::isize(tokens.slice().parse().map_err(map_parseint_error(
- tokens.span(),
- tokens.slice(),
- "isize",
- ))?),
- "f32" => Number::f32(tokens.slice().parse().expect(FLOAT_PARSE_EXPECT_REASON)),
- "f64" => Number::f64(tokens.slice().parse().expect(FLOAT_PARSE_EXPECT_REASON)),
- _ => unreachable!("{}", NUMBER_TYPE_WILDCARD_UNREACHABLE_REASON),
- };
- let start_span = tokens.span().end;
- tokens.next();
+fn parse_number(tokens: &mut TokenStream) -> Result, Diagnostic> {
+ let (number, suffix) = split_number(tokens);
+ let map = |s: NumberKind| map_parseint_error(tokens.span(), tokens.slice(), s);
+
+ let number = match suffix {
+ "u8" => UnsignedInteger::u8(
+ number
+ .parse()
+ .map_err(map(UnsignedIntegerKind::u8.into()))?,
+ )
+ .into(),
+ "u16" => UnsignedInteger::u16(
+ number
+ .parse()
+ .map_err(map(UnsignedIntegerKind::u16.into()))?,
+ )
+ .into(),
+ "u32" => UnsignedInteger::u32(
+ number
+ .parse()
+ .map_err(map(UnsignedIntegerKind::u32.into()))?,
+ )
+ .into(),
+ "u64" => UnsignedInteger::u64(
+ number
+ .parse()
+ .map_err(map(UnsignedIntegerKind::u64.into()))?,
+ )
+ .into(),
+ "usize" => UnsignedInteger::usize(
+ number
+ .parse()
+ .map_err(map(UnsignedIntegerKind::usize.into()))?,
+ )
+ .into(),
+ "i8" => {
+ SignedInteger::i8(number.parse().map_err(map(SignedIntegerKind::i8.into()))?).into()
+ }
+ "i16" => {
+ SignedInteger::i16(number.parse().map_err(map(SignedIntegerKind::i16.into()))?).into()
+ }
+ "i32" => {
+ SignedInteger::i32(number.parse().map_err(map(SignedIntegerKind::i32.into()))?).into()
+ }
+ "isize" => SignedInteger::isize(
+ number
+ .parse()
+ .map_err(map(SignedIntegerKind::isize.into()))?,
+ )
+ .into(),
+ "f32" => Number::Float(Float::f32(number.parse().expect(FLOAT_PARSE_EXPECT_REASON))),
+ "f64" => Number::Float(Float::f64(number.parse().expect(FLOAT_PARSE_EXPECT_REASON))),
+ "" => SignedInteger::Unspecified(number.parse().unwrap()).into(),
+ _ => {
+ return Err(tokens
+ .span()
+ .add(number.len()..0)
+ .wrap(ParseError::InvalidSuffixForNumber(suffix.to_owned()))
+ .into());
+ }
+ };
+ Ok(Spanned {
+ span: tokens.span(),
+ value: number,
+ })
+}
- Ok(Spanned {
- span: start_span..tokens.span().end,
- value: number,
- })
- } else {
- let number = Number::Integer(tokens.slice().parse().unwrap());
-
- Ok(Spanned {
- span: tokens.span(),
- value: number,
- })
- }
+fn split_number<'s>(tokens: &'s TokenStream<'_>) -> (&'s str, &'s str) {
+ let s = tokens.slice();
+ let i = s
+ .as_bytes()
+ .iter()
+ .position(|b| b.is_ascii_alphabetic() || *b == b'_')
+ .unwrap_or(s.len());
+
+ let (number, suffix) = s.split_at(i);
+ (number, suffix)
}
fn parse_var_assign(
name: Spanned,
tokens: &mut TokenStream<'_>,
environment: &Environment,
-) -> Result, ParseError> {
+) -> Result, Diagnostic> {
tokens.next(); // We already know that the next token is an equals
- let value = parse_additive(tokens, environment)?;
+ let value = parse_expression(tokens, environment)?;
Ok(Spanned {
span: name.span.start..value.span.end,
@@ -728,11 +608,11 @@ fn parse_var_assign(
fn parse_object(
tokens: &mut TokenStream,
environment: &Environment,
-) -> Result>, ParseError> {
+) -> Result>, Diagnostic> {
let mut map = HashMap::new();
while let Some(Ok(Token::Identifier)) = tokens.peek() {
tokens.next();
- let ident = tokens.slice().to_string();
+ let ident = tokens.slice().to_owned();
expect!(tokens, Token::Colon);
let expr = parse_expression(tokens, environment)?;
map.insert(ident, expr);
@@ -741,30 +621,11 @@ fn parse_object(
Some(Ok(Token::Comma)) => {
tokens.next();
}
- token => Err(ParseError::ExpectedObjectContinuation(
- tokens.span().wrap(token.clone()),
- ))?,
+ token => Err(tokens
+ .span()
+ .diagnose(ParseError::ExpectedObjectContinuation(token.clone())))?,
}
}
expect!(tokens, Token::RightBracket);
Ok(map)
}
-
-#[cfg(test)]
-mod tests {
- use super::super::lexer::TokenStream;
- use super::super::Environment;
- use super::parse;
-
- #[test]
- fn var_assign() {
- let mut lexer = TokenStream::new("x = 1 + 2 - 30 + y");
- let environment = Environment::default();
-
- let ast = parse(&mut lexer, &environment);
-
- assert!(ast.is_ok());
-
- // TODO: figure out how to assert ast
- }
-}
diff --git a/src/builtin_parser/parser/ast.rs b/src/builtin_parser/parser/ast.rs
new file mode 100644
index 0000000..0ba5912
--- /dev/null
+++ b/src/builtin_parser/parser/ast.rs
@@ -0,0 +1,177 @@
+use kinded::Kinded;
+use std::collections::HashMap;
+use std::fmt::Display;
+
+use crate::builtin_parser::Spanned;
+use crate::builtin_parser::number::Number;
+
+/// An [Abstract Syntax Tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree).
+///
+/// This type represents a list of expressions, which is what makes up a command.
+pub type Ast = Vec>;
+
+/// A type that represents an expression.
+#[derive(Debug, Clone, Kinded)]
+pub enum Expression {
+ // Primitives
+ None,
+ Boolean(bool),
+ Number(Number),
+ Variable(String),
+ String(String),
+ Borrow(Box>),
+ Dereference(Box>),
+ Object(HashMap>),
+ StructObject {
+ name: String,
+ map: HashMap>,
+ },
+ Tuple(Vec>),
+ StructTuple {
+ name: String,
+ tuple: Vec>,
+ },
+
+ // Expressions
+ BinaryOp {
+ left: Box>,
+ operator: BinaryOperator,
+ right: Box>,
+ },
+ UnaryOp {
+ operator: UnaryOperator,
+ operand: Box>,
+ },
+ Member {
+ left: Box>,
+ right: Spanned,
+ },
+
+ // Statement-like
+ VarAssign {
+ name: Box>,
+ value: Box>,
+ },
+ Function {
+ name: String,
+ arguments: Vec>,
+ },
+ ForLoop {
+ index_name: String,
+ loop_count: u64,
+ block: Ast,
+ },
+}
+
+impl ExpressionKind {
+ pub const fn as_natural(&self) -> &'static str {
+ match self {
+ ExpressionKind::None => "nothing",
+ ExpressionKind::Boolean => "a boolean",
+ ExpressionKind::Number => "a number",
+ ExpressionKind::Variable => "a variable name",
+ ExpressionKind::String => "a string",
+ ExpressionKind::Borrow => "a borrow",
+ ExpressionKind::Dereference => "a dereference",
+ ExpressionKind::Object => "an object",
+ ExpressionKind::StructObject => "a struct object",
+ ExpressionKind::Tuple => "a tuple",
+ ExpressionKind::StructTuple => "a struct tuple",
+
+ ExpressionKind::BinaryOp => "a binary operation",
+ ExpressionKind::UnaryOp => "a unary operation",
+ ExpressionKind::Member => "a member expression",
+ ExpressionKind::VarAssign => "a variable assignment",
+ ExpressionKind::Function => "a function call",
+ ExpressionKind::ForLoop => "a for loop",
+ }
+ }
+}
+
+/// A singular element access within a [`Expression::Member`].
+///
+/// Based on `bevy_reflect`'s `Access`.
+#[derive(Debug, Clone, Kinded)]
+pub enum Access {
+ /// A name-based field access on a struct.
+ Field(String),
+ /// An index-based access on a tuple.
+ TupleIndex(usize),
+ // /// An index-based access on a list.
+ // ListIndex(usize),
+}
+impl AccessKind {
+ /// Returns the kind of [`Access`] as a [string slice](str) with an `a` or `an` prepended to it.
+ /// Used for more natural sounding error messages.
+ pub const fn as_natural(self) -> &'static str {
+ match self {
+ AccessKind::Field => "a field",
+ AccessKind::TupleIndex => "a tuple",
+ }
+ }
+}
+
+/// Get the access if its of a certain type, if not, return a [`EvalError`](super::runner::error::EvalError).
+///
+/// For examples, take a look at existing uses in the code.
+macro_rules! access_unwrap {
+ ($expected:literal, $($variant:ident($variant_inner:ident))|+ = $val:expr => $block:block) => {{
+ let Spanned { span, value } = $val;
+ if let $(Access::$variant($variant_inner))|+ = value $block else {
+ use $crate::builtin_parser::parser::AccessKind;
+ use $crate::builtin_parser::runner::error::EvalError;
+
+ Err(span.diagnose(
+ EvalError::IncorrectAccessOperation {
+ expected_access: &[$(AccessKind::$variant),+],
+ expected_type: $expected,
+ got: value.kind(),
+ },
+ ))?
+ }
+ }};
+}
+pub(crate) use access_unwrap;
+
+#[derive(Debug, Clone)]
+pub enum BinaryOperator {
+ Add,
+ Sub,
+ Mul,
+ Div,
+ Mod,
+
+ And,
+ Xor,
+ Or,
+}
+impl Display for BinaryOperator {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ BinaryOperator::Add => write!(f, "+"),
+ BinaryOperator::Sub => write!(f, "-"),
+ BinaryOperator::Mul => write!(f, "*"),
+ BinaryOperator::Div => write!(f, "/"),
+ BinaryOperator::Mod => write!(f, "%"),
+ BinaryOperator::And => write!(f, "&"),
+ BinaryOperator::Xor => write!(f, "^"),
+ BinaryOperator::Or => write!(f, "|"),
+ }
+ }
+}
+
+#[derive(Debug, Clone)]
+pub enum UnaryOperator {
+ /// `-x`
+ Minus,
+ /// `!true`
+ Not,
+}
+impl Display for UnaryOperator {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ match self {
+ UnaryOperator::Minus => write!(f, "-"),
+ UnaryOperator::Not => write!(f, "!"),
+ }
+ }
+}
diff --git a/src/builtin_parser/parser/error.rs b/src/builtin_parser/parser/error.rs
new file mode 100644
index 0000000..f0559c9
--- /dev/null
+++ b/src/builtin_parser/parser/error.rs
@@ -0,0 +1,71 @@
+use crate::builtin_parser::lexer::{FailedToLexCharacter, Token};
+use crate::builtin_parser::number::NumberKind;
+
+#[derive(Debug, thiserror::Error)]
+pub enum ParseError {
+ #[error("unknown token character: {0}")]
+ FailedToLexCharacters(String),
+
+ #[error("expected more tokens, got nothing.")]
+ ExpectedMoreTokens,
+
+ #[error("expected token {expected:?}, got token {got:?} instead.")]
+ ExpectedTokenButGot { expected: Token, got: Token },
+
+ #[error(
+ "expected a semicolon or endline after a complete statement, but got more tokens than expected."
+ )]
+ ExpectedEndline(Token),
+
+ #[error("expected a literal token, got {0:?} which is not a valid literal.")]
+ ExpectedLiteral(Token),
+
+ #[error(
+ "invalid suffix `{0}` for number literal. the suffix must be one of the numeric types (`u32`, `isize`, `f32`, etc.)"
+ )]
+ InvalidSuffixForNumber(String),
+
+ #[error(
+ "invalid suffix `{0}` for float literal. the suffix must be one of the float types (`f32`, `f64`)"
+ )]
+ InvalidSuffixForFloat(String),
+
+ #[error(r#""{0}" is an invalid suffix for a float. the valid suffixes are "f32" and "f64"."#)]
+ IntegerSuffixOnFloat(String),
+
+ #[error("{number} cannot be represented as {number_kind:#} as it is too small.")]
+ NegativeIntOverflow {
+ number: String,
+ number_kind: NumberKind,
+ },
+
+ #[error("{number} cannot be represented as {number_kind:#} as it is too large.")]
+ PositiveIntOverflow {
+ number: String,
+ number_kind: NumberKind,
+ },
+
+ #[error(
+ "expected a continuation to the object declaration (such as a comma or a closing bracket), but got {0:?} instead."
+ )]
+ ExpectedObjectContinuation(Option>),
+
+ #[error(
+ "expected an identifier or integer when accessing member of variable, got {got:?} instead."
+ )]
+ ExpectedIndexer { got: Token },
+
+ #[error("{feature} are not yet supported. {}", format_issue(*issue))]
+ UnsupportedFeature { feature: &'static str, issue: u8 },
+
+ #[error("unexpected closing delimiter: `{delimiter}`")]
+ MismatchedDelimiter { delimiter: char },
+}
+
+pub(crate) fn format_issue(issue: u8) -> String {
+ if issue != 0 {
+ format!("see bevy_dev_console issue #{issue}")
+ } else {
+ String::new()
+ }
+}
diff --git a/src/builtin_parser/parser/tests.rs b/src/builtin_parser/parser/tests.rs
new file mode 100644
index 0000000..edbb9e1
--- /dev/null
+++ b/src/builtin_parser/parser/tests.rs
@@ -0,0 +1,93 @@
+use crate::builtin_parser::Spanned;
+use crate::builtin_parser::parser::Expression;
+use logos::Span;
+
+use super::super::Environment;
+use super::super::lexer::TokenStream;
+use crate::builtin_parser::Number;
+use crate::builtin_parser::parser::BinaryOperator::*;
+use std::assert_matches;
+
+fn setup(src: &str) -> std::vec::IntoIter> {
+ let mut lexer = TokenStream::new(src);
+ let environment = Environment::default();
+
+ let ast = super::parse(&mut lexer, &environment).unwrap();
+
+ ast.into_iter()
+}
+
+#[test]
+fn var_assign() {
+ let mut stmts = setup("x = 1 + 2 - 30 + y");
+
+ assert_matches!(
+ stmts.next(),
+ Some(Spanned {
+ span: Span { start: 0, end: 18 },
+ value:
+ Expression::VarAssign {
+ name:
+ box Spanned {
+ span: Span { start: 0, end: 1 },
+ value: Expression::Variable(_),
+ },
+ value:
+ box Spanned {
+ span: Span { start: 4, end: 18 },
+ value:
+ Expression::BinaryOp {
+ left:
+ box Spanned {
+ span: Span { start: 4, end: 14 },
+ value:
+ Expression::BinaryOp {
+ left:
+ box Spanned {
+ span: Span { start: 4, end: 9 },
+ value:
+ Expression::BinaryOp {
+ left:
+ box Spanned {
+ span:
+ Span {
+ start: 4,
+ end: 5,
+ },
+ value:
+ Expression::Number(Number::Integer(crate::builtin_parser::number::Integer::Signed(crate::builtin_parser::number::SignedInteger::Unspecified(1)))),
+ },
+ operator: Add,
+ right:
+ box Spanned {
+ span:
+ Span {
+ start: 8,
+ end: 9,
+ },
+ value:
+ Expression::Number(Number::Integer(crate::builtin_parser::number::Integer::Signed(crate::builtin_parser::number::SignedInteger::Unspecified(2)))),
+ },
+ },
+ },
+ operator: Sub,
+ right:
+ box Spanned {
+ span: Span { start: 12, end: 14 },
+ value: Expression::Number(Number::Integer(crate::builtin_parser::number::Integer::Signed(crate::builtin_parser::number::SignedInteger::Unspecified(30)))),
+ },
+ },
+ },
+ operator: Add,
+ right:
+ box Spanned {
+ span: Span { start: 17, end: 18 },
+ value: Expression::Variable(_),
+ },
+ },
+ },
+ },
+ })
+ );
+ assert!(stmts.next().is_none());
+}
diff --git a/src/builtin_parser/runner.rs b/src/builtin_parser/runner.rs
index 1146605..a7fbd01 100644
--- a/src/builtin_parser/runner.rs
+++ b/src/builtin_parser/runner.rs
@@ -1,619 +1,117 @@
//! Executes the abstract syntax tree.
use environment::Environment;
-use std::collections::HashMap;
use bevy::prelude::*;
-use bevy::reflect::{
- DynamicEnum, DynamicTuple, ReflectMut, TypeInfo, TypeRegistration, VariantInfo,
-};
-
-use crate::ui::COMMAND_RESULT_NAME;
+use bevy::reflect::TypeRegistration;
use self::error::EvalError;
-use self::member::{eval_member_expression, eval_path, Path};
-use self::reflection::{object_to_dynamic_struct, CreateRegistration, IntoResource};
-use self::unique_rc::UniqueRc;
-use super::parser::{Ast, Expression, Operator};
-use super::{Number, SpanExtension, Spanned};
+use super::Spanned;
+use super::parser::{Ast, Expression};
pub(super) mod environment;
pub(super) mod error;
+pub(super) mod eval;
+pub(super) mod function;
pub(super) mod member;
pub(super) mod reflection;
pub(super) mod stdlib;
pub(super) mod unique_rc;
pub(super) mod value;
+pub use eval::eval_expression;
pub use value::Value;
/// Temporary macro that prevents panicking by replacing the [`todo!`] panic with an error message.
macro_rules! todo_error {
() => {
- Err(EvalError::Custom {
- text: concat!("todo error invoked at ", file!(), ":", line!(), ":", column!()).into(),
- span: 0..0
- })?
+ return Err($crate::builtin_parser::Diagnostic::empty($crate::builtin_parser::EvalError::Custom(
+ concat!("todo error invoked at ", file!(), ":", line!(), ":", column!()).into(),
+ )))
};
($($arg:tt)+) => {
- Err(EvalError::Custom {
- text: format!(concat!("todo error invoked at ", file!(), ":", line!(), ":", column!(), " : {}"), format_args!($($arg)+)).into(),
- span: 0..0
- })?
+ return Err($crate::builtin_parser::Diagnostic::empty($crate::builtin_parser::EvalError::Custom(
+ format!(
+ concat!(
+ "todo error invoked at ",
+ file!(),
+ ":",
+ line!(),
+ ":",
+ column!(),
+ ": {}"
+ ),
+ format_args!($($arg)+)
+ )
+ .into(),
+ ),
+ ))
};
}
-// This makes `todo_error` accessible to the runners submodules
-use todo_error;
+pub(crate) use todo_error;
/// Container for every value needed by evaluation functions.
pub struct EvalParams<'world, 'env, 'reg> {
- world: &'world mut World,
- environment: &'env mut Environment,
- registrations: &'reg [&'reg TypeRegistration],
-}
-
-#[derive(Debug)]
-pub enum ExecutionError {
- NoEnvironment,
- NoTypeRegistry,
- Eval(EvalError),
-}
-
-impl std::fmt::Display for ExecutionError {
- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- match self {
- Self::NoEnvironment => write!(
- f,
- "Environment resource doesn't exist, not executing command."
- ),
- Self::NoTypeRegistry => write!(
- f,
- "The AppTypeRegistry doesn't exist, not executing command. "
- ),
- Self::Eval(run_error) => ::fmt(run_error, f),
- }
- }
-}
-impl std::error::Error for ExecutionError {
- fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
- match self {
- ExecutionError::Eval(eval) => Some(eval),
- _ => None,
- }
- }
-}
-impl From for ExecutionError {
- fn from(value: EvalError) -> Self {
- Self::Eval(value)
- }
+ pub world: &'world mut World,
+ pub environment: &'env mut Environment,
+ pub registrations: &'reg [&'reg TypeRegistration],
}
-pub fn run(ast: Ast, world: &mut World) -> Result<(), ExecutionError> {
- // Temporarily remove the [`Environment`] resource to gain
- // mutability without needing a mutable reference.
- let mut environment = world
- .remove_non_send_resource::()
- .ok_or(ExecutionError::NoEnvironment)?;
-
- // Same thing here (this time we are doing it because we are passing a `&mut World` to `eval_expression`)
- let Some(registry) = world.remove_resource::() else {
- // Make sure to re-insert the resource on failure
- world.insert_non_send_resource(environment);
-
- return Err(ExecutionError::NoTypeRegistry);
- };
-
- let result = (|| {
- let registry_read = registry.read();
-
- let registrations: Vec<_> = registry_read
- .iter()
- .filter(|registration| {
- world
- .components()
- .get_resource_id(registration.type_id())
- .is_some()
- })
- .collect();
-
- for mut statement in ast {
- // Automatically borrow variables
- statement.value = match statement.value {
+pub fn eval(
+ ast: Ast,
+ world: &mut World,
+ environment: &mut Environment,
+ registry: &AppTypeRegistry,
+) -> Result, crate::builtin_parser::Diagnostic> {
+ let registry_read = registry.read();
+
+ let registrations: Vec<_> = registry_read
+ .iter()
+ .filter(|registration| {
+ world
+ .components()
+ .get_resource_id(registration.type_id())
+ .is_some()
+ })
+ .collect();
+ let mut last_value = None;
+ for mut statement in ast {
+ fn autoborrow(statement: Spanned) -> Spanned {
+ let value = match statement.value {
Expression::Variable(variable) => Expression::Borrow(Box::new(Spanned {
span: statement.span.clone(),
value: Expression::Variable(variable),
})),
+ Expression::Member { mut left, right } => {
+ *left = autoborrow(*left);
+ Expression::Member { left, right }
+ }
expr => expr,
};
-
- let span = statement.span.clone();
- let value = eval_expression(
- statement,
- EvalParams {
- world,
- environment: &mut environment,
- registrations: ®istrations,
- },
- )?;
-
- match value {
- Value::None => {}
- value => {
- let value = value.try_format(span, world, ®istrations)?;
-
- info!(name: COMMAND_RESULT_NAME, "{}{value}", crate::ui::COMMAND_RESULT_PREFIX);
- }
- }
- }
-
- Ok(())
- })();
-
- // Add back the resources
- world.insert_resource(registry);
- world.insert_non_send_resource(environment);
-
- result
-}
-
-fn eval_expression(
- expr: Spanned,
- EvalParams {
- world,
- environment,
- registrations,
- }: EvalParams,
-) -> Result {
- match expr.value {
- Expression::VarAssign {
- name,
- value: value_expr,
- } => match eval_path(
- *name,
- EvalParams {
- world,
- environment,
- registrations,
- },
- )?
- .value
- {
- Path::Variable(variable) => {
- let value = eval_expression(
- *value_expr,
- EvalParams {
- world,
- environment,
- registrations,
- },
- )?;
-
- match variable.upgrade() {
- Some(strong) => *strong.borrow_mut() = value,
- None => todo_error!("cannot "),
- }
-
- Ok(Value::Reference(variable))
- }
- Path::NewVariable(variable) => {
- let value = eval_expression(
- *value_expr,
- EvalParams {
- world,
- environment,
- registrations,
- },
- )?;
- let rc = UniqueRc::new(value);
- let weak = rc.borrow();
-
- environment.set(variable, rc);
-
- Ok(Value::Reference(weak))
- }
- Path::Resource(resource) => {
- let registration = registrations.create_registration(resource.id);
- let mut dyn_reflect = resource.mut_dyn_reflect(world, registration);
-
- let reflect = dyn_reflect
- .reflect_path_mut(resource.path.as_str())
- .unwrap();
-
- match reflect.reflect_mut() {
- ReflectMut::Enum(dyn_enum) => {
- let TypeInfo::Enum(enum_info) = registration.type_info() else {
- unreachable!()
- };
- let Spanned { span, value } = *value_expr;
- match value {
- Expression::Variable(name) => {
- let variant_info = match enum_info.variant(&name) {
- Some(variant_info) => variant_info,
- None => {
- return Err(EvalError::EnumVariantNotFound(span.wrap(name)))
- }
- };
- let VariantInfo::Unit(_) = variant_info else {
- return todo_error!("{variant_info:?}");
- };
-
- let new_enum = DynamicEnum::new(name, ());
-
- dyn_enum.apply(&new_enum);
- }
- Expression::StructObject { name, map } => {
- let variant_info = match enum_info.variant(&name) {
- Some(variant_info) => variant_info,
- None => {
- return Err(EvalError::EnumVariantNotFound(span.wrap(name)))
- }
- };
- let VariantInfo::Struct(variant_info) = variant_info else {
- return todo_error!("{variant_info:?}");
- };
-
- let map: HashMap<_, _> = map
- .into_iter()
- .map(|(k, v)| {
- let ty = match variant_info.field(&k) {
- Some(field) => Ok(field.type_path_table().short_path()),
- None => {
- Err(EvalError::EnumVariantStructFieldNotFound {
- field_name: k.clone(),
- variant_name: name.clone(),
- span: span.clone(),
- })
- }
- }?;
-
- let span = v.span.clone();
-
- Ok((
- k,
- (
- eval_expression(
- v,
- EvalParams {
- world,
- environment,
- registrations,
- },
- )?,
- span,
- ty,
- ),
- ))
- })
- .collect::>()?;
-
- let new_enum =
- DynamicEnum::new(name, object_to_dynamic_struct(map)?);
-
- let mut dyn_reflect =
- resource.mut_dyn_reflect(world, registrations);
-
- let dyn_enum = dyn_reflect
- .reflect_path_mut(resource.path.as_str())
- .unwrap();
-
- dyn_enum.apply(&new_enum);
- }
- Expression::StructTuple { name, tuple } => {
- let variant_info = match enum_info.variant(&name) {
- Some(variant_info) => variant_info,
- None => {
- return Err(EvalError::EnumVariantNotFound(span.wrap(name)))
- }
- };
- let VariantInfo::Tuple(variant_info) = variant_info else {
- return todo_error!("{variant_info:?}");
- };
-
- let tuple = eval_tuple(
- tuple,
- EvalParams {
- world,
- environment,
- registrations,
- },
- )?;
-
- let mut dynamic_tuple = DynamicTuple::default();
-
- for (index, element) in tuple.into_vec().into_iter().enumerate() {
- let ty = match variant_info.field_at(index) {
- Some(field) => Ok(field.type_path_table().short_path()),
- None => Err(EvalError::EnumVariantTupleFieldNotFound {
- field_index: index,
- variant_name: name.clone(),
- span: span.clone(),
- }),
- }?;
-
- dynamic_tuple.insert_boxed(
- element.value.into_inner().reflect(element.span, ty)?,
- );
- }
-
- let new_enum = DynamicEnum::new(name, dynamic_tuple);
-
- let mut dyn_reflect =
- resource.mut_dyn_reflect(world, registrations);
-
- let dyn_enum = dyn_reflect
- .reflect_path_mut(resource.path.as_str())
- .unwrap();
-
- dyn_enum.apply(&new_enum);
- }
- _ => todo_error!(),
- }
- }
- _ => {
- let span = value_expr.span.clone();
- let ty = reflect.reflect_short_type_path().to_owned();
- let value = eval_expression(
- *value_expr,
- EvalParams {
- world,
- environment,
- registrations,
- },
- )?;
- let value_reflect = value.reflect(span.clone(), &ty)?;
-
- let mut dyn_reflect = resource.mut_dyn_reflect(world, registrations);
-
- let reflect = dyn_reflect
- .reflect_path_mut(resource.path.as_str())
- .unwrap();
-
- reflect.set(value_reflect).map_err(|value_reflect| {
- EvalError::IncompatibleReflectTypes {
- span,
- expected: reflect.reflect_type_path().to_string(),
- actual: value_reflect.reflect_type_path().to_string(),
- }
- })?;
- }
- }
-
- Ok(Value::Resource(resource))
- }
- },
- Expression::String(string) => Ok(Value::String(string)),
- Expression::Number(number) => Ok(Value::Number(number)),
- Expression::Variable(variable) => {
- if registrations
- .iter()
- .any(|v| v.type_info().type_path_table().short_path() == variable)
- {
- Err(EvalError::CannotMoveOutOfResource(Spanned {
- span: expr.span,
- value: variable,
- }))
- } else {
- environment.move_var(&variable, expr.span)
+ Spanned {
+ span: statement.span,
+ value,
}
}
- Expression::StructObject { name, map } => {
- let hashmap = eval_object(
- map,
- EvalParams {
- world,
- environment,
- registrations,
- },
- )?;
- Ok(Value::StructObject { name, map: hashmap })
- }
- Expression::Object(map) => {
- let hashmap = eval_object(
- map,
- EvalParams {
- world,
- environment,
- registrations,
- },
- )?;
- Ok(Value::Object(hashmap))
- }
- Expression::Tuple(tuple) => {
- let tuple = eval_tuple(
- tuple,
- EvalParams {
- world,
- environment,
- registrations,
- },
- )?;
- Ok(Value::Tuple(tuple))
- }
- Expression::StructTuple { name, tuple } => {
- let tuple = eval_tuple(
- tuple,
- EvalParams {
- world,
- environment,
- registrations,
- },
- )?;
- Ok(Value::StructTuple { name, tuple })
- }
-
- Expression::BinaryOp {
- left,
- operator,
- right,
- } => {
- let left = eval_expression(
- *left,
- EvalParams {
- world,
- environment,
- registrations,
- },
- )?;
- let right = eval_expression(
- *right,
- EvalParams {
- world,
- environment,
- registrations,
- },
- )?;
+ // Automatically borrow variables to prevent move errors on `x`
+ statement = autoborrow(statement);
- match (left, right) {
- (Value::Number(left), Value::Number(right)) => Ok(Value::Number(match operator {
- Operator::Add => Number::add(left, right, expr.span)?,
- Operator::Sub => Number::sub(left, right, expr.span)?,
- Operator::Mul => Number::mul(left, right, expr.span)?,
- Operator::Div => Number::div(left, right, expr.span)?,
- Operator::Mod => Number::rem(left, right, expr.span)?,
- })),
- (left, right) => todo_error!("{left:#?}, {right:#?}"),
- }
- }
- Expression::ForLoop {
- index_name,
- loop_count,
- block,
- } => todo_error!("for loop {index_name}, {loop_count}, {block:#?}"),
- Expression::Member { left, right } => eval_member_expression(
- *left,
- right,
+ let span = statement.span.clone();
+ let value = eval_expression(
+ statement,
EvalParams {
world,
environment,
- registrations,
+ registrations: ®istrations,
},
- ),
- Expression::UnaryOp(sub_expr) => {
- let span = sub_expr.span.clone();
- let value = eval_expression(
- *sub_expr,
- EvalParams {
- world,
- environment,
- registrations,
- },
- )?;
+ )?;
- if let Value::Number(number) = value {
- Ok(Value::Number(number.neg(span)?))
- } else {
- Err(EvalError::ExpectedNumberAfterUnaryOperator(Spanned {
- span,
- value,
- }))
- }
- }
- Expression::Dereference(inner) => {
- if let Expression::Variable(variable) = inner.value {
- let var = environment.get(&variable, inner.span)?;
- match &*var.borrow_inner().borrow() {
- Value::Reference(reference) => {
- let reference = reference
- .upgrade()
- .ok_or(EvalError::ReferenceToMovedData(expr.span))?;
- let owned = reference.borrow().clone();
- Ok(owned)
- }
- value => Ok(value.clone()),
- }
- } else {
- Err(EvalError::CannotDereferenceValue(
- expr.span.wrap(inner.value.kind()),
- ))
- }
- }
- Expression::Borrow(inner) => {
- if let Expression::Variable(variable) = inner.value {
- if let Some(registration) = registrations
- .iter()
- .find(|v| v.type_info().type_path_table().short_path() == variable)
- {
- Ok(Value::Resource(IntoResource::new(registration.type_id())))
- } else {
- let rc = environment.get(&variable, inner.span)?;
- let weak = rc.borrow();
-
- Ok(Value::Reference(weak))
- }
- } else {
- Err(EvalError::CannotBorrowValue(
- expr.span.wrap(inner.value.kind()),
- ))
- }
- }
- Expression::None => Ok(Value::None),
- Expression::Boolean(bool) => Ok(Value::Boolean(bool)),
- Expression::Function { name, arguments } => {
- environment.function_scope(&name, move |environment, function| {
- (function.body)(
- arguments,
- EvalParams {
- world,
- environment,
- registrations,
- },
- )
- })
+ last_value = match value {
+ Value::None => None,
+ value => Some(value.try_format(span, world, ®istrations)?),
}
}
-}
-
-fn eval_object(
- map: HashMap>,
- EvalParams {
- world,
- environment,
- registrations,
- }: EvalParams,
-) -> Result>, EvalError> {
- let map = map
- .into_iter()
- .map(
- |(key, expr)| -> Result<(String, UniqueRc), EvalError> {
- Ok((
- key,
- UniqueRc::new(eval_expression(
- expr,
- EvalParams {
- world,
- environment,
- registrations,
- },
- )?),
- ))
- },
- )
- .collect::>()?;
- Ok(map)
-}
-fn eval_tuple(
- tuple: Vec>,
- EvalParams {
- world,
- environment,
- registrations,
- }: EvalParams,
-) -> Result>]>, EvalError> {
- tuple
- .into_iter()
- .map(|expr| {
- let span = expr.span.clone();
- let value = UniqueRc::new(eval_expression(
- expr,
- EvalParams {
- world,
- environment,
- registrations,
- },
- )?);
- Ok(span.wrap(value))
- })
- .collect::>()
+ Ok(last_value)
}
diff --git a/src/builtin_parser/runner/environment.rs b/src/builtin_parser/runner/environment.rs
index b30d345..e6eea19 100644
--- a/src/builtin_parser/runner/environment.rs
+++ b/src/builtin_parser/runner/environment.rs
@@ -1,39 +1,47 @@
-//! Environment and function registration
+//! Environment and variable storage
use std::collections::HashMap;
-use std::fmt::Debug;
-use crate::builtin_parser::SpanExtension;
+use crate::builtin_parser::runner::EvalParams;
+use crate::builtin_parser::{Diagnostic, Spanned};
use bevy::ecs::world::World;
use bevy::log::warn;
use bevy::reflect::TypeRegistration;
-use logos::Span;
-use super::super::parser::Expression;
-use super::super::Spanned;
use super::error::EvalError;
+pub use super::function::{Function, IntoFunction};
use super::unique_rc::UniqueRc;
-use super::{eval_expression, stdlib, EvalParams, Value};
+use super::{Value, stdlib};
-/// Macro for mass registering functions.
+/// Macro for mass registering [`Function`]s to an [`Environment`].
///
+/// ## Usage
/// ```
-/// fn a() {}
-/// fn b() {}
-/// fn c() {}
+/// fn my_func() {}
+///
+/// # use bevy_dev_console::register;
+/// # let mut environment = bevy_dev_console::builtin_parser::Environment::default();
+/// register!(environment => fn my_func);
+/// ```
+///
+/// ```
+/// # use bevy::prelude::World;
+/// fn pow2(n: i32) -> i32 { n * n }
+/// fn add(a: f32, b: f32) -> f32 { a + b }
+/// fn toggle_debug(world: &mut World) { /* ... */ }
///
/// # use bevy_dev_console::register;
/// # let mut environment = bevy_dev_console::builtin_parser::Environment::default();
/// register!(environment => {
-/// fn a;
-/// fn b;
-/// fn c;
+/// fn pow2;
+/// fn add;
+/// fn toggle_debug as "tdbg";
/// });
/// ```
#[macro_export]
macro_rules! register {
{
- $environment:expr => fn $fn_name:ident;
+ $environment:expr => fn $fn_name:ident
} => {
$environment
.register_fn(stringify!($fn_name), $fn_name)
@@ -55,144 +63,6 @@ macro_rules! register {
};
}
-/// Get around implementation of Result causing stupid errors
-pub(super) struct ResultContainer(pub Result);
-
-impl> From for ResultContainer {
- fn from(value: T) -> Self {
- ResultContainer(Ok(value.into()))
- }
-}
-impl From> for Result {
- fn from(ResultContainer(result): ResultContainer) -> Self {
- result
- }
-}
-impl, E> From> for ResultContainer {
- fn from(result: Result) -> Self {
- ResultContainer(result.map(|v| v.into()))
- }
-}
-/// A parameter in a [`Function`].
-pub trait FunctionParam: Sized {
- /// TODO: Add `Self` as default when gets merged
- type Item<'world, 'env, 'reg>;
- /// Whether this parameter requires a [`Spanned`].
- /// If `false` then `FunctionParam::get`'s `value` will be [`None`], and vice versa.
- const USES_VALUE: bool;
-
- fn get<'world, 'env, 'reg>(
- value: Option>,
- world: &mut Option<&'world mut World>,
- environment: &mut Option<&'env mut Environment>,
- registrations: &'reg [&'reg TypeRegistration],
- ) -> Result, EvalError>;
-}
-
-pub type FunctionType = dyn FnMut(Vec>, EvalParams) -> Result;
-pub struct Function {
- pub argument_count: usize,
- pub body: Box,
-}
-impl Debug for Function {
- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- f.debug_struct("Function")
- .field("argument_count", &self.argument_count)
- .finish_non_exhaustive()
- }
-}
-
-/// Trait that represents a [`Fn`] that can be turned into a [`Function`].
-pub trait IntoFunction {
- fn into_function(self) -> Function;
-}
-
-macro_rules! impl_into_function {
- (
- $($(
- $params:ident
- ),+)?
- ) => {
- #[allow(non_snake_case)]
- impl IntoFunction<( $($($params,)+)? )> for F
- where
- for<'a, 'world, 'env, 'reg> &'a mut F:
- FnMut( $($($params),*)? ) -> R +
- FnMut( $($(<$params as FunctionParam>::Item<'world, 'env, 'reg>),*)? ) -> R,
- R: Into>,
- {
- fn into_function(mut self) -> Function {
- #[allow(unused_variables, unused_mut)]
- let body = Box::new(move |args: Vec>, params: EvalParams| {
- let EvalParams {
- world,
- environment,
- registrations,
- } = params;
- let mut args = args.into_iter().map(|expr| {
- Ok(Spanned {
- span: expr.span.clone(),
- value: eval_expression(
- expr,
- EvalParams {
- world,
- environment,
- registrations,
- }
- )?
- })
- }).collect::, EvalError>>()?.into_iter();
- let world = &mut Some(world);
- let environment = &mut Some(environment);
-
- #[allow(clippy::too_many_arguments)]
- fn call_inner>, $($($params),*)?>(
- mut f: impl FnMut($($($params),*)?) -> R,
- $($($params: $params),*)?
- ) -> R {
- f($($($params),*)?)
- }
- call_inner(
- &mut self,
- $($({
- let arg = if $params::USES_VALUE {
- Some(args.next().unwrap())
- } else {
- None
- };
-
- let res = $params::get(
- arg,
- world,
- environment,
- registrations
- )?;
-
- res
- }),+)?
- )
- .into().into()
- });
-
- let argument_count = $($(
- $params::USES_VALUE as usize +
- )+)? 0;
-
- Function { body, argument_count }
- }
- }
- }
-}
-impl_into_function!();
-impl_into_function!(T1);
-impl_into_function!(T1, T2);
-impl_into_function!(T1, T2, T3);
-impl_into_function!(T1, T2, T3, T4);
-impl_into_function!(T1, T2, T3, T4, T5);
-impl_into_function!(T1, T2, T3, T4, T5, T6);
-impl_into_function!(T1, T2, T3, T4, T5, T6, T7);
-impl_into_function!(T1, T2, T3, T4, T5, T6, T7, T8);
-
/// A variable inside the [`Environment`].
#[derive(Debug)]
pub enum Variable {
@@ -201,17 +71,14 @@ pub enum Variable {
Function(Function),
}
-/// The environment stores all variables and functions.
+/// The environment stores all variables and functions for the builtin parser.
pub struct Environment {
pub(crate) parent: Option>,
pub(crate) variables: HashMap,
}
impl Default for Environment {
fn default() -> Self {
- let mut env = Self {
- parent: None,
- variables: HashMap::new(),
- };
+ let mut env = Self::empty();
stdlib::register(&mut env);
@@ -219,15 +86,61 @@ impl Default for Environment {
}
}
+/// An error that can occur when interacting with a variable in the [`Environment`].
+#[derive(Debug, thiserror::Error)]
+pub enum VariableError {
+ /// The variable was not found.
+ #[error("Variable `{0}` not found.")]
+ NotFound(String),
+ /// The variable was moved and is no longer available.
+ #[error("variable `{0}` was moved")]
+ Moved(String),
+ /// Expected a variable, but found a function.
+ #[error("expected `{0}` to be a variable, but got a function instead")]
+ ExpectedVariableGotFunction(String),
+}
+
+/// An error that can occur when running a function in the [`Environment`].
+#[derive(Debug, thiserror::Error)]
+pub enum RunFunctionError {
+ /// The function was not found.
+ #[error("Function `{0}` not found.")]
+ NotFound(String),
+ /// An error occurred while evaluating the function.
+ #[error(transparent)]
+ Eval(#[from] Diagnostic),
+}
+
+impl From for Diagnostic {
+ fn from(value: RunFunctionError) -> Self {
+ match value {
+ RunFunctionError::NotFound(name) => {
+ Diagnostic::empty(VariableError::NotFound(name).into())
+ }
+ RunFunctionError::Eval(diag) => diag,
+ }
+ }
+}
+
impl Environment {
+ /// A completely empty [`Environment`] without any standard library.
+ #[must_use]
+ pub fn empty() -> Self {
+ Self {
+ parent: None,
+ variables: HashMap::new(),
+ }
+ }
+
/// Set a variable.
pub fn set(&mut self, name: impl Into, value: UniqueRc) {
self.variables.insert(name.into(), Variable::Unmoved(value));
}
/// Returns a reference to a function if it exists.
+ #[must_use]
pub fn get_function(&self, name: &str) -> Option<&Function> {
- let (env, _) = self.resolve(name, 0..0).ok()?;
+ let env = self.resolve(name)?;
match env.variables.get(name) {
Some(Variable::Function(function)) => Some(function),
@@ -239,16 +152,13 @@ impl Environment {
&mut self,
name: &str,
function: impl FnOnce(&mut Self, &mut Function) -> T,
- ) -> T {
- let (env, _) = self.resolve_mut(name, 0..0).unwrap();
-
- let return_result;
+ ) -> Option {
+ let env = self.resolve_mut(name)?;
let var = env.variables.get_mut(name);
+ let return_result;
let fn_obj = match var {
- Some(Variable::Function(_)) => {
- let Variable::Function(mut fn_obj) =
- std::mem::replace(var.unwrap(), Variable::Moved)
- else {
+ Some(var @ Variable::Function(_)) => {
+ let Variable::Function(mut fn_obj) = std::mem::replace(var, Variable::Moved) else {
unreachable!()
};
@@ -256,25 +166,27 @@ impl Environment {
fn_obj
}
- _ => unreachable!(),
+ _ => return None,
};
let var = env.variables.get_mut(name);
let _ = std::mem::replace(var.unwrap(), Variable::Function(fn_obj));
- return_result
+ Some(return_result)
}
+
/// Returns a reference to a variable.
- pub fn get(&self, name: &str, span: Span) -> Result<&UniqueRc, EvalError> {
- let (env, span) = self.resolve(name, span)?;
+ pub fn get_variable(&self, name: &str) -> Result<&UniqueRc, VariableError> {
+ let Some(var) = self.get(name) else {
+ return Err(VariableError::NotFound(name.to_owned()));
+ };
- match env.variables.get(name) {
- Some(Variable::Unmoved(value)) => Ok(value),
- Some(Variable::Moved) => Err(EvalError::VariableMoved(span.wrap(name.to_string()))),
- Some(Variable::Function(_)) => Err(EvalError::ExpectedVariableGotFunction(
- span.wrap(name.to_owned()),
- )),
- None => Err(EvalError::VariableNotFound(span.wrap(name.to_string()))),
+ match var {
+ Variable::Unmoved(value) => Ok(value),
+ Variable::Moved => Err(VariableError::Moved(name.to_owned())),
+ Variable::Function(_) => {
+ Err(VariableError::ExpectedVariableGotFunction(name.to_owned()))
+ }
}
}
@@ -282,15 +194,17 @@ impl Environment {
///
/// However it will no longer be able to be used unless it's a [`Value::None`],
/// [`Value::Boolean`], or [`Value::Number`] in which case it will be copied.
- pub fn move_var(&mut self, name: &str, span: Span) -> Result {
- let (env, span) = self.resolve_mut(name, span)?;
-
- match env.variables.get_mut(name) {
- Some(Variable::Moved) => Err(EvalError::VariableMoved(span.wrap(name.to_string()))),
- Some(Variable::Function(_)) => Err(EvalError::ExpectedVariableGotFunction(
- span.wrap(name.to_owned()),
- )),
- Some(variable_reference) => {
+ pub fn move_var(&mut self, name: &str) -> Result {
+ let Some(var) = self.get_mut(name) else {
+ return Err(VariableError::NotFound(name.to_owned()));
+ };
+
+ match var {
+ Variable::Moved => Err(VariableError::Moved(name.to_owned())),
+ Variable::Function(_) => {
+ Err(VariableError::ExpectedVariableGotFunction(name.to_owned()))
+ }
+ variable_reference @ Variable::Unmoved(_) => {
let Variable::Unmoved(reference) = variable_reference else {
unreachable!()
};
@@ -308,39 +222,48 @@ impl Environment {
};
Ok(value.into_inner())
}
- None => Err(EvalError::VariableNotFound(span.wrap(name.to_string()))),
}
}
- fn resolve(&self, name: &str, span: Span) -> Result<(&Self, Span), EvalError> {
- if self.variables.contains_key(name) {
- return Ok((self, span));
+ fn get(&self, name: &str) -> Option<&Variable> {
+ if let Some(var) = self.variables.get(name) {
+ return Some(var);
}
- match &self.parent {
- Some(parent) => parent.resolve(name, span),
- None => Err(EvalError::VariableNotFound(span.wrap(name.to_string()))),
+ self.parent.as_ref()?.get(name)
+ }
+ fn get_mut(&mut self, name: &str) -> Option<&mut Variable> {
+ if let Some(var) = self.variables.get_mut(name) {
+ return Some(var);
}
+
+ self.parent.as_mut()?.get_mut(name)
}
- fn resolve_mut(&mut self, name: &str, span: Span) -> Result<(&mut Self, Span), EvalError> {
+ fn resolve(&self, name: &str) -> Option<&Self> {
if self.variables.contains_key(name) {
- return Ok((self, span));
+ return Some(self);
}
- match &mut self.parent {
- Some(parent) => parent.resolve_mut(name, span),
- None => Err(EvalError::VariableNotFound(span.wrap(name.to_string()))),
+ self.parent.as_ref()?.resolve(name)
+ }
+ fn resolve_mut(&mut self, name: &str) -> Option<&mut Self> {
+ if self.variables.contains_key(name) {
+ return Some(self);
}
+
+ self.parent.as_mut()?.resolve_mut(name)
}
/// Registers a function for use inside the language.
///
- /// All parameters must implement [`FunctionParam`].
- /// There is a limit of 8 parameters.
+ /// All parameters must implement [`FunctionParam`](super::function::FunctionParam).
+ /// There is a limit of 15 parameters.
///
/// The return value of the function must implement [`Into`]
///
- /// You should take a look at the [Standard Library](super::stdlib) for examples.
+ /// You should take a look at the [Standard Library] for examples.
+ ///
+ /// [Standard Library](https://github.com/doonv/bevy_dev_console/blob/master/src/builtin_parser/runner/stdlib.rs)
pub fn register_fn(
&mut self,
name: impl Into,
@@ -355,10 +278,41 @@ impl Environment {
self
}
+
+ pub fn run_function(
+ &mut self,
+ name: &str,
+ arguments: Vec>,
+ world: &mut World,
+ registrations: &[&TypeRegistration],
+ ) -> Result {
+ self.function_scope(name, move |environment, function| {
+ (function.body)(
+ arguments,
+ EvalParams {
+ world,
+ environment,
+ registrations,
+ },
+ )
+ })
+ .ok_or_else(|| RunFunctionError::NotFound(name.to_owned()))?
+ .map_err(RunFunctionError::Eval)
+ }
+
/// Iterate over all the variables and functions in the current scope of the environment.
///
/// Does not include variables and functions from higher scopes.
- pub fn iter(&self) -> std::collections::hash_map::Iter {
+ #[must_use]
+ pub fn iter(&self) -> std::collections::hash_map::Iter<'_, String, Variable> {
self.variables.iter()
}
}
+
+impl<'a> IntoIterator for &'a Environment {
+ type Item = (&'a String, &'a Variable);
+ type IntoIter = std::collections::hash_map::Iter<'a, String, Variable>;
+ fn into_iter(self) -> Self::IntoIter {
+ self.iter()
+ }
+}
diff --git a/src/builtin_parser/runner/error.rs b/src/builtin_parser/runner/error.rs
index 6892de4..6d5a701 100644
--- a/src/builtin_parser/runner/error.rs
+++ b/src/builtin_parser/runner/error.rs
@@ -1,239 +1,138 @@
use std::borrow::Cow;
+use std::fmt;
-use logos::Span;
+use crate::builtin_parser::NumberError;
+use crate::builtin_parser::parser::{AccessKind, ExpressionKind, UnaryOperator};
+use crate::builtin_parser::runner::environment::VariableError;
+use crate::builtin_parser::runner::value::ValueKind;
+use bevy::reflect::ApplyError;
-use crate::builtin_parser::number::Number;
-use crate::builtin_parser::parser::Access;
-use crate::builtin_parser::Spanned;
-use crate::command::{CommandHint, CommandHintColor};
-
-use super::Value;
-
-/// An error occurring during the while executing the [`AST`](Ast) of the command.
-#[derive(Debug)]
+/// An error occurring during the while evaluating the command.
+#[derive(Debug, thiserror::Error)]
#[allow(missing_docs)]
pub enum EvalError {
/// A custom text message. Contains very little contextual information, try to find an existing error instead.
- Custom {
- /// The text of the message
- text: Cow<'static, str>,
- span: Span,
- },
- InvalidOperation {
- left: Number,
- right: Number,
- operation: &'static str,
- span: Span,
- },
- VariableNotFound(Spanned),
- ExpectedNumberAfterUnaryOperator(Spanned),
- CannotIndexValue(Spanned),
- ReferenceToMovedData(Span),
- VariableMoved(Spanned),
- CannotDereferenceValue(Spanned<&'static str>),
- CannotBorrowValue(Spanned<&'static str>),
- IncompatibleReflectTypes {
- expected: String,
- actual: String,
- span: Span,
- },
- EnumVariantNotFound(Spanned),
- CannotMoveOutOfResource(Spanned),
- CannotNegateUnsignedInteger(Spanned),
- IncompatibleNumberTypes {
- left: &'static str,
- right: &'static str,
- span: Span,
+ #[error("{0}")]
+ Custom(Cow<'static, str>),
+
+ #[error(transparent)]
+ Variable(#[from] VariableError),
+
+ #[error(
+ "cannot apply unary operator `{operator}` to type `{operand}`. the supported types are: {}",
+ FancyJoin(accepted)
+ )]
+ InvalidUnaryOperation {
+ operator: UnaryOperator,
+ operand: ValueKind,
+ accepted: &'static [ValueKind],
},
- IncompatibleFunctionParameter {
- expected: &'static str,
- actual: &'static str,
- span: Span,
+
+ #[error("Cannot index `{0}` with a member expression.")]
+ CannotIndexValue(ValueKind),
+
+ #[error("Cannot access reference to moved data.")]
+ ReferenceToMovedData,
+
+ #[error("Cannot dereference {0}.")]
+ CannotDereferenceValue(ValueKind),
+
+ #[error("Cannot dereference {0}.")]
+ CannotDereferenceValueExpr(ExpressionKind),
+
+ #[error("Cannot borrow {0}. Only variables can be borrowed.")]
+ CannotBorrowValue(ExpressionKind),
+
+ #[error("Cannot set incompatible reflect types. Expected `{expected}`, got `{actual}`")]
+ IncompatibleReflectTypes { expected: String, actual: String },
+
+ #[error("Enum variant `{0}` was not found.")]
+ EnumVariantNotFound(String),
+
+ #[error("cannot move out of resource `{0}`, try borrowing it instead")]
+ CannotMoveOutOfResource(String),
+
+ #[error(transparent)]
+ Number(#[from] NumberError),
+
+ #[error("mismatched function parameter type. expected {expected:#} but got {actual:#}")]
+ IncorrectFunctionParameterType {
+ expected: ValueKind,
+ actual: ValueKind,
},
+
+ #[error("Field `{field_name}` doesn't exist on struct variant `{variant_name}`")]
EnumVariantStructFieldNotFound {
field_name: String,
variant_name: String,
- span: Span,
},
- ExpectedVariableGotFunction(Spanned),
- CannotReflectReference(Span),
- CannotReflectResource(Span),
+
+ #[error("cannot reflect a reference. Try dereferencing it instead")]
+ CannotReflectReference,
+
+ #[error("cannot reflecting resources is not possible at the moment")]
+ CannotReflectResource,
+
+ #[error("field `{field_index}` doesn't exist on tuple variant `{variant_name}`")]
EnumVariantTupleFieldNotFound {
- span: Span,
field_index: usize,
variant_name: String,
},
+
+ #[error(
+ "expected {got} access to access {expected_type} but got {:#}",
+ format_expected_access(expected_access)
+ )]
IncorrectAccessOperation {
- span: Span,
- expected_access: &'static [&'static str],
+ expected_access: &'static [AccessKind],
expected_type: &'static str,
- got: Access,
+ got: AccessKind,
},
- FieldNotFoundInStruct(Spanned),
+
+ #[error("field {0} not found in struct")]
+ FieldNotFoundInStruct(String),
+
+ #[error("field {field_index} is out of bounds for tuple of size {tuple_size}")]
FieldNotFoundInTuple {
- span: Span,
field_index: usize,
tuple_size: usize,
},
+
+ #[error("error while applying value (todo make this error better): {0}")]
+ ApplyError(#[from] ApplyError),
}
-impl EvalError {
- /// Get all the locations of the error in the source.
- pub fn spans(&self) -> Vec {
- use EvalError as E;
-
- match self {
- E::Custom { span, .. } => vec![span.clone()],
- E::VariableNotFound(Spanned { span, .. }) => vec![span.clone()],
- E::ExpectedNumberAfterUnaryOperator(Spanned { span, .. }) => vec![span.clone()],
- E::CannotIndexValue(Spanned { span, .. }) => vec![span.clone()],
- E::FieldNotFoundInStruct(Spanned { span, value: _ }) => vec![span.clone()],
- E::CannotDereferenceValue(Spanned { span, .. }) => vec![span.clone()],
- E::ReferenceToMovedData(span) => vec![span.clone()],
- E::VariableMoved(Spanned { span, .. }) => vec![span.clone()],
- E::CannotBorrowValue(Spanned { span, .. }) => vec![span.clone()],
- E::IncompatibleReflectTypes { span, .. } => vec![span.clone()],
- E::EnumVariantNotFound(Spanned { span, .. }) => vec![span.clone()],
- E::EnumVariantStructFieldNotFound { span, .. } => vec![span.clone()],
- E::EnumVariantTupleFieldNotFound { span, .. } => vec![span.clone()],
- E::CannotMoveOutOfResource(Spanned { span, .. }) => vec![span.clone()],
- E::CannotNegateUnsignedInteger(Spanned { span, .. }) => vec![span.clone()],
- E::IncompatibleNumberTypes { span, .. } => vec![span.clone()],
- E::IncompatibleFunctionParameter { span, .. } => vec![span.clone()],
- E::ExpectedVariableGotFunction(Spanned { span, .. }) => vec![span.clone()],
- E::CannotReflectReference(span) => vec![span.clone()],
- E::CannotReflectResource(span) => vec![span.clone()],
- E::InvalidOperation { span, .. } => vec![span.clone()],
- E::IncorrectAccessOperation { span, .. } => vec![span.clone()],
- E::FieldNotFoundInTuple { span, .. } => vec![span.clone()],
- }
- }
- /// Returns all the hints for this error.
- pub fn hints(&self) -> Vec {
- self.spans()
- .into_iter()
- .map(|span| CommandHint::new(span, CommandHintColor::Error, self.to_string()))
- .collect()
- }
+fn format_expected_access(expected_access: &[AccessKind]) -> String {
+ expected_access
+ .iter()
+ .map(|kind| kind.as_natural())
+ .collect::>()
+ .join(" and ")
}
-impl std::fmt::Display for EvalError {
- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- use EvalError as E;
+struct FancyJoin<'a, T: fmt::Display>(&'a [T]);
- match self {
- E::Custom { text, .. } => f.write_str(text),
- E::VariableNotFound(Spanned { value, .. }) => {
- write!(f, "Variable `{value}` not found.")
- }
- E::ExpectedNumberAfterUnaryOperator(Spanned { value, .. }) => write!(
- f,
- "Expected a number after unary operator (-) but got {} instead.",
- value.natural_kind()
- ),
- E::CannotIndexValue(Spanned { span: _, value }) => {
- write!(f, "Cannot index {} with a member expression.", value.kind())
- }
- E::ReferenceToMovedData(_) => write!(f, "Cannot access reference to moved data."),
- E::VariableMoved(Spanned { value, .. }) => {
- write!(f, "Variable `{value}` was moved.")
- }
- E::CannotDereferenceValue(Spanned { value: kind, .. }) => {
- write!(f, "Cannot dereference {kind}.")
- }
- E::CannotBorrowValue(Spanned { value: kind, .. }) => {
- write!(f, "Cannot borrow {kind}. Only variables can be borrowed.")
+impl<'a, T: fmt::Display> fmt::Display for FancyJoin<'a, T> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ for (i, item) in self.0.iter().enumerate() {
+ if i > 0 {
+ f.write_str(", ")?;
}
- E::IncompatibleReflectTypes {
- expected, actual, ..
- } => write!(
- f,
- "Cannot set incompatible reflect types. Expected `{expected}`, got `{actual}`"
- ),
- E::EnumVariantNotFound(Spanned { value: name, .. }) => {
- write!(f, "Enum variant `{name}` was not found.")
+ if i == self.0.len() - 1 {
+ f.write_str("and ")?;
}
- E::EnumVariantStructFieldNotFound {
- field_name,
- variant_name,
- ..
- } => write!(
- f,
- "Field `{field_name}` doesn't exist on struct variant `{variant_name}`."
- ),
- E::EnumVariantTupleFieldNotFound {
- field_index,
- variant_name,
- ..
- } => write!(
- f,
- "Field `{field_index}` doesn't exist on tuple variant `{variant_name}`."
- ),
- E::CannotMoveOutOfResource(Spanned { value, .. }) => write!(
- f,
- "Cannot move out of resource `{value}`, try borrowing it instead."
- ),
- E::CannotNegateUnsignedInteger(Spanned { value, .. }) => write!(
- f,
- "Unsigned integers cannot be negated. (Type: {})",
- value.natural_kind()
- ),
- E::IncompatibleNumberTypes { left, right, .. } => write!(
- f,
- "Incompatible number types; `{left}` and `{right}` are incompatible."
- ),
- E::IncompatibleFunctionParameter {
- expected, actual, ..
- } => write!(
- f,
- "Mismatched function parameter type. Expected {expected} but got {actual}"
- ),
- E::ExpectedVariableGotFunction(Spanned { value, .. }) => write!(
- f,
- "Expected `{value}` to be a variable, but got a function instead."
- ),
- E::CannotReflectReference(_) => {
- write!(
- f,
- "Cannot reflect a reference. Try dereferencing it instead."
- )
+ if f.alternate() {
+ write!(f, "{:#}", item)?;
+ } else {
+ write!(f, "{}", item)?;
}
- E::CannotReflectResource(_) => {
- write!(
- f,
- "Cannot reflecting resources is not possible at the moment."
- )
- }
- E::InvalidOperation {
- left,
- right,
- operation,
- span: _,
- } => write!(f, "Invalid operation: Cannot {operation} {left} by {right}"),
- E::IncorrectAccessOperation {
- expected_access,
- expected_type,
- got,
- span: _,
- } => write!(
- f,
- "Expected {} access to access {expected_type} but got {}",
- expected_access.join(" and "),
- got.natural_kind()
- ),
- E::FieldNotFoundInStruct(Spanned { span: _, value }) => {
- write!(f, "Field {value} not found in struct")
- }
- E::FieldNotFoundInTuple {
- field_index,
- tuple_size,
- span: _,
- } => write!(
- f,
- "Field {field_index} is out of bounds for tuple of size {tuple_size}"
- ),
}
+ Ok(())
}
}
-impl std::error::Error for EvalError {}
+impl From<&'static str> for EvalError {
+ fn from(value: &'static str) -> Self {
+ Self::Custom(value.into())
+ }
+}
diff --git a/src/builtin_parser/runner/eval.rs b/src/builtin_parser/runner/eval.rs
new file mode 100644
index 0000000..08ca262
--- /dev/null
+++ b/src/builtin_parser/runner/eval.rs
@@ -0,0 +1,564 @@
+//! Evaluation of expressions
+
+use std::collections::HashMap;
+
+use bevy::prelude::*;
+use bevy::reflect::{DynamicEnum, DynamicTuple, ReflectMut, TypeInfo, VariantInfo};
+use kinded::Kinded;
+
+use crate::builtin_parser::parser::{BinaryOperator, Expression, UnaryOperator};
+use crate::builtin_parser::runner::value::ValueKind;
+use crate::builtin_parser::{Diagnostic, ErrorExtension, SpanExtension, Spanned, StrongRef};
+
+use super::EvalParams;
+use super::environment::{RunFunctionError, VariableError};
+use super::error::EvalError;
+use super::member::{Path, eval_member_expression, eval_path};
+use super::reflection::{CreateRegistration, IntoResource, object_to_dynamic_struct};
+use super::unique_rc::UniqueRc;
+use super::value::Value;
+
+pub fn eval_expression(
+ expr: Spanned,
+ EvalParams {
+ world,
+ environment,
+ registrations,
+ }: EvalParams,
+) -> Result