X-Git-Url: http://nitlanguage.org

diff --git a/src/syntax/typing.nit b/src/syntax/typing.nit
index 0201f2d..2382bde 100644
--- a/src/syntax/typing.nit
+++ b/src/syntax/typing.nit
@@ -18,8 +18,8 @@
 package typing
 
 import syntax_base
-import escape
-import control_flow
+import flow
+import scope
 
 redef class MMSrcModule
 	# Walk trough the module and type statments and expressions
@@ -43,16 +43,38 @@ special AbsSyntaxVisitor
 		if n != null then n.accept_typing(self)
 	end
 
-	# Current knowledge about variables names and types
-	fun variable_ctx: VariableContext do return _variable_ctx.as(not null)
-	writable var _variable_ctx: nullable VariableContext
+	# Current knowledge about scoped things (variable, labels, etc.)
+	readable var _scope_ctx: ScopeContext = new ScopeContext(self)
 
-	# Non-bypassable knowledge about variables names and types
-	fun base_variable_ctx: VariableContext do return _base_variable_ctx.as(not null)
-	writable var _base_variable_ctx: nullable VariableContext
+	# Current knowledge about control flow
+	fun flow_ctx: FlowContext do return _flow_ctx.as(not null)
+	writable var _flow_ctx: nullable FlowContext
+
+	# Mark a local variable as set
+	fun mark_is_set(va: Variable)
+	do
+		if flow_ctx.is_set(va) then return
+		flow_ctx = flow_ctx.sub_setvariable(va)
+	end
+
+	# Mark the flow context as unreashable
+	fun mark_unreash(n: ANode)
+	do
+		flow_ctx = flow_ctx.sub_unreash(n)
+	end
+
+	# Enter in an expression as inside a new local variable scope
+	fun enter_visit_block(node: nullable AExpr)
+	do
+		if node == null then return
+		scope_ctx.push(node)
+		enter_visit(node)
+		scope_ctx.pop
+	end
 
-	# Current knowledge about escapable blocks
-	readable writable var _escapable_ctx: EscapableContext = new EscapableContext(self)
+	# Non-bypassable knowledge about variables names and types
+	fun base_flow_ctx: FlowContext do return _base_flow_ctx.as(not null)
+	writable var _base_flow_ctx: nullable FlowContext
 
 	# The current reciever
 	fun self_var: ParamVariable do return _self_var.as(not null)
@@ -67,24 +89,27 @@ special AbsSyntaxVisitor
 	# Is a other constructor of the same class invoked
 	readable writable var _explicit_other_init_call: Bool = false
 
-	# Make the if_true_variable_ctx of the expression effective
-	private fun use_if_true_variable_ctx(e: AExpr)
+	# Make the if_true_flow_ctx of the expression effective
+	private fun use_if_true_flow_ctx(e: AExpr)
 	do
-		var ctx = e.if_true_variable_ctx
-		if ctx != null then variable_ctx = ctx
+		var ctx = e.if_true_flow_ctx
+		if ctx != null then flow_ctx = ctx
 	end
 
-	# Make the if_false_variable_ctx of the expression effective
-	private fun use_if_false_variable_ctx(e: AExpr)
+	# Make the if_false_flow_ctx of the expression effective
+	private fun use_if_false_flow_ctx(e: AExpr)
 	do
-		var ctx = e.if_false_variable_ctx
-		if ctx != null then variable_ctx = ctx
+		var ctx = e.if_false_flow_ctx
+		if ctx != null then flow_ctx = ctx
 	end
 
+	# Are we inside a default closure definition ?
+	readable writable var _is_default_closure_definition: Bool = false
+
 	# Number of nested once
 	readable writable var _once_count: Int = 0
 
-	init(tc, module) do super
+	init(tc, mod) do super
 
 	private fun get_default_constructor_for(n: ANode, c: MMLocalClass, prop: MMSrcMethod): nullable MMMethod
 	do
@@ -118,14 +143,14 @@ special AbsSyntaxVisitor
 		else if candidates.length > 0 then
 			var a = new Array[String]
 			for p in candidates do
-				a.add("{p.full_name}{p.signature}")
+				a.add("{p.full_name}{p.signature.as(not null)}")
 			end
 			v.error(n, "Error: Conflicting default constructor to call for {c}: {a.join(", ")}.")
 			return null
 		else if false_candidates.length > 0 then
 			var a = new Array[String]
 			for p in false_candidates do
-				a.add("{p.full_name}{p.signature}")
+				a.add("{p.full_name}{p.signature.as(not null)}")
 			end
 			v.error(n, "Error: there is no available compatible constrctor in {c}. Discarded candidates are {a.join(", ")}.")
 			return null
@@ -151,8 +176,6 @@ end
 redef class AClassdef
 	redef fun accept_typing(v)
 	do
-		v.variable_ctx = new RootVariableContext(v, self)
-		v.base_variable_ctx = v.variable_ctx
 		v.self_var = new ParamVariable("self".to_symbol, self)
 		v.self_var.stype = local_class.get_type
 		super
@@ -167,25 +190,29 @@ end
 redef class AAttrPropdef
 	redef fun accept_typing(v)
 	do
