← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to contrib/ICSharpCode.NRefactory.CSharp/Parser/mcs/iterators.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
contrib/ICSharpCode.NRefactory.CSharp/Parser/mcs/iterators.cs
1
 
//
2
 
// iterators.cs: Support for implementing iterators
3
 
//
4
 
// Author:
5
 
//   Miguel de Icaza (miguel@ximian.com)
6
 
//   Marek Safar (marek.safar@gmail.com)
7
 
//
8
 
// Dual licensed under the terms of the MIT X11 or GNU GPL
9
 
// Copyright 2003 Ximian, Inc.
10
 
// Copyright 2003-2008 Novell, Inc.
11
 
// Copyright 2011 Xamarin Inc.
12
 
//
13
 
 
14
 
using System;
15
 
using System.Collections.Generic;
16
 
using Mono.CompilerServices.SymbolWriter;
17
 
 
18
 
#if STATIC
19
 
using IKVM.Reflection.Emit;
20
 
#else
21
 
using System.Reflection.Emit;
22
 
#endif
23
 
 
24
 
namespace Mono.CSharp
25
 
{
26
 
        public abstract class YieldStatement<T> : ResumableStatement where T : StateMachineInitializer
27
 
        {
28
 
                protected Expression expr;
29
 
                protected bool unwind_protect;
30
 
                protected T machine_initializer;
31
 
                int resume_pc;
32
 
                
33
 
                protected YieldStatement (Expression expr, Location l)
34
 
                {
35
 
                        this.expr = expr;
36
 
                        loc = l;
37
 
                }
38
 
 
39
 
                public Expression Expr {
40
 
                        get { return this.expr; }
41
 
                }
42
 
                
43
 
                protected override void CloneTo (CloneContext clonectx, Statement t)
44
 
                {
45
 
                        var target = (YieldStatement<T>) t;
46
 
                        target.expr = expr.Clone (clonectx);
47
 
                }
48
 
 
49
 
                protected override void DoEmit (EmitContext ec)
50
 
                {
51
 
                        machine_initializer.InjectYield (ec, expr, resume_pc, unwind_protect, resume_point);
52
 
                }
53
 
 
54
 
                public override bool Resolve (BlockContext bc)
55
 
                {
56
 
                        expr = expr.Resolve (bc);
57
 
                        if (expr == null)
58
 
                                return false;
59
 
 
60
 
                        machine_initializer = bc.CurrentAnonymousMethod as T;
61
 
 
62
 
                        if (!bc.CurrentBranching.CurrentUsageVector.IsUnreachable)
63
 
                                unwind_protect = bc.CurrentBranching.AddResumePoint (this, out resume_pc);
64
 
 
65
 
                        return true;
66
 
                }
67
 
        }
68
 
 
69
 
        public class Yield : YieldStatement<Iterator>
70
 
        {
71
 
                public Yield (Expression expr, Location loc)
72
 
                        : base (expr, loc)
73
 
                {
74
 
                }
75
 
 
76
 
                public static bool CheckContext (ResolveContext ec, Location loc)
77
 
                {
78
 
                        if (!ec.CurrentAnonymousMethod.IsIterator) {
79
 
                                ec.Report.Error (1621, loc,
80
 
                                        "The yield statement cannot be used inside anonymous method blocks");
81
 
                                return false;
82
 
                        }
83
 
 
84
 
                        return true;
85
 
                }
86
 
 
87
 
                public override bool Resolve (BlockContext bc)
88
 
                {
89
 
                        if (!CheckContext (bc, loc))
90
 
                                return false;
91
 
 
92
 
                        if (!base.Resolve (bc))
93
 
                                return false;
94
 
 
95
 
                        var otype = bc.CurrentIterator.OriginalIteratorType;
96
 
                        if (expr.Type != otype) {
97
 
                                expr = Convert.ImplicitConversionRequired (bc, expr, otype, loc);
98
 
                                if (expr == null)
99
 
                                        return false;
100
 
                        }
101
 
 
102
 
                        return true;
103
 
                }
104
 
                
105
 
                public override object Accept (StructuralVisitor visitor)
106
 
                {
107
 
                        return visitor.Visit (this);
108
 
                }
109
 
        }
110
 
 
111
 
        public class YieldBreak : ExitStatement
112
 
        {
113
 
                Iterator iterator;
114
 
 
115
 
                public YieldBreak (Location l)
116
 
                {
117
 
                        loc = l;
118
 
                }
119
 
 
120
 
                public override void Error_FinallyClause (Report Report)
121
 
                {
122
 
                        Report.Error (1625, loc, "Cannot yield in the body of a finally clause");
123
 
                }
124
 
 
125
 
                protected override void CloneTo (CloneContext clonectx, Statement target)
126
 
                {
127
 
                        throw new NotSupportedException ();
128
 
                }
129
 
 
130
 
                protected override bool DoResolve (BlockContext ec)
131
 
                {
132
 
                        iterator = ec.CurrentIterator;
133
 
                        return Yield.CheckContext (ec, loc);
134
 
                }
135
 
 
136
 
                protected override void DoEmit (EmitContext ec)
137
 
                {
138
 
                        iterator.EmitYieldBreak (ec, unwind_protect);
139
 
                }
140
 
                
141
 
                public override object Accept (StructuralVisitor visitor)
142
 
                {
143
 
                        return visitor.Visit (this);
144
 
                }
145
 
        }
146
 
 
147
 
        public abstract class StateMachine : AnonymousMethodStorey
148
 
        {
149
 
                public enum State
150
 
                {
151
 
                        Running = -3, // Used only in CurrentPC, never stored into $PC
152
 
                        Uninitialized = -2,
153
 
                        After = -1,
154
 
                        Start = 0
155
 
                }
156
 
 
157
 
                Field pc_field;
158
 
                StateMachineMethod method;
159
 
                int local_name_idx;
160
 
 
161
 
                protected StateMachine (ParametersBlock block, TypeDefinition parent, MemberBase host, TypeParameters tparams, string name, MemberKind kind)
162
 
                        : base (block, parent, host, tparams, name, kind)
163
 
                {
164
 
                }
165
 
 
166
 
                #region Properties
167
 
 
168
 
                public StateMachineMethod StateMachineMethod {
169
 
                        get {
170
 
                                return method;
171
 
                        }
172
 
                }
173
 
 
174
 
                public Field PC {
175
 
                        get {
176
 
                                return pc_field;
177
 
                        }
178
 
                }
179
 
 
180
 
                #endregion
181
 
 
182
 
                public void AddEntryMethod (StateMachineMethod method)
183
 
                {
184
 
                        if (this.method != null)
185
 
                                throw new InternalErrorException ();
186
 
 
187
 
                        this.method = method;
188
 
                        Members.Add (method);
189
 
                }
190
 
 
191
 
                protected override bool DoDefineMembers ()
192
 
                {
193
 
                        pc_field = AddCompilerGeneratedField ("$PC", new TypeExpression (Compiler.BuiltinTypes.Int, Location));
194
 
 
195
 
                        return base.DoDefineMembers ();
196
 
                }
197
 
 
198
 
                protected override string GetVariableMangledName (LocalVariable local_info)
199
 
                {
200
 
                        if (local_info.IsCompilerGenerated)
201
 
                                return base.GetVariableMangledName (local_info);
202
 
 
203
 
                        return "<" + local_info.Name + ">__" + local_name_idx++.ToString ("X");
204
 
                }
205
 
        }
206
 
 
207
 
        class IteratorStorey : StateMachine
208
 
        {
209
 
                class GetEnumeratorMethod : StateMachineMethod
210
 
                {
211
 
                        sealed class GetEnumeratorStatement : Statement
212
 
                        {
213
 
                                readonly IteratorStorey host;
214
 
                                readonly StateMachineMethod host_method;
215
 
 
216
 
                                Expression new_storey;
217
 
 
218
 
                                public GetEnumeratorStatement (IteratorStorey host, StateMachineMethod host_method)
219
 
                                {
220
 
                                        this.host = host;
221
 
                                        this.host_method = host_method;
222
 
                                        loc = host_method.Location;
223
 
                                }
224
 
 
225
 
                                protected override void CloneTo (CloneContext clonectx, Statement target)
226
 
                                {
227
 
                                        throw new NotSupportedException ();
228
 
                                }
229
 
 
230
 
                                public override bool Resolve (BlockContext ec)
231
 
                                {
232
 
                                        TypeExpression storey_type_expr = new TypeExpression (host.Definition, loc);
233
 
                                        List<Expression> init = null;
234
 
                                        if (host.hoisted_this != null) {
235
 
                                                init = new List<Expression> (host.hoisted_params == null ? 1 : host.HoistedParameters.Count + 1);
236
 
                                                HoistedThis ht = host.hoisted_this;
237
 
                                                FieldExpr from = new FieldExpr (ht.Field, loc);
238
 
                                                from.InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, loc);
239
 
                                                init.Add (new ElementInitializer (ht.Field.Name, from, loc));
240
 
                                        }
241
 
 
242
 
                                        if (host.hoisted_params != null) {
243
 
                                                if (init == null)
244
 
                                                        init = new List<Expression> (host.HoistedParameters.Count);
245
 
 
246
 
                                                for (int i = 0; i < host.hoisted_params.Count; ++i) {
247
 
                                                        HoistedParameter hp = host.hoisted_params [i];
248
 
                                                        HoistedParameter hp_cp = host.hoisted_params_copy [i];
249
 
 
250
 
                                                        FieldExpr from = new FieldExpr (hp_cp.Field, loc);
251
 
                                                        from.InstanceExpression = new CompilerGeneratedThis (ec.CurrentType, loc);
252
 
 
253
 
                                                        init.Add (new ElementInitializer (hp.Field.Name, from, loc));
254
 
                                                }
255
 
                                        }
256
 
 
257
 
                                        if (init != null) {
258
 
                                                new_storey = new NewInitialize (storey_type_expr, null,
259
 
                                                        new CollectionOrObjectInitializers (init, loc), loc);
260
 
                                        } else {
261
 
                                                new_storey = new New (storey_type_expr, null, loc);
262
 
                                        }
263
 
 
264
 
                                        new_storey = new_storey.Resolve (ec);
265
 
                                        if (new_storey != null)
266
 
                                                new_storey = Convert.ImplicitConversionRequired (ec, new_storey, host_method.MemberType, loc);
267
 
 
268
 
                                        ec.CurrentBranching.CurrentUsageVector.Goto ();
269
 
                                        return true;
270
 
                                }
271
 
 
272
 
                                protected override void DoEmit (EmitContext ec)
273
 
                                {
274
 
                                        Label label_init = ec.DefineLabel ();
275
 
 
276
 
                                        ec.EmitThis ();
277
 
                                        ec.Emit (OpCodes.Ldflda, host.PC.Spec);
278
 
                                        ec.EmitInt ((int) State.Start);
279
 
                                        ec.EmitInt ((int) State.Uninitialized);
280
 
 
281
 
                                        var m = ec.Module.PredefinedMembers.InterlockedCompareExchange.Resolve (loc);
282
 
                                        if (m != null)
283
 
                                                ec.Emit (OpCodes.Call, m);
284
 
 
285
 
                                        ec.EmitInt ((int) State.Uninitialized);
286
 
                                        ec.Emit (OpCodes.Bne_Un_S, label_init);
287
 
 
288
 
                                        ec.EmitThis ();
289
 
                                        ec.Emit (OpCodes.Ret);
290
 
 
291
 
                                        ec.MarkLabel (label_init);
292
 
 
293
 
                                        new_storey.Emit (ec);
294
 
                                        ec.Emit (OpCodes.Ret);
295
 
                                }
296
 
                        }
297
 
 
298
 
                        GetEnumeratorMethod (IteratorStorey host, FullNamedExpression returnType, MemberName name)
299
 
                                : base (host, null, returnType, Modifiers.DEBUGGER_HIDDEN, name)
300
 
                        {
301
 
                        }
302
 
 
303
 
                        public static GetEnumeratorMethod Create (IteratorStorey host, FullNamedExpression returnType, MemberName name)
304
 
                        {
305
 
                                return Create (host, returnType, name, null);
306
 
                        }
307
 
 
308
 
                        public static GetEnumeratorMethod Create (IteratorStorey host, FullNamedExpression returnType, MemberName name, Statement statement)
309
 
                        {
310
 
                                var m = new GetEnumeratorMethod (host, returnType, name);
311
 
                                var stmt = statement ?? new GetEnumeratorStatement (host, m);
312
 
                                m.block.AddStatement (stmt);
313
 
                                m.block.IsCompilerGenerated = true;
314
 
                                return m;
315
 
                        }
316
 
                }
317
 
 
318
 
                class DisposeMethod : StateMachineMethod
319
 
                {
320
 
                        sealed class DisposeMethodStatement : Statement
321
 
                        {
322
 
                                Iterator iterator;
323
 
 
324
 
                                public DisposeMethodStatement (Iterator iterator)
325
 
                                {
326
 
                                        this.iterator = iterator;
327
 
                                        this.loc = iterator.Location;
328
 
                                }
329
 
 
330
 
                                protected override void CloneTo (CloneContext clonectx, Statement target)
331
 
                                {
332
 
                                        throw new NotSupportedException ();
333
 
                                }
334
 
 
335
 
                                public override bool Resolve (BlockContext ec)
336
 
                                {
337
 
                                        return true;
338
 
                                }
339
 
 
340
 
                                protected override void DoEmit (EmitContext ec)
341
 
                                {
342
 
                                        ec.CurrentAnonymousMethod = iterator;
343
 
                                        iterator.EmitDispose (ec);
344
 
                                }
345
 
                        }
346
 
 
347
 
                        public DisposeMethod (IteratorStorey host)
348
 
                                : base (host, null, new TypeExpression (host.Compiler.BuiltinTypes.Void, host.Location), Modifiers.PUBLIC | Modifiers.DEBUGGER_HIDDEN,
349
 
                                        new MemberName ("Dispose", host.Location))
350
 
                        {
351
 
                                host.Members.Add (this);
352
 
 
353
 
                                Block.AddStatement (new DisposeMethodStatement (host.Iterator));
354
 
                                Block.IsCompilerGenerated = true;
355
 
                        }
356
 
                }
357
 
 
358
 
                //
359
 
                // Uses Method as method info
360
 
                //
361
 
                class DynamicMethodGroupExpr : MethodGroupExpr
362
 
                {
363
 
                        readonly Method method;
364
 
 
365
 
                        public DynamicMethodGroupExpr (Method method, Location loc)
366
 
                                : base ((IList<MemberSpec>) null, null, loc)
367
 
                        {
368
 
                                this.method = method;
369
 
                                eclass = ExprClass.Unresolved;
370
 
                        }
371
 
 
372
 
                        protected override Expression DoResolve (ResolveContext ec)
373
 
                        {
374
 
                                Methods = new List<MemberSpec> (1) { method.Spec };
375
 
                                type = method.Parent.Definition;
376
 
                                InstanceExpression = new CompilerGeneratedThis (type, Location);
377
 
                                return base.DoResolve (ec);
378
 
                        }
379
 
                }
380
 
 
381
 
                class DynamicFieldExpr : FieldExpr
382
 
                {
383
 
                        readonly Field field;
384
 
 
385
 
                        public DynamicFieldExpr (Field field, Location loc)
386
 
                                : base (loc)
387
 
                        {
388
 
                                this.field = field;
389
 
                        }
390
 
 
391
 
                        protected override Expression DoResolve (ResolveContext ec)
392
 
                        {
393
 
                                spec = field.Spec;
394
 
                                type = spec.MemberType;
395
 
                                InstanceExpression = new CompilerGeneratedThis (type, Location);
396
 
                                return base.DoResolve (ec);
397
 
                        }
398
 
                }
399
 
 
400
 
                public readonly Iterator Iterator;
401
 
 
402
 
                List<HoistedParameter> hoisted_params_copy;
403
 
 
404
 
                TypeExpr iterator_type_expr;
405
 
                Field current_field;
406
 
                Field disposing_field;
407
 
 
408
 
                TypeSpec generic_enumerator_type;
409
 
                TypeSpec generic_enumerable_type;
410
 
 
411
 
                public IteratorStorey (Iterator iterator)
412
 
                        : base (iterator.Container.ParametersBlock, iterator.Host,
413
 
                          iterator.OriginalMethod as MemberBase, iterator.OriginalMethod.CurrentTypeParameters, "Iterator", MemberKind.Class)
414
 
                {
415
 
                        this.Iterator = iterator;
416
 
                }
417
 
 
418
 
                public Field CurrentField {
419
 
                        get {
420
 
                                return current_field;
421
 
                        }
422
 
                }
423
 
 
424
 
                public Field DisposingField {
425
 
                        get {
426
 
                                return disposing_field;
427
 
                        }
428
 
                }
429
 
 
430
 
                public IList<HoistedParameter> HoistedParameters {
431
 
                        get { return hoisted_params; }
432
 
                }
433
 
 
434
 
                protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class)
