end
end
+class MMParam
+ readable var _mmtype: MMType
+ readable var _name: Symbol
+
+ init ( t : MMType, n : Symbol )
+ do
+ _mmtype = t
+ _name = n
+ end
+end
+
# Signature for local properties
class MMSignature
# The type of the reveiver
readable var _recv: MMType
# The parameter types
- var _params: Array[MMType]
+ readable var _params: Array[MMParam]
# The return type
readable var _return_type: nullable MMType
fun [](i: Int): MMType
do
assert _params.length > i
- return _params[i]
+ return _params[i].mmtype
end
redef fun to_s
return self
end
var mod = r.mmmodule
- var p = new Array[MMType]
+ var p = new Array[MMParam]
for i in _params do
- p.add(i.for_module(mod).adapt_to(r))
+ var new_type = i.mmtype.for_module(mod).adapt_to(r)
+ var new_param
+ if new_type == i.mmtype then
+ new_param = i
+ else
+ new_param = new MMParam( new_type, i.name )
+ end
+
+ p.add( new_param )
end
var rv = _return_type
if rv != null then
if _not_for_self_cache != null then return _not_for_self_cache.as(not null)
var need_for_self = false
- var p = new Array[MMType]
+ var p = new Array[MMParam]
for i in _params do
- var i2 = i.not_for_self
- if i != i2 then need_for_self = true
- p.add(i2)
+ var new_type = i.mmtype.not_for_self
+ var new_param
+ if i.mmtype == new_type then
+ new_param = i
+ else
+ need_for_self = true
+ new_param = new MMParam( new_type, i.name )
+ end
+
+ p.add( new_param )
end
var rv = _return_type
return res
end
- init(params: Array[MMType], return_type: nullable MMType, r: MMType)
+ init(params: Array[MMParam], return_type: nullable MMType, r: MMType)
do
_params = params
_return_type = return_type
end
# A static type
-# Note that static type a related to a specific module
+# Note that static type is related to a specific module
abstract class MMType
# The module where self makes sence
fun mmmodule: MMModule is abstract
end
_super_init = base
- var params = new Array[MMType]
+ var params = new Array[MMParam]
if base != null then
var sig = base.signature
for i in [0..sig.arity[ do
- params.add(sig[i])
+ params.add(sig.params[i])
end
end
for a in unassigned_attributes do
var sig = a.signature
if sig == null then return # Broken attribute definition
- params.add(sig.return_type.as(not null))
+ params.add( new MMParam( sig.return_type.as(not null), once "recv".to_symbol))
end
signature = new MMSignature(params, null, local_class.get_type)
end
else if not v.signature_builder.untyped_params.is_empty then
v.error(v.signature_builder.untyped_params.first, "Error: Untyped parameter.")
else
- prop.signature = new MMSignature(new Array[MMType], null, v.local_class.get_type)
+ prop.signature = new MMSignature(new Array[MMParam], null, v.local_class.get_type)
for clos in v.signature_builder.closure_decls do
prop.signature.closures.add(clos.variable.closure)
end
end
var prop = prop
- var signature = new MMSignature(new Array[MMType], t, v.local_class.get_type)
+ var signature = new MMSignature(new Array[MMParam], t, v.local_class.get_type)
prop.signature = signature
var visibility_level = n_visibility.level
process_and_check(v, prop, n_id != null and n_kwredef != null, visibility_level)
end
if n_writable != null or n_id == null then
var m = _writemethod.as(not null)
- m.signature = new MMSignature(new Array[MMType].with_items(t), null, v.local_class.get_type)
+ m.signature = new MMSignature(new Array[MMParam].with_items(new MMParam(t, once "value".to_symbol)), null, v.local_class.get_type)
var vl = visibility_level
if n_id == null then
if n_writable == null then vl = 3 else vl = n_writable.n_visibility.level # write accessor has a specific visibility
redef fun process_and_check(v, prop, has_redef, visibility_level)
do
prop.global.visibility_level = visibility_level
- prop.signature = new MMSignature(new Array[MMType], null, v.local_class.get_type)
+ prop.signature = new MMSignature(new Array[MMParam], null, v.local_class.get_type)
# Disable all checks for main
end
end
redef fun accept_property_verifier(v)
do
super
- var signature = new MMSignature(new Array[MMType], n_type.get_stype(v), v.local_class.get_type)
+ var signature = new MMSignature(new Array[MMParam], n_type.get_stype(v), v.local_class.get_type)
prop.signature = signature
var visibility_level = n_visibility.level
process_and_check(v, prop, n_kwredef != null, visibility_level)
return
end
else if not v.signature_builder.params.is_empty or n_type != null then
- var pars = new Array[MMType]
+ var pars = new Array[MMParam]
for p in v.signature_builder.params do
- pars.add(p.stype.as(not null))
+ pars.add( new MMParam( p.stype.as(not null), p.n_id.to_symbol ) )
end
var ret: nullable MMType = null
if n_type != null then
end
var sig = v.signature_builder.signature
if sig == null then
- sig = new MMSignature(new Array[MMType], null, v.local_class.get_type)
+ sig = new MMSignature(new Array[MMParam], null, v.local_class.get_type)
end
if sig.return_type != null and n_kwbreak != null then
v.error(self, "Syntax Error: A break block cannot have a return value.")
end
# Add the finalizer to the closure signature
- var finalize_sig = new MMSignature(new Array[MMType], null, v.mmmodule.type_any) # FIXME should be no receiver
+ var finalize_sig = new MMSignature(new Array[MMParam], null, v.mmmodule.type_any) # FIXME should be no receiver
var finalizer_clos = new MMClosure(once ("break".to_symbol), finalize_sig, false, true)
sig.closures.add(finalizer_clos)
nitlanguage / nit.git / commitdiff