# 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.

# Common syntax structures for syntax analysis of NIT AST.
package syntax_base

import parser
import mmloader

# Concrete NIT source module
class MMSrcModule
	super MMModule
	# A source module can locate AST nodes of related MM entities
	# Once a source module AST is no more needed, _nodes is set to null
	# See ToolContext::keep_ast property in syntax.nit for details
	var _nodes: nullable HashMap[Object, nullable ANode] = new HashMap[Object, nullable ANode]

	# Release the AST
	fun clear_ast do _nodes = null

	# The related AST node
	fun node: AModule do return nodes(self).as(AModule)

	# Concrete NIT source local classs by name
	readable var _src_local_classes: Map[Symbol, MMSrcLocalClass]

	init(c: MMContext, source: AModule, dir: MMDirectory, name: Symbol, loc: Location)
	do
		super(name, dir, c, loc)
		nodes(self) = source
		_src_local_classes = new HashMap[Symbol, MMSrcLocalClass]
	end

	redef fun nodes(o: Object): nullable ANode
	do
		if _nodes != null and _nodes.has_key(o) then return _nodes[o] else return null
	end
	redef fun nodes=(o: Object, n: nullable ANode)
	do
		assert not _nodes.has_key(o)
		_nodes[o] = n
	end
end

redef class MMModule
	# The AST node of some entity
	private fun nodes(o: Object): nullable ANode do return null
	# The AST node of some entity
	private fun nodes=(o: Object, n: nullable ANode) do abort
end

redef class MMGlobalClass
	# Check that a module can access a class
	fun check_visibility(v: AbsSyntaxVisitor, n: ANode, cm: MMSrcModule): Bool do
		var pm = intro.mmmodule
		assert pm isa MMSrcModule
		var vpm = cm.visibility_for(pm)
		if vpm == 3 then
			return true
		else if vpm == 0 then
			v.error(n, "Visibility error: Class {self} comes from the hidden module {cm}.") # TODO: should not occur
			return false
		else if visibility_level >= 3 then
			v.error(n, "Visibility error: Class {self} is private.")
			return false
		end
		return true
	end
end

# Concrete NIT source local classes
class MMSrcLocalClass
	super MMConcreteClass
	# The first related AST node (if any)
	fun node: nullable AClassdef do return mmmodule.nodes(self).as(nullable AClassdef)

	# Concrete NIT source generic formal parameter by name
	readable var _formal_dict: Map[Symbol, MMTypeFormalParameter] = new HashMap[Symbol, MMTypeFormalParameter]

	# Concrete NIT source properties by name
	readable var _src_local_properties: Map[Symbol, MMLocalProperty]

	init(mod: MMSrcModule, n: Symbol, cla: nullable AClassdef, a: Int)
	do
		super(mod, n, a)
		mod.nodes(self) = cla
		_src_local_properties = new HashMap[Symbol, MMLocalProperty]
	end
end

redef class MMGlobalProperty
	# Check that a module can access a property
	fun check_visibility(v: AbsSyntaxVisitor, n: ANode, cm: MMSrcModule, allows_protected: Bool): Bool do
		var pm = local_class.mmmodule
		assert pm isa MMSrcModule
		var vpm = cm.visibility_for(pm)
		if vpm == 3 then
			return true
		else if vpm == 0 then
			# TODO: should not occurs 
			v.error(n, "Visibility error: Property {self} comes from the hidden module {cm}.")
			return false
		else if visibility_level >= 3 then
			v.error(n, "Visibility error: Property {self} is private.")
			return false
		else if visibility_level >= 2 and not allows_protected then
			v.error(n, "Visibility error: Property {self} is protected and can only acceded by self.")
			return false
		end
		return true
	end
end

redef class MMLocalProperty
	# The attached node (if any)
	fun node: nullable ANode do return null

	# Is the concrete method defined as init
	fun is_init: Bool do return false
