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

diff --git a/src/syntax/typing.nit b/src/syntax/typing.nit
index d070119..7730152 100644
--- a/src/syntax/typing.nit
+++ b/src/syntax/typing.nit
@@ -24,7 +24,7 @@ import control_flow
 redef class MMSrcModule
 	# Walk trough the module and type statments and expressions
 	# Require than supermodules are processed
-	meth do_typing(tc: ToolContext)
+	fun do_typing(tc: ToolContext)
 	do
 		var tv = new TypingVisitor(tc, self)
 		tv.visit(node)
@@ -38,52 +38,55 @@ end
 # * Check type conformance
 private class TypingVisitor
 special AbsSyntaxVisitor
-	redef meth visit(n)
+	redef fun visit(n)
 	do
 		if n != null then n.accept_typing(self)
 	end
 
 	# Current knowledge about variables names and types
-	readable writable attr _variable_ctx: VariableContext
+	fun variable_ctx: VariableContext do return _variable_ctx.as(not null)
+	writable var _variable_ctx: nullable VariableContext
 
 	# Non-bypassable knowledge about variables names and types
-	readable writable attr _base_variable_ctx: VariableContext
+	fun base_variable_ctx: VariableContext do return _base_variable_ctx.as(not null)
+	writable var _base_variable_ctx: nullable VariableContext
 
 	# Current knowledge about escapable blocks
-	readable writable attr _escapable_ctx: EscapableContext = new EscapableContext(self)
+	readable writable var _escapable_ctx: EscapableContext = new EscapableContext(self)
 
 	# The current reciever
-	readable writable attr _self_var: ParamVariable
+	fun self_var: ParamVariable do return _self_var.as(not null)
+	writable var _self_var: nullable ParamVariable
 
 	# Block of the current method
-	readable writable attr _top_block: PExpr
+	readable writable var _top_block: nullable PExpr
 
 	# List of explicit invocation of constructors of super-classes
-	readable writable attr _explicit_super_init_calls: Array[MMMethod]
+	readable writable var _explicit_super_init_calls: nullable Array[MMMethod]
 
 	# Is a other constructor of the same class invoked
-	readable writable attr _explicit_other_init_call: Bool
+	readable writable var _explicit_other_init_call: Bool = false
 
 	# Make the if_true_variable_ctx of the expression effective
-	private meth use_if_true_variable_ctx(e: PExpr)
+	private fun use_if_true_variable_ctx(e: PExpr)
 	do
 		var ctx = e.if_true_variable_ctx
 		if ctx != null then variable_ctx = ctx
 	end
 
 	# Make the if_false_variable_ctx of the expression effective
-	private meth use_if_false_variable_ctx(e: PExpr)
+	private fun use_if_false_variable_ctx(e: PExpr)
 	do
 		var ctx = e.if_false_variable_ctx
 		if ctx != null then variable_ctx = ctx
 	end
 
 	# Number of nested once
-	readable writable attr _once_count: Int = 0
+	readable writable var _once_count: Int = 0
 
 	init(tc, module) do super
 
-	private meth get_default_constructor_for(n: PNode, c: MMLocalClass, prop: MMSrcMethod): MMMethod
+	private fun get_default_constructor_for(n: PNode, c: MMLocalClass, prop: MMSrcMethod): nullable MMMethod
 	do
 		var v = self
 		#var prop = v.local_property
@@ -97,7 +100,7 @@ special AbsSyntaxVisitor
 			var gps = gp.signature_for(c.get_type)
 			assert gp isa MMSrcMethod
 			var garity = gps.arity
-			if prop != null and gp.name == prop.name then
+			if gp.name == prop.name then
 				if garity == 0 or (parity == garity and prop.signature < gps) then
 					return gp
 				else
@@ -137,16 +140,16 @@ end
 ###############################################################################
 
 redef class PNode
-	private meth accept_typing(v: TypingVisitor) 
+	private fun accept_typing(v: TypingVisitor) 
 	do
 		accept_abs_syntax_visitor(v)
 		after_typing(v)
 	end
-	private meth after_typing(v: TypingVisitor) do end
+	private fun after_typing(v: TypingVisitor) do end
 end
 
 redef class PClassdef
-	redef meth accept_typing(v)
+	redef fun accept_typing(v)
 	do
 		v.self_var = new ParamVariable("self".to_symbol, self)
 		v.self_var.stype = local_class.get_type
@@ -155,18 +158,19 @@ redef class PClassdef
 end
 
 redef class AAttrPropdef
-	redef meth accept_typing(v)
+	redef fun accept_typing(v)
 	do
 		super
 		if n_expr != null then
-			v.check_conform_expr(n_expr, prop.signature.return_type)
+			v.check_conform_expr(n_expr.as(not null), prop.signature.return_type.as(not null))
 		end
 	end
 end
 
 redef class AMethPropdef
-	redef readable attr _self_var: ParamVariable
-	redef meth accept_typing(v)
+	redef fun self_var do return _self_var.as(not null)
+	var _self_var: nullable ParamVariable
+	redef fun accept_typing(v)
 	do
 		v.variable_ctx = new RootVariableContext(v, self)
 		v.base_variable_ctx = v.variable_ctx
