X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fiterators.cs;h=cbf983c856f35415037a809edd3143a6dcc8a7ee;hb=732841a4f171062563a831fb8cd3165be1ddfd6e;hp=c659678a52c50f3e9585de8066ab5498cda067ba;hpb=739c1b4b78d643395d7558ebd5ee986c49084ef2;p=mono.git

diff --git a/mcs/mcs/iterators.cs b/mcs/mcs/iterators.cs
index c659678a52c..cbf983c856f 100644
--- a/mcs/mcs/iterators.cs
+++ b/mcs/mcs/iterators.cs
@@ -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,14 @@ 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 +48,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 +58,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,520 +88,490 @@ 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)
 		{
-			return Yield.CheckContext (ec, loc, true);
+			throw new NotSupportedException ();
+		}
+
+		protected override bool DoResolve (BlockContext ec)
+		{
+			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
+	//
+	// Wraps method block into iterator wrapper block
+	//
+	class IteratorStatement : Statement
 	{
-		public readonly Iterator Iterator;
+		Iterator iterator;
+		Block original_block;
 
-		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)
+		public IteratorStatement (Iterator iterator, Block original_block)
 		{
-			this.Iterator = iterator;
-		}
-
-		public override bool IsIterator {
-			get { return true; }
-		}
-
-		public MethodInfo Dispose {
-			get { return dispose_method; }
+			this.iterator = iterator;
+			this.original_block = original_block;
+			this.loc = iterator.Location;
 		}
 
-		public Field PC {
-			get { return pc_field; }
+		protected override void CloneTo (CloneContext clonectx, Statement target)
+		{
+			IteratorStatement t = (IteratorStatement) target;
+			t.original_block = (ExplicitBlock) original_block.Clone (clonectx);
+			t.iterator = (Iterator) iterator.Clone (clonectx);
 		}
 
-		public Field CurrentField {
-			get { return current_field; }
+		public override bool Resolve (BlockContext ec)
+		{
+			ec.StartFlowBranching (iterator);
+			bool ok = original_block.Resolve (ec);
+			ec.EndFlowBranching ();
+			return ok;
 		}
 
-		public Type IteratorType {
-			get { return iterator_type_expr.Type; }
+		protected override void DoEmit (EmitContext ec)
+		{
+			iterator.EmitMoveNext (ec, original_block);
 		}
+	}
 
-		public override TypeExpr [] GetClassBases (out TypeExpr base_class)
+	public class IteratorStorey : AnonymousMethodStorey
+	{
+		class IteratorMethod : Method
 		{
-			iterator_type_expr = InflateType (Iterator.OriginalIteratorType);
-
-#if GMCS_SOURCE
-			generic_args = new TypeArguments (Location);
-			generic_args.Add (iterator_type_expr);
-#endif
+			readonly IteratorStorey host;
 
-			ArrayList list = new ArrayList ();
-			if (Iterator.IsEnumerable) {
-				enumerable_type = new TypeExpression (
-					TypeManager.ienumerable_type, Location);
-				list.Add (enumerable_type);
+			public IteratorMethod (IteratorStorey host, FullNamedExpression returnType, Modifiers mod, MemberName name)
+				: base (host, null, returnType, mod | Modifiers.DEBUGGER_HIDDEN | Modifiers.COMPILER_GENERATED,
+				  name, ParametersCompiled.EmptyReadOnlyParameters, null)
+			{
+				this.host = host;
 
-#if GMCS_SOURCE
-				generic_enumerable_type = new ConstructedType (
-					TypeManager.generic_ienumerable_type,
-					generic_args, Location);
-				list.Add (generic_enumerable_type);
-#endif
+				Block = new ToplevelBlock (Compiler, host.Iterator.Container.Toplevel, ParametersCompiled.EmptyReadOnlyParameters, Location);
 			}
 
-			enumerator_type = new TypeExpression (
-				TypeManager.ienumerator_type, Location);
-			list.Add (enumerator_type);
-
-			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
-
-			type_bases = list;
+			public override EmitContext CreateEmitContext (ILGenerator ig)
+			{
+				EmitContext ec = new EmitContext (this, ig, MemberType);
 
-			return base.GetClassBases (out base_class);
+				ec.CurrentAnonymousMethod = host.Iterator;
+				return ec;
+			}
 		}
 
-		protected override bool DoResolveMembers ()
+		class GetEnumeratorMethod : IteratorMethod
 		{
-			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 ();
+			sealed class GetEnumeratorStatement : Statement
+			{
+				IteratorStorey host;
+				IteratorMethod host_method;
 
-			if (Iterator.IsEnumerable) {
-				new GetEnumeratorMethod (this, false);
-#if GMCS_SOURCE
-				new GetEnumeratorMethod (this, true);
-#endif
-			}
+				Expression new_storey;
 
-			return base.DoResolveMembers ();
-		}
+				public GetEnumeratorStatement (IteratorStorey host, IteratorMethod host_method)
+				{
+					this.host = host;
+					this.host_method = host_method;
+					loc = host_method.Location;
+				}
 
-		public void CaptureScopes ()
-		{
-			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 ();
-			}
-		}
+				protected override void CloneTo (CloneContext clonectx, Statement target)
+				{
+					throw new NotSupportedException ();
+				}
 
-		protected override bool DoDefineMembers ()
-		{
-			if (!base.DoDefineMembers ())
-				return false;
+				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));
+					}
 
-			FetchMethodDispose ();
+					if (host.hoisted_params != null) {
+						if (init == null)
+							init = new List<Expression> (host.HoistedParameters.Count);
 
-			return true;
-		}
+						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];
 
-		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);
-		}
+							FieldExpr from = new FieldExpr (hp_cp.Field, loc);
+							from.InstanceExpression = CompilerGeneratedThis.Instance;
 
