# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2008 Jean Privat <jean@pryen.org>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Analysis property bodies, statements and expressions
package typing

import syntax_base

redef class MMSrcModule
	# Walk trough the module and type statments and expressions
	# Require than supermodules are processed
	meth do_typing(tc: ToolContext)
	do
		var tv = new TypingVisitor(tc, self)
		tv.visit(node)
	end
end

# Typing visitor
# * Associate local variables to nodes
# * Distinguish method call and local variable access
# * Resolve call and attribute access
# * Check type conformance
private class TypingVisitor
special AbsSyntaxVisitor
	redef meth 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

	# Type of the receiver
	readable writable attr _self_type: MMType

	# Block of the current method
	readable writable attr _top_block: PExpr

	# List of explicit invocation of constructors of super-classes
	readable writable attr _explicit_super_init_calls: Array[MMMethod]

	# Is a other constructor of the same class invoked
	readable writable attr _explicit_other_init_call: Bool

	init(tc, module) do super

	private meth get_default_constructor_for(n: PNode, c: MMLocalClass, prop: MMMethod): MMMethod
	do
		var v = self
		#var prop = v.local_property
		#assert prop isa MMMethod
		var candidates = new Array[MMMethod]
		var false_candidates = new Array[MMMethod]
		var parity = prop.signature.arity
		for g in c.global_properties do
			if not g.is_init then continue
			if g.intro.local_class != c then continue
			var gp = c[g]
			assert gp isa MMMethod
			var garity = g.intro.signature.arity
			if prop != null and g.intro.name == prop.name then
				if garity == 0 or garity == parity then
					return gp
				else
					false_candidates.add(gp)
				end
			else if garity == 0 then
				candidates.add(gp)
				false_candidates.add(gp)
			else
				false_candidates.add(gp)
			end
		end
		if candidates.length == 1 then
			return candidates.first
		else if false_candidates.is_empty then
			v.warning(n, "Fatal error: there is no available constrctor in {c}.")
			return null
			#abort
		else
			v.error(n, "Error: Conflicting default constructor to call for {c}: {false_candidates.join(", ")}.")
			return null
		end
	end
end

# Associate symbols to variable and variables to type
# Can be nested
private class VariableContext
	# Look for the variable from its name
	# Return null if nothing found
	meth [](s: Symbol): Variable
	do
		if _dico.has_key(s) then
			return _dico[s]
		else
			return null
		end
	end

	# Register a new variable with its name
	meth add(v: Variable)
	do
		_dico[v.name] = v
	end


	# The effective static type of a given variable
	# May be different from the declaration static type
	meth stype(v: Variable): MMType
	do
		return v.stype
	end

	# Variables by name (in the current context only)
	attr _dico: Map[Symbol, Variable]

	# Build a new VariableContext
	meth sub: VariableContext
	do
		return new SubVariableContext.with(self, null, null)
	end

	# Build a nested VariableContext with new variable information
	meth sub_with(v: Variable, t: MMType): VariableContext
	do
		return new SubVariableContext.with(self, v, t)
	end

	init
	do 
		_dico = new HashMap[Symbol, Variable]
	end
end

private class SubVariableContext
special VariableContext
	readable attr _prev: VariableContext
	attr _variable: Variable
	attr _var_type: MMType

	redef meth [](s)
	do
		if _dico.has_key(s) then
			return _dico[s]
		else
			return prev[s]
		end
	end

	redef meth stype(v)
	do
		if _variable == v then
			return _var_type
		end
		return prev.stype(v)
	end

	init with(p: VariableContext, v: Variable, t: MMType)
	do
		init
		_prev = p
		_variable = v
		_var_type =t
	end
end


###############################################################################

redef class PNode
	private meth accept_typing(v: TypingVisitor) 
	do
		accept_abs_syntax_visitor(v)
		after_typing(v)
	end
	private meth after_typing(v: TypingVisitor) do end
end

redef class PClassdef
	redef meth accept_typing(v)
	do
		v.self_type = local_class.get_type
		super
	end
end

redef class AAttrPropdef
	redef meth accept_typing(v)
	do
		super
		if n_expr != null then
			v.check_conform(n_expr, n_expr.stype, prop.signature.return_type)
		end
	end
end

