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

diff --git a/src/typing.nit b/src/typing.nit
index ca0c64d..207bf95 100644
--- a/src/typing.nit
+++ b/src/typing.nit
@@ -19,7 +19,23 @@
 module typing
 
 import flow
-import modelbuilder
+import modelize_property
+import phase
+import local_var_init
+
+redef class ToolContext
+	var typing_phase: Phase = new TypingPhase(self, [flow_phase, modelize_property_phase, local_var_init_phase])
+end
+
+redef class MPropDef
+	# Does the MPropDef contains a call to super or a call of a super-constructor?
+	var has_supercall: Bool = false
+end
+
+private class TypingPhase
+	super Phase
+	redef fun process_npropdef(npropdef) do npropdef.do_typing(toolcontext.modelbuilder)
+end
 
 private class TypeVisitor
 	var modelbuilder:  ModelBuilder
@@ -68,21 +84,34 @@ private class TypeVisitor
 		return res
 	end
 
-	fun resolve_signature_for(msignature: MSignature, recv: MType, for_self: Bool): MSignature
+	# Retrieve the signature of a `MMethodDef` resolved for a specific call.
+	# This method is an helper to symplify the query on the model.
+	#
+	# Note: `for_self` indicates if the reciever is self or not.
+	# If yes, virtual types are not resolved.
+	fun resolve_signature_for(mmethoddef: MMethodDef, recv: MType, for_self: Bool): MSignature
 	do
-		return self.resolve_for(msignature, recv, for_self).as(MSignature)
+		return self.resolve_for(mmethoddef.msignature.as(not null), recv, for_self).as(MSignature)
 	end
 
-	fun check_subtype(node: ANode, sub, sup: MType): Bool
+	# Check that `sub` is a subtype of `sup`.
+	# If `sub` is not a valud suptype, then display an error on `node` an return null.
+	# If `sub` is a safe subtype of `sup` then return `sub`.
+	# If `sub` is an insafe subtype (ie an imlicit cast is required), then return `sup`.
+	#
+	# The point of the return type is to determinate the usable type on an expression:
+	# If the suptype is safe, then the return type is the one on the expression typed by `sub`.
+	# Is the subtype is unsafe, then the return type is the one of an implicit cast on `sup`.
+	fun check_subtype(node: ANode, sub, sup: MType): nullable MType
 	do
-		if self.is_subtype(sub, sup) then return true
+		if self.is_subtype(sub, sup) then return sub
 		if self.is_subtype(sub, self.anchor_to(sup)) then
 			# FIXME workarround to the current unsafe typing policy. To remove once fixed virtual types exists.
 			#node.debug("Unsafe typing: expected {sup}, got {sub}")
-			return true
+			return sup
 		end
 		self.modelbuilder.error(node, "Type error: expected {sup}, got {sub}")
-		return false
+		return null
 	end
 
 	# Visit an expression and do not care about the return value
@@ -96,7 +125,7 @@ private class TypeVisitor
 	# Return the type of the expression
 	# Display an error and return null if:
 	#  * the type cannot be determined or
-	#  * `nexpr' is a statement
+	#  * `nexpr` is a statement
 	fun visit_expr(nexpr: AExpr): nullable MType
 	do
 		nexpr.accept_typing(self)
@@ -114,11 +143,11 @@ private class TypeVisitor
 		return null
 	end
 
-	# Visit an expression and expect its static type is a least a `sup'
-	# Return the type of the expression
+	# Visit an expression and expect its static type is a least a `sup`
+	# Return the type of the expression or null if
 	#  * the type cannot be determined or
-	#  * `nexpr' is a statement
-	#  * `nexpt' is not a `sup'
+	#  * `nexpr` is a statement or
+	#  * `nexpr` is not a `sup`
 	fun visit_expr_subtype(nexpr: AExpr, sup: nullable MType): nullable MType
 	do
 		var sub = visit_expr(nexpr)
@@ -126,17 +155,18 @@ private class TypeVisitor
 
 		if sup == null then return null # Forward error
 
