Fix remaining doc tests

dust-lang/src/analyzer.rs

@@ -23,8 +23,8 @@ use crate::{
 /// # use dust_lang::*;
 /// let input = "x = 1 + false";
 /// let abstract_tree = parse(input).unwrap();
-/// let variables = HashMap::new();
+/// let mut context = Context::new();
-/// let result = analyze(&abstract_tree, &variables);
+/// let result = analyze(&abstract_tree, &mut context);
 ///
 /// assert!(result.is_err());
 /// ```
@@ -45,8 +45,8 @@ pub fn analyze(
 /// # use dust_lang::*;
 /// let input = "x = 1 + false";
 /// let abstract_tree = parse(input).unwrap();
-/// let variables = HashMap::new();
+/// let mut context = Context::new();
-/// let analyzer = Analyzer::new(&abstract_tree, &variables);
+/// let mut analyzer = Analyzer::new(&abstract_tree, &mut context);
 /// let result = analyzer.analyze();
 ///
 /// assert!(result.is_err());

dust-lang/src/parse.rs

@@ -21,28 +21,31 @@ use crate::{
 /// # Examples
 /// ```
 /// # use dust_lang::*;
-/// let input = "x = 42";
+/// let tree = parse("x = 42").unwrap();
-/// let result = parse(input);
 ///
 /// assert_eq!(
-///     result,
+///     tree,
-///     Ok(AbstractSyntaxTree {
+///     AbstractSyntaxTree {
 ///         nodes: [
-///             Node {
+///             Node::new(
-///                 inner: Statement::Assignment {
+///                 Statement::BinaryOperation {
-///                     identifier: Node {
+///                     left: Box::new(Node::new(
-///                         inner: Identifier::new("x"),
+///                         Statement::Identifier(Identifier::new("x")),
-///                         position: (0, 1),
+///                         (0, 1),
-///                     },
+///                     )),
-///                     value_node: Box::new(Node {
+///                     operator: Node::new(
-///                         inner: Statement::Constant(Value::integer(42)),
+///                         BinaryOperator::Assign,
-///                         position: (4, 6),
+///                         (2, 3)
-///                     })
+///                     ),
+///                     right: Box::new(Node::new(
+///                         Statement::Constant(Value::integer(42)),
+///                         (4, 6),
+///                     ))
 ///                 },
-///                 position: (0, 6),
+///                 (0, 6),
-///             }
+///             )
 ///         ].into(),
-///     }),
+///     },
 /// );
 /// ```
 pub fn parse(input: &str) -> Result<AbstractSyntaxTree, ParseError> {
@@ -87,19 +90,23 @@ pub fn parse(input: &str) -> Result<AbstractSyntaxTree, ParseError> {
 /// assert_eq!(
 ///     nodes,
 ///     Into::<VecDeque<Node<Statement>>>::into([
-///         Node {
+///         Node::new(
-///             inner: Statement::Assignment {
+///             Statement::BinaryOperation {
-///                 identifier: Node {
+///                 left: Box::new(Node::new(
-///                     inner: Identifier::new("x"),
+///                     Statement::Identifier(Identifier::new("x")),
-///                     position: (0, 1),
+///                     (0, 1),
-///                 },
+///                 )),
-///                 value_node: Box::new(Node {
+///                 operator: Node::new(
-///                     inner: Statement::Constant(Value::integer(42)),
+///                     BinaryOperator::Assign,
-///                     position: (4, 6),
+///                     (2, 3),
-///                 }),
+///                 ),
+///                 right: Box::new(Node::new(
+///                     Statement::Constant(Value::integer(42)),
+///                     (4, 6),
+///                 )),
 ///             },
-///             position: (0, 6),
+///             (0, 6),
-///         }
+///         )
 ///     ]),
 /// );
 /// ```
@@ -231,13 +238,23 @@ impl<'src> Parser<'src> {
 
                     let next_node = self.parse_statement(0)?;
 
+                    // If the new statement is already a block, add the next node to it
+                    if statement
+                        .as_ref()
+                        .is_some_and(|statement| matches!(statement, Statement::Block(_)))
+                    {
+                        if let Statement::Block(block) =
+                            statement.get_or_insert_with(|| Statement::Block(Vec::new()))
+                        {
+                            block.push(next_node);
+                        }
                     // If the next node is an assignment, this might be a map
-                    if let Statement::BinaryOperation {
+                    } else if let Statement::BinaryOperation {
                         left,
                         operator:
                             Node {
                                 inner: BinaryOperator::Assign,
-                                ..
+                                position: operator_position,
                             },
                         right,
                     } = next_node.inner
@@ -256,10 +273,28 @@ impl<'src> Parser<'src> {
                                 map_properties.push((*left, *right));
                             }
 
-                            // Ignore commas after properties
+                            // Allow commas after properties
                             if let Token::Comma = self.current.0 {
                                 self.next_token()?;
                             }
+                        } else {
+                            // Otherwise, the new statement is a block
+                            if let Statement::Block(statements) =
+                                statement.get_or_insert_with(|| Statement::Block(Vec::new()))
+                            {
+                                // Add the statement to the block
+                                statements.push(Node::new(
+                                    Statement::BinaryOperation {
+                                        left,
+                                        operator: Node::new(
+                                            BinaryOperator::Assign,
+                                            operator_position,
+                                        ),
+                                        right,
+                                    },
+                                    next_node.position,
+                                ));
+                            }
                         }
                     // Otherwise, the new statement is a block
                     } else if let Statement::Block(statements) =
@@ -655,13 +690,13 @@ mod tests {
                                         Statement::Identifier(Identifier::new("foo")),
                                         (2, 5)
                                     )),
-                                    operator: Node::new(BinaryOperator::Assign, (6, 8)),
+                                    operator: Node::new(BinaryOperator::Assign, (6, 7)),
                                     right: Box::new(Node::new(
                                         Statement::Constant(Value::integer(42)),
-                                        (9, 11)
+                                        (8, 10)
                                     )),
                                 },
-                                (2, 11)
+                                (2, 10)
                             ),)),
                             (2, 15)
                         ),
