language-servers/erg
1
0
Fork 0
mirror of https://github.com/erg-lang/erg.git synced 2025-09-30 04:44:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Improve type mismatch messages

Browse source
This commit is contained in:
Shunsuke Shibayama 2022-11-25 17:20:39 +09:00
parent 14bb674068
commit d26909c317
7 changed files with 50 additions and 27 deletions
Download patch file Download diff file Expand all files Collapse all files

4
compiler/erg_compiler/context/eval.rs
View file

@ -874,7 +874,7 @@ impl Context {
&proj,
t_loc,
self.caused_by(),
self.get_no_candidate_hint(&proj),
Self::get_no_candidate_hint(&proj),
)))
}
}
@ -1169,7 +1169,7 @@ impl Context {
&proj,
t_loc,
self.caused_by(),
self.get_no_candidate_hint(&proj),
Self::get_no_candidate_hint(&proj),
)))
}
}

45
compiler/erg_compiler/context/hint.rs
View file

@ -1,7 +1,7 @@
use erg_common::enum_unwrap;
use crate::ty::typaram::TyParam;
use crate::ty::Type;
use crate::ty::{HasType, Type};
use crate::context::Context;
@ -11,8 +11,9 @@ enum Sequence {
Backward,
}
// TODO: these should not be in Context
impl Context {
fn readable_type(&self, typ: &Type) -> Type {
fn readable_type(typ: &Type) -> Type {
match typ {
Type::FreeVar(fv) if fv.constraint_is_sandwiched() => {
let (sub, sup) = fv.get_subsup().unwrap();
@ -25,7 +26,20 @@ impl Context {
}
}
pub(crate) fn get_type_mismatch_hint(&self, expected: &Type, found: &Type) -> Option<String> {
/// TODO: custom types
fn get_verb_and_preposition(trait_: &Type) -> Option<(&str, &str, Sequence)> {
match &trait_.qual_name()[..] {
"Add" => Some(("add", "and", Sequence::Forward)),
"Sub" => Some(("subtract", "from", Sequence::Backward)),
"Mul" => Some(("multiply", "and", Sequence::Forward)),
"Div" => Some(("divide", "by", Sequence::Forward)),
"Eq" => Some(("compare", "and", Sequence::Forward)),
"Ord" => Some(("compare", "and", Sequence::Forward)),
_ => None,
}
}
pub(crate) fn get_type_mismatch_hint(expected: &Type, found: &Type) -> Option<String> {
let expected = if let Type::FreeVar(fv) = expected {
if fv.is_linked() {
fv.crack().clone()
@ -38,27 +52,26 @@ impl Context {
};
match (&expected.qual_name()[..], &found.qual_name()[..]) {
("Eq", "Float") => Some(String::from("Float has no equivalence relation defined. you should use `l - r <= Float.EPSILON` instead of `l == r`.")),
_ => None,
_ => {
let (verb, preposition, _sequence) = Self::get_verb_and_preposition(&expected)?;
found.union_types()
.map(|(t1, t2)| format!("cannot {verb} {t1} {preposition} {t2}"))
.or_else(|| {
let ts = expected.inner_ts();
Some(format!("cannot {verb} {found} {preposition} {}", ts[0]))
})
}
}
}
pub(crate) fn get_no_candidate_hint(&self, proj: &Type) -> Option<String> {
pub(crate) fn get_no_candidate_hint(proj: &Type) -> Option<String> {
match proj {
Type::Proj { lhs, rhs: _ } => {
if let Type::FreeVar(fv) = lhs.as_ref() {
let (sub, sup) = fv.get_subsup()?;
// TODO: automating
let (verb, preposition, sequence) = match &sup.qual_name()[..] {
"Add" => Some(("add", "and", Sequence::Forward)),
"Sub" => Some(("subtract", "from", Sequence::Backward)),
"Mul" => Some(("multiply", "and", Sequence::Forward)),
"Div" => Some(("divide", "by", Sequence::Forward)),
"Eq" => Some(("compare", "and", Sequence::Forward)),
"Ord" => Some(("compare", "and", Sequence::Forward)),
_ => None,
}?;
let (verb, preposition, sequence) = Self::get_verb_and_preposition(&sup)?;
let sup = enum_unwrap!(sup.typarams().remove(0), TyParam::Type);
let sup = self.readable_type(&sup);
let sup = Self::readable_type(&sup);
let (l, r) = if sequence == Sequence::Forward {
(sub, sup)
} else {

10
compiler/erg_compiler/context/inquire.rs
View file

@ -57,7 +57,7 @@ impl Context {
&spec_t,
body_t,
self.get_candidates(body_t),
self.get_type_mismatch_hint(&spec_t, body_t),
Self::get_type_mismatch_hint(&spec_t, body_t),
)));
}
Ok(())
@ -256,7 +256,7 @@ impl Context {
&mono("LambdaFunc"),
t,
self.get_candidates(t),
self.get_type_mismatch_hint(&mono("LambdaFunc"), t),
Self::get_type_mismatch_hint(&mono("LambdaFunc"), t),
)));
}
}
@ -1075,7 +1075,7 @@ impl Context {
param_t,
arg_t,
self.get_candidates(arg_t),
self.get_type_mismatch_hint(param_t, arg_t),
Self::get_type_mismatch_hint(param_t, arg_t),
)
})
.collect(),
@ -1130,7 +1130,7 @@ impl Context {
param_t,
arg_t,
self.get_candidates(arg_t),
self.get_type_mismatch_hint(param_t, arg_t),
Self::get_type_mismatch_hint(param_t, arg_t),
)
})
.collect(),
@ -1187,7 +1187,7 @@ impl Context {
pt.typ(),
arg_t,
self.get_candidates(arg_t),
self.get_type_mismatch_hint(pt.typ(), arg_t),
Self::get_type_mismatch_hint(pt.typ(), arg_t),
)
})
.collect(),

