# 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
init(tc, module) do super
- private meth get_default_constructor_for(n: PNode, c: MMLocalClass, prop: MMMethod): MMMethod
+ private meth get_default_constructor_for(n: PNode, c: MMLocalClass, prop: MMSrcMethod): MMMethod
do
var v = self
#var prop = v.local_property
if not g.is_init then continue
if g.intro.local_class != c then continue
var gp = c[g]
- assert gp isa MMMethod
+ assert gp isa MMSrcMethod
var garity = gp.signature.arity
- if prop != null and g.intro.name == prop.name then
- if garity == 0 or prop.signature < gp.signature then
+ if prop != null and gp.name == prop.name then
+ if garity == 0 or (parity == garity and prop.signature < gp.signature) then
return gp
else
false_candidates.add(gp)
end
- else if garity == 0 then
+ else if garity == 0 and gp.name == once ("init".to_symbol) then
candidates.add(gp)
false_candidates.add(gp)
else
v.error(n, "Error: Conflicting default constructor to call for {c}: {candidates.join(", ")}.")
return null
else if false_candidates.length > 0 then
- v.error(n, "Error: there is no available compatible constrctor in {c}.")
+ v.error(n, "Error: there is no available compatible constrctor in {c}. discarded candidates are {false_candidates.join(", ")}.")
return null
else
v.warning(n, "Error: there is no available compatible constrctor in {c}.")
attr _dico: Map[Symbol, Variable]
# Build a new VariableContext
- meth sub: VariableContext
+ meth sub: SubVariableContext
do
- return new SubVariableContext.with(self, null, null)
+ return new SubVariableContext.with_prev(self, null, null)
end
# Build a nested VariableContext with new variable information
- meth sub_with(v: Variable, t: MMType): VariableContext
+ meth sub_with(v: Variable, t: MMType): SubVariableContext
do
- return new SubVariableContext.with(self, v, t)
+ return new SubVariableContext.with_prev(self, v, t)
end
init
return prev.stype(v)
end
- init with(p: VariableContext, v: Variable, t: MMType)
+ init with_prev(p: VariableContext, v: Variable, t: MMType)
do
init
_prev = p
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
else
var i = 0
var l = explicit_super_init_calls.length
- var cur_m: MMMethod
- var cur_c: MMLocalClass
+ var cur_m: MMMethod = null
+ var cur_c: MMLocalClass = null
if i < l then
cur_m = explicit_super_init_calls[i]
cur_c = cur_m.global.intro.local_class
# 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
end
redef class AVardeclExpr
- # Assiociated local variable
- readable attr _variable: Variable
-
redef meth after_typing(v)
do
- var va = new Variable(n_id.to_symbol, self)
- _variable = va
+ var va = new VarVariable(n_id.to_symbol, self)
+ variable = va
v.variable_ctx.add(va)
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
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
end
redef class AForVardeclExpr
- # Associated automatic local variable
- readable attr _variable: Variable
-
redef meth after_typing(v)
do
v.variable_ctx = v.variable_ctx.sub
- var variable = new Variable(n_id.to_symbol, self)
- _variable = variable
- v.variable_ctx.add(variable)
+ var va = new AutoVariable(n_id.to_symbol, self)
+ variable = va
+ 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.select_method(once ("iterator".to_symbol))
+ var prop = expr_type.local_class.select_method(once ("iterator".to_symbol))
if prop == null then
v.error(self, "Error: Collection MUST have an iterate method")
return
end
- var iter_type = prop.signature.return_type
- var prop2 = iter_type.select_method(once ("item".to_symbol))
+ var iter_type = prop.signature_for(expr_type).return_type
+ var prop2 = iter_type.local_class.select_method(once ("item".to_symbol))
if prop2 == null then
v.error(self, "Error: {iter_type} MUST have an item method")
return
end
- var t = prop2.signature.return_type
+ var t = prop2.signature_for(iter_type).return_type
if not n_expr.is_self then t = t.not_for_self
- variable.stype = t
+ va.stype = t
end
end
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 AVarFormExpr
- # Associated local variable
- readable writable attr _variable: Variable
-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
return
end
var name = n_assign_op.method_name
- var prop = type_lvalue.select_method(name)
+ var prop = type_lvalue.local_class.select_method(name)
if prop == null then
v.error(self, "Error: Method '{name}' doesn't exists in {type_lvalue}.")
return
end
prop.global.check_visibility(v, self, v.module, false)
- var psig = prop.signature
+ var psig = prop.signature_for(type_lvalue)
_assign_method = prop
- v.check_conform(self, 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
readable attr _assign_method: MMMethod
end
+redef class AVarReassignExpr
+ redef meth after_typing(v)
+ do
+ var t = v.variable_ctx.stype(variable)
+ do_lvalue_typing(v, t)
+ end
+end
+
redef class PAssignOp
meth method_name: Symbol is abstract
end
redef meth method_name do return once "-".to_symbol
end
-redef class AVarReassignExpr
- redef meth after_typing(v)
- do
- var t = v.variable_ctx.stype(variable)
- do_lvalue_typing(v, t)
- 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
redef meth after_typing(v)
do
- var stype: MMType
+ var stype: MMType = null
for n in n_exprs do
var ntype = n.stype
if stype == null or (ntype != null and stype < ntype) then
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
readable attr _init_in_superclass: MMMethod
redef meth after_typing(v)
do
- var precs: Array[MMLocalProperty] = v.local_property.cprhe.direct_greaters
+ var precs: Array[MMLocalProperty] = v.local_property.prhe.direct_greaters
if not precs.is_empty then
v.local_property.need_super = true
else if v.local_property.global.is_init then
if not p.global.is_init then
v.error(self, "Error: {p.local_class}::{p} is not a constructor.")
else
- precs.add(v.self_type.select_property(p.global))
+ precs.add(v.local_class[p.global])
end
end
if precs.is_empty then
_init_in_superclass = p
register_super_init_call(v, p)
if n_args.length > 0 then
- _arguments = process_signature(v, p, true, n_args.to_a)
+ var signature = get_signature(v, v.self_var.stype, p, true)
+ _arguments = process_signature(v, signature, p, 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.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
+ var stype: MMType = null
for prop in precs do
assert prop isa MMMethod
- var t = prop.signature.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
# Attribute accessed
readable attr _prop: MMAttribute
+ # Attribute type of the acceded attribute
+ readable attr _attr_type: MMType
+
# 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.select_attribute(name)
+ var prop = type_recv.local_class.select_attribute(name)
if prop == null then
v.error(self, "Error: Attribute {name} doesn't exists in {type_recv}.")
return
v.error(self, "Error: Attribute {name} from {prop.global.local_class.module} is invisible in {v.module}")
end
_prop = prop
+ var at = prop.signature_for(type_recv).return_type
+ if not n_expr.is_self then at = at.not_for_self
+ _attr_type = at
end
end
if prop == null then
return
end
- var attr_type = prop.signature.return_type
- if not n_expr.is_self then attr_type = attr_type.not_for_self
_stype = attr_type
end
end
if prop == null then
return
end
- var attr_type = prop.signature.return_type
- if not n_expr.is_self then attr_type = attr_type.not_for_self
- v.check_conform(self, n_value.stype, attr_type)
+ v.check_conform_expr(n_value, attr_type)
end
end
if prop == null then
return
end
- var attr_type = prop.signature.return_type
- if not n_expr.is_self then attr_type = attr_type.not_for_self
do_lvalue_typing(v, attr_type)
end
end
do
var prop = get_property(v, type_recv, is_implicit_self, name)
if prop == null then return
- var args = process_signature(v, prop, recv_is_self, raw_args)
+ 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)
if args == null then return
_prop = prop
_arguments = args
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.select_method(name)
+ 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.select_property(props.first.global)
+ var p = type_recv.local_class[props.first.global]
assert p isa MMMethod
prop = p
end
return prop
end
- private meth process_signature(v: TypingVisitor, prop: MMMethod, recv_is_self: Bool, raw_args: Array[PExpr]): Array[PExpr]
+ 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
+ var psig = prop.signature_for(type_recv)
+ if not recv_is_self then psig = psig.not_for_self
+ return psig
+ 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]
+ do
var par_vararg = psig.vararg_rank
var par_arity = psig.arity
var raw_arity: Int
for par_idx in [0..par_arity[ do
var a: PExpr
var par_type = psig[par_idx]
- if not recv_is_self then par_type = par_type.not_for_self
if par_idx == par_vararg then
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)
v.error(self, "Error: Constructor invocation {property} must not be in nested block.")
end
var cla = v.module[property.global.intro.local_class.global]
- var prev_class: MMLocalClass
+ var prev_class: MMLocalClass = null
if not v.explicit_super_init_calls.is_empty then
prev_class = v.explicit_super_init_calls.last.global.intro.local_class
end
end
do_typing(v, t, false, false, name, n_args.to_a)
+ if prop == null then return
+
if not prop.global.is_init then
v.error(self, "Error: {prop} is not a constructor.")
end
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
if prop.global.is_init then
register_super_init_call(v, prop)
end
end
- var t = prop.signature.return_type
+ 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
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
v.error(self, "Error: constructor {prop} is not invoken on 'self'.")
end
end
- var t = prop.signature.return_type
+ var t = prop.signature_for(n_expr.stype).return_type
if not n_expr.is_self then t = t.not_for_self
do_lvalue_typing(v, t)
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
end
+redef class AAsCastExpr
+ redef meth after_typing(v)
+ do
+ v.check_expr(n_expr)
+ _stype = n_type.stype
+ end
+end
+
redef class AProxyExpr
redef meth after_typing(v)
do
nitlanguage / nit.git / blobdiff