X-Git-Url: http://nitlanguage.org

diff --git a/src/icode/icode_base.nit b/src/icode/icode_base.nit
index f46ff5b..09c966b 100644
--- a/src/icode/icode_base.nit
+++ b/src/icode/icode_base.nit
@@ -32,6 +32,10 @@ class IRegister
 	end
 end
 
+# A mark used to associate IEscapes to ISeqs
+class IEscapeMark
+end
+
 # A Closure declaration
 class IClosureDecl
 	# The associated closure definition
@@ -46,21 +50,27 @@ end
 # A routine is a sequence of icodes with entry iregisters (params) and an exit iregister (result)
 class IRoutine
 	# The parameters of the routine
-	readable var _params: IndexedCollection[IRegister]
+	readable var _params: Sequence[IRegister]
 
 	# The closure declared
-	readable writable var _closure_decls: nullable IndexedCollection[IClosureDecl] = null
+	readable writable var _closure_decls: nullable Sequence[IClosureDecl] = null
+
+	# The local variables (excluding params and result)
+	readable var _registers: Set[IRegister] = new HashSet[IRegister]
 
 	# The result of the routine
 	readable var _result: nullable IRegister
 
+	# The local escapes marks of the routine
+	readable var _escape_marks: Set[IEscapeMark] = new HashSet[IEscapeMark]
+
 	# The sequence of icode
 	readable var _body: ISeq = new ISeq
 
 	# The location of the iroutine (if any)
 	readable writable var _location: nullable Location = null
 
-	init(p: IndexedCollection[IRegister], r: nullable IRegister)
+	init(p: Sequence[IRegister], r: nullable IRegister)
 	do
 		_params = p.to_a
 		_result = r
@@ -69,7 +79,7 @@ end
 
 # A closure definition in a iroutine body
 class IClosureDef
-special IRoutine
+	super IRoutine
 	init(p: Array[IRegister], r: nullable IRegister)
 	do
 		super(p, r)
@@ -88,17 +98,20 @@ abstract class ICode
 
 	# The location of the icode (if any)
 	readable writable var _location: nullable Location = null
+
+	# Is the icode side effect free?
+	fun is_pure: Bool do return false
 end
 
 # An icode that uses no registers (no args)
 abstract class ICode0
-special ICode
+	super ICode
 	redef fun arity do return 0
 end
 
 # An icode that uses a single register (1 arg)
 abstract class ICode1
-special ICode
+	super ICode
 	redef fun arity do return 1
 
 	# The single argument
@@ -109,7 +122,7 @@ end
 
 # An icode that uses two single registers (2 args)
 abstract class ICode2
-special ICode
+	super ICode
 	redef fun arity do return 2
 
 	# The first argument
@@ -127,16 +140,16 @@ end
 
 # An icode that uses a variable number of registers (n args) and a variable number of closure definitions
 abstract class ICodeN
-special ICode
+	super ICode
 	redef fun arity do return _exprs.length
 
 	# All arguments
-	readable var _exprs: IndexedCollection[IRegister]
+	readable var _exprs: Sequence[IRegister]
 
 	# All closure definition
-	readable writable var _closure_defs: nullable IndexedCollection[nullable IClosureDef]
+	readable writable var _closure_defs: nullable Sequence[nullable IClosureDef]
 
-	init(e: nullable IndexedCollection[IRegister])
+	init(e: nullable Sequence[IRegister])
 	do
 		if e == null then
 			_exprs = new Array[IRegister]
@@ -150,23 +163,27 @@ end
 
 # A linear sequence of ICode
 class ISeq
-special ICode0
+	super ICode0
 	# The sequence of icode
 	readable var _icodes: List[ICode] = new List[ICode]
+
+	# The associated iescape_mark (if any)
+	readable writable var _iescape_mark: nullable IEscapeMark
+
 	init do end
 end
 
 # An infinite loop of ICode
 # Use IEscape to exit
 class ILoop
-special ISeq
+	super ISeq
 	init do end
 end
 
 # A Condidianal if-then-else statement
 # expr is the condition
 class IIf
