Apply 256 arg limit to lambdas too

schala-lang/src/parsing/combinator.rs

@@ -293,32 +293,34 @@ fn func_signature(input: Span) -> ParseResult<Signature> {
         "func-signature",
         preceded(
             kw("fn"),
-            cut(verify(
+            cut(alt((
-                alt((
+                map(normal_fn, |(name, params, type_anno)| Signature {
-                    map(normal_fn, |(name, params, type_anno)| Signature {
+                    name: rc_string(name.fragment()),
-                        name: rc_string(name.fragment()),
+                    operator: false,
-                        operator: false,
+                    params,
-                        params,
+                    type_anno,
-                        type_anno,
+                }),
-                    }),
+                map(operator_fn, |(op, params, type_anno)| Signature {
-                    map(operator_fn, |(op, params, type_anno)| Signature {
+                    name: rc_string(op.sigil()),
-                        name: rc_string(op.sigil()),
+                    operator: true,
-                        operator: true,
+                    params,
-                        params,
+                    type_anno,
-                        type_anno,
+                }),
-                    }),
+            ))),
-                )),
-                |sig| sig.params.len() < 256,
-            )),
         ),
     )(input)
 }
 
 fn formal_params(input: Span) -> ParseResult<Vec<FormalParam>> {
-    delimited(tok(char('(')), separated_list0(tok(char(',')), formal_param), tok(char(')')))(input)
+    context(
+        "formal-params",
+        verify(
+            delimited(tok(char('(')), separated_list0(tok(char(',')), formal_param), tok(char(')'))),
+            |params: &Vec<_>| params.len() < 256,
+        ),
+    )(input)
 }
 
-//TODO support 256-limit
 fn formal_param(input: Span) -> ParseResult<FormalParam> {
     map(
         tuple((identifier, opt(type_anno), opt(preceded(tok(char('=')), expression)))),
@@ -578,7 +580,6 @@ fn extended_expr_part(input: Span) -> ParseResult<ExtendedPart> {
     ))(input)
 }
 
-//TODO this shouldn't be an expression b/c type annotations disallowed here
 fn invocation_argument(input: Span) -> ParseResult<InvocationArgument> {
     context(
         "invocation-argument",

schala-lang/src/parsing/peg_parser.rs

@@ -1,8 +1,6 @@
 use std::rc::Rc;
 
 use super::Parser;
-//TODO make use of the format_parse_error function
-//use crate::error::{SchalaError, format_parse_error};
 use crate::ast::*;
 
 fn rc_string(s: &str) -> Rc<String> {
@@ -264,7 +262,6 @@ peg::parser! {
         rule call_part(parser: &mut Parser) -> Vec<InvocationArgument> =
             "(" arguments:(invocation_argument(parser) ** ",") ")" { arguments }
 
-        //TODO this shouldn't be an expression b/c type annotations disallowed here
         rule invocation_argument(parser: &mut Parser) -> InvocationArgument =
             _ "_" _ { InvocationArgument::Ignored } /
             _ ident:identifier() _ "=" _ expr:expression(parser) { InvocationArgument::Keyword {

schala-lang/src/parsing/test.rs

@@ -886,6 +886,14 @@ fn max_function_params() {
     //TODO need to create a good, custom error message for this case
     //assert_fail!(&buf, "A function cannot have more than 255 arguments");
     assert_fail!(&buf);
+
+    let mut buf = r#"\("#.to_string();
+    for n in 0..255 {
+        write!(buf, "a{}, ", n).unwrap();
+    }
+    write!(buf, " a256").unwrap();
+    write!(buf, ") {{ return 10 }}").unwrap();
+    assert_fail!(&buf);
 }
 
 #[test]