-		if not check_subtype(nexpr, sub, sup) then
-			return null
+		var res = check_subtype(nexpr, sub, sup)
+		if res != sub then
+			nexpr.implicit_cast_to = res
 		end
-		return sub
+		return res
 	end
 
-	# Visit an expression and expect its static type is a bool
-	# Return the type of the expression
+	# Visit an expression and expect its static type is a `Bool`
+	# Return the type of the expression or null if
 	#  * the type cannot be determined or
-	#  * `nexpr' is a statement
-	#  * `nexpt' is not a `sup'
+	#  * `nexpr` is a statement or
+	#  * `nexpr` is not a `Bool`
 	fun visit_expr_bool(nexpr: AExpr): nullable MType
 	do
 		return self.visit_expr_subtype(nexpr, self.type_bool(nexpr))
@@ -195,11 +225,15 @@ private class TypeVisitor
 		return mclass.mclass_type
 	end
 
-	fun get_method(node: ANode, recvtype: MType, name: String, recv_is_self: Bool): nullable MMethodDef
+	fun get_method(node: ANode, recvtype: MType, name: String, recv_is_self: Bool): nullable CallSite
 	do
 		var unsafe_type = self.anchor_to(recvtype)
 
 		#debug("recv: {recvtype} (aka {unsafe_type})")
+		if recvtype isa MNullType then
+			self.error(node, "Error: Method '{name}' call on 'null'.")
+			return null
+		end
 
 		var mproperty = self.try_get_mproperty_by_name2(node, unsafe_type, name)
 		if mproperty == null then
@@ -212,23 +246,41 @@ private class TypeVisitor
 			return null
 		end
 
+		assert mproperty isa MMethod
 		if mproperty.visibility == protected_visibility and not recv_is_self and self.mmodule.visibility_for(mproperty.intro_mclassdef.mmodule) < intrude_visibility then
 			self.modelbuilder.error(node, "Error: Method '{name}' is protected and can only acceded by self. {mproperty.intro_mclassdef.mmodule.visibility_for(self.mmodule)}")
 			return null
 		end
 
 		var propdefs = mproperty.lookup_definitions(self.mmodule, unsafe_type)
+		var mpropdef
 		if propdefs.length == 0 then
 			self.modelbuilder.error(node, "Type error: no definition found for property {name} in {unsafe_type}")
 			return null
-		else if propdefs.length > 1 then
-			self.modelbuilder.error(node, "Error: confliting property definitions for property {name} in {unsafe_type}: {propdefs.join(" ")}")
-			return null
+		else if propdefs.length == 1 then
+			mpropdef = propdefs.first
+		else
+			self.modelbuilder.warning(node, "Warning: confliting property definitions for property {name} in {unsafe_type}: {propdefs.join(" ")}")
+			mpropdef = mproperty.intro
 		end
 
-		var propdef = propdefs.first
-		assert propdef isa MMethodDef
-		return propdef
+
+		var msignature = self.resolve_signature_for(mpropdef, recvtype, recv_is_self)
+
+		var erasure_cast = false
+		var rettype = mpropdef.msignature.return_mtype
+		if not recv_is_self and rettype != null then
+			if rettype isa MNullableType then rettype = rettype.mtype
+			if rettype isa MParameterType then
+				var erased_rettype = msignature.return_mtype
+				assert erased_rettype != null
+				#node.debug("Erasure cast: Really a {rettype} but unsafely a {erased_rettype}")
+				erasure_cast = true
+			end
+		end
+
+		var callsite = new CallSite(node, recvtype, recv_is_self, mproperty, mpropdef, msignature, erasure_cast)
+		return callsite
 	end
 
 	# Visit the expressions of args and cheik their conformity with the corresponding typi in signature
@@ -334,6 +386,38 @@ private class TypeVisitor
 	end
 end
 
