package typing
import syntax_base
+import escape
redef class MMSrcModule
# Walk trough the module and type statments and expressions
# Current knowledge about variables names and types
readable writable attr _variable_ctx: VariableContext
+ # Current knowledge about escapable blocks
+ readable writable attr _escapable_ctx: EscapableContext = new EscapableContext(self)
+
# The current reciever
readable writable attr _self_var: ParamVariable
# 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
+
+ # Number of nested once
+ readable writable attr _once_count: Int = 0
+
init(tc, module) do super
private meth get_default_constructor_for(n: PNode, c: MMLocalClass, prop: MMSrcMethod): 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
# Associate symbols to variable and variables to type
# Can be nested
-private class VariableContext
+abstract class VariableContext
# Look for the variable from its name
# Return null if nothing found
meth [](s: Symbol): Variable
meth add(v: Variable)
do
_dico[v.name] = v
+ _all_variables.add(v)
+ end
+
+ meth mark_is_set(v: Variable)
+ do
+ _set_variables.add(v)
end
+ meth check_is_set(n: PNode, v: Variable)
+ do
+ if v.must_be_set and not is_set(v) then
+ _visitor.error(n, "Error: variable '{v}' is possibly unset.")
+ var x = self
+ while true do
+ print " {x.node.locate}: {x._set_variables.join(", ")} ; {x._dico.join(", ")}"
+ var x0 = x
+ if x0 isa SubVariableContext then
+ x = x0.prev
+ else
+ break
+ end
+ end
+ end
+ end
# The effective static type of a given variable
# May be different from the declaration static type
# Variables by name (in the current context only)
attr _dico: Map[Symbol, Variable]
+ # All variables in all contextes
+ attr _all_variables: Set[Variable]
+
# Build a new VariableContext
- meth sub: SubVariableContext
+ meth sub(node: PNode): SubVariableContext
do
- return new SubVariableContext.with_prev(self, null, null)
+ return new SubVariableContext.with_prev(self, node)
end
# Build a nested VariableContext with new variable information
- meth sub_with(v: Variable, t: MMType): SubVariableContext
+ meth sub_with(node: PNode, v: Variable, t: MMType): SubVariableContext
do
- return new SubVariableContext.with_prev(self, v, t)
+ return new CastVariableContext.with_prev(self, node, v, t)
end
- init
- do
+ # The visitor of the context (used to display error)
+ attr _visitor: AbsSyntaxVisitor
+
+ # The syntax node that introduced the context
+ readable attr _node: PNode
+
+ init(visitor: AbsSyntaxVisitor, node: PNode)
+ do
+ _visitor = visitor
+ _node = node
_dico = new HashMap[Symbol, Variable]
end
+
+ # Is a control flow break met? (return, break, continue)
+ readable writable attr _unreash: Bool = false
+
+ # Is a control flow already broken?
+ # Used to avoid repeating the same error message
+ readable writable attr _already_unreash: Bool = false
+
+ # Set of variable that are set (assigned)
+ readable attr _set_variables: HashSet[Variable] = new HashSet[Variable]
+
+ # Is a variable set?
+ meth is_set(v: Variable): Bool
+ do
+ return _set_variables.has(v)
+ end
+
+ # Merge back one flow context information
+ meth merge(ctx: VariableContext)
+ do
+ if ctx.unreash then
+ unreash = true
+ if ctx.already_unreash then already_unreash = true
+ return
+ end
+ for v in _all_variables do
+ if not is_set(v) and ctx.is_set(v) then
+ mark_is_set(v)
+ end
+ end
+ end
+
+ # Merge back two alternative flow context informations
+ meth merge2(ctx1, ctx2: VariableContext)
+ do
+ if ctx1.unreash then
+ merge(ctx2)
+ else if ctx2.unreash then
+ merge(ctx1)
+ end
+ for v in _all_variables do
+ if not is_set(v) and ctx1.is_set(v) and ctx2.is_set(v) then
+ mark_is_set(v)
+ end
+ end
+ end
+end
+
+class RootVariableContext
+special VariableContext
+ init(visitor: AbsSyntaxVisitor, node: PNode)
+ do
+ super(visitor, node)
+ _all_variables = new HashSet[Variable]
+ end
end
-private class SubVariableContext
+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, node: PNode)
+ do
+ init(p._visitor, node)
+ _prev = p
+ _all_variables = p._all_variables
+ end
+
+ redef meth is_set(v)
+ do
+ return _set_variables.has(v) or _prev.is_set(v)
+ end
+end
+
+class CastVariableContext
+special SubVariableContext
+ attr _variable: Variable
+ attr _var_type: MMType
+
+ redef meth stype(v)
+ do
if _variable == v then
return _var_type
end
return prev.stype(v)
end
- init with_prev(p: VariableContext, v: Variable, t: MMType)
+ init with_prev(p: VariableContext, node: PNode, v: Variable, t: MMType)
do
- init
- _prev = p
+ super(p, node)
_variable = v
_var_type =t
end
end
+redef class Variable
+ # Is the variable must be set before being used ?
+ meth must_be_set: Bool do return false
+end
+
+redef class VarVariable
+ redef meth must_be_set do return true
+end
+
###############################################################################
redef readable attr _self_var: ParamVariable
redef meth accept_typing(v)
do
- v.variable_ctx = new VariableContext
+ v.variable_ctx = new RootVariableContext(v, self)
_self_var = v.self_var
super
end
end
+redef class AConcreteMethPropdef
+ redef meth accept_typing(v)
+ do
+ super
+ if v.variable_ctx.unreash == false and method.signature.return_type != null then
+ v.error(self, "Control error: Reached end of function (a 'return' with a value was expected).")
+ end
+ end
+end
+
redef class AConcreteInitPropdef
readable attr _super_init_calls: Array[MMMethod] = new Array[MMMethod]
readable attr _explicit_super_init_calls: Array[MMMethod] = new Array[MMMethod]
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
+ # The corresponding escapable object
+ readable attr _escapable: EscapableBlock
+
+ redef meth accept_typing(v)
+ do
+ # Register the closure for ClosureCallExpr
+ v.variable_ctx.add(variable)
+
+ var old_var_ctx = v.variable_ctx
+ v.variable_ctx = v.variable_ctx.sub(self)
+
+ _escapable = new EscapableClosure(self, variable.closure, null)
+ v.escapable_ctx.push(_escapable)
+
+ super
+
+ if n_expr != null then
+ if v.variable_ctx.unreash == false then
+ if variable.closure.signature.return_type != null then
+ v.error(self, "Control error: Reached end of block (a 'continue' with a value was expected).")
+ else if variable.closure.is_break then
+ v.error(self, "Control error: Reached end of break block (an 'abort' was expected).")
+ end
+ end
+ end
+
+ old_var_ctx.merge(v.variable_ctx)
+ v.variable_ctx = old_var_ctx
+ v.escapable_ctx.pop
+ end
+end
+
redef class PType
readable attr _stype: MMType
redef meth after_typing(v)
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
var va = new VarVariable(n_id.to_symbol, self)
variable = va
v.variable_ctx.add(va)
+ if n_expr != null then v.variable_ctx.mark_is_set(va)
if n_type != null then
va.stype = n_type.stype
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
redef meth accept_typing(v)
do
var old_var_ctx = v.variable_ctx
- v.variable_ctx = v.variable_ctx.sub
+ v.variable_ctx = v.variable_ctx.sub(self)
- super
+ for e in n_expr do
+ if v.variable_ctx.unreash and not v.variable_ctx.already_unreash then
+ v.variable_ctx.already_unreash = true
+ v.warning(e, "Warning: unreachable statement.")
+ end
+ v.visit(e)
+ end
+ old_var_ctx.merge(v.variable_ctx)
v.variable_ctx = old_var_ctx
+ _is_typed = true
end
end
redef class AReturnExpr
redef meth after_typing(v)
do
+ v.variable_ctx.unreash = true
var t = v.local_property.signature.return_type
if n_expr == null and t != null then
v.error(self, "Error: Return without value in a function.")
else if n_expr != null and t != null then
v.check_conform_expr(n_expr, t)
end
+ _is_typed = true
+ end
+end
+
+redef class AContinueExpr
+ redef meth after_typing(v)
+ do
+ v.variable_ctx.unreash = true
+ var esc = compute_escapable_block(v.escapable_ctx)
+ if esc == null then return
+
+ if esc.is_break_block then
+ v.error(self, "Error: 'continue' forbiden in break blocks.")
+ return
+ 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 block.")
+ else if n_expr != null and t == null then
+ 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
+
+redef class ABreakExpr
+ redef meth after_typing(v)
+ do
+ v.variable_ctx.unreash = true
+ var esc = compute_escapable_block(v.escapable_ctx)
+ if esc == null then return
+
+ var bl = esc.break_list
+ if n_expr == null and bl != null then
+ 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 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
+
+redef class AAbortExpr
+ redef meth after_typing(v)
+ do
+ v.variable_ctx.unreash = 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.variable_ctx = v.variable_ctx.sub(n_then)
v.visit(n_then)
- # Restore variable ctx
- v.variable_ctx = old_var_ctx
- if n_else != null then
+ if n_else == null then
+ # Restore variable ctx since the 'then' block is optional
+ v.variable_ctx = old_var_ctx
+ else
+ # Remember what appened in the 'then'
+ var then_var_ctx = v.variable_ctx
+ # Reset to process the 'else'
+ v.variable_ctx = old_var_ctx.sub(n_else)
v.visit(n_else)
+ # Merge then and else in the old control_flow
+ old_var_ctx.merge2(then_var_ctx, v.variable_ctx)
v.variable_ctx = old_var_ctx
end
+ _is_typed = true
end
end
redef class AWhileExpr
- redef meth after_typing(v)
+ # The corresponding escapable block
+ readable attr _escapable: EscapableBlock
+
+ redef meth accept_typing(v)
do
+ _escapable = new EscapableBlock(self)
+ v.escapable_ctx.push(_escapable)
+ var old_var_ctx = v.variable_ctx
+ v.variable_ctx = v.variable_ctx.sub(self)
+
+ super
+
v.check_conform_expr(n_expr, v.type_bool)
+ v.variable_ctx = old_var_ctx
+ v.escapable_ctx.pop
+ _is_typed = true
end
end
redef class AForExpr
- redef meth after_typing(v)
- do
- # pop context created in AForVardeclExpr
- var varctx = v.variable_ctx
- assert varctx isa SubVariableContext
- v.variable_ctx = varctx.prev
- end
-end
+ # The corresponding escapable block
+ readable attr _escapable: EscapableBlock
-redef class AForVardeclExpr
- redef meth after_typing(v)
+ readable attr _meth_iterator: MMMethod
+ readable attr _meth_is_ok: MMMethod
+ readable attr _meth_item: MMMethod
+ readable attr _meth_next: MMMethod
+ redef meth accept_typing(v)
do
- v.variable_ctx = v.variable_ctx.sub
+ _escapable = new EscapableBlock(self)
+ v.escapable_ctx.push(_escapable)
+
+ var old_var_ctx = v.variable_ctx
+ v.variable_ctx = v.variable_ctx.sub(self)
var va = new AutoVariable(n_id.to_symbol, self)
variable = va
v.variable_ctx.add(va)
+ 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
+ _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")
return
end
- 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")
+ var iter_type = _meth_iterator.signature_for(expr_type).return_type
+ _meth_is_ok = iter_type.local_class.select_method(once ("is_ok".to_symbol))
+ if _meth_is_ok == null then
+ v.error(self, "Error: {iter_type} MUST have an is_ok method")
return
end
- 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
+ _meth_item = iter_type.local_class.select_method(once ("item".to_symbol))
+ if _meth_item == null then
v.error(self, "Error: {iter_type} MUST have an item method")
return
end
- var t = prop2.signature_for(iter_type).return_type
+ _meth_next = iter_type.local_class.select_method(once ("next".to_symbol))
+ if _meth_next == null then
+ v.error(self, "Error: {iter_type} MUST have a next method")
+ return
+ end
+ var t = _meth_item.signature_for(iter_type).return_type
if not n_expr.is_self then t = t.not_for_self
va.stype = t
+
+ if n_block != null then v.visit(n_block)
+
+ # pop context
+ v.variable_ctx = old_var_ctx
+ 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
+ v.variable_ctx.check_is_set(self, variable)
_stype = v.variable_ctx.stype(variable)
+ _is_typed = _stype != null
end
end
redef class AVarAssignExpr
redef meth after_typing(v)
do
+ v.variable_ctx.mark_is_set(variable)
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)
redef class AVarReassignExpr
redef meth after_typing(v)
do
+ v.variable_ctx.check_is_set(self, variable)
+ v.variable_ctx.mark_is_set(variable)
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 class AStringFormExpr
+ readable attr _meth_with_native: MMMethod
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
end
redef class ASuperstringExpr
+ readable attr _meth_with_capacity: MMMethod
+ readable attr _meth_add: MMMethod
+ readable attr _meth_to_s: MMMethod
+ readable attr _atype: MMType
redef meth after_typing(v)
do
_stype = v.type_string
+ _atype = v.type_array(_stype)
+ _meth_with_capacity = _atype.local_class.select_method(once "with_capacity".to_symbol)
+ if _meth_with_capacity == null then v.error(self, "{_atype} MUST have a with_capacity method.")
+ _meth_add = _atype.local_class.select_method(once "add".to_symbol)
+ 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 class AArrayExpr
- private meth stype=(t: MMType) do _stype = t
+ readable attr _meth_with_capacity: MMMethod
+ readable attr _meth_add: MMMethod
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
- _stype = v.type_array(stype)
+ var stype = v.check_conform_multiexpr(null, n_exprs)
+ if stype == null then return
+ do_typing(v, stype)
+ end
+
+ private meth do_typing(v: TypingVisitor, element_type: MMType)
+ do
+ _stype = v.type_array(element_type)
+
+ _meth_with_capacity = _stype.local_class.select_method(once "with_capacity".to_symbol)
+ 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
redef class ARangeExpr
+ 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
+redef class ACrangeExpr
+ redef meth after_typing(v)
+ do
+ super
+ _meth_init = stype.local_class.select_method(once "init".to_symbol)
+ end
+end
+redef class AOrangeExpr
+ redef meth after_typing(v)
+ do
+ super
+ _meth_init = stype.local_class.select_method(once "without_last".to_symbol)
+ end
+end
+
+
redef class ASuperExpr
special ASuperInitCall
# readable attr _prop: MMSrcMethod
register_super_init_call(v, p)
if n_args.length > 0 then
var signature = get_signature(v, v.self_var.stype, p, true)
- _arguments = process_signature(v, signature, p, n_args.to_a)
+ _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}.")
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
+
+ # 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]
+ 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: '{name}' arity missmatch.")
+ return null
+ end
+ var arg_idx = 0
+ var args = new Array[PExpr]
+ for par_idx in [0..par_arity[ do
+ var a: PExpr
+ var par_type = psig[par_idx]
+ 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_expr(a, par_type)
+ star.add(a)
+ arg_idx = arg_idx + 1
+ end
+ var aa = new AArrayExpr.init_aarrayexpr(star)
+ aa.do_typing(v, par_type)
+ a = aa
+ else
+ a = raw_args[arg_idx]
+ v.check_conform_expr(a, par_type)
+ arg_idx = arg_idx + 1
+ end
+ args.add(a)
+ end
+ return args
+ end
+
+ # Check the conformity of a set of defined closures
+ private meth process_closures(v: TypingVisitor, psig: MMSignature, name: Symbol, cd: Array[PClosureDef]): MMType
+ do
+ var t = psig.return_type
+ var cs = psig.closures # Declared closures
+ var min_arity = 0
+ for c in cs do
+ if not c.is_optional then min_arity += 1
+ end
+ if cd != null then
+ if cs.length == 0 then
+ 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} 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
+ if t != null then break_list = new Array[ABreakExpr]
+
+ # Process each closure definition
+ for i in [0..cd.length[ do
+ var csi = cs[i]
+ var cdi = cd[i]
+ var esc = new EscapableClosure(cdi, csi, break_list)
+ v.escapable_ctx.push(esc)
+ cdi.accept_typing2(v, esc)
+ v.escapable_ctx.pop
+ end
+
+ # Check break type conformity
+ if break_list != null then
+ t = v.check_conform_multiexpr(t, break_list)
+ end
+ end
+ else if min_arity != 0 then
+ 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])
+ 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, raw_args)
+ 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 prop = type_recv.local_class.select_method(name)
+ 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
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)
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
- 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.")
- return null
- end
- var arg_idx = 0
- var args = new Array[PExpr]
- for par_idx in [0..par_arity[ do
- var a: PExpr
- var par_type = psig[par_idx]
- 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_expr(a, par_type)
- star.add(a)
- arg_idx = arg_idx + 1
- end
- var aa = new AArrayExpr.init_aarrayexpr(star)
- aa.stype = v.type_array(par_type)
- a = aa
- else
- a = raw_args[arg_idx]
- v.check_conform_expr(a, par_type)
- arg_idx = arg_idx + 1
- end
- args.add(a)
- end
- return args
- 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
# A possible call of constructor in a super class
name = n_id.to_symbol
end
- do_typing(v, t, false, false, name, n_args.to_a)
+ do_typing(v, t, false, false, name, n_args.to_a, null)
if prop == null then return
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
# 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)
+ do_typing(v, n_expr.stype, n_expr.is_implicit_self, n_expr.is_self, name, raw_arguments, closure_defs)
if prop == null then return
+
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
+
+ _stype = return_type
+ _is_typed = true
end
end
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)
+ do_typing(v, n_expr.stype, n_expr.is_implicit_self, n_expr.is_self, name, raw_args, null)
if prop == null then return
if prop.global.is_init then
if not v.local_property.global.is_init then
var old_args = arguments
raw_args.add(n_value)
- do_typing(v, n_expr.stype, n_expr.is_implicit_self, n_expr.is_self, "{name}=".to_symbol, raw_args)
+ do_typing(v, n_expr.stype, n_expr.is_implicit_self, n_expr.is_self, "{name}=".to_symbol, raw_args, null)
if prop == null then return
if prop.global.is_init then
if not v.local_property.global.is_init then
end
_arguments = old_args # FIXME: What if star parameters do not match betwen the two methods?
+ _is_typed = true
end
end
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.init_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.")
+ return
+ 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
end
redef meth raw_arguments do return n_args.to_a
end
+redef class AClosureCallExpr
+special AAbsAbsSendExpr
+ redef meth after_typing(v)
+ do
+ var va = variable
+ if va.closure.is_break then v.variable_ctx.unreash = true
+ var sig = va.closure.signature
+ var args = process_signature(v, sig, n_id.to_symbol, n_args.to_a)
+ 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_signature = sig
+ _arguments = args
+ _stype = sig.return_type
+ _is_typed = true
+ end
+end
+
+redef class PClosureDef
+ # The corresponding escapable object
+ readable attr _escapable: EscapableBlock
+
+ 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, esc: EscapableClosure) is abstract
+end
+
+redef class AClosureDef
+ redef meth accept_typing2(v, esc)
+ do
+ _escapable = esc
+
+ var sig = esc.closure.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 = esc.closure
+
+ var old_var_ctx = v.variable_ctx
+ v.variable_ctx = v.variable_ctx.sub(self)
+ 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)
+
+ if v.variable_ctx.unreash == false then
+ if closure.signature.return_type != null then
+ v.error(self, "Control error: Reached end of block (a 'continue' with a value was expected).")
+ else if closure.is_break then
+ v.error(self, "Control error: Reached end of break block (a 'break' was expected).")
+ end
+ end
+ v.variable_ctx = old_var_ctx
+ 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)
+ _if_true_variable_ctx = v.variable_ctx.sub_with(self, 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
+
+redef class AOnceExpr
+ redef meth accept_typing(v)
+ do
+ if v.once_count > 0 then
+ v.warning(self, "Useless once in a once expression.")
+ end
+ v.once_count = v.once_count + 1
+
+ super
+
+ v.once_count = v.once_count - 1
+ end
+end
+
nitlanguage / nit.git / blobdiff