redef class AAnnotation
	init init_aannotation (
		n_doc: nullable ADoc,
		n_kwredef: nullable TKwredef,
		n_visibility: nullable AVisibility,
		n_atid: nullable AAtid,
		n_opar: nullable TOpar,
		n_args: Collection[Object], # Should be Collection[AExpr]
		n_cpar: nullable TCpar,
		n_annotations: nullable AAnnotations
	)
	do
		_n_doc = n_doc
		if n_doc != null then n_doc.parent = self
		_n_kwredef = n_kwredef
		if n_kwredef != null then n_kwredef.parent = self
		_n_visibility = n_visibility
		if n_visibility != null then n_visibility.parent = self
		_n_atid = n_atid.as(not null)
		n_atid.parent = self
		_n_opar = n_opar
		if n_opar != null then n_opar.parent = self
		self.n_args.unsafe_add_all(n_args)
		_n_cpar = n_cpar
		if n_cpar != null then n_cpar.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_doc == old_child then
			n_doc = new_child.as(nullable ADoc)
			return
		end
		if _n_kwredef == old_child then
			n_kwredef = new_child.as(nullable TKwredef)
			return
		end
		if _n_visibility == old_child then
			n_visibility = new_child.as(nullable AVisibility)
			return
		end
		if _n_atid == old_child then
			n_atid = new_child.as(AAtid)
			return
		end
		if _n_opar == old_child then
			n_opar = new_child.as(nullable TOpar)
			return
		end
		if n_args.replace_child(old_child, new_child) then return
		if _n_cpar == old_child then
			n_cpar = new_child.as(nullable TCpar)
			return
		end
		if _n_annotations == old_child then
			n_annotations = new_child.as(nullable AAnnotations)
			return
		end
	end

	redef fun n_doc=(node)
	do
		_n_doc = node
		if node != null then node.parent = self
	end
	redef fun n_kwredef=(node)
	do
		_n_kwredef = node
		if node != null then node.parent = self
	end
	redef fun n_visibility=(node)
	do
		_n_visibility = node
		if node != null then node.parent = self
	end
	redef fun n_atid=(node)
	do
		_n_atid = node
		node.parent = self
	end
	redef fun n_opar=(node)
	do
		_n_opar = node
		if node != null then node.parent = self
	end
	redef fun n_cpar=(node)
	do
		_n_cpar = 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_doc)
		v.enter_visit(_n_kwredef)
		v.enter_visit(_n_visibility)
		v.enter_visit(_n_atid)
		v.enter_visit(_n_opar)
		n_args.visit_all(v)
		v.enter_visit(_n_cpar)
		v.enter_visit(_n_annotations)
	end
end

redef class AAnnotation
	# Get the single argument of `self` as a `String`.
	# Raise error and return null on any inconsistency.
	fun arg_as_string(modelbuilder: ModelBuilder): nullable String
	do
		var args = n_args
		if args.length == 1 then
			var arg = args.first.as_string
			if arg != null then return arg
		end

		modelbuilder.error(self, "Syntax Error: `{name}` expects a single String as argument.")
		return null
	end

	# Get the single argument of `self` as an `Int`.
	# Raise error and return null on any inconsistency.
	fun arg_as_int(modelbuilder: ModelBuilder): nullable Int
	do
		var args = n_args
		if args.length == 1 then
			var arg = args.first.as_int
			if arg != null then return arg
		end

		modelbuilder.error(self, "Syntax Error: `{name}` expects a single Int as argument.")
		return null
	end

	# Get the single argument of `self` as an identifier.
	# Raise error and return null on any inconsistency.
	fun arg_as_id(modelbuilder: ModelBuilder): nullable String
	do
		var args = n_args
		if args.length == 1 then
			var arg = args.first.as_id
			if arg != null then return arg
		end

		modelbuilder.error(self, "Syntax Error: `{name}` expects a single identifier as argument.")
		return null
	end
end

redef class AAnnotation
	redef fun accept_pretty_printer(v) do
		if n_visibility != null and not n_visibility isa APublicVisibility then
			v.visit n_visibility
			v.adds
		end
		v.visit n_atid
		v.visit_args n_args
	end
end

redef class AAnnotation
	# Returns a version string (example: "1.5.6b42a7c") from an annotation `version(1, 5, git_revision)`.
	#
	# The user can enter as many fields as needed. The call to `git_revision` will be replaced by the short
	# revision number. If the working tree is dirty, it will append another field with "d" for dirty.
	private fun as_version(modelbuilder: ModelBuilder): String
	do
		var version_fields = new Array[Object]

		var args = n_args
		if args.length < 1 then
			modelbuilder.error(self, "Syntax Error: `{name}` expects at least one argument.")
			return ""
		else
			for arg in args do
				var value
				value = arg.as_int
				if value != null then
					version_fields.add value
					continue
				end

				value = arg.as_string
				if value != null then
					version_fields.add value
				end

				value = arg.as_id
				if value == "git_revision" then
					# Get Git short revision
					var proc = new ProcessReader("git", "rev-parse", "--short", "HEAD")
					proc.wait
					if proc.status != 0 then
						# Fallback if this is not a git repository or git bins are missing
						version_fields.add "0"
						modelbuilder.warning(self, "git_revision", "Warning: `git_revision` used outside of a git repository or git binaries not available")
						continue
					end

					var lines = proc.read_all
					var revision = lines.split("\n").first

					# Is it dirty?
					# If not, the return of `git diff --shortstat` is an empty line
					proc = new ProcessReader("git", "diff-index", "--quiet", "HEAD")
					proc.wait
					var dirty = proc.status != 0
					if dirty then revision += ".d"

					version_fields.add revision
					continue
				end

				var format_error = "Syntax Error: `{name}` expects its arguments to be of type Int or a call to `git_revision`."
				modelbuilder.error(self, format_error)
				return ""
			end
		end

		return version_fields.join(".")
	end

	# Parse all arguments as paths relative to the declaring module
	#
	# If no arguments are given, then use the parent directory of the module.
	private fun as_relative_paths(modelbuilder: ModelBuilder): Array[String]
	do
		var paths = new Array[String]

		var file = location.file
		if file == null then return paths

		var args = n_args
		if args.is_empty then
			paths.add file.filename.dirname
		else
			for arg in args do
				var val = arg.as_string
				if val != null then
					paths.add file.filename.dirname/val
				else modelbuilder.error(arg, "Syntax Error: `app_files` expects String literals as arguments.")
			end
		end

		return paths
	end
end

redef class AAnnotation

	redef fun accept_ast_validation(v)
	do
		# Do not enter in annotations
	end

	private init make(n_args : ANodes[AExpr])
	do
		_n_visibility = new APublicVisibility
		_n_args = n_args
	end
end

redef class AAnnotation

	# Returns the conditions of annotation parameters. If there are several parameters, the result is an `AAndExpr`
	# Example:
	# the contract `ensure(true, i == 10, f >= 1.0)`
	# return this condition `(true and i == 10 and f >= 1.0)`
	private fun construct_condition(v : ContractsVisitor): AExpr
	do
		var n_condition = n_args.first
		n_args.remove_at(0)
		for n_arg in n_args do n_condition = v.ast_builder.make_and(n_condition, n_arg)
		return n_condition
	end
end