Refactor and cleanup parsing/lowering for arrays

Author: nathanwhit

chalk-integration/src/lowering.rs

@@ -1443,18 +1443,21 @@ impl LowerTy for Ty {
     }
 }
 
-trait LowerGenericArg {
-    fn lower(&self, env: &Env) -> LowerResult<chalk_ir::GenericArg<ChalkIr>>;
+impl LowerGenericArg for Const {
+    fn lower(&self, env: &Env) -> LowerResult<chalk_ir::GenericArg<ChalkIr>> {
+        let interner = env.interner();
+        match self {
+            Const::Id(name) => env.lookup_generic_arg(name),
+            Const::WithoutId(const_without_id) => Ok(const_without_id.lower(env)?.cast(interner)),
+        }
+    }
 }
 
-impl LowerGenericArg for GenericArg {
+impl LowerGenericArg for ConstWithoutId {
     fn lower(&self, env: &Env) -> LowerResult<chalk_ir::GenericArg<ChalkIr>> {
         let interner = env.interner();
         match self {
-            GenericArg::Ty(ref t) => Ok(t.lower(env)?.cast(interner)),
-            GenericArg::Lifetime(ref l) => Ok(l.lower(env)?.cast(interner)),
-            GenericArg::Id(name) => env.lookup_generic_arg(&name),
-            GenericArg::ConstValue(value) => Ok(chalk_ir::ConstData {
+            ConstWithoutId::ConstValue(value) => Ok(chalk_ir::ConstData {
                 ty: get_type_of_u32(),
                 value: chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {
                     interned: value.clone(),
@@ -1466,6 +1469,22 @@ impl LowerGenericArg for GenericArg {
     }
 }
 
+trait LowerGenericArg {
+    fn lower(&self, env: &Env) -> LowerResult<chalk_ir::GenericArg<ChalkIr>>;
+}
+
+impl LowerGenericArg for GenericArg {
+    fn lower(&self, env: &Env) -> LowerResult<chalk_ir::GenericArg<ChalkIr>> {
+        let interner = env.interner();
+        match self {
+            GenericArg::Ty(ref t) => Ok(t.lower(env)?.cast(interner)),
+            GenericArg::Lifetime(ref l) => Ok(l.lower(env)?.cast(interner)),
+            GenericArg::Id(name) => env.lookup_generic_arg(&name),
+            GenericArg::ConstWithoutId(c) => Ok(c.lower(env)?.cast(interner)),
+        }
+    }
+}
+
 trait LowerLifetime {
     fn lower(&self, env: &Env) -> LowerResult<chalk_ir::Lifetime<ChalkIr>>;
 }

chalk-parse/src/ast.rs

@@ -109,9 +109,20 @@ pub enum GenericArg {
     Ty(Ty),
     Lifetime(Lifetime),
     Id(Identifier),
+    ConstWithoutId(ConstWithoutId),
+}
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum ConstWithoutId {
     ConstValue(u32),
 }
 
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub enum Const {
+    Id(Identifier),
+    WithoutId(ConstWithoutId),
+}
+
 #[derive(Clone, PartialEq, Eq, Debug)]
 /// An inline bound, e.g. `: Foo<K>` in `impl<K, T: Foo<K>> SomeType<T>`.
 pub enum InlineBound {
@@ -214,7 +225,7 @@ pub enum Ty {
     },
     Array {
         ty: Box<Ty>,
-        len: Box<GenericArg>,
+        len: Const,
     },
     Raw {
         mutability: Mutability,

chalk-parse/src/parser.lalrpop

@@ -238,7 +238,7 @@ TyWithoutId: Ty = {
     "&" <l: Lifetime> "mut" <t:Ty> => Ty::Ref{ mutability: Mutability::Mut, lifetime: l, ty: Box::new(t) },
     "&" <l: Lifetime> <t:Ty> => Ty::Ref{ mutability: Mutability::Not, lifetime: l, ty: Box::new(t) },
     "[" <t:Ty> "]" => Ty::Slice { ty: Box::new(t) }, 
-    "[" <t:Ty> ";" <len:GenericArg> "]" => Ty::Array { ty: Box::new(t), len: Box::new(len) },
+    "[" <t:Ty> ";" <len:Const> "]" => Ty::Array { ty: Box::new(t), len },
 };
 
 ScalarType: ScalarType = {
@@ -280,11 +280,20 @@ Lifetime: Lifetime = {
     <n:LifetimeId> => Lifetime::Id { name: n },
 };
 
+ConstWithoutId: ConstWithoutId = {
+    ConstValue => ConstWithoutId::ConstValue(<>),
+};
+
+Const : Const = {
+    Id => Const::Id(<>),
+    ConstWithoutId => Const::WithoutId(<>),
+};
+
 GenericArg: GenericArg = {
     TyWithoutId => GenericArg::Ty(<>),
     Lifetime => GenericArg::Lifetime(<>),
     Id => GenericArg::Id(<>),
-    ConstValue => GenericArg::ConstValue(<>),
+    ConstWithoutId => GenericArg::ConstWithoutId(<>),
 };
 
 ProjectionTy: ProjectionTy = {

tests/lowering/mod.rs

@@ -595,4 +595,16 @@ fn arrays() {
             fn bar<const N>(baz: [Baz; N]);
         }
     }
+
+    lowering_error! {
+        program {
+            struct Baz { }
+
+            fn foo<T>(baz: [Baz; u32]);
+        }
+
+        error_msg {
+            "parse error: UnrecognizedToken"
+        }
+    }
 }