[fix] #631810: Form.DialogResult needs to call its close events *before* closing.
[mono.git] / mcs / mcs / iterators.cs
index a3abb3a5b46cf4f47745f8dafd53f1c305271d46..0cfccd0759e30e75ebce4eef3323a71557d7da67 100644 (file)
@@ -3,19 +3,19 @@
 //
 // Author:
 //   Miguel de Icaza (miguel@ximian.com)
+//   Marek Safar (marek.safar@gmail.com)
 //
+// Dual licensed under the terms of the MIT X11 or GNU GPL
 // Copyright 2003 Ximian, Inc.
+// Copyright 2003-2008 Novell, Inc.
 //
+
 // TODO:
 //    Flow analysis for Yield.
-//    Emit calls to base object constructor.
-//
-// Generics note:
-//    Current should be defined to return T, and IEnumerator.Current returns object
 //
 
 using System;
-using System.Collections;
+using System.Collections.Generic;
 using System.Reflection;
 using System.Reflection.Emit;
 
@@ -24,7 +24,7 @@ namespace Mono.CSharp {
        public class Yield : ResumableStatement {
                Expression expr;
                bool unwind_protect;
-
+               Iterator iterator;
                int resume_pc;
 
                public Yield (Expression expr, Location l)
@@ -33,22 +33,10 @@ namespace Mono.CSharp {
                        loc = l;
                }
 
-               public static bool CheckContext (EmitContext ec, Location loc, bool isYieldBreak)
+               public static bool CheckContext (ResolveContext ec, Location loc)
                {
-                       for (Block block = ec.CurrentBlock; block != null; block = block.Parent) {
-                               if (!block.Unsafe)
-                                       continue;
-
-                               Report.Error (1629, loc, "Unsafe code may not appear in iterators");
-                               return false;
-                       }
-
-                       //
-                       // We can't use `ec.InUnsafe' here because it's allowed to have an iterator
-                       // inside an unsafe class.  See test-martin-29.cs for an example.
-                       //
                        if (!ec.CurrentAnonymousMethod.IsIterator) {
-                               Report.Error (1621, loc,
+                               ec.Report.Error (1621, loc,
                                              "The yield statement cannot be used inside " +
                                              "anonymous method blocks");
                                return false;
@@ -56,10 +44,9 @@ namespace Mono.CSharp {
 
                        return true;
                }
-               
-               public override bool Resolve (EmitContext ec)
+
+               public override bool Resolve (BlockContext ec)
                {
-                       Report.Debug (64, "RESOLVE YIELD", this, ec, expr, expr.GetType ());
                        expr = expr.Resolve (ec);
                        if (expr == null)
                                return false;
@@ -67,25 +54,26 @@ namespace Mono.CSharp {
                        Report.Debug (64, "RESOLVE YIELD #1", this, ec, expr, expr.GetType (),
                                      ec.CurrentAnonymousMethod, ec.CurrentIterator);
 
-                       if (!CheckContext (ec, loc, false))
+                       if (!CheckContext (ec, loc))
                                return false;
 
-                       Iterator iterator = ec.CurrentIterator;
-                       if (expr.Type != iterator.IteratorType) {
+                       iterator = ec.CurrentIterator;
+                       if (expr.Type != iterator.OriginalIteratorType) {
                                expr = Convert.ImplicitConversionRequired (
-                                       ec, expr, iterator.IteratorType, loc);
+                                       ec, expr, iterator.OriginalIteratorType, loc);
                                if (expr == null)
                                        return false;
                        }
 
-                       unwind_protect = ec.CurrentBranching.AddResumePoint (this, loc, out resume_pc);
+                       if (!ec.CurrentBranching.CurrentUsageVector.IsUnreachable)
+                               unwind_protect = ec.CurrentBranching.AddResumePoint (this, loc, out resume_pc);
 
                        return true;
                }
 
                protected override void DoEmit (EmitContext ec)
                {
-                       ec.CurrentIterator.MarkYield (ec, expr, resume_pc, unwind_protect, resume_point);
+                       iterator.MarkYield (ec, expr, resume_pc, unwind_protect, resume_point);
                }
 
                protected override void CloneTo (CloneContext clonectx, Statement t)
@@ -96,58 +84,250 @@ namespace Mono.CSharp {
                }
        }
 
-       public class YieldBreak : ExitStatement {
+       public class YieldBreak : ExitStatement
+       {
+               Iterator iterator;
+
                public YieldBreak (Location l)
                {
                        loc = l;
                }
 
-               public override void Error_FinallyClause ()
+               public override void Error_FinallyClause (Report Report)
                {
                        Report.Error (1625, loc, "Cannot yield in the body of a finally clause");
                }
 
-               protected override bool DoResolve (EmitContext ec)
+               protected override void CloneTo (CloneContext clonectx, Statement target)
+               {
+                       throw new NotSupportedException ();
+               }
+
+               protected override bool DoResolve (BlockContext ec)
                {
-                       return Yield.CheckContext (ec, loc, true);
+                       iterator = ec.CurrentIterator;
+                       return Yield.CheckContext (ec, loc);
                }
 
                protected override void DoEmit (EmitContext ec)
                {
-                       ec.CurrentIterator.EmitYieldBreak (ec.ig, unwind_protect);
+                       iterator.EmitYieldBreak (ec, unwind_protect);
                }
        }
 
-       public class IteratorHost : RootScopeInfo
+       public class IteratorStorey : AnonymousMethodStorey
        {
+               class GetEnumeratorMethod : IteratorMethod
+               {
+                       sealed class GetEnumeratorStatement : Statement
+                       {
+                               IteratorStorey host;
+                               IteratorMethod host_method;
+
+                               Expression new_storey;
+
+                               public GetEnumeratorStatement (IteratorStorey host, IteratorMethod host_method)
+                               {
+                                       this.host = host;
+                                       this.host_method = host_method;
+                                       loc = host_method.Location;
+                               }
+
+                               protected override void CloneTo (CloneContext clonectx, Statement target)
+                               {
+                                       throw new NotSupportedException ();
+                               }
+
+                               public override bool Resolve (BlockContext ec)
+                               {
+                                       TypeExpression storey_type_expr = new TypeExpression (host.Definition, loc);
+                                       List<Expression> init = null;
+                                       if (host.hoisted_this != null) {
+                                               init = new List<Expression> (host.hoisted_params == null ? 1 : host.HoistedParameters.Count + 1);
+                                               HoistedThis ht = host.hoisted_this;
+                                               FieldExpr from = new FieldExpr (ht.Field, loc);
+                                               from.InstanceExpression = CompilerGeneratedThis.Instance;
+                                               init.Add (new ElementInitializer (ht.Field.Name, from, loc));
+                                       }
+
+                                       if (host.hoisted_params != null) {
+                                               if (init == null)
+                                                       init = new List<Expression> (host.HoistedParameters.Count);
+
+                                               for (int i = 0; i < host.hoisted_params.Count; ++i) {
+                                                       HoistedParameter hp = (HoistedParameter) host.hoisted_params [i];
+                                                       HoistedParameter hp_cp = (HoistedParameter) host.hoisted_params_copy [i];
+
+                                                       FieldExpr from = new FieldExpr (hp_cp.Field, loc);
+                                                       from.InstanceExpression = CompilerGeneratedThis.Instance;
+
+                                                       init.Add (new ElementInitializer (hp.Field.Name, from, loc));
+                                               }
+                                       }
+
+                                       if (init != null) {
+                                               new_storey = new NewInitialize (storey_type_expr, null,
+                                                       new CollectionOrObjectInitializers (init, loc), loc);
+                                       } else {
+                                               new_storey = new New (storey_type_expr, null, loc);
+                                       }
+
+                                       new_storey = new_storey.Resolve (ec);
+                                       if (new_storey != null)
+                                               new_storey = Convert.ImplicitConversionRequired (ec, new_storey, host_method.MemberType, loc);
+
+                                       if (TypeManager.int_interlocked_compare_exchange == null) {
+                                               TypeSpec t = TypeManager.CoreLookupType (ec.Compiler, "System.Threading", "Interlocked", MemberKind.Class, true);
+                                               if (t != null) {
+                                                       var p = new ParametersImported (
+                                                               new[] {
+                                                                       new ParameterData (null, Parameter.Modifier.REF),
+                                                                       new ParameterData (null, Parameter.Modifier.NONE),
+                                                                       new ParameterData (null, Parameter.Modifier.NONE)
+                                                               },
+                                                               new[] {
+                                                                       TypeManager.int32_type, TypeManager.int32_type, TypeManager.int32_type
+                                                               },
+                                                               false);
+                                                       var f = new MemberFilter ("CompareExchange", 0, MemberKind.Method, p, TypeManager.int32_type);
+                                                       TypeManager.int_interlocked_compare_exchange = TypeManager.GetPredefinedMethod (t, f, loc);
+                                               }
+                                       }
+
+                                       ec.CurrentBranching.CurrentUsageVector.Goto ();
+                                       return true;
+                               }
+
+                               protected override void DoEmit (EmitContext ec)
+                               {
+                                       Label label_init = ec.DefineLabel ();
+
+                                       ec.Emit (OpCodes.Ldarg_0);
+                                       ec.Emit (OpCodes.Ldflda, host.PC.Spec);
+                                       ec.EmitInt ((int) Iterator.State.Start);
+                                       ec.EmitInt ((int) Iterator.State.Uninitialized);
+                                       ec.Emit (OpCodes.Call, TypeManager.int_interlocked_compare_exchange);
+
+                                       ec.EmitInt ((int) Iterator.State.Uninitialized);
+                                       ec.Emit (OpCodes.Bne_Un_S, label_init);
+
+                                       ec.Emit (OpCodes.Ldarg_0);
+                                       ec.Emit (OpCodes.Ret);
+
+                                       ec.MarkLabel (label_init);
+
+                                       new_storey.Emit (ec);
+                                       ec.Emit (OpCodes.Ret);
+                               }
+                       }
+
+                       public GetEnumeratorMethod (IteratorStorey host, FullNamedExpression returnType, MemberName name)
+                               : base (host, returnType, Modifiers.DEBUGGER_HIDDEN, name)
+                       {
+                               Block.AddStatement (new GetEnumeratorStatement (host, this));
+                       }
+               }
+
+               class DisposeMethod : IteratorMethod
+               {
+                       sealed class DisposeMethodStatement : Statement
+                       {
+                               Iterator iterator;
+
+                               public DisposeMethodStatement (Iterator iterator)
+                               {
+                                       this.iterator = iterator;
+                                       this.loc = iterator.Location;
+                               }
+
+                               protected override void CloneTo (CloneContext clonectx, Statement target)
+                               {
+                                       throw new NotSupportedException ();
+                               }
+
+                               public override bool Resolve (BlockContext ec)
+                               {
+                                       return true;
+                               }
+
+                               protected override void DoEmit (EmitContext ec)
+                               {
+                                       iterator.EmitDispose (ec);
+                               }
+                       }
+
+                       public DisposeMethod (IteratorStorey host)
+                               : base (host, new TypeExpression (TypeManager.void_type, host.Location), Modifiers.PUBLIC | Modifiers.DEBUGGER_HIDDEN,
+                                       new MemberName ("Dispose", host.Location))
+                       {
+                               host.AddMethod (this);
+
+                               Block.AddStatement (new DisposeMethodStatement (host.Iterator));
+                       }
+               }
+
+               //
+               // Uses Method as method info
+               //
+               class DynamicMethodGroupExpr : MethodGroupExpr
+               {
+                       readonly Method method;
+
+                       public DynamicMethodGroupExpr (Method method, Location loc)
+                               : base ((IList<MemberSpec>) null, null, loc)
+                       {
+                               this.method = method;
+                               eclass = ExprClass.Unresolved;
+                       }
+
+                       protected override Expression DoResolve (ResolveContext ec)
+                       {
+                               Methods = new List<MemberSpec> (1) { method.Spec };
+                               type = method.Parent.Definition;
+                               InstanceExpression = new CompilerGeneratedThis (type, Location);
+                               return base.DoResolve (ec);
+                       }
+               }
+
+               class DynamicFieldExpr : FieldExpr
+               {
+                       readonly Field field;
+
+                       public DynamicFieldExpr (Field field, Location loc)
+                               : base (loc)
+                       {
+                               this.field = field;
+                       }
+
+                       protected override Expression DoResolve (ResolveContext ec)
+                       {
+                               spec = field.Spec;
+                               type = spec.MemberType;
+                               InstanceExpression = new CompilerGeneratedThis (type, Location);
+                               return base.DoResolve (ec);
+                       }
+               }
+
                public readonly Iterator Iterator;
 
                TypeExpr iterator_type_expr;
                Field pc_field;
                Field current_field;
-               MethodInfo dispose_method;
 
                TypeExpr enumerator_type;
                TypeExpr enumerable_type;
                TypeArguments generic_args;
                TypeExpr generic_enumerator_type;
-#if GMCS_SOURCE                
                TypeExpr generic_enumerable_type;
-#endif
-               
-               public IteratorHost (Iterator iterator)
-                       : base (iterator.Container.Toplevel, iterator.Host, iterator.GenericMethod,
-                               iterator.Location)
-               {
-                       this.Iterator = iterator;
-               }
 
-               public override bool IsIterator {
-                       get { return true; }
-               }
+               List<HoistedParameter> hoisted_params_copy;
+               int local_name_idx;
 
-               public MethodInfo Dispose {
-                       get { return dispose_method; }
+               public IteratorStorey (Iterator iterator)
+                       : base (iterator.Container.ParametersBlock, iterator.Host,
+                         iterator.OriginalMethod as MemberBase, iterator.GenericMethod == null ? null : iterator.GenericMethod.CurrentTypeParameters, "Iterator")
+               {
+                       this.Iterator = iterator;
                }
 
                public Field PC {
@@ -158,31 +338,31 @@ namespace Mono.CSharp {
                        get { return current_field; }
                }
 
-               public Type IteratorType {
-                       get { return iterator_type_expr.Type; }
+               public IList<HoistedParameter> HoistedParameters {
+                       get { return hoisted_params; }
                }
 
-               public override TypeExpr [] GetClassBases (out TypeExpr base_class)
+               protected override TypeExpr [] ResolveBaseTypes (out TypeExpr base_class)
                {
-                       iterator_type_expr = InflateType (Iterator.OriginalIteratorType);
+                       var mtype = Iterator.OriginalIteratorType;
+                       if (Mutator != null)
+                               mtype = Mutator.Mutate (mtype);
 
-#if GMCS_SOURCE
-                       generic_args = new TypeArguments (Location);
-                       generic_args.Add (iterator_type_expr);
-#endif
+                       iterator_type_expr = new TypeExpression (mtype, Location);
+                       generic_args = new TypeArguments (iterator_type_expr);
 
-                       ArrayList list = new ArrayList ();
+                       var list = new List<FullNamedExpression> ();
                        if (Iterator.IsEnumerable) {
                                enumerable_type = new TypeExpression (
                                        TypeManager.ienumerable_type, Location);
                                list.Add (enumerable_type);
 
-#if GMCS_SOURCE
-                               generic_enumerable_type = new ConstructedType (
-                                       TypeManager.generic_ienumerable_type,
-                                       generic_args, Location);
-                               list.Add (generic_enumerable_type);
-#endif
+                               if (TypeManager.generic_ienumerable_type != null) {
+                                       generic_enumerable_type = new GenericTypeExpr (
+                                               TypeManager.generic_ienumerable_type,
+                                               generic_args, Location);
+                                       list.Add (generic_enumerable_type);
+                               }
                        }
 
                        enumerator_type = new TypeExpression (
@@ -191,418 +371,193 @@ namespace Mono.CSharp {
 
                        list.Add (new TypeExpression (TypeManager.idisposable_type, Location));
 
-#if GMCS_SOURCE
-                       generic_enumerator_type = new ConstructedType (
-                               TypeManager.generic_ienumerator_type,
-                               generic_args, Location);
-                       list.Add (generic_enumerator_type);
-#endif
+                       if (TypeManager.generic_ienumerator_type != null) {
+                               generic_enumerator_type = new GenericTypeExpr (
+                                       TypeManager.generic_ienumerator_type,
+                                       generic_args, Location);
+                               list.Add (generic_enumerator_type);
+                       }
 
                        type_bases = list;
 
-                       return base.GetClassBases (out base_class);
+                       return base.ResolveBaseTypes (out base_class);
                }
 
-               protected override bool DoResolveMembers ()
+               protected override string GetVariableMangledName (LocalVariable local_info)
                {
-                       pc_field = CaptureVariable ("$PC", TypeManager.system_int32_expr);
-                       current_field = CaptureVariable ("$current", iterator_type_expr);
-
-#if GMCS_SOURCE
-                       Define_Current (true);
-#endif
-                       Define_Current (false);
-                       new DisposeMethod (this);
-                       Define_Reset ();
-
-                       if (Iterator.IsEnumerable) {
-                               new GetEnumeratorMethod (this, false);
-#if GMCS_SOURCE
-                               new GetEnumeratorMethod (this, true);
-#endif
-                       }
-
-                       return base.DoResolveMembers ();
+                       return "<" + local_info.Name + ">__" + local_name_idx++.ToString ();
                }
 
-               public void CaptureScopes ()
+               protected override bool DoDefineMembers ()
                {
-                       Report.Debug (128, "DEFINE ITERATOR HOST", this, scopes);
-
-                       foreach (ScopeInfo si in scopes)
-                               CaptureScope (si);
-
-                       foreach (ScopeInfo si in scopes) {
-                               if (!si.Define ())
-                                       throw new InternalErrorException ();
-                               if (si.DefineType () == null)
-                                       throw new InternalErrorException ();
-                               if (!si.ResolveType ())
-                                       throw new InternalErrorException ();
-                               if (!si.ResolveMembers ())
-                                       throw new InternalErrorException ();
-                               if (!si.DefineMembers ())
-                                       throw new InternalErrorException ();
-                       }
+                       DefineIteratorMembers ();
+                       return base.DoDefineMembers ();
                }
 
-               protected override bool DoDefineMembers ()
+               void DefineIteratorMembers ()
                {
-                       if (!base.DoDefineMembers ())
-                               return false;
+                       pc_field = AddCompilerGeneratedField ("$PC", new TypeExpression (TypeManager.int32_type, Location));
+                       current_field = AddCompilerGeneratedField ("$current", iterator_type_expr);
 
-                       FetchMethodDispose ();
+                       if (hoisted_params != null) {
+                               //
+                               // Iterators are independent, each GetEnumerator call has to
+                               // create same enumerator therefore we have to keep original values
+                               // around for re-initialization
+                               //
+                               // TODO: Do it for assigned/modified parameters only
+                               //
+                               hoisted_params_copy = new List<HoistedParameter> (hoisted_params.Count);
+                               foreach (HoistedParameter hp in hoisted_params) {
+                                       hoisted_params_copy.Add (new HoistedParameter (hp, "<$>" + hp.Field.Name));
+                               }
+                       }
 
-                       return true;
-               }
+                       if (generic_enumerator_type != null)
+                               Define_Current (true);
 
-               protected override void EmitScopeConstructor (EmitContext ec)
-               {
-                       ec.ig.Emit (OpCodes.Ldarg_0);
-                       ec.ig.Emit (OpCodes.Ldarg_1);
-                       ec.ig.Emit (OpCodes.Stfld, pc_field.FieldBuilder);
-                       base.EmitScopeConstructor (ec);
+                       Define_Current (false);
+                       new DisposeMethod (this);
+                       Define_Reset ();
+
+                       if (Iterator.IsEnumerable) {
+                               MemberName name = new MemberName (QualifiedAliasMember.GlobalAlias, "System", null, Location);
+                               name = new MemberName (name, "Collections", Location);
+                               name = new MemberName (name, "IEnumerable", Location);
+                               name = new MemberName (name, "GetEnumerator", Location);
+
+                               if (generic_enumerator_type != null) {
+                                       Method get_enumerator = new IteratorMethod (this, enumerator_type, 0, name);
+
+                                       name = new MemberName (name.Left.Left, "Generic", Location);
+                                       name = new MemberName (name, "IEnumerable", generic_args, Location);
+                                       name = new MemberName (name, "GetEnumerator", Location);
+                                       Method gget_enumerator = new GetEnumeratorMethod (this, generic_enumerator_type, name);
+
+                                       //
+                                       // Just call generic GetEnumerator implementation
+                                       //
+                                       get_enumerator.Block.AddStatement (
+                                               new Return (new Invocation (new DynamicMethodGroupExpr (gget_enumerator, Location), null), Location));
+
+                                       AddMethod (get_enumerator);
+                                       AddMethod (gget_enumerator);
+                               } else {
+                                       AddMethod (new GetEnumeratorMethod (this, enumerator_type, name));
+                               }
+                       }
                }
 
-               void FetchMethodDispose ()
+               protected override void EmitHoistedParameters (EmitContext ec, IList<HoistedParameter> hoisted)
                {
-                       MemberList dispose_list;
-
-                       dispose_list = FindMembers (
-                               CurrentType != null ? CurrentType : TypeBuilder,
-                               MemberTypes.Method, BindingFlags.Public | BindingFlags.Instance,
-                               Type.FilterName, "Dispose");
-
-                       if (dispose_list.Count != 1)
-                               throw new InternalErrorException ("Cannot find Dipose() method.");
-
-                       dispose_method = (MethodInfo) dispose_list [0];
+                       base.EmitHoistedParameters (ec, hoisted);
+                       base.EmitHoistedParameters (ec, hoisted_params_copy);
                }
 
                void Define_Current (bool is_generic)
                {
-                       MemberName left;
                        TypeExpr type;
 
+                       MemberName name = new MemberName (QualifiedAliasMember.GlobalAlias, "System", null, Location);
+                       name = new MemberName (name, "Collections", Location);
+
                        if (is_generic) {
-                               left = new MemberName (
-                                       "System.Collections.Generic.IEnumerator",
-                                       generic_args, Location);
+                               name = new MemberName (name, "Generic", Location);
+                               name = new MemberName (name, "IEnumerator", generic_args, Location);
                                type = iterator_type_expr;
                        } else {
-                               left = new MemberName ("System.Collections.IEnumerator", Location);
-                               type = TypeManager.system_object_expr;
+                               name = new MemberName (name, "IEnumerator");
+                               type = new TypeExpression (TypeManager.object_type, Location);
                        }
 
-                       MemberName name = new MemberName (left, "Current", null, Location);
-
-                       ToplevelBlock get_block = new ToplevelBlock (Location);
-                       get_block.AddStatement (new CurrentBlock (this, is_generic));
+                       name = new MemberName (name, "Current", Location);
 
-                       Accessor getter = new Accessor (get_block, 0, null, Location);
+                       ToplevelBlock get_block = new ToplevelBlock (Compiler, Location);
+                       get_block.AddStatement (new Return (new DynamicFieldExpr (CurrentField, Location), Location));
+                               
+                       Property current = new Property (this, type, Modifiers.DEBUGGER_HIDDEN, name, null);
+                       current.Get = new Property.GetMethod (current, 0, null, Location);
+                       current.Get.Block = get_block;
 
-                       Property current = new Property (
-                               this, type, 0, false, name, null, getter, null, false);
-                       current.ModFlags |= Modifiers.DEBUGGER_HIDDEN;
                        AddProperty (current);
                }
 
                void Define_Reset ()
                {
                        Method reset = new Method (
-                               this, null, TypeManager.system_void_expr,
+                               this, null, new TypeExpression (TypeManager.void_type, Location),
                                Modifiers.PUBLIC | Modifiers.DEBUGGER_HIDDEN,
-                               false, new MemberName ("Reset", Location),
-                               Parameters.EmptyReadOnlyParameters, null);
+                               new MemberName ("Reset", Location),
+                               ParametersCompiled.EmptyReadOnlyParameters, null);
                        AddMethod (reset);
 
-                       reset.Block = new ToplevelBlock (Location);
-                       reset.Block.AddStatement (Create_ThrowNotSupported ());
-               }
-
-               Statement Create_ThrowNotSupported ()
-               {
-                       TypeExpr ex_type = new TypeLookupExpression ("System.NotSupportedException");
+                       reset.Block = new ToplevelBlock (Compiler, Location);
 
-                       return new Throw (new New (ex_type, null, Location), Location);
-               }
+                       TypeSpec ex_type = TypeManager.CoreLookupType (Compiler, "System", "NotSupportedException", MemberKind.Class, true);
+                       if (ex_type == null)
+                               return;
 
-               protected override ScopeInitializer CreateScopeInitializer ()
-               {
-                       return new IteratorHostInitializer (this);
+                       reset.Block.AddStatement (new Throw (new New (new TypeExpression (ex_type, Location), null, Location), Location));
                }
+       }
 
-               protected class IteratorHostInitializer : RootScopeInitializer
-               {
-                       new public readonly IteratorHost Host;
-                       protected Iterator.State state;
-
-                       public IteratorHostInitializer (IteratorHost host)
-                               : base (host)
-                       {
-                               this.Host = host;
-                       }
-
-                       protected override bool DoResolveInternal (EmitContext ec)
-                       {
-                               if (this is EnumeratorScopeInitializer)
-                                       state = Iterator.State.Start;
-                               else if (Host.Iterator.IsEnumerable)
-                                       state = Iterator.State.Uninitialized;
-                               else
-                                       state = Iterator.State.Start;
-
-                               return base.DoResolveInternal (ec);
-                       }
-
-                       protected override void EmitScopeConstructor (EmitContext ec)
-                       {
-                               ec.ig.Emit (OpCodes.Ldc_I4, (int) state);
-                               base.EmitScopeConstructor (ec);
-                       }
-               }
+       class IteratorMethod : Method
+       {
+               readonly IteratorStorey host;
 
-               protected class GetEnumeratorMethod : Method
+               public IteratorMethod (IteratorStorey host, FullNamedExpression returnType, Modifiers mod, MemberName name)
+                       : base (host, null, returnType, mod | Modifiers.COMPILER_GENERATED,
+                         name, ParametersCompiled.EmptyReadOnlyParameters, null)
                {
-                       public IteratorHost Host;
-
-                       static MemberName GetMemberName (IteratorHost host, bool is_generic)
-                       {
-                               MemberName left;
-                               if (is_generic) {
-                                       left = new MemberName (
-                                               "System.Collections.Generic.IEnumerable",
-                                               host.generic_args, host.Location);
-                               } else {
-                                       left = new MemberName (
-                                               "System.Collections.IEnumerable", host.Location);
-                               }
-
-                               return new MemberName (left, "GetEnumerator", host.Location);
-                       }
-
-                       public GetEnumeratorMethod (IteratorHost host, bool is_generic)
-                               : base (host, null, is_generic ?
-                                       host.generic_enumerator_type : host.enumerator_type,
-                                       Modifiers.DEBUGGER_HIDDEN, false, GetMemberName (host, is_generic),
-                                       Parameters.EmptyReadOnlyParameters, null)
-                       {
-                               this.Host = host;
-
-                               host.AddMethod (this);
-
-                               Block = new ToplevelBlock (host.Iterator.Container.Toplevel, null, Location);
-                               Block.AddStatement (new GetEnumeratorStatement (host, type_name));
-                       }
-
-                       public override EmitContext CreateEmitContext (DeclSpace tc, ILGenerator ig)
-                       {
-                               EmitContext ec = new EmitContext (
-                                       this, tc, this.ds, Location, ig, MemberType, ModFlags, false);
-
-                               ec.CurrentAnonymousMethod = Host.Iterator;
-                               return ec;
-                       }
-
-                       protected class GetEnumeratorStatement : Statement
-                       {
-                               IteratorHost host;
-                               Expression type;
-
-                               ExpressionStatement initializer;
-                               Expression cast;
-                               MethodInfo ce;
-
-                               public GetEnumeratorStatement (IteratorHost host, Expression type)
-                               {
-                                       this.host = host;
-                                       this.type = type;
-                                       loc = host.Location;
-                               }
-
-                               public override bool Resolve (EmitContext ec)
-                               {
-                                       type = type.ResolveAsTypeTerminal (ec, false);
-                                       if ((type == null) || (type.Type == null))
-                                               return false;
-
-                                       initializer = host.GetEnumeratorInitializer (ec);
-                                       if (initializer == null)
-                                               return false;
-
-                                       cast = new ClassCast (initializer, type.Type);
-
-                                       if (TypeManager.int_interlocked_compare_exchange == null) {
-                                               Type t = TypeManager.CoreLookupType ("System.Threading", "Interlocked", Kind.Class, true);
-                                               if (t != null) {
-                                                       TypeManager.int_interlocked_compare_exchange = TypeManager.GetPredefinedMethod (
-                                                               t, "CompareExchange", loc, TypeManager.GetReferenceType (TypeManager.int32_type),
-                                                               TypeManager.int32_type, TypeManager.int32_type);
-                                               }
-                                       }
-
-                                       ce = TypeManager.int_interlocked_compare_exchange;
-
-                                       ec.CurrentBranching.CurrentUsageVector.Goto ();
-                                       return true;
-                               }
+                       this.host = host;
 
-                               protected override void DoEmit (EmitContext ec)
-                               {
-                                       ILGenerator ig = ec.ig;
-                                       Label label_init = ig.DefineLabel ();
-
-                                       ig.Emit (OpCodes.Ldarg_0);
-                                       ig.Emit (OpCodes.Ldflda, host.PC.FieldBuilder);
-                                       ig.Emit (OpCodes.Ldc_I4, (int) Iterator.State.Start);
-                                       ig.Emit (OpCodes.Ldc_I4, (int) Iterator.State.Uninitialized);
-                                       ig.Emit (OpCodes.Call, ce);
-
-                                       ig.Emit (OpCodes.Ldc_I4, (int) Iterator.State.Uninitialized);
-                                       ig.Emit (OpCodes.Bne_Un, label_init);
-
-                                       ig.Emit (OpCodes.Ldarg_0);
-                                       ig.Emit (OpCodes.Ret);
-
-                                       ig.MarkLabel (label_init);
-
-                                       initializer.EmitStatement (ec);
-                                       cast.Emit (ec);
-                                       ig.Emit (OpCodes.Ret);
-                               }
-                       }
+                       Block = new ToplevelBlock (host.Compiler, ParametersCompiled.EmptyReadOnlyParameters, Location);
                }
 
-               protected class DisposeMethod : Method
+               public override EmitContext CreateEmitContext (ILGenerator ig)
                {
-                       public IteratorHost Host;
-
-                       public DisposeMethod (IteratorHost host)
-                               : base (host, null, TypeManager.system_void_expr,
-                                       Modifiers.PUBLIC | Modifiers.DEBUGGER_HIDDEN,
-                                       false, new MemberName ("Dispose", host.Location),
-                                       Parameters.EmptyReadOnlyParameters, null)
-                       {
-                               this.Host = host;
-
-                               host.AddMethod (this);
-
-                               Block = new ToplevelBlock (host.Iterator.Block, null, Location);
-                               Block.AddStatement (new DisposeMethodStatement (Host.Iterator));
-
-                               Report.Debug (64, "DISPOSE METHOD", host, Block);
-                       }
-
-                       public override EmitContext CreateEmitContext (DeclSpace tc, ILGenerator ig)
-                       {
-                               EmitContext ec = new EmitContext (
-                                       this, tc, this.ds, Location, ig, MemberType, ModFlags, false);
-
-                               ec.CurrentAnonymousMethod = Host.Iterator;
-                               return ec;
-                       }
-
-                       protected class DisposeMethodStatement : Statement
-                       {
-                               Iterator iterator;
+                       EmitContext ec = new EmitContext (this, ig, MemberType);
 
-                               public DisposeMethodStatement (Iterator iterator)
-                               {
-                                       this.iterator = iterator;
-                                       this.loc = iterator.Location;
-                               }
-
-                               public override bool Resolve (EmitContext ec)
-                               {
-                                       return true;
-                               }
-
-                               protected override void DoEmit (EmitContext ec)
-                               {
-                                       iterator.EmitDispose (ec);
-                               }
-                       }
-               }
-
-               protected ScopeInitializer GetEnumeratorInitializer (EmitContext ec)
-               {
-                       ScopeInitializer init = new EnumeratorScopeInitializer (this);
-                       if (init.Resolve (ec) == null)
-                               throw new InternalErrorException ();
-                       return init;
+                       ec.CurrentAnonymousMethod = host.Iterator;
+                       return ec;
                }
+       }
 
-               protected class EnumeratorScopeInitializer : IteratorHostInitializer
+       //
+       // Iterators are implemented as hidden anonymous block
+       //
+       public class Iterator : AnonymousExpression
+       {
+               sealed class MoveNextMethodStatement : Statement
                {
-                       IteratorHost host;
+                       Iterator iterator;
 
-                       public EnumeratorScopeInitializer (IteratorHost host)
-                               : base (host)
+                       public MoveNextMethodStatement (Iterator iterator)
                        {
-                               this.host = host;
+                               this.iterator = iterator;
+                               this.loc = iterator.Location;
                        }
 
-                       protected override bool DoResolveInternal (EmitContext ec)
+                       protected override void CloneTo (CloneContext clonectx, Statement target)
                        {
-                               type = host.IsGeneric ? host.CurrentType : host.TypeBuilder;
-                               return base.DoResolveInternal (ec);
+                               throw new NotSupportedException ();
                        }
 
-                       protected override void DoEmit (EmitContext ec)
+                       public override bool Resolve (BlockContext ec)
                        {
-                               DoEmitInstance (ec);
-                       }
-
-                       protected override bool IsGetEnumerator {
-                               get { return true; }
-                       }
-
-                       protected override void EmitParameterReference (EmitContext ec,
-                                                                       CapturedParameter cp)
-                       {
-                               ec.ig.Emit (OpCodes.Ldarg_0);
-                               ec.ig.Emit (OpCodes.Ldfld, cp.Field.FieldBuilder);
-                       }
-               }
-
-               protected class CurrentBlock : Statement {
-                       IteratorHost host;
-                       bool is_generic;
-
-                       public CurrentBlock (IteratorHost host, bool is_generic)
-                       {
-                               this.host = host;
-                               this.is_generic = is_generic;
-                               loc = host.Location;
-                       }
-
-                       public override bool Resolve (EmitContext ec)
-                       {
-                               // We emit a 'ret', so prevent the enclosing TopLevelBlock from emitting one too
-                               ec.CurrentBranching.CurrentUsageVector.Goto ();
                                return true;
                        }
 
                        protected override void DoEmit (EmitContext ec)
                        {
-                               ILGenerator ig = ec.ig;
-
-                               ig.Emit (OpCodes.Ldarg_0);
-                               ig.Emit (OpCodes.Ldfld, host.CurrentField.FieldBuilder);
-                               if (!is_generic)
-                                       ig.Emit (OpCodes.Box, host.CurrentField.MemberType);
-                               ig.Emit (OpCodes.Ret);
+                               iterator.EmitMoveNext (ec);
                        }
                }
-       }
-
-       public class Iterator : AnonymousContainer {
-               protected readonly ToplevelBlock OriginalBlock;
-               protected readonly IMethodData OriginalMethod;
-               protected ToplevelBlock block;
 
+               public readonly IMethodData OriginalMethod;
+               public readonly TypeContainer Host;
                public readonly bool IsEnumerable;
-               public readonly bool IsStatic;
+               List<ResumableStatement> resume_points;
 
                //
                // The state as we generate the iterator
@@ -618,8 +573,17 @@ namespace Mono.CSharp {
                        get { return current_pc; }
                }
 
-               public readonly Type OriginalIteratorType;
-               public readonly IteratorHost IteratorHost;
+               public Block Container {
+                       get { return OriginalMethod.Block; }
+               }
+
+               public GenericMethod GenericMethod {
+                       get { return OriginalMethod.GenericMethod; }
+               }
+
+               public readonly TypeSpec OriginalIteratorType;
+
+               IteratorStorey IteratorHost;
 
                public enum State {
                        Running = -3, // Used only in CurrentPC, never stored into $PC
@@ -628,107 +592,101 @@ namespace Mono.CSharp {
                        Start = 0
                }
 
-               public void EmitYieldBreak (ILGenerator ig, bool unwind_protect)
+               public void EmitYieldBreak (EmitContext ec, bool unwind_protect)
                {
-                       ig.Emit (unwind_protect ? OpCodes.Leave : OpCodes.Br, move_next_error);
+                       ec.Emit (unwind_protect ? OpCodes.Leave : OpCodes.Br, move_next_error);
                }
 
                void EmitMoveNext_NoResumePoints (EmitContext ec, Block original_block)
                {
-                       ILGenerator ig = ec.ig;
+                       ec.Emit (OpCodes.Ldarg_0);
+                       ec.Emit (OpCodes.Ldfld, IteratorHost.PC.Spec);
 
-                       ig.Emit (OpCodes.Ldarg_0);
-                       ig.Emit (OpCodes.Ldfld, IteratorHost.PC.FieldBuilder);
-
-                       ig.Emit (OpCodes.Ldarg_0);
-                       IntConstant.EmitInt (ig, (int) State.After);
-                       ig.Emit (OpCodes.Stfld, IteratorHost.PC.FieldBuilder);
+                       ec.Emit (OpCodes.Ldarg_0);
+                       ec.EmitInt ((int) State.After);
+                       ec.Emit (OpCodes.Stfld, IteratorHost.PC.Spec);
 
                        // We only care if the PC is zero (start executing) or non-zero (don't do anything)
-                       ig.Emit (OpCodes.Brtrue, move_next_error);
+                       ec.Emit (OpCodes.Brtrue, move_next_error);
 
-                       SymbolWriter.StartIteratorBody (ec.ig);
+                       SymbolWriter.StartIteratorBody (ec);
                        original_block.Emit (ec);
-                       SymbolWriter.EndIteratorBody (ec.ig);
+                       SymbolWriter.EndIteratorBody (ec);
 
-                       ig.MarkLabel (move_next_error);
-                       ig.Emit (OpCodes.Ldc_I4_0);
-                       ig.Emit (OpCodes.Ret);
+                       ec.MarkLabel (move_next_error);
+                       ec.Emit (OpCodes.Ldc_I4_0);
+                       ec.Emit (OpCodes.Ret);
                }
 
-               internal void EmitMoveNext (EmitContext ec, Block original_block)
+               void EmitMoveNext (EmitContext ec)
                {
-                       ILGenerator ig = ec.ig;
-
-                       move_next_ok = ig.DefineLabel ();
-                       move_next_error = ig.DefineLabel ();
+                       move_next_ok = ec.DefineLabel ();
+                       move_next_error = ec.DefineLabel ();
 
                        if (resume_points == null) {
-                               EmitMoveNext_NoResumePoints (ec, original_block);
+                               EmitMoveNext_NoResumePoints (ec, block);
                                return;
                        }
 
                        current_pc = ec.GetTemporaryLocal (TypeManager.uint32_type);
-                       ig.Emit (OpCodes.Ldarg_0);
-                       ig.Emit (OpCodes.Ldfld, IteratorHost.PC.FieldBuilder);
-                       ig.Emit (OpCodes.Stloc, current_pc);
+                       ec.Emit (OpCodes.Ldarg_0);
+                       ec.Emit (OpCodes.Ldfld, IteratorHost.PC.Spec);
+                       ec.Emit (OpCodes.Stloc, current_pc);
 
                        // We're actually in state 'running', but this is as good a PC value as any if there's an abnormal exit
-                       ig.Emit (OpCodes.Ldarg_0);
-                       IntConstant.EmitInt (ig, (int) State.After);
-                       ig.Emit (OpCodes.Stfld, IteratorHost.PC.FieldBuilder);
+                       ec.Emit (OpCodes.Ldarg_0);
+                       ec.EmitInt ((int) State.After);
+                       ec.Emit (OpCodes.Stfld, IteratorHost.PC.Spec);
 
                        Label [] labels = new Label [1 + resume_points.Count];
-                       labels [0] = ig.DefineLabel ();
+                       labels [0] = ec.DefineLabel ();
 
                        bool need_skip_finally = false;
                        for (int i = 0; i < resume_points.Count; ++i) {
-                               ResumableStatement s = (ResumableStatement) resume_points [i];
+                               ResumableStatement s = resume_points [i];
                                need_skip_finally |= s is ExceptionStatement;
                                labels [i+1] = s.PrepareForEmit (ec);
                        }
 
                        if (need_skip_finally) {
                                skip_finally = ec.GetTemporaryLocal (TypeManager.bool_type);
-                               ig.Emit (OpCodes.Ldc_I4_0);
-                               ig.Emit (OpCodes.Stloc, skip_finally);
+                               ec.Emit (OpCodes.Ldc_I4_0);
+                               ec.Emit (OpCodes.Stloc, skip_finally);
                        }
 
-                       SymbolWriter.StartIteratorDispatcher (ec.ig);
-                       ig.Emit (OpCodes.Ldloc, current_pc);
-                       ig.Emit (OpCodes.Switch, labels);
+                       SymbolWriter.StartIteratorDispatcher (ec);
+                       ec.Emit (OpCodes.Ldloc, current_pc);
+                       ec.Emit (OpCodes.Switch, labels);
 
-                       ig.Emit (OpCodes.Br, move_next_error);
-                       SymbolWriter.EndIteratorDispatcher (ec.ig);
+                       ec.Emit (OpCodes.Br, move_next_error);
+                       SymbolWriter.EndIteratorDispatcher (ec);
 
-                       ig.MarkLabel (labels [0]);
+                       ec.MarkLabel (labels [0]);
 
-                       SymbolWriter.StartIteratorBody (ec.ig);
-                       original_block.Emit (ec);
-                       SymbolWriter.EndIteratorBody (ec.ig);
+                       SymbolWriter.StartIteratorBody (ec);
+                       block.Emit (ec);
+                       SymbolWriter.EndIteratorBody (ec);
 
-                       SymbolWriter.StartIteratorDispatcher (ec.ig);
+                       SymbolWriter.StartIteratorDispatcher (ec);
 
-                       ig.Emit (OpCodes.Ldarg_0);
-                       IntConstant.EmitInt (ig, (int) State.After);
-                       ig.Emit (OpCodes.Stfld, IteratorHost.PC.FieldBuilder);
+                       ec.Emit (OpCodes.Ldarg_0);
+                       ec.EmitInt ((int) State.After);
+                       ec.Emit (OpCodes.Stfld, IteratorHost.PC.Spec);
 
-                       ig.MarkLabel (move_next_error);
-                       ig.Emit (OpCodes.Ldc_I4_0);
-                       ig.Emit (OpCodes.Ret);
+                       ec.MarkLabel (move_next_error);
+                       ec.EmitInt (0);
+                       ec.Emit (OpCodes.Ret);
 
-                       ig.MarkLabel (move_next_ok);
-                       ig.Emit (OpCodes.Ldc_I4_1);
-                       ig.Emit (OpCodes.Ret);
+                       ec.MarkLabel (move_next_ok);
+                       ec.Emit (OpCodes.Ldc_I4_1);
+                       ec.Emit (OpCodes.Ret);
 
-                       SymbolWriter.EndIteratorDispatcher (ec.ig);
+                       SymbolWriter.EndIteratorDispatcher (ec);
                }
 
                public void EmitDispose (EmitContext ec)
                {
-                       ILGenerator ig = ec.ig;
-
-                       Label end = ig.DefineLabel ();
+                       Label end = ec.DefineLabel ();
 
                        Label [] labels = null;
                        int n_resume_points = resume_points == null ? 0 : resume_points.Count;
@@ -747,33 +705,33 @@ namespace Mono.CSharp {
 
                        if (labels != null) {
                                current_pc = ec.GetTemporaryLocal (TypeManager.uint32_type);
-                               ig.Emit (OpCodes.Ldarg_0);
-                               ig.Emit (OpCodes.Ldfld, IteratorHost.PC.FieldBuilder);
-                               ig.Emit (OpCodes.Stloc, current_pc);
+                               ec.Emit (OpCodes.Ldarg_0);
+                               ec.Emit (OpCodes.Ldfld, IteratorHost.PC.Spec);
+                               ec.Emit (OpCodes.Stloc, current_pc);
                        }
 
-                       ig.Emit (OpCodes.Ldarg_0);
-                       IntConstant.EmitInt (ig, (int) State.After);
-                       ig.Emit (OpCodes.Stfld, IteratorHost.PC.FieldBuilder);
+                       ec.Emit (OpCodes.Ldarg_0);
+                       ec.EmitInt ((int) State.After);
+                       ec.Emit (OpCodes.Stfld, IteratorHost.PC.Spec);
 
                        if (labels != null) {
                                //SymbolWriter.StartIteratorDispatcher (ec.ig);
-                               ig.Emit (OpCodes.Ldloc, current_pc);
-                               ig.Emit (OpCodes.Switch, labels);
+                               ec.Emit (OpCodes.Ldloc, current_pc);
+                               ec.Emit (OpCodes.Switch, labels);
                                //SymbolWriter.EndIteratorDispatcher (ec.ig);
 
                                foreach (ResumableStatement s in resume_points)
                                        s.EmitForDispose (ec, this, end, true);
                        }
 
-                       ig.MarkLabel (end);
+                       ec.MarkLabel (end);
                }
 
-               ArrayList resume_points;
-               public int AddResumePoint (ResumableStatement stmt, Location loc)
+               public int AddResumePoint (ResumableStatement stmt)
                {
                        if (resume_points == null)
-                               resume_points = new ArrayList ();
+                               resume_points = new List<ResumableStatement> ();
+
                        resume_points.Add (stmt);
                        return resume_points.Count;
                }
@@ -783,88 +741,51 @@ namespace Mono.CSharp {
                //
                public void MarkYield (EmitContext ec, Expression expr, int resume_pc, bool unwind_protect, Label resume_point)
                {
-                       ILGenerator ig = ec.ig;
-
                        // Store the new current
-                       ig.Emit (OpCodes.Ldarg_0);
+                       ec.Emit (OpCodes.Ldarg_0);
                        expr.Emit (ec);
-                       ig.Emit (OpCodes.Stfld, IteratorHost.CurrentField.FieldBuilder);
+                       ec.Emit (OpCodes.Stfld, IteratorHost.CurrentField.Spec);
 
                        // store resume program-counter
-                       ig.Emit (OpCodes.Ldarg_0);
-                       IntConstant.EmitInt (ig, resume_pc);
-                       ig.Emit (OpCodes.Stfld, IteratorHost.PC.FieldBuilder);
+                       ec.Emit (OpCodes.Ldarg_0);
+                       ec.EmitInt (resume_pc);
+                       ec.Emit (OpCodes.Stfld, IteratorHost.PC.Spec);
 
                        // mark finally blocks as disabled
                        if (unwind_protect && skip_finally != null) {
-                               ig.Emit (OpCodes.Ldc_I4_1);
-                               ig.Emit (OpCodes.Stloc, skip_finally);
+                               ec.EmitInt (1);
+                               ec.Emit (OpCodes.Stloc, skip_finally);
                        }
 
                        // Return ok
-                       ig.Emit (unwind_protect ? OpCodes.Leave : OpCodes.Br, move_next_ok);
-
-                       ig.MarkLabel (resume_point);
-               }
-
-               public override string ContainerType {
-                       get { return "iterator"; }
-               }
-
-               public override bool IsIterator {
-                       get { return true; }
-               }
+                       ec.Emit (unwind_protect ? OpCodes.Leave : OpCodes.Br, move_next_ok);
 
-               public override RootScopeInfo RootScope {
-                       get { return IteratorHost; }
-               }
-
-               public override ScopeInfo Scope {
-                       get { return IteratorHost; }
+                       ec.MarkLabel (resume_point);
                }
 
                //
                // Our constructor
                //
-               private Iterator (IMethodData m_container, DeclSpace host, GenericMethod generic,
-                                int modifiers, Type iterator_type, bool is_enumerable)
-                       : base (host, generic, m_container.ParameterInfo,
-                               new ToplevelBlock (m_container.ParameterInfo, m_container.Location),
-                               m_container.Block, TypeManager.bool_type, modifiers,
-                               m_container.Location)
+               public Iterator (ParametersBlock block, IMethodData method, TypeContainer host, TypeSpec iterator_type, bool is_enumerable)
+                       : base (block, TypeManager.bool_type, block.StartLocation)
                {
-                       this.OriginalBlock = m_container.Block;
-                       this.OriginalMethod = m_container;
+                       this.OriginalMethod = method;
                        this.OriginalIteratorType = iterator_type;
                        this.IsEnumerable = is_enumerable;
+                       this.Host = host;
+                       this.type = method.ReturnType;
+               }
 
-                       Report.Debug (64, "NEW ITERATOR", host, generic, OriginalBlock,
-                                     Container, Block);
-
-                       IteratorHost = new IteratorHost (this);
-                       Block.CreateIteratorHost (IteratorHost);
-
-                       OriginalBlock.ReParent (Container.Toplevel);
-
-                       m_container.Block = Container.Toplevel;
-
-                       OriginalBlock.MakeIterator (this);
+               public override string ContainerType {
+                       get { return "iterator"; }
                }
 
-               protected class TestStatement : Statement
-               {
-                       public override bool Resolve (EmitContext ec)
-                       {
-                               return true;
-                       }
+               public override bool IsIterator {
+                       get { return true; }
+               }
 
-                       protected override void DoEmit (EmitContext ec)
-                       {
-                               ec.ig.Emit (OpCodes.Nop);
-                               ec.ig.Emit (OpCodes.Neg);
-                               ec.ig.Emit (OpCodes.Pop);
-                               ec.ig.Emit (OpCodes.Ret);
-                       }
+               public override AnonymousMethodStorey Storey {
+                       get { return IteratorHost; }
                }
 
                public override string GetSignatureForError ()
@@ -872,144 +793,104 @@ namespace Mono.CSharp {
                        return OriginalMethod.GetSignatureForError ();
                }
 
-               public override bool Define (EmitContext ec)
+               protected override Expression DoResolve (ResolveContext ec)
                {
-                       Report.Debug (64, "RESOLVE ITERATOR", this, Container, Block);
-
-                       Parameters parameters = OriginalMethod.ParameterInfo;
-                       for (int i = 0; i < parameters.Count; i++){
-                               Parameter.Modifier mod = parameters.ParameterModifier (i);
-                               if ((mod & (Parameter.Modifier.REF | Parameter.Modifier.OUT)) != 0){
-                                       Report.Error (1623, Location,
-                                                     "Iterators cannot have ref or out parameters");
-                                       return false;
-                               }
+                       IteratorHost = (IteratorStorey) block.TopBlock.AnonymousMethodStorey;
 
-                               if ((mod & Parameter.Modifier.ARGLIST) != 0) {
-                                       Report.Error (1636, Location,
-                                                     "__arglist is not allowed in parameter list " +
-                                                     "of iterators");
-                                       return false;
-                               }
+                       BlockContext ctx = new BlockContext (ec, block, ReturnType);
+                       ctx.CurrentAnonymousMethod = this;
 
-                               if (parameters.ParameterType (i).IsPointer) {
-                                       Report.Error (1637, Location,
-                                                     "Iterators cannot have unsafe parameters or " +
-                                                     "yield types");
-                                       return false;
-                               }
-                       }
+                       ctx.StartFlowBranching (this, ec.CurrentBranching);
+                       Block.Resolve (ctx);
+                       ctx.EndFlowBranching ();
 
-                       if ((ModFlags & Modifiers.UNSAFE) != 0) {
-                               Report.Error (1629, Location, "Unsafe code may not appear in iterators");
-                               return false;
-                       }
-
-                       if (!base.Define (ec))
-                               return false;
+                       var move_next = new IteratorMethod (IteratorHost, new TypeExpression (TypeManager.bool_type, loc),
+                               Modifiers.PUBLIC, new MemberName ("MoveNext", Location));
+                       move_next.Block.AddStatement (new MoveNextMethodStatement (this));
+                       IteratorHost.AddMethod (move_next);
 
-                       Report.Debug (64, "RESOLVE ITERATOR #1", this, method, method.Parent,
-                                     RootScope, ec);
-
-                       if (!RootScope.ResolveType ())
-                               return false;
-                       if (!RootScope.ResolveMembers ())
-                               return false;
-                       if (!RootScope.DefineMembers ())
-                               return false;
-
-                       ExpressionStatement scope_init = RootScope.GetScopeInitializer (ec);
-                       Container.AddStatement (new StatementExpression (scope_init));
-                       Expression cast = new ClassCast (scope_init, OriginalMethod.ReturnType);
-                       Container.AddStatement (new NoCheckReturn (cast));
-
-                       return true;
-               }
-
-               protected override Method DoCreateMethodHost (EmitContext ec)
-               {
-                       Report.Debug (128, "CREATE METHOD HOST", this, IteratorHost);
-
-                       MemberCore mc = ec.ResolveContext as MemberCore;
-
-                       IteratorHost.CaptureScopes ();
-
-                       return new AnonymousMethodMethod (
-                               this, RootScope, null, TypeManager.system_boolean_expr,
-                               Modifiers.PUBLIC, mc.GetSignatureForError (),
-                               new MemberName ("MoveNext", Location),
-                               Parameters.EmptyReadOnlyParameters);
+                       eclass = ExprClass.Value;
+                       return this;
                }
 
-               public override Expression DoResolve (EmitContext ec)
+               public override void Emit (EmitContext ec)
                {
-                       throw new NotSupportedException ();
-               }
-
-               public Type IteratorType {
-                       get { return IteratorHost.IteratorType; }
-               }
-
-               //
-               // This return statement tricks return into not flagging an error for being
-               // used in a Yields method
-               //
-               class NoCheckReturn : Statement {
-                       public Expression Expr;
-               
-                       public NoCheckReturn (Expression expr)
-                       {
-                               Expr = expr;
-                               loc = expr.Location;
-                       }
-
-                       public override bool Resolve (EmitContext ec)
-                       {
-                               Expr = Expr.Resolve (ec);
-                               if (Expr == null)
-                                       return false;
+                       //
+                       // Load Iterator storey instance
+                       //
+                       IteratorHost.Instance.Emit (ec);
 
-                               ec.CurrentBranching.CurrentUsageVector.Goto ();
+                       //
+                       // Initialize iterator PC when it's unitialized
+                       //
+                       if (IsEnumerable) {
+                               ec.Emit (OpCodes.Dup);
+                               ec.EmitInt ((int)State.Uninitialized);
 
-                               return true;
-                       }
+                               var field = IteratorHost.PC.Spec;
+                               if (Storey.MemberName.IsGeneric) {
+                                       field = MemberCache.GetMember (Storey.Instance.Type, field);
+                               }
 
-                       protected override void DoEmit (EmitContext ec)
-                       {
-                               Expr.Emit (ec);
-                               ec.ig.Emit (OpCodes.Ret);
+                               ec.Emit (OpCodes.Stfld, field);
                        }
                }
 
-               public override Expression CreateExpressionTree (EmitContext ec)
+               public override Expression CreateExpressionTree (ResolveContext ec)
                {
                        throw new NotSupportedException ("ET");
                }
 
-               public static Iterator CreateIterator (IMethodData method, DeclSpace parent,
-                                                      GenericMethod generic, int modifiers)
+               public static void CreateIterator (IMethodData method, TypeContainer parent, Modifiers modifiers, CompilerContext ctx)
                {
                        bool is_enumerable;
-                       Type iterator_type;
+                       TypeSpec iterator_type;
 
-                       Type ret = method.ReturnType;
+                       TypeSpec ret = method.ReturnType;
                        if (ret == null)
-                               return null;
+                               return;
 
                        if (!CheckType (ret, out iterator_type, out is_enumerable)) {
-                               Report.Error (1624, method.Location,
+                               ctx.Report.Error (1624, method.Location,
                                              "The body of `{0}' cannot be an iterator block " +
                                              "because `{1}' is not an iterator interface type",
                                              method.GetSignatureForError (),
                                              TypeManager.CSharpName (ret));
-                               return null;
+                               return;
                        }
 
-                       return new Iterator (method, parent, generic, modifiers,
-                                            iterator_type, is_enumerable);
+                       ParametersCompiled parameters = method.ParameterInfo;
+                       for (int i = 0; i < parameters.Count; i++) {
+                               Parameter p = parameters [i];
+                               Parameter.Modifier mod = p.ModFlags;
+                               if ((mod & Parameter.Modifier.ISBYREF) != 0) {
+                                       ctx.Report.Error (1623, p.Location,
+                                               "Iterators cannot have ref or out parameters");
+                                       return;
+                               }
+
+                               if (p is ArglistParameter) {
+                                       ctx.Report.Error (1636, method.Location,
+                                               "__arglist is not allowed in parameter list of iterators");
+                                       return;
+                               }
+
+                               if (parameters.Types [i].IsPointer) {
+                                       ctx.Report.Error (1637, p.Location,
+                                                         "Iterators cannot have unsafe parameters or " +
+                                                         "yield types");
+                                       return;
+                               }
+                       }
+
+                       if ((modifiers & Modifiers.UNSAFE) != 0) {
+                               ctx.Report.Error (1629, method.Location, "Unsafe code may not appear in iterators");
+                       }
+
+                       method.Block.WrapIntoIterator (method, parent, iterator_type, is_enumerable);
                }
 
-               static bool CheckType (Type ret, out Type original_iterator_type, out bool is_enumerable)
+               static bool CheckType (TypeSpec ret, out TypeSpec original_iterator_type, out bool is_enumerable)
                {
                        original_iterator_type = null;
                        is_enumerable = false;
@@ -1025,25 +906,22 @@ namespace Mono.CSharp {
                                return true;
                        }
 
-#if GMCS_SOURCE
-                       if (!ret.IsGenericType)
+                       InflatedTypeSpec inflated = ret as InflatedTypeSpec;
+                       if (inflated == null)
                                return false;
 
-                       Type[] args = TypeManager.GetTypeArguments (ret);
-                       if (args.Length != 1)
-                               return false;
-
-                       Type gt = ret.GetGenericTypeDefinition ();
-                       if (gt == TypeManager.generic_ienumerable_type) {
-                               original_iterator_type = args [0];
+                       ret = inflated.GetDefinition ();
+                       if (ret == TypeManager.generic_ienumerable_type) {
+                               original_iterator_type = inflated.TypeArguments[0];
                                is_enumerable = true;
                                return true;
-                       } else if (gt == TypeManager.generic_ienumerator_type) {
-                               original_iterator_type = args [0];
+                       }
+                       
+                       if (ret == TypeManager.generic_ienumerator_type) {
+                               original_iterator_type = inflated.TypeArguments[0];
                                is_enumerable = false;
                                return true;
                        }
-#endif
 
                        return false;
                }