2
compiler/erg_compiler/context/tyvar.rs
View file

@ -1285,7 +1285,7 @@ impl Context {
maybe_sup,
maybe_sub,
self.get_candidates(maybe_sub),
self.get_type_mismatch_hint(maybe_sup, maybe_sub),
Self::get_type_mismatch_hint(maybe_sup, maybe_sub),
)));
}
match (maybe_sub, maybe_sup) {

5
compiler/erg_compiler/error.rs
View file

@ -16,9 +16,9 @@ use erg_common::{
use erg_parser::error::{ParserRunnerError, ParserRunnerErrors};
use crate::ty::{Predicate, Type};
use crate::context::Context;
use crate::hir::{Expr, Identifier, Signature};
use crate::ty::{Predicate, Type};
pub fn ordinal_num(n: usize) -> String {
match n.to_string().chars().last().unwrap() {
@ -972,6 +972,7 @@ passed keyword args: {kw_args_len}"
caused_by: String,
hint: Option<String>,
) -> Self {
let hint = hint.or_else(|| Context::get_type_mismatch_hint(trait_, class));
Self::new(
ErrorCore::new(
vec![SubMessage::ambiguous_new(loc, vec![], hint)],

2
compiler/erg_compiler/lower.rs
View file

@ -168,7 +168,7 @@ impl ASTLowerer {
expect,
found,
self.ctx.get_candidates(found),
self.ctx.get_type_mismatch_hint(expect, found),
Context::get_type_mismatch_hint(expect, found),
)
})
}

9
compiler/erg_compiler/ty/mod.rs
View file

@ -1779,6 +1779,15 @@ impl Type {
}
}
pub fn union_types(&self) -> Option<(Type, Type)> {
match self {
Type::FreeVar(fv) if fv.is_linked() => fv.crack().union_types(),
Type::Refinement(refine) => refine.t.union_types(),
Type::Or(t1, t2) => Some((*t1.clone(), *t2.clone())),
_ => None,
}
}
/// assert!((A or B).contains_union(B))
pub fn contains_union(&self, typ: &Type) -> bool {
match self {