model: migrate model_json to new serialization API

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

diff --git a/src/model/model.nit b/src/model/model.nit
index 49f4171..3733566 100644 (file)
--- a/src/model/model.nit
+++ b/src/model/model.nit
@@ -603,7 +603,7 @@ class MClassDef
        # ENSURE: `bound_mtype.mclass == self.mclass`
        var bound_mtype: MClassType
 
-       redef var location: Location
+       redef var location
 
        redef fun visibility do return mclass.visibility
 
@@ -1054,6 +1054,21 @@ abstract class MType
        # In case of conflicts or inconsistencies in the model, the method returns a `MErrorType`.
        fun lookup_fixed(mmodule: MModule, resolved_receiver: MType): MType do return self
 
+       # Is the type a `MErrorType` or contains an `MErrorType`?
+       #
+       # `MErrorType` are used in result with conflict or inconsistencies.
+       #
+       # See `is_legal_in` to check conformity with generic bounds.
+       fun is_ok: Bool do return true
+
+       # Is the type legal in a given `mmodule` (with an optional `anchor`)?
+       #
+       # A type is valid if:
+       #
+       # * it does not contain a `MErrorType` (see `is_ok`).
+       # * its generic formal arguments are within their bounds.
+       fun is_legal_in(mmodule: MModule, anchor: nullable MClassType): Bool do return is_ok
+
        # Can the type be resolved?
        #
        # In order to resolve open types, the formal types must make sence.
@@ -1352,6 +1367,24 @@ class MGenericType
                return true
        end
 
+       redef fun is_ok
+       do
+               for t in arguments do if not t.is_ok then return false
+               return super
+       end
+
+       redef fun is_legal_in(mmodule, anchor)
+       do
+               var mtype
+               if need_anchor then
+                       assert anchor != null
+                       mtype = anchor_to(mmodule, anchor)
+               else
+                       mtype = self
+               end
+               if not mtype.is_ok then return false
+               return mtype.is_subtype(mmodule, null, mtype.mclass.intro.bound_mtype)
+       end
 
        redef fun depth
        do
@@ -1395,8 +1428,10 @@ class MVirtualType
 
        redef fun model do return self.mproperty.intro_mclassdef.mmodule.model
 
-       redef fun lookup_bound(mmodule: MModule, resolved_receiver: MType): MType
+       redef fun lookup_bound(mmodule, resolved_receiver)
        do
+               # There is two possible invalid cases: the vt does not exists in resolved_receiver or the bound is broken
+               if not resolved_receiver.has_mproperty(mmodule, mproperty) then return new MErrorType(model)
                return lookup_single_definition(mmodule, resolved_receiver).bound or else new MErrorType(model)
        end
 
@@ -1558,7 +1593,8 @@ class MParameterType
                                return res
                        end
                end
-               abort
+               # Cannot found `self` in `resolved_receiver`
+               return new MErrorType(model)
        end
 
        # A PT is fixed when:
@@ -1671,6 +1707,10 @@ abstract class MProxyType
                return self.mtype.can_resolve_for(mtype, anchor, mmodule)
        end
 
+       redef fun is_ok do return mtype.is_ok
+
+       redef fun is_legal_in(mmodule, anchor) do return mtype.is_legal_in(mmodule, anchor)
+
        redef fun lookup_fixed(mmodule, resolved_receiver)
        do
                var t = mtype.lookup_fixed(mmodule, resolved_receiver)
@@ -1813,6 +1853,7 @@ end
 # The error type can de used to denote things that are conflicting or inconsistent.
 #
 # Some methods on types can return a `MErrorType` to denote a broken or a conflicting result.
+# Use `is_ok` to check if a type is (or contains) a `MErrorType` .
 class MErrorType
        super MType
        redef var model
@@ -1822,6 +1863,7 @@ class MErrorType
        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 is_ok do return false
 
        redef fun collect_mclassdefs(mmodule) do return new HashSet[MClassDef]