redef class AMethPropdef
	redef meth accept_typing(v)
	do
		v.variable_ctx = new VariableContext
		super
	end
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)
	do
		v.top_block = n_block
		v.explicit_super_init_calls = explicit_super_init_calls
		v.explicit_other_init_call = false
		super
		if v.explicit_other_init_call then
			# TODO: something?
		else 
			var i = 0
			var l = explicit_super_init_calls.length
			var cur_m: MMMethod
			var cur_c: MMLocalClass
			if i < l then
				cur_m = explicit_super_init_calls[i]
				cur_c = cur_m.global.intro.local_class
			end
			var j = 0
			while j < v.local_class.cshe.direct_greaters.length do
				var c = v.local_class.cshe.direct_greaters[j]
				if cur_c != null and c.cshe <= cur_c then
					if c == cur_c then j += 1
					super_init_calls.add(cur_m)
					i += 1
					if i < l then
						cur_m = explicit_super_init_calls[i]
						cur_c = cur_m.global.intro.local_class
					else
						cur_m = null
						cur_c = null
					end
				else
					var p = v.get_default_constructor_for(self, c, method)
					if p != null then
						super_init_calls.add(p)
					end
					j += 1
				end
			end
		end
	end
end

redef class PParam
	redef meth after_typing(v)
	do
		if v.variable_ctx != null then
			v.variable_ctx.add(variable)
		end
	end
end

redef class PType
	readable attr _stype: MMType
	redef meth after_typing(v)
	do
		_stype = get_stype(v)
	end
end

redef class PExpr
	redef readable attr _stype: MMType
	
	# Is the expression the implicit receiver
	meth is_implicit_self: Bool do return false

	# Is the expression the current receiver (implicit or explicit)
	meth is_self: Bool do return false

	# Is the expression a variable access
	meth is_variable: Bool do return false

	# The variable type information if current boolean expression is true
	readable private attr _if_true_variable_ctx: VariableContext
end

redef class AVardeclExpr
	# Assiociated local variable
        readable attr _variable: Variable

	redef meth after_typing(v)
	do
		var va = new Variable(n_id.to_symbol, self)
		_variable = va
		v.variable_ctx.add(va)

		if n_type != null then
			va.stype = n_type.stype
			if n_expr != null then
				v.check_conform(self, n_expr.stype, va.stype)
			end
		else
			va.stype = n_expr.stype
		end
	end
end

redef class ABlockExpr
	redef meth accept_typing(v)
	do
		var old_var_ctx = v.variable_ctx
		v.variable_ctx = v.variable_ctx.sub

		super

		v.variable_ctx = old_var_ctx
	end
end

redef class AReturnExpr
	redef meth after_typing(v)
	do
		var t = v.local_property.signature.return_type
		if n_expr == null and t != null then
			v.error(self, "Error: Return without value in a function.")
		else if n_expr != 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(self, n_expr.stype, t)
		end
	end
end

redef class AIfExpr
	redef meth accept_typing(v)
	do
		var old_var_ctx = v.variable_ctx
		v.visit(n_expr)
		v.check_conform(self, n_expr.stype, v.type_bool)

		if n_expr.if_true_variable_ctx != null then
			v.variable_ctx = n_expr.if_true_variable_ctx
		end

		v.visit(n_then)
		# Restore variable ctx
		v.variable_ctx = old_var_ctx

		if n_else != null then
			v.visit(n_else)
			v.variable_ctx = old_var_ctx
		end
	end
end

redef class AWhileExpr
	redef meth after_typing(v)
	do
		v.check_conform(self, n_expr.stype, v.type_bool)
	end
end

redef class AForExpr
	redef meth after_typing(v)
	do
		# pop context created in AForVardeclExpr
		var varctx = v.variable_ctx 
		assert varctx isa SubVariableContext
		v.variable_ctx = varctx.prev
	end
end