435
 
                {
436
 
                        var mtype = Iterator.OriginalIteratorType;
437
 
                        if (Mutator != null)
438
 
                                mtype = Mutator.Mutate (mtype);
439
 
 
440
 
                        iterator_type_expr = new TypeExpression (mtype, Location);
441
 
 
442
 
                        var ifaces = new List<TypeSpec> (5);
443
 
                        if (Iterator.IsEnumerable) {
444
 
                                ifaces.Add (Compiler.BuiltinTypes.IEnumerable);
445
 
 
446
 
                                if (Module.PredefinedTypes.IEnumerableGeneric.Define ()) {
447
 
                                        generic_enumerable_type = Module.PredefinedTypes.IEnumerableGeneric.TypeSpec.MakeGenericType (Module, new[] { mtype });
448
 
                                        ifaces.Add (generic_enumerable_type);
449
 
                                }
450
 
                        }
451
 
 
452
 
                        ifaces.Add (Compiler.BuiltinTypes.IEnumerator);
453
 
                        ifaces.Add (Compiler.BuiltinTypes.IDisposable);
454
 
 
455
 
                        var ienumerator_generic = Module.PredefinedTypes.IEnumeratorGeneric;
456
 
                        if (ienumerator_generic.Define ()) {
457
 
                                generic_enumerator_type = ienumerator_generic.TypeSpec.MakeGenericType (Module, new [] { mtype });
458
 
                                ifaces.Add (generic_enumerator_type);
459
 
                        }
460
 
 
461
 
                        base_class = null;
462
 
 
463
 
                        base_type = Compiler.BuiltinTypes.Object;
464
 
                        return ifaces.ToArray ();
465
 
                }
