mirror of
https://github.com/roc-lang/roc.git
synced 2024-09-21 15:59:20 +03:00
Remove private tags from Ast
This commit is contained in:
parent
67eb4b9faa
commit
1ed9cf551a
@ -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);
|
||||
|
@ -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"),
|
||||
}
|
||||
}
|
||||
|
@ -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;
|
||||
|
@ -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),
|
||||
|
@ -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;
|
||||
|
@ -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.
|
||||
|
@ -151,7 +151,6 @@ pub fn desugar_expr<'a>(arena: &'a Bump, loc_expr: &'a Loc<Expr<'a>>) -> &'a Loc
|
||||
| MalformedClosure
|
||||
| PrecedenceConflict { .. }
|
||||
| GlobalTag(_)
|
||||
| PrivateTag(_)
|
||||
| OpaqueRef(_) => loc_expr,
|
||||
|
||||
Access(sub_expr, paths) => {
|
||||
|
@ -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)) => {
|
||||
|
@ -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);
|
||||
|
@ -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)
|
||||
}
|
||||
|
@ -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);
|
||||
}
|
||||
|
@ -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<Tag> {
|
||||
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<Tag> {
|
||||
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,
|
||||
|
@ -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<TypeAnnotation<'a>>],
|
||||
},
|
||||
|
||||
Private {
|
||||
name: Loc<&'a str>,
|
||||
args: &'a [Loc<TypeAnnotation<'a>>],
|
||||
},
|
||||
|
||||
// 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(_))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1764,7 +1764,6 @@ fn expr_to_pattern_help<'a>(arena: &'a Bump, expr: &Expr<'a>) -> Result<Pattern<
|
||||
}
|
||||
Expr::Underscore(opt_name) => 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;
|
||||
|
@ -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))
|
||||
|
@ -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,
|
||||
|
Loading…
Reference in New Issue
Block a user