# 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
_dico[v.name] = v
end
-
# The effective static type of a given variable
# May be different from the declaration static type
meth stype(v: Variable): MMType
attr _dico: Map[Symbol, Variable]
# Build a new VariableContext
- meth sub: SubVariableContext
+ meth sub(node: PNode): SubVariableContext
do
- return new SubVariableContext.with_prev(self)
+ 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 CastVariableContext.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
end
-private class SubVariableContext
+class RootVariableContext
+special VariableContext
+ init(visitor: AbsSyntaxVisitor, node: PNode)
+ do
+ super(visitor, node)
+ end
+end
+
+class SubVariableContext
special VariableContext
readable attr _prev: VariableContext
return prev.stype(v)
end
- init with_prev(p: VariableContext)
+ init with_prev(p: VariableContext, node: PNode)
do
- init
+ init(p._visitor, node)
_prev = p
end
end
-private class CastVariableContext
+class CastVariableContext
special SubVariableContext
attr _variable: Variable
attr _var_type: MMType
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
- super(p)
+ super(p, node)
_variable = v
_var_type =t
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
v.variable_ctx.add(variable)
var old_var_ctx = v.variable_ctx
- v.variable_ctx = v.variable_ctx.sub
+ v.variable_ctx = v.variable_ctx.sub(self)
_escapable = new EscapableClosure(self, variable.closure, null)
v.escapable_ctx.push(_escapable)
end
redef class PExpr
- redef readable attr _is_typed: Bool = true # FIXME: Switch to false once subclasses are adapted
+ 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
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
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
else if n_expr != null and t != null then
v.check_conform_expr(n_expr, t)
end
+ _is_typed = true
end
end
# Typing check can only be done later
bl.add(n_expr)
end
+ _is_typed = true
end
end
v.visit(n_else)
v.variable_ctx = old_var_ctx
end
+ _is_typed = true
end
end
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
_escapable = new EscapableBlock(self)
v.escapable_ctx.push(_escapable)
- v.variable_ctx = v.variable_ctx.sub
+ 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
- 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
- assert varctx isa SubVariableContext
- v.variable_ctx = varctx.prev
-
+ v.variable_ctx = old_var_ctx
v.escapable_ctx.pop
+ _is_typed = true
end
end
do
v.check_conform_expr(n_expr, v.type_bool)
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
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
v.check_conform_expr(n_expr, v.type_bool)
_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
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
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
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
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
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
_prop_signature = sig
_arguments = args
_stype = sig.return_type
+ _is_typed = true
end
end
closure = esc.closure
- v.variable_ctx = v.variable_ctx.sub
+ 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)
_accept_typing2 = true
accept_typing(v)
+ 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
nitlanguage / nit.git / blobdiff