-		void FetchMethodDispose ()
-		{
-			MemberList dispose_list;
+							init.Add (new ElementInitializer (hp.Field.Name, from, loc));
+						}
+					}
 
-			dispose_list = FindMembers (
-				CurrentType != null ? CurrentType : TypeBuilder,
-				MemberTypes.Method, BindingFlags.Public | BindingFlags.Instance,
-				Type.FilterName, "Dispose");
+					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);
+					}
 
-			if (dispose_list.Count != 1)
-				throw new InternalErrorException ("Cannot find Dipose() method.");
+					new_storey = new_storey.Resolve (ec);
+					if (new_storey != null)
+						new_storey = Convert.ImplicitConversionRequired (ec, new_storey, host_method.MemberType, loc);
 
-			dispose_method = (MethodInfo) dispose_list [0];
-		}
+					if (TypeManager.int_interlocked_compare_exchange == null) {
+						TypeSpec t = TypeManager.CoreLookupType (ec.Compiler, "System.Threading", "Interlocked", MemberKind.Class, true);
+						if (t != null) {
+							var p = ParametersCompiled.CreateFullyResolved (
+								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
+								}
+								);
+							var f = new MemberFilter ("CompareExchange", 0, MemberKind.Method, p, TypeManager.int32_type);
+							TypeManager.int_interlocked_compare_exchange = TypeManager.GetPredefinedMethod (t, f, loc);
+						}
+					}
 
-		void Define_Current (bool is_generic)
-		{
-			MemberName left;
-			TypeExpr type;
+					ec.CurrentBranching.CurrentUsageVector.Goto ();
+					return true;
+				}
 
-			if (is_generic) {
-				left = new MemberName (
-					"System.Collections.Generic.IEnumerator",
-					generic_args, Location);
-				type = iterator_type_expr;
-			} else {
-				left = new MemberName ("System.Collections.IEnumerator", Location);
-				type = TypeManager.system_object_expr;
-			}
+				protected override void DoEmit (EmitContext ec)
+				{
+					Label label_init = ec.DefineLabel ();
 
-			MemberName name = new MemberName (left, "Current", null, Location);
+					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);
 
