feat(rust-sema): propagate Array and Index into THIR

lccc-project · Sep 17, 2023 · ddaed59 · ddaed59
1 parent 0bf540e
commit ddaed59
Show file tree

Hide file tree

Showing 2 changed files with 63 additions and 5 deletions.
diff --git a/rust/src/sema/mir.rs b/rust/src/sema/mir.rs
@@ -522,7 +522,9 @@ impl<'a> MirConverter<'a> {
             | ThirExprInner::Read(_)
             | ThirExprInner::Unreachable
             | ThirExprInner::Ctor(_)
-            | ThirExprInner::BinaryExpr(_, _, _) => todo!(),
+            | ThirExprInner::BinaryExpr(_, _, _)
+            | ThirExprInner::Array(_)
+            | ThirExprInner::Index(_, _) => todo!(),
         }
     }
 
@@ -665,7 +667,8 @@ impl<'a> MirConverter<'a> {
             | ThirExprInner::Cast(_, _)
             | ThirExprInner::Tuple(_)
             | ThirExprInner::Ctor(_)
-            | ThirExprInner::BinaryExpr(_, _, _) => unreachable!("cannot access"),
+            | ThirExprInner::BinaryExpr(_, _, _)
+            | ThirExprInner::Array(_) | ThirExprInner::Index(_, _) => unreachable!("cannot access"),
         }
     }
 
@@ -805,6 +808,8 @@ impl<'a> MirConverter<'a> {
                     Box::new(self.lower_expr(*rhs)?),
                 ),
             }),
+            super::tyck::ThirExprInner::Array(_) => todo!("array"),
+            super::tyck::ThirExprInner::Index(_, _) => todo!("index"),
             super::tyck::ThirExprInner::MemberAccess(_, _) => {
                 panic!("only top level rvalues get lowered by `lower_expr`")
             }
@@ -957,7 +962,9 @@ impl<'a> MirConverter<'a> {
             | ThirExprInner::Cast(_, _)
             | ThirExprInner::Tuple(_)
             | ThirExprInner::Ctor(_)
-            | ThirExprInner::BinaryExpr(_, _, _) => unreachable!(),
+            | ThirExprInner::BinaryExpr(_, _, _)
+            | ThirExprInner::Array(_)
+            | ThirExprInner::Index(_, _) => unreachable!(),
         }
 
         Ok(())

diff --git a/rust/src/sema/tyck.rs b/rust/src/sema/tyck.rs
@@ -87,6 +87,8 @@ pub enum ThirExprInner {
         Box<Spanned<ThirExpr>>,
         Box<Spanned<ThirExpr>>,
     ),
+    Array(Vec<Spanned<ThirExpr>>),
+    Index(Box<Spanned<ThirExpr>>, Box<Spanned<ThirExpr>>),
 }
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
@@ -174,6 +176,18 @@ impl core::fmt::Display for ThirExprInner {
             ThirExprInner::BinaryExpr(op, lhs, rhs) => {
                 write!(f, "({} {} {})", lhs.body, op.body, rhs.body)
             }
+            ThirExprInner::Array(elements) => {
+                write!(f, "[")?;
+                let mut sep = "";
+                for element in elements {
+                    write!(f, "{}{}", sep, element.body)?;
+                    sep = ", ";
+                }
+                write!(f, "]")
+            }
+            ThirExprInner::Index(base, index) => {
+                write!(f, "{}[{}]", base.body, index.body)
+            }
         }
     }
 }
@@ -670,8 +684,39 @@ impl<'a> ThirConverter<'a> {
                     inner: ThirExprInner::BinaryExpr(*op, Box::new(lhs), Box::new(rhs)),
                 })
             }
-            hir::HirExpr::Array(_) => todo!("array"),
-            hir::HirExpr::Index(_, _) => todo!("index"),
+            hir::HirExpr::Array(elements) => {
+                let elements = elements
+                    .iter()
+                    .map(|x| self.convert_rvalue(x))
+                    .collect::<Result<Vec<_>>>()?;
+                if elements.len() == 0 {
+                    Ok(ThirExpr {
+                        ty: Type::Inferable(InferId(self.next_infer.fetch_increment())),
+                        cat: ValueCategory::Rvalue,
+                        inner: ThirExprInner::Array(elements),
+                    })
+                } else {
+                    Ok(ThirExpr {
+                        ty: elements[0].ty.clone(),
+                        cat: ValueCategory::Rvalue,
+                        inner: ThirExprInner::Array(elements),
+                    })
+                }
+            }
+            hir::HirExpr::Index(base, index) => {
+                let base = self.convert_rvalue(base)?;
+                Ok(ThirExpr {
+                    ty: match &base.ty {
+                        Type::Array(ty, _) => ty.body.clone(),
+                        _ => Type::Inferable(InferId(self.next_infer.fetch_increment())),
+                    },
+                    cat: ValueCategory::Rvalue,
+                    inner: ThirExprInner::Index(
+                        Box::new(base),
+                        Box::new(self.convert_rvalue(index)?),
+                    ),
+                })
+            }
         })
     }
 
@@ -1042,6 +1087,12 @@ impl<'a> Inferer<'a> {
                 status &= self.unify_single_expr(lhs)?;
                 status &= self.unify_single_expr(rhs)?;
             }
+            ThirExprInner::Array(_elements) => {
+                todo!("array")
+            }
+            ThirExprInner::Index(base, index) => {
+                todo!("index")
+            }
         }
 
         Ok(status)