end

# Concrete NIT source attribute
class MMSrcAttribute
	super MMAttribute
	redef fun node: nullable AAttrPropdef do return mmmodule.nodes(self).as(nullable AAttrPropdef)
	init(name: Symbol, cla: MMLocalClass, n: AAttrPropdef)
	do
		super(name, cla)
		cla.mmmodule.nodes(self) = n
	end
end

# Concrete NIT source method
class MMSrcMethod
	super MMMethod
	redef fun is_intern do return false
	redef fun is_abstract do return false
	redef fun extern_name do return null
end

# Concrete NIT source method for an automatic accesor
class MMAttrImplementationMethod
	super MMSrcMethod
	redef fun node: nullable AAttrPropdef do return mmmodule.nodes(self).as(nullable AAttrPropdef)
	init(name: Symbol, cla: MMLocalClass, n: AAttrPropdef)
	do
		super(name, cla)
		cla.mmmodule.nodes(self) = n
	end
end

# Concrete NIT source method for an automatic read accesor
class MMReadImplementationMethod
	super MMAttrImplementationMethod
	init(name: Symbol, cla: MMLocalClass, n: AAttrPropdef)
	do
		super(name, cla, n)
	end
end

# Concrete NIT source method for an automatic write accesor
class MMWriteImplementationMethod
	super MMAttrImplementationMethod
	init(name: Symbol, cla: MMLocalClass, n: AAttrPropdef)
	do
		super(name, cla, n)
	end
end

# Concrete NIT source method for an explicit method
class MMMethSrcMethod
	super MMSrcMethod
	redef readable var _is_init: Bool
	redef readable var _is_intern: Bool
	redef readable var _is_abstract: Bool
	redef readable writable var _extern_name: nullable String # Will be computed during MMBuilder
	redef fun node: nullable AMethPropdef do return mmmodule.nodes(self).as(nullable AMethPropdef)
	init(name: Symbol, cla: MMLocalClass, n: nullable AMethPropdef)
	do
		super(name, cla)
		cla.mmmodule.nodes(self) = n
		_is_init = node isa AConcreteInitPropdef
		_is_intern = node isa AInternMethPropdef
		_is_abstract = node isa ADeferredMethPropdef
		_extern_name = null
	end
end

# Concrete NIT source virtual type
class MMSrcTypeProperty
	super MMLocalProperty
	super MMTypeProperty
	init(name: Symbol, cla: MMLocalClass, n: ATypePropdef)
	do
		super(name, cla)
	end
end

# Concrete NIT implicit constructor
class MMImplicitInit
	super MMMethSrcMethod
	fun super_init: nullable MMLocalProperty is abstract
	redef fun is_init do return true
	readable var _unassigned_attributes: Array[MMSrcAttribute]
	readable var _super_inits: Array[MMLocalProperty]
	init(cla: MMLocalClass, unassigned_attributes: Array[MMSrcAttribute], super_inits: Array[MMLocalProperty])
	do
		super(once "init".to_symbol, cla, null)
		_unassigned_attributes = unassigned_attributes
		_super_inits = super_inits
	end
end

# Local variables
abstract class Variable
	# Name of the variable
	readable var _name: Symbol

	# Declaration AST node
	readable var _decl: nullable ANode

	# Static type
	readable writable var _stype: nullable MMType

	redef fun to_s do return _name.to_s

	fun kind: String is abstract

	init(n: Symbol, d: nullable ANode)
	do
		_name = n
		_decl = d
	end
end

# Variable declared with 'var'
class VarVariable
	super Variable
	redef fun kind do return once "variable"
	init(n: Symbol, d: ANode) do super
end

# Parameter of method (declared in signature)
class ParamVariable
	super Variable
	redef fun kind do return once "parameter"
	init(n: Symbol, d: nullable ANode) do super
end