@@ -670,12 +705,12 @@ mod tests {
                                 Statement::BinaryOperation {
                                     left: Box::new(Node::new(
                                         Statement::Identifier(Identifier::new("bar")),
-                                        (16, 19)
+                                        (12, 15)
                                     )),
-                                    operator: Node::new(BinaryOperator::Assign, (20, 22)),
+                                    operator: Node::new(BinaryOperator::Assign, (16, 17)),
                                     right: Box::new(Node::new(
                                         Statement::Constant(Value::integer(42)),
-                                        (23, 25)
+                                        (18, 20)
                                     )),
                                 },
                                 (12, 20)
@@ -686,12 +721,12 @@ mod tests {
                             Statement::BinaryOperation {
                                 left: Box::new(Node::new(
                                     Statement::Identifier(Identifier::new("baz")),
-                                    (26, 29)
+                                    (22, 25)
                                 )),
-                                operator: Node::new(BinaryOperator::Assign, (30, 32)),
+                                operator: Node::new(BinaryOperator::Assign, (26, 27)),
                                 right: Box::new(Node::new(
                                     Statement::Constant(Value::string("42")),
-                                    (22, 32)
+                                    (28, 32)
                                 )),
                             },
                             (22, 32)

dust-lang/src/value.rs

@@ -43,11 +43,11 @@ use crate::{identifier::Identifier, AbstractSyntaxTree, Context, Type, Vm, VmErr
 ///
 /// ```
 /// # use std::collections::HashMap;
-/// # use dust_lang::{Type, Value};
+/// # use dust_lang::*;
-/// let variables = HashMap::new();
+/// let context = Context::new();
 /// let value = Value::integer(42);
 ///
-/// assert_eq!(value.r#type(&variables), Type::Integer);
+/// assert_eq!(value.r#type(&context), Type::Integer);
 /// ```
 #[derive(Clone, Debug, PartialEq)]
 pub struct Value(Arc<ValueInner>);