466
 
 
467
 
                protected override bool DoDefineMembers ()
468
 
                {
469
 
                        current_field = AddCompilerGeneratedField ("$current", iterator_type_expr);
470
 
                        disposing_field = AddCompilerGeneratedField ("$disposing", new TypeExpression (Compiler.BuiltinTypes.Bool, Location));
471
 
 
472
 
                        if (hoisted_params != null) {
473
 
                                //
474
 
                                // Iterators are independent, each GetEnumerator call has to
475
 
                                // create same enumerator therefore we have to keep original values
476
 
                                // around for re-initialization
477
 
                                //
478
 
                                // TODO: Do it for assigned/modified parameters only
479
 
                                //
480
 
                                hoisted_params_copy = new List<HoistedParameter> (hoisted_params.Count);
481
 
                                foreach (HoistedParameter hp in hoisted_params) {
482
 
                                        hoisted_params_copy.Add (new HoistedParameter (hp, "<$>" + hp.Field.Name));
483
 
                                }
484
 
                        }
485
 
 
486
 
                        if (generic_enumerator_type != null)
487
 
                                Define_Current (true);
488
 
 
489
 
                        Define_Current (false);
490
 
                        new DisposeMethod (this);
491
 
                        Define_Reset ();
492
 
 
493
 
                        if (Iterator.IsEnumerable) {
494
 
                                FullNamedExpression explicit_iface = new TypeExpression (Compiler.BuiltinTypes.IEnumerable, Location);
495
 
                                var name = new MemberName ("GetEnumerator", null, explicit_iface, Location.Null);
496
 
 
497
 
                                if (generic_enumerator_type != null) {
498
 
                                        explicit_iface = new TypeExpression (generic_enumerable_type, Location);
499
 
                                        var gname = new MemberName ("GetEnumerator", null, explicit_iface, Location.Null);
500
 
                                        Method gget_enumerator = GetEnumeratorMethod.Create (this, new TypeExpression (generic_enumerator_type, Location), gname);
501
 
 
502
 
                                        //
503
 
                                        // Just call generic GetEnumerator implementation
504
 
                                        //
505
 
                                        var stmt = new Return (new Invocation (new DynamicMethodGroupExpr (gget_enumerator, Location), null), Location);
506
 
                                        Method get_enumerator = GetEnumeratorMethod.Create (this, new TypeExpression (Compiler.BuiltinTypes.IEnumerator, Location), name, stmt);
507
 
 
508
 
                                        Members.Add (get_enumerator);
509
 
                                        Members.Add (gget_enumerator);
510
 
                                } else {
511
 
                                        Members.Add (GetEnumeratorMethod.Create (this, new TypeExpression (Compiler.BuiltinTypes.IEnumerator, Location), name));
512
 
                                }
513
 
                        }
514
 
 
515
 
                        return base.DoDefineMembers ();
516
 
                }