@@ -176,7 +180,7 @@ redef class AMethPropdef
 end
 
 redef class AConcreteMethPropdef
-	redef meth accept_typing(v)
+	redef fun accept_typing(v)
 	do
 		super
 		if v.variable_ctx.unreash == false and method.signature.return_type != null then
@@ -186,9 +190,9 @@ redef class AConcreteMethPropdef
 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]
-	redef meth accept_typing(v)
+	readable var _super_init_calls: Array[MMMethod] = new Array[MMMethod]
+	readable var _explicit_super_init_calls: Array[MMMethod] = new Array[MMMethod]
+	redef fun accept_typing(v)
 	do
 		v.top_block = n_block
 		v.explicit_super_init_calls = explicit_super_init_calls
@@ -199,8 +203,8 @@ redef class AConcreteInitPropdef
 		else 
 			var i = 0
 			var l = explicit_super_init_calls.length
-			var cur_m: MMMethod = null
-			var cur_c: MMLocalClass = null
+			var cur_m: nullable MMMethod = null
+			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)
@@ -212,7 +216,7 @@ redef class AConcreteInitPropdef
 					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
-					super_init_calls.add(cur_m)
+					super_init_calls.add(cur_m.as(not null))
 					i += 1
 					if i < l then
 						cur_m = explicit_super_init_calls[i]
@@ -234,20 +238,17 @@ redef class AConcreteInitPropdef
 end
 
 redef class PParam
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
-		# TODO: why the test?
-		if v.variable_ctx != null then
-			v.variable_ctx.add(variable)
-		end
+		v.variable_ctx.add(variable)
 	end
 end
 
 redef class AClosureDecl
 	# The corresponding escapable object
-	readable attr _escapable: EscapableBlock
+	readable var _escapable: nullable EscapableBlock
 
-	redef meth accept_typing(v)
+	redef fun accept_typing(v)
 	do
 		# Register the closure for ClosureCallExpr
 		v.variable_ctx.add(variable)
@@ -257,8 +258,9 @@ redef class AClosureDecl
 		v.base_variable_ctx = v.variable_ctx
 		v.variable_ctx = v.variable_ctx.sub(self)
 
-		_escapable = new EscapableClosure(self, variable.closure, null)
-		v.escapable_ctx.push(_escapable)
+		var escapable = new EscapableClosure(self, variable.closure, null)
+		_escapable = escapable
+		v.escapable_ctx.push(escapable)
 
 		super
 
@@ -280,17 +282,19 @@ redef class AClosureDecl
 end
 
 redef class PType
-	readable attr _stype: MMType
-	redef meth after_typing(v)
+	fun stype: MMType do return _stype.as(not null)
+	var _stype: nullable MMType
+
+	redef fun after_typing(v)
 	do
 		_stype = get_stype(v)
 	end
 end
 
 redef class PExpr
-	redef readable attr _is_typed: Bool = false
-	redef meth is_statement: Bool do return _stype == null
-	redef meth stype
+	redef readable var _is_typed: Bool = false
+	redef fun is_statement: Bool do return _stype == null
+	redef fun stype
 	do
 		if not is_typed then
 			print "{locate}: not is_typed"
@@ -300,41 +304,44 @@ redef class PExpr
 			print "{locate}: is_statement"
 			abort
 		end
-		return _stype
+		return _stype.as(not null)
 	end
-	attr _stype: MMType
+	var _stype: nullable MMType
 
 	# Is the expression the implicit receiver
-	meth is_implicit_self: Bool do return false
+	fun is_implicit_self: Bool do return false
 
 	# Is the expression the current receiver (implicit or explicit)
-	meth is_self: Bool do return false
+	fun is_self: Bool do return false
 
 	# The variable accessed is any
-	meth its_variable: Variable do return null
+	fun its_variable: nullable Variable do return null
 
 	# The variable type information if current boolean expression is true
-	readable private attr _if_true_variable_ctx: VariableContext
+	readable private var _if_true_variable_ctx: nullable VariableContext
 
 	# The variable type information if current boolean expression is false
-	readable private attr _if_false_variable_ctx: VariableContext
+	readable private var _if_false_variable_ctx: nullable VariableContext
 end
 
 redef class AVardeclExpr
-	redef meth after_typing(v)
+	var _variable: nullable VarVariable
+	redef fun variable do return _variable.as(not null)
+
+	redef fun after_typing(v)
 	do
 		var va = new VarVariable(n_id.to_symbol, self)
-		variable = va
+		_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
 			if n_expr != null then
-				v.check_conform_expr(n_expr, va.stype)
+				v.check_conform_expr(n_expr.as(not null), va.stype)
 			end
 		else
-			if not v.check_expr(n_expr) then return
+			if not v.check_expr(n_expr.as(not null)) then return
 			va.stype = n_expr.stype
 		end
 		_is_typed = true
@@ -342,7 +349,7 @@ redef class AVardeclExpr
 end
 
 redef class ABlockExpr
-	redef meth accept_typing(v)
+	redef fun accept_typing(v)
 	do
 		var old_var_ctx = v.variable_ctx
 		v.variable_ctx = v.variable_ctx.sub(self)