redef class AForVardeclExpr
	# Associated automatic local variable
	readable attr _variable: Variable

	redef meth after_typing(v)
	do
		v.variable_ctx = v.variable_ctx.sub
		var variable = new Variable(n_id.to_symbol, self)
		_variable = variable
		v.variable_ctx.add(variable)

		var expr_type = n_expr.stype
		if not v.check_conform(self, expr_type, v.type_collection) then
			return
		end
		var prop = expr_type.select_method(once ("iterator".to_symbol))
		if prop == null then
			v.error(self, "Error: Collection MUST have an iterate method")
			return
		end
		var iter_type = prop.signature.return_type
		var prop2 = iter_type.select_method(once ("item".to_symbol))
		if prop2 == null then
			v.error(self, "Error: {iter_type} MUST have an item method")
			return
		end
		var t = prop2.signature.return_type
		if not n_expr.is_self then t = t.not_for_self
		variable.stype = t
	end
end

redef class AAssertExpr
	redef meth after_typing(v)
	do
		v.check_conform(self, n_expr.stype, v.type_bool)
		if n_expr.if_true_variable_ctx != null then v.variable_ctx = n_expr.if_true_variable_ctx
	end
end

redef class AVarFormExpr
	# Associated local variable
        readable writable attr _variable: Variable 
end

redef class AVarExpr
	redef meth is_variable do return true

	redef meth after_typing(v)
	do
		_stype = v.variable_ctx.stype(variable)
	end
end

redef class AVarAssignExpr
	redef meth after_typing(v)
	do
		var t = v.variable_ctx.stype(variable)
		v.check_conform(self, n_value.stype, t)
	end
end

redef class AReassignFormExpr
	# Compute and check method used through the reassigment operator 
	private meth do_lvalue_typing(v: TypingVisitor, type_lvalue: MMType)
	do
		if type_lvalue == null then
			return
		end
		var name = n_assign_op.method_name
		var prop = type_lvalue.select_method(name)
		if prop == null then
			v.error(self, "Error: Method '{name}' doesn't exists in {type_lvalue}.")
			return
		end
		prop.global.check_visibility(v, self, v.module, false)
		var psig = prop.signature
		_assign_method = prop
		v.check_conform(self, n_value.stype, psig[0].not_for_self)
		v.check_conform(self, psig.return_type.not_for_self, n_value.stype)
	end

	# Method used through the reassigment operator (once computed)
	readable attr _assign_method: MMMethod
end

redef class PAssignOp
	meth method_name: Symbol is abstract
end
redef class APlusAssignOp
	redef meth method_name do return once "+".to_symbol
end
redef class AMinusAssignOp
	redef meth method_name do return once "-".to_symbol
end

redef class AVarReassignExpr
	redef meth after_typing(v)
	do
		var t = v.variable_ctx.stype(variable)
		do_lvalue_typing(v, t)
	end
end

redef class ASelfExpr
	redef meth after_typing(v)
	do
		assert v.self_type != null
		_stype = v.self_type
	end

        redef meth is_self do return true
end

redef class AImplicitSelfExpr
        redef meth is_implicit_self do return true
end

redef class AIfexprExpr
	redef meth accept_typing(v)
	do
		var old_var_ctx = v.variable_ctx

		v.visit(n_expr)
		if n_expr.if_true_variable_ctx != null then v.variable_ctx = n_expr.if_true_variable_ctx
		v.visit(n_then)
		v.variable_ctx = old_var_ctx
		v.visit(n_else)

		v.check_conform(self, n_expr.stype, v.type_bool)

		var t = n_then.stype
		var te = n_else.stype
		if t < te then
			t = te
		else if not te < t then
			v.error(self, "Type error: {te} is not a subtype of {t}.")
			return
		end
		
		_stype = t
	end
end

redef class ABoolExpr
	redef meth after_typing(v)
	do
		_stype = v.type_bool
	end
end

redef class AOrExpr
	redef meth after_typing(v)
	do
		v.check_conform(self, n_expr.stype, v.type_bool)
		v.check_conform(self, n_expr2.stype, v.type_bool)
		_stype = v.type_bool
	end
end

redef class AAndExpr
	redef meth accept_typing(v)
	do
		var old_var_ctx = v.variable_ctx

		v.visit(n_expr)
		if n_expr.if_true_variable_ctx != null then v.variable_ctx = n_expr.if_true_variable_ctx

		v.visit(n_expr2)
		if n_expr2.if_true_variable_ctx != null then 
			_if_true_variable_ctx = n_expr2.if_true_variable_ctx
		else
			_if_true_variable_ctx = v.variable_ctx
		end

		v.variable_ctx = old_var_ctx

		v.check_conform(self, n_expr.stype, v.type_bool)
		v.check_conform(self, n_expr2.stype, v.type_bool)
		_stype = v.type_bool
	end