+# A specific method call site with its associated informations.
+class CallSite
+	# The assiciated node for location
+	var node: ANode
+
+	# The statis type of the receiver
+	var recv: MType
+
+	# Is the receiver self?
+	# If "for_self", virtual types of the signature are keeped
+	# If "not_for_self", virtual type are erased
+	var recv_is_self: Bool
+
+	# The designated method
+	var mproperty: MMethod
+
+	# The statically designated method definition
+	# The most specif one, it is.
+	var mpropdef: MMethodDef
+
+	# The resolved signature for the receiver
+	var msignature: MSignature
+
+	# Is a implicit cast required on erasure typing policy?
+	var erasure_cast: Bool
+
+	private fun check_signature(v: TypeVisitor, args: Array[AExpr]): Bool
+	do
+		return v.check_signature(self.node, args, self.mproperty.name, self.msignature)
+	end
+end
+
 redef class Variable
 	# The declared type of the variable
 	var declared_type: nullable MType
@@ -417,12 +501,6 @@ redef class AConcreteMethPropdef
 			assert variable != null
 			variable.declared_type = mtype
 		end
-		for i in [0..mmethoddef.msignature.mclosures.length[ do
-			var mclosure = mmethoddef.msignature.mclosures[i]
-			var variable = self.n_signature.n_closure_decls[i].variable
-			assert variable != null
-			variable.declared_type = mclosure.mtype
-		end
 		v.visit_stmt(nblock)
 
 		if not nblock.after_flow_context.is_unreachable and mmethoddef.msignature.return_mtype != null then
@@ -455,9 +533,15 @@ redef class AExpr
 	var mtype: nullable MType = null
 
 	# Is the statement correctly typed?
-	# Used to distinguish errors and statements when `mtype' == null
+	# Used to distinguish errors and statements when `mtype == null`
 	var is_typed: Bool = false
 
+	# If required, the following implicit cast `.as(XXX)`
+	# Such a cast may by required after evaluating the expression when
+	# a unsafe operation is detected (silently accepted by the Nit language).
+	# The attribute is computed by `check_subtype`
+	var implicit_cast_to: nullable MType = null
+
 	# Return the variable read (if any)
 	# Used to perform adaptive typing
 	fun its_variable: nullable Variable do return null
@@ -474,6 +558,13 @@ redef class ABlockExpr
 		for e in self.n_expr do v.visit_stmt(e)
 		self.is_typed = true
 	end
+
+	# The type of a blockexpr is the one of the last expression (or null if empty)
+	redef fun mtype
+	do
+		if self.n_expr.is_empty then return null
+		return self.n_expr.last.mtype
+	end
 end
 
 redef class AVardeclExpr
@@ -501,11 +592,13 @@ redef class AVardeclExpr
 			end
 		end
 
-		if mtype == null then
-			mtype = v.get_mclass(self, "Object").mclass_type.as_nullable
+		var decltype = mtype
+		if mtype == null or mtype isa MNullType then
+			decltype = v.get_mclass(self, "Object").mclass_type.as_nullable
+			if mtype == null then mtype = decltype
 		end
 
-		variable.declared_type = mtype
+		variable.declared_type = decltype
 		v.set_variable(self, variable, mtype)
 
 		#debug("var {variable}: {mtype}")
@@ -547,15 +640,18 @@ redef class AVarAssignExpr
 end
 
 redef class AReassignFormExpr
+	# @depreciated use `reassign_callsite`
+	fun reassign_property: nullable MMethodDef do return self.reassign_callsite.mpropdef
+
 	# The method designed by the reassign operator.
-	var reassign_property: nullable MMethodDef = null
+	var reassign_callsite: nullable CallSite
 
 	var read_type: nullable MType = null
 
-	# Determine the `reassign_property'
-	# `readtype' is the type of the reading of the left value.
-	# `writetype' is the type of the writing of the left value.
-	# (Because of ACallReassignExpr, both can be different.
+	# Determine the `reassign_property`
+	# `readtype` is the type of the reading of the left value.
+	# `writetype` is the type of the writing of the left value.
+	# (Because of `ACallReassignExpr`, both can be different.
 	# Return the static type of the value to store.
 	private fun resolve_reassignment(v: TypeVisitor, readtype, writetype: MType): nullable MType
 	do
@@ -575,15 +671,11 @@ redef class AReassignFormExpr
 			return null
 		end
 
-		var mpropdef = v.get_method(self, readtype, reassign_name, false)
-		if mpropdef == null then return null # Skip error
-
-		self.reassign_property = mpropdef
-
-		var msignature = mpropdef.msignature
-		assert msignature!= null
-		msignature = v.resolve_signature_for(msignature, readtype, false)
+		var callsite = v.get_method(self, readtype, reassign_name, false)
+		if callsite == null then return null # Skip error
+		self.reassign_callsite = callsite
 
+		var msignature = callsite.msignature
 		var rettype = msignature.return_mtype
 		assert msignature.arity == 1 and rettype != null
 
@@ -604,6 +696,8 @@ redef class AVarReassignExpr
 		var readtype = v.get_variable(self, variable)
 		if readtype == null then return
 
+		read_type = readtype
+
 		var writetype = variable.declared_type
 		if writetype == null then return
 
@@ -732,16 +826,44 @@ redef class AForExpr
 
 	private fun do_type_iterator(v: TypeVisitor, mtype: MType)
 	do
+		# get obj class
 		var objcla = v.get_mclass(self, "Object")
 		if objcla == null then return
 
+		# check iterator method
+		var unsafe_type = v.anchor_to(mtype)
+		if v.try_get_mproperty_by_name2(self, unsafe_type, "iterator") == null then
+			if v.try_get_mproperty_by_name2(self, unsafe_type, "iterate") == null then
+				v.error(self, "Type Error: Expected method 'iterator' in type {mtype}")
+			else
+				v.modelbuilder.error(self, "NOT YET IMPLEMENTED: Do 'for' on {mtype}")
+			end
+			return
+		end
+
+		var itdef = v.get_method(self, mtype, "iterator", true)
+		if itdef == null then
+			v.error(self, "Type Error: Expected method 'iterator' in type {mtype}")
+			return
+		end
+		self.method_iterator = itdef.mproperty
+
+		# check that iterator return something
+		var ittype = itdef.msignature.return_mtype
+		if ittype == null then
+			v.error(self, "Type Error: Expected method 'iterator' to return an Iterator or MapIterator type")
+			return
+		end
+
+		# get iterator type
+		var colit_cla = v.try_get_mclass(self, "Iterator")
+		var mapit_cla = v.try_get_mclass(self, "MapIterator")
 		var is_col = false
 		var is_map = false
 
-		var colcla = v.try_get_mclass(self, "Collection")
-		if colcla != null and v.is_subtype(mtype, colcla.get_mtype([objcla.mclass_type.as_nullable])) then
-			var coltype = mtype.supertype_to(v.mmodule, v.anchor, colcla)
-			self.coltype = coltype
+		if colit_cla != null and v.is_subtype(ittype, colit_cla.get_mtype([objcla.mclass_type.as_nullable])) then
+			# Iterator
+			var coltype = ittype.supertype_to(v.mmodule, v.anchor, colit_cla)
 			var variables =  self.variables
 			if variables.length != 1 then
 				v.error(self, "Type Error: Expected one variable")
@@ -751,10 +873,9 @@ redef class AForExpr
 			is_col = true
 		end
 
-		var mapcla = v.try_get_mclass(self, "Map")
-		if mapcla != null and v.is_subtype(mtype, mapcla.get_mtype([objcla.mclass_type.as_nullable, objcla.mclass_type.as_nullable])) then
-			var coltype = mtype.supertype_to(v.mmodule, v.anchor, mapcla)
-			self.coltype = coltype
+		if mapit_cla != null and v.is_subtype(ittype, mapit_cla.get_mtype([objcla.mclass_type, objcla.mclass_type.as_nullable])) then
+			# Map Iterator
+			var coltype = ittype.supertype_to(v.mmodule, v.anchor, mapit_cla)
 			var variables = self.variables
 			if variables.length != 2 then
 				v.error(self, "Type Error: Expected two variables")
@@ -765,58 +886,46 @@ redef class AForExpr
 			is_map = true
 		end
 
-		if is_col or is_map then
-			# get iterator method
-			var coltype = self.coltype.as(not null)
-			var itdef = v.get_method(self, coltype, "iterator", true)
-			var itdefsign = itdef.msignature
-			if itdef == null or itdefsign == null then
-				v.error(self, "Type Error: Expected method 'iterator' in type {coltype}")
-				return
-			end
-			self.method_iterator = itdef.mproperty
+		if not is_col and not is_map then
+			v.error(self, "Type Error: Expected method 'iterator' to return an Iterator of MapIterator type")
+			return
+		end
 
-			# get iterator type
-			var ittype = v.resolve_signature_for(itdefsign, mtype, false).return_mtype
-			if ittype == null then
-				v.error(self, "Type Error: Expected method 'iterator' to return an Iterator type")
-				return
-			end
+		# anchor formal and virtual types
+		if mtype.need_anchor then mtype = v.anchor_to(mtype)
 
-			# get methods is_ok, next, item
-			var ikdef = v.get_method(self, ittype, "is_ok", false)
-			if ikdef == null then
-				v.error(self, "Type Error: Expected method 'is_ok' in Iterator type {ittype}")
-				return
-			end
-			self.method_is_ok = ikdef.mproperty
+		self.coltype = mtype.as(MClassType)
 
-			var itemdef = v.get_method(self, ittype, "item", false)
-			if itemdef == null then
-				v.error(self, "Type Error: Expected method 'item' in Iterator type {ittype}")
-				return
-			end
-			self.method_item = itemdef.mproperty
+		# get methods is_ok, next, item
+		var ikdef = v.get_method(self, ittype, "is_ok", false)
+		if ikdef == null then
+			v.error(self, "Type Error: Expected method 'is_ok' in Iterator type {ittype}")
+			return
+		end
+		self.method_is_ok = ikdef.mproperty
 
-			var nextdef = v.get_method(self, ittype, "next", false)
-			if nextdef == null then
-				v.error(self, "Type Error: Expected method 'next' in Iterator type {ittype}")
-				return
-			end
-			self.method_next = nextdef.mproperty
+		var itemdef = v.get_method(self, ittype, "item", false)
+		if itemdef == null then
+			v.error(self, "Type Error: Expected method 'item' in Iterator type {ittype}")
+			return
+		end
+		self.method_item = itemdef.mproperty
 
-			if is_map then
-				var keydef = v.get_method(self, ittype, "key", false)
-				if keydef == null then
-					v.error(self, "Type Error: Expected method 'key' in Iterator type {ittype}")
-					return
-				end
-				self.method_key = keydef.mproperty
-			end
+		var nextdef = v.get_method(self, ittype, "next", false)
+		if nextdef == null then
+			v.error(self, "Type Error: Expected method 'next' in Iterator type {ittype}")
 			return
 		end
+		self.method_next = nextdef.mproperty
 
-		v.modelbuilder.error(self, "NOT YET IMPLEMENTED: Do 'for' on {mtype}")
+		if is_map then
+			var keydef = v.get_method(self, ittype, "key", false)
+			if keydef == null then
+				v.error(self, "Type Error: Expected method 'key' in Iterator type {ittype}")
+				return
+			end
+			self.method_key = keydef.mproperty
+		end
 	end
 
 	redef fun accept_typing(v)
@@ -850,6 +959,15 @@ redef class AOrExpr
 	end
 end
 
+redef class AImpliesExpr
+	redef fun accept_typing(v)
+	do
+		v.visit_expr_bool(n_expr)
+		v.visit_expr_bool(n_expr2)
+		self.mtype = v.type_bool(self)
+	end
+end
+
 redef class AAndExpr
 	redef fun accept_typing(v)
 	do
@@ -884,21 +1002,16 @@ redef class AOrElseExpr
 
 		var t = v.merge_types(self, [t1, t2])
 		if t == null then
-			v.error(self, "Type Error: ambiguous type {t1} vs {t2}")
+			t = v.mmodule.object_type
+			if t2 isa MNullableType then
+				t = t.as_nullable
+			end
+			#v.error(self, "Type Error: ambiguous type {t1} vs {t2}")
 		end
 		self.mtype = t
 	end
 end
 
-redef class AEeExpr
-	redef fun accept_typing(v)
-	do
-		v.visit_expr(n_expr)
-		v.visit_expr(n_expr2)
-		self.mtype = v.type_bool(self)
-	end
-end
-
 redef class ATrueExpr
 	redef fun accept_typing(v)
 	do
@@ -988,7 +1101,7 @@ redef class ARangeExpr
 	do
 		var discrete_class = v.get_mclass(self, "Discrete")
 		if discrete_class == null then return # Forward error
-		var discrete_type = discrete_class.mclassdefs.first.bound_mtype
+		var discrete_type = discrete_class.intro.bound_mtype
 		var t1 = v.visit_expr_subtype(self.n_expr, discrete_type)
 		var t2 = v.visit_expr_subtype(self.n_expr2, discrete_type)
 		if t1 == null or t2 == null then return
@@ -1013,7 +1126,7 @@ end
 
 redef class AIsaExpr
 	# The static type to cast to.
-	# (different from the static type of the expression that is Bool).
+	# (different from the static type of the expression that is `Bool`).
 	var cast_type: nullable MType
 	redef fun accept_typing(v)
 	do
@@ -1077,8 +1190,11 @@ end
 ## MESSAGE SENDING AND PROPERTY
 
 redef class ASendExpr
+	# @depreciated: use `callsite`
+	fun mproperty: nullable MMethod do return callsite.mproperty
+
 	# The property invoked by the send.
-	var mproperty: nullable MMethod
+	var callsite: nullable CallSite
 
 	redef fun accept_typing(v)
 	do
@@ -1091,22 +1207,17 @@ redef class ASendExpr
 			return
 		end
 
-		var propdef = v.get_method(self, recvtype, name, self.n_expr isa ASelfExpr)
-		if propdef == null then return
-		var mproperty = propdef.mproperty
-		self.mproperty = mproperty
-		var msignature = propdef.msignature
-		if msignature == null then abort # Forward error
-
-		var for_self = self.n_expr isa ASelfExpr
-		msignature = v.resolve_signature_for(msignature, recvtype, for_self)
+		var callsite = v.get_method(self, recvtype, name, self.n_expr isa ASelfExpr)
+		if callsite == null then return
+		self.callsite = callsite
+		var msignature = callsite.msignature
 
 		var args = compute_raw_arguments
 		self.raw_arguments = args
 
-		v.check_signature(self, args, name, msignature)
+		callsite.check_signature(v, args)
 
-		if mproperty.is_init then
+		if callsite.mproperty.is_init then
 			var vmpropdef = v.mpropdef
 			if not (vmpropdef isa MMethodDef and vmpropdef.mproperty.is_init) then
 				v.error(self, "Can call a init only in another init")
@@ -1119,14 +1230,6 @@ redef class ASendExpr
 		else
 			self.is_typed = true
 		end
-
-		if self.n_closure_defs.length == msignature.mclosures.length then
-			for i in [0..self.n_closure_defs.length[ do
-				self.n_closure_defs[i].accept_typing(v, msignature.mclosures[i])
-			end
-		else
-			debug("closure: got {self.n_closure_defs.length}, want {msignature.mclosures.length}")
-		end
 	end
 
 	# The name of the property
@@ -1250,8 +1353,11 @@ redef class ABraAssignExpr
 end
 
 redef class ASendReassignFormExpr
+	# @depreciated use `write_callsite`
+	fun write_mproperty: nullable MMethod do return write_callsite.mproperty
+
 	# The property invoked for the writing
-	var write_mproperty: nullable MMethod = null
+	var write_callsite: nullable CallSite
 
 	redef fun accept_typing(v)
 	do
@@ -1264,40 +1370,33 @@ redef class ASendReassignFormExpr
 			return
 		end
 
-		var propdef = v.get_method(self, recvtype, name, self.n_expr isa ASelfExpr)
-		if propdef == null then return
-		var mproperty = propdef.mproperty
-		self.mproperty = mproperty
-		var msignature = propdef.msignature
-		if msignature == null then abort # Forward error
 		var for_self = self.n_expr isa ASelfExpr
-		msignature = v.resolve_signature_for(msignature, recvtype, for_self)
+		var callsite = v.get_method(self, recvtype, name, for_self)
+
+		if callsite == null then return
+		self.callsite = callsite
 
 		var args = compute_raw_arguments
 		self.raw_arguments = args
 
-		v.check_signature(self, args, name, msignature)
+		callsite.check_signature(v, args)
 
-		var readtype = msignature.return_mtype
+		var readtype = callsite.msignature.return_mtype
 		if readtype == null then
 			v.error(self, "Error: {name} is not a function")
 			return
 		end
 
-		var wpropdef = v.get_method(self, recvtype, name + "=", self.n_expr isa ASelfExpr)
-		if wpropdef == null then return
-		var wmproperty = wpropdef.mproperty
-		self.write_mproperty = wmproperty
-		var wmsignature = wpropdef.msignature
-		if wmsignature == null then abort # Forward error
-		wmsignature = v.resolve_signature_for(wmsignature, recvtype, for_self)
+		var wcallsite = v.get_method(self, recvtype, name + "=", self.n_expr isa ASelfExpr)
+		if wcallsite == null then return
+		self.write_callsite = wcallsite
 
-		var wtype = self.resolve_reassignment(v, readtype, wmsignature.mparameters.last.mtype)
+		var wtype = self.resolve_reassignment(v, readtype, wcallsite.msignature.mparameters.last.mtype)
 		if wtype == null then return
 
 		args = args.to_a # duplicate so raw_arguments keeps only the getter args
 		args.add(self.n_value)
-		v.check_signature(self, args, name + "=", wmsignature)
+		wcallsite.check_signature(v, args)
 
 		self.is_typed = true
 	end
@@ -1329,6 +1428,10 @@ redef class ASuperExpr
 	# Note: if the super is a normal call-next-method, then this attribute is null
 	var mproperty: nullable MMethod
 
+	# The method to call if the super is in fact a 'super init call'
+	# Note: if the super is a normal call-next-method, then this attribute is null
+	var callsite: nullable CallSite
+
 	redef fun accept_typing(v)
 	do
 		var recvtype = v.nclassdef.mclassdef.bound_mtype
@@ -1345,20 +1448,19 @@ redef class ASuperExpr
 			end
 			v.error(self, "Error: No super method to call for {mproperty}.")
 			return
-		else if superprops.length > 1 then
-			v.modelbuilder.warning(self, "Warning: NOT YET IMPLEMENTED: Conflicting super method to call for {mproperty}: {superprops.join(", ")}.")
-			return
 		end
+		# FIXME: covariance of return type in linear extension?
 		var superprop = superprops.first
 		assert superprop isa MMethodDef
 
-		var msignature = superprop.msignature.as(not null)
-		msignature = v.resolve_signature_for(msignature, recvtype, true)
+		var msignature = v.resolve_signature_for(superprop, recvtype, true)
 		var args = self.n_args.to_a
 		if args.length > 0 then
 			v.check_signature(self, args, mproperty.name, msignature)
 		end
 		self.mtype = msignature.return_mtype
+		self.is_typed = true
+		v.mpropdef.has_supercall = true
 	end
 
 	private fun process_superinit(v: TypeVisitor)
@@ -1395,11 +1497,13 @@ redef class ASuperExpr
 		end
 		self.mproperty = superprop.mproperty
 
+		var msignature = v.resolve_signature_for(superprop, recvtype, true)
+		var callsite = new CallSite(self, recvtype, true, superprop.mproperty, superprop, msignature, false)
+		self.callsite = callsite
+
 		var args = self.n_args.to_a
-		var msignature = superprop.msignature.as(not null)
-		msignature = v.resolve_signature_for(msignature, recvtype, true)
 		if args.length > 0 then
-			v.check_signature(self, args, mproperty.name, msignature)
+			callsite.check_signature(v, args)
 		else
 			# TODO: Check signature
 		end
@@ -1411,8 +1515,11 @@ end
 ####
 
 redef class ANewExpr
+	# @depreciated use `callsite`
+	fun mproperty: nullable MMethod do return self.callsite.mproperty
+
 	# The constructor invoked by the new.
-	var mproperty: nullable MMethod
+	var callsite: nullable CallSite
 
 	redef fun accept_typing(v)
 	do
@@ -1428,6 +1535,14 @@ redef class ANewExpr
 				v.error(self, "Type error: cannot instantiate the formal type {recvtype}.")
 				return
 			end
+		else
+			if recvtype.mclass.kind == abstract_kind then
+				v.error(self, "Cannot instantiate abstract class {recvtype}.")
+				return
+			else if recvtype.mclass.kind == interface_kind then
+				v.error(self, "Cannot instantiate interface {recvtype}.")
+				return
+			end
 		end
 
 		var name: String
@@ -1437,21 +1552,18 @@ redef class ANewExpr
 		else
 			name = "init"
 		end
-		var propdef = v.get_method(self, recvtype, name, false)
-		if propdef == null then return
+		var callsite = v.get_method(self, recvtype, name, false)
+		if callsite == null then return
 
-		self.mproperty = propdef.mproperty
+		self.callsite = callsite
 
-		if not propdef.mproperty.is_init_for(recvtype.mclass) then
+		if not callsite.mproperty.is_init_for(recvtype.mclass) then
 			v.error(self, "Error: {name} is not a constructor.")
 			return
 		end
 
-		var msignature = propdef.msignature.as(not null)
-		msignature = v.resolve_signature_for(msignature, recvtype, false)
-
 		var args = n_args.to_a
-		v.check_signature(self, args, name, msignature)
+		callsite.check_signature(v, args)
 	end
 end
 
@@ -1544,50 +1656,6 @@ end
 
 ###
 
-redef class AClosureCallExpr
-	redef fun accept_typing(v)
-	do
-		var variable = self.variable
-		if variable == null then return # Skip error
-
-		var recvtype = v.nclassdef.mclassdef.bound_mtype
-		var msignature = variable.declared_type.as(MSignature)
-		msignature = v.resolve_signature_for(msignature, recvtype, false)
-
-		var args = n_args.to_a
-		v.check_signature(self, args, variable.name, msignature)
-
-		self.is_typed = true
-		self.mtype = msignature.return_mtype
-	end
-end
-
-redef class AClosureDef
-	var mclosure: nullable MParameter
-
-	private fun accept_typing(v: TypeVisitor, mparameter: MParameter)
-	do
-		var variables = self.variables
-		if variables == null then return
-
-		self.mclosure = mparameter
-		var msignature = mparameter.mtype.as(MSignature)
-
-		if msignature.arity != variables.length then
-			v.error(self, "Type error: closure {mparameter.name} expects {msignature.arity} parameters, {variables.length} given")
-			return
-		end
-
-		for i in [0..variables.length[ do
-			variables[i].declared_type = msignature.mparameters[i].mtype
-		end
-
-		v.visit_stmt(self.n_expr)
-	end
-end
-
-###
-
 redef class ADebugTypeExpr
 	redef fun accept_typing(v)
 	do
@@ -1600,5 +1668,6 @@ redef class ADebugTypeExpr
 			var umtype = v.anchor_to(mtype)
 			v.modelbuilder.warning(self, "Found type {expr} (-> {unsafe}), expected {mtype} (-> {umtype})")
 		end
+		self.is_typed = true
 	end
 end