diff --git a/ast/src/lang/core/expr/expr_to_expr2.rs b/ast/src/lang/core/expr/expr_to_expr2.rs index 126f885499..f19b5a7dfc 100644 --- a/ast/src/lang/core/expr/expr_to_expr2.rs +++ b/ast/src/lang/core/expr/expr_to_expr2.rs @@ -185,20 +185,6 @@ pub fn expr_to_expr2<'a>( Output::default(), ) } - PrivateTag(name) => { - // a private tag without any arguments - let ident_id = env.ident_ids.get_or_insert(&(*name).into()); - let name = Symbol::new(env.home, ident_id); - ( - Expr2::PrivateTag { - name, - variant_var: env.var_store.fresh(), - ext_var: env.var_store.fresh(), - arguments: PoolVec::empty(env.pool), - }, - Output::default(), - ) - } RecordUpdate { fields, @@ -568,17 +554,6 @@ pub fn expr_to_expr2<'a>( name, arguments: args, }, - Expr2::PrivateTag { - variant_var, - ext_var, - name, - .. - } => Expr2::PrivateTag { - variant_var, - ext_var, - name, - arguments: args, - }, _ => { // This could be something like ((if True then fn1 else fn2) arg1 arg2). let fn_expr_id = env.add(fn_expr, fn_region); diff --git a/ast/src/lang/core/pattern.rs b/ast/src/lang/core/pattern.rs index 13d91a9850..9e10ba62e3 100644 --- a/ast/src/lang/core/pattern.rs +++ b/ast/src/lang/core/pattern.rs @@ -280,17 +280,6 @@ pub fn to_pattern2<'a>( arguments: PoolVec::empty(env.pool), } } - PrivateTag(name) => { - let ident_id = env.ident_ids.get_or_insert(&(*name).into()); - - // Canonicalize the tag's name. - Pattern2::PrivateTag { - whole_var: env.var_store.fresh(), - ext_var: env.var_store.fresh(), - tag_name: Symbol::new(env.home, ident_id), - arguments: PoolVec::empty(env.pool), - } - } OpaqueRef(..) => todo_opaques!(), @@ -319,16 +308,6 @@ pub fn to_pattern2<'a>( tag_name: PoolStr::new(name, env.pool), arguments: can_patterns, }, - PrivateTag(name) => { - let ident_id = env.ident_ids.get_or_insert(&name.into()); - - Pattern2::PrivateTag { - whole_var: env.var_store.fresh(), - ext_var: env.var_store.fresh(), - tag_name: Symbol::new(env.home, ident_id), - arguments: can_patterns, - } - } _ => unreachable!("Other patterns cannot be applied"), } } diff --git a/ast/src/lang/core/types.rs b/ast/src/lang/core/types.rs index 59f727d2f7..d65d2bb059 100644 --- a/ast/src/lang/core/types.rs +++ b/ast/src/lang/core/types.rs @@ -702,21 +702,6 @@ fn can_tags<'a>( break 'inner tag_name; } - Tag::Private { name, args } => { - let ident_id = env.ident_ids.get_or_insert(&name.value.into()); - let symbol = Symbol::new(env.home, ident_id); - - let arg_types = PoolVec::with_capacity(args.len() as u32, env.pool); - - for (type_id, loc_arg) in arg_types.iter_node_ids().zip(args.iter()) { - as_type_id(env, scope, rigids, type_id, &loc_arg.value, loc_arg.region); - } - - let tag_name = TagName::Private(symbol); - tag_types.push((tag_name.clone(), arg_types)); - - break 'inner tag_name; - } Tag::SpaceBefore(nested, _) | Tag::SpaceAfter(nested, _) => { // check the nested tag instead tag = nested; diff --git a/cli/src/format.rs b/cli/src/format.rs index ea77c5f1dc..3913838f85 100644 --- a/cli/src/format.rs +++ b/cli/src/format.rs @@ -618,7 +618,6 @@ impl<'a> RemoveSpaces<'a> for Expr<'a> { Expr::Var { module_name, ident } => Expr::Var { module_name, ident }, Expr::Underscore(a) => Expr::Underscore(a), Expr::GlobalTag(a) => Expr::GlobalTag(a), - Expr::PrivateTag(a) => Expr::PrivateTag(a), Expr::OpaqueRef(a) => Expr::OpaqueRef(a), Expr::Closure(a, b) => Expr::Closure( arena.alloc(a.remove_spaces(arena)), @@ -670,7 +669,6 @@ impl<'a> RemoveSpaces<'a> for Pattern<'a> { match *self { Pattern::Identifier(a) => Pattern::Identifier(a), Pattern::GlobalTag(a) => Pattern::GlobalTag(a), - Pattern::PrivateTag(a) => Pattern::PrivateTag(a), Pattern::OpaqueRef(a) => Pattern::OpaqueRef(a), Pattern::Apply(a, b) => Pattern::Apply( arena.alloc(a.remove_spaces(arena)), @@ -757,10 +755,6 @@ impl<'a> RemoveSpaces<'a> for Tag<'a> { name: name.remove_spaces(arena), args: args.remove_spaces(arena), }, - Tag::Private { name, args } => Tag::Private { - name: name.remove_spaces(arena), - args: args.remove_spaces(arena), - }, Tag::Malformed(a) => Tag::Malformed(a), Tag::SpaceBefore(a, _) => a.remove_spaces(arena), Tag::SpaceAfter(a, _) => a.remove_spaces(arena), diff --git a/compiler/can/src/annotation.rs b/compiler/can/src/annotation.rs index b6bdff3e87..fe07bccbab 100644 --- a/compiler/can/src/annotation.rs +++ b/compiler/can/src/annotation.rs @@ -365,7 +365,7 @@ pub fn find_type_def_symbols( while let Some(tag) = inner_stack.pop() { match tag { - Tag::Global { args, .. } | Tag::Private { args, .. } => { + Tag::Global { args, .. } => { for t in args.iter() { stack.push(&t.value); } @@ -1253,31 +1253,6 @@ fn can_tags<'a>( break 'inner tag_name; } - Tag::Private { name, args } => { - let ident_id = env.ident_ids.get_or_insert(&name.value.into()); - let symbol = Symbol::new(env.home, ident_id); - let mut arg_types = Vec::with_capacity(args.len()); - - for arg in args.iter() { - let ann = can_annotation_help( - env, - &arg.value, - arg.region, - scope, - var_store, - introduced_variables, - local_aliases, - references, - ); - - arg_types.push(ann); - } - - let tag_name = TagName::Private(symbol); - tag_types.push((tag_name.clone(), arg_types)); - - break 'inner tag_name; - } Tag::SpaceBefore(nested, _) | Tag::SpaceAfter(nested, _) => { // check the nested tag instead tag = nested; diff --git a/compiler/can/src/expr.rs b/compiler/can/src/expr.rs index c8e85d3166..31d476d2b8 100644 --- a/compiler/can/src/expr.rs +++ b/compiler/can/src/expr.rs @@ -830,23 +830,6 @@ pub fn canonicalize_expr<'a>( Output::default(), ) } - ast::Expr::PrivateTag(tag) => { - let variant_var = var_store.fresh(); - let ext_var = var_store.fresh(); - let tag_ident = env.ident_ids.get_or_insert(&(*tag).into()); - let symbol = Symbol::new(env.home, tag_ident); - let lambda_set_symbol = env.gen_unique_symbol(); - - ( - ZeroArgumentTag { - name: TagName::Private(symbol), - variant_var, - ext_var, - closure_name: lambda_set_symbol, - }, - Output::default(), - ) - } ast::Expr::OpaqueRef(opaque_ref) => { // If we're here, the opaque reference is definitely not wrapping an argument - wrapped // arguments are handled in the Apply branch. diff --git a/compiler/can/src/operator.rs b/compiler/can/src/operator.rs index 5b1facf5b5..85a5bc1c5f 100644 --- a/compiler/can/src/operator.rs +++ b/compiler/can/src/operator.rs @@ -151,7 +151,6 @@ pub fn desugar_expr<'a>(arena: &'a Bump, loc_expr: &'a Loc>) -> &'a Loc | MalformedClosure | PrecedenceConflict { .. } | GlobalTag(_) - | PrivateTag(_) | OpaqueRef(_) => loc_expr, Access(sub_expr, paths) => { diff --git a/compiler/can/src/pattern.rs b/compiler/can/src/pattern.rs index fac8a67365..7fb54af2ea 100644 --- a/compiler/can/src/pattern.rs +++ b/compiler/can/src/pattern.rs @@ -269,17 +269,6 @@ pub fn canonicalize_pattern<'a>( arguments: vec![], } } - PrivateTag(name) => { - let ident_id = env.ident_ids.get_or_insert(&(*name).into()); - - // Canonicalize the tag's name. - Pattern::AppliedTag { - whole_var: var_store.fresh(), - ext_var: var_store.fresh(), - tag_name: TagName::Private(Symbol::new(env.home, ident_id)), - arguments: vec![], - } - } OpaqueRef(name) => { // If this opaque ref had an argument, we would be in the "Apply" branch. let loc_name = Loc::at(region, (*name).into()); @@ -314,17 +303,6 @@ pub fn canonicalize_pattern<'a>( arguments: can_patterns, } } - PrivateTag(name) => { - let ident_id = env.ident_ids.get_or_insert(&name.into()); - let tag_name = TagName::Private(Symbol::new(env.home, ident_id)); - - Pattern::AppliedTag { - whole_var: var_store.fresh(), - ext_var: var_store.fresh(), - tag_name, - arguments: can_patterns, - } - } OpaqueRef(name) => match scope.lookup_opaque_ref(name, tag.region) { Ok((opaque, opaque_def)) => { diff --git a/compiler/fmt/src/annotation.rs b/compiler/fmt/src/annotation.rs index 8a6184f944..d28868ccf8 100644 --- a/compiler/fmt/src/annotation.rs +++ b/compiler/fmt/src/annotation.rs @@ -468,9 +468,7 @@ impl<'a> Formattable for Tag<'a> { use self::Tag::*; match self { - Global { args, .. } | Private { args, .. } => { - args.iter().any(|arg| (&arg.value).is_multiline()) - } + Global { args, .. } => args.iter().any(|arg| (&arg.value).is_multiline()), Tag::SpaceBefore(_, _) | Tag::SpaceAfter(_, _) => true, Malformed(text) => text.chars().any(|c| c == '\n'), } @@ -503,24 +501,6 @@ impl<'a> Formattable for Tag<'a> { } } } - Tag::Private { name, args } => { - debug_assert!(name.value.starts_with('@')); - buf.indent(indent); - buf.push_str(name.value); - if is_multiline { - let arg_indent = indent + INDENT; - - for arg in *args { - buf.newline(); - arg.format_with_options(buf, Parens::InApply, Newlines::No, arg_indent); - } - } else { - for arg in *args { - buf.spaces(1); - arg.format_with_options(buf, Parens::InApply, Newlines::No, indent); - } - } - } Tag::SpaceBefore(_, _) | Tag::SpaceAfter(_, _) => unreachable!(), Tag::Malformed(raw) => { buf.indent(indent); diff --git a/compiler/fmt/src/expr.rs b/compiler/fmt/src/expr.rs index c8aafa6cff..c6d059237d 100644 --- a/compiler/fmt/src/expr.rs +++ b/compiler/fmt/src/expr.rs @@ -38,7 +38,6 @@ impl<'a> Formattable for Expr<'a> { | MalformedIdent(_, _) | MalformedClosure | GlobalTag(_) - | PrivateTag(_) | OpaqueRef(_) => false, // These expressions always have newlines @@ -273,7 +272,7 @@ impl<'a> Formattable for Expr<'a> { buf.indent(indent); buf.push_str(string); } - GlobalTag(string) | PrivateTag(string) | OpaqueRef(string) => { + GlobalTag(string) | OpaqueRef(string) => { buf.indent(indent); buf.push_str(string) } diff --git a/compiler/fmt/src/pattern.rs b/compiler/fmt/src/pattern.rs index c903ad9596..2d4d5357a8 100644 --- a/compiler/fmt/src/pattern.rs +++ b/compiler/fmt/src/pattern.rs @@ -29,7 +29,6 @@ impl<'a> Formattable for Pattern<'a> { Pattern::Identifier(_) | Pattern::GlobalTag(_) - | Pattern::PrivateTag(_) | Pattern::OpaqueRef(_) | Pattern::Apply(_, _) | Pattern::NumLiteral(..) @@ -58,7 +57,7 @@ impl<'a> Formattable for Pattern<'a> { buf.indent(indent); buf.push_str(string) } - GlobalTag(name) | PrivateTag(name) | OpaqueRef(name) => { + GlobalTag(name) | OpaqueRef(name) => { buf.indent(indent); buf.push_str(name); } diff --git a/compiler/load_internal/src/docs.rs b/compiler/load_internal/src/docs.rs index 0400a53533..42dc9d4c77 100644 --- a/compiler/load_internal/src/docs.rs +++ b/compiler/load_internal/src/docs.rs @@ -404,8 +404,7 @@ fn record_field_to_doc( } } -// The Option here represents if it is private. Private tags -// evaluate to `None`. +// The Option here represents if it is malformed. fn tag_to_doc(in_func_ann: bool, tag: ast::Tag) -> Option { match tag { ast::Tag::Global { name, args } => Some(Tag { @@ -420,7 +419,6 @@ fn tag_to_doc(in_func_ann: bool, tag: ast::Tag) -> Option { type_vars }, }), - ast::Tag::Private { .. } => None, ast::Tag::SpaceBefore(&sub_tag, _) => tag_to_doc(in_func_ann, sub_tag), ast::Tag::SpaceAfter(&sub_tag, _) => tag_to_doc(in_func_ann, sub_tag), ast::Tag::Malformed(_) => None, diff --git a/compiler/parse/src/ast.rs b/compiler/parse/src/ast.rs index 4c3a299fdf..6880e42086 100644 --- a/compiler/parse/src/ast.rs +++ b/compiler/parse/src/ast.rs @@ -189,7 +189,6 @@ pub enum Expr<'a> { // Tags GlobalTag(&'a str), - PrivateTag(&'a str), // Reference to an opaque type, e.g. $Opaq // TODO(opaques): $->@ in the above comment @@ -446,11 +445,6 @@ pub enum Tag<'a> { args: &'a [Loc>], }, - Private { - name: Loc<&'a str>, - args: &'a [Loc>], - }, - // We preserve this for the formatter; canonicalization ignores it. SpaceBefore(&'a Tag<'a>, &'a [CommentOrNewline<'a>]), SpaceAfter(&'a Tag<'a>, &'a [CommentOrNewline<'a>]), @@ -523,7 +517,6 @@ pub enum Pattern<'a> { Identifier(&'a str), GlobalTag(&'a str), - PrivateTag(&'a str), OpaqueRef(&'a str), @@ -628,7 +621,6 @@ impl<'a> Pattern<'a> { match (self, other) { (Identifier(x), Identifier(y)) => x == y, (GlobalTag(x), GlobalTag(y)) => x == y, - (PrivateTag(x), PrivateTag(y)) => x == y, (Apply(constructor_x, args_x), Apply(constructor_y, args_y)) => { let equivalent_args = args_x .iter() @@ -926,7 +918,7 @@ impl<'a> Expr<'a> { } pub fn is_tag(&self) -> bool { - matches!(self, Expr::GlobalTag(_) | Expr::PrivateTag(_)) + matches!(self, Expr::GlobalTag(_)) } } diff --git a/compiler/parse/src/expr.rs b/compiler/parse/src/expr.rs index cf28dc2a41..04074aa9fb 100644 --- a/compiler/parse/src/expr.rs +++ b/compiler/parse/src/expr.rs @@ -1764,7 +1764,6 @@ fn expr_to_pattern_help<'a>(arena: &'a Bump, expr: &Expr<'a>) -> Result Ok(Pattern::Underscore(opt_name)), Expr::GlobalTag(value) => Ok(Pattern::GlobalTag(value)), - Expr::PrivateTag(value) => Ok(Pattern::PrivateTag(value)), Expr::OpaqueRef(value) => Ok(Pattern::OpaqueRef(value)), Expr::Apply(loc_val, loc_args, _) => { let region = loc_val.region; diff --git a/compiler/parse/src/type_annotation.rs b/compiler/parse/src/type_annotation.rs index 45b34b7157..45b1d39216 100644 --- a/compiler/parse/src/type_annotation.rs +++ b/compiler/parse/src/type_annotation.rs @@ -214,16 +214,9 @@ fn tag_type<'a>(min_indent: u32) -> impl Parser<'a, Tag<'a>, ETypeTagUnion<'a>> let (_, args, state) = specialize_ref(ETypeTagUnion::Type, loc_applied_args_e(min_indent)) .parse(arena, state)?; - let result = if name.value.starts_with('@') { - Tag::Private { - name, - args: args.into_bump_slice(), - } - } else { - Tag::Global { - name, - args: args.into_bump_slice(), - } + let result = Tag::Global { + name, + args: args.into_bump_slice(), }; Ok((MadeProgress, result, state)) diff --git a/repl_eval/src/eval.rs b/repl_eval/src/eval.rs index 2079678fa2..44acb07ae9 100644 --- a/repl_eval/src/eval.rs +++ b/repl_eval/src/eval.rs @@ -475,11 +475,7 @@ fn tag_name_to_expr<'a>(env: &Env<'a, '_>, tag_name: &TagName) -> Expr<'a> { env.arena .alloc_str(&tag_name.as_ident_str(env.interns, env.home)), ), - TagName::Private(_) => Expr::PrivateTag( - env.arena - .alloc_str(&tag_name.as_ident_str(env.interns, env.home)), - ), - TagName::Closure(_) => unreachable!("User cannot type this"), + TagName::Private(_) | TagName::Closure(_) => unreachable!("User cannot type this"), } } @@ -1052,11 +1048,7 @@ fn bool_to_ast<'a, M: ReplAppMemory>( let loc_tag_expr = { let tag_name = &tag_name.as_ident_str(env.interns, env.home); - let tag_expr = if tag_name.starts_with('@') { - Expr::PrivateTag(arena.alloc_str(tag_name)) - } else { - Expr::GlobalTag(arena.alloc_str(tag_name)) - }; + let tag_expr = Expr::GlobalTag(arena.alloc_str(tag_name)); &*arena.alloc(Loc { value: tag_expr, @@ -1135,11 +1127,7 @@ fn byte_to_ast<'a, M: ReplAppMemory>( let loc_tag_expr = { let tag_name = &tag_name.as_ident_str(env.interns, env.home); - let tag_expr = if tag_name.starts_with('@') { - Expr::PrivateTag(arena.alloc_str(tag_name)) - } else { - Expr::GlobalTag(arena.alloc_str(tag_name)) - }; + let tag_expr = Expr::GlobalTag(arena.alloc_str(tag_name)); &*arena.alloc(Loc { value: tag_expr,