# Automatic variable (like in the 'for' statement)
class AutoVariable
	super Variable
	redef fun kind do return once "automatic variable"
	init(n: Symbol, d: ANode) do super
end

# False variable corresponding to closures declared in signatures
# Lives in the same namespace than variables
class ClosureVariable
	super Variable
	redef fun kind do return once "closure"

	# The signature of the closure
	readable var _closure: MMClosure

	init(n: Symbol, d: ANode, c: MMClosure)
	do
		super(n, d)
		_closure = c
	end
end

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

# Visitor used during the syntax analysis
class AbsSyntaxVisitor
	super Visitor
	fun get_type_by_name(clsname: Symbol): MMType
	do
		if not _mmmodule.has_global_class_named(clsname) then _tc.fatal_error(_mmmodule.location, "Missing necessary class: \"{clsname}\"")
		var cls = _mmmodule.class_by_name(clsname)
		return cls.get_type
	end

	fun get_instantiated_type_by_name(clsname: Symbol, vtype: Array[MMType]): MMType
	do
		if not _mmmodule.has_global_class_named(clsname) then _tc.fatal_error(_mmmodule.location, "Missing necessary class: \"{clsname}\"")
		var cls = _mmmodule.class_by_name(clsname)
		return cls.get_instantiate_type(vtype)
	end

	# The root type Object
	fun type_object: MMType
	do
		return get_type_by_name(once ("Object".to_symbol))
	end

	# The primitive type Bool
	fun type_bool: MMType
	do
		return get_type_by_name(once ("Bool".to_symbol))
	end
	
	# The primitive type Int 
	fun type_int: MMType
	do
		return get_type_by_name(once ("Int".to_symbol))
	end

	# The primitive type Float
	fun type_float: MMType
	do
		return get_type_by_name(once ("Float".to_symbol))
	end

	# The primitive type Char
	fun type_char: MMType
	do
		return get_type_by_name(once ("Char".to_symbol))
	end

	# The primitive type String
	fun type_string: MMType
	do
		return get_type_by_name(once ("String".to_symbol))
	end

	# The primitive type Collection[nullable Object]
	fun type_collection: MMType
	do
		return get_instantiated_type_by_name(once ("Collection".to_symbol), [type_object.as_nullable])
	end

	# The primitive type NativeString
	fun type_nativestring: MMType
	do
		return get_type_by_name(once ("NativeString".to_symbol))
	end

	# The primitive type Array[?]
	fun type_array(stype: MMType): MMType
	do
		return get_instantiated_type_by_name(once ("Array".to_symbol), [stype])
	end

	# The primitive type Discrete
	fun type_discrete: MMType
	do
		return get_type_by_name(once ("Discrete".to_symbol))
	end

	# The primitive type Range[?]
	fun type_range(stype: MMType): MMType
	do
		return get_instantiated_type_by_name(once ("Range".to_symbol), [stype])
	end

	# The primitive type of null
	fun type_none: MMType
	do
		return _mmmodule.type_none
	end

	fun get_method(recv: MMType, name: Symbol): MMMethod
	do
		if not recv.local_class.has_global_property_by_name(name) then
			fatal_error(current_node, "Fatal Error: {recv} must have a property named {name}.")
		end
		return recv.local_class.select_method(name)
	end

	# The current module
	readable var _mmmodule: MMSrcModule

	# The current class
	fun local_class: MMSrcLocalClass do return _local_class.as(not null)
	writable var _local_class: nullable MMSrcLocalClass

	# The current property
	fun local_property: MMLocalProperty do return _local_property.as(not null)
	writable var _local_property: nullable MMLocalProperty

	# The current tool configuration/status
	readable var _tc: ToolContext 

	# Display an error for a given syntax node
	fun error(n: nullable ANode, s: String)
	do
		_tc.error(if n == null then null else n.location, s)
	end

	# Add an error, show errors and quit
	fun fatal_error(n: nullable ANode, s: String)
	do
		_tc.fatal_error(if n == null then null else n.location, s)
	end

	# Display a warning for a given syntax node
	fun warning(n: nullable ANode, s: String)
	do
		_tc.warning(if n == null then null else n.location, s)
	end

	# Check conformity and display error
	fun check_conform(n: ANode, subtype: nullable MMType, stype: nullable MMType): Bool
	do
		if stype == null or subtype == null then
			return false
		end
		if subtype < stype  then
			return true
		end
		error(n, "Type error: expected {stype}, got {subtype}")
		return false
	end

	# Check that an expression has a static type and that 
	# Display an error and return false if n is a statement
	# Require that the static type of n is known
	fun check_expr(n: AExpr): Bool
	do
		if not n.is_typed then
			if tc.error_count == 0 then
				print("{n.location} not typed but not error")
				abort
			end
			# An error occured in a sub node,
			# sillently cascade fail
			return false
		else if n.is_statement then
			error(n, "Type error: expected expression.")
			return false
		end
		return true
	end

	# Combine check_conform and check_expr
	fun check_conform_expr(n: AExpr, stype: nullable MMType): Bool
	do
		if stype == null then return false
		if check_expr(n) then return check_conform(n, n.stype, stype) else return false
	end

	# Check conformance between multiple expressions and a static type
	# Conformance is granted if among them there is a most general type
	# Return the most general type if a conformance is found
	# Display an error and return null if no conformance is found
	# The only allowed combinaison is with the nullable marker
	# @param stype is a possible additional type (without node)
	# Examples:
	#   Int, Int, Object => return Object
	#   Int, Float => display error, return null
	#   nullable Int, Object => return nullable Object
	fun check_conform_multiexpr(stype: nullable MMType, nodes: Collection[AExpr]): nullable MMType
	do
		var node: nullable AExpr = null # candidate node
		for n in nodes do
			if not check_expr(n) then return null
			var ntype = n.stype
			if stype != null and stype.is_nullable != ntype.is_nullable then
				# nullable combinaison: if one of them is nulable, considers that both are
				stype = stype.as_nullable
				ntype = ntype.as_nullable
			end
			if stype == null or stype < ntype then
				stype = ntype
				node = n
			end
		end
		assert stype != null
		for n in nodes do
			if not n.stype < stype then
				if node == null then
					error(n, "Type error: no most general type. Got {n.stype} and {stype}.")
				else
					error(n, "Type error: no most general type. Got {n.stype} and {stype} at {node.location.relative_to(n.location)}.")
				end
				return null
			end
		end
		return stype
	end

	protected init(tc: ToolContext, mmmodule: MMSrcModule)
	do
		_tc = tc
		_mmmodule = mmmodule
	end
