Introduce Generic Arrays (#472)

* Introduce generic Array type

* Simplify handling of Failable types

src/modules/function/invocation_utils.rs

@@ -40,7 +40,7 @@ fn run_function_with_args(meta: &mut ParserMetadata, mut fun: FunctionDecl, args
  // Check if the function argument types match
  if fun.is_args_typed {
  for (index, (arg_name, arg_type, given_type)) in izip!(fun.arg_names.iter(), fun.arg_types.iter(), args.iter()).enumerate() {
- if arg_type != given_type {
+ if !given_type.is_allowed_in(arg_type) {
  let fun_name = &fun.name;
  let ordinal = ordinal_number(index);
  return error!(meta, tok, format!("{ordinal} argument '{arg_name}' of function '{fun_name}' expects type '{arg_type}', but '{given_type}' was given"))
@@ -116,4 +116,4 @@ fn handle_similar_function(meta: &ParserMetadata, name: &str) -> Option<String>
  let vars = Vec::from_iter(meta.get_fun_names());
  find_best_similarity(name, &vars)
  .and_then(|(match_name, score)| (score >= 0.75).then(|| format!("Did you mean '{match_name}'?")))
-}
+}

src/modules/function/ret.rs

@@ -37,16 +37,9 @@ impl SyntaxModule<ParserMetadata> for Return {
  syntax(meta, &mut self.expr)?;
  let ret_type = meta.context.fun_ret_type.as_ref();
  let expr_type = &self.expr.get_type();
- // Unpacking Failable types
- let (ret_type, expr_type) = match (ret_type, expr_type) {
- types @ (Some(Type::Failable(_)), Type::Failable(_)) => types,
- (Some(Type::Failable(ret_type)), expr_type) => (Some(ret_type.as_ref()), expr_type),
- (Some(ret_type), Type::Failable(expr_type)) => (Some(ret_type), expr_type.as_ref()),
- types => types
- };
  match ret_type {
  Some(ret_type) => {
- if ret_type != expr_type {
+ if !expr_type.is_allowed_in(ret_type) {
  return error!(meta, tok => {
  message: "Return type does not match function return type",
  comment: format!("Given type: {}, expected type: {}", expr_type, ret_type)

src/modules/types.rs

@@ -14,14 +14,36 @@ pub enum Type {
  Generic
 }
 
+impl Type {
+ pub fn is_subset_of(&self, other: &Type) -> bool {
+ match (self, other) {
+ (Type::Array(current), Type::Array(other)) => {
+ **current != Type::Generic && **other == Type::Generic
+ }
+ (current, Type::Failable(other)) if !matches!(current, Type::Failable(_)) => {
+ current.is_allowed_in(other)
+ },
+ _ => false
+ }
+ }
+
+ pub fn is_allowed_in(&self, other: &Type) -> bool {
+ self == other || self.is_subset_of(other)
+ }
+}
+
 impl Display for Type {
  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  match self {
  Type::Text => write!(f, "Text"),
  Type::Bool => write!(f, "Bool"),
  Type::Num => write!(f, "Num"),
  Type::Null => write!(f, "Null"),
- Type::Array(t) => write!(f, "[{}]", t),
+ Type::Array(t) => if **t == Type::Generic {
+ write!(f, "[]")
+ } else {
+ write!(f, "[{}]", t)
+ },
  Type::Failable(t) => write!(f, "{}?", t),
  Type::Generic => write!(f, "Generic")
  }
@@ -64,15 +86,19 @@ pub fn try_parse_type(meta: &mut ParserMetadata) -> Result<Type, Failure> {
  "[" => {
  let index = meta.get_index();
  meta.increment_index();
- match try_parse_type(meta) {
- Ok(Type::Array(_)) => error!(meta, tok, "Arrays cannot be nested due to the Bash limitations"),
- Ok(result_type) => {
- token(meta, "]")?;
- Ok(Type::Array(Box::new(result_type)))
- },
- Err(_) => {
- meta.set_index(index);
- Err(Failure::Quiet(PositionInfo::at_eof(meta)))
+ if token(meta, "]").is_ok() {
+ Ok(Type::Array(Box::new(Type::Generic)))
+ } else {
+ match try_parse_type(meta) {
+ Ok(Type::Array(_)) => error!(meta, tok, "Arrays cannot be nested due to the Bash limitations"),
+ Ok(result_type) => {
+ token(meta, "]")?;
+ Ok(Type::Array(Box::new(result_type)))
+ },
+ Err(_) => {
+ meta.set_index(index);
+ Err(Failure::Quiet(PositionInfo::at_eof(meta)))
+ }
  }
  }
  },
@@ -107,3 +133,61 @@ pub fn try_parse_type(meta: &mut ParserMetadata) -> Result<Type, Failure> {
 
  res
 }
+
+#[cfg(test)]
+mod tests {
+ use super::Type;
+
+ #[test]
+ fn concrete_array_is_a_subset_of_generic_array() {
+ let a = Type::Array(Box::new(Type::Text));
+ let b = Type::Array(Box::new(Type::Generic));
+
+ assert!(a.is_subset_of(&b));
+ }
+
+ #[test]
+ fn generic_array_is_not_a_subset_of_concrete_array() {
+ let a = Type::Array(Box::new(Type::Text));
+ let b = Type::Array(Box::new(Type::Generic));
+
+ assert!(!b.is_subset_of(&a));
+ }
+
+ #[test]
+ fn concrete_array_is_not_a_subset_of_itself() {
+ let a = Type::Array(Box::new(Type::Text));
+
+ assert!(!a.is_subset_of(&a));
+ }
+
+ #[test]
+ fn generic_array_is_not_a_subset_of_itself() {
+ let a = Type::Array(Box::new(Type::Generic));
+
+ assert!(!a.is_subset_of(&a));
+ }
+
+ #[test]
+ fn non_failable_is_a_subset_of_failable() {
+ let a = Type::Text;
+ let b = Type::Failable(Box::new(Type::Text));
+
+ assert!(a.is_subset_of(&b));
+ }
+
+ #[test]
+ fn failable_is_not_a_subset_of_non_failable() {
+ let a = Type::Text;
+ let b = Type::Failable(Box::new(Type::Text));
+
+ assert!(!b.is_subset_of(&a));
+ }
+
+ #[test]
+ fn failable_is_not_a_subset_of_itself() {
+ let a = Type::Failable(Box::new(Type::Text));
+
+ assert!(!a.is_subset_of(&a));
+ }
+}

src/tests/validity/generic_array_in_argument.ab

@@ -0,0 +1,10 @@
+// Output
+// 1 2 3
+// Hello Hi
+
+fun test(arr: []): Null {
+ echo arr
+}
+
+test([1, 2, 3])
+test(["Hello", "Hi"])

src/tests/validity/generic_array_in_argument_and_return.ab

@@ -0,0 +1,10 @@
+// Output
+// 1 2 3
+// Hello Hi
+
+fun test(arr: []): [] {
+ return arr
+}
+
+echo test([1, 2, 3])
+echo test(["Hello", "Hi"])

src/tests/validity/generic_array_in_failable_return.ab

@@ -0,0 +1,9 @@
+// Output
+// 1 2 3
+
+fun test(arr: [Num]): []? {
+ if false { fail 1 }
+ return arr
+}
+
+echo unsafe test([1, 2, 3])

src/tests/validity/generic_array_in_return.ab

@@ -0,0 +1,8 @@
+// Output
+// 1 2 3
+
+fun test(arr: [Num]): [] {
+ return arr
+}
+
+echo test([1, 2, 3])

src/tests/validity/generic_array_type_check.ab

@@ -0,0 +1,26 @@
+// Output
+// Generic
+// Number
+// Text
+
+fun return_generic(): [] {
+ return ["the great unknown"]
+}
+
+fun test(arr: []) {
+ if arr is [] {
+ echo "Generic"
+ }
+
+ if arr is [Num] {
+ echo "Number"
+ }
+
+ if arr is [Text] {
+ echo "Text"
+ }
+}
+
+test(return_generic())
+test([42, 69])
+test(["Hello", "Hi"])