icode: closures are generated within a ICodeBuilder

[nit.git] / src / syntax / icode_generation.nit

diff --git a/src/syntax/icode_generation.nit b/src/syntax/icode_generation.nit
index f002863..9477f2d 100644 (file)
--- a/src/syntax/icode_generation.nit
+++ b/src/syntax/icode_generation.nit
@@ -79,12 +79,16 @@ special ICodeBuilder
        # Register where a functionnal nit return must store its value
        readable writable var _return_value: nullable IRegister
 
+       # The method associated to the iroutine (if any)
+       readable var _method: nullable MMMethod
+
        init(visitor: AbsSyntaxVisitor, r: IRoutine, m: nullable MMMethod)
        do
-               super(visitor.module, r, m)
+               super(visitor.module, r)
                _visitor = visitor
                _return_seq = r.body
                _return_value = r.result
+               _method = m
        end
 
        # Insert implicit super init calls
@@ -115,17 +119,17 @@ special ICodeBuilder
                end
                var l = n.super_init_calls.length
                while i < l do
-                       var p = n.super_init_calls[i]
-                       if p == stop_prop then break
+                       var sp = n.super_init_calls[i]
+                       if sp == stop_prop then break
                        var cargs = new Array[IRegister]
-                       if p.signature.arity == 0 then
+                       if sp.signature.arity == 0 then
                                cargs.add(iroutine.params.first)
                        else
                                for va in iroutine.params do
                                        cargs.add(va)
                                end
                        end
-                       stmt(new ICall(p, cargs))
+                       stmt(new ICall(sp, cargs))
                        i += 1
                end
        end
@@ -314,7 +318,7 @@ redef class AMethPropdef
 end
 
 redef class ASignature
-       fun fill_iroutine_parameters(v: A2IContext, orig_sig: MMSignature, params: IndexedCollection[IRegister], closdecls: nullable IndexedCollection[IClosureDecl])
+       fun fill_iroutine_parameters(v: A2IContext, orig_sig: MMSignature, params: Sequence[IRegister], closdecls: nullable Sequence[IClosureDecl])
        do
                for ap in n_params do
                        var reg = v.variable(ap.variable)
@@ -336,7 +340,7 @@ redef class AClosureDecl
        redef fun accept_icode_generation(vv)
        do
                var v = vv.icode_ctx
-               var iclos = variable.closure.signature.generate_empty_iclosuredef
+               var iclos = variable.closure.signature.generate_empty_iclosuredef(v)
                var old_seq = v.seq
                v.seq = iclos.body
                escapable.continue_seq = iclos.body
@@ -738,6 +742,29 @@ redef class AWhileExpr
        end
 end
 
+redef class ALoopExpr
+       redef fun generate_icode(v)
+       do
+               var seq_old = v.seq
+               var iloop = new ILoop
+               v.stmt(iloop)
+               escapable.break_seq = iloop
+               v.seq = iloop
+
+               # Process inside
+               if n_block != null then
+                       var seq = new ISeq
+                       v.stmt(seq)
+                       v.seq = seq
+                       escapable.continue_seq = seq
+                       v.generate_stmt(n_block)
+               end
+
+               v.seq = seq_old
+               return null
+       end
+end
+
 redef class AForExpr
        redef fun generate_icode(v)
        do
@@ -1137,7 +1164,7 @@ redef class ASuperExpr
                                return null
                        end
                else
-                       var p = prop
+                       p = prop
                        var rtype = p.signature.return_type
                        if rtype == null then
                                v.stmt(new ISuper(p, args))
@@ -1244,14 +1271,24 @@ redef class ASendExpr
                        closcns = new Array[nullable IClosureDef]
                        var cdarity = 0
                        if closure_defs != null then cdarity = closure_defs.length
-                       for i in [0..cdarity[ do
-                               closure_defs[i].escapable.break_seq = seq
-                               closure_defs[i].escapable.break_value = r
-                               var cn = closure_defs[i].generate_iclosuredef(v)
-                               closcns.add(cn)
-                       end
-                       for i in [cdarity..prop_signature.closures.length[ do
-                               closcns.add(null)
+                       var closure_defs = closure_defs
+                       for mmc in prop_signature.closures do
+                               var found = false
+                               var name = mmc.name
+                               if closure_defs != null then
+                                       for cd in closure_defs do
+                                               if cd.n_id.to_symbol != name then continue
+                                               assert found == false
+                                               found = true
+                                               cd.escapable.break_seq = seq
+                                               cd.escapable.break_value = r
+                                               var cn = cd.generate_iclosuredef(v)
+                                               closcns.add(cn)
+                                       end
+                               end
+                               if not found then
+                                       closcns.add(null)
+                               end
                        end
                end
 
@@ -1413,7 +1450,7 @@ redef class AClosureCallExpr
                                v.add_assignment(r, r2)
                        end
                        v.seq = iif.else_seq
-                       var r3 = closdecl_default.inline_in_seq(iif.else_seq, args)
+                       var r3 = v.inline_routine(closdecl_default, args)
                        if r != null then
                                assert r3 != null
                                v.add_assignment(r, r3)