typeck: support units in let patterns

core-lang · Sep 10, 2020 · 706196c · 706196c
1 parent 7af00c0
commit 706196c
Show file tree

Hide file tree

Showing 4 changed files with 59 additions and 12 deletions.
diff --git a/dora/src/error/msg.rs b/dora/src/error/msg.rs
@@ -95,8 +95,9 @@ pub enum SemError {
     ExpectedIdentifier(String),
     ExpectedStringable(String),
     ExpectedSomeIdentifier,
-    ExpectedTuple(String),
-    ExpectedTupleWithLength(String, usize, usize),
+    LetPatternExpectedTuple(String),
+    LetPatternShouldBeUnit,
+    LetPatternExpectedTupleWithLength(String, usize, usize),
     MisplacedElse,
     IoError,
     ExpectedClassElement(String),
@@ -354,11 +355,16 @@ impl SemError {
                 format!("identifier expected but got {}.", tok)
             }
             SemError::ExpectedSomeIdentifier => "identifier expected".into(),
-            SemError::ExpectedTuple(ref ty) => format!("tuple expected but got type {}.", ty),
-            SemError::ExpectedTupleWithLength(ref ty, ty_length, pattern_length) => format!(
-                "tuple {} has {} elements but pattern has {}.",
-                ty, ty_length, pattern_length
-            ),
+            SemError::LetPatternExpectedTuple(ref ty) => {
+                format!("tuple expected but got type {}.", ty)
+            }
+            SemError::LetPatternShouldBeUnit => format!("let pattern should be unit."),
+            SemError::LetPatternExpectedTupleWithLength(ref ty, ty_length, pattern_length) => {
+                format!(
+                    "tuple {} has {} elements but pattern has {}.",
+                    ty, ty_length, pattern_length
+                )
+            }
             SemError::ExpectedTopLevelElement(ref token) => {
                 format!("expected function or class but got {}.", token)
             }

diff --git a/dora/src/ty.rs b/dora/src/ty.rs
@@ -137,6 +137,14 @@ impl BuiltinType {
         }
     }
 
+    pub fn is_tuple_or_unit(&self) -> bool {
+        match self {
+            &BuiltinType::Tuple(_) => true,
+            &BuiltinType::Unit => true,
+            _ => false,
+        }
+    }
+
     pub fn cls_id(&self, vm: &VM) -> Option<ClassId> {
         match *self {
             BuiltinType::Class(cls_id, _) => Some(cls_id),

diff --git a/dora/src/typeck/expr.rs b/dora/src/typeck/expr.rs
@@ -135,16 +135,28 @@ impl<'a, 'ast> TypeCheck<'a, 'ast> {
             }
 
             LetPattern::Tuple(ref tuple) => {
-                if !ty.is_tuple() {
+                if !ty.is_tuple_or_unit() {
                     let ty_name = ty.name(self.vm);
                     self.vm.diag.lock().report(
                         self.file,
                         tuple.pos,
-                        SemError::ExpectedTuple(ty_name),
+                        SemError::LetPatternExpectedTuple(ty_name),
                     );
                     return;
                 }
 
+                if ty.is_unit() {
+                    // () doesn't have any subparts
+                    if tuple.parts.len() != 0 {
+                        self.vm.diag.lock().report(
+                            self.file,
+                            tuple.pos,
+                            SemError::LetPatternShouldBeUnit,
+                        );
+                    }
+                    return;
+                }
+
                 let tuple_id = ty.tuple_id().expect("type should be tuple");
                 let parts = self.vm.tuples.lock().get(tuple_id).len();
 
@@ -153,7 +165,11 @@ impl<'a, 'ast> TypeCheck<'a, 'ast> {
                     self.vm.diag.lock().report(
                         self.file,
                         tuple.pos,
-                        SemError::ExpectedTupleWithLength(ty_name, parts, tuple.parts.len()),
+                        SemError::LetPatternExpectedTupleWithLength(
+                            ty_name,
+                            parts,
+                            tuple.parts.len(),
+                        ),
                     );
                     return;
                 }

diff --git a/dora/src/typeck/tests.rs b/dora/src/typeck/tests.rs
@@ -353,13 +353,30 @@ fn type_let() {
     err(
         "fun f() { let (a, b) = true; }",
         pos(1, 15),
-        SemError::ExpectedTuple("Bool".into()),
+        SemError::LetPatternExpectedTuple("Bool".into()),
+    );
+
+    ok("fun f(value: ()) { let () = value; }");
+    err(
+        "fun f() { let () = true; }",
+        pos(1, 15),
+        SemError::LetPatternExpectedTuple("Bool".into()),
+    );
+    err(
+        "fun f() { let (a, b) = (); }",
+        pos(1, 15),
+        SemError::LetPatternShouldBeUnit,
     );
 
     err(
         "fun f() { let (a, b) = (true,); }",
         pos(1, 15),
-        SemError::ExpectedTupleWithLength("(Bool)".into(), 1, 2),
+        SemError::LetPatternExpectedTupleWithLength("(Bool)".into(), 1, 2),
+    );
+    err(
+        "fun f() { let () = (true,); }",
+        pos(1, 15),
+        SemError::LetPatternExpectedTupleWithLength("(Bool)".into(), 1, 0),
     );
 
     ok("fun f(value: (Int32, (Int32, Int32))) -> Int32 { let (a, (b, c)) = value; a+b+c }");