-			ToplevelBlock get_block = new ToplevelBlock (Location);
-			get_block.AddStatement (new CurrentBlock (this, is_generic));
+					ec.EmitInt ((int) Iterator.State.Uninitialized);
+					ec.Emit (OpCodes.Bne_Un_S, label_init);
 
-			Accessor getter = new Accessor (get_block, 0, null, Location);
+					ec.Emit (OpCodes.Ldarg_0);
+					ec.Emit (OpCodes.Ret);
 
-			Property current = new Property (
-				this, type, 0, false, name, null, getter, null, false);
-			AddProperty (current);
-		}
+					ec.MarkLabel (label_init);
 
-		void Define_Reset ()
-		{
-			Method reset = new Method (
-				this, null, TypeManager.system_void_expr, Modifiers.PUBLIC,
-				false, new MemberName ("Reset", Location),
-				Parameters.EmptyReadOnlyParameters, null);
-			AddMethod (reset);
+					new_storey.Emit (ec);
+					ec.Emit (OpCodes.Ret);
+				}
+			}
 
-			reset.Block = new ToplevelBlock (Location);
-			reset.Block.AddStatement (Create_ThrowNotSupported ());
+			public GetEnumeratorMethod (IteratorStorey host, FullNamedExpression returnType, MemberName name)
+				: base (host, returnType, 0, name)
+			{
+				Block.AddStatement (new GetEnumeratorStatement (host, this));
+			}
 		}
 
-		Statement Create_ThrowNotSupported ()
+		class DisposeMethod : IteratorMethod
 		{
-			TypeExpr ex_type = new TypeLookupExpression ("System.NotSupportedException");
+			sealed class DisposeMethodStatement : Statement
+			{
+				Iterator iterator;
 
-			return new Throw (new New (ex_type, null, Location), Location);
-		}
+				public DisposeMethodStatement (Iterator iterator)
+				{
+					this.iterator = iterator;
+					this.loc = iterator.Location;
+				}
 
-		protected override ScopeInitializer CreateScopeInitializer ()
-		{
-			return new IteratorHostInitializer (this);
-		}
+				protected override void CloneTo (CloneContext clonectx, Statement target)
+				{
+					throw new NotSupportedException ();
+				}
 
-		protected class IteratorHostInitializer : RootScopeInitializer
-		{
-			new public readonly IteratorHost Host;
-			protected Iterator.State state;
+				public override bool Resolve (BlockContext ec)
+				{
+					return true;
+				}
 
-			public IteratorHostInitializer (IteratorHost host)
-				: base (host)
-			{
-				this.Host = host;
+				protected override void DoEmit (EmitContext ec)
+				{
+					iterator.EmitDispose (ec);
+				}
 			}
 
-			protected override bool DoResolveInternal (EmitContext ec)
+			public DisposeMethod (IteratorStorey host)
+				: base (host, TypeManager.system_void_expr, Modifiers.PUBLIC, new MemberName ("Dispose", host.Location))
 			{
-				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);
-			}
+				host.AddMethod (this);
 
-			protected override void EmitScopeConstructor (EmitContext ec)
-			{
-				ec.ig.Emit (OpCodes.Ldc_I4, (int) state);
-				base.EmitScopeConstructor (ec);
+				Block = new ToplevelBlock (Compiler, host.Iterator.Container, ParametersCompiled.EmptyReadOnlyParameters, Location);
+				Block.AddStatement (new DisposeMethodStatement (host.Iterator));
 			}
 		}
 
-		protected class GetEnumeratorMethod : Method
+		//
+		// Uses Method as method info
+		//
+		class DynamicMethodGroupExpr : MethodGroupExpr
 		{
-			public IteratorHost Host;
+			readonly Method method;
 
-			static MemberName GetMemberName (IteratorHost host, bool is_generic)
+			public DynamicMethodGroupExpr (Method method, Location loc)
+				: base (null, loc)
 			{
-				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);
+				this.method = method;
+				eclass = ExprClass.Unresolved;
 			}
 
