Expand macros earlier so they include constants

This also simplifies macro expansion significantly, having it operate
in-place.

Author: udoprog

crates/rune-modules/README.md

@@ -54,6 +54,7 @@ See each module for documentation:
 * [fs]
 * [process]
 * [signal]
+* [rand]
 
 ### Features
 
@@ -62,9 +63,10 @@ See each module for documentation:
 * `json` for the [json module][json]
 * `toml` for the [toml module][toml]
 * `time` for the [time module][time]
-* `fs` for the [fs module]][fs]
-* `process` for the [process module]][process]
-* `signal` for the [process module]][signal]
+* `fs` for the [fs module][fs]
+* `process` for the [process module][process]
+* `signal` for the [signal module][signal]
+* `rand` for the [rand module][rand]
 
 [http]: https://docs.rs/rune-modules/0/rune_modules/http/
 [json]: https://docs.rs/rune-modules/0/rune_modules/json/
@@ -73,3 +75,4 @@ See each module for documentation:
 [fs]: https://docs.rs/rune-modules/0/rune_modules/fs/
 [process]: https://docs.rs/rune-modules/0/rune_modules/process/
 [signal]: https://docs.rs/rune-modules/0/rune_modules/signal/
+[rand]: https://docs.rs/rune-modules/0/rune_modules/rand/

crates/rune/src/ast/block.rs

@@ -1,5 +1,5 @@
 use crate::ast;
-use crate::{OptionSpanned as _, Parse, ParseError, ParseErrorKind, Parser, Spanned, ToTokens};
+use crate::{Parse, ParseError, Parser, Spanned, ToTokens};
 
 /// A block of expressions.
 #[derive(Debug, Clone, PartialEq, Eq, ToTokens, Spanned)]
