use std::collections::BTreeMap;
use bumpalo::Bump;
use nash_ast::{ConstructorName, Pattern as CanPattern, PatternCtor, PatternCtorArg};
use nash_region::{Located, Region};
use nash_source::Pattern as SourcePattern;
use crate::Error;
use crate::environment::{self, Env, dups};
use crate::error::{BadArityContext, DuplicatePatternContext};
pub type Bindings<'a> = BTreeMap<&'a str, Region>;
pub fn verify<'a>(
bump: &'a Bump,
env: &Env<'a>,
context: DuplicatePatternContext<'a>,
pattern: &'a Located<SourcePattern<'a>>,
) -> Result<(&'a Located<CanPattern<'a>>, Bindings<'a>), Vec<Error<'a>>> {
let (patterns, bindings) = verify_all(bump, env, context, std::slice::from_ref(&pattern))?;
Ok((patterns[0], bindings))
}
pub fn verify_all<'a>(
bump: &'a Bump,
env: &Env<'a>,
context: DuplicatePatternContext<'a>,
patterns: &[&'a Located<SourcePattern<'a>>],
) -> Result<(Vec<&'a Located<CanPattern<'a>>>, Bindings<'a>), Vec<Error<'a>>> {
let mut bound: Vec<(&'a str, Region)> = Vec::new();
let mut results = Vec::with_capacity(patterns.len());
let mut errors = Vec::new();
for pattern in patterns {
match canonicalize(bump, env, pattern, &mut bound) {
Ok(p) => results.push(p),
Err(errs) => errors.extend(errs),
}
}
if !errors.is_empty() {
return Err(errors);
}
let bindings = detect_duplicates(context, bound)?;
Ok((results, bindings))
}
pub fn detect_duplicates<'a>(
context: DuplicatePatternContext<'a>,
bound: Vec<(&'a str, Region)>,
) -> Result<Bindings<'a>, Vec<Error<'a>>> {
dups::detect(bound, |name, first, second| Error::DuplicatePattern {
context,
name,
first,
second,
})
}
pub fn canonicalize<'a>(
bump: &'a Bump,
env: &Env<'a>,
pattern: &'a Located<SourcePattern<'a>>,
bindings: &mut Vec<(&'a str, Region)>,
) -> Result<&'a Located<CanPattern<'a>>, Vec<Error<'a>>> {
let can = match &pattern.value {
SourcePattern::Anything => CanPattern::Anything,
SourcePattern::Var(name) => {
bindings.push((name, pattern.region));
CanPattern::Var(name)
}
SourcePattern::Record(fields) => {
for field in *fields {
bindings.push((field.value, field.region));
}
let names = bump.alloc_slice_fill_iter(fields.iter().map(|f| f.value));
CanPattern::Record(names)
}
SourcePattern::Alias {
pattern: inner,
name,
} => {
let can_inner = canonicalize(bump, env, inner, bindings)?;
bindings.push((name.value, name.region));
CanPattern::Alias {
pattern: can_inner,
name: name.value,
}
}
SourcePattern::Unit => CanPattern::Unit,
SourcePattern::Pair { first, second } => {
let (first, second) = crate::accumulate::accumulate2(
canonicalize(bump, env, first, bindings),
canonicalize(bump, env, second, bindings),
)?;
CanPattern::Pair { first, second }
}
SourcePattern::Tuple {
first,
second,
rest,
} => {
let (first, second, rest) = crate::accumulate::accumulate3(
canonicalize(bump, env, first, bindings),
canonicalize(bump, env, second, bindings),
canonicalize_list(bump, env, rest, bindings),
)?;
CanPattern::Tuple {
first,
second,
rest,
}
}
SourcePattern::Ctor {
region: name_region,
name,
args,
} => {
let ctor = env.find_ctor(bump, *name_region, name)?;
canonicalize_ctor_pattern(bump, env, pattern.region, name, args, &ctor, bindings)?
}
SourcePattern::CtorQual {
region: name_region,
module,
name,
args,
} => {
let ctor = env.find_ctor_qual(bump, *name_region, module, name)?;
canonicalize_ctor_pattern(bump, env, pattern.region, name, args, &ctor, bindings)?
}
SourcePattern::List(pats) => {
let can_pats = canonicalize_list(bump, env, pats, bindings)?;
CanPattern::List(can_pats)
}
SourcePattern::Cons { head, tail } => {
let (head, tail) = crate::accumulate::accumulate2(
canonicalize(bump, env, head, bindings),
canonicalize(bump, env, tail, bindings),
)?;
CanPattern::Cons { head, tail }
}
SourcePattern::Str(s) => CanPattern::Str(s),
SourcePattern::Bytes(bytes) => CanPattern::Bytes(bytes),
SourcePattern::Int(n) => CanPattern::Int(*n),
};
Ok(bump.alloc(Located::at(pattern.region, can)))
}
fn canonicalize_ctor_pattern<'a>(
bump: &'a Bump,
env: &Env<'a>,
region: Region,
name: &'a str,
args: &'a [&'a Located<SourcePattern<'a>>],
ctor: &environment::Ctor<'a>,
bindings: &mut Vec<(&'a str, Region)>,
) -> Result<CanPattern<'a>, Vec<Error<'a>>> {
match ctor {
environment::Ctor::Union {
home,
type_name,
type_vars: _,
union: union_def,
index,
arity,
arguments: expected_types,
options,
alternatives,
} => {
let mut repeated = Vec::new();
let args = if let [argument] = args
&& let SourcePattern::Record(names) = &argument.value
&& let Some(labels) = union_def
.ctors
.iter()
.find(|ctor| ctor.index == *index)
.and_then(|ctor| ctor.labels)
{
let unknown: Vec<_> = names
.iter()
.filter(|field| !labels.contains(&field.value))
.map(|field| Error::LabeledCtorUnknownField {
region: field.region,
ctor: name,
field: field.value,
})
.collect();
if !unknown.is_empty() {
return Err(unknown);
}
let mut seen = std::collections::BTreeSet::new();
for field in *names {
if !seen.insert(field.value) {
repeated.push((field.value, field.region));
}
}
&*bump.alloc_slice_fill_iter(labels.iter().map(|label| {
&*bump.alloc(match names.iter().find(|name| name.value == *label) {
Some(name) => Located::at(name.region, SourcePattern::Var(name.value)),
None => Located::at(argument.region, SourcePattern::Anything),
})
}))
} else {
args
};
if args.len() != *arity as usize {
return Err(vec![Error::BadArity {
region,
context: BadArityContext::PatternArity,
name,
expected: *arity as usize,
actual: args.len(),
}]);
}
let mut ctor_args = Vec::with_capacity(args.len());
let mut errors = Vec::new();
for (i, (pat, expected_typ)) in args
.iter()
.copied()
.zip(expected_types.iter().copied())
.enumerate()
{
match canonicalize(bump, env, pat, bindings) {
Ok(can_pat) => ctor_args.push(PatternCtorArg {
index: i as u16,
typ: expected_typ,
pattern: can_pat,
}),
Err(mut e) => errors.append(&mut e),
}
}
bindings.extend(repeated);
if !errors.is_empty() {
return Err(errors);
}
Ok(CanPattern::Constructor(PatternCtor {
reference: ConstructorName {
home: *home,
union: type_name,
name,
},
union: union_def,
index: *index,
arguments: bump.alloc_slice_fill_iter(ctor_args),
options: *options,
alternatives: *alternatives,
}))
}
environment::Ctor::Bool { union, .. } => {
if !args.is_empty() {
return Err(vec![Error::BadArity {
region,
context: BadArityContext::PatternArity,
name,
expected: 0,
actual: args.len(),
}]);
}
Ok(CanPattern::Bool {
union,
value: name == "True",
})
}
environment::Ctor::RecordCtor { .. } => {
Err(vec![Error::PatternHasRecordCtor { region, name }])
}
}
}
fn canonicalize_list<'a>(
bump: &'a Bump,
env: &Env<'a>,
patterns: &'a [&'a Located<SourcePattern<'a>>],
bindings: &mut Vec<(&'a str, Region)>,
) -> Result<&'a [&'a Located<CanPattern<'a>>], Vec<Error<'a>>> {
let mut results = Vec::with_capacity(patterns.len());
let mut errors = Vec::new();
for pat in patterns {
match canonicalize(bump, env, pat, bindings) {
Ok(p) => results.push(p),
Err(mut e) => errors.append(&mut e),
}
}
if errors.is_empty() {
Ok(bump.alloc_slice_fill_iter(results))
} else {
Err(errors)
}
}
#[cfg(test)]
mod tests {
use super::*;
use bumpalo::Bump;
use nash_ast::{CtorOpts, ModuleName, Type as CanType, Union};
use nash_can::DuplicatePatternContext;
use nash_can::pattern::verify;
use nash_can::environment::{Ctor, Env, Info};
fn empty_env<'a>(_bump: &'a Bump) -> Env<'a> {
Env {
kinds: nash_can::kinds::KindEnv::from_interfaces(None),
traits: Default::default(),
q_traits: Default::default(),
home: ModuleName {
package: None,
name: "Main",
},
vars: Default::default(),
types: Default::default(),
ctors: Default::default(),
binops: Default::default(),
q_vars: Default::default(),
q_types: Default::default(),
q_ctors: Default::default(),
}
}
fn env_with_maybe<'a>(bump: &'a Bump) -> Env<'a> {
let home = ModuleName {
package: None,
name: "Maybe",
};
let mut env = empty_env(bump);
let nothing_ctor = bump.alloc(nash_ast::Ctor {
labels: None,
name: "Nothing",
index: 1,
arity: 0,
arguments: &[],
});
let just_arg_typ = bump.alloc(Located::at(Region::zero(), CanType::Var("a")));
let just_ctor = bump.alloc(nash_ast::Ctor {
labels: None,
name: "Just",
index: 0,
arity: 1,
arguments: bump.alloc_slice_fill_iter([&*just_arg_typ]),
});
let maybe_union: &Union = bump.alloc(Union {
kind: bump.alloc(nash_ast::Kind::Arrow(
&nash_ast::Kind::Type,
&nash_ast::Kind::Type,
)),
context: &[],
name: bump.alloc(Located::at(Region::zero(), "Maybe")),
parameters: bump.alloc_slice_fill_iter(["a"]),
ctors: bump.alloc_slice_fill_iter([&*nothing_ctor, &*just_ctor]),
alternatives: 2,
options: CtorOpts::Normal,
});
let nothing = Ctor::Union {
home,
type_name: "Maybe",
type_vars: &["a"],
union: maybe_union,
index: 1,
arity: 0,
arguments: &[],
options: CtorOpts::Normal,
alternatives: 2,
};
env.ctors.insert("Nothing", Info::Specific(home, nothing));
let just = Ctor::Union {
home,
type_name: "Maybe",
type_vars: &["a"],
union: maybe_union,
index: 0,
arity: 1,
arguments: bump.alloc_slice_fill_iter([&*just_arg_typ]),
options: CtorOpts::Normal,
alternatives: 2,
};
env.ctors.insert("Just", Info::Specific(home, just));
env
}
fn env_with_record_ctor<'a>(bump: &'a Bump) -> Env<'a> {
let home = ModuleName {
package: None,
name: "Main",
};
let mut env = empty_env(bump);
let field_typ: &Located<CanType> =
bump.alloc(Located::at(Region::zero(), CanType::Var("a")));
let record_type: &Located<CanType> = bump.alloc(Located::at(
Region::zero(),
CanType::Record {
fields: bump.alloc_slice_fill_iter([
nash_ast::FieldType {
index: 0,
field: "x",
typ: field_typ,
},
nash_ast::FieldType {
index: 1,
field: "y",
typ: field_typ,
},
]),
},
));
let ctor = match &record_type.value {
CanType::Record { fields, .. } => nash_can::environment::make_record_ctor(
bump,
home,
"Point",
&[],
record_type,
fields,
),
_ => unreachable!(),
};
env.ctors.insert("Point", Info::Specific(home, ctor));
env
}
fn env_with_bool<'a>(bump: &'a Bump) -> Env<'a> {
let module = nash_parse::Parser::new(
bump,
"module Main exposing (..)\nimport Primitive exposing (type bool(..))\nimport Builtin\n",
)
.module()
.unwrap();
let interfaces = std::collections::BTreeMap::from([(
"Builtin",
nash_can::kinds::builtin_interface(bump),
)]);
nash_can::environment::foreign::create_initial_env(
bump,
empty_env(bump).home,
Some(&interfaces),
module.imports,
)
.unwrap()
}
fn env_with_data<'a>(bump: &'a Bump) -> Env<'a> {
let module = nash_parse::Parser::new(
bump,
"module Main exposing (..)\nimport Primitive exposing (Data(..))\nimport Builtin\n",
)
.module()
.unwrap();
let interfaces = std::collections::BTreeMap::from([(
"Builtin",
nash_can::kinds::builtin_interface(bump),
)]);
nash_can::environment::foreign::create_initial_env(
bump,
empty_env(bump).home,
Some(&interfaces),
module.imports,
)
.unwrap()
}
fn parse_pattern<'a>(bump: &'a Bump, input: &str) -> &'a Located<SourcePattern<'a>> {
let src = bump.alloc_str(input);
let mut parser = nash_parse::Parser::new(bump, src);
let (pat, _end) = parser.pattern_expr().expect("expected successful parse");
pat
}
macro_rules! assert_pattern_snapshot {
($input:expr, $env_fn:ident) => {{
let bump = Bump::new();
let env = $env_fn(&bump);
let pat = parse_pattern(&bump, $input);
let result = verify(&bump, &env, DuplicatePatternContext::CaseBranch, pat);
insta::with_settings!({
description => $input,
omit_expression => true,
}, {
insta::assert_debug_snapshot!(result.unwrap());
});
}};
}
macro_rules! assert_pattern_error_snapshot {
($input:expr, $env_fn:ident) => {{
let bump = Bump::new();
let env = $env_fn(&bump);
let pat = parse_pattern(&bump, $input);
let result = verify(&bump, &env, DuplicatePatternContext::CaseBranch, pat);
insta::with_settings!({info => &"diagnostic",
description => $input,
omit_expression => true,
}, {
insta::assert_snapshot!(crate::snapshot_support::errors($input, &result.unwrap_err()));
});
}};
}
#[test]
fn wildcard() {
assert_pattern_snapshot!("_", empty_env);
}
#[test]
fn variable() {
assert_pattern_snapshot!("x", empty_env);
}
#[test]
fn record_pattern() {
assert_pattern_snapshot!("{ x, y }", empty_env);
}
#[test]
fn unit() {
assert_pattern_snapshot!("()", empty_env);
}
#[test]
fn tuple_two() {
assert_pattern_snapshot!("( a, b )", empty_env);
}
#[test]
fn tuple_three() {
assert_pattern_snapshot!("( a, b, c )", empty_env);
}
#[test]
fn literal_int() {
assert_pattern_snapshot!("42", empty_env);
}
#[test]
fn literal_str() {
assert_pattern_snapshot!(r#""hello""#, empty_env);
}
#[test]
fn list_pattern() {
assert_pattern_snapshot!("[ a, b ]", empty_env);
}
#[test]
fn cons_pattern() {
assert_pattern_snapshot!("x :: xs", empty_env);
}
#[test]
fn ctor_no_args() {
assert_pattern_snapshot!("Nothing", env_with_maybe);
}
#[test]
fn ctor_with_args() {
assert_pattern_snapshot!("Just x", env_with_maybe);
}
#[test]
fn bool_true_pattern() {
assert_pattern_snapshot!("True", env_with_bool);
}
#[test]
fn bool_false_pattern() {
assert_pattern_snapshot!("False", env_with_bool);
}
#[test]
fn alias_pattern() {
assert_pattern_snapshot!("(x, y) as pair", empty_env);
}
#[test]
fn constr_binds_one_pair() {
assert_pattern_snapshot!("Constr payload", env_with_data);
}
#[test]
fn constr_rejects_two_fields() {
assert_pattern_error_snapshot!("Constr index items", env_with_data);
}
#[test]
fn tuple_four() {
assert_pattern_snapshot!("( a, b, c, d )", empty_env);
}
#[test]
fn ctor_wrong_arity() {
assert_pattern_error_snapshot!("Just x y", env_with_maybe);
}
#[test]
fn ctor_not_found() {
assert_pattern_error_snapshot!("Foo", empty_env);
}
#[test]
fn record_ctor_in_pattern() {
assert_pattern_error_snapshot!("Point", env_with_record_ctor);
}
#[test]
fn duplicate_vars() {
assert_pattern_error_snapshot!("( x, x )", empty_env);
}
#[test]
fn bool_pattern_with_args_is_bad_arity() {
assert_pattern_error_snapshot!("True x", env_with_bool);
}
#[test]
fn duplicate_across_sibling_patterns() {
let bump = Bump::new();
let input = "module Main exposing (..)\nf = \\x x -> x\n";
let module = nash_parse::Parser::new(&bump, input).module().unwrap();
let errors =
nash_can::canonicalize(&bump, nash_can::Context::default(), &module).unwrap_err();
insta::with_settings!({info => &"diagnostic", description => input, omit_expression => true}, {
insta::assert_snapshot!(crate::snapshot_support::errors(input, &errors));
});
}
}