src/compiler: Added fixint variants to compiler

[nit.git] / src / model / model.nit

diff --git a/src/model/model.nit b/src/model/model.nit
index ff7bb48..7812cb2 100644 (file)
--- a/src/model/model.nit
+++ b/src/model/model.nit
@@ -206,6 +206,24 @@ redef class MModule
        # The primitive type `Int`
        var int_type: MClassType = self.get_primitive_class("Int").mclass_type is lazy
 
+       # The primitive type `Byte`
+       var byte_type: MClassType = self.get_primitive_class("Byte").mclass_type is lazy
+
+       # The primitive type `Int8`
+       var int8_type: MClassType = self.get_primitive_class("Int8").mclass_type is lazy
+
+       # The primitive type `Int16`
+       var int16_type: MClassType = self.get_primitive_class("Int16").mclass_type is lazy
+
+       # The primitive type `UInt16`
+       var uint16_type: MClassType = self.get_primitive_class("UInt16").mclass_type is lazy
+
+       # The primitive type `Int32`
+       var int32_type: MClassType = self.get_primitive_class("Int32").mclass_type is lazy
+
+       # The primitive type `UInt32`
+       var uint32_type: MClassType = self.get_primitive_class("UInt32").mclass_type is lazy
+
        # The primitive type `Char`
        var char_type: MClassType = self.get_primitive_class("Char").mclass_type is lazy
 
@@ -514,6 +532,18 @@ class MClass
 
        # Is there a `new` factory to allow the pseudo instantiation?
        var has_new_factory = false is writable
+
+       # Is `self` a standard or abstract class kind?
+       var is_class: Bool is lazy do return kind == concrete_kind or kind == abstract_kind
+
+       # Is `self` an interface kind?
+       var is_interface: Bool is lazy do return kind == interface_kind
+
+       # Is `self` an enum kind?
+       var is_enum: Bool is lazy do return kind == enum_kind
+
+       # Is `self` and abstract class?
+       var is_abstract: Bool is lazy do return kind == abstract_kind
 end
 
 
@@ -1697,8 +1727,32 @@ class MNullType
        redef fun c_name do return "null"
        redef fun as_nullable do return self
 
-       # Aborts on `null`
-       redef fun as_notnull do abort # sorry...
+       redef var as_notnull = new MBottomType(model) is lazy
+       redef fun need_anchor do return false
+       redef fun resolve_for(mtype, anchor, mmodule, cleanup_virtual) do return self
+       redef fun can_resolve_for(mtype, anchor, mmodule) do return true
+
+       redef fun collect_mclassdefs(mmodule) do return new HashSet[MClassDef]
+
+       redef fun collect_mclasses(mmodule) do return new HashSet[MClass]
+
+       redef fun collect_mtypes(mmodule) do return new HashSet[MClassType]
+end
+
+# The special universal most specific type.
+#
+# This type is intended to be only used internally for type computation or analysis and should not be exposed to the user.
+# The bottom type can de used to denote things that are absurd, dead, or the absence of knowledge.
+#
+# Semantically it is the singleton `null.as_notnull`.
+class MBottomType
+       super MType
+       redef var model: Model
+       redef fun to_s do return "bottom"
+       redef fun full_name do return "bottom"
+       redef fun c_name do return "bottom"
+       redef fun as_nullable do return model.null_type
+       redef fun as_notnull do return self
        redef fun need_anchor do return false
        redef fun resolve_for(mtype, anchor, mmodule, cleanup_virtual) do return self
        redef fun can_resolve_for(mtype, anchor, mmodule) do return true
@@ -1774,22 +1828,6 @@ class MSignature
        # The number of parameters
        fun arity: Int do return mparameters.length
 
-       # The number of non-default parameters
-       #
-       # The number of default parameters is then `arity-min_arity`.
-       #
-       # Note that there cannot be both varargs and default prameters, thus
-       # if `vararg_rank != -1` then `min_arity` == `arity`
-       fun min_arity: Int
-       do
-               if vararg_rank != -1 then return arity
-               var res = 0
-               for p in mparameters do
-                       if not p.is_default then res += 1
-               end
-               return res
-       end
-
        redef fun to_s
        do
                var b = new FlatBuffer
@@ -1843,9 +1881,6 @@ class MParameter
        # Is the parameter a vararg?
        var is_vararg: Bool
 
-       # Is the parameter a default one?
-       var is_default: Bool
-
        redef fun to_s
        do
                if is_vararg then
@@ -1861,7 +1896,7 @@ class MParameter
        do
                if not self.mtype.need_anchor then return self
                var newtype = self.mtype.resolve_for(mtype, anchor, mmodule, cleanup_virtual)
-               var res = new MParameter(self.name, newtype, self.is_vararg, self.is_default)
+               var res = new MParameter(self.name, newtype, self.is_vararg)
                return res
        end
 
@@ -2129,6 +2164,10 @@ class MMethod
        do
                return self.is_init
        end
+
+       # A specific method that is safe to call on null.
+       # Currently, only `==`, `!=` and `is_same_instance` are safe
+       fun is_null_safe: Bool do return name == "==" or name == "!=" or name == "is_same_instance"
 end
 
 # A global attribute