@@ -63,55 +63,9 @@ impl Parse for Block {
         let mut statements = Vec::new();
 
         let open = parser.parse()?;
-        let mut must_be_last = None;
 
         while !parser.peek::<ast::CloseBrace>()? {
-            let attributes = parser.parse()?;
-            let visibility = parser.parse()?;
-
-            if ast::Item::peek_as_stmt(parser)? {
-                let decl: ast::Item = ast::Item::parse_with_meta(parser, attributes, visibility)?;
-
-                if let Some(span) = must_be_last {
-                    return Err(ParseError::new(
-                        span,
-                        ParseErrorKind::ExpectedBlockSemiColon {
-                            followed_span: decl.span(),
-                        },
-                    ));
-                }
-
-                statements.push(ast::Stmt::Item(decl));
-                continue;
-            }
-
-            if let Some(span) = visibility.option_span() {
-                return Err(ParseError::new(
-                    span,
-                    ParseErrorKind::UnsupportedExprVisibility,
-                ));
-            }
-
-            let expr: ast::Expr = ast::Expr::parse_primary_with_attributes(parser, attributes)?;
-
-            if let Some(span) = must_be_last {
-                return Err(ParseError::new(
-                    span,
-                    ParseErrorKind::ExpectedBlockSemiColon {
-                        followed_span: expr.span(),
-                    },
-                ));
-            }
-
-            if parser.peek::<ast::SemiColon>()? {
-                statements.push(ast::Stmt::Semi(expr, parser.parse()?));
-            } else {
-                if expr.needs_semi() {
-                    must_be_last = Some(expr.span());
-                }
-
-                statements.push(ast::Stmt::Expr(expr));
-            }
+            statements.push(parser.parse()?);
         }
 
         let close = parser.parse()?;

crates/rune/src/ast/expr.rs

@@ -1,5 +1,7 @@
 use crate::ast;
-use crate::{Parse, ParseError, ParseErrorKind, Parser, Peek, Spanned, ToTokens};
+use crate::{
+    OptionSpanned as _, Parse, ParseError, ParseErrorKind, Parser, Peek, Spanned, ToTokens,
+};
 use std::mem::take;
 use std::ops;
 
@@ -173,28 +175,27 @@ impl Expr {
     /// are arguments to statements immediately followed by blocks. Like `if`,
     /// `while`, and `match`.
     pub(crate) fn parse_without_eager_brace(parser: &mut Parser<'_>) -> Result<Self, ParseError> {
-        Self::parse_full(parser, EagerBrace(false), ExprChain(true), vec![])
+        Self::parse_full(parser, EagerBrace(false), ExprChain(true), &mut vec![])
     }
 
     /// Full, configurable parsing of an expression.
-    pub(crate) fn parse_full(
+    fn parse_full(
         parser: &mut Parser<'_>,
         eager_brace: EagerBrace,
         expr_chain: ExprChain,
-        attributes: Vec<ast::Attribute>,
+        attributes: &mut Vec<ast::Attribute>,
     ) -> Result<Self, ParseError> {
         let lhs = Self::parse_primary(parser, eager_brace, expr_chain, attributes)?;
         Ok(Self::parse_expr_binary(parser, lhs, 0, eager_brace)?)
     }
 
     /// Parse expressions that start with an identifier.
-    pub(crate) fn parse_ident_start(
+    pub(crate) fn parse_with_path(
         parser: &mut Parser<'_>,
+        path: ast::Path,
         eager_brace: EagerBrace,
         attributes: &mut Vec<ast::Attribute>,
     ) -> Result<Self, ParseError> {
-        let path = parser.parse::<ast::Path>()?;
-
         if *eager_brace && parser.peek::<ast::OpenBrace>()? {
             let ident = ast::LitObjectIdent::Named(path);
 
@@ -226,7 +227,7 @@ impl Expr {
         }
 
         let open = parser.parse::<ast::OpenParen>()?;
-        let expr = ast::Expr::parse_full(parser, EagerBrace(true), ExprChain(true), vec![])?;
+        let expr = ast::Expr::parse_full(parser, EagerBrace(true), ExprChain(true), &mut vec![])?;
 
         if parser.peek::<ast::CloseParen>()? {
             return Ok(Expr::ExprGroup(ast::ExprGroup {
@@ -244,19 +245,27 @@ impl Expr {
         }))
     }
 
-    pub(crate) fn parse_primary_with_attributes(
+    pub(crate) fn parse_with_meta(
         parser: &mut Parser<'_>,
-        attributes: Vec<ast::Attribute>,
+        attributes: &mut Vec<ast::Attribute>,
+        path: Option<ast::Path>,
     ) -> Result<Self, ParseError> {
-        Self::parse_full(parser, EagerBrace(true), ExprChain(true), attributes)
+        let lhs = if let Some(path) = path {
+            let expr = Self::parse_with_path(parser, path, EagerBrace(true), attributes)?;
+            Self::parse_expr_chain(parser, expr)?
+        } else {
+            Self::parse_primary(parser, EagerBrace(true), ExprChain(true), attributes)?
+        };
+
+        Ok(Self::parse_expr_binary(parser, lhs, 0, EagerBrace(true))?)
     }
 
     /// Parse a single expression value.
     pub(crate) fn parse_primary(
         parser: &mut Parser<'_>,
         eager_brace: EagerBrace,
         expr_chain: ExprChain,
-        mut attributes: Vec<ast::Attribute>,
+        attributes: &mut Vec<ast::Attribute>,
     ) -> Result<Self, ParseError> {
         while parser.peek::<ast::Attribute>()? {
             attributes.push(parser.parse::<ast::attribute::InnerAttribute>()?.0);
@@ -265,25 +274,26 @@ impl Expr {
         let expr = if ast::Lit::peek_in_expr(parser)? {
             ast::Expr::ExprLit(ast::ExprLit::parse_with_attributes(
                 parser,
-                take(&mut attributes),
+                take(attributes),
             )?)
         } else {
             let token = parser.token_peek_eof()?;
 
             match token.kind {
                 ast::Kind::Async => {
                     let async_: ast::Async = parser.parse()?;
-                    let expr: Self = Self::parse_primary(parser, eager_brace, expr_chain, vec![])?;
+                    let expr: Self =
+                        Self::parse_primary(parser, eager_brace, expr_chain, &mut vec![])?;
 
                     match expr {
                         Self::ExprClosure(expr_closure) => Self::ExprClosure(ast::ExprClosure {
-                            attributes: take(&mut attributes),
+                            attributes: take(attributes),
                             async_: Some(async_),
                             args: expr_closure.args,
                             body: expr_closure.body,
                         }),
                         Self::ExprBlock(expr_block) => Self::ExprAsync(ast::ExprAsync {
-                            attributes: take(&mut attributes),
+                            attributes: take(attributes),
                             async_,
                             block: expr_block.block,
                         }),
@@ -296,12 +306,12 @@ impl Expr {
                     }
                 }
                 ast::Kind::PipePipe | ast::Kind::Pipe => Self::ExprClosure(
-                    ast::ExprClosure::parse_with_attributes(parser, take(&mut attributes))?,
+                    ast::ExprClosure::parse_with_attributes(parser, take(attributes))?,
                 ),
                 ast::Kind::Self_ => Self::Self_(parser.parse()?),
                 ast::Kind::Select => Self::ExprSelect(ast::ExprSelect::parse_with_attributes(
                     parser,
-                    take(&mut attributes),
+                    take(attributes),
                 )?),
                 ast::Kind::Label(..) => {
                     let label =
@@ -312,21 +322,21 @@ impl Expr {
                         ast::Kind::While => {
                             Self::ExprWhile(ast::ExprWhile::parse_with_attributes_and_label(
                                 parser,
-                                take(&mut attributes),
+                                take(attributes),
                                 label,
                             )?)
                         }
                         ast::Kind::Loop => {
                             Self::ExprLoop(ast::ExprLoop::parse_with_attributes_and_label(
                                 parser,
-                                take(&mut attributes),
+                                take(attributes),
                                 label,
                             )?)
                         }
                         ast::Kind::For => {
                             Self::ExprFor(ast::ExprFor::parse_with_attributes_and_label(
                                 parser,
-                                take(&mut attributes),
+                                take(attributes),
                                 label,
                             )?)
                         }
@@ -340,70 +350,56 @@ impl Expr {
                 }
                 ast::Kind::While => Self::ExprWhile(ast::ExprWhile::parse_with_attributes(
                     parser,
-                    take(&mut attributes),
+                    take(attributes),
                 )?),
                 ast::Kind::Loop => Self::ExprLoop(ast::ExprLoop::parse_with_attributes(
                     parser,
-                    take(&mut attributes),
+                    take(attributes),
                 )?),
                 ast::Kind::For => Self::ExprFor(ast::ExprFor::parse_with_attributes(
                     parser,
-                    take(&mut attributes),
+                    take(attributes),
                 )?),
                 ast::Kind::Let => Self::ExprLet(ast::ExprLet::parse_with_attributes(
                     parser,
-                    take(&mut attributes),
+                    take(attributes),
                 )?),
                 ast::Kind::If => Self::ExprIf(ast::ExprIf::parse_with_attributes(
                     parser,
-                    take(&mut attributes),
+                    take(attributes),
                 )?),
                 ast::Kind::Match => Self::ExprMatch(ast::ExprMatch::parse_with_attributes(
                     parser,
-                    take(&mut attributes),
+                    take(attributes),
                 )?),
                 ast::Kind::Open(ast::Delimiter::Parenthesis) => {
-                    Self::parse_open_paren(parser, &mut attributes)?
+                    Self::parse_open_paren(parser, attributes)?
                 }
                 ast::Kind::Open(ast::Delimiter::Brace) => Self::ExprBlock(
-                    ast::ExprBlock::parse_with_attributes(parser, take(&mut attributes))?,
+                    ast::ExprBlock::parse_with_attributes(parser, take(attributes))?,
                 ),
                 ast::Kind::Ident(..) => {
-                    Self::parse_ident_start(parser, eager_brace, &mut attributes)?
+                    let path = parser.parse()?;
+                    Self::parse_with_path(parser, path, eager_brace, attributes)?
                 }
                 ast::Kind::Break => Self::ExprBreak(ast::ExprBreak::parse_with_attributes(
                     parser,
-                    take(&mut attributes),
+                    take(attributes),
                 )?),
                 ast::Kind::Yield => Self::ExprYield(ast::ExprYield::parse_with_attributes(
                     parser,
-                    take(&mut attributes),
+                    take(attributes),
                 )?),
                 ast::Kind::Return => Self::ExprReturn(ast::ExprReturn::parse_with_attributes(
                     parser,
-                    take(&mut attributes),
+                    take(attributes),
                 )?),
                 _ => {
                     return Err(ParseError::expected(token, "expression"));
                 }
             }
         };
 
-        let mut it = attributes.into_iter();
-
-        if let Some(first) = it.next() {
-            let span = if let Some(last) = it.next_back() {
-                first.span().join(last.span())
-            } else {
-                first.span()
-            };
-
-            return Err(ParseError::new(
-                span,
-                ParseErrorKind::AttributesNotSupported,
-            ));
-        }
-
         if !*expr_chain {
             return Ok(expr);
         }
@@ -469,8 +465,12 @@ impl Expr {
                         }
                     }
 
-                    let next =
-                        Expr::parse_primary(parser, EagerBrace(false), ExprChain(false), vec![])?;
+                    let next = Expr::parse_primary(
+                        parser,
+                        EagerBrace(false),
+                        ExprChain(false),
+                        &mut vec![],
+                    )?;
 
                     let span = match next {
                         Expr::Path(path) => {
@@ -536,7 +536,7 @@ impl Expr {
                 parser.token_next()?;
             }
 
-            let mut rhs = Self::parse_primary(parser, eager_brace, ExprChain(true), vec![])?;
+            let mut rhs = Self::parse_primary(parser, eager_brace, ExprChain(true), &mut vec![])?;
 
             lookahead_tok = parser.token_peek_pair()?;
 
@@ -607,8 +607,17 @@ impl Expr {
 /// ```
 impl Parse for Expr {
     fn parse(parser: &mut Parser<'_>) -> Result<Self, ParseError> {
-        let attributes = parser.parse()?;
-        Self::parse_full(parser, EagerBrace(true), ExprChain(true), attributes)
+        let mut attributes = parser.parse()?;
+        let expr = Self::parse_full(parser, EagerBrace(true), ExprChain(true), &mut attributes)?;
+
+        if let Some(span) = attributes.option_span() {
+            return Err(ParseError::new(
+                span,
+                ParseErrorKind::AttributesNotSupported,
+            ));
+        }
+
+        Ok(expr)
     }
 }
 

crates/rune/src/ast/expr_unary.rs

@@ -38,7 +38,7 @@ impl Parse for ExprUnary {
                 parser,
                 EagerBrace(true),
                 ExprChain(true),
-                vec![],
+                &mut vec![],
             )?),
         })
     }