517
 
 
518
 
                void Define_Current (bool is_generic)
519
 
                {
520
 
                        TypeExpr type;
521
 
                        FullNamedExpression explicit_iface;
522
 
 
523
 
                        if (is_generic) {
524
 
                                explicit_iface = new TypeExpression (generic_enumerator_type, Location);
525
 
                                type = iterator_type_expr;
526
 
                        } else {
527
 
                                explicit_iface = new TypeExpression (Module.Compiler.BuiltinTypes.IEnumerator, Location);
528
 
                                type = new TypeExpression (Compiler.BuiltinTypes.Object, Location);
529
 
                        }
530
 
 
531
 
                        var name = new MemberName ("Current", null, explicit_iface, Location);
532
 
 
533
 
                        ToplevelBlock get_block = new ToplevelBlock (Compiler, Location) {
534
 
                                IsCompilerGenerated = true
535
 
                        };
536
 
                        get_block.AddStatement (new Return (new DynamicFieldExpr (CurrentField, Location), Location));
537
 
                                
538
 
                        Property current = new Property (this, type, Modifiers.DEBUGGER_HIDDEN | Modifiers.COMPILER_GENERATED, name, null);
539
 
                        current.Get = new Property.GetMethod (current, Modifiers.COMPILER_GENERATED, null, Location);
540
 
                        current.Get.Block = get_block;
541
 
 
542
 
                        Members.Add (current);
543
 
                }
544
 
 
545
 
                void Define_Reset ()
546
 
                {
547
 
                        Method reset = new Method (
548
 
                                this, new TypeExpression (Compiler.BuiltinTypes.Void, Location),
549
 
                                Modifiers.PUBLIC | Modifiers.DEBUGGER_HIDDEN | Modifiers.COMPILER_GENERATED,
550
 
                                new MemberName ("Reset", Location),
551
 
                                ParametersCompiled.EmptyReadOnlyParameters, null);
552
 
                        Members.Add (reset);
553
 
 
554
 
                        reset.Block = new ToplevelBlock (Compiler, Location) {
555
 
                                IsCompilerGenerated = true
556
 
                        };
557
 
 
558
 
                        TypeSpec ex_type = Module.PredefinedTypes.NotSupportedException.Resolve ();
559
 
                        if (ex_type == null)
560
 
                                return;
561
 
 
562
 
                        reset.Block.AddStatement (new Throw (new New (new TypeExpression (ex_type, Location), null, Location), Location));
563
 
                }
564
 
 
565
 
                protected override void EmitHoistedParameters (EmitContext ec, List<HoistedParameter> hoisted)
566
 
                {
567
 
                        base.EmitHoistedParameters (ec, hoisted);
568
 
                        base.EmitHoistedParameters (ec, hoisted_params_copy);
569
 
                }
570
 
        }
571
 
 
572
 
        public class StateMachineMethod : Method
573
 
        {
574
 
                readonly StateMachineInitializer expr;
575
 
 
576
 
                public StateMachineMethod (StateMachine host, StateMachineInitializer expr, FullNamedExpression returnType, Modifiers mod, MemberName name)
577
 
                        : base (host, returnType, mod | Modifiers.COMPILER_GENERATED,
578
 
                          name, ParametersCompiled.EmptyReadOnlyParameters, null)
579
 
                {
580
 
                        this.expr = expr;
581
 
                        Block = new ToplevelBlock (host.Compiler, ParametersCompiled.EmptyReadOnlyParameters, Location.Null);
582
 
                }
583
 
 
584
 
                public override EmitContext CreateEmitContext (ILGenerator ig, SourceMethodBuilder sourceMethod)
585
 
                {
586
 
                        EmitContext ec = new EmitContext (this, ig, MemberType, sourceMethod);
587
 
                        ec.CurrentAnonymousMethod = expr;
588
 
 
589
 
                        if (expr is AsyncInitializer)
590
 
                                ec.With (BuilderContext.Options.AsyncBody, true);
591
 
 
592
 
                        return ec;
593
 
                }
594
 
        }
