# The primitive type `String`
var string_type: MClassType = self.get_primitive_class("String").mclass_type is lazy
- # The primitive type `NativeString`
- var native_string_type: MClassType = self.get_primitive_class("NativeString").mclass_type is lazy
+ # The primitive type `CString`
+ var c_string_type: MClassType = self.get_primitive_class("CString").mclass_type is lazy
# A primitive type of `Array`
fun array_type(elt_type: MType): MClassType do return array_class.get_mtype([elt_type])
# ENSURE: `bound_mtype.mclass == self.mclass`
var bound_mtype: MClassType
- redef var location: Location
+ redef var location
redef fun visibility do return mclass.visibility
# 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.
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
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
return res
end
end
- abort
+ # Cannot found `self` in `resolved_receiver`
+ return new MErrorType(model)
end
# A PT is fixed when:
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)
# 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
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]