Add ClassDefType

compiler/erg_compiler/context/initialize/mod.rs

@@ -19,7 +19,7 @@ use erg_parser::ast::VarName;
 
 use crate::context::initialize::const_func::{class_func, inherit_func, inheritable_func};
 use crate::context::instantiate::{ConstTemplate, TyVarContext};
-use crate::context::{Context, ContextKind, DefaultInfo, ParamSpec, TraitInstance};
+use crate::context::{ClassDefType, Context, ContextKind, DefaultInfo, ParamSpec, TraitInstance};
 use crate::varinfo::{Mutability, VarInfo, VarKind};
 use DefaultInfo::*;
 use Mutability::*;
@@ -114,7 +114,7 @@ impl Context {
         let t = Self::instantiate_t(t, &mut tv_ctx);
         // FIXME: panic
         if let Some((_, root_ctx)) = self.poly_types.get_mut(&t.name()) {
-            root_ctx.methods_list.push((t, ctx));
+            root_ctx.methods_list.push((ClassDefType::Simple(t), ctx));
         } else {
             let name = VarName::from_str(t.name());
             self.locals.insert(
@@ -463,6 +463,8 @@ impl Context {
         float.register_builtin_const("SubO", ValueObj::builtin_t(Float));
         float.register_builtin_const("MulO", ValueObj::builtin_t(Float));
         float.register_builtin_const("DivO", ValueObj::builtin_t(Float));
+        // TODO: support multi platform
+        float.register_builtin_const("EPSILON", ValueObj::Float(2.220446049250313e-16));
         float.register_builtin_const("MutType!", ValueObj::builtin_t(mono("Float!")));
         float.register_builtin_impl("Real", Float, Const, Public);
         float.register_builtin_impl("Imag", Float, Const, Public);

compiler/erg_compiler/context/mod.rs

@@ -65,6 +65,23 @@ impl TraitInstance {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub enum ClassDefType {
+    Simple(Type),
+    ImplTrait { class: Type, impl_trait: Type },
+}
+
+impl std::fmt::Display for ClassDefType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ClassDefType::Simple(ty) => write!(f, "{ty}"),
+            ClassDefType::ImplTrait { class, impl_trait } => {
+                write!(f, "{class}|<: {impl_trait}|")
+            }
+        }
+    }
+}
+
 /// ```
 /// # use erg_common::ty::{Type, TyParam};
 /// # use erg_compiler::context::TyParamIdx;
@@ -254,7 +271,7 @@ pub struct Context {
     pub(crate) super_traits: Vec<Type>,  // if self is not a trait, means implemented traits
     // method definitions, if the context is a type
     // specializations are included and needs to be separated out
-    pub(crate) methods_list: Vec<(Type, Context)>,
+    pub(crate) methods_list: Vec<(ClassDefType, Context)>,
     /// K: method name, V: impl patch
     /// Provided methods can switch implementations on a scope-by-scope basis
     /// K: メソッド名, V: それを実装するパッチたち

compiler/erg_compiler/context/register.rs

@@ -14,7 +14,7 @@ use erg_type::value::{GenTypeObj, TypeKind, TypeObj, ValueObj};
 use erg_type::{HasType, ParamTy, SubrType, TyBound, Type};
 use Type::*;
 
-use crate::context::{Context, DefaultInfo, RegistrationMode, TraitInstance};
+use crate::context::{ClassDefType, Context, DefaultInfo, RegistrationMode, TraitInstance};
 use crate::error::readable_name;
 use crate::error::{TyCheckError, TyCheckResult};
 use crate::hir;
@@ -590,7 +590,8 @@ impl Context {
                     methods.register_fixed_auto_impl("__new__", new_t.clone(), Immutable, Private);
                     // 必要なら、ユーザーが独自に上書きする
                     methods.register_auto_impl("new", new_t, Immutable, Public);
-                    ctx.methods_list.push((gen.t.clone(), methods));
+                    ctx.methods_list
+                        .push((ClassDefType::Simple(gen.t.clone()), methods));
                     self.register_gen_mono_type(ident, gen, ctx, Const);
                 } else {
                     todo!()
@@ -625,7 +626,8 @@ impl Context {
                         );
                         // 必要なら、ユーザーが独自に上書きする
                         methods.register_auto_impl("new", new_t, Immutable, Public);
-                        ctx.methods_list.push((gen.t.clone(), methods));
+                        ctx.methods_list
+                            .push((ClassDefType::Simple(gen.t.clone()), methods));
                         self.register_gen_mono_type(ident, gen, ctx, Const);
                     } else {
                         todo!("super class not found")