@@ -362,23 +369,24 @@ redef class ABlockExpr
 end
 
 redef class AReturnExpr
-	redef meth after_typing(v)
+	redef fun 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
+		var e = n_expr
+		if e == null and t != null then
 			v.error(self, "Error: Return without value in a function.")
-		else if n_expr != null and t == null then
+		else if e != 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_expr(n_expr, t)
+		else if e != null and t != null then
+			v.check_conform_expr(e, t)
 		end
 		_is_typed = true
 	end
 end
 
 redef class AContinueExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		v.variable_ctx.unreash = true
 		var esc = compute_escapable_block(v.escapable_ctx)
@@ -395,14 +403,14 @@ redef class AContinueExpr
 		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)
+			v.check_conform_expr(n_expr.as(not null), t)
 		end
 		_is_typed = true
 	end
 end
 
 redef class ABreakExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		v.variable_ctx.unreash = true
 		var esc = compute_escapable_block(v.escapable_ctx)
@@ -415,21 +423,21 @@ redef class ABreakExpr
 			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)
+			bl.add(n_expr.as(not null))
 		end
 		_is_typed = true
 	end
 end
 
 redef class AAbortExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		v.variable_ctx.unreash = true
 	end
 end
 
 redef class AIfExpr
-	redef meth accept_typing(v)
+	redef fun accept_typing(v)
 	do
 		var old_var_ctx = v.variable_ctx
 		v.visit(n_expr)
@@ -440,7 +448,7 @@ redef class AIfExpr
 
 		# Process the 'then'
 		if n_then != null then
-			v.variable_ctx = v.variable_ctx.sub(n_then)
+			v.variable_ctx = v.variable_ctx.sub(n_then.as(not null))
 			v.visit(n_then)
 		end
 
@@ -453,7 +461,7 @@ redef class AIfExpr
 
 		# Process the 'else'
 		if n_else != null then
-			v.variable_ctx = v.variable_ctx.sub(n_else)
+			v.variable_ctx = v.variable_ctx.sub(n_else.as(not null))
 			v.visit(n_else)
 		end
 
@@ -466,12 +474,13 @@ end
 
 redef class AWhileExpr
 	# The corresponding escapable block
-	readable attr _escapable: EscapableBlock
+	readable var _escapable: nullable EscapableBlock
 
-	redef meth accept_typing(v)
+	redef fun accept_typing(v)
 	do
-		_escapable = new EscapableBlock(self)
-		v.escapable_ctx.push(_escapable)
+		var escapable = new EscapableBlock(self)
+		_escapable = escapable
+		v.escapable_ctx.push(escapable)
 		var old_var_ctx = v.variable_ctx
 		var old_base_var_ctx = v.base_variable_ctx
 		v.base_variable_ctx = v.variable_ctx
@@ -486,7 +495,7 @@ redef class AWhileExpr
 
 		# Process inside
 		if n_block != null then
-			v.variable_ctx = v.variable_ctx.sub(n_block)
+			v.variable_ctx = v.variable_ctx.sub(n_block.as(not null))
 			v.visit(n_block)
 		end
 
@@ -498,36 +507,45 @@ redef class AWhileExpr
 end
 
 redef class AForExpr
-	# The corresponding escapable block
-	readable attr _escapable: EscapableBlock
+	var _variable: nullable AutoVariable
+	redef fun variable do return _variable.as(not null)
 
-	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
-		_escapable = new EscapableBlock(self)
-		v.escapable_ctx.push(_escapable)
+	# The corresponding escapable block
+	readable var _escapable: nullable EscapableBlock
+
+	var _meth_iterator: nullable MMMethod
+	fun meth_iterator: MMMethod do return _meth_iterator.as(not null)
+	var _meth_is_ok: nullable MMMethod
+	fun meth_is_ok: MMMethod do return _meth_is_ok.as(not null)
+	var _meth_item: nullable MMMethod
+	fun meth_item: MMMethod do return _meth_item.as(not null)
+	var _meth_next: nullable MMMethod
+	fun meth_next: MMMethod do return _meth_next.as(not null)
+	redef fun accept_typing(v)
+	do
+		var escapable = new EscapableBlock(self)
+		_escapable = escapable
+		v.escapable_ctx.push(escapable)
 
 		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 va = new AutoVariable(n_id.to_symbol, self)
-		variable = va
+		_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
+
 		_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 iter_type = _meth_iterator.signature_for(expr_type).return_type
+		var iter_type = _meth_iterator.signature_for(expr_type).return_type.as(not null)
 		_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")
@@ -558,7 +576,7 @@ redef class AForExpr
 end
 
 redef class AAssertExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		v.check_conform_expr(n_expr, v.type_bool)
 		v.use_if_true_variable_ctx(n_expr)
@@ -566,10 +584,15 @@ redef class AAssertExpr
 	end
 end
 
+redef class AVarFormExpr
+	var _variable: nullable Variable
+	redef fun variable do return _variable.as(not null)
+end
+
 redef class AVarExpr
-	redef meth its_variable do return variable
+	redef fun its_variable do return variable
 
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		v.variable_ctx.check_is_set(self, variable)
 		_stype = v.variable_ctx.stype(variable)