595
 
 
596
 
        public abstract class StateMachineInitializer : AnonymousExpression
597
 
        {
598
 
                sealed class MoveNextBodyStatement : Statement
599
 
                {
600
 
                        readonly StateMachineInitializer state_machine;
601
 
 
602
 
                        public MoveNextBodyStatement (StateMachineInitializer stateMachine)
603
 
                        {
604
 
                                this.state_machine = stateMachine;
605
 
                                this.loc = stateMachine.Location;
606
 
                        }
607
 
 
608
 
                        protected override void CloneTo (CloneContext clonectx, Statement target)
609
 
                        {
610
 
                                throw new NotSupportedException ();
611
 
                        }
612
 
 
613
 
                        public override bool Resolve (BlockContext ec)
614
 
                        {
615
 
                                return true;
616
 
                        }
617
 
 
618
 
                        protected override void DoEmit (EmitContext ec)
619
 
                        {
620
 
                                state_machine.EmitMoveNext (ec);
621
 
                        }
622
 
 
623
 
                        public override void Emit (EmitContext ec)
624
 
                        {
625
 
                                // Don't create sequence point
626
 
                                DoEmit (ec);
627
 
                        }
628
 
                }
629
 
 
630
 
                public readonly TypeDefinition Host;
631
 
                protected StateMachine storey;
632
 
 
633
 
                //
634
 
                // The state as we generate the machine
635
 
                //
636
 
                Label move_next_ok;
637
 
                Label iterator_body_end;
638
 
                protected Label move_next_error;
639
 
                LocalBuilder skip_finally;
640
 
                protected LocalBuilder current_pc;
641
 
                protected List<ResumableStatement> resume_points;
642
 
 
643
 
                protected StateMachineInitializer (ParametersBlock block, TypeDefinition host, TypeSpec returnType)
644
 
                        : base (block, returnType, block.StartLocation)
645
 
                {
646
 
                        this.Host = host;
647
 
                }
648
 
 
649
 
                #region Properties
650
 
 
651
 
                public Label BodyEnd {
652
 
                        get {
653
 
                                return iterator_body_end;
654
 
                        }
655
 
                }
656
 
 
657
 
                public LocalBuilder CurrentPC
658
 
                {
659
 
                        get {
660
 
                                return current_pc;
661
 
                        }
662
 
                }
663
 
 
664
 
                public LocalBuilder SkipFinally {
665
 
                        get {
666
 
                                return skip_finally;
667
 
                        }
668
 
                }
669
 
 
670
 
                public override AnonymousMethodStorey Storey {
671
 
                        get {
672
 
                                return storey;
673
 
                        }
674
 
                }
675
 
 
676
 
                #endregion
677
 
 
678
 
                public int AddResumePoint (ResumableStatement stmt)
679
 
                {
680
 
                        if (resume_points == null)
681
 
                                resume_points = new List<ResumableStatement> ();
682
 
 
683
 
                        resume_points.Add (stmt);
684
 
                        return resume_points.Count;
685
 
                }
686
 
 
687
 
                public override Expression CreateExpressionTree (ResolveContext ec)
688
 
                {
689
 
                        throw new NotSupportedException ("ET");
690
 
                }
691
 
 
692
 
                protected virtual BlockContext CreateBlockContext (ResolveContext rc)
693
 
                {
694
 
                        var ctx = new BlockContext (rc, block, ((BlockContext) rc).ReturnType);
695
 
                        ctx.CurrentAnonymousMethod = this;
696
 
                        return ctx;
697
 
                }
698
 
 
699
 
                protected override Expression DoResolve (ResolveContext ec)
700
 
                {
701
 
                        var ctx = CreateBlockContext (ec);
702
 
 
703
 
                        Block.Resolve (ctx);
704
 
 
705
 
                        //
706
 
                        // Explicit return is required for Task<T> state machine
707
 
                        //
708
 
                        var task_storey = storey as AsyncTaskStorey;
709
 
                        if (task_storey == null || (task_storey.ReturnType != null && !task_storey.ReturnType.IsGenericTask))
710
 
                                ctx.CurrentBranching.CurrentUsageVector.Goto ();
711
 
 
712
 
                        ctx.EndFlowBranching ();
713
 
 
714
 
                        if (!ec.IsInProbingMode) {
715
 
                                var move_next = new StateMachineMethod (storey, this, new TypeExpression (ReturnType, loc), Modifiers.PUBLIC, new MemberName ("MoveNext", loc));
716
 
                                move_next.Block.AddStatement (new MoveNextBodyStatement (this));
717
 
                                storey.AddEntryMethod (move_next);
718
 
                        }
719
 
 
720
 
                        eclass = ExprClass.Value;
721
 
                        return this;
722
 
                }
723
 
 
724
 
                public override void Emit (EmitContext ec)
725
 
                {
726
 
                        //
727
 
                        // Load state machine instance
728
 
                        //
729
 
                        storey.Instance.Emit (ec);
730
 
                }
731
 
 
732
 
                void EmitMoveNext_NoResumePoints (EmitContext ec)
733
 
                {
734
 
                        ec.EmitThis ();
735
 
                        ec.Emit (OpCodes.Ldfld, storey.PC.Spec);
736
 
 
737
 
                        ec.EmitThis ();
738
 
                        ec.EmitInt ((int) IteratorStorey.State.After);
739
 
                        ec.Emit (OpCodes.Stfld, storey.PC.Spec);
740
 
 
741
 
                        // We only care if the PC is zero (start executing) or non-zero (don't do anything)
742
 
                        ec.Emit (OpCodes.Brtrue, move_next_error);
743
 
 
744
 
                        iterator_body_end = ec.DefineLabel ();
745
 
 
746
 
                        block.EmitEmbedded (ec);
747
 
 
748
 
                        ec.MarkLabel (iterator_body_end);
749
 
 
750
 
                        EmitMoveNextEpilogue (ec);
751
 
 
752
 
                        ec.MarkLabel (move_next_error);
753
 
 
754
 
                        if (ReturnType.Kind != MemberKind.Void) {
755
 
                                ec.EmitInt (0);
756
 
                                ec.Emit (OpCodes.Ret);
757
 
                        }
758
 
                }
759
 
 
760
 
                void EmitMoveNext (EmitContext ec)
761
 
                {
762
 
                        move_next_ok = ec.DefineLabel ();
763
 
                        move_next_error = ec.DefineLabel ();
764
 
 
765
 
                        if (resume_points == null) {
766
 
                                EmitMoveNext_NoResumePoints (ec);
767
 
                                return;
768
 
                        }
769
 
                        
770
 
                        current_pc = ec.GetTemporaryLocal (ec.BuiltinTypes.UInt);
771
 
                        ec.EmitThis ();
772
 
                        ec.Emit (OpCodes.Ldfld, storey.PC.Spec);
773
 
                        ec.Emit (OpCodes.Stloc, current_pc);
774
 
 
775
 
                        // We're actually in state 'running', but this is as good a PC value as any if there's an abnormal exit
776
 
                        ec.EmitThis ();
777
 
                        ec.EmitInt ((int) IteratorStorey.State.After);
778
 
                        ec.Emit (OpCodes.Stfld, storey.PC.Spec);
779
 
 
780
 
                        Label[] labels = new Label[1 + resume_points.Count];
781
 
                        labels[0] = ec.DefineLabel ();
782
 
 
783
 
                        bool need_skip_finally = false;
784
 
                        for (int i = 0; i < resume_points.Count; ++i) {
785
 
                                ResumableStatement s = resume_points[i];
786
 
                                need_skip_finally |= s is ExceptionStatement;
787
 
                                labels[i + 1] = s.PrepareForEmit (ec);
788
 
                        }
789
 
 
790
 
                        if (need_skip_finally) {
791
 
                                skip_finally = ec.GetTemporaryLocal (ec.BuiltinTypes.Bool);
792
 
                                ec.EmitInt (0);
793
 
                                ec.Emit (OpCodes.Stloc, skip_finally);
794
 
                        }
795
 
 
796
 
                        var async_init = this as AsyncInitializer;
797
 
                        if (async_init != null)
798
 
                                ec.BeginExceptionBlock ();
799
 
 
800
 
                        ec.Emit (OpCodes.Ldloc, current_pc);
801
 
                        ec.Emit (OpCodes.Switch, labels);
802
 
 
803
 
                        ec.Emit (async_init != null ? OpCodes.Leave : OpCodes.Br, move_next_error);
804
 
 
805
 
                        ec.MarkLabel (labels[0]);
806
 
 
807
 
                        iterator_body_end = ec.DefineLabel ();
808
 
 
809
 
                        block.EmitEmbedded (ec);
810
 
 
811
 
                        ec.MarkLabel (iterator_body_end);
812
 
 
813
 
                        if (async_init != null) {
814
 
                                var catch_value = LocalVariable.CreateCompilerGenerated (ec.Module.Compiler.BuiltinTypes.Exception, block, Location);
815
 
 
816
 
                                ec.BeginCatchBlock (catch_value.Type);
817
 
                                catch_value.EmitAssign (ec);
818
 
 
819
 
                                ec.EmitThis ();
820
 
                                ec.EmitInt ((int) IteratorStorey.State.After);
821
 
                                ec.Emit (OpCodes.Stfld, storey.PC.Spec);
822
 
 
823
 
                                ((AsyncTaskStorey) async_init.Storey).EmitSetException (ec, new LocalVariableReference (catch_value, Location));
824
 
 
825
 
                                ec.Emit (OpCodes.Leave, move_next_ok);
826
 
                                ec.EndExceptionBlock ();
827
 
                        }
828
 
 
829
 
                        ec.Mark (Block.Original.EndLocation);
830
 
                        ec.EmitThis ();
831
 
                        ec.EmitInt ((int) IteratorStorey.State.After);
832
 
                        ec.Emit (OpCodes.Stfld, storey.PC.Spec);
833
 
 
834
 
                        EmitMoveNextEpilogue (ec);
835
 
 
836
 
                        ec.MarkLabel (move_next_error);
837
 
                        
838
 
                        if (ReturnType.Kind != MemberKind.Void) {
839
 
                                ec.EmitInt (0);
840
 
                                ec.Emit (OpCodes.Ret);
841
 
                        }
842
 
 
843
 
                        ec.MarkLabel (move_next_ok);
844
 
 
845
 
                        if (ReturnType.Kind != MemberKind.Void) {
846
 
                                ec.EmitInt (1);
847
 
                                ec.Emit (OpCodes.Ret);
848
 
                        }
849
 
                }
850
 
 
851
 
                protected virtual void EmitMoveNextEpilogue (EmitContext ec)
852
 
                {
853
 
                }
854
 
 
855
 
                public void EmitLeave (EmitContext ec, bool unwind_protect)
856
 
                {
857
 
                        // Return ok
858
 
                        ec.Emit (unwind_protect ? OpCodes.Leave : OpCodes.Br, move_next_ok);
859
 
                }
860
 
 
861
 
                //
862
 
                // Called back from YieldStatement
863
 
                //
864
 
                public virtual void InjectYield (EmitContext ec, Expression expr, int resume_pc, bool unwind_protect, Label resume_point)
865
 
                {
866
 
                        //
867
 
                        // Guard against being disposed meantime
868
 
                        //
869
 
                        Label disposed = ec.DefineLabel ();
870
 
                        var iterator = storey as IteratorStorey;
871
 
                        if (iterator != null) {
872
 
                                ec.EmitThis ();
873
 
                                ec.Emit (OpCodes.Ldfld, iterator.DisposingField.Spec);
874
 
                                ec.Emit (OpCodes.Brtrue_S, disposed);
875
 
                        }
876
 
 
877
 
                        //
878
 
                        // store resume program-counter
879
 
                        //
880
 
                        ec.EmitThis ();
881
 
                        ec.EmitInt (resume_pc);
882
 
                        ec.Emit (OpCodes.Stfld, storey.PC.Spec);
883
 
 
884
 
                        if (iterator != null) {
885
 
                                ec.MarkLabel (disposed);
886
 
                        }
887
 
 
888
 
                        // mark finally blocks as disabled
889
 
                        if (unwind_protect && skip_finally != null) {
890
 
                                ec.EmitInt (1);
891
 
                                ec.Emit (OpCodes.Stloc, skip_finally);
892
 
                        }
893
 
                }
894
 
 
895
 
                public void SetStateMachine (StateMachine stateMachine)
896
 
                {
897
 
                        this.storey = stateMachine;
898
 
                }
899
 
        }