-		var old_var_ctx = v.variable_ctx
-		v.variable_ctx = old_var_ctx.sub(self)
+		v.flow_ctx = new RootFlowContext(v, self)
+		v.base_flow_ctx = v.flow_ctx
+
+		v.scope_ctx.push(self)
 		_self_var = v.self_var
 		super
 		if n_expr != null then
 			v.check_conform_expr(n_expr.as(not null), prop.signature.return_type.as(not null))
 		end
-		v.variable_ctx = old_var_ctx
+		v.scope_ctx.pop
 	end
 end
 
 redef class AMethPropdef
 	redef fun accept_typing(v)
 	do
-		var old_var_ctx = v.variable_ctx
-		v.variable_ctx = old_var_ctx.sub(self)
+		v.flow_ctx = new RootFlowContext(v, self)
+		v.base_flow_ctx = v.flow_ctx
+
+		v.scope_ctx.push(self)
 		_self_var = v.self_var
 		super
-		v.variable_ctx = old_var_ctx
+		v.scope_ctx.pop
 	end
 end
 
@@ -193,7 +220,7 @@ redef class AConcreteMethPropdef
 	redef fun after_typing(v)
 	do
 		super
-		if v.variable_ctx.unreash == false and method.signature.return_type != null then
+		if not v.flow_ctx.unreash 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
@@ -220,12 +247,12 @@ redef class AConcreteInitPropdef
 			var cur_c: nullable MMLocalClass = null
 			if i < l then
 				cur_m = explicit_super_init_calls[i]
-				cur_c = cur_m.global.intro.local_class.for_module(v.module)
+				cur_c = cur_m.global.intro.local_class.for_module(v.mmmodule)
 			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 or c.global.is_mixin then
+				if c.global.is_interface or c.global.is_enum or c.global.is_mixin then
 					j += 1
 				else if cur_c != null and (c.cshe <= cur_c or cur_c.global.is_mixin) then
 					if c == cur_c then j += 1
@@ -233,7 +260,7 @@ redef class AConcreteInitPropdef
 					i += 1
 					if i < l then
 						cur_m = explicit_super_init_calls[i]
-						cur_c = cur_m.global.intro.local_class.for_module(v.module)
+						cur_c = cur_m.global.intro.local_class.for_module(v.mmmodule)
 					else
 						cur_m = null
 						cur_c = null
@@ -253,7 +280,7 @@ end
 redef class AParam
 	redef fun after_typing(v)
 	do
-		v.variable_ctx.add(variable)
+		v.scope_ctx.add_variable(variable)
 	end
 end
 
@@ -264,33 +291,41 @@ redef class AClosureDecl
 	redef fun accept_typing(v)
 	do
 		# Register the closure for ClosureCallExpr
-		v.variable_ctx.add(variable)
+		v.scope_ctx.add_variable(variable)
 
-		var old_var_ctx = v.variable_ctx
-		var old_base_var_ctx = v.base_variable_ctx
-		v.base_variable_ctx = v.variable_ctx
-		v.variable_ctx = v.variable_ctx.sub(self)
+		var old_flow_ctx = v.flow_ctx
+		var old_base_flow_ctx = v.base_flow_ctx
+		v.base_flow_ctx = v.flow_ctx
 
-		var escapable = new EscapableClosure(self, variable.closure, null)
+		var blist: nullable Array[AExpr] = null
+		var t = v.local_property.signature.return_type
+		if t != null then blist = new Array[AExpr]
+		var escapable = new EscapableClosure(self, variable.closure, blist)
 		_escapable = escapable
-		v.escapable_ctx.push(escapable, null)
+		v.scope_ctx.push_escapable(escapable, null)
+
+		v.is_default_closure_definition = true
 
 		super
 
+		v.is_default_closure_definition = false
+
 		if n_expr != null then
-			if v.variable_ctx.unreash == false then
+			if v.flow_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).")
+				else if variable.closure.is_break and escapable.break_list != null then
+					v.error(self, "Control error: Reached end of break block (a 'break' with a value was expected).")
 				end
 			end
 		end
+		if blist != null then for x in blist do
+			v.check_conform_expr(x, t)
+		end
 
-		old_var_ctx.merge(v.variable_ctx)
-		v.variable_ctx = old_var_ctx
-		v.base_variable_ctx = old_base_var_ctx
-		v.escapable_ctx.pop
+		v.flow_ctx = old_flow_ctx
+		v.base_flow_ctx = old_base_flow_ctx
+		v.scope_ctx.pop
 	end
 end
 
@@ -337,11 +372,11 @@ redef class AExpr
 	# The variable accessed is any
 	fun its_variable: nullable Variable do return null
 
-	# The variable type information if current boolean expression is true
-	readable private var _if_true_variable_ctx: nullable VariableContext
+	# The control flow information if current boolean expression is true
+	readable private var _if_true_flow_ctx: nullable FlowContext
 
-	# The variable type information if current boolean expression is false
-	readable private var _if_false_variable_ctx: nullable VariableContext
+	# The control flow information if current boolean expression is false
+	readable private var _if_false_flow_ctx: nullable FlowContext
 end
 
 redef class AVardeclExpr
