implement mono / lowering for tuples

crates/compiler/parse/src/ast.rs

@@ -1,6 +1,7 @@
 use std::fmt::Debug;
 
 use crate::header::{AppHeader, HostedHeader, InterfaceHeader, PackageHeader, PlatformHeader};
+use crate::ident::Accessor;
 use crate::parser::ESingleQuote;
 use bumpalo::collections::{String, Vec};
 use bumpalo::Bump;
@@ -243,13 +244,12 @@ pub enum Expr<'a> {
 
     /// Look up exactly one field on a record, e.g. `x.foo`.
     RecordAccess(&'a Expr<'a>, &'a str),
-    /// e.g. `.foo`
-    RecordAccessorFunction(&'a str),
+
+    /// e.g. `.foo` or `.0`
+    AccessorFunction(Accessor<'a>),
 
     /// Look up exactly one field on a tuple, e.g. `(x, y).1`.
     TupleAccess(&'a Expr<'a>, &'a str),
-    /// e.g. `.1`
-    TupleAccessorFunction(&'a str),
 
     // Collection Literals
     List(Collection<'a, &'a Loc<Expr<'a>>>),
@@ -612,7 +612,7 @@ pub enum TypeAnnotation<'a> {
     },
 
     Tuple {
-        fields: Collection<'a, Loc<TypeAnnotation<'a>>>,
+        elems: Collection<'a, Loc<TypeAnnotation<'a>>>,
         /// The row type variable in an open tuple, e.g. the `r` in `( Str, Str )r`.
         /// This is None if it's a closed tuple annotation like `( Str, Str )`.
         ext: Option<&'a Loc<TypeAnnotation<'a>>>,
@@ -1459,8 +1459,7 @@ impl<'a> Malformed for Expr<'a> {
             Float(_) |
             Num(_) |
             NonBase10Int { .. } |
-            TupleAccessorFunction(_) |
-            RecordAccessorFunction(_) |
+            AccessorFunction(_) |
             Var { .. } |
             Underscore(_) |
             Tag(_) |
@@ -1729,7 +1728,7 @@ impl<'a> Malformed for TypeAnnotation<'a> {
                 fields.iter().any(|field| field.is_malformed())
                     || ext.map(|ext| ext.is_malformed()).unwrap_or_default()
             }
-            TypeAnnotation::Tuple { fields, ext } => {
+            TypeAnnotation::Tuple { elems: fields, ext } => {
                 fields.iter().any(|field| field.is_malformed())
                     || ext.map(|ext| ext.is_malformed()).unwrap_or_default()
             }

crates/compiler/parse/src/expr.rs

@@ -1872,9 +1872,8 @@ fn expr_to_pattern_help<'a>(arena: &'a Bump, expr: &Expr<'a>) -> Result<Pattern<
             is_negative: *is_negative,
         }),
         // These would not have parsed as patterns
-        Expr::RecordAccessorFunction(_)
+        Expr::AccessorFunction(_)
         | Expr::RecordAccess(_, _)
-        | Expr::TupleAccessorFunction(_)
         | Expr::TupleAccess(_, _)
         | Expr::List { .. }
         | Expr::Closure(_, _)
@@ -2459,8 +2458,7 @@ fn ident_to_expr<'a>(arena: &'a Bump, src: Ident<'a>) -> Expr<'a> {
 
             answer
         }
-        Ident::RecordAccessorFunction(string) => Expr::RecordAccessorFunction(string),
-        Ident::TupleAccessorFunction(string) => Expr::TupleAccessorFunction(string),
+        Ident::AccessorFunction(string) => Expr::AccessorFunction(string),
         Ident::Malformed(string, problem) => Expr::MalformedIdent(string, problem),
     }
 }

crates/compiler/parse/src/ident.rs

@@ -43,10 +43,8 @@ pub enum Ident<'a> {
         module_name: &'a str,
         parts: &'a [Accessor<'a>],
     },
-    /// .foo { foo: 42 }
-    RecordAccessorFunction(&'a str),
-    /// .1 (1, 2, 3)
-    TupleAccessorFunction(&'a str),
+    /// `.foo { foo: 42 }` or `.1 (1, 2, 3)`
+    AccessorFunction(Accessor<'a>),
     /// .Foo or foo. or something like foo.Bar
     Malformed(&'a str, BadIdent),
 }
@@ -71,8 +69,7 @@ impl<'a> Ident<'a> {
 
                 len - 1
             }
-            RecordAccessorFunction(string) => string.len(),
-            TupleAccessorFunction(string) => string.len(),
+            AccessorFunction(string) => string.len(),
             Malformed(string, _) => string.len(),
         }
     }
@@ -339,7 +336,7 @@ where
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub enum Accessor<'a> {
     RecordField(&'a str),
     TupleIndex(&'a str),
@@ -436,13 +433,9 @@ fn chomp_identifier_chain<'a>(
     match char::from_utf8_slice_start(&buffer[chomped..]) {
         Ok((ch, width)) => match ch {
             '.' => match chomp_accessor(&buffer[1..], pos) {
-                Ok(Accessor::RecordField(accessor)) => {
+                Ok(accessor) => {
                     let bytes_parsed = 1 + accessor.len();
-                    return Ok((bytes_parsed as u32, Ident::RecordAccessorFunction(accessor)));
-                }
-                Ok(Accessor::TupleIndex(accessor)) => {
-                    let bytes_parsed = 1 + accessor.len();
-                    return Ok((bytes_parsed as u32, Ident::TupleAccessorFunction(accessor)));
+                    return Ok((bytes_parsed as u32, Ident::AccessorFunction(accessor)));
                 }
                 Err(fail) => return Err((1, fail)),
             },

crates/compiler/parse/src/parser.rs

@@ -536,8 +536,7 @@ pub enum EPattern<'a> {
     IndentEnd(Position),
     AsIndentStart(Position),
 
-    RecordAccessorFunction(Position),
-    TupleAccessorFunction(Position),
+    AccessorFunction(Position),
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]

crates/compiler/parse/src/pattern.rs

@@ -417,13 +417,9 @@ fn loc_ident_pattern_help<'a>(
                     state,
                 ))
             }
-            Ident::RecordAccessorFunction(_string) => Err((
+            Ident::AccessorFunction(_string) => Err((
                 MadeProgress,
-                EPattern::RecordAccessorFunction(loc_ident.region.start()),
-            )),
-            Ident::TupleAccessorFunction(_string) => Err((
-                MadeProgress,
-                EPattern::TupleAccessorFunction(loc_ident.region.start()),
+                EPattern::AccessorFunction(loc_ident.region.start()),
             )),
             Ident::Malformed(malformed, problem) => {
                 debug_assert!(!malformed.is_empty());

crates/compiler/parse/src/type_annotation.rs

@@ -250,7 +250,7 @@ fn loc_type_in_parens<'a>(
             if fields.len() > 1 || ext.is_some() {
                 Ok((
                     MadeProgress,
-                    Loc::at(region, TypeAnnotation::Tuple { fields, ext }),
+                    Loc::at(region, TypeAnnotation::Tuple { elems: fields, ext }),
                     state,
                 ))
             } else if fields.len() == 1 {