@@ -578,7 +601,7 @@ redef class AVarExpr
 end
 
 redef class AVarAssignExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		v.variable_ctx.mark_is_set(variable)
 		var t = v.variable_ctx.stype(variable)
@@ -598,7 +621,7 @@ redef class AReassignFormExpr
 	# Compute and check method used through the reassigment operator
 	# On success return the static type of the result of the reassigment operator
 	# Else display an error and return null
-	private meth do_rvalue_typing(v: TypingVisitor, type_lvalue: MMType): MMType
+	private fun do_rvalue_typing(v: TypingVisitor, type_lvalue: nullable MMType): nullable MMType
 	do
 		if type_lvalue == null then
 			return null
@@ -618,11 +641,11 @@ redef class AReassignFormExpr
 	end
 
 	# Method used through the reassigment operator (once computed)
-	readable attr _assign_method: MMMethod
+	readable var _assign_method: nullable MMMethod
 end
 
 redef class AVarReassignExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		v.variable_ctx.check_is_set(self, variable)
 		v.variable_ctx.mark_is_set(variable)
@@ -642,34 +665,37 @@ redef class AVarReassignExpr
 end
 
 redef class PAssignOp
-	meth method_name: Symbol is abstract
+	fun method_name: Symbol is abstract
 end
 redef class APlusAssignOp
-	redef meth method_name do return once "+".to_symbol
+	redef fun method_name do return once "+".to_symbol
 end
 redef class AMinusAssignOp
-	redef meth method_name do return once "-".to_symbol
+	redef fun method_name do return once "-".to_symbol
 end
 
 redef class ASelfExpr
-	redef meth its_variable do return variable
+	var _variable: nullable ParamVariable
+	redef fun variable do return _variable.as(not null)
+
+	redef fun its_variable do return variable
 
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
-		variable = v.self_var
+		_variable = v.self_var
 		_stype = v.variable_ctx.stype(variable)
 		_is_typed = true
 	end
 
-        redef meth is_self do return true
+        redef fun is_self do return true
 end
 
 redef class AImplicitSelfExpr
-        redef meth is_implicit_self do return true
+        redef fun is_implicit_self do return true
 end
 
 redef class AIfexprExpr
-	redef meth accept_typing(v)
+	redef fun accept_typing(v)
 	do
 		var old_var_ctx = v.variable_ctx
 
@@ -688,7 +714,7 @@ redef class AIfexprExpr
 end
 
 redef class ABoolExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		_stype = v.type_bool
 		_is_typed = true
@@ -696,7 +722,7 @@ redef class ABoolExpr
 end
 
 redef class AOrExpr
-	redef meth accept_typing(v)
+	redef fun accept_typing(v)
 	do
 		var old_var_ctx = v.variable_ctx
 
@@ -720,7 +746,7 @@ redef class AOrExpr
 end
 
 redef class AAndExpr
-	redef meth accept_typing(v)
+	redef fun accept_typing(v)
 	do
 		var old_var_ctx = v.variable_ctx
 
@@ -744,7 +770,7 @@ redef class AAndExpr
 end
 
 redef class ANotExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		v.check_conform_expr(n_expr, v.type_bool)
 
@@ -758,7 +784,7 @@ redef class ANotExpr
 end
 
 redef class AIntExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		_stype = v.type_int
 		_is_typed = true
@@ -766,7 +792,7 @@ redef class AIntExpr
 end
 
 redef class AFloatExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		_stype = v.type_float
 		_is_typed = true
@@ -774,7 +800,7 @@ redef class AFloatExpr
 end
 
 redef class ACharExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		_stype = v.type_char
 		_is_typed = true
@@ -782,8 +808,9 @@ redef class ACharExpr
 end
 
 redef class AStringFormExpr
-	readable attr _meth_with_native: MMMethod
-	redef meth after_typing(v)
+	var _meth_with_native: nullable MMMethod
+	fun meth_with_native: MMMethod do return _meth_with_native.as(not null)
+	redef fun after_typing(v)
 	do
 		_stype = v.type_string
 		_is_typed = true
@@ -793,17 +820,22 @@ redef class AStringFormExpr
 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)
+	fun meth_with_capacity: MMMethod do return _meth_with_capacity.as(not null)
+	var _meth_with_capacity: nullable MMMethod
+	fun meth_add: MMMethod do return _meth_add.as(not null)
+	var _meth_add: nullable MMMethod
+	fun meth_to_s: MMMethod do return _meth_to_s.as(not null)
+	var _meth_to_s: nullable MMMethod
+	readable var _atype: nullable MMType
+	redef fun after_typing(v)
+	do
+		var stype = v.type_string
+		_stype = stype
+		var atype = v.type_array(stype)
+		_atype = atype
+		_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)
+		_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.")
@@ -812,7 +844,7 @@ redef class ASuperstringExpr
 end
 
 redef class ANullExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		_stype = v.type_none
 		_is_typed = true
@@ -820,17 +852,18 @@ redef class ANullExpr
 end
 
 redef class AArrayExpr
