# 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
special MMModule
	# The related AST node
	readable attr _node: AModule

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

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

redef class MMGlobalClass
	# Check that a module can access a class
	meth check_visibility(v: AbsSyntaxVisitor, n: PNode, cm: MMSrcModule): Bool do
		var pm = intro.module
		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
special MMConcreteClass
	# The related AST nodes
	readable attr _nodes: Array[PClassdef]

	# Concrete NIT source generic formal parameter by name
	readable writable attr _formal_dict: Map[Symbol, MMTypeFormalParameter]

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

	init(n: Symbol, cla: PClassdef, a: Int)
	do
		super(n, a)
		_nodes = [cla]
		_src_local_properties = new HashMap[Symbol, MMLocalProperty]
	end
end

redef class MMGlobalProperty
	# Check that a module can access a property
	meth check_visibility(v: AbsSyntaxVisitor, n: PNode, cm: MMSrcModule, allows_protected: Bool): Bool do
		var pm = local_class.module
		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)
	meth node: PNode do return null

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

# Concrete NIT source attribute
class MMSrcAttribute
special MMAttribute
	redef readable attr _node: AAttrPropdef
	init(name: Symbol, cla: MMLocalClass, n: AAttrPropdef)
	do
		super(name, cla)
		_node = n
	end
end

# Concrete NIT source method
class MMSrcMethod
special MMMethod
end

# Concrete NIT source method for an automatic accesor
class MMAttrImplementationMethod
special MMSrcMethod
	redef readable attr _node: AAttrPropdef
	init(name: Symbol, cla: MMLocalClass, n: AAttrPropdef)
	do
		super(name, cla)
		_node = n
	end
end

# Concrete NIT source method for an automatic read accesor
class MMReadImplementationMethod
special 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
special 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
special MMSrcMethod
	redef meth is_init do return _node isa AConcreteInitPropdef
	redef readable attr _node: AMethPropdef
	init(name: Symbol, cla: MMLocalClass, n: AMethPropdef)
	do
		super(name, cla)
		_node = n
	end
end

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

# Concrete NIT implicit constructor
class MMImplicitInit
special MMMethSrcMethod
	redef meth is_init do return true
	readable attr _unassigned_attributes: Array[MMSrcAttribute]
	readable attr _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 attr _name: Symbol 

	# Declaration AST node
	readable attr _decl: PNode

	# Static type
	readable writable attr _stype: MMType 

	redef meth to_s do return _name.to_s

	meth kind: String is abstract

	init(n: Symbol, d: PNode)
	do
		#assert n != null
		#assert d != null
		_name = n
		_decl = d
	end
end

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

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

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

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

	# The signature of the closure
	readable attr _closure: MMClosure

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

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

# Visitor used during the syntax analysis
class AbsSyntaxVisitor
special Visitor
	# The root type Object
	meth type_object: MMType
	do
		return _module.class_by_name(once ("Object".to_symbol)).get_type
	end

	# The primitive type Bool
	meth type_bool: MMType
	do
		return _module.class_by_name(once ("Bool".to_symbol)).get_type
	end
	
	# The primitive type Int 
	meth type_int: MMType
	do
		return _module.class_by_name(once ("Int".to_symbol)).get_type
	end

	# The primitive type Float
	meth type_float: MMType
	do
		return _module.class_by_name(once ("Float".to_symbol)).get_type
	end

	# The primitive type Char
	meth type_char: MMType
	do
		return _module.class_by_name(once ("Char".to_symbol)).get_type
	end

	# The primitive type String
	meth type_string: MMType
	do
		return _module.class_by_name(once ("String".to_symbol)).get_type
	end

	# The primitive type Collection[Object]
	meth type_collection: MMType
	do
		return _module.class_by_name(once ("Collection".to_symbol)).get_type
	end

	# The primitive type Array[?]
	meth type_array(stype: MMType): MMType
	do
		return _module.class_by_name(once ("Array".to_symbol)).get_instantiate_type([stype])
	end

	# The primitive type Discrete
	meth type_discrete: MMType
	do
		return _module.class_by_name(once ("Discrete".to_symbol)).get_type
	end

	# The primitive type Range[?]
	meth type_range(stype: MMType): MMType
	do
		return _module.class_by_name(once ("Range".to_symbol)).get_instantiate_type([stype])
	end

	# The primitive type of null
	meth type_none: MMType
	do
		return _module.type_none
	end

	# The current module
	readable writable attr _module: MMSrcModule 

	# The current class
	readable writable attr _local_class: MMSrcLocalClass 

	# The current property
	readable writable attr _local_property: MMLocalProperty

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

	# Display an error for a given syntax node
	meth error(n: PNode, s: String)
	do
		_tc.error("{locate(n)}: {s}")
	end

	# Display a warning for a given syntax node
	meth warning(n: PNode, s: String)
	do
		_tc.warning("{locate(n)}: {s}")
	end

	#
	meth locate(n: PNode): String
	do
		if n != null then return n.locate
		return _module.filename
	end

	# Check conformity and display error
	meth check_conform(n: PNode, subtype: MMType, stype: 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}'{stype.module}, got {subtype}'{subtype.module}")
		#abort
		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
	meth check_expr(n: PExpr): Bool
	do
		# FIXME: The tc.error_count is a workaround since currently there is no way
		# to distingate statements from buggy expressions: both have a null stype
		if tc.error_count == 0 and n.stype == null then
			error(n, "Type error: expected expression.")
			return false
		end
		return true
	end

	# Combine check_conform and check_expr
	meth check_conform_expr(n: PExpr, stype: MMType): Bool
	do
		if check_expr(n) then return check_conform(n, n.stype, stype) else return false
	end


	protected init(tc: ToolContext, module: MMSrcModule)
	do
		_tc = tc
		_module = module
	end