@@ -352,18 +387,21 @@ redef class AVardeclExpr
 	do
 		var va = new VarVariable(n_id.to_symbol, n_id)
 		_variable = va
-		v.variable_ctx.add(va)
-		if n_expr != null then v.variable_ctx.mark_is_set(va)
+		v.scope_ctx.add_variable(va)
+		var ne = n_expr
+		if ne != null then v.mark_is_set(va)
 
 		if n_type != null then
 			if not n_type.is_typed then return
 			va.stype = n_type.stype
-			if n_expr != null then
-				v.check_conform_expr(n_expr.as(not null), va.stype)
+			if ne != null then
+				v.check_conform_expr(ne, va.stype)
 			end
+		else if ne != null then
+			if not v.check_expr(ne) then return
+			va.stype = ne.stype
 		else
-			if not v.check_expr(n_expr.as(not null)) then return
-			va.stype = n_expr.stype
+			va.stype = v.type_object.as_nullable
 		end
 		_is_typed = true
 	end
@@ -372,19 +410,15 @@ end
 redef class ABlockExpr
 	redef fun accept_typing(v)
 	do
-		var old_var_ctx = v.variable_ctx
-		v.variable_ctx = v.variable_ctx.sub(self)
-
 		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.")
+			if not v.flow_ctx.unreash then
+				v.enter_visit(e)
+			else if not v.flow_ctx.already_unreash then
+				v.flow_ctx.already_unreash = true
+				v.error(e, "Error: unreachable statement.")
 			end
-			v.enter_visit(e)
 		end
 
-		old_var_ctx.merge(v.variable_ctx)
-		v.variable_ctx = old_var_ctx
 		_is_typed = true
 	end
 end
@@ -392,8 +426,14 @@ end
 redef class AReturnExpr
 	redef fun after_typing(v)
 	do
-		v.variable_ctx.unreash = true
+		v.mark_unreash(self)
 		var t = v.local_property.signature.return_type
+
+		if v.is_default_closure_definition then
+			v.error(self, "Error: 'return' invalid in default closure definitions. Use 'continue' or 'break'.")
+			return
+		end
+
 		var e = n_expr
 		if e == null and t != null then
 			v.error(self, "Error: Return without value in a function.")
@@ -409,8 +449,8 @@ end
 redef class AContinueExpr
 	redef fun after_typing(v)
 	do
-		v.variable_ctx.unreash = true
-		var esc = compute_escapable_block(v.escapable_ctx)
+		v.mark_unreash(self)
+		var esc = compute_escapable_block(v.scope_ctx)
 		if esc == null then return
 
 		if esc.is_break_block then
@@ -433,10 +473,13 @@ end
 redef class ABreakExpr
 	redef fun after_typing(v)
 	do
-		v.variable_ctx.unreash = true
-		var esc = compute_escapable_block(v.escapable_ctx)
+		var old_flow_ctx = v.flow_ctx
+		v.mark_unreash(self)
+		var esc = compute_escapable_block(v.scope_ctx)
 		if esc == null then return
 
+		esc.break_flow_contexts.add(old_flow_ctx)
+
 		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.")
@@ -453,145 +496,164 @@ end
 redef class AAbortExpr
 	redef fun after_typing(v)
 	do
-		v.variable_ctx.unreash = true
+		v.mark_unreash(self)
 		_is_typed = true
 	end
 end
 
-redef class ADoExpr
+# An abstract control structure with feature escapable block
+class AAbsControl
+special AExpr
 	# The corresponding escapable block
 	readable var _escapable: nullable EscapableBlock
 
-	redef fun accept_typing(v)
+	# Enter and process a control structure
+	private fun process_control(v: TypingVisitor, escapable: EscapableBlock, n_label: nullable ALabel, is_loop: Bool)
 	do
-		var escapable = new BreakOnlyEscapableBlock(self)
+		# Register the escapable block
 		_escapable = escapable
-		v.escapable_ctx.push(escapable, n_label)
+		v.scope_ctx.push_escapable(escapable, n_label)
 
-		super
+		# Save an prepare the contextes
+		var old_flow_ctx = v.flow_ctx
+		var old_base_flow_ctx = v.base_flow_ctx
+		if is_loop then v.base_flow_ctx = v.flow_ctx
+
+		# Do the main processing
+		process_control_inside(v)
+
+		# Add the end of the block as an exit context
+		if not v.flow_ctx.unreash then
+			escapable.break_flow_contexts.add(v.flow_ctx)
+		end
 
-		v.escapable_ctx.pop
+		# Merge all exit contexts
+		if escapable.break_flow_contexts.is_empty then
+			v.flow_ctx = old_flow_ctx
+			v.mark_unreash(self)
+		else
+			v.flow_ctx = old_base_flow_ctx.merge(self, escapable.break_flow_contexts)
+		end
+
+		if is_loop then v.base_flow_ctx = old_base_flow_ctx
+		v.scope_ctx.pop
 		_is_typed = true
 	end
