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

Fix: variable to have VarInfo instead of Type

Browse source
This commit is contained in:
Shunsuke Shibayama 2022-10-18 00:25:47 +09:00
parent 119a326ebb
commit 46b87e1ca3
29 changed files with 888 additions and 816 deletions
Download patch file Download diff file Expand all files Collapse all files

472
compiler/erg_compiler/context/initialize/mod.rs
View file

@ -26,7 +26,7 @@ use erg_parser::ast::VarName;
use crate::context::initialize::const_func::*;
use crate::context::instantiate::ConstTemplate;
use crate::context::{
ClassDefType, Context, ContextKind, DefaultInfo, MethodType, ParamSpec, TraitInstance,
ClassDefType, Context, ContextKind, DefaultInfo, MethodInfo, ParamSpec, TraitInstance,
};
use crate::mod_cache::SharedModuleCache;
use crate::varinfo::{Mutability, VarInfo, VarKind};
@ -48,7 +48,38 @@ impl Context {
} else {
self.decls.insert(
name,
VarInfo::new(t, Immutable, vis, Builtin, None, impl_of),
VarInfo::new(t, Immutable, vis, Builtin, None, impl_of, None),
);
}
}
fn register_builtin_py_decl(
&mut self,
name: &'static str,
t: Type,
vis: Visibility,
py_name: Option<&'static str>,
) {
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,
impl_of,
py_name.map(Str::ever),
),
);
}
}
@ -69,13 +100,39 @@ impl Context {
if self.locals.get(&name).is_some() {
panic!("already registered: {name}");
} else {
self.locals
.insert(name, VarInfo::new(t, muty, vis, Builtin, None, impl_of));
self.locals.insert(
name,
VarInfo::new(t, muty, vis, Builtin, None, impl_of, None),
);
}
}
fn register_builtin_py_impl(
&mut self,
name: &'static str,
t: Type,
muty: Mutability,
vis: Visibility,
py_name: Option<&'static str>,
) {
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, impl_of, py_name.map(Str::ever)),
);
}
}
fn register_builtin_immutable_private_var(&mut self, name: &'static str, t: Type) {
self.register_builtin_impl(name, t, Immutable, Private)
self.register_builtin_impl(name, t, Immutable, Private);
}
fn register_builtin_const(&mut self, name: &str, vis: Visibility, obj: ValueObj) {
@ -95,6 +152,7 @@ impl Context {
Builtin,
None,
impl_of,
None,
);
self.consts.insert(VarName::from_str(Str::rc(name)), obj);
self.locals.insert(VarName::from_str(Str::rc(name)), vi);
@ -124,15 +182,29 @@ impl Context {
unique_in_place(&mut self.super_traits);
}
fn register_builtin_type(&mut self, t: Type, ctx: Self, vis: Visibility, muty: Mutability) {
fn register_builtin_type(
&mut self,
t: Type,
ctx: Self,
vis: Visibility,
muty: Mutability,
py_name: Option<&'static str>,
) {
if t.typarams_len().is_none() {
self.register_mono_type(t, ctx, vis, muty);
self.register_mono_type(t, ctx, vis, muty, py_name);
} else {
self.register_poly_type(t, ctx, vis, muty);
self.register_poly_type(t, ctx, vis, muty, py_name);
}
}
fn register_mono_type(&mut self, t: Type, ctx: Self, vis: Visibility, muty: Mutability) {
fn register_mono_type(
&mut self,
t: Type,
ctx: Self,
vis: Visibility,
muty: Mutability,
py_name: Option<&'static str>,
) {
if self.rec_get_mono_type(&t.local_name()).is_some() {
panic!("{} has already been registered", t.local_name());
} else if self.rec_get_const_obj(&t.local_name()).is_some() {
@ -146,7 +218,15 @@ impl Context {
};
self.locals.insert(
name.clone(),
VarInfo::new(meta_t, muty, vis, Builtin, None, None),
VarInfo::new(
meta_t,
muty,
vis,
Builtin,
None,
None,
py_name.map(Str::ever),
),
);
self.consts
.insert(name.clone(), ValueObj::builtin_t(t.clone()));
@ -162,21 +242,21 @@ impl Context {
}
for (trait_method, vi) in ctx.decls.iter() {
if let Some(types) = self.method_to_traits.get_mut(trait_method.inspect()) {
types.push(MethodType::new(t.clone(), vi.t.clone()));
types.push(MethodInfo::new(t.clone(), vi.clone()));
} else {
self.method_to_traits.insert(
trait_method.inspect().clone(),
vec![MethodType::new(t.clone(), vi.t.clone())],
vec![MethodInfo::new(t.clone(), vi.clone())],
);
}
}
for (class_method, vi) in ctx.locals.iter() {
if let Some(types) = self.method_to_classes.get_mut(class_method.inspect()) {
types.push(MethodType::new(t.clone(), vi.t.clone()));
types.push(MethodInfo::new(t.clone(), vi.clone()));
} else {
self.method_to_classes.insert(
class_method.inspect().clone(),
vec![MethodType::new(t.clone(), vi.t.clone())],
vec![MethodInfo::new(t.clone(), vi.clone())],
);
}
}
@ -185,7 +265,14 @@ impl Context {
}
// FIXME: MethodDefsと再代入は違う
fn register_poly_type(&mut self, t: Type, ctx: Self, vis: Visibility, muty: Mutability) {
fn register_poly_type(
&mut self,
t: Type,
ctx: Self,
vis: Visibility,
muty: Mutability,
py_name: Option<&'static str>,
) {
// FIXME: panic
if let Some((_, root_ctx)) = self.poly_types.get_mut(&t.local_name()) {
root_ctx.methods_list.push((ClassDefType::Simple(t), ctx));
@ -198,7 +285,15 @@ impl Context {
};
self.locals.insert(
name.clone(),
VarInfo::new(meta_t, muty, vis, Builtin, None, None),
VarInfo::new(
meta_t,
muty,
vis,
Builtin,
None,
None,
py_name.map(Str::ever),
),
);
self.consts
.insert(name.clone(), ValueObj::builtin_t(t.clone()));
@ -214,21 +309,21 @@ impl Context {
}
for (trait_method, vi) in ctx.decls.iter() {
if let Some(traits) = self.method_to_traits.get_mut(trait_method.inspect()) {
traits.push(MethodType::new(t.clone(), vi.t.clone()));
traits.push(MethodInfo::new(t.clone(), vi.clone()));
} else {
self.method_to_traits.insert(
trait_method.inspect().clone(),
vec![MethodType::new(t.clone(), vi.t.clone())],
vec![MethodInfo::new(t.clone(), vi.clone())],
);
}
}
for (class_method, vi) in ctx.locals.iter() {
if let Some(types) = self.method_to_classes.get_mut(class_method.inspect()) {
types.push(MethodType::new(t.clone(), vi.t.clone()));
types.push(MethodInfo::new(t.clone(), vi.clone()));
} else {
self.method_to_classes.insert(
class_method.inspect().clone(),
vec![MethodType::new(t.clone(), vi.t.clone())],
vec![MethodInfo::new(t.clone(), vi.clone())],
);
}
}
@ -249,7 +344,7 @@ impl Context {
let name = VarName::from_static(name);
self.locals.insert(
name.clone(),
VarInfo::new(Patch, muty, vis, Builtin, None, None),
VarInfo::new(Patch, muty, vis, Builtin, None, None, None),
);
for method_name in ctx.locals.keys() {
if let Some(patches) = self.method_impl_patches.get_mut(method_name) {
@ -307,7 +402,7 @@ impl Context {
t_read,
set! { subtypeof(mono_q("Self"), mono("Readable!")) },
);
readable.register_builtin_decl("read!", t_read, Public);
readable.register_builtin_py_decl("read!", t_read, Public, Some("read"));
/* Writable */
let mut writable = Self::builtin_mono_trait("Writable!", 2);
let t_write = pr1_kw_met(ref_mut(mono_q("Self"), None), kw("s", Str), Nat);
@ -315,12 +410,12 @@ impl Context {
t_write,
set! { subtypeof(mono_q("Self"), mono("Writable!")) },
);
writable.register_builtin_decl("write!", t_write, Public);
writable.register_builtin_py_decl("write!", t_write, Public, Some("write"));
/* Show */
let mut show = Self::builtin_mono_trait("Show", 2);
let t_show = fn0_met(ref_(mono_q("Self")), Str);
let t_show = quant(t_show, set! { subtypeof(mono_q("Self"), mono("Show")) });
show.register_builtin_decl("to_str", t_show, Public);
show.register_builtin_py_decl("to_str", t_show, Public, Some("__str__"));
/* In */
let mut in_ = Self::builtin_poly_trait("In", vec![PS::t("T", NonDefault)], 2);
let params = vec![PS::t("T", NonDefault)];
@ -447,50 +542,90 @@ impl Context {
let op_t = quant(op_t, set! {r_bound, self_bound});
floor_div.register_builtin_decl("__floordiv__", op_t, Public);
floor_div.register_builtin_decl("Output", Type, Public);
self.register_builtin_type(mono("Unpack"), unpack, Private, Const);
self.register_builtin_type(mono("InheritableType"), inheritable_type, Private, Const);
self.register_builtin_type(mono("Named"), named, Private, Const);
self.register_builtin_type(mono("Mutable"), mutable, Private, Const);
self.register_builtin_type(mono("Immutizable"), immutizable, Private, Const);
self.register_builtin_type(mono("Mutizable"), mutizable, Private, Const);
self.register_builtin_type(mono("PathLike"), pathlike, Private, Const);
self.register_builtin_type(mono("Readable!"), readable, Private, Const);
self.register_builtin_type(mono("Writable!"), writable, Private, Const);
self.register_builtin_type(mono("Show"), show, Private, Const);
self.register_builtin_type(mono("Unpack"), unpack, Private, Const, None);
self.register_builtin_type(
mono("InheritableType"),
inheritable_type,
Private,
Const,
None,
);
self.register_builtin_type(mono("Named"), named, Private, Const, None);
self.register_builtin_type(mono("Mutable"), mutable, Private, Const, None);
self.register_builtin_type(mono("Immutizable"), immutizable, Private, Const, None);
self.register_builtin_type(mono("Mutizable"), mutizable, Private, Const, None);
self.register_builtin_type(mono("PathLike"), pathlike, Private, Const, None);
self.register_builtin_type(
mono("Readable!"),
readable,
Private,
Const,
Some("Readable"),
);
self.register_builtin_type(
mono("Writable!"),
writable,
Private,
Const,
Some("Writable"),
);
self.register_builtin_type(mono("Show"), show, Private, Const, None);
self.register_builtin_type(
poly("Input", vec![ty_tp(mono_q("T"))]),
input,
Private,
Const,
None,
);
self.register_builtin_type(
poly("Output", vec![ty_tp(mono_q("T"))]),
output,
Private,
Const,
None,
);
self.register_builtin_type(
poly("In", vec![ty_tp(mono_q("T"))]),
in_,
Private,
Const,
None,
);
self.register_builtin_type(
poly("Eq", vec![ty_tp(mono_q("R"))]),
eq,
Private,
Const,
None,
);
self.register_builtin_type(poly("In", vec![ty_tp(mono_q("T"))]), in_, Private, Const);
self.register_builtin_type(poly("Eq", vec![ty_tp(mono_q("R"))]), eq, Private, Const);
self.register_builtin_type(
poly("PartialOrd", vec![ty_tp(mono_q("R"))]),
partial_ord,
Private,
Const,
None,
);
self.register_builtin_type(mono("Ord"), ord, Private, Const, None);
self.register_builtin_type(mono("Num"), num, Private, Const, None);
self.register_builtin_type(
poly("Seq", vec![ty_tp(mono_q("T"))]),
seq,
Private,
Const,
None,
);
self.register_builtin_type(mono("Ord"), ord, Private, Const);
self.register_builtin_type(mono("Num"), num, Private, Const);
self.register_builtin_type(poly("Seq", vec![ty_tp(mono_q("T"))]), seq, Private, Const);
self.register_builtin_type(
poly("Iterable", vec![ty_tp(mono_q("T"))]),
iterable,
Private,
Const,
None,
);
self.register_builtin_type(poly("Add", ty_params.clone()), add, Private, Const);
self.register_builtin_type(poly("Sub", ty_params.clone()), sub, Private, Const);
self.register_builtin_type(poly("Mul", ty_params.clone()), mul, Private, Const);
self.register_builtin_type(poly("Div", ty_params.clone()), div, Private, Const);
self.register_builtin_type(poly("FloorDiv", ty_params), floor_div, Private, Const);
self.register_builtin_type(poly("Add", ty_params.clone()), add, Private, Const, None);
self.register_builtin_type(poly("Sub", ty_params.clone()), sub, Private, Const, None);
self.register_builtin_type(poly("Mul", ty_params.clone()), mul, Private, Const, None);
self.register_builtin_type(poly("Div", ty_params.clone()), div, Private, Const, None);
self.register_builtin_type(poly("FloorDiv", ty_params), floor_div, Private, Const, None);
self.register_const_param_defaults(
"Eq",
vec![ConstTemplate::Obj(ValueObj::builtin_t(mono_q("Self")))],
@ -551,8 +686,8 @@ impl Context {
float.register_superclass(Obj, &obj);
// TODO: support multi platform
float.register_builtin_const("EPSILON", Public, ValueObj::Float(2.220446049250313e-16));
float.register_builtin_impl("Real", Float, Const, Public);
float.register_builtin_impl("Imag", Float, Const, Public);
float.register_builtin_py_impl("Real", Float, Const, Public, Some("real"));
float.register_builtin_py_impl("Imag", Float, Const, Public, Some("imag"));
float.register_marker_trait(mono("Num"));
float.register_marker_trait(mono("Ord"));
let mut float_partial_ord =
@ -598,15 +733,15 @@ impl Context {
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_show.register_builtin_py_impl("to_str", t, Immutable, Public, Some("__str__"));
float.register_trait(Float, float_show);
/* Ratio */
// TODO: Int, Nat, Boolの継承元をRatioにする(今はFloat)
let mut ratio = Self::builtin_mono_class("Ratio", 2);
ratio.register_superclass(Obj, &obj);
ratio.register_builtin_impl("Real", Ratio, Const, Public);
ratio.register_builtin_impl("Imag", Ratio, Const, Public);
ratio.register_builtin_py_impl("Real", Ratio, Const, Public, Some("real"));
ratio.register_builtin_py_impl("Imag", Ratio, Const, Public, Some("imag"));
ratio.register_marker_trait(mono("Num"));
ratio.register_marker_trait(mono("Ord"));
let mut ratio_partial_ord =
@ -702,17 +837,17 @@ impl Context {
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_show.register_builtin_py_impl("to_str", t, Immutable, Public, Some("__str__"));
int.register_trait(Int, int_show);
int.register_builtin_impl("Real", Int, Const, Public);
int.register_builtin_impl("Imag", Int, Const, Public);
int.register_builtin_py_impl("Real", Int, Const, Public, Some("real"));
int.register_builtin_py_impl("Imag", Int, Const, Public, Some("imag"));
/* Nat */
let mut nat = Self::builtin_mono_class("Nat", 10);
nat.register_superclass(Int, &int);
// class("Rational"),
// class("Integral"),
nat.register_builtin_impl(
nat.register_builtin_py_impl(
"times!",
pr_met(
Nat,
@ -723,6 +858,7 @@ impl Context {
),
Immutable,
Public,
Some("times"),
);
nat.register_marker_trait(mono("Num"));
nat.register_marker_trait(mono("Ord"));
@ -932,7 +1068,7 @@ impl Context {
t,
set! {static_instance("T", Type), static_instance("N", Nat), static_instance("M", Nat)},
);
array_.register_builtin_impl("concat", t, Immutable, Public);
array_.register_builtin_py_impl("concat", t, Immutable, Public, Some("__add__"));
// Array(T, N)|<: Add(Array(T, M))|.
// Output = Array(T, N + M)
// __add__: (self: Array(T, N), other: Array(T, M)) -> Array(T, N + M) = Array.concat
@ -983,7 +1119,13 @@ impl Context {
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(Some(mono("Show")), 1);
array_show.register_builtin_impl("to_str", fn0_met(arr_t.clone(), Str), Immutable, Public);
array_show.register_builtin_py_impl(
"to_str",
fn0_met(arr_t.clone(), Str),
Immutable,
Public,
Some("__str__"),
);
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);
@ -1102,7 +1244,13 @@ impl Context {
tuple_getitem_t,
set! {static_instance("Ts", array_t(Type, mono_q_tp("N"))), static_instance("N", Nat)},
);
tuple_.register_builtin_impl("__Tuple_getitem__", tuple_getitem_t, Const, Public);
tuple_.register_builtin_py_impl(
"__Tuple_getitem__",
tuple_getitem_t,
Const,
Public,
Some("__getitem__"),
);
/* record */
let mut record = Self::builtin_mono_class("Record", 2);
record.register_superclass(Obj, &obj);
@ -1211,7 +1359,7 @@ impl Context {
/* File_mut */
let mut file_mut = Self::builtin_mono_class("File!", 2);
let mut file_mut_readable = Self::builtin_methods(Some(mono("Readable!")), 1);
file_mut_readable.register_builtin_impl(
file_mut_readable.register_builtin_py_impl(
"read!",
pr_met(
ref_mut(mono("File!"), None),
@ -1222,14 +1370,16 @@ impl Context {
),
Immutable,
Public,
Some("read"),
);
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(
file_mut_writable.register_builtin_py_impl(
"write!",
pr1_kw_met(ref_mut(mono("File!"), None), kw("s", Str), Nat),
Immutable,
Public,
Some("write"),
);
file_mut.register_trait(mono("File!"), file_mut_writable);
/* Array_mut */
@ -1257,7 +1407,7 @@ impl Context {
t,
set! {static_instance("T", Type), static_instance("N", mono("Nat!"))},
);
array_mut_.register_builtin_impl("push!", t, Immutable, Public);
array_mut_.register_builtin_py_impl("push!", t, Immutable, Public, Some("append"));
let t = pr_met(
array_mut_t.clone(),
vec![kw("f", nd_func(vec![anon(mono_q("T"))], None, mono_q("T")))],
@ -1310,7 +1460,7 @@ impl Context {
t,
set! {static_instance("T", Type), static_instance("N", mono("Nat!"))},
);
set_mut_.register_builtin_impl("add!", t, Immutable, Public);
set_mut_.register_builtin_py_impl("add!", t, Immutable, Public, Some("add"));
let t = pr_met(
set_mut_t.clone(),
vec![kw("f", nd_func(vec![anon(mono_q("T"))], None, mono_q("T")))],
@ -1363,53 +1513,99 @@ impl Context {
let mut named_func = Self::builtin_mono_class("NamedFunc", 2);
named_func.register_superclass(mono("Func"), &func);
named_func.register_marker_trait(mono("Named"));
let mut quant = Self::builtin_mono_class("Quantified", 2);
quant.register_superclass(mono("Proc"), &proc);
let mut qfunc = Self::builtin_mono_class("QuantifiedFunc", 2);
qfunc.register_superclass(mono("Func"), &func);
self.register_builtin_type(Obj, obj, Private, Const);
self.register_builtin_type(Obj, obj, Private, Const, Some("object"));
// self.register_type(mono("Record"), vec![], record, Private, Const);
self.register_builtin_type(Int, int, Private, Const);
self.register_builtin_type(Nat, nat, Private, Const);
self.register_builtin_type(Float, float, Private, Const);
self.register_builtin_type(Ratio, ratio, Private, Const);
self.register_builtin_type(Bool, bool_, Private, Const);
self.register_builtin_type(Str, str_, Private, Const);
self.register_builtin_type(NoneType, nonetype, Private, Const);
self.register_builtin_type(Type, type_, Private, Const);
self.register_builtin_type(ClassType, class_type, Private, Const);
self.register_builtin_type(TraitType, trait_type, Private, Const);
self.register_builtin_type(g_module_t, generic_module, Private, Const);
self.register_builtin_type(module_t, module, Private, Const);
self.register_builtin_type(arr_t, array_, Private, Const);
self.register_builtin_type(set_t, set_, Private, Const);
self.register_builtin_type(g_dict_t, generic_dict, Private, Const);
self.register_builtin_type(dict_t, dict_, Private, Const);
self.register_builtin_type(mono("Bytes"), bytes, Private, Const);
self.register_builtin_type(mono("GenericTuple"), generic_tuple, Private, Const);
self.register_builtin_type(tuple_t, tuple_, Private, Const);
self.register_builtin_type(mono("Record"), record, Private, Const);
self.register_builtin_type(or_t, or, Private, Const);
self.register_builtin_type(mono("StrIterator"), str_iterator, Private, Const);
self.register_builtin_type(Int, int, Private, Const, Some("int"));
self.register_builtin_type(Nat, nat, Private, Const, Some("Nat"));
self.register_builtin_type(Float, float, Private, Const, Some("float"));
self.register_builtin_type(Ratio, ratio, Private, Const, Some("Ratio"));
self.register_builtin_type(Bool, bool_, Private, Const, Some("Bool"));
self.register_builtin_type(Str, str_, Private, Const, Some("Str"));
self.register_builtin_type(NoneType, nonetype, Private, Const, Some("NoneType"));
self.register_builtin_type(Type, type_, Private, Const, Some("type"));
self.register_builtin_type(ClassType, class_type, Private, Const, Some("ClassType"));
self.register_builtin_type(TraitType, trait_type, Private, Const, Some("TraitType"));
self.register_builtin_type(
g_module_t,
generic_module,
Private,
Const,
Some("ModuleType"),
);
self.register_builtin_type(module_t, module, Private, Const, Some("Module"));
self.register_builtin_type(arr_t, array_, Private, Const, Some("list"));
self.register_builtin_type(set_t, set_, Private, Const, Some("set"));
self.register_builtin_type(g_dict_t, generic_dict, Private, Const, Some("dict"));
self.register_builtin_type(dict_t, dict_, Private, Const, Some("dict"));
self.register_builtin_type(mono("Bytes"), bytes, Private, Const, Some("bytes"));
self.register_builtin_type(
mono("GenericTuple"),
generic_tuple,
Private,
Const,
Some("tuple"),
);
self.register_builtin_type(tuple_t, tuple_, Private, Const, Some("tuple"));
self.register_builtin_type(mono("Record"), record, Private, Const, Some("Record"));
self.register_builtin_type(or_t, or, Private, Const, Some("Union"));
self.register_builtin_type(
mono("StrIterator"),
str_iterator,
Private,
Const,
Some("str_iterator"),
);
self.register_builtin_type(
poly("ArrayIterator", vec![ty_tp(mono_q("T"))]),
array_iterator,
Private,
Const,
Some("array_iterator"),
);
self.register_builtin_type(mono("Int!"), int_mut, Private, Const, Some("int"));
self.register_builtin_type(mono("Nat!"), nat_mut, Private, Const, Some("Nat"));
self.register_builtin_type(mono("Float!"), float_mut, Private, Const, Some("float"));
self.register_builtin_type(mono("Ratio!"), ratio_mut, Private, Const, Some("Ratio"));
self.register_builtin_type(mono("Bool!"), bool_mut, Private, Const, Some("Bool"));
self.register_builtin_type(mono("Str!"), str_mut, Private, Const, Some("Str"));
self.register_builtin_type(mono("File!"), file_mut, Private, Const, Some("File"));
self.register_builtin_type(array_mut_t, array_mut_, Private, Const, Some("list"));
self.register_builtin_type(set_mut_t, set_mut_, Private, Const, Some("set"));
self.register_builtin_type(range_t, range, Private, Const, Some("Range"));
self.register_builtin_type(mono("Proc"), proc, Private, Const, Some("Proc"));
self.register_builtin_type(
mono("NamedProc"),
named_proc,
Private,
Const,
Some("NamedProc"),
);
self.register_builtin_type(mono("Func"), func, Private, Const, Some("Func"));
self.register_builtin_type(
mono("NamedFunc"),
named_func,
Private,
Const,
Some("NamedFunc"),
);
self.register_builtin_type(
mono("Quantified"),
quant,
Private,
Const,
Some("Quantified"),
);
self.register_builtin_type(
mono("QuantifiedFunc"),
qfunc,
Private,
Const,
Some("QuantifiedFunc"),
);
self.register_builtin_type(mono("Int!"), int_mut, Private, Const);
self.register_builtin_type(mono("Nat!"), nat_mut, Private, Const);
self.register_builtin_type(mono("Float!"), float_mut, Private, Const);
self.register_builtin_type(mono("Ratio!"), ratio_mut, Private, Const);
self.register_builtin_type(mono("Bool!"), bool_mut, Private, Const);
self.register_builtin_type(mono("Str!"), str_mut, Private, Const);
self.register_builtin_type(mono("File!"), file_mut, Private, Const);
self.register_builtin_type(array_mut_t, array_mut_, Private, Const);
self.register_builtin_type(set_mut_t, set_mut_, Private, Const);
self.register_builtin_type(range_t, range, Private, Const);
self.register_builtin_type(mono("Proc"), proc, Private, Const);
self.register_builtin_type(mono("NamedProc"), named_proc, Private, Const);
self.register_builtin_type(mono("Func"), func, Private, Const);
self.register_builtin_type(mono("NamedFunc"), named_func, Private, Const);
self.register_builtin_type(mono("QuantifiedFunc"), qfunc, Private, Const);
}
fn init_builtin_funcs(&mut self) {
@ -1519,33 +1715,57 @@ impl Context {
let t_exit = t_quit.clone();
let t_repr = nd_func(vec![kw("object", Obj)], None, Str);
let t_round = nd_func(vec![kw("number", Float)], None, Int);
self.register_builtin_impl("abs", t_abs, Immutable, Private);
self.register_builtin_impl("ascii", t_ascii, Immutable, Private);
self.register_builtin_py_impl("abs", t_abs, Immutable, Private, Some("abs"));
self.register_builtin_py_impl("ascii", t_ascii, Immutable, Private, Some("ascii"));
self.register_builtin_impl("assert", t_assert, Const, Private); // assert casting に悪影響が出る可能性があるため、Constとしておく
self.register_builtin_impl("bin", t_bin, Immutable, Private);
self.register_builtin_impl("chr", t_chr, Immutable, Private);
self.register_builtin_impl("classof", t_classof, Immutable, Private);
self.register_builtin_impl("compile", t_compile, Immutable, Private);
self.register_builtin_py_impl("bin", t_bin, Immutable, Private, Some("bin"));
self.register_builtin_py_impl("chr", t_chr, Immutable, Private, Some("chr"));
self.register_builtin_py_impl("classof", t_classof, Immutable, Private, Some("type"));
self.register_builtin_py_impl("compile", t_compile, Immutable, Private, Some("compile"));
self.register_builtin_impl("cond", t_cond, Immutable, Private);
self.register_builtin_impl("discard", t_discard, Immutable, Private);
self.register_builtin_impl("exit", t_exit, Immutable, Private);
self.register_builtin_py_impl("exit", t_exit, Immutable, Private, Some("exit"));
self.register_builtin_impl("if", t_if, Immutable, Private);
self.register_builtin_impl("import", t_import, Immutable, Private);
self.register_builtin_impl("isinstance", t_isinstance, Immutable, Private);
self.register_builtin_impl("issubclass", t_issubclass, Immutable, Private);
self.register_builtin_impl("len", t_len, Immutable, Private);
self.register_builtin_impl("log", t_log, Immutable, Private);
self.register_builtin_impl("oct", t_oct, Immutable, Private);
self.register_builtin_impl("ord", t_ord, Immutable, Private);
self.register_builtin_impl("panic", t_panic, Immutable, Private);
self.register_builtin_impl("pow", t_pow, Immutable, Private);
self.register_builtin_py_impl("import", t_import, Immutable, Private, Some("__import__"));
self.register_builtin_py_impl(
"isinstance",
t_isinstance,
Immutable,
Private,
Some("isinstance"),
);
self.register_builtin_py_impl(
"issubclass",
t_issubclass,
Immutable,
Private,
Some("issubclass"),
);
self.register_builtin_py_impl("len", t_len, Immutable, Private, Some("len"));
self.register_builtin_py_impl("log", t_log, Immutable, Private, Some("print"));
self.register_builtin_py_impl("oct", t_oct, Immutable, Private, Some("oct"));
self.register_builtin_py_impl("ord", t_ord, Immutable, Private, Some("ord"));
self.register_builtin_py_impl("panic", t_panic, Immutable, Private, Some("quit"));
self.register_builtin_py_impl("pow", t_pow, Immutable, Private, Some("pow"));
if cfg!(feature = "debug") {
self.register_builtin_impl("py", t_pyimport.clone(), Immutable, Private);
self.register_builtin_py_impl(
"py",
t_pyimport.clone(),
Immutable,
Private,
Some("__import__"),
);
}
self.register_builtin_impl("pyimport", t_pyimport, Immutable, Private);
self.register_builtin_impl("quit", t_quit, Immutable, Private);
self.register_builtin_impl("repr", t_repr, Immutable, Private);
self.register_builtin_impl("round", t_round, Immutable, Private);
self.register_builtin_py_impl(
"pyimport",
t_pyimport,
Immutable,
Private,
Some("__import__"),
);
self.register_builtin_py_impl("quit", t_quit, Immutable, Private, Some("quit"));
self.register_builtin_py_impl("repr", t_repr, Immutable, Private, Some("repr"));
self.register_builtin_py_impl("round", t_round, Immutable, Private, Some("round"));
}
fn init_builtin_const_funcs(&mut self) {
@ -1682,16 +1902,16 @@ impl Context {
t_with,
set! {static_instance("T", Type), static_instance("U", Type)},
);
self.register_builtin_impl("dir!", t_dir, Immutable, Private);
self.register_builtin_impl("print!", t_print, Immutable, Private);
self.register_builtin_impl("id!", t_id, Immutable, Private);
self.register_builtin_impl("input!", t_input, Immutable, Private);
self.register_builtin_py_impl("dir!", t_dir, Immutable, Private, Some("dir"));
self.register_builtin_py_impl("print!", t_print, Immutable, Private, Some("print"));
self.register_builtin_py_impl("id!", t_id, Immutable, Private, Some("id"));
self.register_builtin_py_impl("input!", t_input, Immutable, Private, Some("input"));
self.register_builtin_impl("if!", t_if, Immutable, Private);
self.register_builtin_impl("for!", t_for, Immutable, Private);
self.register_builtin_impl("globals!", t_globals, Immutable, Private);
self.register_builtin_impl("locals!", t_locals, Immutable, Private);
self.register_builtin_py_impl("globals!", t_globals, Immutable, Private, Some("globals"));
self.register_builtin_py_impl("locals!", t_locals, Immutable, Private, Some("locals"));
self.register_builtin_impl("while!", t_while, Immutable, Private);
self.register_builtin_impl("open!", t_open, Immutable, Private);
self.register_builtin_py_impl("open!", t_open, Immutable, Private, Some("open"));
self.register_builtin_impl("with!", t_with, Immutable, Private);
}

3
compiler/erg_compiler/context/initialize/py_mods/glob.rs
View file

@ -13,7 +13,7 @@ use Visibility::*;
impl Context {
pub(crate) fn init_py_glob_mod() -> Self {
let mut glob = Context::builtin_module("glob", 10);
glob.register_builtin_impl(
glob.register_builtin_py_impl(
"glob!",
proc(
vec![kw("pathname", Str)],
@ -23,6 +23,7 @@ impl Context {
),
Immutable,
Public,
Some("glob"),
);
glob
}

3
compiler/erg_compiler/context/initialize/py_mods/importlib.rs
View file

@ -12,11 +12,12 @@ use Visibility::*;
impl Context {
pub(crate) fn init_py_importlib_mod() -> Self {
let mut importlib = Context::builtin_module("importlib", 15);
importlib.register_builtin_impl(
importlib.register_builtin_py_impl(
"reload!",
proc1(mono("GenericModule"), NoneType),
Immutable,
Public,
Some("reload"),
);
importlib
}

11
compiler/erg_compiler/context/initialize/py_mods/io.rs
View file

@ -15,13 +15,20 @@ impl Context {
let mut string_io = Context::builtin_mono_class("StringIO!", 0);
// FIXME: include Obj (pass main_ctx as a param)
// string_io.register_superclass(Obj, obj);
string_io.register_builtin_impl(
string_io.register_builtin_py_impl(
"getvalue!",
pr0_met(ref_(mono("io.StringIO!")), Str),
Immutable,
Public,
Some("getvalue"),
);
io.register_builtin_type(
mono("io.StringIO!"),
string_io,
Public,
Const,
Some("io.StringIO"),
);
io.register_builtin_type(mono("io.StringIO!"), string_io, Public, Const);
io
}
}

37
compiler/erg_compiler/context/initialize/py_mods/os.rs
View file

@ -13,15 +13,22 @@ use Visibility::*;
impl Context {
pub(crate) fn init_py_os_mod() -> Self {
let mut os = Context::builtin_module("os", 15);
os.register_builtin_impl(
os.register_builtin_py_impl(
"chdir!",
nd_proc1(kw("path", mono("PathLike")), NoneType),
Immutable,
Public,
Some("chdir"),
);
os.register_builtin_impl("getcwd!", proc0(Str), Immutable, Public);
os.register_builtin_impl("getenv!", nd_proc1(kw("key", Str), Str), Immutable, Public);
os.register_builtin_impl(
os.register_builtin_py_impl("getcwd!", proc0(Str), Immutable, Public, Some("getcwd"));
os.register_builtin_py_impl(
"getenv!",
nd_proc1(kw("key", Str), Str),
Immutable,
Public,
Some("getenv"),
);
os.register_builtin_py_impl(
"listdir!",
proc(
vec![],
@ -31,15 +38,17 @@ impl Context {
),
Immutable,
Public,
Some("listdir"),
);
os.register_builtin_impl(
os.register_builtin_py_impl(
"mkdir!",
nd_proc1(kw("path", mono("PathLike")), NoneType),
Immutable,
Public,
Some("mkdir"),
);
os.register_builtin_impl("name", Str, Immutable, Public);
os.register_builtin_impl(
os.register_builtin_py_impl(
"putenv!",
proc(
vec![kw("key", Str), kw("value", Str)],
@ -49,20 +58,23 @@ impl Context {
),
Immutable,
Public,
Some("putenv"),
);
os.register_builtin_impl(
os.register_builtin_py_impl(
"remove!",
nd_proc1(kw("path", mono("PathLike")), NoneType),
Immutable,
Public,
Some("remove"),
);
os.register_builtin_impl(
os.register_builtin_py_impl(
"removedirs!",
nd_proc1(kw("name", mono("PathLike")), NoneType),
Immutable,
Public,
Some("removedirs"),
);
os.register_builtin_impl(
os.register_builtin_py_impl(
"rename!",
proc(
vec![kw("src", mono("PathLike")), kw("dst", mono("PathLike"))],
@ -72,19 +84,22 @@ impl Context {
),
Immutable,
Public,
Some("rename"),
);
os.register_builtin_impl(
os.register_builtin_py_impl(
"rmdir!",
nd_proc1(kw("path", mono("PathLike")), NoneType),
Immutable,
Public,
Some("rmdir"),
);
if cfg!(unix) {
os.register_builtin_impl(
os.register_builtin_py_impl(
"uname!",
proc0(mono("posix.UnameResult")),
Immutable,
Public,
Some("uname"),
);
}
// TODO

8
compiler/erg_compiler/context/initialize/py_mods/random.rs
View file

@ -15,7 +15,7 @@ use Visibility::*;
impl Context {
pub(crate) fn init_py_random_mod() -> Self {
let mut random = Context::builtin_module("random", 10);
random.register_builtin_impl(
random.register_builtin_py_impl(
"seed!",
proc(
vec![],
@ -28,12 +28,14 @@ impl Context {
),
Immutable,
Public,
Some("seed"),
);
random.register_builtin_impl(
random.register_builtin_py_impl(
"randint!",
nd_proc(vec![kw("a", Int), kw("b", Int)], None, Int),
Immutable,
Public,
Some("randint"),
);
let t = nd_proc(
vec![kw("seq", poly("Seq", vec![ty_tp(mono_q("T"))]))],
@ -41,7 +43,7 @@ impl Context {
mono_q("T"),
);
let t = quant(t, set! {static_instance("T", Type)});
random.register_builtin_impl("choice!", t, Immutable, Public);
random.register_builtin_py_impl("choice!", t, Immutable, Public, Some("choice"));
random
}
}

8
compiler/erg_compiler/context/initialize/py_mods/socket.rs
View file

@ -31,7 +31,13 @@ impl Context {
Immutable,
Public,
);
socket.register_builtin_type(mono("socket.Socket!"), sock, Public, Const);
socket.register_builtin_type(
mono("socket.Socket!"),
sock,
Public,
Const,
Some("socket.Socket"),
);
socket
}
}

10
compiler/erg_compiler/context/initialize/py_mods/time.rs
View file

@ -12,8 +12,14 @@ use Visibility::*;
impl Context {
pub(crate) fn init_py_time_mod() -> Self {
let mut time = Context::builtin_module("time", 15);
time.register_builtin_impl("sleep!", proc1(Float, NoneType), Immutable, Public);
time.register_builtin_impl("time!", proc0(Float), Immutable, Public);
time.register_builtin_py_impl(
"sleep!",
proc1(Float, NoneType),
Immutable,
Public,
Some("sleep"),
);
time.register_builtin_py_impl("time!", proc0(Float), Immutable, Public, Some("time"));
time
}
}

10
compiler/erg_compiler/context/initialize/py_mods/urllib.rs
View file

@ -18,7 +18,13 @@ impl Context {
urllib.py_mod_cache = Some(SharedModuleCache::new());
let mut request_class = Context::builtin_mono_class("Request", 5);
request_class.register_builtin_impl("data", mono("Bytes"), Immutable, Public);
urllib.register_builtin_type(mono("urllib.request.Request"), request_class, Public, Const);
urllib.register_builtin_type(
mono("urllib.request.Request"),
request_class,
Public,
Const,
Some("urllib.request.Request"),
);
urllib.register_builtin_impl("request", module_from_path("request"), Immutable, Public);
let mut request = Context::builtin_module("urllib.request", 15);
let t = proc(
@ -30,7 +36,7 @@ impl Context {
],
mono("http.client.HTTPResponse"),
);
request.register_builtin_impl("urlopen", t, Immutable, Public);
request.register_builtin_py_impl("urlopen!", t, Immutable, Public, Some("urlopen"));
urllib.register_builtin_impl("parse", module_from_path("parse"), Immutable, Public);
let parse = Context::builtin_module("urllib.parse", 15);
urllib