feat: support binary operations for function return type (#184)

* feat: support binary operations for function return type

examples/generic_repeated_array.no

@@ -1,10 +1,10 @@
-fn init_arr(const LEFT: Field) -> [Field; LEFT] {
- let arr = [0; LEFT];
+fn init_arr(const LEFT: Field) -> [Field; 1 + (LEFT * 2)] {
+ let arr = [0; 1 + (LEFT * 2)];
  return arr;
 }
 
 fn main(pub public_input: Field) -> [Field; 3] {
- let mut arr = init_arr(3);
+ let mut arr = init_arr(1);
  for ii in 0..3 {
  arr[ii] = public_input;
  }

src/negative_tests.rs

@@ -1,13 +1,27 @@
 use crate::{
  backends::r1cs::{R1csBn254Field, R1CS},
  circuit_writer::CircuitWriter,
- compiler::{typecheck_next_file_inner, Sources},
+ compiler::{get_nast, typecheck_next_file_inner, Sources},
  error::{ErrorKind, Result},
  mast::Mast,
+ name_resolution::NAST,
  type_checker::TypeChecker,
  witness::CompiledCircuit,
 };
 
+fn nast_pass(code: &str) -> Result<(NAST<R1CS<R1csBn254Field>>, usize)> {
+ let mut source = Sources::new();
+ let res = get_nast(
+ None,
+ &mut source,
+ "example.no".to_string(),
+ code.to_string(),
+ 0,
+ );
+
+ res
+}
+
 fn tast_pass(code: &str) -> (Result<usize>, TypeChecker<R1CS<R1csBn254Field>>, Sources) {
  let mut source = Sources::new();
  let mut tast = TypeChecker::<R1CS<R1csBn254Field>>::new();
@@ -371,3 +385,17 @@ fn test_multiplication_mismatch() {
  let res = tast_pass(code).0;
  assert!(matches!(res.unwrap_err().kind, ErrorKind::MismatchType(..)));
 }
+
+#[test]
+fn test_generic_missing_parenthesis() {
+ let code = r#"
+ fn init_arr(const LEFT: Field) -> [Field; 1 + LEFT * 2] {
+ let arr = [0; 1 + (LEFT * 2)];
+ return arr;
+ }
+ "#;
+
+ let res = nast_pass(code).err();
+ println!("{:?}", res);
+ assert!(matches!(res.unwrap().kind, ErrorKind::MissingParenthesis));
+}

src/parser/types.rs

@@ -247,6 +247,7 @@ impl Symbolic {
  let lhs = Symbolic::parse(lhs)?;
  let rhs = Symbolic::parse(rhs);
 
+ // no protected flags are needed, as this is based on expression nodes which already ordered the operations
  match op {
  Op2::Addition => Ok(Symbolic::Add(Box::new(lhs), Box::new(rhs?))),
  Op2::Multiplication => Ok(Symbolic::Mul(Box::new(lhs), Box::new(rhs?))),
@@ -472,43 +473,25 @@ impl Ty {
 
  // [type; size]
  // ^
- let siz_first = tokens.bump_err(ctx, ErrorKind::InvalidToken)?;
-
- // [type; size]
- // ^
- let siz_second = tokens.bump_err(ctx, ErrorKind::InvalidToken)?;
-
- // return Array(ty, siz) if size is a number and right_paren is ]
- match (&siz_first.kind, &siz_second.kind) {
- (TokenKind::BigUInt(b), TokenKind::RightBracket) => {
- let siz: u32 = b
- .try_into()
- .map_err(|_e| ctx.error(ErrorKind::InvalidArraySize, siz_first.span))?;
- let span = span.merge_with(siz_second.span);
-
+ let expr = Expr::parse(ctx, tokens)?;
+ match expr.kind {
+ ExprKind::BigUInt(n) => {
+ tokens.bump_expected(ctx, TokenKind::RightBracket)?;
  Ok(Ty {
- kind: TyKind::Array(Box::new(ty.kind), siz),
+ kind: TyKind::Array(Box::new(ty.kind), n.try_into().unwrap()),
  span,
  })
  }
- // [Field; nn]
- // [Field; NN]
- // ^^^
- (TokenKind::Identifier(name), TokenKind::RightBracket) => {
- let siz = Ident::new(name.to_string(), siz_first.span);
- let span = span.merge_with(siz_second.span);
- let sym = if is_generic_parameter(name) {
- Symbolic::Generic(siz)
- } else {
- Symbolic::Constant(siz)
- };
-
+ _ => {
+ tokens.bump_expected(ctx, TokenKind::RightBracket)?;
  Ok(Ty {
- kind: TyKind::GenericSizedArray(Box::new(ty.kind), sym),
+ kind: TyKind::GenericSizedArray(
+ Box::new(ty.kind),
+ Symbolic::parse(&expr)?,
+ ),
  span,
  })
  }
- _ => Err(ctx.error(ErrorKind::InvalidSymbolicSize, siz_first.span)),
  }
  }