-special ICode1
+	super ICode1
 	# The 'then' sequence of icode
 	readable var _then_seq: ISeq = new ISeq
 	# The 'else' sequence of icode
@@ -176,27 +193,24 @@ end
 
 # Escape to to end of a parent sequence
 class IEscape
-special ICode0
+	super ICode0
 	# The seqeuence to escape
-	# The control flow continues at the next icode after the sequence
-	readable var _seq: ISeq
-	init(seq: ISeq) do _seq = seq
+	# The control flow continues at the next icode after the associated sequence
+	readable var _iescape_mark: IEscapeMark
+	init(mark: IEscapeMark) do _iescape_mark = mark
 end
 
 # An abort statement
 class IAbort
-special ICode0
+	super ICode0
 	# The reason the abort occured
 	# tests.first is the format
 	readable var _texts: Array[String]
-	# The local property that has the abort (if any)
-	readable var _property_location: nullable MMLocalProperty
 	# The module that has the abort
 	readable var _module_location: MMModule
-	init(t: Array[String], pl: nullable MMLocalProperty, ml: MMModule)
+	init(t: Array[String], ml: MMModule)
 	do
 		_texts = t
-		_property_location = pl
 		_module_location = ml
 	end
 end
@@ -205,11 +219,11 @@ end
 
 # The root of all method invocations
 abstract class IAbsCall
-special ICodeN
+	super ICodeN
 	# The called method
 	readable var _property: MMMethod
 
-	init(p: MMMethod, e: IndexedCollection[IRegister])
+	init(p: MMMethod, e: Sequence[IRegister])
 	do
 		super(e)
 		_property = p
@@ -219,79 +233,185 @@ end
 # A simple procedure or function call
 # exprs.first is the reciever, other are arguments
 class ICall
-special IAbsCall
+	super IAbsCall
 	init(p, e) do super
 end
 
 # A super method call
 # exprs.first is the reciever, other are arguments
 class ISuper
-special IAbsCall
+	super IAbsCall
 	init(p, e) do super
 end
 
 # An instantiation
 # no reciever, all exprs are arguments
+# Will call in order:
+# - IAllocateInstance
+# - IInitAttributes
+# - IStaticCall -> target Initializer
+# - ICheckInstance
 class INew
-special ICall
+	super IAbsCall
 	# The type to instantiate
 	readable var _stype: MMType
-	init(t: MMType, p: MMMethod, a: IndexedCollection[IRegister])
+	init(t: MMType, p: MMMethod, a: Sequence[IRegister])
 	do
 		super(p, a)
 		_stype = t
 	end
 end
 
+# An allocation of a new object
+# No receivers, returns a new object of type 't'
+# Will allocate memory and ensure dynamic type and object identity
+class IAllocateInstance
+	super ICode0
+	# The type to allocate
+	readable var _stype: MMType
+	init(t: MMType)
+	do
+		_stype = t
+	end
+end
+
+# A static call to a specific method
+class IStaticCall
+	super IAbsCall
+	init(p: MMMethod, a: Sequence[IRegister]) do super
+end
+
+# A validation of a newly constructed instance
+class ICheckInstance
+	super ICode1
+	# The type to allocate
+	readable var _stype: MMType
+	init(t: MMType, e: IRegister)
+	do
+		super(e)
+		_stype = t
+	end
+end
+
+# Initialisation of default attributes of a new instance
+class IInitAttributes
+	super ICode1
+	# The type to initialize
+	readable var _stype: MMType
+	init(t: MMType, e: IRegister)
+	do
+		super(e)
+		_stype = t
+	end
+end
+
 # A closure call
 # exprs are the arguments
 class IClosCall
-special ICodeN
+	super ICodeN
 	# The called closure
 	readable var _closure_decl: IClosureDecl
 
 	# The !break sequence (if any)
 	readable writable var _break_seq: nullable ISeq = null
 
-	init(c: IClosureDecl, e: IndexedCollection[IRegister])
+	init(c: IClosureDecl, e: Sequence[IRegister])
 	do
 		super(e)
 		_closure_decl = c
 	end
 end
 
-# A native C code
-# Mainly used to implements things that do not have a specific ICode yet
+# A native inlined call
+# Native are associated to local properties to distinguish them
 # expr are the arguments
 class INative