+
+	# What to do inside the control block?
+	private fun process_control_inside(v: TypingVisitor) is abstract
+end
+
+redef class ADoExpr
+special AAbsControl
+	redef fun accept_typing(v)
+	do
+		process_control(v, new BreakOnlyEscapableBlock(self), n_label, false)
+	end
+
+	redef fun process_control_inside(v)
+	do
+		v.enter_visit_block(n_block)
+	end
 end
 
 redef class AIfExpr
 	redef fun accept_typing(v)
 	do
-		var old_var_ctx = v.variable_ctx
 		v.enter_visit(n_expr)
 		v.check_conform_expr(n_expr, v.type_bool)
 
 		# Prepare 'then' context
-		v.use_if_true_variable_ctx(n_expr)
+		var old_flow_ctx = v.flow_ctx
+		v.use_if_true_flow_ctx(n_expr)
 
 		# Process the 'then'
-		if n_then != null then
-			v.variable_ctx = v.variable_ctx.sub(n_then.as(not null))
-			v.enter_visit(n_then)
-		end
+		v.enter_visit_block(n_then)
 
 		# Remember what appened in the 'then'
-		var then_var_ctx = v.variable_ctx
+		var then_flow_ctx = v.flow_ctx
 
 		# Prepare 'else' context
-		v.variable_ctx = old_var_ctx
-		v.use_if_false_variable_ctx(n_expr)
+		v.flow_ctx = old_flow_ctx
+		v.use_if_false_flow_ctx(n_expr)
 
 		# Process the 'else'
-		if n_else != null then
-			v.variable_ctx = v.variable_ctx.sub(n_else.as(not null))
-			v.enter_visit(n_else)
-		end
+		v.enter_visit_block(n_else)
 
 		# Merge 'then' and 'else' contexts
-		old_var_ctx.merge2(then_var_ctx, v.variable_ctx, v.base_variable_ctx)
-		v.variable_ctx = old_var_ctx
+		v.flow_ctx = v.base_flow_ctx.merge_reash(self, then_flow_ctx, v.flow_ctx)
 		_is_typed = true
 	end
 end
 
 redef class AWhileExpr
-	# The corresponding escapable block
-	readable var _escapable: nullable EscapableBlock
-
+special AAbsControl
 	redef fun accept_typing(v)
 	do
-		var escapable = new EscapableBlock(self)
-		_escapable = escapable
-		v.escapable_ctx.push(escapable, n_label)
-		var old_var_ctx = v.variable_ctx
-		var old_base_var_ctx = v.base_variable_ctx
-		v.base_variable_ctx = v.variable_ctx
-		v.variable_ctx = v.variable_ctx.sub(self)
+		process_control(v, new EscapableBlock(self), n_label, true)
+	end
+
+	redef fun process_control_inside(v)
+	do
+		var old_flow_ctx = v.flow_ctx
 
 		# Process condition
 		v.enter_visit(n_expr)
 		v.check_conform_expr(n_expr, v.type_bool)
 
+		if n_expr isa ATrueExpr then
+			v.warning(self, "Warning: use 'loop' instead of 'while true do'.")
+		end
+
 		# Prepare inside context (assert cond)
-		v.use_if_true_variable_ctx(n_expr)
+		v.use_if_true_flow_ctx(n_expr)
 
 		# Process inside
-		if n_block != null then
-			v.variable_ctx = v.variable_ctx.sub(n_block.as(not null))
-			v.enter_visit(n_block)
-		end
+		v.enter_visit_block(n_block)
 
-		v.variable_ctx = old_var_ctx
-		v.base_variable_ctx = old_base_var_ctx
-		v.escapable_ctx.pop
-		_is_typed = true
+		# Compute outside context (assert !cond + all breaks)
+		v.flow_ctx = old_flow_ctx
+		v.use_if_false_flow_ctx(n_expr)
+		escapable.break_flow_contexts.add(v.flow_ctx)
 	end
 end
 
 redef class ALoopExpr
-	# The corresponding escapable block
-	readable var _escapable: nullable EscapableBlock
-
+special AAbsControl
 	redef fun accept_typing(v)
 	do
-		var escapable = new EscapableBlock(self)
-		_escapable = escapable
-		v.escapable_ctx.push(escapable, n_label)
-		var old_var_ctx = v.variable_ctx
-		var old_base_var_ctx = v.base_variable_ctx
-		v.base_variable_ctx = v.variable_ctx
-		v.variable_ctx = v.variable_ctx.sub(self)
+		process_control(v, new EscapableBlock(self), n_label, true)
+	end
 
+	redef fun process_control_inside(v)
+	do
 		# Process inside
-		if n_block != null then
-			v.variable_ctx = v.variable_ctx.sub(n_block.as(not null))
-			v.enter_visit(n_block)
-		end
+		v.enter_visit_block(n_block)
 
-		v.variable_ctx = old_var_ctx
-		v.base_variable_ctx = old_base_var_ctx
-		v.escapable_ctx.pop
-		_is_typed = true
+		# Never automatically reach after the loop
+		v.mark_unreash(self)
 	end
 end
 
 redef class AForExpr
+special AAbsControl
 	var _variable: nullable AutoVariable
 	redef fun variable do return _variable.as(not null)
 
-	# The corresponding escapable block
-	readable var _escapable: nullable EscapableBlock
-
 	redef fun accept_typing(v)
 	do