-			public GetEnumeratorMethod (IteratorHost host, bool is_generic)
-				: base (host, null, is_generic ?
-					host.generic_enumerator_type : host.enumerator_type,
-					0, false, GetMemberName (host, is_generic),
-					Parameters.EmptyReadOnlyParameters, null)
+			protected override Expression DoResolve (ResolveContext ec)
 			{
-				this.Host = host;
-
-				host.AddMethod (this);
-
-				Block = new ToplevelBlock (host.Iterator.Container.Toplevel, null, Location);
-				Block.AddStatement (new GetEnumeratorStatement (host, type_name));
+				Methods = new List<MemberSpec> (1) { method.Spec };
+				type = method.Parent.Definition;
+				InstanceExpression = new CompilerGeneratedThis (type, Location);
+				return base.DoResolve (ec);
 			}
+		}
 
-			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;
-			}
+		class DynamicFieldExpr : FieldExpr
+		{
+			readonly Field field;
 
-			public override void EmitExtraSymbolInfo (SourceMethod source)
+			public DynamicFieldExpr (Field field, Location loc)
+				: base (loc)
 			{
-				source.SetCompilerGenerated ();
+				this.field = field;
 			}
 
-			protected class GetEnumeratorStatement : Statement
+			protected override Expression DoResolve (ResolveContext ec)
 			{
-				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;
-				}
+				spec = field.Spec;
+				type = spec.MemberType;
+				InstanceExpression = new CompilerGeneratedThis (type, Location);
+				return base.DoResolve (ec);
+			}
+		}
 
-				public override bool Resolve (EmitContext ec)
-				{
-					type = type.ResolveAsTypeTerminal (ec, false);
-					if ((type == null) || (type.Type == null))
-						return false;
+		public readonly Iterator Iterator;
 
-					initializer = host.GetEnumeratorInitializer (ec);
-					if (initializer == null)
-						return false;
+		TypeExpr iterator_type_expr;
+		Field pc_field;
+		Field current_field;
 
-					cast = new ClassCast (initializer, type.Type);
+		TypeExpr enumerator_type;
+		TypeExpr enumerable_type;
+		TypeArguments generic_args;
+		TypeExpr generic_enumerator_type;
+		TypeExpr generic_enumerable_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);
-						}
-					}
+		List<HoistedParameter> hoisted_params_copy;
+		int local_name_idx;
 
-					ce = TypeManager.int_interlocked_compare_exchange;
+		public IteratorStorey (Iterator iterator)
+			: base (iterator.Container.Toplevel, iterator.Host,
+			  iterator.OriginalMethod as MemberBase, iterator.GenericMethod, "Iterator")
+		{
+			this.Iterator = iterator;
+		}
 
-					ec.CurrentBranching.CurrentUsageVector.Goto ();
-					return true;
-				}
+		public Field PC {
+			get { return pc_field; }
+		}
 
-				protected override void DoEmit (EmitContext ec)
-				{
-					ILGenerator ig = ec.ig;
-					Label label_init = ig.DefineLabel ();
+		public Field CurrentField {
+			get { return current_field; }
+		}
 
-					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);
+		public IList<HoistedParameter> HoistedParameters {
+			get { return hoisted_params; }
+		}
 