-special ICodeN
-	# The native C code
-	# Special character sequence '@@@' will be substitued in order with the arguments
-	readable var _code: String
+	super ICodeN
+	# The associated local property
+	readable var _method: MMMethod
 
-	init(c: String, e: nullable IndexedCollection[IRegister])
+	init(m: MMMethod, e: nullable Sequence[IRegister])
 	do
 		super(e)
-		_code = c
+		_method = m
 	end
+
+	redef readable writable var _is_pure: Bool = false
+end
+
+# A literal Int value
+class IIntValue
+	super ICode0
+	# The value
+	readable var _value: String
+
+	init(v: String) do _value = v
+
+	redef fun is_pure do return true
+end
+
+# A literal Bool value
+class IBoolValue
+	super ICode0
+	# The value
+	readable var _value: Bool
+
+	init(v: Bool) do _value = v
+
+	redef fun is_pure do return true
+end
+
+# A literal NativeString value
+class IStringValue
+	super ICode0
+	# The value
+	readable var _value: String
+
+	init(v: String) do _value = v
+
+	redef fun is_pure do return true
+end
+
+# A literal Float value
+class IFloatValue
+	super ICode0
+	# The value
+	readable var _value: String
+
+	init(v: String) do _value = v
+
+	redef fun is_pure do return true
+end
+
+# A literal Char value
+class ICharValue
+	super ICode0
+	# The value
+	readable var _value: String
+
+	init(v: String) do _value = v
+
+	redef fun is_pure do return true
 end
 
 # A register assigment
 # expr is the assigned value
 # result is the register assigned
 class IMove
-special ICode1
+	super ICode1
 	init(r: IRegister, e: IRegister)
 	do
 		super(e)
 		_result = r
 	end
+
+	redef fun is_pure do return true
 end
 
 # An attribute read access
 # expr is the reciever
 class IAttrRead
-special ICode1
+	super ICode1
 	# The accessed attribute
 	readable var _property: MMAttribute
 
@@ -300,12 +420,14 @@ special ICode1
 		super(r)
 		_property = p
 	end
+
+	redef fun is_pure do return true
 end
 
 # An attribute assignment
 # expr1 is the receiver, expr2 is the assigned value
 class IAttrWrite
-special ICode2
+	super ICode2
 	# The accessed attribute
 	readable var _property: MMAttribute
 
@@ -320,7 +442,7 @@ end
 # An attribute is_set check
 # expr is the reciever
 class IAttrIsset
-special ICode1
+	super ICode1
 	# The accessed attribute
 	readable var _property: MMAttribute
 
@@ -329,12 +451,14 @@ special ICode1
 		super(r)
 		_property = p
 	end
+
+	redef fun is_pure do return true
 end
 
 # A type check
 # expr is the expression checked
 class ITypeCheck
-special ICode1
+	super ICode1
 	# The static type checkes to
 	readable var _stype: MMType
 
@@ -343,39 +467,45 @@ special ICode1
 		super(e)
 		_stype = t
 	end
+
+	redef fun is_pure do return true
 end
 
 # The 'is' operator
 # expr1 and expr2 are both operands
 class IIs
-special ICode2
+	super ICode2
 	init(e1, e2: IRegister)
 	do
 		super
 	end
+
+	redef fun is_pure do return true
 end
 
 # The unary 'not' operation
 # expr is the operand
 class INot
-special ICode1
+	super ICode1
 	init(e: IRegister)
 	do
 		super
 	end
+
+	redef fun is_pure do return true
 end
 
 # Evaluate body once them return the same value again and again
 # if result is not null, then it must also be assigned in the body
 class IOnce
-special ICode0
+	super ICode0
 	readable var _body: ISeq = new ISeq
 	init do end
 end
 
 # Is a closure given as a parameter?
 class IHasClos
-special ICode0
+	super ICode0
 	# The called closure
 	readable var _closure_decl: IClosureDecl
 
@@ -383,6 +513,8 @@ special ICode0
 	do
 		_closure_decl = c
 	end
+
+	redef fun is_pure do return true
 end
 
 #################################################