-		var escapable = new EscapableBlock(self)
-		_escapable = escapable
-		v.escapable_ctx.push(escapable, n_label)
+		process_control(v, new EscapableBlock(self), n_label, true)
+	end
 
-		var old_var_ctx = v.variable_ctx
-		var old_base_var_ctx = v.base_variable_ctx
-		v.base_variable_ctx = v.variable_ctx
-		v.variable_ctx = v.variable_ctx.sub(self)
+	redef fun process_control_inside(v)
+	do
+		v.scope_ctx.push(self)
+		var old_flow_ctx = v.flow_ctx
+
+		# Create the automatic variable
 		var va = new AutoVariable(n_id.to_symbol, n_id)
 		_variable = va
-		v.variable_ctx.add(va)
+		v.scope_ctx.add_variable(va)
 
 		# Process collection
 		v.enter_visit(n_expr)
@@ -607,14 +669,12 @@ redef class AForExpr
 		if not n_expr.is_self then va_stype = va_stype.not_for_self
 		va.stype = va_stype
 
-		# Body evaluation
-		if n_block != null then v.enter_visit(n_block)
+		# Process inside
+		v.enter_visit_block(n_block)
 
-		# pop context
-		v.variable_ctx = old_var_ctx
-		v.base_variable_ctx = old_base_var_ctx
-		v.escapable_ctx.pop
-		_is_typed = true
+		# end == begin of the loop
+		v.flow_ctx = old_flow_ctx
+		v.scope_ctx.pop
 	end
 end
 
@@ -627,14 +687,14 @@ redef class AAssertExpr
 
 		# Process optional 'else' part
 		if n_else != null then
-			var old_var_ctx = v.variable_ctx
-			v.use_if_false_variable_ctx(n_expr)
+			var old_flow_ctx = v.flow_ctx
+			v.use_if_false_flow_ctx(n_expr)
 			v.enter_visit(n_else)
-			v.variable_ctx = old_var_ctx
+			v.flow_ctx = old_flow_ctx
 		end
 
 		# Prepare outside
-		v.use_if_true_variable_ctx(n_expr)
+		v.use_if_true_flow_ctx(n_expr)
 		_is_typed = true
 	end
 end
@@ -649,8 +709,8 @@ redef class AVarExpr
 
 	redef fun after_typing(v)
 	do
-		v.variable_ctx.check_is_set(self, variable)
-		_stype = v.variable_ctx.stype(variable)
+		v.flow_ctx.check_is_set(self, variable)
+		_stype = v.flow_ctx.stype(variable)
 		_is_typed = _stype != null
 	end
 end
@@ -658,15 +718,15 @@ end
 redef class AVarAssignExpr
 	redef fun after_typing(v)
 	do
-		v.variable_ctx.mark_is_set(variable)
-		var t = v.variable_ctx.stype(variable)
+		v.mark_is_set(variable)
 
 		# Check the base type
-		var btype = v.base_variable_ctx.stype(variable)
-		if not v.check_conform_expr(n_value, btype) then return
+		var btype = v.base_flow_ctx.stype(variable)
+		if not v.check_expr(n_value) then return
+		if btype != null and not v.check_conform_expr(n_value, btype) then return
 
 		# Always cast
-		v.variable_ctx.stype(variable) = n_value.stype
+		v.flow_ctx = v.flow_ctx.sub_with(self, variable, n_value.stype)
 
 		_is_typed = true
 	end
@@ -682,13 +742,17 @@ redef class AReassignFormExpr
 			return null
 		end
 		var name = n_assign_op.method_name
+		if type_lvalue isa MMTypeNone then
+			v.error(self, "Error: Method '{name}' call on 'null'.")
+			return null
+		end
 		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 null
 		end
 		var prop = lc.select_method(name)
-		prop.global.check_visibility(v, self, v.module, false)
+		prop.global.check_visibility(v, self, v.mmmodule, false)
 		var psig = prop.signature_for(type_lvalue)
 		_assign_method = prop
 		if not v.check_conform_expr(n_value, psig[0].not_for_self) then return null
@@ -702,18 +766,19 @@ end
 redef class AVarReassignExpr
 	redef fun 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)
+		v.flow_ctx.check_is_set(self, variable)
+		v.mark_is_set(variable)
+		var t = v.flow_ctx.stype(variable)
 		var t2 = do_rvalue_typing(v, t)
 		if t2 == null then return
 
 		# Check the base type
-		var btype = v.base_variable_ctx.stype(variable)
-		if not v.check_conform(n_value, t2, btype) then return
+		var btype = v.base_flow_ctx.stype(variable)
+		if not v.check_expr(n_value) then return
+		if btype != null and not v.check_conform(n_value, t2, btype) then return
 
 		# Always cast
-		v.variable_ctx.stype(variable) = t2
+		v.flow_ctx = v.flow_ctx.sub_with(self, variable, t2)
 
 		_is_typed = true
 	end
@@ -738,7 +803,7 @@ redef class ASelfExpr
 	redef fun after_typing(v)
 	do
 		_variable = v.self_var
-		_stype = v.variable_ctx.stype(variable)
+		_stype = v.flow_ctx.stype(variable)
 		_is_typed = true
 	end
 