end

redef class ANotExpr
	redef meth after_typing(v)
	do
		v.check_conform(self, n_expr.stype, v.type_bool)
		_stype = v.type_bool
	end
end

redef class AIntExpr
	redef meth after_typing(v)
	do
		_stype = v.type_int

	end
end

redef class AFloatExpr
	redef meth after_typing(v)
	do
		_stype = v.type_float
	end
end

redef class ACharExpr
	redef meth after_typing(v)
	do
		_stype = v.type_char
	end
end

redef class AStringFormExpr
	redef meth after_typing(v)
	do
		_stype = v.type_string
	end
end

redef class ASuperstringExpr
	redef meth after_typing(v)
	do
		_stype = v.type_string
	end
end

redef class ANullExpr
	redef meth after_typing(v)
	do
		_stype = v.type_none
	end
end

redef class AArrayExpr
	private meth stype=(t: MMType) do _stype = t

	redef meth after_typing(v)
	do
		var stype: MMType
		for n in n_exprs do
			var ntype = n.stype
			if stype == null or (ntype != null and stype < ntype) then
				stype = ntype
			end
		end
		for n in n_exprs do
			v.check_conform(self, n.stype, stype)
		end
		_stype = v.type_array(stype)
	end
end

redef class ARangeExpr
	redef meth after_typing(v)
	do
		var ntype = n_expr.stype
		var ntype2 = n_expr2.stype
		if ntype == null or ntype == null then
			return
		end
		if ntype < ntype2 then
			ntype = ntype2
		else if not ntype2 < ntype then
			v.error(self, "Type error: {ntype} incompatible with {ntype2}.")
			return
		end
		var dtype = v.type_discrete
		v.check_conform(self, ntype, dtype)
		_stype = v.type_range(ntype)
	end
end

redef class ASuperExpr
special ASuperInitCall
	# readable attr _prop: MMSrcMethod
	readable attr _init_in_superclass: MMMethod
	redef meth after_typing(v)
	do
		var precs: Array[MMLocalProperty] = v.local_property.cprhe.direct_greaters
		if not precs.is_empty then
			v.local_property.need_super = true
		else if v.local_property.global.is_init then
			var base_precs = v.local_class.super_methods_named(v.local_property.name)
			for p in base_precs do
				if not p.global.is_init then
					v.error(self, "Error: {p.local_class}::{p} is not a constructor.")
				else
					precs.add(v.self_type.select_property(p.global))
				end
			end
			if precs.is_empty then
				v.error(self, "Error: No contructor named {v.local_property.name} in superclasses.")
				return
			else if precs.length > 1 then
				v.error(self, "Error: Conflicting contructors named {v.local_property.name} in superclasses: {precs.join(", ")}.")
				return
			end
			var p = base_precs.first
			assert p isa MMMethod
			_init_in_superclass = p
			register_super_init_call(v, p)
			if n_args.length > 0 then
				_arguments = process_signature(v, p, true, n_args.to_a)
			end
		else
			v.error(self, "Error: No super method to call for {v.local_property}.")
			return
		end

		if precs.first.signature.return_type != null then
			var stypes = new Array[MMType]
			var stype: MMType
			for prop in precs do
				assert prop isa MMMethod
				var t = prop.signature.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)
			end
			_stype = stype
		end
		var p = v.local_property
		assert p isa MMSrcMethod
		_prop = p
	end
end

redef class AAttrFormExpr
	# Attribute accessed
	readable attr _prop: MMAttribute

	# Compute the attribute accessed
	private meth do_typing(v: TypingVisitor)
	do
		var type_recv = n_expr.stype
		if type_recv == null then
			return
		end
		var name = n_id.to_symbol
		var prop = type_recv.select_attribute(name)
		if prop == null then
			v.error(self, "Error: Attribute {name} doesn't exists in {type_recv}.")
			return
		else 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}")
		end
		_prop = prop
	end
end

redef class AAttrExpr
	redef meth after_typing(v)
	do
		do_typing(v)
		if prop == null then
			return
		end
		var attr_type = prop.signature.return_type
		if not n_expr.is_self then attr_type = attr_type.not_for_self
		_stype = attr_type
	end
