From 4e2b36bb963b52e8f0a8c4aef5da6b5b30005fd9 Mon Sep 17 00:00:00 2001 From: Shunsuke Shibayama Date: Sat, 15 Oct 2022 11:15:16 +0900 Subject: [PATCH 1/4] Fix projection type inference bug --- compiler/erg_compiler/context/eval.rs | 70 +-- .../erg_compiler/context/initialize/mod.rs | 427 +++++++++--------- compiler/erg_compiler/context/inquire.rs | 4 +- compiler/erg_compiler/context/mod.rs | 33 +- compiler/erg_compiler/context/register.rs | 133 +++++- compiler/erg_compiler/lower.rs | 49 +- compiler/erg_compiler/varinfo.rs | 4 + examples/impl.er | 8 +- 8 files changed, 419 insertions(+), 309 deletions(-) diff --git a/compiler/erg_compiler/context/eval.rs b/compiler/erg_compiler/context/eval.rs index 968d5a93..f7d2ae12 100644 --- a/compiler/erg_compiler/context/eval.rs +++ b/compiler/erg_compiler/context/eval.rs @@ -921,15 +921,10 @@ impl Context { } // in Methods if self.name == sub.qual_name() { - if let Ok(obj) = self.get_const_local(&Token::symbol(&rhs), &self.name) { - if let ValueObj::Type(quant_t) = obj { - let subst_ctx = SubstContext::new(&sub, self, t_loc); - let t = subst_ctx.substitute(quant_t.typ().clone())?; - let t = self.eval_t_params(t, level, t_loc)?; - return Ok(t); - } else { - todo!() - } + if let Some(t) = + self.validate_and_project(&sub, opt_sup.as_ref(), &rhs, self, level, t_loc) + { + return Ok(t); } } for ty_ctx in self.get_nominal_super_type_ctxs(&sub).ok_or_else(|| { @@ -942,15 +937,10 @@ impl Context { None, // TODO: ) })? { - if let Ok(obj) = ty_ctx.get_const_local(&Token::symbol(&rhs), &self.name) { - if let ValueObj::Type(quant_t) = obj { - let subst_ctx = SubstContext::new(&sub, self, t_loc); - let t = subst_ctx.substitute(quant_t.typ().clone())?; - let t = self.eval_t_params(t, level, t_loc)?; - return Ok(t); - } else { - todo!() - } + if let Some(t) = + self.validate_and_project(&sub, opt_sup.as_ref(), &rhs, ty_ctx, level, t_loc) + { + return Ok(t); } for (class, methods) in ty_ctx.methods_list.iter() { match (class, &opt_sup) { @@ -966,15 +956,10 @@ impl Context { } _ => {} } - if let Ok(obj) = methods.get_const_local(&Token::symbol(&rhs), &self.name) { - if let ValueObj::Type(quant_t) = obj { - let subst_ctx = SubstContext::new(&sub, self, t_loc); - let t = subst_ctx.substitute(quant_t.typ().clone())?; - let t = self.eval_t_params(t, level, t_loc)?; - return Ok(t); - } else { - todo!() - } + if let Some(t) = + self.validate_and_project(&sub, opt_sup.as_ref(), &rhs, methods, level, t_loc) + { + return Ok(t); } } } @@ -1014,6 +999,37 @@ impl Context { } } + fn validate_and_project( + &self, + sub: &Type, + opt_sup: Option<&Type>, + rhs: &str, + methods: &Context, + level: usize, + t_loc: Location, + ) -> Option { + if let Ok(obj) = methods.get_const_local(&Token::symbol(rhs), &self.name) { + #[allow(clippy::single_match)] + match (&opt_sup, methods.impl_of()) { + (Some(sup), Some(trait_)) => { + if !self.supertype_of(&trait_, sup) { + return None; + } + } + _ => {} + } + if let ValueObj::Type(quant_t) = obj { + let subst_ctx = SubstContext::new(sub, self, t_loc); + let t = subst_ctx.substitute(quant_t.typ().clone()).ok()?; + let t = self.eval_t_params(t, level, t_loc).ok()?; + return Some(t); + } else { + todo!() + } + } + None + } + fn eval_proj_call( &self, lhs: TyParam, diff --git a/compiler/erg_compiler/context/initialize/mod.rs b/compiler/erg_compiler/context/initialize/mod.rs index e79199b0..68f6da05 100644 --- a/compiler/erg_compiler/context/initialize/mod.rs +++ b/compiler/erg_compiler/context/initialize/mod.rs @@ -37,12 +37,19 @@ use Visibility::*; impl Context { fn register_builtin_decl(&mut self, name: &'static str, t: Type, vis: Visibility) { + let impl_of = if let ContextKind::MethodDefs(Some(tr)) = &self.kind { + Some(tr.clone()) + } else { + None + }; let name = VarName::from_static(name); if self.decls.get(&name).is_some() { panic!("already registered: {name}"); } else { - self.decls - .insert(name, VarInfo::new(t, Immutable, vis, Builtin, None)); + self.decls.insert( + name, + VarInfo::new(t, Immutable, vis, Builtin, None, impl_of), + ); } } @@ -53,21 +60,42 @@ impl Context { muty: Mutability, vis: Visibility, ) { + let impl_of = if let ContextKind::MethodDefs(Some(tr)) = &self.kind { + Some(tr.clone()) + } else { + None + }; let name = VarName::from_static(name); if self.locals.get(&name).is_some() { panic!("already registered: {name}"); } else { self.locals - .insert(name, VarInfo::new(t, muty, vis, Builtin, None)); + .insert(name, VarInfo::new(t, muty, vis, Builtin, None, impl_of)); } } + fn register_builtin_immutable_private_var(&mut self, name: &'static str, t: Type) { + self.register_builtin_impl(name, t, Immutable, Private) + } + fn register_builtin_const(&mut self, name: &str, vis: Visibility, obj: ValueObj) { if self.rec_get_const_obj(name).is_some() { panic!("already registered: {name}"); } else { + let impl_of = if let ContextKind::MethodDefs(Some(tr)) = &self.kind { + Some(tr.clone()) + } else { + None + }; // TODO: not all value objects are comparable - let vi = VarInfo::new(v_enum(set! {obj.clone()}), Const, vis, Builtin, None); + let vi = VarInfo::new( + v_enum(set! {obj.clone()}), + Const, + vis, + Builtin, + None, + impl_of, + ); self.consts.insert(VarName::from_str(Str::rc(name)), obj); self.locals.insert(VarName::from_str(Str::rc(name)), vi); } @@ -116,8 +144,10 @@ impl Context { ContextKind::Trait => Type::TraitType, _ => Type::Type, }; - self.locals - .insert(name.clone(), VarInfo::new(meta_t, muty, vis, Builtin, None)); + self.locals.insert( + name.clone(), + VarInfo::new(meta_t, muty, vis, Builtin, None, None), + ); self.consts .insert(name.clone(), ValueObj::builtin_t(t.clone())); for impl_trait in ctx.super_traits.iter() { @@ -166,8 +196,10 @@ impl Context { ContextKind::Trait => Type::TraitType, _ => Type::Type, }; - self.locals - .insert(name.clone(), VarInfo::new(meta_t, muty, vis, Builtin, None)); + self.locals.insert( + name.clone(), + VarInfo::new(meta_t, muty, vis, Builtin, None, None), + ); self.consts .insert(name.clone(), ValueObj::builtin_t(t.clone())); for impl_trait in ctx.super_traits.iter() { @@ -215,8 +247,10 @@ impl Context { panic!("{} has already been registered", name); } else { let name = VarName::from_static(name); - self.locals - .insert(name.clone(), VarInfo::new(Patch, muty, vis, Builtin, None)); + self.locals.insert( + name.clone(), + VarInfo::new(Patch, muty, vis, Builtin, None, None), + ); for method_name in ctx.locals.keys() { if let Some(patches) = self.method_impl_patches.get_mut(method_name) { patches.push(name.clone()); @@ -231,25 +265,10 @@ impl Context { fn init_builtin_consts(&mut self) { // TODO: this is not a const, but a special property - self.register_builtin_impl("__name__", Str, Immutable, Private); - self.register_builtin_impl( - "license", - mono("_sitebuiltins._Printer"), - Immutable, - Private, - ); - self.register_builtin_impl( - "credits", - mono("_sitebuiltins._Printer"), - Immutable, - Private, - ); - self.register_builtin_impl( - "copyright", - mono("_sitebuiltins._Printer"), - Immutable, - Private, - ); + self.register_builtin_immutable_private_var("__name__", Str); + self.register_builtin_immutable_private_var("license", mono("_sitebuiltins._Printer")); + self.register_builtin_immutable_private_var("credits", mono("_sitebuiltins._Printer")); + self.register_builtin_immutable_private_var("copyright", mono("_sitebuiltins._Printer")); } /// see std/prelude.er @@ -519,12 +538,12 @@ impl Context { Public, ); obj.register_builtin_impl("__bytes__", fn0_met(Obj, mono("Bytes")), Immutable, Public); - let mut obj_in = Self::builtin_methods("In", 2); + let mut obj_in = Self::builtin_methods(Some(poly("In", vec![ty_tp(Type)])), 2); obj_in.register_builtin_impl("__in__", fn1_met(Obj, Type, Bool), Const, Public); - obj.register_trait(Obj, poly("In", vec![ty_tp(Type)]), obj_in); - let mut obj_mutizable = Self::builtin_methods("Mutizable", 1); + obj.register_trait(Obj, obj_in); + let mut obj_mutizable = Self::builtin_methods(Some(mono("Mutizable")), 1); obj_mutizable.register_builtin_const("MutType!", Public, ValueObj::builtin_t(mono("Obj!"))); - obj.register_trait(Obj, mono("Mutizable"), obj_mutizable); + obj.register_trait(Obj, obj_mutizable); // Obj does not implement Eq /* Float */ @@ -536,53 +555,51 @@ impl Context { float.register_builtin_impl("Imag", Float, Const, Public); float.register_marker_trait(mono("Num")); float.register_marker_trait(mono("Ord")); - let mut float_partial_ord = Self::builtin_methods("PartialOrd", 2); + let mut float_partial_ord = + Self::builtin_methods(Some(poly("PartialOrd", vec![ty_tp(Float)])), 2); float_partial_ord.register_builtin_impl( "__cmp__", fn1_met(Float, Float, mono("Ordering")), Const, Public, ); - float.register_trait( - Float, - poly("PartialOrd", vec![ty_tp(Float)]), - float_partial_ord, - ); + float.register_trait(Float, float_partial_ord); // Float doesn't have an `Eq` implementation let op_t = fn1_met(Float, Float, Float); - let mut float_add = Self::builtin_methods("Add", 2); + let mut float_add = Self::builtin_methods(Some(poly("Add", vec![ty_tp(Float)])), 2); float_add.register_builtin_impl("__add__", op_t.clone(), Const, Public); float_add.register_builtin_const("Output", Public, ValueObj::builtin_t(Float)); - float.register_trait(Float, poly("Add", vec![ty_tp(Float)]), float_add); - let mut float_sub = Self::builtin_methods("Sub", 2); + float.register_trait(Float, float_add); + let mut float_sub = Self::builtin_methods(Some(poly("Sub", vec![ty_tp(Float)])), 2); float_sub.register_builtin_impl("__sub__", op_t.clone(), Const, Public); float_sub.register_builtin_const("Output", Public, ValueObj::builtin_t(Float)); - float.register_trait(Float, poly("Sub", vec![ty_tp(Float)]), float_sub); - let mut float_mul = Self::builtin_methods("Mul", 2); + float.register_trait(Float, float_sub); + let mut float_mul = Self::builtin_methods(Some(poly("Mul", vec![ty_tp(Float)])), 2); float_mul.register_builtin_impl("__mul__", op_t.clone(), Const, Public); float_mul.register_builtin_const("Output", Public, ValueObj::builtin_t(Float)); float_mul.register_builtin_const("PowOutput", Public, ValueObj::builtin_t(Float)); - float.register_trait(Float, poly("Mul", vec![ty_tp(Float)]), float_mul); - let mut float_div = Self::builtin_methods("Div", 2); + float.register_trait(Float, float_mul); + let mut float_div = Self::builtin_methods(Some(poly("Div", vec![ty_tp(Float)])), 2); float_div.register_builtin_impl("__div__", op_t.clone(), Const, Public); float_div.register_builtin_const("Output", Public, ValueObj::builtin_t(Float)); float_div.register_builtin_const("ModOutput", Public, ValueObj::builtin_t(Float)); - float.register_trait(Float, poly("Div", vec![ty_tp(Float)]), float_div); - let mut float_floordiv = Self::builtin_methods("FloorDiv", 2); + float.register_trait(Float, float_div); + let mut float_floordiv = + Self::builtin_methods(Some(poly("FloorDiv", vec![ty_tp(Float)])), 2); float_floordiv.register_builtin_impl("__floordiv__", op_t, Const, Public); float_floordiv.register_builtin_const("Output", Public, ValueObj::builtin_t(Float)); - float.register_trait(Float, poly("FloorDiv", vec![ty_tp(Float)]), float_floordiv); - let mut float_mutizable = Self::builtin_methods("Mutizable", 2); + float.register_trait(Float, float_floordiv); + let mut float_mutizable = Self::builtin_methods(Some(mono("Mutizable")), 2); float_mutizable.register_builtin_const( "MutType!", Public, ValueObj::builtin_t(mono("Float!")), ); - float.register_trait(Float, mono("Mutizable"), float_mutizable); - let mut float_show = Self::builtin_methods("Show", 1); + float.register_trait(Float, float_mutizable); + let mut float_show = Self::builtin_methods(Some(mono("Show")), 1); let t = fn0_met(Float, Str); float_show.register_builtin_impl("to_str", t, Immutable, Public); - float.register_trait(Float, mono("Show"), float_show); + float.register_trait(Float, float_show); /* Ratio */ // TODO: Int, Nat, Boolの継承元をRatioにする(今はFloat) @@ -592,55 +609,53 @@ impl Context { ratio.register_builtin_impl("Imag", Ratio, Const, Public); ratio.register_marker_trait(mono("Num")); ratio.register_marker_trait(mono("Ord")); - let mut ratio_partial_ord = Self::builtin_methods("PartialOrd", 2); + let mut ratio_partial_ord = + Self::builtin_methods(Some(poly("PartialOrd", vec![ty_tp(Ratio)])), 2); ratio_partial_ord.register_builtin_impl( "__cmp__", fn1_met(Ratio, Ratio, mono("Ordering")), Const, Public, ); - ratio.register_trait( - Ratio, - poly("PartialOrd", vec![ty_tp(Ratio)]), - ratio_partial_ord, - ); - let mut ratio_eq = Self::builtin_methods("Eq", 2); + ratio.register_trait(Ratio, ratio_partial_ord); + let mut ratio_eq = Self::builtin_methods(Some(poly("Eq", vec![ty_tp(Ratio)])), 2); ratio_eq.register_builtin_impl("__eq__", fn1_met(Ratio, Ratio, Bool), Const, Public); - ratio.register_trait(Ratio, poly("Eq", vec![ty_tp(Ratio)]), ratio_eq); + ratio.register_trait(Ratio, ratio_eq); let op_t = fn1_met(Ratio, Ratio, Ratio); - let mut ratio_add = Self::builtin_methods("Add", 2); + let mut ratio_add = Self::builtin_methods(Some(poly("Add", vec![ty_tp(Ratio)])), 2); ratio_add.register_builtin_impl("__add__", op_t.clone(), Const, Public); ratio_add.register_builtin_const("Output", Public, ValueObj::builtin_t(Ratio)); - ratio.register_trait(Ratio, poly("Add", vec![ty_tp(Ratio)]), ratio_add); - let mut ratio_sub = Self::builtin_methods("Sub", 2); + ratio.register_trait(Ratio, ratio_add); + let mut ratio_sub = Self::builtin_methods(Some(poly("Sub", vec![ty_tp(Ratio)])), 2); ratio_sub.register_builtin_impl("__sub__", op_t.clone(), Const, Public); ratio_sub.register_builtin_const("Output", Public, ValueObj::builtin_t(Ratio)); - ratio.register_trait(Ratio, poly("Sub", vec![ty_tp(Ratio)]), ratio_sub); - let mut ratio_mul = Self::builtin_methods("Mul", 2); + ratio.register_trait(Ratio, ratio_sub); + let mut ratio_mul = Self::builtin_methods(Some(poly("Mul", vec![ty_tp(Ratio)])), 2); ratio_mul.register_builtin_impl("__mul__", op_t.clone(), Const, Public); ratio_mul.register_builtin_const("Output", Public, ValueObj::builtin_t(Ratio)); ratio_mul.register_builtin_const("PowOutput", Public, ValueObj::builtin_t(Ratio)); - ratio.register_trait(Ratio, poly("Mul", vec![ty_tp(Ratio)]), ratio_mul); - let mut ratio_div = Self::builtin_methods("Div", 2); + ratio.register_trait(Ratio, ratio_mul); + let mut ratio_div = Self::builtin_methods(Some(poly("Div", vec![ty_tp(Ratio)])), 2); ratio_div.register_builtin_impl("__div__", op_t.clone(), Const, Public); ratio_div.register_builtin_const("Output", Public, ValueObj::builtin_t(Ratio)); ratio_div.register_builtin_const("ModOutput", Public, ValueObj::builtin_t(Ratio)); - ratio.register_trait(Ratio, poly("Div", vec![ty_tp(Ratio)]), ratio_div); - let mut ratio_floordiv = Self::builtin_methods("FloorDiv", 2); + ratio.register_trait(Ratio, ratio_div); + let mut ratio_floordiv = + Self::builtin_methods(Some(poly("FloorDiv", vec![ty_tp(Ratio)])), 2); ratio_floordiv.register_builtin_impl("__floordiv__", op_t, Const, Public); ratio_floordiv.register_builtin_const("Output", Public, ValueObj::builtin_t(Ratio)); - ratio.register_trait(Ratio, poly("FloorDiv", vec![ty_tp(Ratio)]), ratio_floordiv); - let mut ratio_mutizable = Self::builtin_methods("Mutizable", 2); + ratio.register_trait(Ratio, ratio_floordiv); + let mut ratio_mutizable = Self::builtin_methods(Some(mono("Mutizable")), 2); ratio_mutizable.register_builtin_const( "MutType!", Public, ValueObj::builtin_t(mono("Ratio!")), ); - ratio.register_trait(Ratio, mono("Mutizable"), ratio_mutizable); - let mut ratio_show = Self::builtin_methods("Show", 1); + ratio.register_trait(Ratio, ratio_mutizable); + let mut ratio_show = Self::builtin_methods(Some(mono("Show")), 1); let t = fn0_met(Ratio, Str); ratio_show.register_builtin_impl("to_str", t, Immutable, Public); - ratio.register_trait(Ratio, mono("Show"), ratio_show); + ratio.register_trait(Ratio, ratio_show); /* Int */ let mut int = Self::builtin_mono_class("Int", 2); @@ -651,43 +666,44 @@ impl Context { // class("Rational"), // class("Integral"), int.register_builtin_impl("abs", fn0_met(Int, Nat), Immutable, Public); - let mut int_partial_ord = Self::builtin_methods("PartialOrd", 2); + let mut int_partial_ord = + Self::builtin_methods(Some(poly("PartialOrd", vec![ty_tp(Int)])), 2); int_partial_ord.register_builtin_impl( "__partial_cmp__", fn1_met(Int, Int, or(mono("Ordering"), NoneType)), Const, Public, ); - int.register_trait(Int, poly("PartialOrd", vec![ty_tp(Int)]), int_partial_ord); - let mut int_eq = Self::builtin_methods("Eq", 2); + int.register_trait(Int, int_partial_ord); + let mut int_eq = Self::builtin_methods(Some(poly("Eq", vec![ty_tp(Int)])), 2); int_eq.register_builtin_impl("__eq__", fn1_met(Int, Int, Bool), Const, Public); - int.register_trait(Int, poly("Eq", vec![ty_tp(Int)]), int_eq); + int.register_trait(Int, int_eq); // __div__ is not included in Int (cast to Ratio) let op_t = fn1_met(Int, Int, Int); - let mut int_add = Self::builtin_methods("Add", 2); + let mut int_add = Self::builtin_methods(Some(poly("Add", vec![ty_tp(Int)])), 2); int_add.register_builtin_impl("__add__", op_t.clone(), Const, Public); int_add.register_builtin_const("Output", Public, ValueObj::builtin_t(Int)); - int.register_trait(Int, poly("Add", vec![ty_tp(Int)]), int_add); - let mut int_sub = Self::builtin_methods("Sub", 2); + int.register_trait(Int, int_add); + let mut int_sub = Self::builtin_methods(Some(poly("Sub", vec![ty_tp(Int)])), 2); int_sub.register_builtin_impl("__sub__", op_t.clone(), Const, Public); int_sub.register_builtin_const("Output", Public, ValueObj::builtin_t(Int)); - int.register_trait(Int, poly("Sub", vec![ty_tp(Int)]), int_sub); - let mut int_mul = Self::builtin_methods("Mul", 2); + int.register_trait(Int, int_sub); + let mut int_mul = Self::builtin_methods(Some(poly("Mul", vec![ty_tp(Int)])), 2); int_mul.register_builtin_impl("__mul__", op_t.clone(), Const, Public); int_mul.register_builtin_const("Output", Public, ValueObj::builtin_t(Int)); int_mul.register_builtin_const("PowOutput", Public, ValueObj::builtin_t(Nat)); - int.register_trait(Int, poly("Mul", vec![ty_tp(Int)]), int_mul); - let mut int_floordiv = Self::builtin_methods("FloorDiv", 2); + int.register_trait(Int, int_mul); + let mut int_floordiv = Self::builtin_methods(Some(poly("FloorDiv", vec![ty_tp(Int)])), 2); int_floordiv.register_builtin_impl("__floordiv__", op_t, Const, Public); int_floordiv.register_builtin_const("Output", Public, ValueObj::builtin_t(Int)); - int.register_trait(Int, poly("FloorDiv", vec![ty_tp(Int)]), int_floordiv); - let mut int_mutizable = Self::builtin_methods("Mutizable", 2); + int.register_trait(Int, int_floordiv); + let mut int_mutizable = Self::builtin_methods(Some(mono("Mutizable")), 2); int_mutizable.register_builtin_const("MutType!", Public, ValueObj::builtin_t(mono("Int!"))); - int.register_trait(Int, mono("Mutizable"), int_mutizable); - let mut int_show = Self::builtin_methods("Show", 1); + int.register_trait(Int, int_mutizable); + let mut int_show = Self::builtin_methods(Some(mono("Show")), 1); let t = fn0_met(Int, Str); int_show.register_builtin_impl("to_str", t, Immutable, Public); - int.register_trait(Int, mono("Show"), int_show); + int.register_trait(Int, int_show); int.register_builtin_impl("Real", Int, Const, Public); int.register_builtin_impl("Imag", Int, Const, Public); @@ -710,34 +726,35 @@ impl Context { ); nat.register_marker_trait(mono("Num")); nat.register_marker_trait(mono("Ord")); - let mut nat_eq = Self::builtin_methods("Eq", 2); + let mut nat_eq = Self::builtin_methods(Some(poly("Eq", vec![ty_tp(Nat)])), 2); nat_eq.register_builtin_impl("__eq__", fn1_met(Nat, Nat, Bool), Const, Public); - nat.register_trait(Nat, poly("Eq", vec![ty_tp(Nat)]), nat_eq); - let mut nat_partial_ord = Self::builtin_methods("PartialOrd", 2); + nat.register_trait(Nat, nat_eq); + let mut nat_partial_ord = + Self::builtin_methods(Some(poly("PartialOrd", vec![ty_tp(Nat)])), 2); nat_partial_ord.register_builtin_impl( "__cmp__", fn1_met(Nat, Nat, mono("Ordering")), Const, Public, ); - nat.register_trait(Nat, poly("PartialOrd", vec![ty_tp(Nat)]), nat_partial_ord); + nat.register_trait(Nat, nat_partial_ord); // __sub__, __div__ is not included in Nat (cast to Int/ Ratio) let op_t = fn1_met(Nat, Nat, Nat); - let mut nat_add = Self::builtin_methods("Add", 2); + let mut nat_add = Self::builtin_methods(Some(poly("Add", vec![ty_tp(Nat)])), 2); nat_add.register_builtin_impl("__add__", op_t.clone(), Const, Public); nat_add.register_builtin_const("Output", Public, ValueObj::builtin_t(Nat)); - nat.register_trait(Nat, poly("Add", vec![ty_tp(Nat)]), nat_add); - let mut nat_mul = Self::builtin_methods("Mul", 2); + nat.register_trait(Nat, nat_add); + let mut nat_mul = Self::builtin_methods(Some(poly("Mul", vec![ty_tp(Nat)])), 2); nat_mul.register_builtin_impl("__mul__", op_t.clone(), Const, Public); nat_mul.register_builtin_const("Output", Public, ValueObj::builtin_t(Nat)); - nat.register_trait(Nat, poly("Mul", vec![ty_tp(Nat)]), nat_mul); - let mut nat_floordiv = Self::builtin_methods("FloorDiv", 2); + nat.register_trait(Nat, nat_mul); + let mut nat_floordiv = Self::builtin_methods(Some(poly("FloorDiv", vec![ty_tp(Nat)])), 2); nat_floordiv.register_builtin_impl("__floordiv__", op_t, Const, Public); nat_floordiv.register_builtin_const("Output", Public, ValueObj::builtin_t(Nat)); - nat.register_trait(Nat, poly("FloorDiv", vec![ty_tp(Nat)]), nat_floordiv); - let mut nat_mutizable = Self::builtin_methods("Mutizable", 2); + nat.register_trait(Nat, nat_floordiv); + let mut nat_mutizable = Self::builtin_methods(Some(mono("Mutizable")), 2); nat_mutizable.register_builtin_const("MutType!", Public, ValueObj::builtin_t(mono("Nat!"))); - nat.register_trait(Nat, mono("Mutizable"), nat_mutizable); + nat.register_trait(Nat, nat_mutizable); nat.register_builtin_impl("Real", Nat, Const, Public); nat.register_builtin_impl("Imag", Nat, Const, Public); @@ -751,31 +768,28 @@ impl Context { bool_.register_builtin_impl("__or__", fn1_met(Bool, Bool, Bool), Const, Public); bool_.register_marker_trait(mono("Num")); bool_.register_marker_trait(mono("Ord")); - let mut bool_partial_ord = Self::builtin_methods("PartialOrd", 2); + let mut bool_partial_ord = + Self::builtin_methods(Some(poly("PartialOrd", vec![ty_tp(Bool)])), 2); bool_partial_ord.register_builtin_impl( "__cmp__", fn1_met(Bool, Bool, mono("Ordering")), Const, Public, ); - bool_.register_trait( - Bool, - poly("PartialOrd", vec![ty_tp(Bool)]), - bool_partial_ord, - ); - let mut bool_eq = Self::builtin_methods("Eq", 2); + bool_.register_trait(Bool, bool_partial_ord); + let mut bool_eq = Self::builtin_methods(Some(poly("Eq", vec![ty_tp(Bool)])), 2); bool_eq.register_builtin_impl("__eq__", fn1_met(Bool, Bool, Bool), Const, Public); - bool_.register_trait(Bool, poly("Eq", vec![ty_tp(Bool)]), bool_eq); - let mut bool_mutizable = Self::builtin_methods("Mutizable", 2); + bool_.register_trait(Bool, bool_eq); + let mut bool_mutizable = Self::builtin_methods(Some(mono("Mutizable")), 2); bool_mutizable.register_builtin_const( "MutType!", Public, ValueObj::builtin_t(mono("Bool!")), ); - bool_.register_trait(Bool, mono("Mutizable"), bool_mutizable); - let mut bool_show = Self::builtin_methods("Show", 1); + bool_.register_trait(Bool, bool_mutizable); + let mut bool_show = Self::builtin_methods(Some(mono("Show")), 1); bool_show.register_builtin_impl("to_str", fn0_met(Bool, Str), Immutable, Public); - bool_.register_trait(Bool, mono("Show"), bool_show); + bool_.register_trait(Bool, bool_show); /* Str */ let mut str_ = Self::builtin_mono_class("Str", 10); str_.register_superclass(Obj, &obj); @@ -805,49 +819,49 @@ impl Context { Immutable, Public, ); - let mut str_eq = Self::builtin_methods("Eq", 2); + let mut str_eq = Self::builtin_methods(Some(poly("Eq", vec![ty_tp(Str)])), 2); str_eq.register_builtin_impl("__eq__", fn1_met(Str, Str, Bool), Const, Public); - str_.register_trait(Str, poly("Eq", vec![ty_tp(Str)]), str_eq); - let mut str_seq = Self::builtin_methods("Seq", 2); + str_.register_trait(Str, str_eq); + let mut str_seq = Self::builtin_methods(Some(poly("Seq", vec![ty_tp(Str)])), 2); str_seq.register_builtin_impl("len", fn0_met(Str, Nat), Const, Public); str_seq.register_builtin_impl("get", fn1_met(Str, Nat, Str), Const, Public); - str_.register_trait(Str, poly("Seq", vec![ty_tp(Str)]), str_seq); - let mut str_add = Self::builtin_methods("Add", 2); + str_.register_trait(Str, str_seq); + let mut str_add = Self::builtin_methods(Some(poly("Add", vec![ty_tp(Str)])), 2); str_add.register_builtin_impl("__add__", fn1_met(Str, Str, Str), Const, Public); str_add.register_builtin_const("Output", Public, ValueObj::builtin_t(Str)); - str_.register_trait(Str, poly("Add", vec![ty_tp(Str)]), str_add); - let mut str_mul = Self::builtin_methods("Mul", 2); + str_.register_trait(Str, str_add); + let mut str_mul = Self::builtin_methods(Some(poly("Mul", vec![ty_tp(Nat)])), 2); str_mul.register_builtin_impl("__mul__", fn1_met(Str, Nat, Str), Const, Public); str_mul.register_builtin_const("Output", Public, ValueObj::builtin_t(Str)); - str_.register_trait(Str, poly("Mul", vec![ty_tp(Nat)]), str_mul); - let mut str_mutizable = Self::builtin_methods("Mutizable", 2); + str_.register_trait(Str, str_mul); + let mut str_mutizable = Self::builtin_methods(Some(mono("Mutizable")), 2); str_mutizable.register_builtin_const("MutType!", Public, ValueObj::builtin_t(mono("Str!"))); - str_.register_trait(Str, mono("Mutizable"), str_mutizable); - let mut str_show = Self::builtin_methods("Show", 1); + str_.register_trait(Str, str_mutizable); + let mut str_show = Self::builtin_methods(Some(mono("Show")), 1); str_show.register_builtin_impl("to_str", fn0_met(Str, Str), Immutable, Public); - str_.register_trait(Str, mono("Show"), str_show); - let mut str_iterable = Self::builtin_methods("Iterable", 2); + str_.register_trait(Str, str_show); + let mut str_iterable = Self::builtin_methods(Some(poly("Iterable", vec![ty_tp(Str)])), 2); str_iterable.register_builtin_impl( "iter", fn0_met(Str, mono("StrIterator")), Immutable, Public, ); - str_.register_trait(Str, poly("Iterable", vec![ty_tp(Str)]), str_iterable); + str_.register_trait(Str, str_iterable); /* NoneType */ let mut nonetype = Self::builtin_mono_class("NoneType", 10); nonetype.register_superclass(Obj, &obj); - let mut nonetype_eq = Self::builtin_methods("Eq", 2); + let mut nonetype_eq = Self::builtin_methods(Some(poly("Eq", vec![ty_tp(NoneType)])), 2); nonetype_eq.register_builtin_impl( "__eq__", fn1_met(NoneType, NoneType, Bool), Const, Public, ); - nonetype.register_trait(NoneType, poly("Eq", vec![ty_tp(NoneType)]), nonetype_eq); - let mut nonetype_show = Self::builtin_methods("Show", 1); + nonetype.register_trait(NoneType, nonetype_eq); + let mut nonetype_show = Self::builtin_methods(Some(mono("Show")), 1); nonetype_show.register_builtin_impl("to_str", fn0_met(NoneType, Str), Immutable, Public); - nonetype.register_trait(NoneType, mono("Show"), nonetype_show); + nonetype.register_trait(NoneType, nonetype_show); /* Type */ let mut type_ = Self::builtin_mono_class("Type", 2); type_.register_superclass(Obj, &obj); @@ -858,47 +872,44 @@ impl Context { Public, ); type_.register_marker_trait(mono("Named")); - let mut type_eq = Self::builtin_methods("Eq", 2); + let mut type_eq = Self::builtin_methods(Some(poly("Eq", vec![ty_tp(Type)])), 2); type_eq.register_builtin_impl("__eq__", fn1_met(Type, Type, Bool), Const, Public); - type_.register_trait(Type, poly("Eq", vec![ty_tp(Type)]), type_eq); + type_.register_trait(Type, type_eq); let mut class_type = Self::builtin_mono_class("ClassType", 2); class_type.register_superclass(Type, &type_); class_type.register_marker_trait(mono("Named")); - let mut class_eq = Self::builtin_methods("Eq", 2); + let mut class_eq = Self::builtin_methods(Some(poly("Eq", vec![ty_tp(ClassType)])), 2); class_eq.register_builtin_impl( "__eq__", fn1_met(ClassType, ClassType, Bool), Const, Public, ); - class_type.register_trait(ClassType, poly("Eq", vec![ty_tp(ClassType)]), class_eq); + class_type.register_trait(ClassType, class_eq); let mut trait_type = Self::builtin_mono_class("TraitType", 2); trait_type.register_superclass(Type, &type_); trait_type.register_marker_trait(mono("Named")); - let mut trait_eq = Self::builtin_methods("Eq", 2); + let mut trait_eq = Self::builtin_methods(Some(poly("Eq", vec![ty_tp(TraitType)])), 2); trait_eq.register_builtin_impl( "__eq__", fn1_met(TraitType, TraitType, Bool), Const, Public, ); - trait_type.register_trait(TraitType, poly("Eq", vec![ty_tp(TraitType)]), trait_eq); + trait_type.register_trait(TraitType, trait_eq); let g_module_t = mono("GenericModule"); let mut generic_module = Self::builtin_mono_class("GenericModule", 2); generic_module.register_superclass(Obj, &obj); generic_module.register_marker_trait(mono("Named")); - let mut generic_module_eq = Self::builtin_methods("Eq", 2); + let mut generic_module_eq = + Self::builtin_methods(Some(poly("Eq", vec![ty_tp(g_module_t.clone())])), 2); generic_module_eq.register_builtin_impl( "__eq__", fn1_met(g_module_t.clone(), g_module_t.clone(), Bool), Const, Public, ); - generic_module.register_trait( - g_module_t.clone(), - poly("Eq", vec![ty_tp(g_module_t.clone())]), - generic_module_eq, - ); + generic_module.register_trait(g_module_t.clone(), generic_module_eq); let module_t = module(mono_q_tp("Path")); let mut module = Self::builtin_poly_class("Module", vec![PS::named_nd("Path", Str)], 2); module.register_superclass(g_module_t.clone(), &generic_module); @@ -961,35 +972,28 @@ impl Context { None, ))); array_.register_builtin_const("__getitem__", Public, get_item); - let mut array_eq = Self::builtin_methods("Eq", 2); + let mut array_eq = Self::builtin_methods(Some(poly("Eq", vec![ty_tp(arr_t.clone())])), 2); array_eq.register_builtin_impl( "__eq__", fn1_met(arr_t.clone(), arr_t.clone(), Bool), Const, Public, ); - array_.register_trait( - arr_t.clone(), - poly("Eq", vec![ty_tp(arr_t.clone())]), - array_eq, - ); + array_.register_trait(arr_t.clone(), array_eq); array_.register_marker_trait(mono("Mutizable")); array_.register_marker_trait(poly("Seq", vec![ty_tp(mono_q("T"))])); - let mut array_show = Self::builtin_methods("Show", 1); + let mut array_show = Self::builtin_methods(Some(mono("Show")), 1); array_show.register_builtin_impl("to_str", fn0_met(arr_t.clone(), Str), Immutable, Public); - array_.register_trait(arr_t.clone(), mono("Show"), array_show); - let mut array_iterable = Self::builtin_methods("Iterable", 2); + array_.register_trait(arr_t.clone(), array_show); + let mut array_iterable = + Self::builtin_methods(Some(poly("Iterable", vec![ty_tp(mono_q("T"))])), 2); array_iterable.register_builtin_impl( "iter", fn0_met(Str, mono("ArrayIterator")), Immutable, Public, ); - array_.register_trait( - arr_t.clone(), - poly("Iterable", vec![ty_tp(mono_q("T"))]), - array_iterable, - ); + array_.register_trait(arr_t.clone(), array_iterable); /* Set */ let mut set_ = Self::builtin_poly_class("Set", vec![PS::t_nd("T"), PS::named_nd("N", Nat)], 10); @@ -1015,38 +1019,31 @@ impl Context { vec![TyParam::t(mono_q("T")), TyParam::mono_q("N").mutate()], )); set_.register_builtin_const("MutType!", Public, mut_type); - let mut set_eq = Self::builtin_methods("Eq", 2); + let mut set_eq = Self::builtin_methods(Some(poly("Eq", vec![ty_tp(set_t.clone())])), 2); set_eq.register_builtin_impl( "__eq__", fn1_met(set_t.clone(), set_t.clone(), Bool), Const, Public, ); - set_.register_trait( - set_t.clone(), - poly("Eq", vec![ty_tp(set_t.clone())]), - set_eq, - ); + set_.register_trait(set_t.clone(), set_eq); set_.register_marker_trait(mono("Mutizable")); set_.register_marker_trait(poly("Seq", vec![ty_tp(mono_q("T"))])); - let mut set_show = Self::builtin_methods("Show", 1); + let mut set_show = Self::builtin_methods(Some(mono("Show")), 1); set_show.register_builtin_impl("to_str", fn0_met(set_t.clone(), Str), Immutable, Public); - set_.register_trait(set_t.clone(), mono("Show"), set_show); + set_.register_trait(set_t.clone(), set_show); let g_dict_t = mono("GenericDict"); let mut generic_dict = Self::builtin_mono_class("GenericDict", 2); generic_dict.register_superclass(Obj, &obj); - let mut generic_dict_eq = Self::builtin_methods("Eq", 2); + let mut generic_dict_eq = + Self::builtin_methods(Some(poly("Eq", vec![ty_tp(g_dict_t.clone())])), 2); generic_dict_eq.register_builtin_impl( "__eq__", fn1_met(g_dict_t.clone(), g_dict_t.clone(), Bool), Const, Public, ); - generic_dict.register_trait( - g_dict_t.clone(), - poly("Eq", vec![ty_tp(g_dict_t.clone())]), - generic_dict_eq, - ); + generic_dict.register_trait(g_dict_t.clone(), generic_dict_eq); let dict_t = poly("Dict", vec![mono_q_tp("D")]); let mut dict_ = // TODO: D <: GenericDict @@ -1075,18 +1072,15 @@ impl Context { bytes.register_superclass(Obj, &obj); let mut generic_tuple = Self::builtin_mono_class("GenericTuple", 1); generic_tuple.register_superclass(Obj, &obj); - let mut tuple_eq = Self::builtin_methods("Eq", 2); + let mut tuple_eq = + Self::builtin_methods(Some(poly("Eq", vec![ty_tp(mono("GenericTuple"))])), 2); tuple_eq.register_builtin_impl( "__eq__", fn1_met(mono("GenericTuple"), mono("GenericTuple"), Bool), Const, Public, ); - generic_tuple.register_trait( - mono("GenericTuple"), - poly("Eq", vec![ty_tp(mono("GenericTuple"))]), - tuple_eq, - ); + generic_tuple.register_trait(mono("GenericTuple"), tuple_eq); // Ts <: GenericArray let tuple_t = poly("Tuple", vec![mono_q_tp("Ts")]); let mut tuple_ = @@ -1120,7 +1114,7 @@ impl Context { /* Float_mut */ let mut float_mut = Self::builtin_mono_class("Float!", 2); float_mut.register_superclass(Float, &float); - let mut float_mut_mutable = Self::builtin_methods("Mutable", 2); + let mut float_mut_mutable = Self::builtin_methods(Some(mono("Mutable")), 2); float_mut_mutable.register_builtin_const("ImmutType", Public, ValueObj::builtin_t(Float)); let f_t = kw("f", func(vec![kw("old", Float)], None, vec![], Float)); let t = pr_met( @@ -1131,11 +1125,11 @@ impl Context { NoneType, ); float_mut_mutable.register_builtin_impl("update!", t, Immutable, Public); - float_mut.register_trait(mono("Float!"), mono("Mutable"), float_mut_mutable); + float_mut.register_trait(mono("Float!"), float_mut_mutable); /* Ratio_mut */ let mut ratio_mut = Self::builtin_mono_class("Ratio!", 2); ratio_mut.register_superclass(Ratio, &ratio); - let mut ratio_mut_mutable = Self::builtin_methods("Mutable", 2); + let mut ratio_mut_mutable = Self::builtin_methods(Some(mono("Mutable")), 2); ratio_mut_mutable.register_builtin_const("ImmutType", Public, ValueObj::builtin_t(Ratio)); let f_t = kw("f", func(vec![kw("old", Ratio)], None, vec![], Ratio)); let t = pr_met( @@ -1146,12 +1140,12 @@ impl Context { NoneType, ); ratio_mut_mutable.register_builtin_impl("update!", t, Immutable, Public); - ratio_mut.register_trait(mono("Ratio!"), mono("Mutable"), ratio_mut_mutable); + ratio_mut.register_trait(mono("Ratio!"), ratio_mut_mutable); /* Int_mut */ let mut int_mut = Self::builtin_mono_class("Int!", 2); int_mut.register_superclass(Int, &int); int_mut.register_superclass(mono("Float!"), &float_mut); - let mut int_mut_mutable = Self::builtin_methods("Mutable", 2); + let mut int_mut_mutable = Self::builtin_methods(Some(mono("Mutable")), 2); int_mut_mutable.register_builtin_const("ImmutType", Public, ValueObj::builtin_t(Int)); let f_t = kw("f", func(vec![kw("old", Int)], None, vec![], Int)); let t = pr_met( @@ -1162,12 +1156,12 @@ impl Context { NoneType, ); int_mut_mutable.register_builtin_impl("update!", t, Immutable, Public); - int_mut.register_trait(mono("Int!"), mono("Mutable"), int_mut_mutable); + int_mut.register_trait(mono("Int!"), int_mut_mutable); let mut nat_mut = Self::builtin_mono_class("Nat!", 2); nat_mut.register_superclass(Nat, &nat); nat_mut.register_superclass(mono("Int!"), &int_mut); /* Nat_mut */ - let mut nat_mut_mutable = Self::builtin_methods("Mutable", 2); + let mut nat_mut_mutable = Self::builtin_methods(Some(mono("Mutable")), 2); nat_mut_mutable.register_builtin_const("ImmutType", Public, ValueObj::builtin_t(Nat)); let f_t = kw("f", func(vec![kw("old", Nat)], None, vec![], Nat)); let t = pr_met( @@ -1178,12 +1172,12 @@ impl Context { NoneType, ); nat_mut_mutable.register_builtin_impl("update!", t, Immutable, Public); - nat_mut.register_trait(mono("Nat!"), mono("Mutable"), nat_mut_mutable); + nat_mut.register_trait(mono("Nat!"), nat_mut_mutable); /* Bool_mut */ let mut bool_mut = Self::builtin_mono_class("Bool!", 2); bool_mut.register_superclass(Bool, &bool_); bool_mut.register_superclass(mono("Nat!"), &nat_mut); - let mut bool_mut_mutable = Self::builtin_methods("Mutable", 2); + let mut bool_mut_mutable = Self::builtin_methods(Some(mono("Mutable")), 2); bool_mut_mutable.register_builtin_const("ImmutType", Public, ValueObj::builtin_t(Bool)); let f_t = kw("f", func(vec![kw("old", Bool)], None, vec![], Bool)); let t = pr_met( @@ -1194,11 +1188,11 @@ impl Context { NoneType, ); bool_mut_mutable.register_builtin_impl("update!", t, Immutable, Public); - bool_mut.register_trait(mono("Bool!"), mono("Mutable"), bool_mut_mutable); + bool_mut.register_trait(mono("Bool!"), bool_mut_mutable); /* Str_mut */ let mut str_mut = Self::builtin_mono_class("Str!", 2); str_mut.register_superclass(Str, &nonetype); - let mut str_mut_mutable = Self::builtin_methods("Mutable", 2); + let mut str_mut_mutable = Self::builtin_methods(Some(mono("Mutable")), 2); str_mut_mutable.register_builtin_const("ImmutType", Public, ValueObj::builtin_t(Str)); let f_t = kw("f", func(vec![kw("old", Str)], None, vec![], Str)); let t = pr_met( @@ -1209,10 +1203,10 @@ impl Context { NoneType, ); str_mut_mutable.register_builtin_impl("update!", t, Immutable, Public); - str_mut.register_trait(mono("Str!"), mono("Mutable"), str_mut_mutable); + str_mut.register_trait(mono("Str!"), str_mut_mutable); /* File_mut */ let mut file_mut = Self::builtin_mono_class("File!", 2); - let mut file_mut_readable = Self::builtin_methods("Readable!", 1); + let mut file_mut_readable = Self::builtin_methods(Some(mono("Readable!")), 1); file_mut_readable.register_builtin_impl( "read!", pr_met( @@ -1225,15 +1219,15 @@ impl Context { Immutable, Public, ); - file_mut.register_trait(mono("File!"), mono("Readable!"), file_mut_readable); - let mut file_mut_writable = Self::builtin_methods("Writable!", 1); + file_mut.register_trait(mono("File!"), file_mut_readable); + let mut file_mut_writable = Self::builtin_methods(Some(mono("Writable!")), 1); file_mut_writable.register_builtin_impl( "write!", pr1_kw_met(ref_mut(mono("File!"), None), kw("s", Str), Nat), Immutable, Public, ); - file_mut.register_trait(mono("File!"), mono("Writable!"), file_mut_writable); + file_mut.register_trait(mono("File!"), file_mut_writable); /* Array_mut */ let array_mut_t = poly("Array!", vec![ty_tp(mono_q("T")), mono_q_tp("N")]); let mut array_mut_ = Self::builtin_poly_class( @@ -1283,9 +1277,9 @@ impl Context { vec![], NoneType, ); - let mut array_mut_mutable = Self::builtin_methods("Mutable", 2); + let mut array_mut_mutable = Self::builtin_methods(Some(mono("Mutable")), 2); array_mut_mutable.register_builtin_impl("update!", t, Immutable, Public); - array_mut_.register_trait(array_mut_t.clone(), mono("Mutable"), array_mut_mutable); + array_mut_.register_trait(array_mut_t.clone(), array_mut_mutable); /* Set_mut */ let set_mut_t = poly("Set!", vec![ty_tp(mono_q("T")), mono_q_tp("N")]); let mut set_mut_ = Self::builtin_poly_class( @@ -1336,27 +1330,23 @@ impl Context { vec![], NoneType, ); - let mut set_mut_mutable = Self::builtin_methods("Mutable", 2); + let mut set_mut_mutable = Self::builtin_methods(Some(mono("Mutable")), 2); set_mut_mutable.register_builtin_impl("update!", t, Immutable, Public); - set_mut_.register_trait(set_mut_t.clone(), mono("Mutable"), set_mut_mutable); + set_mut_.register_trait(set_mut_t.clone(), set_mut_mutable); /* Range */ let range_t = poly("Range", vec![TyParam::t(mono_q("T"))]); let mut range = Self::builtin_poly_class("Range", vec![PS::t_nd("T")], 2); // range.register_superclass(Obj, &obj); range.register_superclass(Type, &type_); range.register_marker_trait(poly("Output", vec![ty_tp(mono_q("T"))])); - let mut range_eq = Self::builtin_methods("Eq", 2); + let mut range_eq = Self::builtin_methods(Some(poly("Eq", vec![ty_tp(range_t.clone())])), 2); range_eq.register_builtin_impl( "__eq__", fn1_met(range_t.clone(), range_t.clone(), Bool), Const, Public, ); - range.register_trait( - range_t.clone(), - poly("Eq", vec![ty_tp(range_t.clone())]), - range_eq, - ); + range.register_trait(range_t.clone(), range_eq); /* Proc */ let mut proc = Self::builtin_mono_class("Proc", 2); proc.register_superclass(Obj, &obj); @@ -1816,28 +1806,27 @@ impl Context { PS::named_nd("O", Int), PS::named_nd("P", Int), ]; + let class = Type::from(&m..=&n); // Interval is a bounding patch connecting M..N and (Add(O..P, M+O..N..P), Sub(O..P, M-P..N-O)) - let mut interval = Self::builtin_poly_patch("Interval", Type::from(&m..=&n), params, 2); + let mut interval = Self::builtin_poly_patch("Interval", class.clone(), params, 2); let op_t = fn1_met( - Type::from(&m..=&n), + class.clone(), Type::from(&o..=&p), Type::from(m.clone() + o.clone()..=n.clone() + p.clone()), ); - let mut interval_add = Self::builtin_methods("Add", 2); + let mut interval_add = + Self::builtin_methods(Some(poly("Add", vec![TyParam::from(&o..=&p)])), 2); interval_add.register_builtin_impl("__add__", op_t, Const, Public); interval_add.register_builtin_const( "Output", Public, ValueObj::builtin_t(Type::from(m.clone() + o.clone()..=n.clone() + p.clone())), ); - interval.register_trait( - Type::from(&m..=&n), - poly("Add", vec![TyParam::from(&o..=&p)]), - interval_add, - ); - let mut interval_sub = Self::builtin_methods("Sub", 2); + interval.register_trait(class.clone(), interval_add); + let mut interval_sub = + Self::builtin_methods(Some(poly("Sub", vec![TyParam::from(&o..=&p)])), 2); let op_t = fn1_met( - Type::from(&m..=&n), + class.clone(), Type::from(&o..=&p), Type::from(m.clone() - p.clone()..=n.clone() - o.clone()), ); @@ -1845,13 +1834,9 @@ impl Context { interval_sub.register_builtin_const( "Output", Public, - ValueObj::builtin_t(Type::from(m.clone() - p.clone()..=n.clone() - o.clone())), - ); - interval.register_trait( - Type::from(&m..=&n), - poly("Sub", vec![TyParam::from(&o..=&p)]), - interval_sub, + ValueObj::builtin_t(Type::from(m - p..=n - o)), ); + interval.register_trait(class, interval_sub); self.register_builtin_patch("Interval", interval, Private, Const); // eq.register_impl("__ne__", op_t, Const, Public); // ord.register_impl("__le__", op_t.clone(), Const, Public); diff --git a/compiler/erg_compiler/context/inquire.rs b/compiler/erg_compiler/context/inquire.rs index 6a43e977..11c46c34 100644 --- a/compiler/erg_compiler/context/inquire.rs +++ b/compiler/erg_compiler/context/inquire.rs @@ -1150,9 +1150,9 @@ impl Context { if let Some(obj) = self.consts.get(name.inspect()) { Ok(obj.clone()) } else { - if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) { + /*if let Some(parent) = self.get_outer().or_else(|| self.get_builtins()) { return parent.get_const_local(name, namespace); - } + }*/ Err(TyCheckError::no_var_error( self.cfg.input.clone(), line!() as usize, diff --git a/compiler/erg_compiler/context/mod.rs b/compiler/erg_compiler/context/mod.rs index dbe1e4a2..80547feb 100644 --- a/compiler/erg_compiler/context/mod.rs +++ b/compiler/erg_compiler/context/mod.rs @@ -225,7 +225,7 @@ pub enum ContextKind { Func, Proc, Class, - MethodDefs, + MethodDefs(Option), // Type: trait implemented Trait, StructuralTrait, Patch(Type), @@ -250,7 +250,7 @@ impl From for ContextKind { impl ContextKind { pub const fn is_method_def(&self) -> bool { - matches!(self, Self::MethodDefs) + matches!(self, Self::MethodDefs(_)) } pub const fn is_type(&self) -> bool { @@ -462,13 +462,13 @@ impl Context { let idx = ParamIdx::Nth(idx); let kind = VarKind::parameter(id, idx, param.default_info); let muty = Mutability::from(name); - let vi = VarInfo::new(param.t, muty, Private, kind, None); + let vi = VarInfo::new(param.t, muty, Private, kind, None, None); params_.push((Some(VarName::new(Token::static_symbol(name))), vi)); } else { let idx = ParamIdx::Nth(idx); let kind = VarKind::parameter(id, idx, param.default_info); let muty = Mutability::Immutable; - let vi = VarInfo::new(param.t, muty, Private, kind, None); + let vi = VarInfo::new(param.t, muty, Private, kind, None, None); params_.push((None, vi)); } } @@ -677,18 +677,23 @@ impl Context { } #[inline] - pub fn methods>( - name: S, + pub fn methods( + impl_trait: Option, cfg: ErgConfig, mod_cache: Option, py_mod_cache: Option, capacity: usize, level: usize, ) -> Self { + let name = if let Some(tr) = &impl_trait { + tr.local_name() + } else { + Str::ever("Methods") + }; Self::with_capacity( - name.into(), + name, cfg, - ContextKind::MethodDefs, + ContextKind::MethodDefs(impl_trait), vec![], None, mod_cache, @@ -699,9 +704,9 @@ impl Context { } #[inline] - pub fn builtin_methods>(name: S, capacity: usize) -> Self { + pub fn builtin_methods(impl_trait: Option, capacity: usize) -> Self { Self::methods( - name, + impl_trait, ErgConfig::default(), None, None, @@ -811,6 +816,14 @@ impl Context { self.outer.as_ref().map(|x| x.as_ref()) } + pub(crate) fn impl_of(&self) -> Option { + if let ContextKind::MethodDefs(Some(tr)) = &self.kind { + Some(tr.clone()) + } else { + None + } + } + pub(crate) fn path(&self) -> Str { // NOTE: this need to be changed if we want to support nested classes/traits if let Some(outer) = self.get_outer() { diff --git a/compiler/erg_compiler/context/register.rs b/compiler/erg_compiler/context/register.rs index 94295789..047a7aa3 100644 --- a/compiler/erg_compiler/context/register.rs +++ b/compiler/erg_compiler/context/register.rs @@ -86,7 +86,7 @@ impl Context { } else { self.decls.insert( ident.name.clone(), - VarInfo::new(sig_t, muty, vis, kind, None), + VarInfo::new(sig_t, muty, vis, kind, None, self.impl_of()), ); Ok(()) } @@ -121,11 +121,12 @@ impl Context { vis, kind.clone(), Some(comptime_decos.clone()), + self.impl_of(), ); self.decls.insert(sig.ident.name.clone(), vi); e })?; - let vi = VarInfo::new(t, muty, vis, kind, Some(comptime_decos)); + let vi = VarInfo::new(t, muty, vis, kind, Some(comptime_decos), self.impl_of()); if let Some(_decl) = self.decls.remove(name) { Err(TyCheckErrors::from(TyCheckError::duplicate_decl_error( self.cfg.input.clone(), @@ -161,7 +162,15 @@ impl Context { let generalized = self.generalize_t(body_t.clone()); self.decls.remove(ident.inspect()); let vis = ident.vis(); - let vi = VarInfo::new(generalized, muty, vis, VarKind::Defined(id), None); + let vi = VarInfo::new( + generalized, + muty, + vis, + VarKind::Defined(id), + None, + self.impl_of(), + ); + log!(info "Registered {}::{}: {} {:?}", self.name, ident.name, vi.t, vi.impl_of); self.locals.insert(ident.name.clone(), vi); Ok(()) } @@ -211,7 +220,7 @@ impl Context { let muty = Mutability::from(&name.inspect()[..]); self.params.push(( Some(name.clone()), - VarInfo::new(spec_t, muty, Private, kind, None), + VarInfo::new(spec_t, muty, Private, kind, None, None), )); Ok(()) } @@ -250,7 +259,7 @@ impl Context { VarKind::parameter(DefId(get_hash(&(&self.name, name))), idx, default); self.params.push(( Some(name.clone()), - VarInfo::new(spec_t, Immutable, Private, kind, None), + VarInfo::new(spec_t, Immutable, Private, kind, None, None), )); Ok(()) } @@ -289,7 +298,7 @@ impl Context { VarKind::parameter(DefId(get_hash(&(&self.name, name))), idx, default); self.params.push(( Some(name.clone()), - VarInfo::new(spec_t, Immutable, Private, kind, None), + VarInfo::new(spec_t, Immutable, Private, kind, None, None), )); Ok(()) } @@ -451,9 +460,10 @@ impl Context { sig.ident.vis(), VarKind::Defined(id), Some(comptime_decos), + self.impl_of(), ); let t = vi.t.clone(); - log!(info "Registered {}::{name}: {}", self.name, t); + log!(info "Registered {}::{name}: {t}", self.name); self.locals.insert(name.clone(), vi); Ok(t) } @@ -487,6 +497,7 @@ impl Context { sig.ident.vis(), VarKind::DoesNotExist, Some(comptime_decos), + self.impl_of(), ); log!(info "Registered {}::{name}: {}", self.name, &vi.t); self.locals.insert(name.clone(), vi); @@ -576,8 +587,10 @@ impl Context { if self.locals.get(&name).is_some() { panic!("already registered: {name}"); } else { - self.locals - .insert(name, VarInfo::new(t, muty, vis, VarKind::Auto, None)); + self.locals.insert( + name, + VarInfo::new(t, muty, vis, VarKind::Auto, None, self.impl_of()), + ); } } @@ -593,33 +606,55 @@ impl Context { if self.locals.get(&name).is_some() { panic!("already registered: {name}"); } else { - self.locals - .insert(name, VarInfo::new(t, muty, vis, VarKind::FixedAuto, None)); + self.locals.insert( + name, + VarInfo::new(t, muty, vis, VarKind::FixedAuto, None, self.impl_of()), + ); } } - fn _register_gen_decl(&mut self, name: VarName, t: Type, vis: Visibility) { + fn _register_gen_decl( + &mut self, + name: VarName, + t: Type, + vis: Visibility, + impl_of: Option, + ) { if self.decls.get(&name).is_some() { panic!("already registered: {name}"); } else { self.decls.insert( name, - VarInfo::new(t, Immutable, vis, VarKind::Declared, None), + VarInfo::new(t, Immutable, vis, VarKind::Declared, None, impl_of), ); } } - fn _register_gen_impl(&mut self, name: VarName, t: Type, muty: Mutability, vis: Visibility) { + fn _register_gen_impl( + &mut self, + name: VarName, + t: Type, + muty: Mutability, + vis: Visibility, + impl_of: Option, + ) { if self.locals.get(&name).is_some() { panic!("already registered: {name}"); } else { let id = DefId(get_hash(&(&self.name, &name))); - self.locals - .insert(name, VarInfo::new(t, muty, vis, VarKind::Defined(id), None)); + self.locals.insert( + name, + VarInfo::new(t, muty, vis, VarKind::Defined(id), None, impl_of), + ); } } - pub(crate) fn register_trait(&mut self, class: Type, trait_: Type, methods: Self) { + pub(crate) fn register_trait(&mut self, class: Type, methods: Self) { + let trait_ = if let ContextKind::MethodDefs(Some(tr)) = &methods.kind { + tr.clone() + } else { + todo!() + }; self.super_traits.push(trait_.clone()); self.methods_list .push((ClassDefType::impl_trait(class, trait_), methods)); @@ -648,7 +683,9 @@ impl Context { TypeObj::Generated(gen) => { self.register_gen_type(ident, gen); } - TypeObj::Builtin(_t) => panic!("aliasing bug"), + TypeObj::Builtin(t) => { + self.register_type_alias(ident, t); + } }, // TODO: not all value objects are comparable other => { @@ -659,9 +696,10 @@ impl Context { ident.vis(), VarKind::Defined(id), None, + self.impl_of(), ); - self.consts.insert(ident.name.clone(), other); self.decls.insert(ident.name.clone(), vi); + self.consts.insert(ident.name.clone(), other); } } Ok(()) @@ -682,7 +720,7 @@ impl Context { self.level, ); let mut methods = Self::methods( - gen.t.qual_name(), + None, self.cfg.clone(), self.mod_cache.clone(), self.py_mod_cache.clone(), @@ -720,7 +758,7 @@ impl Context { ctx.register_superclass(sup, sup_ctx); } let mut methods = Self::methods( - gen.t.qual_name(), + None, self.cfg.clone(), self.mod_cache.clone(), self.py_mod_cache.clone(), @@ -778,7 +816,14 @@ impl Context { } else { Mutability::Immutable }; - let vi = VarInfo::new(t.clone(), muty, field.vis, VarKind::Declared, None); + let vi = VarInfo::new( + t.clone(), + muty, + field.vis, + VarKind::Declared, + None, + self.impl_of(), + ); ctx.decls .insert(VarName::from_str(field.symbol.clone()), vi); } @@ -807,8 +852,14 @@ impl Context { } else { Mutability::Immutable }; - let vi = - VarInfo::new(t.clone(), muty, field.vis, VarKind::Declared, None); + let vi = VarInfo::new( + t.clone(), + muty, + field.vis, + VarKind::Declared, + None, + self.impl_of(), + ); ctx.decls .insert(VarName::from_str(field.symbol.clone()), vi); } @@ -826,6 +877,31 @@ impl Context { } } + pub(crate) fn register_type_alias(&mut self, ident: &Identifier, t: Type) { + if self.mono_types.contains_key(ident.inspect()) { + panic!("{ident} has already been registered"); + } else if self.rec_get_const_obj(ident.inspect()).is_some() && ident.vis().is_private() { + panic!("{ident} has already been registered as const"); + } else { + let name = &ident.name; + let muty = Mutability::from(&ident.inspect()[..]); + let id = DefId(get_hash(&(&self.name, &name))); + self.decls.insert( + name.clone(), + VarInfo::new( + Type::Type, + muty, + ident.vis(), + VarKind::Defined(id), + None, + self.impl_of(), + ), + ); + self.consts + .insert(name.clone(), ValueObj::Type(TypeObj::Builtin(t))); + } + } + fn register_gen_mono_type( &mut self, ident: &Identifier, @@ -846,7 +922,14 @@ impl Context { let id = DefId(get_hash(&(&self.name, &name))); self.decls.insert( name.clone(), - VarInfo::new(meta_t, muty, ident.vis(), VarKind::Defined(id), None), + VarInfo::new( + meta_t, + muty, + ident.vis(), + VarKind::Defined(id), + None, + self.impl_of(), + ), ); self.consts .insert(name.clone(), ValueObj::Type(TypeObj::Generated(gen))); diff --git a/compiler/erg_compiler/lower.rs b/compiler/erg_compiler/lower.rs index 822dfe78..e0a98822 100644 --- a/compiler/erg_compiler/lower.rs +++ b/compiler/erg_compiler/lower.rs @@ -927,12 +927,11 @@ impl ASTLowerer { } } } - let id = body.id; self.ctx .outer .as_mut() .unwrap() - .assign_var_sig(&sig, found_body_t, id)?; + .assign_var_sig(&sig, found_body_t, body.id)?; let ident = hir::Identifier::bare(ident.dot.clone(), ident.name.clone()); let sig = hir::VarSignature::new(ident, found_body_t.clone()); let body = hir::DefBody::new(body.op, block, body.id); @@ -1087,8 +1086,8 @@ impl ASTLowerer { self.ctx.get_similar_name(&class.local_name()), ))); } - self.ctx - .grow(&class.local_name(), ContextKind::MethodDefs, Private, None); + let kind = ContextKind::MethodDefs(impl_trait.as_ref().map(|(t, _)| t.clone())); + self.ctx.grow(&class.local_name(), kind, Private, None); for def in methods.defs.iter_mut() { if methods.vis.is(TokenKind::Dot) { def.sig.ident_mut().unwrap().dot = Some(Token::new( @@ -1110,21 +1109,19 @@ impl ASTLowerer { } } } - match self.ctx.check_decls() { - Ok(()) => { - self.check_override(&class); - if let Some((trait_, _)) = &impl_trait { - self.register_trait_impl(&class, trait_); - } - if let Err(err) = self.check_trait_impl(impl_trait, &class) { - self.errs.push(err); - } - self.check_collision_and_push(class); - } - Err(mut errs) => { - self.errs.append(&mut errs); - } + if let Err(mut errs) = self.ctx.check_decls() { + self.errs.append(&mut errs); } + if let Some((trait_, _)) = &impl_trait { + self.check_override(&class, Some(trait_)); + self.register_trait_impl(&class, trait_); + } else { + self.check_override(&class, None); + } + if let Err(err) = self.check_trait_impl(impl_trait, &class) { + self.errs.push(err); + } + self.check_collision_and_push(class); } let class = mono(hir_def.sig.ident().inspect()); let class_ctx = self.ctx.get_nominal_type_ctx(&class).unwrap(); @@ -1185,8 +1182,9 @@ impl ASTLowerer { } } - fn check_override(&mut self, class: &Type) { + fn check_override(&mut self, class: &Type, impl_trait: Option<&Type>) { if let Some(sups) = self.ctx.get_nominal_super_type_ctxs(class) { + // exclude the first one because it is the class itself for sup in sups.into_iter().skip(1) { for (method_name, vi) in self.ctx.locals.iter().chain( self.ctx @@ -1194,13 +1192,16 @@ impl ASTLowerer { .iter() .flat_map(|(_, c)| c.locals.iter()), ) { - if let Some(_sup_vi) = sup.get_current_scope_var(method_name.inspect()) { + if let Some(sup_vi) = sup.get_current_scope_var(method_name.inspect()) { // must `@Override` if let Some(decos) = &vi.comptime_decos { if decos.contains("Override") { continue; } } + if sup_vi.impl_of.as_ref() != impl_trait { + continue; + } self.errs.push(LowerError::override_error( self.cfg.input.clone(), line!() as usize, @@ -1270,7 +1271,6 @@ impl ASTLowerer { if let Some((name, vi)) = self.ctx.get_local_kv(decl_name.inspect()) { unverified_names.remove(name); - log!(err "checking"); if !self.ctx.supertype_of(&decl_vi.t, &vi.t) { self.errs.push(LowerError::trait_member_type_error( self.cfg.input.clone(), @@ -1355,14 +1355,16 @@ impl ASTLowerer { .ctx .get_mut_nominal_type_ctx(&class) .unwrap_or_else(|| todo!("{class} not found")); - for (newly_defined_name, _vi) in methods.locals.clone().into_iter() { + for (newly_defined_name, vi) in methods.locals.clone().into_iter() { for (_, already_defined_methods) in class_root.methods_list.iter_mut() { // TODO: 特殊化なら同じ名前でもOK // TODO: 定義のメソッドもエラー表示 if let Some((_already_defined_name, already_defined_vi)) = already_defined_methods.get_local_kv(newly_defined_name.inspect()) { - if already_defined_vi.kind != VarKind::Auto { + if already_defined_vi.kind != VarKind::Auto + && already_defined_vi.impl_of == vi.impl_of + { self.errs.push(LowerError::duplicate_definition_error( self.cfg.input.clone(), line!() as usize, @@ -1542,6 +1544,7 @@ impl ASTLowerer { ident.vis(), VarKind::Declared, None, + None, ); self.ctx.decls.insert(ident.name.clone(), vi); } diff --git a/compiler/erg_compiler/varinfo.rs b/compiler/erg_compiler/varinfo.rs index d94b9135..51e15c60 100644 --- a/compiler/erg_compiler/varinfo.rs +++ b/compiler/erg_compiler/varinfo.rs @@ -122,6 +122,7 @@ pub struct VarInfo { pub vis: Visibility, pub kind: VarKind, pub comptime_decos: Option>, + pub impl_of: Option, } impl fmt::Display for VarInfo { @@ -160,6 +161,7 @@ impl VarInfo { Private, VarKind::DoesNotExist, None, + None, ); pub const fn new( @@ -168,6 +170,7 @@ impl VarInfo { vis: Visibility, kind: VarKind, comptime_decos: Option>, + impl_of: Option, ) -> Self { Self { t, @@ -175,6 +178,7 @@ impl VarInfo { vis, kind, comptime_decos, + impl_of, } } diff --git a/examples/impl.er b/examples/impl.er index 4e8cf859..037e63da 100644 --- a/examples/impl.er +++ b/examples/impl.er @@ -6,12 +6,18 @@ Point|Point <: Add(Point)|. Output = Point __add__ self, other: Point = Point.new(self::x + other::x, self::y + other::y) +Point|Point <: Mul(Point)|. + Output = Nat + __mul__ self, other: Point = + self::x * other::x + self::y * other::y Point|Point <: Eq(Point)|. __eq__ self, other: Point = self::x == other::x and self::y == other::y p = Point.new 1, 2 q = Point.new 3, 4 -r = p + q +r: Point = p + q +s: Nat = p * q +assert s == 11 assert r == Point.new 4, 6 assert r.norm() == 52 From a1688b972b82851a7a26238cc5776ae75995da0c Mon Sep 17 00:00:00 2001 From: Shunsuke Shibayama Date: Sat, 15 Oct 2022 11:17:05 +0900 Subject: [PATCH 2/4] Update version (v0.5.9) --- Cargo.lock | 8 ++++---- Cargo.toml | 10 +++++----- compiler/erg_compiler/Cargo.toml | 4 ++-- compiler/erg_parser/Cargo.toml | 2 +- 4 files changed, 12 insertions(+), 12 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 08aef69f..800c1039 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4,7 +4,7 @@ version = 3 [[package]] name = "erg" -version = "0.5.9-nightly.6" +version = "0.5.9" dependencies = [ "erg_common", "erg_compiler", @@ -13,7 +13,7 @@ dependencies = [ [[package]] name = "erg_common" -version = "0.5.9-nightly.6" +version = "0.5.9" dependencies = [ "hermit-abi", "libc", @@ -22,7 +22,7 @@ dependencies = [ [[package]] name = "erg_compiler" -version = "0.5.9-nightly.6" +version = "0.5.9" dependencies = [ "erg_common", "erg_parser", @@ -30,7 +30,7 @@ dependencies = [ [[package]] name = "erg_parser" -version = "0.5.9-nightly.6" +version = "0.5.9" dependencies = [ "erg_common", ] diff --git a/Cargo.toml b/Cargo.toml index fb2f5256..19106a61 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "erg" -version = "0.5.9-nightly.6" +version = "0.5.9" description = "The Erg programming language" authors = ["erg-lang team "] license = "MIT OR Apache-2.0" @@ -18,7 +18,7 @@ members = [ ] [workspace.package] -version = "0.5.9-nightly.6" +version = "0.5.9" authors = ["erg-lang team "] license = "MIT OR Apache-2.0" edition = "2021" @@ -50,9 +50,9 @@ traditional_chinese = [ pre-commit = [] [dependencies] -erg_common = { version = "0.5.9-nightly.6", path = "./compiler/erg_common" } -erg_parser = { version = "0.5.9-nightly.6", path = "./compiler/erg_parser" } -erg_compiler = { version = "0.5.9-nightly.6", path = "./compiler/erg_compiler" } +erg_common = { version = "0.5.9", path = "./compiler/erg_common" } +erg_parser = { version = "0.5.9", path = "./compiler/erg_parser" } +erg_compiler = { version = "0.5.9", path = "./compiler/erg_compiler" } # [workspace] # member = ["cm", "dyne"] diff --git a/compiler/erg_compiler/Cargo.toml b/compiler/erg_compiler/Cargo.toml index 38c2793f..618c16ec 100644 --- a/compiler/erg_compiler/Cargo.toml +++ b/compiler/erg_compiler/Cargo.toml @@ -24,8 +24,8 @@ traditional_chinese = [ ] [dependencies] -erg_common = { version = "0.5.9-nightly.6", path = "../erg_common" } -erg_parser = { version = "0.5.9-nightly.6", path = "../erg_parser" } +erg_common = { version = "0.5.9", path = "../erg_common" } +erg_parser = { version = "0.5.9", path = "../erg_parser" } [lib] path = "lib.rs" diff --git a/compiler/erg_parser/Cargo.toml b/compiler/erg_parser/Cargo.toml index 9b121054..03d5e749 100644 --- a/compiler/erg_parser/Cargo.toml +++ b/compiler/erg_parser/Cargo.toml @@ -16,7 +16,7 @@ simplified_chinese = ["erg_common/simplified_chinese"] traditional_chinese = ["erg_common/traditional_chinese"] [dependencies] -erg_common = { version = "0.5.9-nightly.6", path = "../erg_common" } +erg_common = { version = "0.5.9", path = "../erg_common" } [lib] path = "lib.rs" From afd8d33d49fa9c825502665f81c9cf5f211f07b9 Mon Sep 17 00:00:00 2001 From: Shunsuke Shibayama Date: Sat, 15 Oct 2022 12:13:09 +0900 Subject: [PATCH 3/4] Add `no_build_rs` feature --- Cargo.toml | 1 + compiler/erg_compiler/Cargo.toml | 1 + compiler/erg_compiler/build.rs | 3 ++ compiler/erg_compiler/codegen.rs | 51 +++++++++++++++++++------------- 4 files changed, 35 insertions(+), 21 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 19106a61..f5c708df 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -47,6 +47,7 @@ traditional_chinese = [ "erg_parser/traditional_chinese", "erg_compiler/traditional_chinese", ] +no_build_rs = ["erg_compiler/no_build_rs"] pre-commit = [] [dependencies] diff --git a/compiler/erg_compiler/Cargo.toml b/compiler/erg_compiler/Cargo.toml index 618c16ec..591f381b 100644 --- a/compiler/erg_compiler/Cargo.toml +++ b/compiler/erg_compiler/Cargo.toml @@ -22,6 +22,7 @@ traditional_chinese = [ "erg_common/traditional_chinese", "erg_parser/traditional_chinese", ] +no_build_rs = [] [dependencies] erg_common = { version = "0.5.9", path = "../erg_common" } diff --git a/compiler/erg_compiler/build.rs b/compiler/erg_compiler/build.rs index d9aecdd5..57e47670 100644 --- a/compiler/erg_compiler/build.rs +++ b/compiler/erg_compiler/build.rs @@ -5,6 +5,9 @@ use std::fs; use std::path; fn main() -> std::io::Result<()> { + if cfg!(feature = "no_build_rs") { + return Ok(()); + } // Create a ".erg" directory let erg_path = env::home_dir() .expect("failed to get the location of the home dir") diff --git a/compiler/erg_compiler/codegen.rs b/compiler/erg_compiler/codegen.rs index 4fef9b24..27ab7215 100644 --- a/compiler/erg_compiler/codegen.rs +++ b/compiler/erg_compiler/codegen.rs @@ -2051,27 +2051,36 @@ impl CodeGenerator { } fn load_prelude_py(&mut self) { - self.emit_global_import_items( - Identifier::public("sys"), - vec![( - Identifier::public("path"), - Some(Identifier::private("#path")), - )], - ); - self.emit_load_name_instr(Identifier::private("#path")); - self.emit_load_method_instr("Array!", None, Identifier::public("push!")); - self.emit_load_const(env!("ERG_STD_PATH")); - self.write_instr(CALL_METHOD); - self.write_arg(1u8); - self.stack_dec(); - self.emit_pop_top(); - self.emit_global_import_items( - Identifier::public("_erg_std_prelude"), - vec![( - Identifier::public("in_operator"), - Some(Identifier::private("#in_operator")), - )], - ); + if let Some(std_path) = option_env!("ERG_STD_PATH") { + self.emit_global_import_items( + Identifier::public("sys"), + vec![( + Identifier::public("path"), + Some(Identifier::private("#path")), + )], + ); + self.emit_load_name_instr(Identifier::private("#path")); + self.emit_load_method_instr("Array!", None, Identifier::public("push!")); + self.emit_load_const(std_path); + self.write_instr(CALL_METHOD); + self.write_arg(1u8); + self.stack_dec(); + self.emit_pop_top(); + self.emit_global_import_items( + Identifier::public("_erg_std_prelude"), + vec![( + Identifier::public("in_operator"), + Some(Identifier::private("#in_operator")), + )], + ); + } else { + self.emit_load_name_instr(Identifier::private("exec")); + self.emit_load_const(include_str!("std/_erg_std_prelude.py")); + self.write_instr(CALL_FUNCTION); + self.write_arg(1u8); + self.stack_dec(); + self.emit_pop_top(); + } } fn load_record_type(&mut self) { From a2adc58fcb024f33a7bb16fe674df5b1de05884a Mon Sep 17 00:00:00 2001 From: Shunsuke Shibayama Date: Sat, 15 Oct 2022 12:14:28 +0900 Subject: [PATCH 4/4] Update release.yml --- .github/workflows/release.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 7f1ea4b1..b7e27576 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -43,5 +43,6 @@ jobs: with: bin: erg target: ${{ matrix.target }} + features: no_build_rs env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}