@@ -752,24 +817,30 @@ end
 redef class AIfexprExpr
 	redef fun accept_typing(v)
 	do
-		var old_var_ctx = v.variable_ctx
+		var old_flow_ctx = v.flow_ctx
 
 		# Process condition
 		v.enter_visit(n_expr)
 		v.check_conform_expr(n_expr, v.type_bool)
 
 		# Prepare 'then' context
-		v.use_if_true_variable_ctx(n_expr)
+		v.use_if_true_flow_ctx(n_expr)
 
 		# Process 'then'
-		v.enter_visit(n_then)
+		v.enter_visit_block(n_then)
+
+		# Remember what appened in the 'then'
+		var then_flow_ctx = v.flow_ctx
 
 		# Prepare 'else' context
-		v.variable_ctx = old_var_ctx
-		v.use_if_false_variable_ctx(n_expr)
+		v.flow_ctx = old_flow_ctx
+		v.use_if_false_flow_ctx(n_expr)
 
 		# Process 'else'
-		v.enter_visit(n_else)
+		v.enter_visit_block(n_else)
+
+		# Merge 'then' and 'else' contexts
+		v.flow_ctx = v.base_flow_ctx.merge_reash(self, then_flow_ctx, v.flow_ctx)
 
 		var stype = v.check_conform_multiexpr(null, [n_then, n_else])
 		if stype == null then return
@@ -790,7 +861,7 @@ end
 redef class AOrExpr
 	redef fun accept_typing(v)
 	do
-		var old_var_ctx = v.variable_ctx
+		var old_flow_ctx = v.flow_ctx
 		var stype = v.type_bool
 		_stype = stype
 
@@ -798,17 +869,17 @@ redef class AOrExpr
 		v.enter_visit(n_expr)
 
 		# Prepare right operand context
-		v.use_if_false_variable_ctx(n_expr)
+		v.use_if_false_flow_ctx(n_expr)
 
 		# Process right operand
 		v.enter_visit(n_expr2)
-		if n_expr2.if_false_variable_ctx != null then
-			_if_false_variable_ctx = n_expr2.if_false_variable_ctx
+		if n_expr2.if_false_flow_ctx != null then
+			_if_false_flow_ctx = n_expr2.if_false_flow_ctx
 		else
-			_if_false_variable_ctx = v.variable_ctx
+			_if_false_flow_ctx = v.flow_ctx
 		end
 
-		v.variable_ctx = old_var_ctx
+		v.flow_ctx = old_flow_ctx
 
 		v.check_conform_expr(n_expr, stype)
 		v.check_conform_expr(n_expr2, stype)
@@ -820,24 +891,24 @@ end
 redef class AAndExpr
 	redef fun accept_typing(v)
 	do
-		var old_var_ctx = v.variable_ctx
+		var old_flow_ctx = v.flow_ctx
 		var stype = v.type_bool
 
 		# Process left operand
 		v.enter_visit(n_expr)
 
 		# Prepare right operand context
-		v.use_if_true_variable_ctx(n_expr)
+		v.use_if_true_flow_ctx(n_expr)
 
 		# Process right operand
 		v.enter_visit(n_expr2)
-		if n_expr2.if_true_variable_ctx != null then
-			_if_true_variable_ctx = n_expr2.if_true_variable_ctx
+		if n_expr2.if_true_flow_ctx != null then
+			_if_true_flow_ctx = n_expr2.if_true_flow_ctx
 		else
-			_if_true_variable_ctx = v.variable_ctx
+			_if_true_flow_ctx = v.flow_ctx
 		end
 
-		v.variable_ctx = old_var_ctx
+		v.flow_ctx = old_flow_ctx
 
 		v.check_conform_expr(n_expr, stype)
 		v.check_conform_expr(n_expr2, stype)
@@ -852,14 +923,53 @@ redef class ANotExpr
 		v.check_conform_expr(n_expr, v.type_bool)
 
 		# Invert if_true/if_false information
-		_if_false_variable_ctx = n_expr._if_true_variable_ctx
-		_if_true_variable_ctx = n_expr._if_false_variable_ctx
+		_if_false_flow_ctx = n_expr._if_true_flow_ctx
+		_if_true_flow_ctx = n_expr._if_false_flow_ctx
 
 		_stype = v.type_bool
 		_is_typed = true
 	end
 end
 
+redef class AOrElseExpr
+	redef fun after_typing(v)
+	do
+		var old_flow_ctx = v.flow_ctx
+
+		# Process left operand
+		v.enter_visit(n_expr)
+		v.check_expr(n_expr)
+
+		# Consider the type of the left operand
+		var t = n_expr.stype
+		if not t.is_nullable then
+			v.warning(n_expr, "Warning: left operant of a 'or else' is not a nullable type.")
+		else
+			t = t.as_notnull
+		end
+
+		# Prepare the else context : ie the first expression is null
+		var variable = n_expr.its_variable
+		if variable != null then
+			v.flow_ctx.sub_with(self, variable, v.type_none)
+		end
+
+		# Process right operand
+		v.enter_visit(n_expr2)
+		v.check_expr(n_expr)
+
+		# Restore the context
+		v.flow_ctx = old_flow_ctx
+
+		# Merge the types
+		var stype = v.check_conform_multiexpr(t, [n_expr2])
+		if stype == null then return
+
+		_stype = stype
+		_is_typed = true
+	end
+end
+
 redef class AIntExpr
 	redef fun after_typing(v)
 	do
