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

Fix lowerer crash bugs

Browse source
This commit is contained in:
Shunsuke Shibayama 2022-09-30 15:46:27 +09:00
parent 12664a0e1c
commit 622e1fa350
4 changed files with 99 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -495,10 +495,16 @@ impl Context {
self.get_similar_attr_from_singular(obj, method_name.inspect()),
));
}
if let Some(trait_) = self.rec_get_method_traits(method_name) {
match self.rec_get_method_traits(method_name) {
Ok(trait_) => {
let (_, ctx) = self.get_nominal_type_ctx(trait_).unwrap();
return ctx.rec_get_var_t(method_name, input, namespace);
}
Err(err) if err.core.kind == ErrorKind::TypeError => {
return Err(err);
}
_ => {}
}
// TODO: patch
Err(TyCheckError::no_attr_error(
self.cfg.input.clone(),
@ -1561,17 +1567,32 @@ impl Context {
}
}
fn rec_get_method_traits(&self, name: &Identifier) -> Option<&Type> {
if let Some(t) = self.method_traits.get(name.inspect()) {
if t.len() == 1 {
Some(&t[0])
fn rec_get_method_traits(&self, name: &Identifier) -> SingleTyCheckResult<&Type> {
if let Some(candidates) = self.method_traits.get(name.inspect()) {
let first_t = candidates.first().unwrap();
if candidates.iter().skip(1).all(|t| t == first_t) {
Ok(&candidates[0])
} else {
None
Err(TyCheckError::ambiguous_type_error(
self.cfg.input.clone(),
line!() as usize,
name,
candidates,
self.caused_by(),
))
}
} else if let Some(outer) = self.get_outer().or_else(|| self.get_builtins()) {
outer.rec_get_method_traits(name)
} else {
None
Err(TyCheckError::no_attr_error(
self.cfg.input.clone(),
line!() as usize,
name.loc(),
self.caused_by(),
&Type::Failure,
name.inspect(),
None,
))
}
}

18
compiler/erg_compiler/context/register.rs
View file

@ -50,14 +50,11 @@ impl Context {
return Some((name, vi));
}
if is_const {
if let Some(outer) = self.get_outer().or_else(|| self.get_builtins()) {
let outer = self.get_outer().or_else(|| self.get_builtins())?;
outer.registered_info(name, is_const)
} else {
None
}
} else {
None
}
}
fn _declare_var(
@ -460,18 +457,27 @@ impl Context {
// To allow forward references and recursive definitions
pub(crate) fn preregister(&mut self, block: &ast::Block) -> TyCheckResult<()> {
let mut total_errs = TyCheckErrors::empty();
for expr in block.iter() {
match expr {
ast::Expr::Def(def) => {
self.preregister_def(def)?;
if let Err(errs) = self.preregister_def(def) {
total_errs.extend(errs.into_iter());
}
}
ast::Expr::ClassDef(class_def) => {
self.preregister_def(&class_def.def)?;
if let Err(errs) = self.preregister_def(&class_def.def) {
total_errs.extend(errs.into_iter());
}
}
_ => {}
}
}
if total_errs.is_empty() {
Ok(())
} else {
Err(total_errs)
}
}
pub(crate) fn preregister_def(&mut self, def: &ast::Def) -> TyCheckResult<()> {

32
compiler/erg_compiler/error.rs
View file

@ -920,6 +920,38 @@ passed keyword args: {RED}{kw_args_len}{RESET}"
caused_by,
)
}
pub fn ambiguous_type_error(
input: Input,
errno: usize,
expr: &(impl Locational + Display),
candidates: &[Type],
caused_by: AtomicStr,
) -> Self {
Self::new(
ErrorCore::new(
errno,
TypeError,
expr.loc(),
switch_lang!(
"japanese" => format!("{expr}の型を一意に決定できませんでした\n候補: {}", fmt_vec(candidates)),
"simplified_chinese" => format!("无法确定{expr}的类型\n候选：{}", fmt_vec(candidates)),
"traditional_chinese" => format!("無法確定{expr}的類型\n候選：{}", fmt_vec(candidates)),
"english" => format!("cannot determine the type of {expr}\ncandidates: {}", fmt_vec(candidates)),
),
Some(
switch_lang!(
"japanese" => "多相関数の場合は`f|T := Int|`, 型属性の場合は`T|T <: Trait|.X`などのようにして型を指定してください",
"simplified_chinese" => "如果是多态函数，请使用`f|T := Int|`，如果是类型属性，请使用`T|T <: Trait|.X`等方式指定类型",
"traditional_chinese" => "如果是多型函數，請使用`f|T := Int|`，如果是類型屬性，請使用`T|T <: Trait|.X`等方式指定類型",
"english" => "if it is a polymorphic function, use `f|T := Int|`, or if it is a type attribute, use `T|T <: Trait|.X` etc. to specify the type",
).into(),
),
),
input,
caused_by,
)
}
}
pub type TyCheckErrors = CompileErrors;

38
compiler/erg_compiler/lower.rs
View file

@ -508,16 +508,12 @@ impl ASTLowerer {
ContextKind::Func
};
self.ctx.grow(&name, kind, Private)?;
self.ctx
.assign_params(&lambda.sig.params, None)
.map_err(|e| {
self.pop_append_errs();
e
})?;
self.ctx.preregister(&lambda.body).map_err(|e| {
self.pop_append_errs();
e
})?;
if let Err(errs) = self.ctx.assign_params(&lambda.sig.params, None) {
self.errs.extend(errs.into_iter());
}
if let Err(errs) = self.ctx.preregister(&lambda.body) {
self.errs.extend(errs.into_iter());
}
let body = self.lower_block(lambda.body).map_err(|e| {
self.pop_append_errs();
e
@ -606,8 +602,13 @@ impl ASTLowerer {
body: ast::DefBody,
) -> LowerResult<hir::Def> {
log!(info "entered {}({sig})", fn_name!());
self.ctx.preregister(&body.block)?;
let block = self.lower_block(body.block)?;
if let Err(errs) = self.ctx.preregister(&body.block) {
self.errs.extend(errs.into_iter());
}
let block = self.lower_block(body.block).map_err(|e| {
self.pop_append_errs();
e
})?;
let found_body_t = block.ref_t();
let opt_expect_body_t = self
.ctx
@ -660,9 +661,16 @@ impl ASTLowerer {
.t
.clone();
let t = enum_unwrap!(t, Type::Subr);
self.ctx.assign_params(&sig.params, Some(t.clone()))?;
self.ctx.preregister(&body.block)?;
let block = self.lower_block(body.block)?;
if let Err(errs) = self.ctx.assign_params(&sig.params, Some(t.clone())) {
self.errs.extend(errs.into_iter());
}
if let Err(errs) = self.ctx.preregister(&body.block) {
self.errs.extend(errs.into_iter());
}
let block = self.lower_block(body.block).map_err(|e| {
self.pop_append_errs();
e
})?;
let found_body_t = block.ref_t();
let expect_body_t = t.return_t.as_ref();
if !sig.is_const() {