# Current knowledge about variables names and types
readable writable attr _variable_ctx: VariableContext
- # Current knowledge about escapable blocs
+ # Current knowledge about escapable blocks
readable writable attr _escapable_ctx: EscapableContext = new EscapableContext(self)
# The current reciever
# Is a other constructor of the same class invoked
readable writable attr _explicit_other_init_call: Bool
+ # Make the if_true_variable_ctx of the expression effective
+ private meth use_if_true_variable_ctx(e: PExpr)
+ do
+ var ctx = e.if_true_variable_ctx
+ if ctx != null then
+ variable_ctx = ctx
+ end
+ end
+
init(tc, module) do super
private meth get_default_constructor_for(n: PNode, c: MMLocalClass, prop: MMSrcMethod): MMMethod
# Build a new VariableContext
meth sub: SubVariableContext
do
- return new SubVariableContext.with_prev(self, null, null)
+ return new SubVariableContext.with_prev(self)
end
# Build a nested VariableContext with new variable information
meth sub_with(v: Variable, t: MMType): SubVariableContext
do
- return new SubVariableContext.with_prev(self, v, t)
+ return new CastVariableContext.with_prev(self, v, t)
end
init
private class SubVariableContext
special VariableContext
readable attr _prev: VariableContext
- attr _variable: Variable
- attr _var_type: MMType
redef meth [](s)
do
redef meth stype(v)
do
+ return prev.stype(v)
+ end
+
+ init with_prev(p: VariableContext)
+ do
+ init
+ _prev = p
+ end
+end
+
+private class CastVariableContext
+special SubVariableContext
+ attr _variable: Variable
+ attr _var_type: MMType
+
+ redef meth stype(v)
+ do
if _variable == v then
return _var_type
end
init with_prev(p: VariableContext, v: Variable, t: MMType)
do
- init
- _prev = p
+ super(p)
_variable = v
_var_type =t
end
end
redef class PExpr
- redef readable attr _stype: MMType
-
+ redef readable attr _is_typed: Bool = false
+ redef meth is_statement: Bool do return _stype == null
+ redef meth stype
+ do
+ if not is_typed then
+ print "{locate}: not is_typed"
+ abort
+ end
+ if is_statement then
+ print "{locate}: is_statement"
+ abort
+ end
+ return _stype
+ end
+ attr _stype: MMType
+
# Is the expression the implicit receiver
meth is_implicit_self: Bool do return false
v.check_conform_expr(n_expr, va.stype)
end
else
- v.check_expr(n_expr)
+ if not v.check_expr(n_expr) then return
va.stype = n_expr.stype
end
+ _is_typed = true
end
end
super
v.variable_ctx = old_var_ctx
+ _is_typed = true
end
end
else if n_expr != null and t != null then
v.check_conform_expr(n_expr, t)
end
+ _is_typed = true
end
end
var t = esc.continue_stype
if n_expr == null and t != null then
- v.error(self, "Error: continue with a value required in this bloc.")
+ v.error(self, "Error: continue with a value required in this block.")
else if n_expr != null and t == null then
- v.error(self, "Error: continue without value required in this bloc.")
+ v.error(self, "Error: continue without value required in this block.")
else if n_expr != null and t != null then
v.check_conform_expr(n_expr, t)
end
+ _is_typed = true
end
end
var bl = esc.break_list
if n_expr == null and bl != null then
- v.error(self, "Error: break with a value required in this bloc.")
+ v.error(self, "Error: break with a value required in this block.")
else if n_expr != null and bl == null then
- v.error(self, "Error: break without value required in this bloc.")
+ v.error(self, "Error: break without value required in this block.")
else if n_expr != null and bl != null then
# Typing check can only be done later
bl.add(n_expr)
end
+ _is_typed = true
end
end
v.visit(n_expr)
v.check_conform_expr(n_expr, v.type_bool)
- if n_expr.if_true_variable_ctx != null then
- v.variable_ctx = n_expr.if_true_variable_ctx
- end
+ v.use_if_true_variable_ctx(n_expr)
v.visit(n_then)
# Restore variable ctx
v.visit(n_else)
v.variable_ctx = old_var_ctx
end
+ _is_typed = true
end
end
v.check_conform_expr(n_expr, v.type_bool)
v.escapable_ctx.pop
+ _is_typed = true
end
end
v.visit(n_expr)
+ if not v.check_conform_expr(n_expr, v.type_collection) then return
var expr_type = n_expr.stype
- if not v.check_conform_expr(n_expr, v.type_collection) then
- return
- end
_meth_iterator = expr_type.local_class.select_method(once ("iterator".to_symbol))
if _meth_iterator == null then
v.error(self, "Error: Collection MUST have an iterate method")
if n_block != null then v.visit(n_block)
# pop context
- var varctx = v.variable_ctx
+ var varctx = v.variable_ctx
assert varctx isa SubVariableContext
v.variable_ctx = varctx.prev
v.escapable_ctx.pop
+ _is_typed = true
end
end
redef meth after_typing(v)
do
v.check_conform_expr(n_expr, v.type_bool)
- if n_expr.if_true_variable_ctx != null then v.variable_ctx = n_expr.if_true_variable_ctx
+ v.use_if_true_variable_ctx(n_expr)
+ _is_typed = true
end
end
redef meth after_typing(v)
do
_stype = v.variable_ctx.stype(variable)
+ _is_typed = _stype != null
end
end
do
var t = v.variable_ctx.stype(variable)
v.check_conform_expr(n_value, t)
+ _is_typed = true
end
end
return
end
var name = n_assign_op.method_name
- var prop = type_lvalue.local_class.select_method(name)
- if prop == null then
+ var lc = type_lvalue.local_class
+ if not lc.has_global_property_by_name(name) then
v.error(self, "Error: Method '{name}' doesn't exists in {type_lvalue}.")
return
end
+ var prop = lc.select_method(name)
prop.global.check_visibility(v, self, v.module, false)
var psig = prop.signature_for(type_lvalue)
_assign_method = prop
- v.check_conform_expr(n_value, psig[0].not_for_self)
- v.check_conform(self, psig.return_type.not_for_self, n_value.stype)
+ if not v.check_conform_expr(n_value, psig[0].not_for_self) then return
+ if not v.check_conform(self, psig.return_type.not_for_self, n_value.stype) then return
end
# Method used through the reassigment operator (once computed)
do
var t = v.variable_ctx.stype(variable)
do_lvalue_typing(v, t)
+ _is_typed = true
end
end
do
variable = v.self_var
_stype = v.variable_ctx.stype(variable)
+ _is_typed = true
end
redef meth is_self do return true
var old_var_ctx = v.variable_ctx
v.visit(n_expr)
- if n_expr.if_true_variable_ctx != null then v.variable_ctx = n_expr.if_true_variable_ctx
+ v.use_if_true_variable_ctx(n_expr)
v.visit(n_then)
v.variable_ctx = old_var_ctx
v.visit(n_else)
v.check_conform_expr(n_expr, v.type_bool)
- if not v.check_expr(n_then) or not v.check_expr(n_else) then return
-
- var t = n_then.stype
- var te = n_else.stype
- if t < te then
- t = te
- else if not te < t then
- v.error(self, "Type error: {te} is not a subtype of {t}.")
- return
- end
-
- _stype = t
+ _stype = v.check_conform_multiexpr(null, [n_then, n_else])
+ _is_typed = _stype != null
end
end
redef meth after_typing(v)
do
_stype = v.type_bool
+ _is_typed = true
end
end
v.check_conform_expr(n_expr, v.type_bool)
v.check_conform_expr(n_expr2, v.type_bool)
_stype = v.type_bool
+ _is_typed = true
end
end
var old_var_ctx = v.variable_ctx
v.visit(n_expr)
- if n_expr.if_true_variable_ctx != null then v.variable_ctx = n_expr.if_true_variable_ctx
+ v.use_if_true_variable_ctx(n_expr)
v.visit(n_expr2)
if n_expr2.if_true_variable_ctx != null then
v.check_conform_expr(n_expr, v.type_bool)
v.check_conform_expr(n_expr2, v.type_bool)
_stype = v.type_bool
+ _is_typed = true
end
end
do
v.check_conform_expr(n_expr, v.type_bool)
_stype = v.type_bool
+ _is_typed = true
end
end
redef meth after_typing(v)
do
_stype = v.type_int
-
+ _is_typed = true
end
end
redef meth after_typing(v)
do
_stype = v.type_float
+ _is_typed = true
end
end
redef meth after_typing(v)
do
_stype = v.type_char
+ _is_typed = true
end
end
redef meth after_typing(v)
do
_stype = v.type_string
+ _is_typed = true
_meth_with_native = _stype.local_class.select_method(once "with_native".to_symbol)
if _meth_with_native == null then v.error(self, "{_stype} MUST have a with_native method.")
end
if _meth_add == null then v.error(self, "{_atype} MUST have an add method.")
_meth_to_s = v.type_object.local_class.select_method(once "to_s".to_symbol)
if _meth_to_s == null then v.error(self, "Object MUST have a to_s method.")
+ _is_typed = true
end
end
redef meth after_typing(v)
do
_stype = v.type_none
+ _is_typed = true
end
end
redef meth after_typing(v)
do
- var stype: MMType = null
- for n in n_exprs do
- var ntype = n.stype
- if stype == null or (ntype != null and stype < ntype) then
- stype = ntype
- end
- end
- for n in n_exprs do
- v.check_conform_expr(n, stype)
- end
+ var stype = v.check_conform_multiexpr(null, n_exprs)
+ if stype == null then return
do_typing(v, stype)
end
if _meth_with_capacity == null then v.error(self, "{_stype} MUST have a with_capacity method.")
_meth_add = _stype.local_class.select_method(once "add".to_symbol)
if _meth_add == null then v.error(self, "{_stype} MUST have an add method.")
+
+ _is_typed = true
end
end
readable attr _meth_init: MMMethod
redef meth after_typing(v)
do
+ if not v.check_expr(n_expr) or not v.check_expr(n_expr2) then return
var ntype = n_expr.stype
var ntype2 = n_expr2.stype
- if ntype == null or ntype == null then
- return
- end
if ntype < ntype2 then
ntype = ntype2
else if not ntype2 < ntype then
return
end
var dtype = v.type_discrete
- v.check_conform_expr(n_expr, dtype)
- v.check_conform_expr(n_expr2, dtype)
+ if not v.check_conform_expr(n_expr, dtype) or not v.check_conform_expr(n_expr2, dtype) then return
_stype = v.type_range(ntype)
+ _is_typed = true
end
end
var p = v.local_property
assert p isa MMSrcMethod
_prop = p
+ _is_typed = true
end
end
if not v.check_expr(n_expr) then return
var type_recv = n_expr.stype
var name = n_id.to_symbol
- var prop = type_recv.local_class.select_attribute(name)
- if prop == null then
+ var lc = type_recv.local_class
+ if not lc.has_global_property_by_name(name) then
v.error(self, "Error: Attribute {name} doesn't exists in {type_recv}.")
return
- else if v.module.visibility_for(prop.global.local_class.module) < 3 then
+ end
+ var prop = lc.select_attribute(name)
+ if v.module.visibility_for(prop.global.local_class.module) < 3 then
v.error(self, "Error: Attribute {name} from {prop.global.local_class.module} is invisible in {v.module}")
end
_prop = prop
redef meth after_typing(v)
do
do_typing(v)
- if prop == null then
- return
- end
+ if prop == null then return
_stype = attr_type
+ _is_typed = true
end
end
redef meth after_typing(v)
do
do_typing(v)
- if prop == null then
- return
- end
- v.check_conform_expr(n_value, attr_type)
+ if prop == null then return
+ if not v.check_conform_expr(n_value, attr_type) then return
+ _is_typed = true
end
end
redef meth after_typing(v)
do
do_typing(v)
- if prop == null then
- return
- end
+ if prop == null then return
do_lvalue_typing(v, attr_type)
+ _is_typed = true
end
end
-class AAbsSendExpr
+class AAbsAbsSendExpr
special PExpr
# The signature of the called property
readable attr _prop_signature: MMSignature
- # Compute the called global property
- private meth do_typing(v: TypingVisitor, type_recv: MMType, is_implicit_self: Bool, recv_is_self: Bool, name: Symbol, raw_args: Array[PExpr], closure_defs: Array[PClosureDef])
- do
- var prop = get_property(v, type_recv, is_implicit_self, name)
- if prop == null then return
- var sig = get_signature(v, type_recv, prop, recv_is_self)
- if sig == null then return
- var args = process_signature(v, sig, prop.name, raw_args)
- if args == null then return
- var rtype = process_closures(v, sig, prop.name, closure_defs)
- _prop = prop
- _prop_signature = sig
- _arguments = args
- _return_type = rtype
- end
-
- private meth get_property(v: TypingVisitor, type_recv: MMType, is_implicit_self: Bool, name: Symbol): MMMethod
- do
- if type_recv == null then return null
- var prop = type_recv.local_class.select_method(name)
- if prop == null and v.local_property.global.is_init then
- var props = type_recv.local_class.super_methods_named(name)
- if props.length > 1 then
- v.error(self, "Error: Ambigous method name '{name}' for {props.join(", ")}. Use explicit designation.")
- return null
- else if props.length == 1 then
- var p = type_recv.local_class[props.first.global]
- assert p isa MMMethod
- prop = p
- end
-
- end
- if prop == null then
- if is_implicit_self then
- v.error(self, "Error: Method or variable '{name}' unknown in {type_recv}.")
- else
- v.error(self, "Error: Method '{name}' doesn't exists in {type_recv}.")
- end
- return null
- end
- return prop
- end
-
- # Get the signature for a local property and a receiver
- private meth get_signature(v: TypingVisitor, type_recv: MMType, prop: MMMethod, recv_is_self: Bool): MMSignature
- do
- prop.global.check_visibility(v, self, v.module, recv_is_self)
- var psig = prop.signature_for(type_recv)
- if not recv_is_self then psig = psig.not_for_self
- return psig
- end
+ # The real arguments used (after star transformation) (once computed)
+ readable attr _arguments: Array[PExpr]
# Check the conformity of a set of arguments `raw_args' to a signature.
private meth process_signature(v: TypingVisitor, psig: MMSignature, name: Symbol, raw_args: Array[PExpr]): Array[PExpr]
end
if cd != null then
if cs.length == 0 then
- v.error(self, "Error: {name} does not require blocs.")
+ v.error(self, "Error: {name} does not require blocks.")
else if cd.length > cs.length or cd.length < min_arity then
- v.error(self, "Error: {name} requires {cs.length} blocs, {cd.length} found.")
+ v.error(self, "Error: {name} requires {cs.length} blocks, {cd.length} found.")
else
# Initialize the break list if a value is required for breaks (ie. if the method is a function)
var break_list: Array[ABreakExpr] = null
# Check break type conformity
if break_list != null then
- for n in break_list do
- var ntype = n.stype
- if t == null or (t != null and t < ntype) then
- t = ntype
- end
- end
- for n in break_list do
- v.check_conform_expr(n, t)
- end
+ t = v.check_conform_multiexpr(t, break_list)
end
end
else if min_arity != 0 then
- v.error(self, "Error: {name} requires {cs.length} blocs.")
+ v.error(self, "Error: {name} requires {cs.length} blocks.")
end
return t
end
+end
+
+class AAbsSendExpr
+special AAbsAbsSendExpr
+ # Compute the called global property
+ private meth do_typing(v: TypingVisitor, type_recv: MMType, is_implicit_self: Bool, recv_is_self: Bool, name: Symbol, raw_args: Array[PExpr], closure_defs: Array[PClosureDef])
+ do
+ var prop = get_property(v, type_recv, is_implicit_self, name)
+ if prop == null then return
+ var sig = get_signature(v, type_recv, prop, recv_is_self)
+ if sig == null then return
+ var args = process_signature(v, sig, prop.name, raw_args)
+ if args == null then return
+ var rtype = process_closures(v, sig, prop.name, closure_defs)
+ if rtype == null and sig.return_type != null then return
+ _prop = prop
+ _prop_signature = sig
+ _arguments = args
+ _return_type = rtype
+ end
+
+ private meth get_property(v: TypingVisitor, type_recv: MMType, is_implicit_self: Bool, name: Symbol): MMMethod
+ do
+ if type_recv == null then return null
+ var lc = type_recv.local_class
+ var prop: MMMethod = null
+ if lc.has_global_property_by_name(name) then prop = lc.select_method(name)
+ if prop == null and v.local_property.global.is_init then
+ var props = type_recv.local_class.super_methods_named(name)
+ if props.length > 1 then
+ v.error(self, "Error: Ambigous method name '{name}' for {props.join(", ")}. Use explicit designation.")
+ return null
+ else if props.length == 1 then
+ var p = type_recv.local_class[props.first.global]
+ assert p isa MMMethod
+ prop = p
+ end
+
+ end
+ if prop == null then
+ if is_implicit_self then
+ v.error(self, "Error: Method or variable '{name}' unknown in {type_recv}.")
+ else
+ v.error(self, "Error: Method '{name}' doesn't exists in {type_recv}.")
+ end
+ return null
+ end
+ return prop
+ end
+
+ # Get the signature for a local property and a receiver
+ private meth get_signature(v: TypingVisitor, type_recv: MMType, prop: MMMethod, recv_is_self: Bool): MMSignature
+ do
+ prop.global.check_visibility(v, self, v.module, recv_is_self)
+ var psig = prop.signature_for(type_recv)
+ if not recv_is_self then psig = psig.not_for_self
+ return psig
+ end
# The invoked method (once computed)
readable attr _prop: MMMethod
- # The real arguments used (after star transformation) (once computed)
- readable attr _arguments: Array[PExpr]
-
# The return type (if any) (once computed)
readable attr _return_type: MMType
end
if not prop.global.is_init then
v.error(self, "Error: {prop} is not a constructor.")
+ return
end
_stype = t
+ _is_typed = true
end
end
end
_stype = return_type
+ _is_typed = true
end
end
end
_arguments = old_args # FIXME: What if star parameters do not match betwen the two methods?
+ _is_typed = true
end
end
var variable = v.variable_ctx[name]
if variable != null then
if variable isa ClosureVariable then
- var n = new AClosureCallExpr(n_id, n_args, n_closure_defs)
+ var n = new AClosureCallExpr.init_aclosurecallexpr(n_id, n_args, n_closure_defs)
replace_with(n)
n.variable = variable
n.after_typing(v)
end
redef class AClosureCallExpr
+special AAbsAbsSendExpr
redef meth after_typing(v)
do
var va = variable
var sig = va.closure.signature
var args = process_signature(v, sig, n_id.to_symbol, n_args.to_a)
- if closure_defs != null then
- process_closures(v, sig, n_id.to_symbol, closure_defs)
+ if not n_closure_defs.is_empty then
+ process_closures(v, sig, n_id.to_symbol, n_closure_defs.to_a)
end
if args == null then return
- _prop = null
_prop_signature = sig
_arguments = args
_stype = sig.return_type
+ _is_typed = true
end
end
end
end
+class ATypeCheckExpr
+special PExpr
+ private meth check_expr_cast(v: TypingVisitor, n_expr: PExpr, n_type: PType)
+ do
+ if not v.check_expr(n_expr) then return
+ var etype = n_expr.stype
+ var ttype = n_type.stype
+ if etype == ttype then
+ v.warning(self, "Warning: Expression is already a {ttype}.")
+ else if etype < ttype then
+ v.warning(self, "Warning: Expression is already a {ttype} since it is a {etype}.")
+ end
+ end
+end
+
redef class AIsaExpr
+special ATypeCheckExpr
redef meth after_typing(v)
do
+ check_expr_cast(v, n_expr, n_type)
var variable = n_expr.its_variable
if variable != null then
_if_true_variable_ctx = v.variable_ctx.sub_with(variable, n_type.stype)
end
_stype = v.type_bool
+ _is_typed = true
end
end
redef class AAsCastExpr
+special ATypeCheckExpr
redef meth after_typing(v)
do
- v.check_expr(n_expr)
+ check_expr_cast(v, n_expr, n_type)
_stype = n_type.stype
+ _is_typed = _stype != null
end
end
redef class AProxyExpr
redef meth after_typing(v)
do
+ if not n_expr.is_typed then return
+ _is_typed = true
+ if n_expr.is_statement then return
_stype = n_expr.stype
end
end
nitlanguage / nit.git / blobdiff