schala-lang/src/parsing/combinator.rs

@@ -293,34 +293,32 @@ fn func_signature(input: Span) -> ParseResult<Signature> {
         "func-signature",
         preceded(
             kw("fn"),
-            cut(alt((
-                map(normal_fn, |(name, params, type_anno)| Signature {
-                    name: rc_string(name.fragment()),
-                    operator: false,
-                    params,
-                    type_anno,
-                }),
-                map(operator_fn, |(op, params, type_anno)| Signature {
-                    name: rc_string(op.sigil()),
-                    operator: true,
-                    params,
-                    type_anno,
-                }),
-            ))),
+            cut(verify(
+                alt((
+                    map(normal_fn, |(name, params, type_anno)| Signature {
+                        name: rc_string(name.fragment()),
+                        operator: false,
+                        params,
+                        type_anno,
+                    }),
+                    map(operator_fn, |(op, params, type_anno)| Signature {
+                        name: rc_string(op.sigil()),
+                        operator: true,
+                        params,
+                        type_anno,
+                    }),
+                )),
+                |sig| sig.params.len() < 256,
+            )),
         ),
     )(input)
 }
 
 fn formal_params(input: Span) -> ParseResult<Vec<FormalParam>> {
-    context(
-        "formal-params",
-        verify(
-            delimited(tok(char('(')), separated_list0(tok(char(',')), formal_param), tok(char(')'))),
-            |params: &Vec<_>| params.len() < 256,
-        ),
-    )(input)
+    delimited(tok(char('(')), separated_list0(tok(char(',')), formal_param), tok(char(')')))(input)
 }
 
+//TODO support 256-limit
 fn formal_param(input: Span) -> ParseResult<FormalParam> {
     map(
         tuple((identifier, opt(type_anno), opt(preceded(tok(char('=')), expression)))),
@@ -580,6 +578,7 @@ 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,6 +1,8 @@
 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> {
@@ -262,6 +264,7 @@ 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,14 +886,6 @@ 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]