end

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

redef class ANode
	protected fun accept_abs_syntax_visitor(v: AbsSyntaxVisitor) do visit_all(v)
end

redef class Token
	var _symbol_cache: nullable Symbol

	# Symbol associated with the text
	# Lazily computed
	fun to_symbol: Symbol
	do
		var s = _symbol_cache
		if s == null then
			s = text.to_symbol
			_symbol_cache = s
		end
		return s
	end
end

redef class AClassdef
	# Associated class (MM entity)
	fun local_class: MMSrcLocalClass is abstract

	# Next AClassdef of the same class (if any)
	readable writable var _next_node: nullable AClassdef = null
end

redef class APropdef
	# Associated 'self' variable
	fun self_var: ParamVariable is abstract
end

redef class AAttrPropdef
	# Associated attribute (MM entity)
	fun prop: MMSrcAttribute is abstract

	# Associated read accessor (MM entity)
	fun readmethod: nullable MMSrcMethod is abstract

	# Associated write accessor (MM entity)
	fun writemethod: nullable MMSrcMethod is abstract
end

redef class AConcreteInitPropdef
	readable var _super_init_calls: Array[MMMethod] = new Array[MMMethod]
	readable var _explicit_super_init_calls: Array[MMMethod] = new Array[MMMethod]
end