@@ -897,8 +1007,10 @@ redef class ASuperstringExpr
 	var _atype: nullable MMType
 	redef fun after_typing(v)
 	do
+		var otype = v.type_object
 		var stype = v.type_string
 		_stype = stype
+		for e in n_exprs do v.check_conform_expr(e, otype)
 		var atype = v.type_array(stype)
 		_atype = atype
 		_is_typed = true
@@ -988,7 +1100,7 @@ redef class ASuperExpr
 			var stype: nullable MMType = null
 			for prop in precs do
 				assert prop isa MMMethod
-				var t = prop.signature_for(v.self_var.stype.as(not null)).return_type.for_module(v.module).adapt_to(v.local_property.signature.recv)
+				var t = prop.signature_for(v.self_var.stype.as(not null)).return_type.for_module(v.mmmodule).adapt_to(v.local_property.signature.recv)
 				stypes.add(t)
 				if stype == null or stype < t then
 					stype = t
@@ -1019,14 +1131,18 @@ redef class AAttrFormExpr
 		if not v.check_expr(n_expr) then return
 		var type_recv = n_expr.stype
 		var name = n_id.to_symbol
+		if type_recv isa MMTypeNone then
+			v.error(self, "Error: Attribute '{name}' access on 'null'.")
+			return
+		end
 		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
 		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}")
+		if v.mmmodule.visibility_for(prop.global.local_class.mmmodule) < 3 then
+			v.error(self, "Error: Attribute {name} from {prop.global.local_class.mmmodule} is invisible in {v.mmmodule}")
 		end
 		_prop = prop
 		var at = prop.signature_for(type_recv).return_type 
@@ -1168,9 +1284,9 @@ redef class AAbsAbsSendExpr
 					var csi = psig.closure_named(cni)
 					if csi != null then
 						var esc = new EscapableClosure(cdi, csi, break_list)
-						v.escapable_ctx.push(esc, n_label)
+						v.scope_ctx.push_escapable(esc, n_label)
 						cdi.accept_typing2(v, esc)
-						v.escapable_ctx.pop
+						v.scope_ctx.pop
 					else if cs.length == 1 then
 						v.error(cdi.n_id, "Error: no closure named '!{cni}' in {name}; only closure is !{cs.first.name}.")
 					else
@@ -1211,16 +1327,25 @@ redef class AAbsSendExpr
 
 	private fun get_property(v: TypingVisitor, type_recv: MMType, is_implicit_self: Bool, name: Symbol): nullable MMMethod
 	do
+		if type_recv isa MMTypeNone then
+			if name == (once "==".to_symbol) or name == (once "!=".to_symbol) then
+				# Special case on != and == that are allowed for 'null'
+				type_recv = v.type_object.as_nullable
+			else
+				v.error(self, "Error: Method '{name}' call on 'null'.")
+				return null
+			end
+		end
 		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
-			var props = type_recv.local_class.super_methods_named(name)
+			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.")
 				return null
 			else if props.length == 1 then 
-				var p = type_recv.local_class[props.first.global]
+				var p = lc[props.first.global]
 				assert p isa MMMethod
 				prop = p
 			end
@@ -1240,7 +1365,7 @@ redef class AAbsSendExpr
 	# Get the signature for a local property and a receiver
 	private fun 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)
+		prop.global.check_visibility(v, self, v.mmmodule, recv_is_self)
 		var psig = prop.signature_for(type_recv)
 		if not recv_is_self then psig = psig.not_for_self
 		return psig
@@ -1262,7 +1387,7 @@ redef class ASuperInitCall
 		if parent != v.top_block and self != v.top_block then
 			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 cla = v.mmmodule[property.global.intro.local_class.global]
 		var prev_class: nullable MMLocalClass = null
 		var esic = v.explicit_super_init_calls.as(not null)
 		if not esic.is_empty then
@@ -1276,12 +1401,11 @@ redef class ASuperInitCall
 		else if cla == prev_class then
 			v.error(self, "Error: Only one super constructor invocation of class {cla} is allowed.")
 		else
-			var last_is_found = prev_class == null
 			for c in order do
 				if c == prev_class then
-					last_is_found = true
+					prev_class = null
 				else if c == cla then
-					if not last_is_found 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)
@@ -1413,7 +1537,11 @@ redef class AEqExpr
 		end
 
 		if n_expr.stype isa MMTypeNone then
-			try_to_isa(v, n_expr2)
+			if n_expr2.stype isa MMTypeNone then
+				v.warning(self, "Warning: comparaison between 2 null values.")
+			else
+				try_to_isa(v, n_expr2)
+			end
 		else if n_expr2.stype isa MMTypeNone then
 			try_to_isa(v, n_expr)
 		end