-					ig.Emit (OpCodes.Ldc_I4, (int) Iterator.State.Uninitialized);
-					ig.Emit (OpCodes.Bne_Un, label_init);
+		protected override TypeExpr [] ResolveBaseTypes (out TypeExpr base_class)
+		{
+			var mtype = Iterator.OriginalIteratorType;
+			if (Mutator != null)
+				mtype = Mutator.Mutate (mtype);
 
-					ig.Emit (OpCodes.Ldarg_0);
-					ig.Emit (OpCodes.Ret);
+			iterator_type_expr = new TypeExpression (mtype, Location);
+			generic_args = new TypeArguments (iterator_type_expr);
 
-					ig.MarkLabel (label_init);
+			var list = new List<FullNamedExpression> ();
+			if (Iterator.IsEnumerable) {
+				enumerable_type = new TypeExpression (
+					TypeManager.ienumerable_type, Location);
+				list.Add (enumerable_type);
 
-					initializer.EmitStatement (ec);
-					cast.Emit (ec);
-					ig.Emit (OpCodes.Ret);
+				if (TypeManager.generic_ienumerable_type != null) {
+					generic_enumerable_type = new GenericTypeExpr (
+						TypeManager.generic_ienumerable_type,
+						generic_args, Location);
+					list.Add (generic_enumerable_type);
 				}
 			}
-		}
-
-		protected class DisposeMethod : Method
-		{
-			public IteratorHost Host;
 
-			public DisposeMethod (IteratorHost host)
-				: base (host, null, TypeManager.system_void_expr, Modifiers.PUBLIC,
-					false, new MemberName ("Dispose", host.Location),
-					Parameters.EmptyReadOnlyParameters, null)
-			{
-				this.Host = host;
-
-				host.AddMethod (this);
+			enumerator_type = new TypeExpression (
+				TypeManager.ienumerator_type, Location);
+			list.Add (enumerator_type);
 
-				Block = new ToplevelBlock (host.Iterator.Block, null, Location);
-				Block.AddStatement (new DisposeMethodStatement (Host.Iterator));
+			list.Add (new TypeExpression (TypeManager.idisposable_type, Location));
 
-				Report.Debug (64, "DISPOSE METHOD", host, Block);
+			if (TypeManager.generic_ienumerator_type != null) {
+				generic_enumerator_type = new GenericTypeExpr (
+					TypeManager.generic_ienumerator_type,
+					generic_args, Location);
+				list.Add (generic_enumerator_type);
 			}
 
-			public override EmitContext CreateEmitContext (DeclSpace tc, ILGenerator ig)
-			{
-				EmitContext ec = new EmitContext (
-					this, tc, this.ds, Location, ig, MemberType, ModFlags, false);
+			type_bases = list;
 
-				ec.CurrentAnonymousMethod = Host.Iterator;
-				return ec;
-			}
+			return base.ResolveBaseTypes (out base_class);
+		}
 
-			public override void EmitExtraSymbolInfo (SourceMethod source)
-			{
-				source.SetCompilerGenerated ();
-			}
+		protected override string GetVariableMangledName (LocalInfo local_info)
+		{
+			return "<" + local_info.Name + ">__" + local_name_idx++.ToString ();
+		}
 
-			protected class DisposeMethodStatement : Statement
-			{
-				Iterator iterator;
+		protected override bool DoDefineMembers ()
+		{
+			DefineIteratorMembers ();
+			return base.DoDefineMembers ();
+		}
 
-				public DisposeMethodStatement (Iterator iterator)
-				{
-					this.iterator = iterator;
-					this.loc = iterator.Location;
-				}
+		void DefineIteratorMembers ()
+		{
+			pc_field = AddCompilerGeneratedField ("$PC", TypeManager.system_int32_expr);
+			current_field = AddCompilerGeneratedField ("$current", iterator_type_expr);
 
-				public override bool Resolve (EmitContext ec)
-				{
-					return true;
+			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));
 				}
+			}
 
-				protected override void DoEmit (EmitContext ec)
-				{
-					iterator.EmitDispose (ec);
+			if (generic_enumerator_type != null)
+				Define_Current (true);
+
+			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));
 				}
 			}
 		}
 
-		protected ScopeInitializer GetEnumeratorInitializer (EmitContext ec)
+		protected override void EmitHoistedParameters (EmitContext ec, IList<HoistedParameter> hoisted)
 		{
-			ScopeInitializer init = new EnumeratorScopeInitializer (this);
-			if (init.Resolve (ec) == null)
-				throw new InternalErrorException ();
-			return init;
+			base.EmitHoistedParameters (ec, hoisted);
+			base.EmitHoistedParameters (ec, hoisted_params_copy);
 		}
 
