redef class AArrayExpr
	init init_aarrayexpr (
		n_obra: nullable TObra,
		n_exprs: Collection[Object], # Should be Collection[AExpr]
		n_type: nullable AType,
		n_cbra: nullable TCbra,
		n_annotations: nullable AAnnotations
	)
	do
		_n_obra = n_obra.as(not null)
		n_obra.parent = self
		self.n_exprs.unsafe_add_all(n_exprs)
		_n_type = n_type
		if n_type != null then n_type.parent = self
		_n_cbra = n_cbra.as(not null)
		n_cbra.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_obra == old_child then
			n_obra = new_child.as(TObra)
			return
		end
		if n_exprs.replace_child(old_child, new_child) then return
		if _n_type == old_child then
			n_type = new_child.as(nullable AType)
			return
		end
		if _n_cbra == old_child then
			n_cbra = new_child.as(TCbra)
			return
		end
		if _n_annotations == old_child then
			n_annotations = new_child.as(nullable AAnnotations)
			return
		end
	end

	redef fun n_obra=(node)
	do
		_n_obra = 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_cbra=(node)
	do
		_n_cbra = node
		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_obra)
		n_exprs.visit_all(v)
		v.enter_visit(_n_type)
		v.enter_visit(_n_cbra)
		v.enter_visit(_n_annotations)
	end
end

redef class AArrayExpr
	redef fun accept_pretty_printer(v) do
		v.consume "["
		v.visit_list n_exprs
		if n_type != null then
			v.consume ":"
			v.adds
			v.visit n_type
		end
		v.consume "]"
	end
end

redef class AArrayExpr
	# The `with_capacity` method on Array
	var with_capacity_callsite: nullable CallSite

	# The `push` method on arrays
	var push_callsite: nullable CallSite

	# The element of each type
	var element_mtype: nullable MType

	# Set that `self` is a part of comprehension array `na`
	# If `self` is a `for`, or a `if`, then `set_comprehension` is recursively applied.
	private fun set_comprehension(n: nullable AExpr)
	do
		if n == null then
			return
		else if n isa AForExpr then
			set_comprehension(n.n_block)
		else if n isa AIfExpr then
			set_comprehension(n.n_then)
			set_comprehension(n.n_else)
		else
			# is a leave
			n.comprehension = self
		end
	end
	redef fun accept_typing(v)
	do
		var mtype: nullable MType = null
		var ntype = self.n_type
		if ntype != null then
			mtype = v.resolve_mtype(ntype)
			if mtype == null then return # Skip error
		end
		var mtypes = new Array[nullable MType]
		var useless = false
		for e in self.n_exprs do
			var t = v.visit_expr(e)
			if t == null then
				return # Skip error
			end
			set_comprehension(e)
			if mtype != null then
				if v.check_subtype(e, t, mtype, false) == null then return # Forward error
				if t == mtype then useless = true
			else
				mtypes.add(t)
			end
		end
		if mtype == null then
			# Ensure monotony for type adaptation on loops
			if self.element_mtype != null then mtypes.add self.element_mtype
			mtype = v.merge_types(self, mtypes)
		end
		if mtype == null or mtype isa MNullType then
			v.error(self, "Type Error: ambiguous array type {mtypes.join(" ")}")
			return
		end
		if useless then
			assert ntype != null
			v.display_warning(ntype, "useless-type", "Warning: useless type declaration `{mtype}` in literal Array since it can be inferred from the elements type.")
		end

		self.element_mtype = mtype

		var mclass = v.get_mclass(self, "Array")
		if mclass == null then return # Forward error
		var array_mtype = mclass.get_mtype([mtype])

		with_capacity_callsite = v.build_callsite_by_name(self, array_mtype, "with_capacity", false)
		push_callsite = v.build_callsite_by_name(self, array_mtype, "push", false)

		self.mtype = array_mtype
	end
end

redef class AArrayExpr
	redef fun accept_rapid_type_visitor(v)
	do
		var mtype = self.mtype.as(MClassType)
		v.add_type(mtype)
		var native = v.analysis.mainmodule.native_array_type(mtype.arguments.first)
		v.add_type(native)
		mtype = v.cleanup_type(mtype).as(not null)
		var prop = v.get_method(mtype, "with_native")
		v.add_monomorphic_send(mtype, prop)
		v.add_callsite(with_capacity_callsite)
		v.add_callsite(push_callsite)
	end
end

redef class AArrayExpr
	redef fun expr(v)
	do
		var val = new Array[Instance]
		var old_comprehension = v.frame.comprehension
		v.frame.comprehension = val
		for nexpr in self.n_exprs do
			if nexpr isa AForExpr then
				v.stmt(nexpr)
			else
				var i = v.expr(nexpr)
				if i == null then return null
				val.add(i)
			end
		end
		v.frame.comprehension = old_comprehension
		var mtype = v.unanchor_type(self.mtype.as(not null)).as(MClassType)
		var elttype = mtype.arguments.first
		return v.array_instance(val, elttype)
	end
end

redef class AArrayExpr
	redef fun generate_basic_blocks(ssa, old_block)
	do
		for nexpr in self.n_exprs do
			old_block = nexpr.generate_basic_blocks(ssa, old_block)
		end

		return old_block
	end
end

redef class AArrayExpr
	redef fun numbering(v, position)
	do
		for nexpr in self.n_exprs do
			position = v.numbering(nexpr, position)
		end
		return position
	end
end

redef class AArrayExpr
	redef fun expr(v)
	do
		var mtype = self.element_mtype.as(not null)
		var array = new Array[RuntimeVariable]
		var res = v.array_instance(array, mtype)

		var old_comprehension = v.frame.comprehension
		v.frame.comprehension = res
		for nexpr in self.n_exprs do
			v.stmt(nexpr)
		end
		v.frame.comprehension = old_comprehension

		return res
	end
end

redef class AArrayExpr
	# `[x,y]` is replaced with
	#
	# ~~~nitish
	# var t = new Array[X].with_capacity(2)
	# t.add(x)
	# t.add(y)
	# t
	# ~~~
	redef fun full_transform_visitor(v)
	do
		if is_broken then return # Skip broken

		var nblock = v.builder.make_block

		var nnew = v.builder.make_new(with_capacity_callsite.as(not null), [v.builder.make_int(n_exprs.length)])
		self.nnew = nnew

		nblock.add nnew

		super

		for nexpr in self.n_exprs do
			nblock.add nexpr
		end
		var nres = nnew.make_var_read
		nblock.add nres

		replace_with(nblock)
	end

	private var nnew: ANewExpr is noinit
end