end

redef class AAttrAssignExpr
	redef meth after_typing(v)
	do
		do_typing(v)
		if prop == null then
			return
		end
		var attr_type = prop.signature.return_type
		if not n_expr.is_self then attr_type = attr_type.not_for_self
		v.check_conform(self, n_value.stype, attr_type)
	end
end

redef class AAttrReassignExpr
	redef meth after_typing(v)
	do
		do_typing(v)
		if prop == null then
			return
		end
		var attr_type = prop.signature.return_type
		if not n_expr.is_self then attr_type = attr_type.not_for_self
		do_lvalue_typing(v, attr_type)
	end
end

class AAbsSendExpr
special PExpr
	# 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])
	do
		var prop = get_property(v, type_recv, is_implicit_self, name)
		if prop == null then return
		var args = process_signature(v, prop, recv_is_self, raw_args)
		if args == null then return
		_prop = prop
		_arguments = args
	end

	private meth get_property(v: TypingVisitor, type_recv: MMType, is_implicit_self: Bool, name: Symbol): MMMethod
	do
		if type_recv == null then return null
		var prop = type_recv.select_method(name)
		if prop == null and v.local_property.global.is_init then
			var props = type_recv.local_class.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.select_property(props.first.global)
				assert p isa MMMethod
				prop = p
			end

		end
		if prop == null then
			if is_implicit_self then
				v.error(self, "Error: Method or variable '{name}' unknown in {type_recv}.")
			else
				v.error(self, "Error: Method '{name}' doesn't exists in {type_recv}.")
			end
			return null
		end
		return prop
	end

	private meth process_signature(v: TypingVisitor, prop: MMMethod, recv_is_self: Bool, raw_args: Array[PExpr]): Array[PExpr]
	do
		prop.global.check_visibility(v, self, v.module, recv_is_self)
		var psig = prop.signature
		var par_vararg = psig.vararg_rank
		var par_arity = psig.arity
		var raw_arity: Int
		if raw_args == null then raw_arity = 0 else raw_arity = raw_args.length
		if par_arity > raw_arity or (par_arity != raw_arity and par_vararg == -1) then
			v.error(self, "Error: Method '{prop}' arity missmatch.")
			return null
		end
		var arg_idx = 0
		var args = new Array[PExpr]
		for par_idx in [0..par_arity[ do
			var a: PExpr
			var par_type = psig[par_idx]
			if not recv_is_self then par_type = par_type.not_for_self
			if par_idx == par_vararg then
				var star = new Array[PExpr]
				for i in [0..(raw_arity-par_arity)] do
					a = raw_args[arg_idx]
					v.check_conform(self, a.stype, par_type)
					star.add(a)
					arg_idx = arg_idx + 1
				end
				var aa = new AArrayExpr.init_aarrayexpr(star)
				aa.stype = v.type_array(par_type)
				a = aa
			else
				a = raw_args[arg_idx]
				v.check_conform(self, a.stype, par_type)
				arg_idx = arg_idx + 1
			end
			args.add(a)
		end
		return args
	end

	# The invoked method (once computed)
	readable attr _prop: MMMethod

	# The real arguments used (after star transformation) (once computed)
	readable attr _arguments: Array[PExpr]
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)
	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
		if not v.explicit_super_init_calls.is_empty then
			prev_class = v.explicit_super_init_calls.last.global.intro.local_class
		end
		var order = v.local_class.cshe.reverse_linear_extension
		if cla == v.local_class then
			v.explicit_other_init_call = true
		else if not order.has(cla) then
			v.error(self, "Error: Constructor of class {cla} must be one in {order.join(", ")}.")
		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
				else if c == cla then
					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)
					break
				end
			end
		end
	end

end

redef class ANewExpr
special AAbsSendExpr
	redef meth after_typing(v)
	do
		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
		end
		var name: Symbol
		if n_id == null then
			name = once "init".to_symbol
		else
			name = n_id.to_symbol
		end

		do_typing(v, t, false, false, name, n_args.to_a)
		if not prop.global.is_init then
			v.error(self, "Error: {prop} is not a constructor.")
		end
		_stype = t
	end
end