-		protected class EnumeratorScopeInitializer : IteratorHostInitializer
+		void Define_Current (bool is_generic)
 		{
-			IteratorHost host;
+			TypeExpr type;
 
-			public EnumeratorScopeInitializer (IteratorHost host)
-				: base (host)
-			{
-				this.host = host;
-			}
+			MemberName name = new MemberName (QualifiedAliasMember.GlobalAlias, "System", null, Location);
+			name = new MemberName (name, "Collections", Location);
 
-			protected override bool DoResolveInternal (EmitContext ec)
-			{
-				type = host.IsGeneric ? host.CurrentType : host.TypeBuilder;
-				return base.DoResolveInternal (ec);
+			if (is_generic) {
+				name = new MemberName (name, "Generic", Location);
+				name = new MemberName (name, "IEnumerator", generic_args, Location);
+				type = iterator_type_expr;
+			} else {
+				name = new MemberName (name, "IEnumerator");
+				type = TypeManager.system_object_expr;
 			}
 
-			protected override void DoEmit (EmitContext ec)
-			{
-				DoEmitInstance (ec);
-			}
+			name = new MemberName (name, "Current", Location);
 
-			protected override bool IsGetEnumerator {
-				get { return true; }
-			}
+			ToplevelBlock get_block = new ToplevelBlock (Compiler, Location);
+			get_block.AddStatement (new Return (new DynamicFieldExpr (CurrentField, Location), Location));
+				
+			Accessor getter = new Accessor (get_block, 0, null, null, Location);
 
-			protected override void EmitParameterReference (EmitContext ec,
-									CapturedParameter cp)
-			{
-				ec.ig.Emit (OpCodes.Ldarg_0);
-				ec.ig.Emit (OpCodes.Ldfld, cp.Field.FieldBuilder);
-			}
+			Property current = new Property (
+				this, type, Modifiers.DEBUGGER_HIDDEN, name, null, getter, null, false);
+			AddProperty (current);
 		}
 
-		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;
-			}
+		void Define_Reset ()
+		{
+			Method reset = new Method (
+				this, null, TypeManager.system_void_expr,
+				Modifiers.PUBLIC | Modifiers.DEBUGGER_HIDDEN,
+				new MemberName ("Reset", Location),
+				ParametersCompiled.EmptyReadOnlyParameters, null);
+			AddMethod (reset);
 
-			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;
-			}
+			reset.Block = new ToplevelBlock (Compiler, Location);
 
-			protected override void DoEmit (EmitContext ec)
-			{
-				ILGenerator ig = ec.ig;
+			TypeSpec ex_type = TypeManager.CoreLookupType (Compiler, "System", "NotSupportedException", MemberKind.Class, true);
+			if (ex_type == null)
+				return;
 
-				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);
-			}
+			reset.Block.AddStatement (new Throw (new New (new TypeExpression (ex_type, Location), null, Location), Location));
 		}
 	}
 
-	public class Iterator : AnonymousContainer {
-		protected readonly ToplevelBlock OriginalBlock;
-		protected readonly IMethodData OriginalMethod;
-		protected ToplevelBlock block;
-
+	//
+	// Iterators are implemented as hidden anonymous block
+	//
+	public class Iterator : AnonymousExpression {
+		public readonly IMethodData OriginalMethod;
+		AnonymousMethodMethod method;
+		public readonly TypeContainer Host;
 		public readonly bool IsEnumerable;
-		public readonly bool IsStatic;
+		List<ResumableStatement> resume_points;
 
 		//
 		// The state as we generate the iterator
@@ -625,8 +587,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;
+
+		readonly IteratorStorey IteratorHost;
 
 		public enum State {
 			Running = -3, // Used only in CurrentPC, never stored into $PC
@@ -635,40 +606,36 @@ 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;
-
-			ig.Emit (OpCodes.Ldarg_0);
-			ig.Emit (OpCodes.Ldfld, IteratorHost.PC.FieldBuilder);
+			ec.Emit (OpCodes.Ldarg_0);
+			ec.Emit (OpCodes.Ldfld, IteratorHost.PC.Spec);
 
-			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)
 		{
-			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);
@@ -676,66 +643,64 @@ namespace Mono.CSharp {
 			}
 
 			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);
+			SymbolWriter.StartIteratorBody (ec);
 			original_block.Emit (ec);
-			SymbolWriter.EndIteratorBody (ec.ig);
+			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;
@@ -754,33 +719,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;
 		}