-	readable attr _meth_with_capacity: MMMethod
-	readable attr _meth_add: MMMethod
+	fun meth_with_capacity: MMMethod do return _meth_with_capacity.as(not null)
+	var _meth_with_capacity: nullable MMMethod
+	fun meth_add: MMMethod do return _meth_add.as(not null)
+	var _meth_add: nullable MMMethod
 
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		var stype = v.check_conform_multiexpr(null, n_exprs)
-		if stype == null then return
-		do_typing(v, stype)
+		if stype != null then do_typing(v, stype)
 	end
 
-	private meth do_typing(v: TypingVisitor, element_type: MMType)
+	private fun do_typing(v: TypingVisitor, element_type: MMType)
 	do
 		_stype = v.type_array(element_type)
 
@@ -844,8 +877,9 @@ redef class AArrayExpr
 end
 
 redef class ARangeExpr
-	readable attr _meth_init: MMMethod
-	redef meth after_typing(v)
+	fun meth_init: MMMethod do return _meth_init.as(not null)
+	var _meth_init: nullable MMMethod
+	redef fun 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
@@ -864,14 +898,14 @@ redef class ARangeExpr
 end
 
 redef class ACrangeExpr
-	redef meth after_typing(v)
+	redef fun 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)
+	redef fun after_typing(v)
 	do
 		super
 		_meth_init = stype.local_class.select_method(once "without_last".to_symbol)
@@ -881,9 +915,9 @@ end
 
 redef class ASuperExpr
 special ASuperInitCall
-	# readable attr _prop: MMSrcMethod
-	readable attr _init_in_superclass: MMMethod
-	redef meth after_typing(v)
+	# readable var _prop: MMSrcMethod
+	readable var _init_in_superclass: nullable MMMethod
+	redef fun after_typing(v)
 	do
 		var precs: Array[MMLocalProperty] = v.local_property.prhe.direct_greaters
 		if not precs.is_empty then
@@ -909,7 +943,7 @@ special ASuperInitCall
 			_init_in_superclass = p
 			register_super_init_call(v, p)
 			if n_args.length > 0 then
-				var signature = get_signature(v, v.self_var.stype, p, true)
+				var signature = get_signature(v, v.self_var.stype.as(not null), p, true)
 				_arguments = process_signature(v, signature, p.name, n_args.to_a)
 			end
 		else
@@ -917,19 +951,19 @@ special ASuperInitCall
 			return
 		end
 
-		if precs.first.signature_for(v.self_var.stype).return_type != null then
+		if precs.first.signature_for(v.self_var.stype.as(not null)).return_type != null then
 			var stypes = new Array[MMType]
-			var stype: MMType = null
+			var stype: nullable MMType = null
 			for prop in precs do
 				assert prop isa MMMethod
-				var t = prop.signature_for(v.self_var.stype).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.module).adapt_to(v.local_property.signature.recv)
 				stypes.add(t)
 				if stype == null or stype < t then
 					stype = t
 				end
 			end
 			for t in stypes do
-				v.check_conform(self, t, stype)
+				v.check_conform(self, t, stype.as(not null))
 			end
 			_stype = stype
 		end
@@ -942,13 +976,13 @@ end
 
 redef class AAttrFormExpr
 	# Attribute accessed
-	readable attr _prop: MMAttribute
+	readable var _prop: nullable MMAttribute
 
 	# Attribute type of the acceded attribute
-	readable attr _attr_type: MMType
+	readable var _attr_type: nullable MMType
 
 	# Compute the attribute accessed
-	private meth do_typing(v: TypingVisitor)
+	private fun do_typing(v: TypingVisitor)
 	do
 		if not v.check_expr(n_expr) then return
 		var type_recv = n_expr.stype
@@ -970,7 +1004,7 @@ redef class AAttrFormExpr
 end
 
 redef class AAttrExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		do_typing(v)
 		if prop == null then return
@@ -980,7 +1014,7 @@ redef class AAttrExpr
 end
 
 redef class AAttrAssignExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		do_typing(v)
 		if prop == null then return
@@ -990,7 +1024,7 @@ redef class AAttrAssignExpr
 end
 
 redef class AAttrReassignExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		do_typing(v)
 		if prop == null then return
@@ -1001,16 +1035,29 @@ redef class AAttrReassignExpr
 	end
 end
 
+redef class AIssetAttrExpr
+	redef fun after_typing(v)
+	do
+		do_typing(v)
+		if prop == null then return
+		if attr_type.is_nullable then
+			v.error(self, "Error: isset on a nullable attribute.")
+		end
+		_stype = v.type_bool
+		_is_typed = true
+	end
+end
+
 class AAbsAbsSendExpr
 special PExpr
 	# The signature of the called property
-	readable attr _prop_signature: MMSignature
+	readable var _prop_signature: nullable MMSignature
 
 	# The real arguments used (after star transformation) (once computed)
-	readable attr _arguments: Array[PExpr]
+	readable var _arguments: nullable 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]
+	private fun process_signature(v: TypingVisitor, psig: MMSignature, name: Symbol, raw_args: nullable Array[PExpr]): nullable Array[PExpr]
 	do
 		var par_vararg = psig.vararg_rank
 		var par_arity = psig.arity
@@ -1047,7 +1094,7 @@ special PExpr
 	end
 
 	# Check the conformity of a set of defined closures