redef class ASendExpr
special ASuperInitCall
	# Name of the invoked property
	meth name: Symbol is abstract 

	# Raw arguments used (withour star transformation)
	meth raw_arguments: Array[PExpr] is abstract

	redef meth after_typing(v)
	do
		do_all_typing(v)
	end

	private meth do_all_typing(v: TypingVisitor)
	do
		do_typing(v, n_expr.stype, n_expr.is_implicit_self, n_expr.is_self, name, raw_arguments)
		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.")
			else if not n_expr.is_self then
				v.error(self, "Error: constructor {prop} is not invoken on 'self'.")
			else
				register_super_init_call(v, prop)
			end
		end
		var t = prop.signature.return_type
		if t != null and not n_expr.is_self then t = t.not_for_self
		_stype = t
	end
end

class ASendReassignExpr
special ASendExpr
special AReassignFormExpr
	readable attr _read_prop: MMMethod
	redef meth do_all_typing(v)
	do
		var raw_args = raw_arguments
		do_typing(v, n_expr.stype, n_expr.is_implicit_self, n_expr.is_self, name, raw_args)
		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.")
			else if not n_expr.is_self then
				v.error(self, "Error: constructor {prop} is not invoken on 'self'.")
			end
		end
		var t = prop.signature.return_type
		if not n_expr.is_self then t = t.not_for_self

		do_lvalue_typing(v, t)

		_read_prop = prop
		var old_args = arguments
		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)
		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.")
			else if not n_expr.is_self then
				v.error(self, "Error: constructor {prop} is not invoken on 'self'.")
			end
		end

		_arguments = old_args # FIXME: What if star parameters do not match betwen the two methods?
	end
end

redef class ABinopExpr
	redef meth raw_arguments do return [n_expr2]
end
redef class AEqExpr
	redef meth name do return once "==".to_symbol
end
redef class ANeExpr
	redef meth name do return once "!=".to_symbol
end
redef class ALtExpr
	redef meth name do return once "<".to_symbol
end
redef class ALeExpr
	redef meth name do return once "<=".to_symbol
end
redef class AGtExpr
	redef meth name do return once ">".to_symbol
end
redef class AGeExpr
	redef meth name do return once ">=".to_symbol
end
redef class APlusExpr
	redef meth name do return once "+".to_symbol
end
redef class AMinusExpr
	redef meth name do return once "-".to_symbol
end
redef class AStarshipExpr
	redef meth name do return once "<=>".to_symbol
end
redef class AStarExpr
	redef meth name do return once "*".to_symbol
end
redef class ASlashExpr
	redef meth name do return once "/".to_symbol
end
redef class APercentExpr
	redef meth 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
end

redef class ACallFormExpr
	redef meth after_typing(v)
	do
		if n_expr.is_implicit_self then
			var name = n_id.to_symbol
			var variable = v.variable_ctx[name]
			if variable != null then
				if not n_args.is_empty then
					v.error(self, "Error: {name} is variable, not a function.")
				end
				var vform = variable_create(variable)
				vform.variable = variable
				replace_with(vform)
				vform.after_typing(v)
				return
			end
		end
		super
	end

	# Create a variable acces corresponding to the call form
	meth variable_create(variable: Variable): AVarFormExpr is abstract
end

redef class ACallExpr
	redef meth 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
end

redef class ACallAssignExpr
	redef meth 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
		var res = n_args.to_a
		res.add(n_value)
		return res
	end
end

redef class ACallReassignExpr
special ASendReassignExpr
	redef meth 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
end

redef class ABraExpr
	redef meth name do return once "[]".to_symbol
	redef meth 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
		var res = n_args.to_a
		res.add(n_value)
		return res
	end
end

redef class ABraReassignExpr
special ASendReassignExpr
	redef meth name do return once "[]".to_symbol
	redef meth 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
end

redef class AIsaExpr
	redef meth after_typing(v)
	do
		if n_expr.is_variable then
			var n = n_expr
			assert n isa AVarExpr
			_if_true_variable_ctx = v.variable_ctx.sub_with(n.variable, n_type.stype)
		end
		_stype = v.type_bool
	end
end

redef class AProxyExpr
	redef meth after_typing(v)
	do
		_stype = n_expr.stype
	end
end