Fix parse_variadic_add3 test

Parsing/printing the function AST wasn't really working before this.

Author: Techcable

src/ast/functions.rs

@@ -357,19 +357,31 @@ regular_insn_common!(CallInstruction);
 /// An argument to a [`CallInstruction`].
 #[derive(Clone, Debug, Eq, PartialEq, Hash)]
 pub enum CallArgument {
-    Value(Value),
+    Regular(RegularCallArgument),
     Environment(Value),
     VariadicMarker(Span),
 }
 impl Display for CallArgument {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            CallArgument::Value(value) => Display::fmt(value, f),
+            CallArgument::Regular(inner) => Display::fmt(inner, f),
             CallArgument::Environment(value) => write!(f, "env {value}"),
             CallArgument::VariadicMarker(_) => f.write_str("..."),
         }
     }
 }
+/// A regular [`CallArgument`], including both a value and its type.
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct RegularCallArgument {
+    pub span: Span,
+    pub ty: AbiType,
+    pub value: Value,
+}
+impl Display for RegularCallArgument {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{} {}", self.ty, self.value)
+    }
+}
 
 #[derive(Clone, Debug, Eq, PartialEq, Hash)]
 pub struct ThreadLocalRef {

src/ast/functions/parse.rs

@@ -1,8 +1,9 @@
 use crate::ast::data::Constant;
 use crate::ast::functions::{
-    EnvironmentParamDef, FunctionBlock, FunctionBody, FunctionDef, InsnDestInfo, JumpInstruction,
-    JumpInstructionKind, ParamDef, PhiArg, PhiInstruction, RegularInstruction, RegularParamDef,
-    SimpleInstruction, SimpleInstructionArgs, ThreadLocalRef, Value, VariadicParamDef,
+    CallArgument, CallInstruction, EnvironmentParamDef, FunctionBlock, FunctionBody, FunctionDef,
+    InsnDestInfo, JumpInstruction, JumpInstructionKind, ParamDef, PhiArg, PhiInstruction,
+    RegularCallArgument, RegularInstruction, RegularParamDef, SimpleInstruction,
+    SimpleInstructionArgs, ThreadLocalRef, Value, VariadicParamDef,
 };
 use crate::ast::linkage::Linkage;
 use crate::ast::types::{AbiType, BaseType};
@@ -114,7 +115,7 @@ impl Parse for RegularParamDef {
 impl Parse for EnvironmentParamDef {
     const DESC: &'static str = "environment parameter";
     fn parser<'a>() -> impl TokenParser<'a, Self> {
-        operator!(...)
+        keyword!(env)
             .parser()
             .ignore_then(TemporaryName::parser())
             .map_with(|name, extra| EnvironmentParamDef {
@@ -269,9 +270,11 @@ impl Parse for PhiArg {
 impl Parse for RegularInstruction {
     const DESC: &'static str = "regular instruction";
     fn parser<'a>() -> impl TokenParser<'a, Self> {
-        SimpleInstruction::parser()
-            .map(RegularInstruction::Simple)
-            .labelled(Self::DESC)
+        choice((
+            SimpleInstruction::parser().map(RegularInstruction::Simple),
+            CallInstruction::parser().map(RegularInstruction::Call),
+        ))
+        .labelled(Self::DESC)
     }
 }
 impl_fromstr_via_parse!(RegularInstruction);
@@ -298,6 +301,57 @@ impl Parse for SimpleInstruction {
     }
 }
 impl_fromstr_via_parse!(SimpleInstruction);
+impl Parse for CallInstruction {
+    const DESC: &'static str = "call instruction";
+    fn parser<'a>() -> impl TokenParser<'a, Self> {
+        let args = CallArgument::parser()
+            .separated_by(operator!(,).parser())
+            .collect::<Vec<_>>()
+            .delimited_by(just(Token::OpenParen), just(Token::CloseParen));
+        InsnDestInfo::parser()
+            .or_not()
+            .then(keyword!(call).parser().to_span())
+            .then(Value::parser())
+            .then(args)
+            .map_with(
+                |(((dest_info, call_kw_span), target), args), extra| CallInstruction {
+                    span: extra.span(),
+                    call_kw_span,
+                    target,
+                    args,
+                    dest_info,
+                },
+            )
+    }
+}
+impl Parse for CallArgument {
+    const DESC: &'static str = "call argument";
+    fn parser<'a>() -> impl TokenParser<'a, Self> {
+        choice((
+            RegularCallArgument::parser().map(CallArgument::Regular),
+            keyword!(env)
+                .parser()
+                .ignore_then(Value::parser())
+                .map(CallArgument::Environment),
+            operator!(...)
+                .parser()
+                .to_span()
+                .map(CallArgument::VariadicMarker),
+        ))
+    }
+}
+impl Parse for RegularCallArgument {
+    const DESC: &'static str = "regular call argument";
+    fn parser<'a>() -> impl TokenParser<'a, Self> {
+        AbiType::parser()
+            .then(Value::parser())
+            .map_with(|(ty, value), extra| RegularCallArgument {
+                ty,
+                value,
+                span: extra.span(),
+            })
+    }
+}
 impl Parse for InsnDestInfo {
     const DESC: &'static str = "instruction destination";
     fn parser<'a>() -> impl TokenParser<'a, Self> {

src/ast/functions/test.rs

@@ -1,7 +1,8 @@
+use crate::ast::data::Constant;
 use crate::ast::functions::{
-    FunctionBlock, FunctionBody, FunctionDef, InsnDestInfo, JumpInstruction, ParamDef, PhiArg,
-    PhiInstruction, RegularInstruction, RegularParamDef, SimpleInstruction, SimpleInstructionArgs,
-    Value, VariadicParamDef,
+    CallArgument, CallInstruction, FunctionBlock, FunctionBody, FunctionDef, InsnDestInfo,
+    JumpInstruction, ParamDef, PhiArg, PhiInstruction, RegularCallArgument, RegularInstruction,
+    RegularParamDef, SimpleInstruction, SimpleInstructionArgs, Value, VariadicParamDef,
 };
 use crate::ast::linkage::Linkage;
 use crate::ast::types::BaseType;
@@ -139,6 +140,36 @@ fn variadic_add3() -> FunctionDef {
                         args: SimpleInstructionArgs::from([32.into()]),
                     }
                     .into(),
+                    SimpleInstruction {
+                        span: Span::MISSING,
+                        dest_info: None,
+                        name: Ident::unspanned("vastart"),
+                        args: SimpleInstructionArgs::from([TemporaryName::unspanned("ap").into()]),
+                    }
+                    .into(),
+                    CallInstruction {
+                        span: Span::MISSING,
+                        dest_info: Some(InsnDestInfo {
+                            span: Span::MISSING,
+                            ty: BaseType::Single,
+                            dest: TemporaryName::unspanned("r"),
+                        }),
+                        target: Value::Constant(Constant::SymbolRef(GlobalName::unspanned("vadd"))),
+                        call_kw_span: Span::MISSING,
+                        args: vec![
+                            CallArgument::Regular(RegularCallArgument {
+                                ty: BaseType::Single.into(),
+                                value: TemporaryName::unspanned("a").into(),
+                                span: Span::MISSING,
+                            }),
+                            CallArgument::Regular(RegularCallArgument {
+                                ty: BaseType::Long.into(),
+                                value: TemporaryName::unspanned("ap").into(),
+                                span: Span::MISSING,
+                            }),
+                        ],
+                    }
+                    .into(),
                 ],
                 terminator: Some(JumpInstruction::Return {
                     value: Some(TemporaryName::unspanned("r").into()),

src/lexer.rs

@@ -107,7 +107,6 @@ fn token<'a>() -> impl StringParser<'a, Token> {
         // must come after Operator since `z` is an operator
         ident().map(Token::Ident),
         string_literal().map(Token::StringLiteral),
-        delimiter(),
         one_of("+-")
             .or_not()
             .ignore_then(text::int(10))
@@ -133,6 +132,7 @@ fn token<'a>() -> impl StringParser<'a, Token> {
         .map(Token::from);
     let newline_token = ascii_newline().repeated().at_least(1).to(Token::Newline);
     symbol
+        .or(delimiter())
         .or(basic_token.then_ignore(require_space_like()))
         .or(newline_token)
         .labelled("token")

src/lexer/tokens.rs

@@ -301,6 +301,7 @@ define_keyword_enum!(
         Align,
         Call,
         Data,
+        Env,
         Export,
         Function,
         Hlt,