-	private meth process_closures(v: TypingVisitor, psig: MMSignature, name: Symbol, cd: Array[PClosureDef]): MMType
+	private fun process_closures(v: TypingVisitor, psig: MMSignature, name: Symbol, cd: nullable Array[PClosureDef]): nullable MMType
 	do
 		var t = psig.return_type
 		var cs = psig.closures # Declared closures
@@ -1062,7 +1109,7 @@ special PExpr
 				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
+				var break_list: nullable Array[ABreakExpr] = null
 				if t != null then break_list = new Array[ABreakExpr]
 
 				# Process each closure definition
@@ -1090,12 +1137,11 @@ 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], closure_defs: Array[PClosureDef])
+	private fun do_typing(v: TypingVisitor, type_recv: MMType, is_implicit_self: Bool, recv_is_self: Bool, name: Symbol, raw_args: nullable Array[PExpr], closure_defs: nullable 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.name, raw_args)
 		if args == null then return
 		var rtype = process_closures(v, sig, prop.name, closure_defs)
@@ -1106,11 +1152,10 @@ special AAbsAbsSendExpr
 		_return_type = rtype
 	end
 
-	private meth get_property(v: TypingVisitor, type_recv: MMType, is_implicit_self: Bool, name: Symbol): MMMethod
+	private fun get_property(v: TypingVisitor, type_recv: MMType, is_implicit_self: Bool, name: Symbol): nullable MMMethod
 	do
-		if type_recv == null then return null
 		var lc = type_recv.local_class
-		var prop: MMMethod = null
+		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)
@@ -1136,7 +1181,7 @@ special AAbsAbsSendExpr
 	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
+	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)
 		var psig = prop.signature_for(type_recv)
@@ -1145,25 +1190,26 @@ special AAbsAbsSendExpr
 	end
 
 	# The invoked method (once computed)
-	readable attr _prop: MMMethod
+	readable var _prop: nullable MMMethod
 
 	# The return type (if any) (once computed)
-	readable attr _return_type: MMType
+	readable var _return_type: nullable MMType
 end
 
 # A possible call of constructor in a super class
 # Could be an explicit call or with the 'super' keyword
 class ASuperInitCall
 special AAbsSendExpr
-	private meth register_super_init_call(v: TypingVisitor, property: MMMethod)
+	private fun register_super_init_call(v: TypingVisitor, property: MMMethod)
 	do
 		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 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
+		var prev_class: nullable MMLocalClass = null
+		var esic = v.explicit_super_init_calls.as(not null)
+		if not esic.is_empty then
+			prev_class = esic.last.global.intro.local_class
 		end
 		var order = v.local_class.cshe.reverse_linear_extension
 		if cla == v.local_class then
@@ -1181,7 +1227,7 @@ special AAbsSendExpr
 					if not last_is_found then
 						v.error(self, "Error: Constructor of {c} must be invoked before constructor of {prev_class}")
 					end
-					v.explicit_super_init_calls.add(property)
+					esic.add(property)
 					break
 				end
 			end
@@ -1192,10 +1238,10 @@ end
 
 redef class ANewExpr
 special AAbsSendExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
+		if n_type._stype == null then return
 		var t = n_type.stype
-		if t == null then return
 		if t.local_class.global.is_abstract then
 			v.error(self, "Error: try to instantiate abstract class {t.local_class}.")
 			return
@@ -1223,24 +1269,25 @@ end
 redef class ASendExpr
 special ASuperInitCall
 	# Name of the invoked property
-	meth name: Symbol is abstract 
+	fun name: Symbol is abstract 
 
 	# Raw arguments used (withour star transformation)
-	meth raw_arguments: Array[PExpr] is abstract
+	fun raw_arguments: nullable Array[PExpr] is abstract
 
 	# Closure definitions
-	meth closure_defs: Array[PClosureDef] do return null
+	fun closure_defs: nullable Array[PClosureDef] do return null
 
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		do_all_typing(v)
 	end
 
-	private meth do_all_typing(v: TypingVisitor)
+	private fun 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, closure_defs)
-		if prop == null then return
+		if _prop == null then return
+		var prop = _prop.as(not null)
 
 		if prop.global.is_init then
 			if not v.local_property.global.is_init then
@@ -1260,12 +1307,13 @@ end
 class ASendReassignExpr
 special ASendExpr
 special AReassignFormExpr
-	readable attr _read_prop: MMMethod
-	redef meth do_all_typing(v)
+	readable var _read_prop: nullable MMMethod
+	redef fun 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, null)
+		var prop = _prop
 		if prop == null then return
 		if prop.global.is_init then
 			if not v.local_property.global.is_init then
@@ -1274,7 +1322,7 @@ special AReassignFormExpr
 				v.error(self, "Error: constructor {prop} is not invoken on 'self'.")
 			end
 		end
-		var t = prop.signature_for(n_expr.stype).return_type
+		var t = prop.signature_for(n_expr.stype).return_type.as(not null)
 		if not n_expr.is_self then t = t.not_for_self
 
 		var t2 = do_rvalue_typing(v, t)
@@ -1286,7 +1334,6 @@ special AReassignFormExpr
 		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, null)