redef class AMethPropdef
	# Associated method (MM entity)
	fun method: MMMethSrcMethod is abstract
end

redef class ATypePropdef
	# Associated formal type (MM entity)
	fun prop: MMSrcTypeProperty is abstract
end

redef class AParam
	# Position in the signature
	fun position: Int is abstract

	# Associated local variable
	fun variable: ParamVariable is abstract 
end

redef class AClosureDecl
	# Position in the signature
	fun position: Int is abstract

	# Associated closure variable
	fun variable: ClosureVariable is abstract
end

redef class AType
	# Is the node correcly typed
	# Return false if typed was not yet computed or
	# if an error occured during the typing computation
	fun is_typed: Bool is abstract

	# Return corresponding static type. (require is_typed)
	fun stype: MMType is abstract

	var _stype_cache: nullable MMType = null
	var _stype_cached: Bool = false

	# Retrieve the local class corresponding to the type.
	# Display an error and return null if there is no class
	# Display an error and return null if the type is not class based (formal one)
	fun get_local_class(v: AbsSyntaxVisitor): nullable MMLocalClass
	do
		var name = n_id.to_symbol
		var mod = v.mmmodule
		var cla = v.local_class

		if cla.formal_dict.has_key(name) or cla.has_global_property_by_name(name) then
			v.error(n_id, "Type error: {name} is a formal type")
			_stype_cached = true
			return null
		end

		if not mod.has_global_class_named(name) then
			v.error(n_id, "Type error: class {name} not found in module {mod}.")
			_stype_cached = true
			return null
		end

		var local_class = mod.class_by_name(name)
		local_class.global.check_visibility(v, self, mod)
		return local_class
	end

	# Retrieve corresponding static type.
	# Display an error and return null if there is a problem
	# But do not performs any subtype check.
	# get_unchecked_stype should be called to check that the static type is fully valid
	fun get_unchecked_stype(v: AbsSyntaxVisitor): nullable MMType
	do
		if _stype_cached then return _stype_cache
		_stype_cached = true

		var name = n_id.to_symbol
		var mod = v.mmmodule
		var cla = v.local_class
		var t: nullable MMType

		if cla.formal_dict.has_key(name) then
			if n_types.length > 0 then
				v.error(self, "Type error: formal type {name} cannot have formal parameters.")
				return null
			end
			t = cla.formal_dict[name]
			if n_kwnullable != null then t = t.as_nullable
			_stype_cache = t
			return t
		end

		if cla.has_global_property_by_name(name) then
			if n_types.length > 0 then
				v.error(self, "Type error: formal type {name} cannot have formal parameters.")
				return null
			end
			t = cla.get_type.local_class.select_virtual_type(name).stype_for(cla.get_type)
			if t == null then
				v.error(self, "Type error: circular definition in formal type {name}.")
				return null
			end
			if n_kwnullable != null then t = t.as_nullable
			_stype_cache = t
			return t
		end

		var local_class = get_local_class(v)
		if local_class == null then return null

		var arity = n_types.length
		if local_class.arity != arity then
			if arity == 0 then
				v.error(self, "Type error: '{local_class}' is a generic class.")
			else if local_class.arity == 0 then
				v.error(self, "Type error: '{local_class}' is not a generic class.")
			else
				v.error(self, "Type error: '{local_class}' has {local_class.arity} parameters ({arity} are provided).")
			end
			return null
		end

		if arity > 0 then
			var tab = new Array[MMType]
			for p in n_types do
				var t2 = p.get_unchecked_stype(v)
				if t2 == null then return null
				tab.add(t2)
			end
			t = local_class.get_instantiate_type(tab)
		else
			t = local_class.get_type
		end
		if n_kwnullable != null then t = t.as_nullable
		_stype_cache = t
		return t
	end

	# Retrieve corresponding static type.
	# Display an error and return null if there is a problem
	fun get_stype(v: AbsSyntaxVisitor): nullable MMType
	do
		var t = get_unchecked_stype(v)
		if t == null then return null
		if not t.is_valid then return null
		check_conform(v)
		return t
	end

	# Check that a static definition type is conform with regard to formal types
	# Useful with get_unchecked_stype
	# Remember that conformance check need that ancestors are totaly computed
	fun check_conform(v: AbsSyntaxVisitor)
	do
		var st = get_unchecked_stype(v)
		if st == null then return 
		var local_class = st.local_class
		var arity = n_types.length
		if arity > 0 then
			for i in [0..arity[ do
				var p = n_types[i]
				var pt = p.get_stype(v)
				var b = local_class.get_formal(i)
				if not b.is_valid then return
				var bt = b.bound
				bt = bt.adapt_to(st) # We need to abapt because of F-genericity
				v.check_conform(p, pt, bt)
			end
		end
	end
end

redef class AExpr
	# Is the expression node correcly typed
	# Return false if typed was not yet computed or
	# if an error occured during the typing computation
	fun is_typed: Bool is abstract

	# Is the expression node a statement? (ie has no return value)
	# require: is_typed
	fun is_statement: Bool is abstract

	# The static type of the expression
	# require: is_typed and not is_statement
	fun stype: MMType is abstract
end

class AAbsAbsSendExpr
	super AExpr
	# The signature of the called property (require is_typed)
	fun prop_signature: MMSignature is abstract

	# The raw arguments used (without vararg transformation) (require is_typed)
	fun raw_arguments: Array[AExpr] is abstract
end

class AAbsSendExpr
	super AAbsAbsSendExpr
	# The invoked method (require is_typed)
	fun prop: MMMethod is abstract

	# The return type (if any) (once computed)
	fun return_type: nullable MMType is abstract
end

class ASuperInitCall
	super AAbsSendExpr
end

redef class ASuperExpr
	super ASuperInitCall
	fun init_in_superclass: nullable MMMethod is abstract
end

redef class ANewExpr
	super AAbsSendExpr
end

redef class ASendExpr
	super ASuperInitCall
	# Closure definitions
	fun closure_defs: nullable Array[AClosureDef] is abstract
end

redef class AReassignFormExpr
	# Method used through the reassigment operator (require is_typed)
	fun assign_method: MMMethod is abstract
end

class ASendReassignExpr
	super ASendExpr
	super AReassignFormExpr
	# The invoked method used to read (require is_typed)
	# prop is the method used to write
	fun read_prop: MMMethod is abstract
end

redef class ACallReassignExpr
	super ASendReassignExpr
end

redef class ABraReassignExpr
	super ASendReassignExpr
end

redef class AAttrFormExpr
	# Attribute accessed (require is_typed)
	fun prop: MMAttribute is abstract

	# Attribute type of the acceded attribute (require is_typed)
	fun attr_type: MMType is abstract
end

redef class ASuperstringExpr
	fun atype: MMType is abstract
end

redef class AVardeclExpr
	# Assiociated local variable
	fun variable: VarVariable is abstract
	#readable writable var _variable: nullable VarVariable
end

redef class AForExpr
	# Associated automatic local variable
	fun variables: Array[AutoVariable] is abstract
end

redef class ASelfExpr
	# Associated local variable
	fun variable: ParamVariable is abstract
end

redef class AVarFormExpr
	# Associated local variable
	fun variable: Variable is abstract
end

redef class AClosureCallExpr
	super AAbsAbsSendExpr
	# Associated closure variable
	fun variable: ClosureVariable is abstract
end

redef class AClosureDef
	# Associated closure
	fun closure: MMClosure is abstract

	# Automatic variables
	readable writable var _variables: nullable Array[AutoVariable]
end