Remove private tags from idents

compiler/parse/src/ast.rs

@@ -579,7 +579,6 @@ impl<'a> Pattern<'a> {
     pub fn from_ident(arena: &'a Bump, ident: Ident<'a>) -> Pattern<'a> {
         match ident {
             Ident::GlobalTag(string) => Pattern::GlobalTag(string),
-            Ident::PrivateTag(string) => Pattern::PrivateTag(string),
             Ident::OpaqueRef(string) => Pattern::OpaqueRef(string),
             Ident::Access { module_name, parts } => {
                 if parts.len() == 1 {

compiler/parse/src/expr.rs

@@ -2438,7 +2438,6 @@ where
 fn ident_to_expr<'a>(arena: &'a Bump, src: Ident<'a>) -> Expr<'a> {
     match src {
         Ident::GlobalTag(string) => Expr::GlobalTag(string),
-        Ident::PrivateTag(string) => Expr::PrivateTag(string),
         Ident::OpaqueRef(string) => Expr::OpaqueRef(string),
         Ident::Access { module_name, parts } => {
             let mut iter = parts.iter();

compiler/parse/src/ident.rs

@@ -36,8 +36,6 @@ impl<'a> From<&'a UppercaseIdent<'a>> for &'a str {
 pub enum Ident<'a> {
     /// Foo or Bar
     GlobalTag(&'a str),
-    /// @Foo or @Bar
-    PrivateTag(&'a str),
     /// $Foo or $Bar
     // TODO(opaques): $->@ in the above comment
     OpaqueRef(&'a str),
@@ -57,7 +55,7 @@ impl<'a> Ident<'a> {
         use self::Ident::*;
 
         match self {
-            GlobalTag(string) | PrivateTag(string) | OpaqueRef(string) => string.len(),
+            GlobalTag(string) | OpaqueRef(string) => string.len(),
             Access { module_name, parts } => {
                 let mut len = if module_name.is_empty() {
                     0
@@ -101,24 +99,7 @@ pub fn lowercase_ident<'a>() -> impl Parser<'a, &'a str, ()> {
 }
 
 pub fn tag_name<'a>() -> impl Parser<'a, &'a str, ()> {
-    move |arena, state: State<'a>| {
-        if state.bytes().starts_with(b"@") {
-            match chomp_private_tag_or_opaque(
-                /* private tag */ true,
-                state.bytes(),
-                state.pos(),
-            ) {
-                Err(BadIdent::Start(_)) => Err((NoProgress, (), state)),
-                Err(_) => Err((MadeProgress, (), state)),
-                Ok(ident) => {
-                    let width = ident.len();
-                    Ok((MadeProgress, ident, state.advance(width)))
-                }
-            }
-        } else {
-            uppercase_ident().parse(arena, state)
-        }
-    }
+    move |arena, state: State<'a>| uppercase_ident().parse(arena, state)
 }
 
 /// This could be:
@@ -311,21 +292,13 @@ fn chomp_accessor(buffer: &[u8], pos: Position) -> Result<&str, BadIdent> {
     }
 }
 
-/// a `@Token` private tag
-fn chomp_private_tag_or_opaque(
-    private_tag: bool, // If false, opaque
-    buffer: &[u8],
-    pos: Position,
-) -> Result<&str, BadIdent> {
-    // assumes the leading `@` has NOT been chomped already
-    debug_assert_eq!(buffer.get(0), Some(if private_tag { &b'@' } else { &b'$' }));
+/// a `$Token` opaque
+fn chomp_opaque_ref(buffer: &[u8], pos: Position) -> Result<&str, BadIdent> {
+    // assumes the leading `$` has NOT been chomped already
+    debug_assert_eq!(buffer.get(0), Some(&b'$'));
     use encode_unicode::CharExt;
 
-    let bad_ident = if private_tag {
-        BadIdent::BadPrivateTag
-    } else {
-        BadIdent::BadOpaqueRef
-    };
+    let bad_ident = BadIdent::BadOpaqueRef;
 
     match chomp_uppercase_part(&buffer[1..]) {
         Ok(name) => {
@@ -362,15 +335,11 @@ fn chomp_identifier_chain<'a>(
                 }
                 Err(fail) => return Err((1, fail)),
             },
-            c @ ('@' | '$') => match chomp_private_tag_or_opaque(c == '@', buffer, pos) {
+            '$' => match chomp_opaque_ref(buffer, pos) {
                 Ok(tagname) => {
                     let bytes_parsed = tagname.len();
 
-                    let ident = if c == '@' {
-                        Ident::PrivateTag
-                    } else {
-                        Ident::OpaqueRef
-                    };
+                    let ident = Ident::OpaqueRef;
 
                     return Ok((bytes_parsed as u32, ident(tagname)));
                 }

compiler/parse/src/pattern.rs

@@ -240,14 +240,10 @@ fn loc_ident_pattern_help<'a>(
                     Ok((MadeProgress, loc_tag, state))
                 }
             }
-            Ident::PrivateTag(name) | Ident::OpaqueRef(name) => {
+            Ident::OpaqueRef(name) => {
                 let loc_pat = Loc {
                     region: loc_ident.region,
-                    value: if matches!(loc_ident.value, Ident::PrivateTag(..)) {
-                        Pattern::PrivateTag(name)
-                    } else {
-                        Pattern::OpaqueRef(name)
-                    },
+                    value: Pattern::OpaqueRef(name),
                 };
 
                 // Make sure `@Foo Bar 1` is parsed as `@Foo (Bar) 1`, and not `@Foo (Bar 1)`