syntax: add 'loop' construction

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

diff --git a/src/syntax/typing.nit b/src/syntax/typing.nit
index 9a807e6..13737aa 100644 (file)
--- a/src/syntax/typing.nit
+++ b/src/syntax/typing.nit
@@ -545,6 +545,33 @@ redef class AWhileExpr
        end
 end
 
+redef class ALoopExpr
+       # The corresponding escapable block
+       readable var _escapable: nullable EscapableBlock
+
+       redef fun accept_typing(v)
+       do
+               var escapable = new EscapableBlock(self)
+               _escapable = escapable
+               v.escapable_ctx.push(escapable, n_label)
+               var old_var_ctx = v.variable_ctx
+               var old_base_var_ctx = v.base_variable_ctx
+               v.base_variable_ctx = v.variable_ctx
+               v.variable_ctx = v.variable_ctx.sub(self)
+
+               # Process inside
+               if n_block != null then
+                       v.variable_ctx = v.variable_ctx.sub(n_block.as(not null))
+                       v.enter_visit(n_block)
+               end
+
+               v.variable_ctx = old_var_ctx
+               v.base_variable_ctx = old_base_var_ctx
+               v.escapable_ctx.pop
+               _is_typed = true
+       end
+end
+
 redef class AForExpr
        var _variable: nullable AutoVariable
        redef fun variable do return _variable.as(not null)
@@ -1124,12 +1151,23 @@ redef class AAbsAbsSendExpr
 
                                # Process each closure definition
                                for i in [0..arity[ do
-                                       var csi = cs[i]
                                        var cdi = cd[i]
-                                       var esc = new EscapableClosure(cdi, csi, break_list)
-                                       v.escapable_ctx.push(esc, n_label)
-                                       cdi.accept_typing2(v, esc)
-                                       v.escapable_ctx.pop
+                                       var cni = cdi.n_id.to_symbol
+                                       var csi = psig.closure_named(cni)
+                                       if csi != null then
+                                               var esc = new EscapableClosure(cdi, csi, break_list)
+                                               v.escapable_ctx.push(esc, n_label)
+                                               cdi.accept_typing2(v, esc)
+                                               v.escapable_ctx.pop
+                                       else if cs.length == 1 then
+                                               v.error(cdi.n_id, "Error: no closure named '!{cni}' in {name}; only closure is !{cs.first.name}.")
+                                       else
+                                               var a = new Array[String]
+                                               for c in cs do
+                                                       a.add("!{c.name}")
+                                               end
+                                               v.error(cdi.n_id, "Error: no closure named '!{cni}' in {name}; only closures are {a.join(",")}.")
+                                       end
                                end
 
                                # Check break type conformity
@@ -1517,6 +1555,14 @@ end
 redef class ABraExpr
        redef fun name do return once "[]".to_symbol
        redef fun compute_raw_arguments do return n_args.to_a
+       redef fun closure_defs
+       do
+               if n_closure_defs.is_empty then
+                       return null
+               else
+                       return n_closure_defs.to_a
+               end
+       end
 end
 
 redef class ABraAssignExpr
@@ -1559,6 +1605,16 @@ redef class AClosureCallExpr
        end
 end
 
+redef class AClosureId
+       fun to_symbol: Symbol is abstract
+end
+redef class ASimpleClosureId
+       redef fun to_symbol: Symbol do return n_id.to_symbol
+end
+redef class ABreakClosureId
+       redef fun to_symbol: Symbol do return n_kwbreak.to_symbol
+end
+
 redef class AClosureDef
        var _closure: nullable MMClosure
        redef fun closure do return _closure.as(not null)
@@ -1578,8 +1634,8 @@ redef class AClosureDef
                _escapable = esc
 
                var sig = esc.closure.signature
-               if sig.arity != n_id.length then
-                       v.error(self, "Error: {sig.arity} automatic variable names expected, {n_id.length} found.")
+               if sig.arity != n_ids.length then
+                       v.error(self, "Error: {sig.arity} automatic variable names expected, {n_ids.length} found.")
                        return
                end
 
@@ -1590,8 +1646,8 @@ redef class AClosureDef
                v.base_variable_ctx = v.variable_ctx
                v.variable_ctx = v.variable_ctx.sub(self)
                variables = new Array[AutoVariable]
-               for i in [0..n_id.length[ do
-                       var va = new AutoVariable(n_id[i].to_symbol, self)
+               for i in [0..n_ids.length[ do
+                       var va = new AutoVariable(n_ids[i].to_symbol, self)
                        variables.add(va)
                        va.stype = sig[i]
                        v.variable_ctx.add(va)