@@ -790,28 +755,26 @@ 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);
+			ec.Emit (unwind_protect ? OpCodes.Leave : OpCodes.Br, move_next_ok);
 
-			ig.MarkLabel (resume_point);
+			ec.MarkLabel (resume_point);
 		}
 
 		public override string ContainerType {
@@ -822,56 +785,26 @@ namespace Mono.CSharp {
 			get { return true; }
 		}
 
-		public override RootScopeInfo RootScope {
-			get { return IteratorHost; }
-		}
-
-		public override ScopeInfo Scope {
+		public override AnonymousMethodStorey Storey {
 			get { return IteratorHost; }
 		}
 
 		//
 		// 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)
+		private Iterator (CompilerContext ctx, IMethodData method, TypeContainer host, TypeSpec iterator_type, bool is_enumerable)
+			: base (
+				new ToplevelBlock (ctx, method.Block, ParametersCompiled.EmptyReadOnlyParameters, method.Block.StartLocation),
+				TypeManager.bool_type,
+				method.Location)
 		{
-			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);
-		}
-
-		protected class TestStatement : Statement
-		{
-			public override bool Resolve (EmitContext ec)
-			{
-				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);
-			}
+			IteratorHost = Block.ChangeToIterator (this, method.Block);
 		}
 
 		public override string GetSignatureForError ()
@@ -879,144 +812,101 @@ namespace Mono.CSharp {
 			return OriginalMethod.GetSignatureForError ();
 		}
 
-		public override bool Define (EmitContext 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;
-				}
-
-				if ((mod & Parameter.Modifier.ARGLIST) != 0) {
-					Report.Error (1636, Location,
-						      "__arglist is not allowed in parameter list " +
-						      "of iterators");
-					return false;
-				}
-
-				if (parameters.ParameterType (i).IsPointer) {
-					Report.Error (1637, Location,
-						      "Iterators cannot have unsafe parameters or " +
-						      "yield types");
-					return false;
-				}
-			}
-
-			if ((ModFlags & Modifiers.UNSAFE) != 0) {
-				Report.Error (1629, Location, "Unsafe code may not appear in iterators");
-				return false;
-			}
-
-			if (!base.Define (ec))
-				return false;
-
-			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)
+		protected override Expression DoResolve (ResolveContext 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 (),
+			method = new AnonymousMethodMethod (Storey,
+				this, Storey, null, TypeManager.system_boolean_expr,
+				Modifiers.PUBLIC, OriginalMethod.GetSignatureForError (),
 				new MemberName ("MoveNext", Location),
-				Parameters.EmptyReadOnlyParameters);
-		}
+				ParametersCompiled.EmptyReadOnlyParameters);
 
-		public override Expression DoResolve (EmitContext ec)
-		{
-			throw new NotSupportedException ();
-		}
+			if (Compatible (ec) == null)
+				return null;
 
-		public Type IteratorType {
-			get { return IteratorHost.IteratorType; }
+			eclass = ExprClass.Value;
+			return this;
 		}
 
-		//
-		// 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;
+		public override void Emit (EmitContext ec)
+		{
+			//
+			// Load Iterator storey instance
+			//
+			method.Storey.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");
+				return;
+			}
+
+			// TODO: Ugly leftover
+			new Iterator (ctx, 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;
@@ -1032,25 +922,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;
 		}