redef class MMLocalClass
# The pos-th formal type parameter
- meth get_formal(pos: Int): MMTypeFormalParameter
+ fun get_formal(pos: Int): MMTypeFormalParameter
do
return formals_types[pos]
end
# Register a new formal type
# Called in order during the building of the class
- meth register_formal(f: MMTypeFormalParameter)
+ fun register_formal(f: MMTypeFormalParameter)
do
assert f.def_class == self
assert f.position == _formals_types.length
end
# All the insanciated types of the class
- attr _types: Array[MMTypeGeneric] = new Array[MMTypeGeneric]
+ var _types: Array[MMTypeGeneric] = new Array[MMTypeGeneric]
# Instanciate a type from the generic class
- meth get_instantiate_type(t: Array[MMType]): MMType
+ fun get_instantiate_type(t: Array[MMType]): MMType
do
for g in _types do
if g.params_equals(t) then return g
end
# The formal types of the class
- attr _formals_types: Array[MMTypeFormalParameter] = new Array[MMTypeFormalParameter]
+ var _formals_types: Array[MMTypeFormalParameter] = new Array[MMTypeFormalParameter]
# Return the definition formal types for the class
# Import them from the intro class if needed
- private meth formals_types: Array[MMTypeFormalParameter]
+ private fun formals_types: Array[MMTypeFormalParameter]
do
if _formals_types.is_empty then
assert not self isa MMConcreteClass
for i in [0..arity[ do
var oft = global.intro.get_formal(i)
var ft = _formals_types[i]
- ft.bound = oft.bound.for_module(module)
+ ft.bound = oft.bound.for_module(mmmodule)
end
end
return _formals_types
end
- redef meth get_type
+ redef fun get_type
do
if _base_type_cache == null and is_generic then
_base_type_cache = get_instantiate_type(formals_types)
- return _base_type_cache
+ return _base_type_cache.as(not null)
else
return super
end
end
# Is the class a generic one?
- meth is_generic: Bool do return arity > 0
+ fun is_generic: Bool do return arity > 0
end
redef class MMType
# TODO: IS this useful?
- meth is_generic: Bool is abstract
+ fun is_generic: Bool is abstract
end
redef class MMTypeFormal
- redef meth is_generic do return _bound.is_generic
+ redef fun is_generic do return _bound.is_generic
end
redef class MMTypeSimpleClass
- redef meth is_generic do return false
+ redef fun is_generic do return false
end
class MMTypeGeneric
-special MMTypeClass
+ super MMTypeClass
# Formal arguments
- readable attr _params: Array[MMType]
- attr _props: Map[MMGlobalProperty, MMLocalProperty] = new HashMap[MMGlobalProperty, MMLocalProperty]
+ readable var _params: Array[MMType]
- redef meth is_generic do return true
+ redef fun is_generic do return true
- redef meth is_supertype(t)
+ redef fun is_supertype(t)
do
if t.local_class.cshe <= _local_class then
var u = t.upcast_for(_local_class)
return false
end
- redef meth upcast_for(c)
+ redef fun upcast_for(c)
do
var t = super
if t != self then
return t
end
- redef meth for_module(mod)
+ redef fun for_module(mod)
do
var t: MMType = self
- if module != mod then
+ if mmmodule != mod then
var parms = new Array[MMType]
for p in _params do
parms.add(p.for_module(mod))
var b = _local_class.for_module(mod)
t = b.get_instantiate_type(parms)
end
- assert t != null
return t
end
- redef meth adapt_to(r)
+ redef fun adapt_to(r)
do
var rv = new Array[MMType]
for i in _params do
return l
end
- private meth params_equals(t: Array[MMType]): Bool
+ private fun params_equals(t: Array[MMType]): Bool
do
if t.length != _params.length then
return false
end
for i in [0..t.length[ do
- assert _params[i] != null
- assert t[i] != null
if _params[i] != t[i] then
return false
end
return true
end
- redef meth select_property(g)
- do
- if g == null then
- return null
- end
- if not _props.has_key(g) then
- assert _local_class != null
- var p = _local_class[g]
- if p != null then
- #var p2 = p.adapt_property(self)
- #_props[g] = p2
- #return p2
- return p
- else
- assert false
- end
- end
- return _props[g]
- end
-
- redef meth to_s
+ redef fun to_s
do
return "{super}[{_params.join(", ")}]"
end
# Is self a subtype of t?
# Require that t.local_class = self.local_class
- private meth is_subtype(t: MMTypeGeneric) : Bool
+ private fun is_subtype(t: MMTypeGeneric) : Bool
do
for i in [0.._params.length[
do
end
class MMTypeFormalParameter
-special MMTypeFormal
+ super MMTypeFormal
# The class where self is defined
- readable attr _def_class: MMLocalClass
+ readable var _def_class: MMLocalClass
# The position is self in def_class
- readable attr _position: Int
+ readable var _position: Int
- redef meth module do return _def_class.module
+ redef fun mmmodule do return _def_class.mmmodule
- redef meth for_module(mod)
+ redef fun for_module(mod)
do
var t: MMType = self
- if module != mod then
+ if mmmodule != mod then
t = mod[_def_class.global].get_formal(position)
end
- assert t != null
return t
end
- redef meth upcast_for(c) do return self
+ redef fun upcast_for(c) do return _bound.upcast_for(c)
- meth bound=(t: MMType)
+ fun bound=(t: MMType)
do
assert _bound == null
_bound = t
end
- redef meth adapt_to(r)
+ redef fun adapt_to(r)
do
r = r.direct_type
var old_r = r.upcast_for(def_class)
#if not old_r isa MMTypeGeneric then
- # print "adapt {self}'{def_class}'{self.module} to {r}'{r.module}"
- # print " old_r = {old_r}'{old_r.module}"
+ # print "adapt {self}'{def_class}'{self.mmmodule} to {r}'{r.mmmodule}"
+ # print " old_r = {old_r}'{old_r.mmmodule}"
#end
assert old_r isa MMTypeGeneric
var reduct = old_r.params[position]
- assert reduct != null
return reduct
end
init(n: Symbol, p: Int, intro: MMLocalClass)
do
- assert n != null
- _name = n
+ super(n, null)
_position = p
_def_class = intro
end
end
redef class MMTypeNone
- redef meth is_generic do return false
- redef meth for_module(mod) do return self
- redef meth adapt_to(r) do return self
+ redef fun is_generic do return false
+ redef fun for_module(mod) do return self
+ redef fun adapt_to(r) do return self
end