X-Git-Url: http://nitlanguage.org

diff --git a/src/model/model.nit b/src/model/model.nit
index 4395cee..f0bfe8b 100644
--- a/src/model/model.nit
+++ b/src/model/model.nit
@@ -206,6 +206,9 @@ 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 `Char`
 	var char_type: MClassType = self.get_primitive_class("Char").mclass_type is lazy
 
@@ -514,6 +517,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 +1712,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
@@ -1717,6 +1756,15 @@ class MSignature
 	# The each parameter (in order)
 	var mparameters: Array[MParameter]
 
+	# Returns a parameter named `name`, if any.
+	fun mparameter_by_name(name: String): nullable MParameter
+	do
+		for p in mparameters do
+			if p.name == name then return p
+		end
+		return null
+	end
+
 	# The return type (null for a procedure)
 	var return_mtype: nullable MType
 
@@ -2120,6 +2168,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