@@ -1422,8 +1550,9 @@ redef class AEqExpr
 	private fun try_to_isa(v: TypingVisitor, n: AExpr)
 	do
 		var variable = n.its_variable
-		if variable != null then
-			_if_false_variable_ctx = v.variable_ctx.sub_with(self, variable, n.stype.as_notnull)
+		if variable != null and n.stype isa MMNullableType then
+			_if_false_flow_ctx = v.flow_ctx.sub_with(self, variable, n.stype.as_notnull)
+			_if_true_flow_ctx = v.flow_ctx.sub_with(self, variable, v.type_none)
 		end
 	end
 end
@@ -1439,7 +1568,11 @@ redef class ANeExpr
 		end
 
 		if n_expr.stype isa MMTypeNone then
-			try_to_isa(v, n_expr2)
+			if n_expr2.stype isa MMTypeNone then
+				v.warning(self, "Warning: comparaison between 2 null values.")
+			else
+				try_to_isa(v, n_expr2)
+			end
 		else if n_expr2.stype isa MMTypeNone then
 			try_to_isa(v, n_expr)
 		end
@@ -1448,8 +1581,9 @@ redef class ANeExpr
 	private fun try_to_isa(v: TypingVisitor, n: AExpr)
 	do
 		var variable = n.its_variable
-		if variable != null then
-			_if_true_variable_ctx = v.variable_ctx.sub_with(self, variable, n.stype.as_notnull)
+		if variable != null and n.stype isa MMNullableType then
+			_if_true_flow_ctx = v.flow_ctx.sub_with(self, variable, n.stype.as_notnull)
+			_if_false_flow_ctx = v.flow_ctx.sub_with(self, variable, v.type_none)
 		end
 	end
 end
@@ -1459,12 +1593,18 @@ end
 redef class ALeExpr
 	redef fun name do return once "<=".to_symbol
 end
+redef class ALlExpr
+	redef fun name do return once "<<".to_symbol
+end
 redef class AGtExpr
 	redef fun name do return once ">".to_symbol
 end
 redef class AGeExpr
 	redef fun name do return once ">=".to_symbol
 end
+redef class AGgExpr
+	redef fun name do return once ">>".to_symbol
+end
 redef class APlusExpr
 	redef fun name do return once "+".to_symbol
 end
@@ -1494,7 +1634,7 @@ redef class ACallFormExpr
 	do
 		if n_expr.is_implicit_self then
 			var name = n_id.to_symbol
-			var variable = v.variable_ctx[name]
+			var variable = v.scope_ctx[name]
 			if variable != null then
 				var n: AExpr
 				if variable isa ClosureVariable then
@@ -1604,7 +1744,7 @@ redef class AClosureCallExpr
 	redef fun after_typing(v)
 	do
 		var va = variable
-		if va.closure.is_break then v.variable_ctx.unreash = true
+		if va.closure.is_break then v.mark_unreash(self)
 		var sig = va.closure.signature
 		var s = process_signature(v, sig, n_id.to_symbol, compute_raw_arguments)
 		if not n_closure_defs.is_empty then
@@ -1653,30 +1793,31 @@ redef class AClosureDef
 
 		_closure = esc.closure
 
-		var old_var_ctx = v.variable_ctx
-		var old_base_var_ctx = v.base_variable_ctx
-		v.base_variable_ctx = v.variable_ctx
-		v.variable_ctx = v.variable_ctx.sub(self)
+		v.scope_ctx.push(self)
+		var old_flow_ctx = v.flow_ctx
+		var old_base_flow_ctx = v.base_flow_ctx
+		v.base_flow_ctx = v.flow_ctx
 		variables = new Array[AutoVariable]
 		for i in [0..n_ids.length[ do
 			var va = new AutoVariable(n_ids[i].to_symbol, n_ids[i])
 			variables.add(va)
 			va.stype = sig[i]
-			v.variable_ctx.add(va)
+			v.scope_ctx.add_variable(va)
 		end
 
 		_accept_typing2 = true
 		accept_typing(v)
 
-		if v.variable_ctx.unreash == false then
+		if v.flow_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).")
+			else if closure.is_break and esc.break_list != null then
+				v.error(self, "Control error: Reached end of break block (a 'break' with a value was expected).")
 			end
 		end
-		v.variable_ctx = old_var_ctx
-		v.base_variable_ctx = old_base_var_ctx
+		v.flow_ctx = old_flow_ctx
+		v.base_flow_ctx = old_base_flow_ctx
+		v.scope_ctx.pop
 	end
 end
 
@@ -1692,6 +1833,9 @@ special AExpr
 			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}.")
+		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}.")
 		else if etype.is_nullable and etype.as_notnull == ttype then
 			if ttype isa MMTypeFormal and ttype.bound.is_nullable then
 				# No warning in this case since with
@@ -1716,7 +1860,7 @@ special ATypeCheckExpr
 		if not n_type.is_typed then return
 		var variable = n_expr.its_variable
 		if variable != null then
-			_if_true_variable_ctx = v.variable_ctx.sub_with(self, variable, n_type.stype)
+			_if_true_flow_ctx = v.flow_ctx.sub_with(self, variable, n_type.stype)
 		end
 		_stype = v.type_bool
 		_is_typed = true