-		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.")
@@ -1301,11 +1348,11 @@ special AReassignFormExpr
 end
 
 redef class ABinopExpr
-	redef meth raw_arguments do return [n_expr2]
+	redef fun raw_arguments do return [n_expr2]
 end
 redef class AEqExpr
-	redef meth name do return once "==".to_symbol
-	redef meth after_typing(v)
+	redef fun name do return once "==".to_symbol
+	redef fun after_typing(v)
 	do
 		super
 		if not is_typed then return
@@ -1321,7 +1368,7 @@ redef class AEqExpr
 		end
 	end
 
-	private meth try_to_isa(v: TypingVisitor, n: PExpr)
+	private fun try_to_isa(v: TypingVisitor, n: PExpr)
 	do
 		var variable = n.its_variable
 		if variable != null then
@@ -1330,8 +1377,8 @@ redef class AEqExpr
 	end
 end
 redef class ANeExpr
-	redef meth name do return once "!=".to_symbol
-	redef meth after_typing(v)
+	redef fun name do return once "!=".to_symbol
+	redef fun after_typing(v)
 	do
 		super
 		if not is_typed then return
@@ -1347,7 +1394,7 @@ redef class ANeExpr
 		end
 	end
 
-	private meth try_to_isa(v: TypingVisitor, n: PExpr)
+	private fun try_to_isa(v: TypingVisitor, n: PExpr)
 	do
 		var variable = n.its_variable
 		if variable != null then
@@ -1356,52 +1403,52 @@ redef class ANeExpr
 	end
 end
 redef class ALtExpr
-	redef meth name do return once "<".to_symbol
+	redef fun name do return once "<".to_symbol
 end
 redef class ALeExpr
-	redef meth name do return once "<=".to_symbol
+	redef fun name do return once "<=".to_symbol
 end
 redef class AGtExpr
-	redef meth name do return once ">".to_symbol
+	redef fun name do return once ">".to_symbol
 end
 redef class AGeExpr
-	redef meth name do return once ">=".to_symbol
+	redef fun name do return once ">=".to_symbol
 end
 redef class APlusExpr
-	redef meth name do return once "+".to_symbol
+	redef fun name do return once "+".to_symbol
 end
 redef class AMinusExpr
-	redef meth name do return once "-".to_symbol
+	redef fun name do return once "-".to_symbol
 end
 redef class AStarshipExpr
-	redef meth name do return once "<=>".to_symbol
+	redef fun name do return once "<=>".to_symbol
 end
 redef class AStarExpr
-	redef meth name do return once "*".to_symbol
+	redef fun name do return once "*".to_symbol
 end
 redef class ASlashExpr
-	redef meth name do return once "/".to_symbol
+	redef fun name do return once "/".to_symbol
 end
 redef class APercentExpr
-	redef meth name do return once "%".to_symbol
+	redef fun name do return once "%".to_symbol
 end
 
 redef class AUminusExpr
-	redef meth name do return once "unary -".to_symbol
-	redef meth raw_arguments do return null
+	redef fun name do return once "unary -".to_symbol
+	redef fun raw_arguments do return null
 end
 
 redef class ACallFormExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
-		if n_expr != null and n_expr.is_implicit_self then
+		if n_expr.is_implicit_self then
 			var name = n_id.to_symbol
 			var variable = v.variable_ctx[name]
 			if variable != null then
 				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._variable = variable
 					n.after_typing(v)
 					return
 				else
@@ -1410,7 +1457,7 @@ redef class ACallFormExpr
 						return
 					end
 					var vform = variable_create(variable)
-					vform.variable = variable
+					vform._variable = variable
 					replace_with(vform)
 					vform.after_typing(v)
 					return
@@ -1421,9 +1468,9 @@ redef class ACallFormExpr
 		super
 	end
 
-	redef meth closure_defs
+	redef fun closure_defs
 	do
-		if n_closure_defs == null or n_closure_defs.is_empty then
+		if n_closure_defs.is_empty then
 			return null
 		else
 			return n_closure_defs.to_a
@@ -1431,27 +1478,27 @@ redef class ACallFormExpr
 	end
 
 	# Create a variable acces corresponding to the call form
-	meth variable_create(variable: Variable): AVarFormExpr is abstract
+	fun variable_create(variable: Variable): AVarFormExpr is abstract
 end
 
 redef class ACallExpr
-	redef meth variable_create(variable)
+	redef fun variable_create(variable)
 	do
 		return new AVarExpr.init_avarexpr(n_id)
 	end
 
-	redef meth name do return n_id.to_symbol
-	redef meth raw_arguments do return n_args.to_a
+	redef fun name do return n_id.to_symbol
+	redef fun raw_arguments do return n_args.to_a
 end
 
 redef class ACallAssignExpr
-	redef meth variable_create(variable)
+	redef fun variable_create(variable)
 	do
 		return new AVarAssignExpr.init_avarassignexpr(n_id, n_assign, n_value)
 	end
 
-	redef meth name do return (n_id.text + "=").to_symbol
-	redef meth raw_arguments do
+	redef fun name do return (n_id.text + "=").to_symbol
+	redef fun raw_arguments do
 		var res = n_args.to_a
 		res.add(n_value)
 		return res