end

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

redef class PNode
	protected meth accept_abs_syntax_visitor(v: AbsSyntaxVisitor) do visit_all(v)
end

redef class Token
	attr _symbol: Symbol

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

redef class PClassdef
	# Associated class (MM entity)
	meth local_class: MMSrcLocalClass is abstract
end

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

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

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

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

	# Associated 'self' variable
	meth self_var: ParamVariable is abstract
end

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

redef class PParam
	# Position in the signature
	meth position: Int is abstract

	# Associated local variable
	meth variable: ParamVariable is abstract 
end

redef class PClosureDecl
	# Associated closure variable
	meth variable: ClosureVariable is abstract
end

redef class PType
	# 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)
	meth get_local_class(v: AbsSyntaxVisitor): MMLocalClass is abstract

	# Retrieve corresponding static type.
	# Display an error and return null if there is a problem
	meth get_stype(v: AbsSyntaxVisitor): MMType is abstract

	# 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
	meth get_unchecked_stype(v: AbsSyntaxVisitor): MMType is abstract

	# 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
	meth check_conform(v: AbsSyntaxVisitor) is abstract
end

redef class AType
	attr _stype_cache: MMType
	attr _stype_cached: Bool = false

	redef meth get_local_class(v)
	do
		var name = n_id.to_symbol
		var mod = v.module
		var cla = v.local_class

		if (cla.formal_dict != null and cla.formal_dict.has_key(name)) or (cla.global_properties != null and 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

	redef meth get_unchecked_stype(v)
	do
		if _stype_cached then return _stype_cache
		_stype_cached = true

		var name = n_id.to_symbol
		var mod = v.module
		var cla = v.local_class

		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
			var formal = cla.formal_dict[name]
			_stype_cache = formal
			return formal
		end

		if cla.global_properties != null and 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
			var 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
			_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
			v.error(self, "Type error: '{local_class}' has {local_class.arity} parameters which differs from the {arity} params.")
			return null
		end

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

	redef meth check_conform(v)
	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 bt = local_class.get_formal(i).bound
				if bt == null then return
				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 PExpr
	# Static type
	# Is null for statement and for erronus expression
	meth stype: MMType is abstract
end

redef class AVardeclExpr
	# Assiociated local variable
	readable writable attr _variable: VarVariable
end

redef class AForVardeclExpr
	# Associated automatic local variable
	readable writable attr _variable: AutoVariable
end

redef class ASelfExpr
	# Associated local variable
	readable writable attr _variable: ParamVariable 
end

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

redef class AClosureCallExpr
	# Associated closure variable
	readable writable attr _variable: ClosureVariable
end

redef class PClosureDef
	# Associated closure
	readable writable attr _closure: MMClosure

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