900
 
 
901
 
        //
902
 
        // Iterators are implemented as state machine blocks
903
 
        //
904
 
        public class Iterator : StateMachineInitializer
905
 
        {
906
 
                sealed class TryFinallyBlockProxyStatement : Statement
907
 
                {
908
 
                        TryFinallyBlock block;
909
 
                        Iterator iterator;
910
 
 
911
 
                        public TryFinallyBlockProxyStatement (Iterator iterator, TryFinallyBlock block)
912
 
                        {
913
 
                                this.iterator = iterator;
914
 
                                this.block = block;
915
 
                        }
916
 
 
917
 
                        protected override void CloneTo (CloneContext clonectx, Statement target)
918
 
                        {
919
 
                                throw new NotSupportedException ();
920
 
                        }
921
 
 
922
 
                        protected override void DoEmit (EmitContext ec)
923
 
                        {
924
 
                                //
925
 
                                // Restore redirection for any captured variables
926
 
                                //
927
 
                                ec.CurrentAnonymousMethod = iterator;
928
 
 
929
 
                                using (ec.With (BuilderContext.Options.OmitDebugInfo, !ec.HasMethodSymbolBuilder)) {
930
 
                                        block.EmitFinallyBody (ec);
931
 
                                }
932
 
                        }
933
 
                }
934
 
 
935
 
                public readonly IMethodData OriginalMethod;
936
 
                public readonly bool IsEnumerable;
937
 
                public readonly TypeSpec OriginalIteratorType;
938
 
                int finally_hosts_counter;
939
 
 
940
 
                public Iterator (ParametersBlock block, IMethodData method, TypeDefinition host, TypeSpec iterator_type, bool is_enumerable)
941
 
                        : base (block, host, host.Compiler.BuiltinTypes.Bool)
942
 
                {
943
 
                        this.OriginalMethod = method;
944
 
                        this.OriginalIteratorType = iterator_type;
945
 
                        this.IsEnumerable = is_enumerable;
946
 
                        this.type = method.ReturnType;
947
 
                }
948
 
 
949
 
                #region Properties
950
 
 
951
 
                public ToplevelBlock Container {
952
 
                        get { return OriginalMethod.Block; }
953
 
                }
954
 
 
955
 
                public override string ContainerType {
956
 
                        get { return "iterator"; }
957
 
                }
958
 
 
959
 
                public override bool IsIterator {
960
 
                        get { return true; }
961
 
                }
962
 
 
963
 
                #endregion
964
 
 
965
 
                public Method CreateFinallyHost (TryFinallyBlock block)
966
 
                {
967
 
                        var method = new Method (storey, new TypeExpression (storey.Compiler.BuiltinTypes.Void, loc),
968
 
                                Modifiers.COMPILER_GENERATED, new MemberName (CompilerGeneratedContainer.MakeName (null, null, "Finally", finally_hosts_counter++), loc),
969
 
                                ParametersCompiled.EmptyReadOnlyParameters, null);
970
 
 
971
 
                        method.Block = new ToplevelBlock (method.Compiler, method.ParameterInfo, loc);
972
 
                        method.Block.IsCompilerGenerated = true;
973
 
                        method.Block.AddStatement (new TryFinallyBlockProxyStatement (this, block));
974
 
 
975
 
                        // Cannot it add to storey because it'd be emitted before nested
976
 
                        // anonoymous methods which could capture shared variable
977
 
 
978
 
                        return method;
979
 
                }
980
 
 
981
 
                public void EmitYieldBreak (EmitContext ec, bool unwind_protect)
982
 
                {
983
 
                        ec.Emit (unwind_protect ? OpCodes.Leave : OpCodes.Br, move_next_error);
984
 
                }
985
 
 
986
 
                public override string GetSignatureForError ()
987
 
                {
988
 
                        return OriginalMethod.GetSignatureForError ();
989
 
                }
990
 
 
991
 
                public override void Emit (EmitContext ec)
992
 
                {
993
 
                        //
994
 
                        // Load Iterator storey instance
995
 
                        //
996
 
                        storey.Instance.Emit (ec);
997
 
 
998
 
                        //
999
 
                        // Initialize iterator PC when it's unitialized
1000
 
                        //
1001
 
                        if (IsEnumerable) {
1002
 
                                ec.Emit (OpCodes.Dup);
1003
 
                                ec.EmitInt ((int)IteratorStorey.State.Uninitialized);
1004
 
 
1005
 
                                var field = storey.PC.Spec;
1006
 
                                if (storey.MemberName.IsGeneric) {
1007
 
                                        field = MemberCache.GetMember (Storey.Instance.Type, field);
1008
 
                                }
1009
 
 
1010
 
                                ec.Emit (OpCodes.Stfld, field);
1011
 
                        }
1012
 
                }
1013
 
 
1014
 
                public void EmitDispose (EmitContext ec)
1015
 
                {
1016
 
                        if (resume_points == null)
1017
 
                                return;
1018
 
 
1019
 
                        Label end = ec.DefineLabel ();
1020
 
 
1021
 
                        Label[] labels = null;
1022
 
                        for (int i = 0; i < resume_points.Count; ++i) {
1023
 
                                ResumableStatement s = resume_points[i];
1024
 
                                Label ret = s.PrepareForDispose (ec, end);
1025
 
                                if (ret.Equals (end) && labels == null)
1026
 
                                        continue;
1027
 
                                if (labels == null) {
1028
 
                                        labels = new Label[resume_points.Count + 1];
1029
 
                                        for (int j = 0; j <= i; ++j)
1030
 
                                                labels[j] = end;
1031
 
                                }
1032
 
 
1033
 
                                labels[i + 1] = ret;
1034
 
                        }
1035
 
 
1036
 
                        if (labels != null) {
1037
 
                                current_pc = ec.GetTemporaryLocal (ec.BuiltinTypes.UInt);
1038
 
                                ec.EmitThis ();
1039
 
                                ec.Emit (OpCodes.Ldfld, storey.PC.Spec);
1040
 
                                ec.Emit (OpCodes.Stloc, current_pc);
1041
 
                        }
1042
 
 
1043
 
                        ec.EmitThis ();
1044
 
                        ec.EmitInt (1);
1045
 
                        ec.Emit (OpCodes.Stfld, ((IteratorStorey) storey).DisposingField.Spec);
1046
 
 
1047
 
                        ec.EmitThis ();
1048
 
                        ec.EmitInt ((int) IteratorStorey.State.After);
1049
 
                        ec.Emit (OpCodes.Stfld, storey.PC.Spec);
1050
 
 
1051
 
                        if (labels != null) {
1052
 
                                //SymbolWriter.StartIteratorDispatcher (ec.ig);
1053
 
                                ec.Emit (OpCodes.Ldloc, current_pc);
1054
 
                                ec.Emit (OpCodes.Switch, labels);
1055
 
                                //SymbolWriter.EndIteratorDispatcher (ec.ig);
1056
 
 
1057
 
                                foreach (ResumableStatement s in resume_points)
1058
 
                                        s.EmitForDispose (ec, current_pc, end, true);
1059
 
                        }
1060
 
 
1061
 
                        ec.MarkLabel (end);
1062
 
                }
1063
 
 
1064
 
                public override void EmitStatement (EmitContext ec)
1065
 
                {
1066
 
                        throw new NotImplementedException ();
1067
 
                }
1068
 
 
1069
 
                public override void InjectYield (EmitContext ec, Expression expr, int resume_pc, bool unwind_protect, Label resume_point)
1070
 
                {
1071
 
                        // Store the new value into current
1072
 
                        var fe = new FieldExpr (((IteratorStorey) storey).CurrentField, loc);
1073
 
                        fe.InstanceExpression = new CompilerGeneratedThis (storey.CurrentType, loc);
1074
 
                        fe.EmitAssign (ec, expr, false, false);
1075
 
 
1076
 
                        base.InjectYield (ec, expr, resume_pc, unwind_protect, resume_point);
1077
 
 
1078
 
                        EmitLeave (ec, unwind_protect);
1079
 
 
1080
 
                        ec.MarkLabel (resume_point);
1081
 
                }
1082
 
 
1083
 
                protected override BlockContext CreateBlockContext (ResolveContext rc)
1084
 
                {
1085
 
                        var bc = base.CreateBlockContext (rc);
1086
 
                        bc.StartFlowBranching (this, rc.CurrentBranching);
1087
 
                        return bc;
1088
 
                }
1089
 
 
1090
 
                public static void CreateIterator (IMethodData method, TypeDefinition parent, Modifiers modifiers)
1091
 
                {
1092
 
                        bool is_enumerable;
1093
 
                        TypeSpec iterator_type;
1094
 
 
1095
 
                        TypeSpec ret = method.ReturnType;
1096
 
                        if (ret == null)
1097
 
                                return;
1098
 
 
1099
 
                        if (!CheckType (ret, parent, out iterator_type, out is_enumerable)) {
1100
 
                                parent.Compiler.Report.Error (1624, method.Location,
1101
 
                                              "The body of `{0}' cannot be an iterator block " +
1102
 
                                              "because `{1}' is not an iterator interface type",
1103
 
                                              method.GetSignatureForError (),
1104
 
                                              TypeManager.CSharpName (ret));
1105
 
                                return;
1106
 
                        }
1107
 
 
1108
 
                        ParametersCompiled parameters = method.ParameterInfo;
1109
 
                        for (int i = 0; i < parameters.Count; i++) {
1110
 
                                Parameter p = parameters [i];
1111
 
                                Parameter.Modifier mod = p.ModFlags;
1112
 
                                if ((mod & Parameter.Modifier.RefOutMask) != 0) {
1113
 
                                        parent.Compiler.Report.Error (1623, p.Location,
1114
 
                                                "Iterators cannot have ref or out parameters");
1115
 
                                        return;
1116
 
                                }
1117
 
 
1118
 
                                if (p is ArglistParameter) {
1119
 
                                        parent.Compiler.Report.Error (1636, method.Location,
1120
 
                                                "__arglist is not allowed in parameter list of iterators");
1121
 
                                        return;
1122
 
                                }
1123
 
 
1124
 
                                if (parameters.Types [i].IsPointer) {
1125
 
                                        parent.Compiler.Report.Error (1637, p.Location,
1126
 
                                                "Iterators cannot have unsafe parameters or yield types");
1127
 
                                        return;
1128
 
                                }
1129
 
                        }
1130
 
 
1131
 
                        if ((modifiers & Modifiers.UNSAFE) != 0) {
1132
 
                                parent.Compiler.Report.Error (1629, method.Location, "Unsafe code may not appear in iterators");
1133
 
                        }
1134
 
 
1135
 
                        method.Block = method.Block.ConvertToIterator (method, parent, iterator_type, is_enumerable);
1136
 
                }
1137
 
 
1138
 
                static bool CheckType (TypeSpec ret, TypeContainer parent, out TypeSpec original_iterator_type, out bool is_enumerable)
1139
 
                {
1140
 
                        original_iterator_type = null;
1141
 
                        is_enumerable = false;
1142
 
 
1143
 
                        if (ret.BuiltinType == BuiltinTypeSpec.Type.IEnumerable) {
1144
 
                                original_iterator_type = parent.Compiler.BuiltinTypes.Object;
1145
 
                                is_enumerable = true;
1146
 
                                return true;
1147
 
                        }
1148
 
                        if (ret.BuiltinType == BuiltinTypeSpec.Type.IEnumerator) {
1149
 
                                original_iterator_type = parent.Compiler.BuiltinTypes.Object;
1150
 
                                is_enumerable = false;
1151
 
                                return true;
1152
 
                        }
1153
 
 
1154
 
                        InflatedTypeSpec inflated = ret as InflatedTypeSpec;
1155
 
                        if (inflated == null)
1156
 
                                return false;
1157
 
 
1158
 
                        var member_definition = inflated.MemberDefinition;
1159
 
                        PredefinedType ptype = parent.Module.PredefinedTypes.IEnumerableGeneric;
1160
 
 
1161
 
                        if (ptype.Define () && ptype.TypeSpec.MemberDefinition == member_definition) {
1162
 
                                original_iterator_type = inflated.TypeArguments[0];
1163
 
                                is_enumerable = true;
1164
 
                                return true;
1165
 
                        }
1166
 
 
1167
 
                        ptype = parent.Module.PredefinedTypes.IEnumeratorGeneric;
1168
 
                        if (ptype.Define () && ptype.TypeSpec.MemberDefinition == member_definition) {
1169
 
                                original_iterator_type = inflated.TypeArguments[0];
1170
 
                                is_enumerable = false;
1171
 
                                return true;
1172
 
                        }
1173
 
 
1174
 
                        return false;
1175
 
                }
1176
 
        }
1177
 
}
1178