Use more Rust-like syntax for variadic fns

Author: nathanwhit

chalk-parse/src/ast.rs

@@ -466,3 +466,51 @@ pub enum ClosureKind {
     FnMut,
     FnOnce,
 }
+
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub enum FnArg {
+    NonVariadic(Ty),
+    Variadic,
+}
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub enum FnArgs {
+    NonVariadic(Vec<Ty>),
+    Variadic(Vec<Ty>),
+}
+
+impl FnArgs {
+    pub fn is_variadic(&self) -> bool {
+        match self {
+            Self::Variadic(..) => true,
+            _ => false,
+        }
+    }
+
+    pub fn to_tys(self) -> Vec<Ty> {
+        match self {
+            Self::NonVariadic(tys) | Self::Variadic(tys) => tys,
+        }
+    }
+
+    pub fn from_vec(mut args: Vec<FnArg>) -> Result<Self, &'static str> {
+        let mut tys = Vec::with_capacity(args.len());
+        let last = args.pop();
+        for arg in args {
+            match arg {
+                FnArg::NonVariadic(ty) => tys.push(ty),
+                FnArg::Variadic => {
+                    return Err("a variadic argument must be the last parameter in a function");
+                }
+            }
+        }
+
+        Ok(match last {
+            Some(FnArg::NonVariadic(ty)) => {
+                tys.push(ty);
+                FnArgs::NonVariadic(tys)
+            }
+            Some(FnArg::Variadic) => FnArgs::Variadic(tys),
+            None => FnArgs::NonVariadic(tys),
+        })
+    }
+}

chalk-parse/src/parser.lalrpop

@@ -140,28 +140,31 @@ FnReturn: Ty = {
 };
 
 FnDefn: FnDefn = {
-    <var:Variadic?> <safety:Safety?> <abi:FnAbi?> "fn" <n:Id> <p:Angle<VariableKind>>"(" <args:FnArgs> ")"
+    <safety:Safety?> <abi:FnAbi?> "fn" <n:Id> <p:Angle<VariableKind>>"(" <args:FnArgs> ")"
         <ret_ty:FnReturn?> <w:QuantifiedWhereClauses> ";" => FnDefn
     {
         name: n,
         variable_kinds: p,
         where_clauses: w,
-        argument_types: args,
+        variadic: args.is_variadic(),
+        argument_types: args.to_tys(),
         return_type: ret_ty.unwrap_or_else(|| Ty::Tuple { types: Vec::new() }),
         abi: abi.unwrap_or_default(),
         safety: safety.unwrap_or_default(),
-        variadic: var.unwrap_or(false),
     }
 };
 
 FnAbi: FnAbi = "extern" "\"" <id:Id> "\"" => FnAbi(id.str);
 
-FnArg: Ty = {
-    Id ":" <arg_ty: Ty> => arg_ty
+FnArg: FnArg = {
+    Id ":" "..." => FnArg::Variadic,
+    Id ":" <arg_ty: Ty> => FnArg::NonVariadic(arg_ty),
 };
 
-FnArgs: Vec<Ty> = {
-    <Comma<FnArg>>
+FnArgs: FnArgs = {
+    <Comma<FnArg>> =>? FnArgs::from_vec(<>).map_err(|e| lalrpop_util::ParseError::User {
+        error: e,
+    })
 };
 
 ClosureDefn: ClosureDefn = {
@@ -183,7 +186,7 @@ ClosureSelf: ClosureKind = {
 }
 
 ClosureArgs: Vec<Ty> = {
-    "," <args:FnArgs> => args,
+    "," <args:FnArgs> => args.to_tys(),
 }
 
 TraitDefn: TraitDefn = {
@@ -317,20 +320,28 @@ Safety: Safety = {
     "unsafe" => Safety::Unsafe,
 };
 
-Variadic: bool = {
-    "variadic" => true,
-}
+FnArgTy: FnArg = {
+    "..." => FnArg::Variadic,
+    <arg_ty: Ty> => FnArg::NonVariadic(arg_ty),
+};
+
+FnArgTys: FnArgs = {
+    <Comma<FnArgTy>> =>? FnArgs::from_vec(<>).map_err(|e| lalrpop_util::ParseError::User {
+        error: e,
+    })
+};
 
 TyWithoutId: Ty = {
-    <l:ForLifetimes?> <var:Variadic?> <safety:Safety?> <abi:FnAbi?> "fn" "(" <types:Comma<Ty>> ")" <ret_ty:FnReturn?> => Ty::ForAll {
+    <l:ForLifetimes?> <safety:Safety?> <abi:FnAbi?> "fn" "(" <types:FnArgTys> ")" <ret_ty:FnReturn?> => Ty::ForAll {
         lifetime_names: l.unwrap_or_default(),
+        variadic: types.is_variadic(),
         types: types
+                   .to_tys()
                    .into_iter()
                    .chain(std::iter::once(ret_ty.unwrap_or_else(|| Ty::Tuple { types: Vec::new() })))
                    .map(Box::new).collect(),
         safety: safety.unwrap_or_default(),
         abi: abi.unwrap_or_default(),
-        variadic: var.unwrap_or(false)
     },
     <ScalarType> => Ty::Scalar { ty: <> },
     "str" => Ty::Str,

tests/lowering/mod.rs

@@ -731,15 +731,15 @@ fn extern_functions() {
 fn unsafe_variadic_functions() {
     lowering_success! {
         program {
-            unsafe fn foo();
-            variadic unsafe fn bar();
+            unsafe fn foo(_: u8);
+            unsafe fn bar(_: u8, _: ...);
             unsafe extern "C" fn baz();
         }
     }
     lowering_success! {
         program {
-            variadic fn foo();
-            variadic extern "C" fn bar();
+            fn foo(_: u8, _: ...);
+            extern "C" fn bar(_: u8, _: ...);
         }
     }
 }

tests/test/unify.rs

@@ -109,14 +109,14 @@ fn forall_equality() {
 
         goal {
             // Variadic function pointers should not be equal to non-variadic fn pointers.
-            variadic fn(): Eq<fn()>
+            fn(u8, ...): Eq<fn(u8)>
         } yields {
             "No possible solution"
         }
 
         goal {
             // Variadic function pointers should be equal to variadic fn pointers.
-            variadic fn(): Eq<variadic fn()>
+            fn(u8, ...): Eq<fn(u8, ...)>
         } yields {
             "Unique; substitution [], lifetime constraints []"
         }