redef class AVardeclExpr
	init init_avardeclexpr (
		n_kwvar: nullable TKwvar,
		n_id: nullable TId,
		n_type: nullable AType,
		n_assign: nullable TAssign,
		n_expr: nullable AExpr,
		n_annotations: nullable AAnnotations
	)
	do
		_n_kwvar = n_kwvar
		if n_kwvar != null then n_kwvar.parent = self
		_n_id = n_id.as(not null)
		n_id.parent = self
		_n_type = n_type
		if n_type != null then n_type.parent = self
		_n_assign = n_assign
		if n_assign != null then n_assign.parent = self
		_n_expr = n_expr
		if n_expr != null then n_expr.parent = self
		_n_annotations = n_annotations
		if n_annotations != null then n_annotations.parent = self
	end

	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
	do
		if _n_kwvar == old_child then
			n_kwvar = new_child.as(nullable TKwvar)
			return
		end
		if _n_id == old_child then
			n_id = new_child.as(TId)
			return
		end
		if _n_type == old_child then
			n_type = new_child.as(nullable AType)
			return
		end
		if _n_assign == old_child then
			n_assign = new_child.as(nullable TAssign)
			return
		end
		if _n_expr == old_child then
			n_expr = new_child.as(nullable AExpr)
			return
		end
		if _n_annotations == old_child then
			n_annotations = new_child.as(nullable AAnnotations)
			return
		end
	end

	redef fun n_kwvar=(node)
	do
		_n_kwvar = node
		if node != null then node.parent = self
	end
	redef fun n_id=(node)
	do
		_n_id = node
		node.parent = self
	end
	redef fun n_type=(node)
	do
		_n_type = node
		if node != null then node.parent = self
	end
	redef fun n_assign=(node)
	do
		_n_assign = node
		if node != null then node.parent = self
	end
	redef fun n_expr=(node)
	do
		_n_expr = node
		if node != null then node.parent = self
	end
	redef fun n_annotations=(node)
	do
		_n_annotations = node
		if node != null then node.parent = self
	end


	redef fun visit_all(v: Visitor)
	do
		v.enter_visit(_n_kwvar)
		v.enter_visit(_n_id)
		v.enter_visit(_n_type)
		v.enter_visit(_n_assign)
		v.enter_visit(_n_expr)
		v.enter_visit(_n_annotations)
	end
end

redef class AVardeclExpr
	# The variable associated with the variable declaration
	var variable: nullable Variable
	redef fun accept_scope_visitor(v)
	do
		super
		var nid = self.n_id
		var variable = new Variable(nid.text)
		v.register_variable(nid, variable)
		variable.warn_unread = true # wait for some read mark.
		self.variable = variable
	end
end

redef class AVardeclExpr
	redef fun accept_pretty_printer(v) do
		v.visit n_kwvar
		v.adds
		v.visit n_id

		if n_type != null then
			v.consume ":"
			v.adds
			v.visit n_type
		end

		if n_expr != null then
			v.adds
			v.consume "="
			v.adds
			v.visit n_expr
		end
	end

	redef fun is_inlinable do return true
end

redef class AVardeclExpr
	redef fun accept_reaching_defs(v) do
		super
		v.kill(variable.as(not null))
		v.gen(variable.as(not null), location)
	end
end

redef class AVardeclExpr
	redef fun accept_local_var_visitor(v)
	do
		super
		# The variable is unset only if there is no initial value.

		# Note: loops in initial value are not a problem
		# Example:
		#
		#     var foo = foo + 1 #-> Error during typing: "self.foo" unknown
		#
		#     var foo
		#     foo = foo + 1 #-> Error here because 'foo' is possibly unset
		if self.n_expr == null then
			v.mark_is_unset(self, self.variable)
		end
	end
end

redef class AVardeclExpr
	redef fun accept_typing(v)
	do
		var variable = self.variable
		if variable == null then return # Skip error

		var ntype = self.n_type
		var mtype: nullable MType
		if ntype == null then
			mtype = null
		else
			mtype = v.resolve_mtype(ntype)
			if mtype == null then return # Skip error
		end

		var nexpr = self.n_expr
		if nexpr != null then
			if mtype != null then
				var etype = v.visit_expr_subtype(nexpr, mtype)
				if etype == mtype then
					assert ntype != null
					v.modelbuilder.advice(ntype, "useless-type", "Warning: useless type definition for variable `{variable.name}`")
				end
			else
				mtype = v.visit_expr(nexpr)
				if mtype == null then return # Skip error
			end
		end

		var decltype = mtype
		if mtype == null or mtype isa MNullType then
			var objclass = v.get_mclass(self, "Object")
			if objclass == null then return # skip error
			decltype = objclass.mclass_type.as_nullable
			if mtype == null then mtype = decltype
		end

		variable.declared_type = decltype
		v.set_variable(self, variable, mtype)

		#debug("var {variable}: {mtype}")

		self.mtype = mtype
		self.is_typed = true
	end
end

redef class AVardeclExpr
	redef fun expr(v)
	do
		var ne = self.n_expr
		if ne != null then
			var i = v.expr(ne)
			if i == null then return null
			v.write_variable(self.variable.as(not null), i)
			return i
		end
		return null
	end
end

redef class AVardeclExpr
	redef fun generate_basic_blocks(ssa, old_block)
	do
		var decl = self.variable.as(not null)

		# Add the corresponding variable to the enclosing mpropdef
		ssa.propdef.variables.add(decl)

		decl.original_variable = decl
		decl.assignment_blocks.add(old_block)
		old_block.variables.add(decl)

		if self.n_expr != null then
			self.variable.dep_exprs.add(self.n_expr.as(not null))
			old_block = self.n_expr.generate_basic_blocks(ssa, old_block)
		end

		return old_block
	end
end

redef class AVardeclExpr
	redef fun numbering(v, position)
	do
		# Attribute a position to this variable
		self.variable.as(not null).position = position
		position += 1

		# Recursively continue to numbering the variables
		position = v.numbering(self.n_expr, position)

		# `position` is the next available position in the environment
		return position
	end
end

redef class AVardeclExpr
	# `var x = y` is replaced with `x = y`
	#
	# Declarations are only useful for scope rules
	# Once names are associated with real objects, ther declaration become useless
	# Therefore, if there is no initial value, then just ignore it
	# Else, replace it with a simple assignment
	redef fun accept_transform_visitor(v)
	do
		var nexpr = n_expr
		if nexpr == null then
			# do nothing
			# note: not detached because the collection is currently under iteration
		else
			var nvar = v.builder.make_var_assign(self.variable.as(not null), nexpr)
			replace_with(nvar)
		end
	end
end

redef class AVardeclExpr
	redef fun stmt(v)
	do
		var variable = self.variable.as(not null)
		var ne = self.n_expr
		if ne != null then
			var i = v.expr(ne, variable.declared_type)
			v.assign(v.variable(variable), i)
		end
	end
end

redef class AVardeclExpr
	redef fun decorate_tag(v, res, token)
	do
		if token != n_id then return null
		var variable = self.variable
		if variable == null then return null
		res.add_class("nc_v")
		return variable.infobox(v)
	end
end

redef class AVardeclExpr
	redef fun stmt(v) do
		var variable = self.variable.as(not null)
		var ne = self.n_expr
		var decl = v.variable(variable)
		if ne != null then
			var i = v.expr(ne, variable.declared_type)
			v.assign(decl, i)
		end
	end
end