roc-lang/roc
1
1
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2024-09-21 15:59:20 +03:00
Code Issues Packages Projects Releases Wiki Activity

Remove private tags from Ast

Browse Source
This commit is contained in:
Ayaz Hafiz 2022-04-25 11:20:37 -04:00
parent 67eb4b9faa
commit 1ed9cf551a
No known key found for this signature in database
GPG Key ID: 0E2A37416A25EF58
16 changed files with 12 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
ast/src/lang/core/expr/expr_to_expr2.rs
View File

@ -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);

21
ast/src/lang/core/pattern.rs
View File

@ -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"),
}
}

15
ast/src/lang/core/types.rs
View File

@ -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;

6
cli/src/format.rs
View File

@ -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),

27
compiler/can/src/annotation.rs
View File

@ -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;

17
compiler/can/src/expr.rs
View File

@ -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.

1
compiler/can/src/operator.rs
View File

@ -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) => {

22
compiler/can/src/pattern.rs
View File

@ -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)) => {

22
compiler/fmt/src/annotation.rs
View File

@ -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);

3
compiler/fmt/src/expr.rs
View File

@ -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)
}

3
compiler/fmt/src/pattern.rs
View File

@ -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);
}

4
compiler/load_internal/src/docs.rs
View File

@ -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,

10
compiler/parse/src/ast.rs
View File

@ -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(_))
}
}

1
compiler/parse/src/expr.rs
View File

@ -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;

13
compiler/parse/src/type_annotation.rs
View File

@ -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))

18
repl_eval/src/eval.rs
View File

@ -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,