@@ -1460,23 +1507,23 @@ end
 
 redef class ACallReassignExpr
 special ASendReassignExpr
-	redef meth variable_create(variable)
+	redef fun variable_create(variable)
 	do
 		return new AVarReassignExpr.init_avarreassignexpr(n_id, n_assign_op, n_value)
 	end
 
-	redef meth name do return n_id.to_symbol
-	redef meth raw_arguments do return n_args.to_a
+	redef fun name do return n_id.to_symbol
+	redef fun raw_arguments do return n_args.to_a
 end
 
 redef class ABraExpr
-	redef meth name do return once "[]".to_symbol
-	redef meth raw_arguments do return n_args.to_a
+	redef fun name do return once "[]".to_symbol
+	redef fun raw_arguments do return n_args.to_a
 end
 
 redef class ABraAssignExpr
-	redef meth name do return once "[]=".to_symbol
-	redef meth raw_arguments do
+	redef fun name do return once "[]=".to_symbol
+	redef fun raw_arguments do
 		var res = n_args.to_a
 		res.add(n_value)
 		return res
@@ -1485,18 +1532,21 @@ end
 
 redef class ABraReassignExpr
 special ASendReassignExpr
-	redef meth name do return once "[]".to_symbol
-	redef meth raw_arguments do return n_args.to_a
+	redef fun name do return once "[]".to_symbol
+	redef fun raw_arguments do return n_args.to_a
 end
 
 redef class AInitExpr
-	redef meth name do return once "init".to_symbol
-	redef meth raw_arguments do return n_args.to_a
+	redef fun name do return once "init".to_symbol
+	redef fun raw_arguments do return n_args.to_a
 end
 
 redef class AClosureCallExpr
 special AAbsAbsSendExpr
-	redef meth after_typing(v)
+	var _variable: nullable ClosureVariable
+	redef fun variable do return _variable.as(not null)
+
+	redef fun after_typing(v)
 	do
 		var va = variable
 		if va.closure.is_break then v.variable_ctx.unreash = true
@@ -1514,21 +1564,24 @@ special AAbsAbsSendExpr
 end
 
 redef class PClosureDef
+	var _closure: nullable MMClosure
+	redef fun closure do return _closure.as(not null)
+
 	# The corresponding escapable object
-	readable attr _escapable: EscapableBlock
+	readable var _escapable: nullable EscapableBlock
 
-	attr _accept_typing2: Bool
-	redef meth accept_typing(v)
+	var _accept_typing2: Bool = false
+	redef fun 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
+	private fun accept_typing2(v: TypingVisitor, esc: EscapableClosure) is abstract
 end
 
 redef class AClosureDef
-	redef meth accept_typing2(v, esc)
+	redef fun accept_typing2(v, esc)
 	do
 		_escapable = esc
 
@@ -1538,7 +1591,7 @@ redef class AClosureDef
 			return
 		end
 
-		closure = esc.closure
+		_closure = esc.closure
 
 		var old_var_ctx = v.variable_ctx
 		var old_base_var_ctx = v.base_variable_ctx
@@ -1569,7 +1622,7 @@ end
 
 class ATypeCheckExpr
 special PExpr
-	private meth check_expr_cast(v: TypingVisitor, n_expr: PExpr, n_type: PType)
+	private fun 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
@@ -1579,7 +1632,13 @@ special PExpr
 		else if etype < ttype then
 			v.warning(self, "Warning: Expression is already a {ttype} since it is a {etype}.")
 		else if etype.is_nullable and etype.as_notnull == ttype then
-			if self isa AIsaExpr then
+			if ttype isa MMTypeFormal and ttype.bound.is_nullable then
+				# No warning in this case since with
+				#   type T: nullable A
+				#   var x: nullable T
+				# 'x.as(not null)' != 'x.as(T)'
+				# 'x != null' != 'x isa T'
+			else if self isa AIsaExpr then
 				v.warning(self, "Warning: Prefer '!= null'.")
 			else
 				v.warning(self, "Warning: Prefer '.as(not null)'.")
@@ -1590,7 +1649,7 @@ end
 
 redef class AIsaExpr
 special ATypeCheckExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		check_expr_cast(v, n_expr, n_type)
 		var variable = n_expr.its_variable
@@ -1604,7 +1663,7 @@ end
 
 redef class AAsCastExpr
 special ATypeCheckExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		check_expr_cast(v, n_expr, n_type)
 		_stype = n_type.stype
@@ -1613,7 +1672,7 @@ special ATypeCheckExpr
 end
 
 redef class AAsNotnullExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		if not v.check_expr(n_expr) then return
 		var t = n_expr.stype
@@ -1629,7 +1688,7 @@ redef class AAsNotnullExpr
 end
 
 redef class AProxyExpr
-	redef meth after_typing(v)
+	redef fun after_typing(v)
 	do
 		if not n_expr.is_typed then return
 		_is_typed = true
@@ -1639,7 +1698,7 @@ redef class AProxyExpr
 end
 
 redef class AOnceExpr
-	redef meth accept_typing(v)
+	redef fun accept_typing(v)
 	do
 		if v.once_count > 0 then
 			v.warning(self, "Useless once in a once expression.")