Merge: typing: new warning `useless-truism` to catch trainees.

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

diff --git a/src/model/model.nit b/src/model/model.nit
index 28303d0..935b201 100644 (file)
--- a/src/model/model.nit
+++ b/src/model/model.nit
@@ -885,7 +885,7 @@ abstract class MType
                if anchor == null then anchor = sub # UGLY: any anchor will work
                var resolved_sub = sub.anchor_to(mmodule, anchor)
                var res = resolved_sub.collect_mclasses(mmodule).has(sup.mclass)
-               if res == false then return false
+               if not res then return false
                if not sup isa MGenericType then return true
                var sub2 = sub.supertype_to(mmodule, anchor, sup.mclass)
                assert sub2.mclass == sup.mclass
@@ -893,7 +893,7 @@ abstract class MType
                        var sub_arg = sub2.arguments[i]
                        var sup_arg = sup.arguments[i]
                        res = sub_arg.is_subtype(mmodule, anchor, sup_arg)
-                       if res == false then return false
+                       if not res then return false
                end
                return true
        end
@@ -1975,16 +1975,34 @@ class MSignature
                var b = new FlatBuffer
                if not mparameters.is_empty then
                        b.append("(")
+                       var last_mtype = null
                        for i in [0..mparameters.length[ do
                                var mparameter = mparameters[i]
+
+                               # Group types that are common to contiguous parameters
+                               if mparameter.mtype != last_mtype and last_mtype != null then
+                                       b.append(": ")
+                                       b.append(last_mtype.to_s)
+                               end
+
                                if i > 0 then b.append(", ")
                                b.append(mparameter.name)
-                               b.append(": ")
-                               b.append(mparameter.mtype.to_s)
+
                                if mparameter.is_vararg then
+                                       b.append(": ")
+                                       b.append(mparameter.mtype.to_s)
                                        b.append("...")
+                                       last_mtype = null
+                               else
+                                       last_mtype = mparameter.mtype
                                end
                        end
+
+                       if last_mtype != null then
+                               b.append(": ")
+                               b.append(last_mtype.to_s)
+                       end
+
                        b.append(")")
                end
                var ret = self.return_mtype
@@ -2595,10 +2613,16 @@ class MClassKind
        # Can a class of kind `self` specializes a class of kind `other`?
        fun can_specialize(other: MClassKind): Bool
        do
-               if other == interface_kind then return true # everybody can specialize interfaces
-               if self == interface_kind or self == enum_kind then
-                       # no other case for interfaces
+               if other == interface_kind then
+                       # everybody can specialize interfaces
+                       return true
+               else if self == interface_kind or self == enum_kind then
+                       # no other case for interfaces and enums
                        return false
+               else if self == subset_kind then
+                       # A subset may specialize anything, except another subset.
+                       # TODO: Allow sub-subsets once we can handle them.
+                       return other != subset_kind
                else if self == extern_kind then
                        # only compatible with themselves
                        return self == other
@@ -2619,6 +2643,8 @@ fun interface_kind: MClassKind do return once new MClassKind("interface", false,
 fun enum_kind: MClassKind do return once new MClassKind("enum", false, true, false)
 # The class kind `extern`
 fun extern_kind: MClassKind do return once new MClassKind("extern class", false, true, false)
+# The class kind `subset`
+fun subset_kind: MClassKind do return once new MClassKind("subset", true, false, false)
 
 # A standalone pre-constructed model used to test various model-related methods.
 #