super AbsSyntaxVisitor
redef fun visit(n)
do
- if n != null then n.accept_typing(self)
+ n.accept_typing(self)
end
# Current knowledge about scoped things (variable, labels, etc.)
end
else if ne != null then
if not v.check_expr(ne) then return
- va.stype = ne.stype
+ var st = ne.stype
+ if st isa MMTypeNone then
+ va.stype = v.type_object.as_nullable
+ v.flow_ctx = v.flow_ctx.sub_with(self, va, st)
+ else
+ va.stype = st
+ end
else
va.stype = v.type_object.as_nullable
end
end
end
+redef class AImpliesExpr
+ redef fun accept_typing(v)
+ do
+ var old_flow_ctx = v.flow_ctx
+ var stype = v.type_bool
+ _stype = stype
+
+ # Process left operand
+ v.enter_visit(n_expr)
+
+ # Prepare right operand context
+ v.use_if_true_flow_ctx(n_expr)
+
+ # Process right operand
+ v.enter_visit(n_expr2)
+ if n_expr2.if_false_flow_ctx != null then
+ _if_false_flow_ctx = n_expr2.if_false_flow_ctx
+ else
+ _if_false_flow_ctx = v.flow_ctx
+ end
+
+ v.flow_ctx = old_flow_ctx
+
+ v.check_conform_expr(n_expr, stype)
+ v.check_conform_expr(n_expr2, stype)
+ _stype = stype
+ _is_typed = true
+ end
+end
+
redef class AAndExpr
redef fun accept_typing(v)
do
var lc = type_recv.local_class
var prop: nullable 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
+ if prop == null then
var props = lc.super_methods_named(name)
if props.length > 1 then
v.error(self, "Error: Ambigous method name '{name}' for {props.join(", ")}. Use explicit designation.")
if c == prev_class then
prev_class = null
else if c == cla then
- if prev_class != null then
- v.error(self, "Error: Constructor of {c} must be invoked before constructor of {prev_class}")
- end
esic.add(property)
break
end
v.error(self, "Error: try to instantiate abstract class {t.local_class}.")
return
end
+ if t.is_nullable then
+ v.error(self, "Type error: cannot instantiate the nullable type {t}.")
+ end
var name: Symbol
if n_id == null then
name = once "init".to_symbol
v.error(self, "Error: {prop} is not a constructor.")
return
end
+ if not prop.global.is_init_for(t.local_class) then
+ v.error(self, "Error: {prop} is not a constructor in {t.local_class}.")
+ return
+ end
_stype = t
_is_typed = true
end
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}.")
+ if not ttype.has_formal and not etype.has_formal then
+ # the old metamodel is not that great with formal types
+ v.warning(self, "Warning: Expression is already a {ttype} since it is a {etype}.")
+ end
else if etype isa MMTypeNone then
# ttype is not nullable because of prevous test
v.warning(self, "Warning: Expression is null therefore cannot be a {ttype}.")
end
end
+redef class ADebugTypeExpr
+ redef fun after_typing(v)
+ do
+ if not v.check_expr(n_expr) then return
+ if not n_type.is_typed then return
+ var etype = n_expr.stype
+ var ttype = n_type.stype
+ if etype != ttype then
+ v.warning(self, "Warning: Expression is a {etype}, expected {ttype}.")
+ end
+ end
+end