# Current knowledge about variables names and types
readable writable attr _variable_ctx: VariableContext
- # Type of the receiver
- readable writable attr _self_type: MMType
+ # The current reciever
+ readable writable attr _self_var: ParamVariable
# Block of the current method
readable writable attr _top_block: PExpr
+ # Current closure 'return' static type (if any)
+ readable writable attr _closure_stype: MMType
+
+ # Current closure method return type (for break) (if any)
+ readable writable attr _closure_break_stype: MMType = null
+
+ # Current closure break expressions (if any)
+ readable writable attr _break_list: Array[PExpr]
+
# List of explicit invocation of constructors of super-classes
readable writable attr _explicit_super_init_calls: Array[MMMethod]
var false_candidates = new Array[MMMethod]
var parity = prop.signature.arity
for g in c.global_properties do
- if not g.is_init then continue
- if g.intro.local_class != c then continue
+ if not g.is_init_for(c) then continue
var gp = c[g]
+ var gps = gp.signature_for(c.get_type)
assert gp isa MMSrcMethod
- var garity = gp.signature.arity
+ var garity = gps.arity
if prop != null and gp.name == prop.name then
- if garity == 0 or (parity == garity and prop.signature < gp.signature) then
+ if garity == 0 or (parity == garity and prop.signature < gps) then
return gp
else
false_candidates.add(gp)
if candidates.length == 1 then
return candidates.first
else if candidates.length > 0 then
- v.error(n, "Error: Conflicting default constructor to call for {c}: {candidates.join(", ")}.")
+ var a = new Array[String]
+ for p in candidates do
+ a.add("{p.full_name}{p.signature}")
+ end
+ v.error(n, "Error: Conflicting default constructor to call for {c}: {a.join(", ")}.")
return null
else if false_candidates.length > 0 then
- v.error(n, "Error: there is no available compatible constrctor in {c}. discarded candidates are {false_candidates.join(", ")}.")
+ var a = new Array[String]
+ for p in false_candidates do
+ a.add("{p.full_name}{p.signature}")
+ end
+ v.error(n, "Error: there is no available compatible constrctor in {c}. Discarded candidates are {a.join(", ")}.")
return null
else
- v.warning(n, "Error: there is no available compatible constrctor in {c}.")
+ v.error(n, "Error: there is no available compatible constrctor in {c}.")
return null
end
end
redef class PClassdef
redef meth accept_typing(v)
do
- v.self_type = local_class.get_type
+ v.self_var = new ParamVariable("self".to_symbol, self)
+ v.self_var.stype = local_class.get_type
super
end
end
do
super
if n_expr != null then
- v.check_conform(n_expr, n_expr.stype, prop.signature.return_type)
+ v.check_conform_expr(n_expr, prop.signature.return_type)
end
end
end
redef class AMethPropdef
+ redef readable attr _self_var: ParamVariable
redef meth accept_typing(v)
do
v.variable_ctx = new VariableContext
+ _self_var = v.self_var
super
end
end
v.explicit_super_init_calls = explicit_super_init_calls
v.explicit_other_init_call = false
super
- if v.explicit_other_init_call then
+ if v.explicit_other_init_call or method.global.intro != method then
# TODO: something?
else
var i = 0
var cur_c: MMLocalClass = null
if i < l then
cur_m = explicit_super_init_calls[i]
- cur_c = cur_m.global.intro.local_class
+ cur_c = cur_m.global.intro.local_class.for_module(v.module)
end
var j = 0
while j < v.local_class.cshe.direct_greaters.length do
var c = v.local_class.cshe.direct_greaters[j]
- if c.global.is_interface or c.global.is_universal then
+ if c.global.is_interface or c.global.is_universal or c.global.is_mixin then
j += 1
- else if cur_c != null and c.cshe <= cur_c then
+ else if cur_c != null and (c.cshe <= cur_c or cur_c.global.is_mixin) then
if c == cur_c then j += 1
super_init_calls.add(cur_m)
i += 1
if i < l then
cur_m = explicit_super_init_calls[i]
- cur_c = cur_m.global.intro.local_class
+ cur_c = cur_m.global.intro.local_class.for_module(v.module)
else
cur_m = null
cur_c = null
redef class PParam
redef meth after_typing(v)
do
+ # TODO: why the test?
if v.variable_ctx != null then
v.variable_ctx.add(variable)
end
end
end
+redef class AClosureDecl
+ redef meth after_typing(v)
+ do
+ v.variable_ctx.add(variable)
+ end
+end
+
redef class PType
readable attr _stype: MMType
redef meth after_typing(v)
# Is the expression the current receiver (implicit or explicit)
meth is_self: Bool do return false
- # Is the expression a variable access
- meth is_variable: Bool do return false
+ # The variable accessed is any
+ meth its_variable: Variable do return null
# The variable type information if current boolean expression is true
readable private attr _if_true_variable_ctx: VariableContext
if n_type != null then
va.stype = n_type.stype
if n_expr != null then
- v.check_conform(self, n_expr.stype, va.stype)
+ v.check_conform_expr(n_expr, va.stype)
end
else
+ v.check_expr(n_expr)
va.stype = n_expr.stype
end
end
else if n_expr != null and t == null then
v.error(self, "Error: Return with value in a procedure.")
else if n_expr != null and t != null then
- v.check_conform(self, n_expr.stype, t)
+ v.check_conform_expr(n_expr, t)
+ end
+ end
+end
+
+redef class AContinueExpr
+ redef meth after_typing(v)
+ do
+ var t = v.closure_stype
+ if n_expr == null and t != null then
+ v.error(self, "Error: continue with a value required in this bloc.")
+ else if n_expr != null and t == null then
+ v.error(self, "Error: continue without value required in this bloc.")
+ else if n_expr != null and t != null then
+ v.check_conform_expr(n_expr, t)
+ end
+ end
+end
+
+redef class ABreakExpr
+ redef meth after_typing(v)
+ do
+ var t = v.closure_break_stype
+ if n_expr == null and t != null then
+ v.error(self, "Error: break with a value required in this bloc.")
+ else if n_expr != null and t == null then
+ v.error(self, "Error: break without value required in this bloc.")
+ else if n_expr != null and t != null then
+ # Typing check can only be done later
+ v.break_list.add(n_expr)
end
end
end
do
var old_var_ctx = v.variable_ctx
v.visit(n_expr)
- v.check_conform(self, n_expr.stype, v.type_bool)
+ 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
redef class AWhileExpr
redef meth after_typing(v)
do
- v.check_conform(self, n_expr.stype, v.type_bool)
+ v.check_conform_expr(n_expr, v.type_bool)
end
end
v.variable_ctx.add(va)
var expr_type = n_expr.stype
- if not v.check_conform(self, expr_type, v.type_collection) then
+ if not v.check_conform_expr(n_expr, v.type_collection) then
return
end
var prop = expr_type.local_class.select_method(once ("iterator".to_symbol))
redef class AAssertExpr
redef meth after_typing(v)
do
- v.check_conform(self, n_expr.stype, v.type_bool)
+ 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
end
redef class AVarExpr
- redef meth is_variable do return true
+ redef meth its_variable do return variable
redef meth after_typing(v)
do
redef meth after_typing(v)
do
var t = v.variable_ctx.stype(variable)
- v.check_conform(self, n_value.stype, t)
+ v.check_conform_expr(n_value, t)
end
end
prop.global.check_visibility(v, self, v.module, false)
var psig = prop.signature_for(type_lvalue)
_assign_method = prop
- v.check_conform(n_value, n_value.stype, psig[0].not_for_self)
+ v.check_conform_expr(n_value, psig[0].not_for_self)
v.check_conform(self, psig.return_type.not_for_self, n_value.stype)
end
end
redef class ASelfExpr
+ redef meth its_variable do return variable
+
redef meth after_typing(v)
do
- assert v.self_type != null
- _stype = v.self_type
+ variable = v.self_var
+ _stype = v.variable_ctx.stype(variable)
end
redef meth is_self do return true
v.variable_ctx = old_var_ctx
v.visit(n_else)
- v.check_conform(self, n_expr.stype, v.type_bool)
+ 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
redef class AOrExpr
redef meth after_typing(v)
do
- v.check_conform(self, n_expr.stype, v.type_bool)
- v.check_conform(self, n_expr2.stype, v.type_bool)
+ v.check_conform_expr(n_expr, v.type_bool)
+ v.check_conform_expr(n_expr2, v.type_bool)
_stype = v.type_bool
end
end
v.variable_ctx = old_var_ctx
- v.check_conform(self, n_expr.stype, v.type_bool)
- v.check_conform(self, n_expr2.stype, v.type_bool)
+ v.check_conform_expr(n_expr, v.type_bool)
+ v.check_conform_expr(n_expr2, v.type_bool)
_stype = v.type_bool
end
end
redef class ANotExpr
redef meth after_typing(v)
do
- v.check_conform(self, n_expr.stype, v.type_bool)
+ v.check_conform_expr(n_expr, v.type_bool)
_stype = v.type_bool
end
end
end
end
for n in n_exprs do
- v.check_conform(self, n.stype, stype)
+ v.check_conform_expr(n, stype)
end
_stype = v.type_array(stype)
end
return
end
var dtype = v.type_discrete
- v.check_conform(self, ntype, dtype)
+ v.check_conform_expr(n_expr, dtype)
+ v.check_conform_expr(n_expr2, dtype)
_stype = v.type_range(ntype)
end
end
_init_in_superclass = p
register_super_init_call(v, p)
if n_args.length > 0 then
- var signature = get_signature(v, v.self_type, p, true)
- _arguments = process_signature(v, signature, p, n_args.to_a)
+ var signature = get_signature(v, v.self_var.stype, p, true)
+ _arguments = process_signature(v, signature, p.name, n_args.to_a)
end
else
v.error(self, "Error: No super method to call for {v.local_property}.")
return
end
- if precs.first.signature_for(v.self_type).return_type != null then
+ if precs.first.signature_for(v.self_var.stype).return_type != null then
var stypes = new Array[MMType]
var stype: MMType = null
for prop in precs do
assert prop isa MMMethod
- var t = prop.signature_for(v.self_type).return_type.for_module(v.module).adapt_to(v.local_property.signature.recv)
+ var t = prop.signature_for(v.self_var.stype).return_type.for_module(v.module).adapt_to(v.local_property.signature.recv)
stypes.add(t)
if stype == null or stype < t then
stype = t
# Compute the attribute accessed
private meth do_typing(v: TypingVisitor)
do
+ if not v.check_expr(n_expr) then return
var type_recv = n_expr.stype
- if type_recv == null then
- return
- end
var name = n_id.to_symbol
var prop = type_recv.local_class.select_attribute(name)
if prop == null then
if prop == null then
return
end
- v.check_conform(self, n_value.stype, attr_type)
+ v.check_conform_expr(n_value, attr_type)
end
end
class AAbsSendExpr
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])
do
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, raw_args)
+ var args = process_signature(v, sig, prop.name, raw_args)
if args == null then return
_prop = prop
+ _prop_signature = sig
_arguments = args
end
end
# Check the conformity of a set of arguments `raw_args' to a signature.
- private meth process_signature(v: TypingVisitor, psig: MMSignature, prop: MMMethod, raw_args: Array[PExpr]): Array[PExpr]
+ private meth process_signature(v: TypingVisitor, psig: MMSignature, name: Symbol, raw_args: Array[PExpr]): Array[PExpr]
do
var par_vararg = psig.vararg_rank
var par_arity = psig.arity
var raw_arity: Int
if raw_args == null then raw_arity = 0 else raw_arity = raw_args.length
if par_arity > raw_arity or (par_arity != raw_arity and par_vararg == -1) then
- v.error(self, "Error: Method '{prop}' arity missmatch.")
+ v.error(self, "Error: '{name}' arity missmatch.")
return null
end
var arg_idx = 0
var star = new Array[PExpr]
for i in [0..(raw_arity-par_arity)] do
a = raw_args[arg_idx]
- v.check_conform(self, a.stype, par_type)
+ v.check_conform_expr(a, par_type)
star.add(a)
arg_idx = arg_idx + 1
end
a = aa
else
a = raw_args[arg_idx]
- v.check_conform(self, a.stype, par_type)
+ v.check_conform_expr(a, par_type)
arg_idx = arg_idx + 1
end
args.add(a)
# Raw arguments used (withour star transformation)
meth raw_arguments: Array[PExpr] is abstract
+ # Closure definitions
+ meth closure_defs: Array[PClosureDef] do return null
+
redef meth after_typing(v)
do
do_all_typing(v)
private meth do_all_typing(v: TypingVisitor)
do
+ if not v.check_expr(n_expr) then return
do_typing(v, n_expr.stype, n_expr.is_implicit_self, n_expr.is_self, name, raw_arguments)
if prop == null then return
+
+ var t = prop.signature_for(n_expr.stype).return_type
+ if t != null and not n_expr.is_self then t = t.not_for_self
+
+ var cd = closure_defs
+ var cs = _prop_signature.closures # Closure signatures
+ if cd != null then
+ if cs.length == 0 then
+ v.error(self, "Error: property {prop} does not require blocs.")
+ else if cs.length != cd.length then
+ v.error(self, "Error: property {prop} requires {cs.length} blocs, {cd.length} found.")
+ else
+ var old_bbst = v.closure_break_stype
+ var old_bl = v.break_list
+ v.closure_break_stype = t
+ v.break_list = new Array[ABreakExpr]
+ for i in [0..cs.length[ do
+ cd[i].accept_typing2(v, cs[i])
+ end
+ for n in v.break_list do
+ var ntype = n.stype
+ if t == null or (t != null and t < ntype) then
+ t = ntype
+ end
+ end
+ for n in v.break_list do
+ v.check_conform_expr(n, t)
+ end
+
+ v.closure_break_stype = old_bbst
+ v.break_list = old_bl
+ end
+ else if cs.length != 0 then
+ v.error(self, "Error: property {prop} requires {cs.length} blocs.")
+ end
+
if prop.global.is_init then
if not v.local_property.global.is_init then
v.error(self, "Error: try to invoke constructor {prop} in a method.")
register_super_init_call(v, prop)
end
end
- var t = prop.signature_for(n_expr.stype).return_type
- if t != null and not n_expr.is_self then t = t.not_for_self
_stype = t
end
end
readable attr _read_prop: MMMethod
redef meth do_all_typing(v)
do
+ if not v.check_expr(n_expr) then return
var raw_args = raw_arguments
do_typing(v, n_expr.stype, n_expr.is_implicit_self, n_expr.is_self, name, raw_args)
if prop == null then return
redef class ACallFormExpr
redef meth after_typing(v)
do
- if n_expr.is_implicit_self then
+ if n_expr != null and n_expr.is_implicit_self then
var name = n_id.to_symbol
var variable = v.variable_ctx[name]
if variable != null then
- if not n_args.is_empty then
- v.error(self, "Error: {name} is variable, not a function.")
+ if variable isa ClosureVariable then
+ var n = new AClosureCallExpr(n_id, n_args, n_closure_defs)
+ replace_with(n)
+ n.variable = variable
+ n.after_typing(v)
+ return
+ else
+ if not n_args.is_empty then
+ v.error(self, "Error: {name} is variable, not a function.")
+ end
+ var vform = variable_create(variable)
+ vform.variable = variable
+ replace_with(vform)
+ vform.after_typing(v)
+ return
end
- var vform = variable_create(variable)
- vform.variable = variable
- replace_with(vform)
- vform.after_typing(v)
- return
end
end
super
end
+
+ redef meth closure_defs
+ do
+ if n_closure_defs == null or n_closure_defs.is_empty then
+ return null
+ else
+ return n_closure_defs.to_a
+ end
+ end
# Create a variable acces corresponding to the call form
meth variable_create(variable: Variable): AVarFormExpr is abstract
redef meth raw_arguments do return n_args.to_a
end
+redef class AClosureCallExpr
+ 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 args == null then return
+ _prop = null
+ _prop_signature = sig
+ _arguments = args
+ _stype = sig.return_type
+ end
+end
+
+redef class PClosureDef
+ attr _accept_typing2: Bool
+ redef meth accept_typing(v)
+ do
+ # Typing is deferred, wait accept_typing2(v)
+ if _accept_typing2 then super
+ end
+
+ private meth accept_typing2(v: TypingVisitor, clos: MMClosure) is abstract
+end
+
+redef class AClosureDef
+ redef meth accept_typing2(v, clos)
+ do
+ var sig = clos.signature
+ if sig.arity != n_id.length then
+ v.error(self, "Error: {sig.arity} automatic variable names expected, {n_id.length} found.")
+ return
+ end
+
+ closure = clos
+
+ var old_stype = v.closure_stype
+ v.closure_stype = sig.return_type
+
+ v.variable_ctx = v.variable_ctx.sub
+ variables = new Array[AutoVariable]
+ for i in [0..n_id.length[ do
+ var va = new AutoVariable(n_id[i].to_symbol, self)
+ variables.add(va)
+ va.stype = sig[i]
+ v.variable_ctx.add(va)
+ end
+
+ _accept_typing2 = true
+ accept_typing(v)
+
+ v.closure_stype = old_stype
+ end
+end
+
redef class AIsaExpr
redef meth after_typing(v)
do
- if n_expr.is_variable then
- var n = n_expr
- assert n isa AVarExpr
- _if_true_variable_ctx = v.variable_ctx.sub_with(n.variable, n_type.stype)
+ 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
end
redef class AAsCastExpr
redef meth after_typing(v)
do
+ v.check_expr(n_expr)
_stype = n_type.stype
- var et = n_expr.stype
end
end
nitlanguage / nit.git / blobdiff