# limitations under the License.
# Static types and property signatures
-package static_type
+module static_type
intrude import abstractmetamodel
end
end
+class MMParam
+ var mmtype: MMType
+ var name: Symbol writable
+
+ init ( t : MMType, n : Symbol )
+ do
+ mmtype = t
+ name = n
+ end
+
+ redef fun to_s do return "{name}: {mmtype}"
+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
var tmp: String
var a = new Array[String].with_capacity(_params.length)
for i in [0.._params.length[ do
- #var pn = _params_name[i]
var p = _params[i]
- #a.add("{pn}: {p}")
a.add(p.to_s)
end
- s.append("({a.join(",")})")
+ s.append("({a.join(", ")})")
end
var rt = _return_type
if rt != null then s.append(": {rt}")
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
end
+
+redef class MMExplicitImport
+ var signature : MMSignature
+
+ redef init( local_class : MMLocalClass, meth : MMMethod )
+ do
+ super
+ signature = meth.signature.adaptation_to( local_class.get_type )
+ end
+end
+
# A closure in a signature
class MMClosure
# The name of the closure (without the !)
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
# 'c' Must be a super-class of self
# Example:
# class A[E]
- # class B[F] special A[F]
- # class C[G] special B[String]
- # class D special C[Float]
+ # class B[F] super A[F]
+ # class C[G] super B[String]
+ # class D super C[Float]
# 'A[Int]'.upcast_for('A') -> 'A[Int]'
# 'A[Int]'.upcast_for('B') -> abort
# 'B[Int]'.upcast_for('B') -> 'B[Int]'
end
class MMNullableType
-special MMType
- var _base_type: MMType
+ super MMType
+ readable var _base_type: MMType
redef fun is_valid do return _base_type.is_valid
redef fun is_nullable: Bool do return true
redef fun as_notnull do return _base_type
end
end
-class MMTypeClass
-special MMType
+abstract class MMTypeClass
+ super MMType
redef readable var _local_class: MMLocalClass
redef fun mmmodule do return _local_class.mmmodule end
redef fun <(t) do return t.is_supertype(self)
end
class MMTypeSimpleClass
-special MMTypeClass
+ super MMTypeClass
redef fun is_supertype(t)
do
return t.local_class.cshe <= _local_class
# The type of null
class MMTypeNone
-special MMType
+ super MMType
redef readable var _mmmodule: MMModule
redef fun is_nullable: Bool do return true
redef fun <(t) do return t isa MMTypeNone or t isa MMNullableType
return class_by_name(once ("Bool".to_symbol)).get_type
end
end
+
+# Explicitly imported cast
+class MMImportedCast
+ readable var _from : MMType
+ readable var _to : MMType
+
+ fun is_about_nullable_only : Bool
+ do
+ return ( _from.is_nullable and _to.as_nullable == _from ) or
+ ( _to.is_nullable and _from.as_nullable == _to )
+ end
+
+ fun is_not_null_to_nullable : Bool
+ do
+ return not _from.is_nullable and _to.is_nullable
+ end
+
+ fun is_nullable_to_not_null : Bool
+ do
+ return _from.is_nullable and not _to.is_nullable
+ end
+
+ redef fun == ( o )
+ do
+ return o isa MMImportedCast and
+ o.from == from and o.to == to
+ end
+end
+
+# Method local properties
+redef class MMMethod
+ # casts explicitely imported to be available from native implementation
+ fun explicit_casts : Set[ MMImportedCast ] is abstract
+end
nitlanguage / nit.git / blobdiff